corenote.c revision d2a70789f056fc6c9ce3ab047b52126d80b0e3da
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
* Copyright (c) 2013, Joyent, Inc. All rights reserved.
*/
/*
* String conversion routines the system structs found in
* Solaris core file note sections. These items are not
* ELF constructs. However, elfdump contains code for decoding
* them, and therefore requires formatting support.
*/
#include <stdio.h>
#include <procfs.h>
#include <sys/secflags.h>
#include <string.h>
#include <_conv.h>
#include <corenote_msg.h>
const char *
{
0, 0,
};
#if NT_NUM != NT_SECFLAGS
#error "NT_NUM has grown. Update core note types[]"
#endif
static const conv_ds_msg_t ds_types = {
inv_buf));
}
const char *
{
static const Msg types_0_22[] = {
};
static const conv_ds_msg_t ds_types_0_22 = {
CONV_DS_MSG_INIT(0, types_0_22) };
static const Msg types_2000_2011[] = {
};
static const conv_ds_msg_t ds_types_2000_2011 = {
static const Msg types_2014_2023[] = {
};
static const conv_ds_msg_t ds_types_2014_2023 = {
inv_buf));
}
const char *
{
};
static const conv_ds_msg_t ds_sigarr = {
inv_buf));
}
const char *
{
};
static const conv_ds_msg_t ds_fltarr = {
inv_buf));
}
const char *
{
};
static const conv_ds_msg_t ds_sysnumarr = {
int use_num = 0;
/*
* Range check, and handle the unused values in the middle
* of the range. Although the missing values have strings,
* we still prefer to format them, because those strings are
* decimal, and the default behavior, unless the CONV_FMT_DECIMAL
* flag is set, is to display such things in hex.
*/
switch (sysnum) {
case 0:
case 2:
case 7:
case 8:
case 11:
case 22:
case 30:
case 41:
case 48:
case 76:
case 87:
case 101:
case 102:
case 123:
case 124:
case 125:
case 126:
case 143:
case 147:
case 154:
case 169:
case 224:
use_num = 1;
break;
default:
break;
}
if (use_num)
inv_buf));
}
const char *
{
};
static const conv_ds_msg_t ds_errarr_1_74 = {
};
static const conv_ds_msg_t ds_errarr_77_99 = {
};
static const conv_ds_msg_t ds_errarr_120_134 = {
};
static const conv_ds_msg_t ds_errarr_143_151 = {
inv_buf));
}
const char *
{
};
static const conv_ds_msg_t ds_models = {
inv_buf));
}
const char *
{
};
static const conv_ds_msg_t ds_why_arr = {
inv_buf));
}
const char *
{
/*
* The meaning of pr_what depends on the corresponding
* value of pr_why, as discussed in the proc(4) manpage.
*/
switch (why) {
case PR_SIGNALLED:
case PR_JOBCONTROL:
case PR_SYSENTRY:
case PR_SYSEXIT:
case PR_FAULTED:
};
}
/*
* Return the name of the general purpose register indexed by
*/
const char *
{
};
static const conv_ds_msg_t ds_sparc_gen_reg = {
CONV_DS_MSG_INIT(0, sparc_gen_reg) };
};
static const conv_ds_msg_t ds_sparc_32_37_reg = {
};
static const conv_ds_msg_t ds_sparcv9_32_37_reg = {
};
static const conv_ds_msg_t ds_amd64_reg = {
CONV_DS_MSG_INIT(0, amd64_reg) };
};
static const conv_ds_msg_t ds_i86_reg = {
CONV_DS_MSG_INIT(0, i86_reg) };
};
static const conv_ds_t *ds_sparcv9[] = {
};
switch (mach) {
case EM_386:
break;
case EM_AMD64:
break;
case EM_SPARC:
case EM_SPARC32PLUS:
break;
case EM_SPARCV9:
ds = ds_sparcv9;
break;
default:
}
inv_buf));
}
const char *
{
};
inv_buf));
}
const char *
{
const char *fmt;
/*
* in that they are negative values. The libconv code is all
* built around the Word type, which is unsigned. Rather than
* modify libconv for this one case, we simply handle
* these constants differently that the usual approach,
* and stay away from conv_invalid_val() and conv_map_ds().
*/
switch (priv) {
case PRIV_ALL:
return (MSG_ORIG(MSG_PRIV_ALL));
case PRIV_MULTIPLE:
return (MSG_ORIG(MSG_PRIV_MULTIPLE));
case PRIV_NONE:
return (MSG_ORIG(MSG_PRIV_NONE));
case PRIV_ALLZONE:
return (MSG_ORIG(MSG_PRIV_ALLZONE));
case PRIV_GLOBAL:
return (MSG_ORIG(MSG_PRIV_GLOBAL));
}
}
const char *
{
const char *fmt;
/*
* in that they are negative values. The libconv code is all
* built around the Word type, which is unsigned. Rather than
* modify libconv for this one case, we simply handle
* these constants differently that the usual approach,
* and stay away from conv_invalid_val() and conv_map_ds().
*/
switch (id) {
case PS_NONE:
return (MSG_ORIG(MSG_PS_NONE));
case PS_QUERY:
return (MSG_ORIG(MSG_PS_QUERY));
case PS_MYID:
return (MSG_ORIG(MSG_PS_MYID));
case PS_SOFT:
return (MSG_ORIG(MSG_PS_SOFT));
case PS_HARD:
return (MSG_ORIG(MSG_PS_HARD));
case PS_QUERY_TYPE:
return (MSG_ORIG(MSG_PS_QUERY_TYPE));
}
}
/*
* Return a string describing the si_code field of
* the siginfo_t struct.
*
* The meaning of si_code is dependent on both the target
* machine (mach) as well as the signal (sig).
*/
const char *
{
/* Values of si_code for user generated signals */
};
static const conv_ds_msg_t ds_msg_user_arr = {
CONV_DS_MSG_INIT(0, user_arr) };
static const conv_ds_t *ds_user_arr[] = {
/*
* Architecture dependent system generated signals. All
* versions of Solaris use the same set of these values.
*/
};
static const conv_ds_msg_t ds_msg_trap_arr = {
static const conv_ds_t *ds_trap_arr[] = {
};
static const conv_ds_msg_t ds_msg_cld_arr = {
static const conv_ds_t *ds_cld_arr[] = {
};
static const conv_ds_msg_t ds_msg_poll_arr = {
static const conv_ds_t *ds_poll_arr[] = {
/*
* Architecture dependent system generated signals.
* These items (ILL, EMT, FPE, SEGV, BUS) are platform
* dependent. Some architectures have extra codes.
* The same name may have a different integer value.
* Multiple arrays are used when they differ, and one
* array when all the architectures agree.
*/
/* ILL */
};
static const conv_ds_msg_t ds_msg_ill_arr = {
static const conv_ds_t *ds_ill_arr[] = {
/* EMT */
};
static const conv_ds_msg_t ds_msg_emt_arr_sparc = {
static const conv_ds_t *ds_emt_arr_sparc[] = {
};
static const conv_ds_msg_t ds_msg_emt_arr_x86 = {
static const conv_ds_t *ds_emt_arr_x86[] = {
/* FPE */
};
static const conv_ds_msg_t ds_msg_fpe_arr_sparc = {
static const conv_ds_t *ds_fpe_arr_sparc[] = {
};
static const conv_ds_msg_t ds_msg_fpe_arr_x86 = {
static const conv_ds_t *ds_fpe_arr_x86[] = {
/* SEGV */
};
static const conv_ds_msg_t ds_msg_segv_arr = {
static const conv_ds_t *ds_segv_arr[] = {
/* BUS */
};
static const conv_ds_msg_t ds_msg_bus_arr = {
static const conv_ds_t *ds_bus_arr[] = {
/* Handle the si_code values that do not depend on the signal */
switch (si_code) {
case SI_NOINFO:
return (MSG_ORIG(MSG_SI_NOINFO));
case SI_DTRACE:
return (MSG_ORIG(MSG_SI_DTRACE));
case SI_RCTL:
return (MSG_ORIG(MSG_SI_RCTL));
default:
/* User generated signal codes are <= 0 */
if (si_code <= 0) {
/*
* If no signal was delivered, and si_code is
* 0, return "0" rather than "SI_USER".
*/
return (MSG_ORIG(MSG_GBL_ZERO));
const char *fmt;
}
}
}
/*
* If we didn't return above, then this is a
* system generated signal, and the meaning of si_code
* depends on the signal that was delivered, and possibly
* on the target architecture.
*/
switch (mach) {
case EM_386:
case EM_AMD64:
break;
case EM_SPARC:
case EM_SPARC32PLUS:
case EM_SPARCV9:
break;
default:
break;
}
switch (sig) {
case SIGTRAP:
case SIGCLD:
case SIGPOLL:
case SIGILL:
case SIGEMT:
switch (arch) {
case ARCH_SPARC:
case ARCH_X86:
}
break;
case SIGFPE:
switch (arch) {
case ARCH_SPARC:
case ARCH_X86:
}
break;
case SIGSEGV:
case SIGBUS:
}
/* If not recognized, format as a number */
}
#define AUXAFFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_auxv_af_buf_t is large enough:
*
* AUXAFFLGSZ is the real minimum size of the buffer required by
* conv_cnote_auxv_af(). However, Conv_cnote_auxv_af_buf_t
* uses CONV_CNOTE_AUXV_AF_BUFSIZE to set the buffer size. We do
* things this way because the definition of AUXAFFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE AUXAFFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_AUXV_AF_BUFSIZE does not match AUXAFFLGSZ"
#endif
const char *
{
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_auxv_af_buf->buf);
}
#define CCFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_cc_content_buf_t is large enough:
*
* CCFLGSZ is the real minimum size of the buffer required by
* conv_cnote_cc_content(). However, Conv_cnote_cc_content_buf_t
* uses CONV_CNOTE_CC_CONTENT_BUFSIZE to set the buffer size. We do
* things this way because the definition of CCFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE CCFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_CC_CONTENT_BUFSIZE does not match CCFLGSZ"
#endif
const char *
{
/*
* Note: core_content_t is a 64-bit integer value, but our
* conv_expn_field() logic is all built around 32-bit
* Word values. This will probably need changing someday,
* but for now, we make do with the 32-bit engine. This works
* because the number of bits actually assigned in
* 32-bits.
*
* The downside is that any bits set in the upper half of
* the flags will be ignored. At the time of this writing,
* that can only occur via core file corruption, which presumably
* would be evident in other ways.
*/
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_cc_content_buf->buf);
}
#define PRFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_pr_flags_buf_t is large enough:
*
* PRFLGSZ is the real minimum size of the buffer required by
* conv_cnote_pr_flags(). However, Conv_cnote_pr_flags_buf_t
* uses CONV_CNOTE_PR_FLAGS_BUFSIZE to set the buffer size. We do
* things this way because the definition of PRFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE PRFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_PR_FLAGS_BUFSIZE does not match PRFLGSZ"
#endif
const char *
{
{ PR_ISTOP, MSG_PR_FLAGS_ISTOP },
{ PR_DSTOP, MSG_PR_FLAGS_DSTOP },
{ PR_STEP, MSG_PR_FLAGS_STEP },
{ PR_ASLEEP, MSG_PR_FLAGS_ASLEEP },
{ PR_ASLWP, MSG_PR_FLAGS_ASLWP },
{ PR_AGENT, MSG_PR_FLAGS_AGENT },
{ PR_DETACH, MSG_PR_FLAGS_DETACH },
{ PR_DAEMON, MSG_PR_FLAGS_DAEMON },
{ PR_IDLE, MSG_PR_FLAGS_IDLE },
{ PR_ISSYS, MSG_PR_FLAGS_ISSYS },
{ PR_VFORKP, MSG_PR_FLAGS_VFORKP },
{ PR_ORPHAN, MSG_PR_FLAGS_ORPHAN },
{ PR_FORK, MSG_PR_FLAGS_FORK },
{ PR_RLC, MSG_PR_FLAGS_RLC },
{ PR_KLC, MSG_PR_FLAGS_KLC },
{ PR_ASYNC, MSG_PR_FLAGS_ASYNC },
{ PR_MSACCT, MSG_PR_FLAGS_MSACCT },
{ PR_BPTADJ, MSG_PR_FLAGS_BPTADJ },
{ PR_PTRACE, MSG_PR_FLAGS_PTRACE },
{ PR_MSFORK, MSG_PR_FLAGS_MSFORK },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_pr_flags_buf->buf);
}
#define OLDPRFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_old_pr_flags_buf_t is large enough:
*
* OLDPRFLGSZ is the real minimum size of the buffer required by
* conv_cnote_old_pr_flags(). However, Conv_cnote_old_pr_flags_buf_t
* uses CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE to set the buffer size. We do
* things this way because the definition of OLDPRFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE OLDPRFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE does not match OLDPRFLGSZ"
#endif
const char *
{
/*
* <sys/old_procfs.h> defines names for many of these flags
* values. To avoid confusion, we don't include <sys/old_procfs.h>,
* and specify the values directly.
*/
{ 0x0001, MSG_PR_FLAGS_STOPPED },
{ 0x0002, MSG_PR_FLAGS_ISTOP },
{ 0x0004, MSG_PR_FLAGS_DSTOP },
{ 0x0008, MSG_PR_FLAGS_ASLEEP },
{ 0x0010, MSG_PR_FLAGS_FORK },
{ 0x0020, MSG_PR_FLAGS_RLC },
{ 0x0040, MSG_PR_FLAGS_PTRACE },
{ 0x0080, MSG_PR_FLAGS_PCINVAL },
{ 0x0100, MSG_PR_FLAGS_ISSYS },
{ 0x0200, MSG_PR_FLAGS_STEP },
{ 0x0400, MSG_PR_FLAGS_KLC },
{ 0x0800, MSG_PR_FLAGS_ASYNC },
{ 0x1000, MSG_PR_FLAGS_PCOMPAT },
{ 0x2000, MSG_PR_FLAGS_MSACCT },
{ 0x4000, MSG_PR_FLAGS_BPTADJ },
{ 0x8000, MSG_PR_FLAGS_ASLWP },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_old_pr_flags_buf->buf);
}
#define PROCFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_proc_flag_buf_t is large enough:
*
* PROCFLGSZ is the real minimum size of the buffer required by
* conv_cnote_proc_flag(). However, Conv_cnote_proc_flag_buf_t
* uses CONV_CNOTE_PROC_FLAG_BUFSIZE to set the buffer size. We do
* things this way because the definition of PROCFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE PROCFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_PROC_FLAG_BUFSIZE does not match PROCFLGSZ"
#endif
const char *
{
/*
* Most of the proc flags are implementation dependant, and can
* change between releases. As such, we do not attempt to translate
* them to symbolic form, but simply report them in hex form.
* However, SMSACCT and SSYS are special, and their bit values
* are maintained between releases so they can be used in the
* psinfo_t.p_flag field. We therefore translate these items.
*
*
* it redefines 'struct list', which we have defined in sgs.h. As
* SMSACCT and SSYS are stable public values, we simply use
* their numeric value.
*/
{ 0x00000001, MSG_PROC_FLAG_SSYS },
{ 0x02000000, MSG_PROC_FLAG_SMSACCT },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_proc_flag_buf->buf);
}
#define SAFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_sa_flags_buf_t is large enough:
*
* SAFLGSZ is the real minimum size of the buffer required by
* conv_cnote_sa_flags(). However, Conv_cnote_sa_flags_buf_t
* uses CONV_CNOTE_SA_FLAGS_BUFSIZE to set the buffer size. We do
* things this way because the definition of SAFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE SAFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_SA_FLAGS_BUFSIZE does not match SAFLGSZ"
#endif
const char *
{
{ SA_ONSTACK, MSG_SA_ONSTACK },
{ SA_RESETHAND, MSG_SA_RESETHAND },
{ SA_RESTART, MSG_SA_RESTART },
{ SA_SIGINFO, MSG_SA_SIGINFO },
{ SA_NODEFER, MSG_SA_NODEFER },
{ SA_NOCLDWAIT, MSG_SA_NOCLDWAIT },
{ SA_NOCLDSTOP, MSG_SA_NOCLDSTOP },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_sa_flags_buf->buf);
}
#define SSFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_ss_flags_buf_t is large enough:
*
* SSFLGSZ is the real minimum size of the buffer required by
* conv_cnote_ss_flags(). However, Conv_cnote_ss_flags_buf_t
* uses CONV_CNOTE_SS_FLAGS_BUFSIZE to set the buffer size. We do
* things this way because the definition of SSFLGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE SSFLGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_SS_FLAGS_BUFSIZE does not match SSFLGSZ"
#endif
const char *
{
{ SS_ONSTACK, MSG_SS_ONSTACK },
{ SS_DISABLE, MSG_SS_DISABLE },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)cnote_ss_flags_buf->buf);
}
/*
* Solaris has a variety of types that use bitmasks to represent
* sets of things like signals (sigset_t), faults (fltset_t), and
* system calls (sysset_t). These types use arrays of unsigned 32-bit
* integers to represent the set. These are public types that
* cannot be changed, so they are generously oversized to allow
* for future growth. Hence, there are usually unused bits.
*
* conv_bitmaskset() generalizes the process of displaying these items.
*/
typedef struct {
/*
* entry:
* n_mask - # of 32-bit masks that make up this bitmask type.
* maskarr - Array of n_mask 32-bit mask values
* bitmask_descarr - Array of n_mask bitmask_desc_t descriptors,
* one for each mask, specifying the bitmask names, and
* a mask of the bits that are not defined by the system.
* fmt_flags - CONV_FMT_* values, used to specify formatting details.
* conv_buf - Buffer to receive formatted results
* conv_buf_size - Size of conv_buf, including room for NULL termination
*/
static const char *
{
int i, need_sep = 0;
/* If every bit of every mask is 0, return 0 as the result */
for (i = 0; i < n_mask; i++)
if (maskarr[i] != 0)
break;
if (i == n_mask)
return (MSG_ORIG(MSG_GBL_ZERO));
/*
* At least one bit is non-zero. Move through the masks
* and process each one.
*/
if ((fmt_flags & CONV_FMT_NOBKT) == 0) {
}
/*
* conv_expn_field() orders its output with the most significant
* bits on the left. To preserve this ordering across the
* subwords or our "virtual bitmask", we need to process
* the sub-words in the same order, from most significant down
* to least significant. Since unassigned bits tend to be at
* the MSB end of the word, we process the unused bits first.
*
* One implication of this is that the caller should not use
* the unassigned bits for "abandoned" bits in the middle of
* a used range, but should instead define the string for
* that bit as being the string representation of that decimal
* value (i.e. "65"). That will cause the bit to be properly
* sorted among the named bits to either side of it.
*/
for (i = 0; i < n_mask; i++) {
size_t n;
mask &= ~unused_bits;
if (mask != 0) {
if (need_sep) {
}
need_sep = 1;
(void) conv_expn_field(&conv_arg,
}
if (unused_bits != 0) {
int j;
if ((unused_bits & bit) == 0)
continue;
if (need_sep) {
}
need_sep = 1;
EC_WORD(j + (bits_per_mask * i)));
}
}
}
if ((fmt_flags & CONV_FMT_NOBKT) == 0) {
}
return ((const char *) conv_buf);
}
#define SIGSET_FLAGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/* sigset_t [0] - Signals [1 - 32] */ \
\
/* \
* sigset_t [1] - Signals [33 - 64] \
* There are 24 unused bits, each of which needs two \
* characters plus a separator. \
*/ \
\
/* \
* sigset_t [2] - Signals [65 - 96] \
* There are 32 unused bits, each of which needs two \
* characters plus a separator. \
*/ \
\
/* \
* sigset_t [2] - Signals [97 - 128] \
* There are 32 unused bits. Three of these need two \
* characters, and 29 need 3. Each one needs a separator. \
*/ \
\
/*
* Ensure that Conv_cnote_sigset_buf_t is large enough:
*
* SIGSET_FLAGSZ is the real minimum size of the buffer required by
* conv_cnote_sigset(). However, Conv_cnote_sigset_buf_t
* uses CONV_CNOTE_SIGSET_BUFSIZE to set the buffer size. We do
* things this way because the definition of SIGSET_FLAGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE SIGSET_FLAGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_SIGSET_BUFSIZE does not match SIGSET_FLAGSZ"
#endif
const char *
{
#define N_MASK 4
{ 0x00000001, MSG_SIGHUP_ALT },
{ 0x00000002, MSG_SIGINT_ALT },
{ 0x00000004, MSG_SIGQUIT_ALT },
{ 0x00000008, MSG_SIGILL_ALT },
{ 0x00000010, MSG_SIGTRAP_ALT },
{ 0x00000020, MSG_SIGABRT_ALT },
{ 0x00000040, MSG_SIGEMT_ALT },
{ 0x00000080, MSG_SIGFPE_ALT },
{ 0x00000100, MSG_SIGKILL_ALT },
{ 0x00000200, MSG_SIGBUS_ALT },
{ 0x00000400, MSG_SIGSEGV_ALT },
{ 0x00000800, MSG_SIGSYS_ALT },
{ 0x00001000, MSG_SIGPIPE_ALT },
{ 0x00002000, MSG_SIGALRM_ALT },
{ 0x00004000, MSG_SIGTERM_ALT },
{ 0x00008000, MSG_SIGUSR1_ALT },
{ 0x00010000, MSG_SIGUSR2_ALT },
{ 0x00020000, MSG_SIGCHLD_ALT },
{ 0x00040000, MSG_SIGPWR_ALT },
{ 0x00080000, MSG_SIGWINCH_ALT },
{ 0x00100000, MSG_SIGURG_ALT },
{ 0x00200000, MSG_SIGPOLL_ALT },
{ 0x00400000, MSG_SIGSTOP_ALT },
{ 0x00800000, MSG_SIGTSTP_ALT },
{ 0x01000000, MSG_SIGCONT_ALT },
{ 0x02000000, MSG_SIGTTIN_ALT },
{ 0x04000000, MSG_SIGTTOU_ALT },
{ 0x08000000, MSG_SIGVTALRM_ALT },
{ 0x10000000, MSG_SIGPROF_ALT },
{ 0x20000000, MSG_SIGXCPU_ALT },
{ 0x40000000, MSG_SIGXFSZ_ALT },
{ 0x80000000, MSG_SIGWAITING_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SIGLWP_ALT },
{ 0x00000002, MSG_SIGFREEZE_ALT },
{ 0x00000004, MSG_SIGTHAW_ALT },
{ 0x00000008, MSG_SIGCANCEL_ALT },
{ 0x00000010, MSG_SIGLOST_ALT },
{ 0x00000020, MSG_SIGXRES_ALT },
{ 0x00000040, MSG_SIGJVM1_ALT },
{ 0x00000080, MSG_SIGJVM2_ALT },
{ 0, 0 }
};
{ vda0, 0 },
{ vda1, 0xffffff00 },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff }
};
}
#define FLTSET_FLAGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/* \
* fltset_t[0] - Faults [1 - 32] \
* There are 19 unused bits, each of which needs two \
* characters plus a separator. \
*/ \
/* \
* fltset_t [1] - Faults [33 - 64] \
* There are 32 unused bits, each of which needs two \
* characters plus a separator. \
*/ \
/* \
* fltset_t [2] - Faults [65 - 96] \
* There are 32 unused bits, each of which needs two \
* characters plus a separator. \
*/ \
/* \
* fltset_t [3] - Faults [97 - 128] \
* There are 32 unused bits. Three of these need two \
* characters, and 29 need 3. Each one needs a separator. \
*/ \
\
/*
* Ensure that Conv_cnote_fltset_buf_t is large enough:
*
* FLTSET_FLAGSZ is the real minimum size of the buffer required by
* conv_cnote_fltset(). However, Conv_cnote_fltset_buf_t
* uses CONV_CNOTE_FLTSET_BUFSIZE to set the buffer size. We do
* things this way because the definition of FLTSET_FLAGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE FLTSET_FLAGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_FLTSET_BUFSIZE does not match FLTSET_FLAGSZ"
#endif
const char *
{
#define N_MASK 4
{ 0x00000001, MSG_FLTILL_ALT },
{ 0x00000002, MSG_FLTPRIV_ALT },
{ 0x00000004, MSG_FLTBPT_ALT },
{ 0x00000008, MSG_FLTTRACE_ALT },
{ 0x00000010, MSG_FLTACCESS_ALT },
{ 0x00000020, MSG_FLTBOUNDS_ALT },
{ 0x00000040, MSG_FLTIOVF_ALT },
{ 0x00000080, MSG_FLTIZDIV_ALT },
{ 0x00000100, MSG_FLTFPE_ALT },
{ 0x00000200, MSG_FLTSTACK_ALT },
{ 0x00000400, MSG_FLTPAGE_ALT },
{ 0x00000800, MSG_FLTWATCH_ALT },
{ 0x00001000, MSG_FLTCPCOVF_ALT },
{ 0, 0 }
};
{ vda0, 0xffffe000 },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff }
};
}
#define SYSSET_FLAGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
(512 * CONV_EXPN_FIELD_DEF_SEP_SIZE) + \
\
/* sysset_t[0] - System Calls [1 - 32] */ \
MSG_SYS_EXIT_ALT_SIZE /* 1 */ + \
MSG_SYS_2_SIZE /* 2 (unused) */ + \
MSG_SYS_READ_ALT_SIZE /* 3 */ + \
MSG_SYS_WRITE_ALT_SIZE /* 4 */ + \
MSG_SYS_OPEN_ALT_SIZE /* 5 */ + \
MSG_SYS_CLOSE_ALT_SIZE /* 6 */ + \
MSG_SYS_7_SIZE /* 7 (unused) */ + \
MSG_SYS_8_SIZE /* 8 (unused) */ + \
MSG_SYS_LINK_ALT_SIZE /* 9 */ + \
MSG_SYS_UNLINK_ALT_SIZE /* 10 */ + \
MSG_SYS_11_SIZE /* 11 (unused) */ + \
MSG_SYS_CHDIR_ALT_SIZE /* 12 */ + \
MSG_SYS_TIME_ALT_SIZE /* 13 */ + \
MSG_SYS_MKNOD_ALT_SIZE /* 14 */ + \
MSG_SYS_CHMOD_ALT_SIZE /* 15 */ + \
MSG_SYS_CHOWN_ALT_SIZE /* 16 */ + \
MSG_SYS_BRK_ALT_SIZE /* 17 */ + \
MSG_SYS_STAT_ALT_SIZE /* 18 */ + \
MSG_SYS_LSEEK_ALT_SIZE /* 19 */ + \
MSG_SYS_GETPID_ALT_SIZE /* 20 */ + \
MSG_SYS_MOUNT_ALT_SIZE /* 21 */ + \
MSG_SYS_22_SIZE /* 22 (unused) */ + \
MSG_SYS_SETUID_ALT_SIZE /* 23 */ + \
MSG_SYS_GETUID_ALT_SIZE /* 24 */ + \
MSG_SYS_STIME_ALT_SIZE /* 25 */ + \
MSG_SYS_PCSAMPLE_ALT_SIZE /* 26 */ + \
MSG_SYS_ALARM_ALT_SIZE /* 27 */ + \
MSG_SYS_FSTAT_ALT_SIZE /* 28 */ + \
MSG_SYS_PAUSE_ALT_SIZE /* 29 */ + \
MSG_SYS_30_SIZE /* 30 (unused) */ + \
MSG_SYS_STTY_ALT_SIZE /* 31 */ + \
MSG_SYS_GTTY_ALT_SIZE /* 32 */ + \
\
/* sysset_t[1] - System Calls [33 - 64] */ \
MSG_SYS_ACCESS_ALT_SIZE /* 33 */ + \
MSG_SYS_NICE_ALT_SIZE /* 34 */ + \
MSG_SYS_STATFS_ALT_SIZE /* 35 */ + \
MSG_SYS_SYNC_ALT_SIZE /* 36 */ + \
MSG_SYS_KILL_ALT_SIZE /* 37 */ + \
MSG_SYS_FSTATFS_ALT_SIZE /* 38 */ + \
MSG_SYS_PGRPSYS_ALT_SIZE /* 39 */ + \
MSG_SYS_UUCOPYSTR_ALT_SIZE /* 40 */ + \
MSG_SYS_41_SIZE /* 41 (unused) */ + \
MSG_SYS_PIPE_ALT_SIZE /* 42 */ + \
MSG_SYS_TIMES_ALT_SIZE /* 43 */ + \
MSG_SYS_PROFIL_ALT_SIZE /* 44 */ + \
MSG_SYS_FACCESSAT_ALT_SIZE /* 45 */ + \
MSG_SYS_SETGID_ALT_SIZE /* 46 */ + \
MSG_SYS_GETGID_ALT_SIZE /* 47 */ + \
MSG_SYS_48_SIZE /* 48 (unused) */ + \
MSG_SYS_MSGSYS_ALT_SIZE /* 49 */ + \
MSG_SYS_SYSI86_ALT_SIZE /* 50 */ + \
MSG_SYS_ACCT_ALT_SIZE /* 51 */ + \
MSG_SYS_SHMSYS_ALT_SIZE /* 52 */ + \
MSG_SYS_SEMSYS_ALT_SIZE /* 53 */ + \
MSG_SYS_IOCTL_ALT_SIZE /* 54 */ + \
MSG_SYS_UADMIN_ALT_SIZE /* 55 */ + \
MSG_SYS_FCHOWNAT_ALT_SIZE /* 56 */ + \
MSG_SYS_UTSSYS_ALT_SIZE /* 57 */ + \
MSG_SYS_FDSYNC_ALT_SIZE /* 58 */ + \
MSG_SYS_EXECVE_ALT_SIZE /* 59 */ + \
MSG_SYS_UMASK_ALT_SIZE /* 60 */ + \
MSG_SYS_CHROOT_ALT_SIZE /* 61 */ + \
MSG_SYS_FCNTL_ALT_SIZE /* 62 */ + \
MSG_SYS_ULIMIT_ALT_SIZE /* 63 */ + \
MSG_SYS_RENAMEAT_ALT_SIZE /* 64 */ + \
\
/* sysset_t[2] - System Calls [65 - 96] */ \
MSG_SYS_UNLINKAT_ALT_SIZE /* 65 */ + \
MSG_SYS_FSTATAT_ALT_SIZE /* 66 */ + \
MSG_SYS_FSTATAT64_ALT_SIZE /* 67 */ + \
MSG_SYS_OPENAT_ALT_SIZE /* 68 */ + \
MSG_SYS_OPENAT64_ALT_SIZE /* 69 */ + \
MSG_SYS_TASKSYS_ALT_SIZE /* 70 */ + \
MSG_SYS_ACCTCTL_ALT_SIZE /* 71 */ + \
MSG_SYS_EXACCTSYS_ALT_SIZE /* 72 */ + \
MSG_SYS_GETPAGESIZES_ALT_SIZE /* 73 */ + \
MSG_SYS_RCTLSYS_ALT_SIZE /* 74 */ + \
MSG_SYS_SIDSYS_ALT_SIZE /* 75 */ + \
MSG_SYS_76_SIZE /* 76 (unused) */ + \
MSG_SYS_LWP_PARK_ALT_SIZE /* 77 */ + \
MSG_SYS_SENDFILEV_ALT_SIZE /* 78 */ + \
MSG_SYS_RMDIR_ALT_SIZE /* 79 */ + \
MSG_SYS_MKDIR_ALT_SIZE /* 80 */ + \
MSG_SYS_GETDENTS_ALT_SIZE /* 81 */ + \
MSG_SYS_PRIVSYS_ALT_SIZE /* 82 */ + \
MSG_SYS_UCREDSYS_ALT_SIZE /* 83 */ + \
MSG_SYS_SYSFS_ALT_SIZE /* 84 */ + \
MSG_SYS_GETMSG_ALT_SIZE /* 85 */ + \
MSG_SYS_PUTMSG_ALT_SIZE /* 86 */ + \
MSG_SYS_87_SIZE /* 87 (unused) */ + \
MSG_SYS_LSTAT_ALT_SIZE /* 88 */ + \
MSG_SYS_SYMLINK_ALT_SIZE /* 89 */ + \
MSG_SYS_READLINK_ALT_SIZE /* 90 */ + \
MSG_SYS_SETGROUPS_ALT_SIZE /* 91 */ + \
MSG_SYS_GETGROUPS_ALT_SIZE /* 92 */ + \
MSG_SYS_FCHMOD_ALT_SIZE /* 93 */ + \
MSG_SYS_FCHOWN_ALT_SIZE /* 94 */ + \
MSG_SYS_SIGPROCMASK_ALT_SIZE /* 95 */ + \
MSG_SYS_SIGSUSPEND_ALT_SIZE /* 96 */ + \
\
/* sysset_t[3] - System Calls [97 - 128] */ \
MSG_SYS_SIGALTSTACK_ALT_SIZE /* 97 */ + \
MSG_SYS_SIGACTION_ALT_SIZE /* 98 */ + \
MSG_SYS_SIGPENDING_ALT_SIZE /* 99 */ + \
MSG_SYS_CONTEXT_ALT_SIZE /* 100 */ + \
MSG_SYS_101_SIZE /* 101 (unused) */ + \
MSG_SYS_102_SIZE /* 102 (unused) */ + \
MSG_SYS_STATVFS_ALT_SIZE /* 103 */ + \
MSG_SYS_FSTATVFS_ALT_SIZE /* 104 */ + \
MSG_SYS_GETLOADAVG_ALT_SIZE /* 105 */ + \
MSG_SYS_NFSSYS_ALT_SIZE /* 106 */ + \
MSG_SYS_WAITID_ALT_SIZE /* 107 */ + \
MSG_SYS_SIGSENDSYS_ALT_SIZE /* 108 */ + \
MSG_SYS_HRTSYS_ALT_SIZE /* 109 */ + \
MSG_SYS_UTIMESYS_ALT_SIZE /* 110 */ + \
MSG_SYS_SIGRESEND_ALT_SIZE /* 111 */ + \
MSG_SYS_PRIOCNTLSYS_ALT_SIZE /* 112 */ + \
MSG_SYS_PATHCONF_ALT_SIZE /* 113 */ + \
MSG_SYS_MINCORE_ALT_SIZE /* 114 */ + \
MSG_SYS_MMAP_ALT_SIZE /* 115 */ + \
MSG_SYS_MPROTECT_ALT_SIZE /* 116 */ + \
MSG_SYS_MUNMAP_ALT_SIZE /* 117 */ + \
MSG_SYS_FPATHCONF_ALT_SIZE /* 118 */ + \
MSG_SYS_VFORK_ALT_SIZE /* 119 */ + \
MSG_SYS_FCHDIR_ALT_SIZE /* 120 */ + \
MSG_SYS_READV_ALT_SIZE /* 121 */ + \
MSG_SYS_WRITEV_ALT_SIZE /* 122 */ + \
MSG_SYS_123_SIZE /* 123 (unused) */ + \
MSG_SYS_124_SIZE /* 124 (unused) */ + \
MSG_SYS_125_SIZE /* 125 (unused) */ + \
MSG_SYS_126_SIZE /* 126 (unused) */ + \
MSG_SYS_MMAPOBJ_ALT_SIZE /* 127 */ + \
MSG_SYS_SETRLIMIT_ALT_SIZE /* 128 */ + \
\
/* sysset_t[4] - System Calls [129 - 160] */ \
MSG_SYS_GETRLIMIT_ALT_SIZE /* 129 */ + \
MSG_SYS_LCHOWN_ALT_SIZE /* 130 */ + \
MSG_SYS_MEMCNTL_ALT_SIZE /* 131 */ + \
MSG_SYS_GETPMSG_ALT_SIZE /* 132 */ + \
MSG_SYS_PUTPMSG_ALT_SIZE /* 133 */ + \
MSG_SYS_RENAME_ALT_SIZE /* 134 */ + \
MSG_SYS_UNAME_ALT_SIZE /* 135 */ + \
MSG_SYS_SETEGID_ALT_SIZE /* 136 */ + \
MSG_SYS_SYSCONFIG_ALT_SIZE /* 137 */ + \
MSG_SYS_ADJTIME_ALT_SIZE /* 138 */ + \
MSG_SYS_SYSTEMINFO_ALT_SIZE /* 139 */ + \
MSG_SYS_SHAREFS_ALT_SIZE /* 140 */ + \
MSG_SYS_SETEUID_ALT_SIZE /* 141 */ + \
MSG_SYS_FORKSYS_ALT_SIZE /* 142 */ + \
MSG_SYS_143_SIZE /* 143 (unused) */ + \
MSG_SYS_SIGTIMEDWAIT_ALT_SIZE /* 144 */ + \
MSG_SYS_LWP_INFO_ALT_SIZE /* 145 */ + \
MSG_SYS_YIELD_ALT_SIZE /* 146 */ + \
MSG_SYS_147_SIZE /* 147 (unused) */ + \
MSG_SYS_LWP_SEMA_POST_ALT_SIZE /* 148 */ + \
MSG_SYS_LWP_SEMA_TRYWAIT_ALT_SIZE /* 149 */ + \
MSG_SYS_LWP_DETACH_ALT_SIZE /* 150 */ + \
MSG_SYS_CORECTL_ALT_SIZE /* 151 */ + \
MSG_SYS_MODCTL_ALT_SIZE /* 152 */ + \
MSG_SYS_FCHROOT_ALT_SIZE /* 153 */ + \
MSG_SYS_154_SIZE /* 154 (unused) */ + \
MSG_SYS_VHANGUP_ALT_SIZE /* 155 */ + \
MSG_SYS_GETTIMEOFDAY_ALT_SIZE /* 156 */ + \
MSG_SYS_GETITIMER_ALT_SIZE /* 157 */ + \
MSG_SYS_SETITIMER_ALT_SIZE /* 158 */ + \
MSG_SYS_LWP_CREATE_ALT_SIZE /* 159 */ + \
MSG_SYS_LWP_EXIT_ALT_SIZE /* 160 */ + \
\
/* sysset_t[5] - System Calls [161 - 192] */ \
MSG_SYS_LWP_SUSPEND_ALT_SIZE /* 161 */ + \
MSG_SYS_LWP_CONTINUE_ALT_SIZE /* 162 */ + \
MSG_SYS_LWP_KILL_ALT_SIZE /* 163 */ + \
MSG_SYS_LWP_SELF_ALT_SIZE /* 164 */ + \
MSG_SYS_LWP_SIGMASK_ALT_SIZE /* 165 */ + \
MSG_SYS_LWP_PRIVATE_ALT_SIZE /* 166 */ + \
MSG_SYS_LWP_WAIT_ALT_SIZE /* 167 */ + \
MSG_SYS_LWP_MUTEX_WAKEUP_ALT_SIZE /* 168 */ + \
MSG_SYS_169_SIZE /* 169 (unused) */ + \
MSG_SYS_LWP_COND_WAIT_ALT_SIZE /* 170 */ + \
MSG_SYS_LWP_COND_SIGNAL_ALT_SIZE /* 171 */ + \
MSG_SYS_LWP_COND_BROADCAST_ALT_SIZE /* 172 */ + \
MSG_SYS_PREAD_ALT_SIZE /* 173 */ + \
MSG_SYS_PWRITE_ALT_SIZE /* 174 */ + \
MSG_SYS_LLSEEK_ALT_SIZE /* 175 */ + \
MSG_SYS_INST_SYNC_ALT_SIZE /* 176 */ + \
MSG_SYS_BRAND_ALT_SIZE /* 177 */ + \
MSG_SYS_KAIO_ALT_SIZE /* 178 */ + \
MSG_SYS_CPC_ALT_SIZE /* 179 */ + \
MSG_SYS_LGRPSYS_ALT_SIZE /* 180 */ + \
MSG_SYS_RUSAGESYS_ALT_SIZE /* 181 */ + \
MSG_SYS_PORT_ALT_SIZE /* 182 */ + \
MSG_SYS_POLLSYS_ALT_SIZE /* 183 */ + \
MSG_SYS_LABELSYS_ALT_SIZE /* 184 */ + \
MSG_SYS_ACL_ALT_SIZE /* 185 */ + \
MSG_SYS_AUDITSYS_ALT_SIZE /* 186 */ + \
MSG_SYS_PROCESSOR_BIND_ALT_SIZE /* 187 */ + \
MSG_SYS_PROCESSOR_INFO_ALT_SIZE /* 188 */ + \
MSG_SYS_P_ONLINE_ALT_SIZE /* 189 */ + \
MSG_SYS_SIGQUEUE_ALT_SIZE /* 190 */ + \
MSG_SYS_CLOCK_GETTIME_ALT_SIZE /* 191 */ + \
MSG_SYS_CLOCK_SETTIME_ALT_SIZE /* 192 */ + \
\
/* sysset_t[6] - System Calls [193 - 224] */ \
MSG_SYS_CLOCK_GETRES_ALT_SIZE /* 193 */ + \
MSG_SYS_TIMER_CREATE_ALT_SIZE /* 194 */ + \
MSG_SYS_TIMER_DELETE_ALT_SIZE /* 195 */ + \
MSG_SYS_TIMER_SETTIME_ALT_SIZE /* 196 */ + \
MSG_SYS_TIMER_GETTIME_ALT_SIZE /* 197 */ + \
MSG_SYS_TIMER_GETOVERRUN_ALT_SIZE /* 198 */ + \
MSG_SYS_NANOSLEEP_ALT_SIZE /* 199 */ + \
MSG_SYS_FACL_ALT_SIZE /* 200 */ + \
MSG_SYS_DOOR_ALT_SIZE /* 201 */ + \
MSG_SYS_SETREUID_ALT_SIZE /* 202 */ + \
MSG_SYS_SETREGID_ALT_SIZE /* 203 */ + \
MSG_SYS_INSTALL_UTRAP_ALT_SIZE /* 204 */ + \
MSG_SYS_SIGNOTIFY_ALT_SIZE /* 205 */ + \
MSG_SYS_SCHEDCTL_ALT_SIZE /* 206 */ + \
MSG_SYS_PSET_ALT_SIZE /* 207 */ + \
MSG_SYS_SPARC_UTRAP_INSTALL_ALT_SIZE /* 208 */ + \
MSG_SYS_RESOLVEPATH_ALT_SIZE /* 209 */ + \
MSG_SYS_LWP_MUTEX_TIMEDLOCK_ALT_SIZE /* 210 */ + \
MSG_SYS_LWP_SEMA_TIMEDWAIT_ALT_SIZE /* 211 */ + \
MSG_SYS_LWP_RWLOCK_SYS_ALT_SIZE /* 212 */ + \
MSG_SYS_GETDENTS64_ALT_SIZE /* 213 */ + \
MSG_SYS_MMAP64_ALT_SIZE /* 214 */ + \
MSG_SYS_STAT64_ALT_SIZE /* 215 */ + \
MSG_SYS_LSTAT64_ALT_SIZE /* 216 */ + \
MSG_SYS_FSTAT64_ALT_SIZE /* 217 */ + \
MSG_SYS_STATVFS64_ALT_SIZE /* 218 */ + \
MSG_SYS_FSTATVFS64_ALT_SIZE /* 219 */ + \
MSG_SYS_SETRLIMIT64_ALT_SIZE /* 220 */ + \
MSG_SYS_GETRLIMIT64_ALT_SIZE /* 221 */ + \
MSG_SYS_PREAD64_ALT_SIZE /* 222 */ + \
MSG_SYS_PWRITE64_ALT_SIZE /* 223 */ + \
MSG_SYS_224_SIZE /* 224 (unused) */ + \
\
/* sysset_t[7] - System Calls [225 - 256] */ \
MSG_SYS_OPEN64_ALT_SIZE /* 225 */ + \
MSG_SYS_RPCSYS_ALT_SIZE /* 226 */ + \
MSG_SYS_ZONE_ALT_SIZE /* 227 */ + \
MSG_SYS_AUTOFSSYS_ALT_SIZE /* 228 */ + \
MSG_SYS_GETCWD_ALT_SIZE /* 229 */ + \
MSG_SYS_SO_SOCKET_ALT_SIZE /* 230 */ + \
MSG_SYS_SO_SOCKETPAIR_ALT_SIZE /* 231 */ + \
MSG_SYS_BIND_ALT_SIZE /* 232 */ + \
MSG_SYS_LISTEN_ALT_SIZE /* 233 */ + \
MSG_SYS_ACCEPT_ALT_SIZE /* 234 */ + \
MSG_SYS_CONNECT_ALT_SIZE /* 235 */ + \
MSG_SYS_SHUTDOWN_ALT_SIZE /* 236 */ + \
MSG_SYS_RECV_ALT_SIZE /* 237 */ + \
MSG_SYS_RECVFROM_ALT_SIZE /* 238 */ + \
MSG_SYS_RECVMSG_ALT_SIZE /* 239 */ + \
MSG_SYS_SEND_ALT_SIZE /* 240 */ + \
MSG_SYS_SENDMSG_ALT_SIZE /* 241 */ + \
MSG_SYS_SENDTO_ALT_SIZE /* 242 */ + \
MSG_SYS_GETPEERNAME_ALT_SIZE /* 243 */ + \
MSG_SYS_GETSOCKNAME_ALT_SIZE /* 244 */ + \
MSG_SYS_GETSOCKOPT_ALT_SIZE /* 245 */ + \
MSG_SYS_SETSOCKOPT_ALT_SIZE /* 246 */ + \
MSG_SYS_SOCKCONFIG_ALT_SIZE /* 247 */ + \
MSG_SYS_NTP_GETTIME_ALT_SIZE /* 248 */ + \
MSG_SYS_NTP_ADJTIME_ALT_SIZE /* 249 */ + \
MSG_SYS_LWP_MUTEX_UNLOCK_ALT_SIZE /* 250 */ + \
MSG_SYS_LWP_MUTEX_TRYLOCK_ALT_SIZE /* 251 */ + \
MSG_SYS_LWP_MUTEX_REGISTER_ALT_SIZE /* 252 */ + \
MSG_SYS_CLADM_ALT_SIZE /* 253 */ + \
MSG_SYS_UUCOPY_ALT_SIZE /* 254 */ + \
MSG_SYS_UMOUNT2_ALT_SIZE /* 255 */ + \
3 /* 256 (unused) */ + \
\
/* sysset_t[8] - System Calls [257 - 288] */ \
(32 * 3) /* 257 - 288 (unused) */ + \
\
/* sysset_t[9] - System Calls [289 - 320] */ \
(32 * 3) /* 289 - 320 (unused) */ + \
\
/* sysset_t[10] - System Calls [321 - 352] */ \
(32 * 3) /* 321 - 352 (unused) */ + \
\
/* sysset_t[11] - System Calls [353 - 384] */ \
(32 * 3) /* 353 - 384 (unused) */ + \
\
/* sysset_t[12] - System Calls [385 - 416] */ \
(32 * 3) /* 385 - 416 (unused) */ + \
\
/* sysset_t[13] - System Calls [417 - 448] */ \
(32 * 3) /* 417 - 448 (unused) */ + \
\
/* sysset_t[14] - System Calls [449 - 480] */ \
(32 * 3) /* 449 - 480 (unused) */ + \
\
/* sysset_t[15] - System Calls [481 - 512] */ \
(32 * 3) /* 481 - 512 (unused) */ + \
\
/*
* Ensure that Conv_cnote_sysset_buf_t is large enough:
*
* SYSSET_FLAGSZ is the real minimum size of the buffer required by
* conv_cnote_sysset(). However, Conv_cnote_sysset_buf_t
* uses CONV_CNOTE_SYSSET_BUFSIZE to set the buffer size. We do
* things this way because the definition of SYSSET_FLAGSZ uses information
* that is not available in the environment of other programs
* that include the conv.h header file.
*/
#define REPORT_BUFSIZE SYSSET_FLAGSZ
#include "report_bufsize.h"
#error "CONV_CNOTE_SYSSET_BUFSIZE does not match SYSSET_FLAGSZ"
#endif
const char *
{
#define N_MASK 16
{ 0x00000001, MSG_SYS_EXIT_ALT },
{ 0x00000002, MSG_SYS_2 },
{ 0x00000004, MSG_SYS_READ_ALT },
{ 0x00000008, MSG_SYS_WRITE_ALT },
{ 0x00000010, MSG_SYS_OPEN_ALT },
{ 0x00000020, MSG_SYS_CLOSE_ALT },
{ 0x00000040, MSG_SYS_7 },
{ 0x00000080, MSG_SYS_8 },
{ 0x00000100, MSG_SYS_LINK_ALT },
{ 0x00000200, MSG_SYS_UNLINK_ALT },
{ 0x00000400, MSG_SYS_11 },
{ 0x00000800, MSG_SYS_CHDIR_ALT },
{ 0x00001000, MSG_SYS_TIME_ALT },
{ 0x00002000, MSG_SYS_MKNOD_ALT },
{ 0x00004000, MSG_SYS_CHMOD_ALT },
{ 0x00008000, MSG_SYS_CHOWN_ALT },
{ 0x00010000, MSG_SYS_BRK_ALT },
{ 0x00020000, MSG_SYS_STAT_ALT },
{ 0x00040000, MSG_SYS_LSEEK_ALT },
{ 0x00080000, MSG_SYS_GETPID_ALT },
{ 0x00100000, MSG_SYS_MOUNT_ALT },
{ 0x00200000, MSG_SYS_22 },
{ 0x00400000, MSG_SYS_SETUID_ALT },
{ 0x00800000, MSG_SYS_GETUID_ALT },
{ 0x01000000, MSG_SYS_STIME_ALT },
{ 0x02000000, MSG_SYS_PCSAMPLE_ALT },
{ 0x04000000, MSG_SYS_ALARM_ALT },
{ 0x08000000, MSG_SYS_FSTAT_ALT },
{ 0x10000000, MSG_SYS_PAUSE_ALT },
{ 0x20000000, MSG_SYS_30 },
{ 0x40000000, MSG_SYS_STTY_ALT },
{ 0x80000000, MSG_SYS_GTTY_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_ACCESS_ALT },
{ 0x00000002, MSG_SYS_NICE_ALT },
{ 0x00000004, MSG_SYS_STATFS_ALT },
{ 0x00000008, MSG_SYS_SYNC_ALT },
{ 0x00000010, MSG_SYS_KILL_ALT },
{ 0x00000020, MSG_SYS_FSTATFS_ALT },
{ 0x00000040, MSG_SYS_PGRPSYS_ALT },
{ 0x00000080, MSG_SYS_UUCOPYSTR_ALT },
{ 0x00000100, MSG_SYS_41 },
{ 0x00000200, MSG_SYS_PIPE_ALT },
{ 0x00000400, MSG_SYS_TIMES_ALT },
{ 0x00000800, MSG_SYS_PROFIL_ALT },
{ 0x00001000, MSG_SYS_FACCESSAT_ALT },
{ 0x00002000, MSG_SYS_SETGID_ALT },
{ 0x00004000, MSG_SYS_GETGID_ALT },
{ 0x00008000, MSG_SYS_48 },
{ 0x00010000, MSG_SYS_MSGSYS_ALT },
{ 0x00020000, MSG_SYS_SYSI86_ALT },
{ 0x00040000, MSG_SYS_ACCT_ALT },
{ 0x00080000, MSG_SYS_SHMSYS_ALT },
{ 0x00100000, MSG_SYS_SEMSYS_ALT },
{ 0x00200000, MSG_SYS_IOCTL_ALT },
{ 0x00400000, MSG_SYS_UADMIN_ALT },
{ 0x00800000, MSG_SYS_FCHOWNAT_ALT },
{ 0x01000000, MSG_SYS_UTSSYS_ALT },
{ 0x0200000, MSG_SYS_FDSYNC_ALT },
{ 0x04000000, MSG_SYS_EXECVE_ALT },
{ 0x08000000, MSG_SYS_UMASK_ALT },
{ 0x10000000, MSG_SYS_CHROOT_ALT },
{ 0x20000000, MSG_SYS_FCNTL_ALT },
{ 0x40000000, MSG_SYS_ULIMIT_ALT },
{ 0x80000000, MSG_SYS_RENAMEAT_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_UNLINKAT_ALT },
{ 0x00000002, MSG_SYS_FSTATAT_ALT },
{ 0x00000004, MSG_SYS_FSTATAT64_ALT },
{ 0x00000008, MSG_SYS_OPENAT_ALT },
{ 0x00000010, MSG_SYS_OPENAT64_ALT },
{ 0x00000020, MSG_SYS_TASKSYS_ALT },
{ 0x00000040, MSG_SYS_ACCTCTL_ALT },
{ 0x00000080, MSG_SYS_EXACCTSYS_ALT },
{ 0x00000100, MSG_SYS_GETPAGESIZES_ALT },
{ 0x00000200, MSG_SYS_RCTLSYS_ALT },
{ 0x00000400, MSG_SYS_SIDSYS_ALT },
{ 0x00000800, MSG_SYS_76 },
{ 0x00001000, MSG_SYS_LWP_PARK_ALT },
{ 0x00002000, MSG_SYS_SENDFILEV_ALT },
{ 0x00004000, MSG_SYS_RMDIR_ALT },
{ 0x00008000, MSG_SYS_MKDIR_ALT },
{ 0x00010000, MSG_SYS_GETDENTS_ALT },
{ 0x00020000, MSG_SYS_PRIVSYS_ALT },
{ 0x00040000, MSG_SYS_UCREDSYS_ALT },
{ 0x00080000, MSG_SYS_SYSFS_ALT },
{ 0x00100000, MSG_SYS_GETMSG_ALT },
{ 0x00200000, MSG_SYS_PUTMSG_ALT },
{ 0x00400000, MSG_SYS_87 },
{ 0x00800000, MSG_SYS_LSTAT_ALT },
{ 0x01000000, MSG_SYS_SYMLINK_ALT },
{ 0x02000000, MSG_SYS_READLINK_ALT },
{ 0x04000000, MSG_SYS_SETGROUPS_ALT },
{ 0x08000000, MSG_SYS_GETGROUPS_ALT },
{ 0x10000000, MSG_SYS_FCHMOD_ALT },
{ 0x20000000, MSG_SYS_FCHOWN_ALT },
{ 0x40000000, MSG_SYS_SIGPROCMASK_ALT },
{ 0x80000000, MSG_SYS_SIGSUSPEND_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_SIGALTSTACK_ALT },
{ 0x00000002, MSG_SYS_SIGACTION_ALT },
{ 0x00000004, MSG_SYS_SIGPENDING_ALT },
{ 0x00000008, MSG_SYS_CONTEXT_ALT },
{ 0x00000010, MSG_SYS_101 },
{ 0x00000020, MSG_SYS_102 },
{ 0x00000040, MSG_SYS_STATVFS_ALT },
{ 0x00000080, MSG_SYS_FSTATVFS_ALT },
{ 0x00000100, MSG_SYS_GETLOADAVG_ALT },
{ 0x00000200, MSG_SYS_NFSSYS_ALT },
{ 0x00000400, MSG_SYS_WAITID_ALT },
{ 0x00000800, MSG_SYS_SIGSENDSYS_ALT },
{ 0x00001000, MSG_SYS_HRTSYS_ALT },
{ 0x00002000, MSG_SYS_UTIMESYS_ALT },
{ 0x00004000, MSG_SYS_SIGRESEND_ALT },
{ 0x00008000, MSG_SYS_PRIOCNTLSYS_ALT },
{ 0x00010000, MSG_SYS_PATHCONF_ALT },
{ 0x00020000, MSG_SYS_MINCORE_ALT },
{ 0x00040000, MSG_SYS_MMAP_ALT },
{ 0x00080000, MSG_SYS_MPROTECT_ALT },
{ 0x00100000, MSG_SYS_MUNMAP_ALT },
{ 0x00200000, MSG_SYS_FPATHCONF_ALT },
{ 0x00400000, MSG_SYS_VFORK_ALT },
{ 0x00800000, MSG_SYS_FCHDIR_ALT },
{ 0x01000000, MSG_SYS_READV_ALT },
{ 0x02000000, MSG_SYS_WRITEV_ALT },
{ 0x04000000, MSG_SYS_123 },
{ 0x08000000, MSG_SYS_124 },
{ 0x10000000, MSG_SYS_125 },
{ 0x20000000, MSG_SYS_126 },
{ 0x40000000, MSG_SYS_MMAPOBJ_ALT },
{ 0x80000000, MSG_SYS_SETRLIMIT_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_GETRLIMIT_ALT },
{ 0x00000002, MSG_SYS_LCHOWN_ALT },
{ 0x00000004, MSG_SYS_MEMCNTL_ALT },
{ 0x00000008, MSG_SYS_GETPMSG_ALT },
{ 0x00000010, MSG_SYS_PUTPMSG_ALT },
{ 0x00000020, MSG_SYS_RENAME_ALT },
{ 0x00000040, MSG_SYS_UNAME_ALT },
{ 0x00000080, MSG_SYS_SETEGID_ALT },
{ 0x00000100, MSG_SYS_SYSCONFIG_ALT },
{ 0x00000200, MSG_SYS_ADJTIME_ALT },
{ 0x00000400, MSG_SYS_SYSTEMINFO_ALT },
{ 0x00000800, MSG_SYS_SHAREFS_ALT },
{ 0x00001000, MSG_SYS_SETEUID_ALT },
{ 0x00002000, MSG_SYS_FORKSYS_ALT },
{ 0x00004000, MSG_SYS_143 },
{ 0x00008000, MSG_SYS_SIGTIMEDWAIT_ALT },
{ 0x00010000, MSG_SYS_LWP_INFO_ALT },
{ 0x00020000, MSG_SYS_YIELD_ALT },
{ 0x00040000, MSG_SYS_147 },
{ 0x00080000, MSG_SYS_LWP_SEMA_POST_ALT },
{ 0x00100000, MSG_SYS_LWP_SEMA_TRYWAIT_ALT },
{ 0x00200000, MSG_SYS_LWP_DETACH_ALT },
{ 0x00400000, MSG_SYS_CORECTL_ALT },
{ 0x00800000, MSG_SYS_MODCTL_ALT },
{ 0x01000000, MSG_SYS_FCHROOT_ALT },
{ 0x02000000, MSG_SYS_154 },
{ 0x04000000, MSG_SYS_VHANGUP_ALT },
{ 0x08000000, MSG_SYS_GETTIMEOFDAY_ALT },
{ 0x10000000, MSG_SYS_GETITIMER_ALT },
{ 0x20000000, MSG_SYS_SETITIMER_ALT },
{ 0x40000000, MSG_SYS_LWP_CREATE_ALT },
{ 0x80000000, MSG_SYS_LWP_EXIT_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_LWP_SUSPEND_ALT },
{ 0x00000002, MSG_SYS_LWP_CONTINUE_ALT },
{ 0x00000004, MSG_SYS_LWP_KILL_ALT },
{ 0x00000008, MSG_SYS_LWP_SELF_ALT },
{ 0x00000010, MSG_SYS_LWP_SIGMASK_ALT },
{ 0x00000020, MSG_SYS_LWP_PRIVATE_ALT },
{ 0x00000040, MSG_SYS_LWP_WAIT_ALT },
{ 0x00000080, MSG_SYS_LWP_MUTEX_WAKEUP_ALT },
{ 0x00000100, MSG_SYS_169 },
{ 0x00000200, MSG_SYS_LWP_COND_WAIT_ALT },
{ 0x00000400, MSG_SYS_LWP_COND_SIGNAL_ALT },
{ 0x00000800, MSG_SYS_LWP_COND_BROADCAST_ALT },
{ 0x00001000, MSG_SYS_PREAD_ALT },
{ 0x00002000, MSG_SYS_PWRITE_ALT },
{ 0x00004000, MSG_SYS_LLSEEK_ALT },
{ 0x00008000, MSG_SYS_INST_SYNC_ALT },
{ 0x00010000, MSG_SYS_BRAND_ALT },
{ 0x00020000, MSG_SYS_KAIO_ALT },
{ 0x00040000, MSG_SYS_CPC_ALT },
{ 0x00080000, MSG_SYS_LGRPSYS_ALT },
{ 0x00100000, MSG_SYS_RUSAGESYS_ALT },
{ 0x00200000, MSG_SYS_PORT_ALT },
{ 0x00400000, MSG_SYS_POLLSYS_ALT },
{ 0x00800000, MSG_SYS_LABELSYS_ALT },
{ 0x01000000, MSG_SYS_ACL_ALT },
{ 0x02000000, MSG_SYS_AUDITSYS_ALT },
{ 0x04000000, MSG_SYS_PROCESSOR_BIND_ALT },
{ 0x08000000, MSG_SYS_PROCESSOR_INFO_ALT },
{ 0x10000000, MSG_SYS_P_ONLINE_ALT },
{ 0x20000000, MSG_SYS_SIGQUEUE_ALT },
{ 0x40000000, MSG_SYS_CLOCK_GETTIME_ALT },
{ 0x80000000, MSG_SYS_CLOCK_SETTIME_ALT },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_CLOCK_GETRES_ALT },
{ 0x00000002, MSG_SYS_TIMER_CREATE_ALT },
{ 0x00000004, MSG_SYS_TIMER_DELETE_ALT },
{ 0x00000008, MSG_SYS_TIMER_SETTIME_ALT },
{ 0x00000010, MSG_SYS_TIMER_GETTIME_ALT },
{ 0x00000020, MSG_SYS_TIMER_GETOVERRUN_ALT },
{ 0x00000040, MSG_SYS_NANOSLEEP_ALT },
{ 0x00000080, MSG_SYS_FACL_ALT },
{ 0x00000100, MSG_SYS_DOOR_ALT },
{ 0x00000200, MSG_SYS_SETREUID_ALT },
{ 0x00000400, MSG_SYS_SETREGID_ALT },
{ 0x00000800, MSG_SYS_INSTALL_UTRAP_ALT },
{ 0x00001000, MSG_SYS_SIGNOTIFY_ALT },
{ 0x00002000, MSG_SYS_SCHEDCTL_ALT },
{ 0x00004000, MSG_SYS_PSET_ALT },
{ 0x00008000, MSG_SYS_SPARC_UTRAP_INSTALL_ALT },
{ 0x00010000, MSG_SYS_RESOLVEPATH_ALT },
{ 0x00020000, MSG_SYS_LWP_MUTEX_TIMEDLOCK_ALT },
{ 0x00040000, MSG_SYS_LWP_SEMA_TIMEDWAIT_ALT },
{ 0x00080000, MSG_SYS_LWP_RWLOCK_SYS_ALT },
{ 0x00100000, MSG_SYS_GETDENTS64_ALT },
{ 0x00200000, MSG_SYS_MMAP64_ALT },
{ 0x00400000, MSG_SYS_STAT64_ALT },
{ 0x00800000, MSG_SYS_LSTAT64_ALT },
{ 0x01000000, MSG_SYS_FSTAT64_ALT },
{ 0x02000000, MSG_SYS_STATVFS64_ALT },
{ 0x04000000, MSG_SYS_FSTATVFS64_ALT },
{ 0x08000000, MSG_SYS_SETRLIMIT64_ALT },
{ 0x10000000, MSG_SYS_GETRLIMIT64_ALT },
{ 0x20000000, MSG_SYS_PREAD64_ALT },
{ 0x40000000, MSG_SYS_PWRITE64_ALT },
{ 0x80000000, MSG_SYS_224 },
{ 0, 0 }
};
{ 0x00000001, MSG_SYS_OPEN64_ALT },
{ 0x00000002, MSG_SYS_RPCSYS_ALT },
{ 0x00000004, MSG_SYS_ZONE_ALT },
{ 0x00000008, MSG_SYS_AUTOFSSYS_ALT },
{ 0x00000010, MSG_SYS_GETCWD_ALT },
{ 0x00000020, MSG_SYS_SO_SOCKET_ALT },
{ 0x00000040, MSG_SYS_SO_SOCKETPAIR_ALT },
{ 0x00000080, MSG_SYS_BIND_ALT },
{ 0x00000100, MSG_SYS_LISTEN_ALT },
{ 0x00000200, MSG_SYS_ACCEPT_ALT },
{ 0x00000400, MSG_SYS_CONNECT_ALT },
{ 0x00000800, MSG_SYS_SHUTDOWN_ALT },
{ 0x00001000, MSG_SYS_RECV_ALT },
{ 0x00002000, MSG_SYS_RECVFROM_ALT },
{ 0x00004000, MSG_SYS_RECVMSG_ALT },
{ 0x00008000, MSG_SYS_SEND_ALT },
{ 0x00010000, MSG_SYS_SENDMSG_ALT },
{ 0x00020000, MSG_SYS_SENDTO_ALT },
{ 0x00040000, MSG_SYS_GETPEERNAME_ALT },
{ 0x00080000, MSG_SYS_GETSOCKNAME_ALT },
{ 0x00100000, MSG_SYS_GETSOCKOPT_ALT },
{ 0x00200000, MSG_SYS_SETSOCKOPT_ALT },
{ 0x00400000, MSG_SYS_SOCKCONFIG_ALT },
{ 0x00800000, MSG_SYS_NTP_GETTIME_ALT },
{ 0x01000000, MSG_SYS_NTP_ADJTIME_ALT },
{ 0x02000000, MSG_SYS_LWP_MUTEX_UNLOCK_ALT },
{ 0x04000000, MSG_SYS_LWP_MUTEX_TRYLOCK_ALT },
{ 0x08000000, MSG_SYS_LWP_MUTEX_REGISTER_ALT },
{ 0x10000000, MSG_SYS_CLADM_ALT },
{ 0x20000000, MSG_SYS_UUCOPY_ALT },
{ 0x40000000, MSG_SYS_UMOUNT2_ALT },
/* 256 (unused) */
{ 0, 0 }
};
{ vda0, 0x00000000 },
{ vda1, 0x00000000 },
{ vda2, 0x00000000 },
{ vda3, 0x00000000 },
{ vda4, 0x00000000 },
{ vda5, 0x00000000 },
{ vda6, 0x00000000 },
{ vda7, 0x80000000 },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff },
{ NULL, 0xffffffff }
};
}
const char *
{
CONV_EXPN_FIELD_ARG arg = { 0 };
{ 0x0001, MSG_PR_O_WRONLY },
{ 0x0002, MSG_PR_O_RDONLY },
{ 0x200000, MSG_PR_O_SEARCH },
{ 0x400000, MSG_PR_O_EXEC },
{ 0x0004, MSG_PR_O_NDELAY },
{ 0x0008, MSG_PR_O_APPEND },
{ 0x0010, MSG_PR_O_SYNC },
{ 0x0040, MSG_PR_O_DSYNC },
{ 0x0080, MSG_PR_O_NONBLOCK },
{ 0x0100, MSG_PR_O_CREAT },
{ 0x0200, MSG_PR_O_TRUNC },
{ 0x0400, MSG_PR_O_EXCL },
{ 0x0800, MSG_PR_O_NOCTTY },
{ 0x4000, MSG_PR_O_XATTR },
{ 0x8000, MSG_PR_O_RSYNC },
{ 0x2000, MSG_PR_O_LARGEFILE },
{ 0x20000, MSG_PR_O_NOFOLLOW },
{ 0x40000, MSG_PR_O_NOLINKS },
{ 0, NULL },
};
switch (fileflags & (0x600003)) {
case 0: /* RDONLY */
break;
case 1: /* WRONLY */
case 2: /* RDWR */
case 0x200000: /* SEARCH */
case 0x400000:
/* In isolate, treat these as normal bits */
break;
default:
/* More than one bit set in this group, emit numerically */
}
if (fileflags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return (buf);
}
const char *
{
CONV_EXPN_FIELD_ARG arg = { 0 };
Msg s;
{ 0x1000, MSG_S_IFIFO },
{ 0x800, MSG_S_ISUID },
{ 0x400, MSG_S_ISGID },
{ 0x200, MSG_S_ISVTX },
{ 0400, MSG_S_IRUSR },
{ 0200, MSG_S_IWUSR },
{ 0100, MSG_S_IXUSR },
{ 0040, MSG_S_IRGRP },
{ 0020, MSG_S_IWGRP },
{ 0010, MSG_S_IXGRP },
{ 0004, MSG_S_IROTH },
{ 0002, MSG_S_IWOTH },
{ 0001, MSG_S_IXOTH },
{ 0, NULL },
};
switch (mode & (0xf000)) {
case 0x1000:
s = MSG_S_IFIFO;
break;
case 0x2000:
s = MSG_S_IFCHR;
break;
case 0x4000:
s = MSG_S_IFDIR;
break;
case 0x5000:
s = MSG_S_IFNAM;
break;
case 0x6000:
s = MSG_S_IFBLK;
break;
case 0x8000:
s = MSG_S_IFREG;
break;
case 0xA000:
s = MSG_S_IFLNK;
break;
case 0xc000:
s = MSG_S_IFSOCK;
break;
case 0xd000:
s = MSG_S_IFDOOR;
break;
case 0xe000:
s = MSG_S_IFPORT;
break;
default:
s = NULL;
break;
}
if (s) {
} else {
}
if (mode == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return (buf);
}
#define PROCSECFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
/*
* Ensure that Conv_cnote_pr_secflags_buf_t is large enough:
*
* PROCSECFLGSZ is the real minimum size of the buffer required by
* conv_prsecflags(). However, Conv_cnote_pr_secflags_buf_t uses
* CONV_CNOTE_PSECFLAGS_FLAG_BUFSIZE to set the buffer size. We do things this
* way because the definition of PROCSECFLGSZ uses information that is not
* available in the environment of other programs that include the conv.h
* header file.
*/
#define REPORT_BUFSIZE PROCSECFLGSZ
#include "report_bufsize.h"
#error "CONV_PRSECFLAGS_BUFSIZE does not match PROCSECFLGSZ"
#endif
const char *
{
/*
* The values are initialized later, based on position in this array
*/
{ 0, MSG_ASLR },
{ 0, MSG_FORBIDNULLMAP },
{ 0, MSG_NOEXECSTACK },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = {
};
int i;
if (flags == 0)
return (MSG_ORIG(MSG_GBL_ZERO));
return ((const char *)secflags_buf->buf);
}