1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 /*
  27  * Copyright 2012 DEY Storage Systems, Inc.  All rights reserved.
  28  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
  29  */
  30 
  31 /*
  32  * String conversion routines the system structs found in
  33  * Solaris core file note sections. These items are not
  34  * ELF constructs. However, elfdump contains code for decoding
  35  * them, and therefore requires formatting support.
  36  */
  37 #include        <stdio.h>
  38 #include        <procfs.h>
  39 #include        <sys/corectl.h>
  40 #include        <sys/secflags.h>
  41 #include        <string.h>
  42 #include        <_conv.h>
  43 #include        <corenote_msg.h>
  44 
  45 const char *
  46 conv_cnote_type(Word type, Conv_fmt_flags_t fmt_flags,
  47     Conv_inv_buf_t *inv_buf)
  48 {
  49         static const Msg        types[] = {
  50                 MSG_NT_PRSTATUS,        MSG_NT_PRFPREG,
  51                 MSG_NT_PRPSINFO,        MSG_NT_PRXREG,
  52                 MSG_NT_PLATFORM,        MSG_NT_AUXV,
  53                 MSG_NT_GWINDOWS,        MSG_NT_ASRS,
  54                 MSG_NT_LDT,             MSG_NT_PSTATUS,
  55                 0,                      0,
  56                 MSG_NT_PSINFO,          MSG_NT_PRCRED,
  57                 MSG_NT_UTSNAME,         MSG_NT_LWPSTATUS,
  58                 MSG_NT_LWPSINFO,        MSG_NT_PRPRIV,
  59                 MSG_NT_PRPRIVINFO,      MSG_NT_CONTENT,
  60                 MSG_NT_ZONENAME,        MSG_NT_FDINFO,
  61                 MSG_NT_SPYMASTER,       MSG_NT_SECFLAGS
  62         };
  63 #if NT_NUM != NT_SECFLAGS
  64 #error "NT_NUM has grown. Update core note types[]"
  65 #endif
  66         static const conv_ds_msg_t ds_types = {
  67             CONV_DS_MSG_INIT(NT_PRSTATUS, types) };
  68         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_types), NULL };
  69 
  70 
  71         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, type, ds, fmt_flags,
  72             inv_buf));
  73 }
  74 
  75 
  76 const char *
  77 conv_cnote_auxv_type(Word type, Conv_fmt_flags_t fmt_flags,
  78     Conv_inv_buf_t *inv_buf)
  79 {
  80         static const Msg        types_0_22[] = {
  81                 MSG_AUXV_AT_NULL,               MSG_AUXV_AT_IGNORE,
  82                 MSG_AUXV_AT_EXECFD,             MSG_AUXV_AT_PHDR,
  83                 MSG_AUXV_AT_PHENT,              MSG_AUXV_AT_PHNUM,
  84                 MSG_AUXV_AT_PAGESZ,             MSG_AUXV_AT_BASE,
  85                 MSG_AUXV_AT_FLAGS,              MSG_AUXV_AT_ENTRY,
  86                 MSG_AUXV_AT_NOTELF,             MSG_AUXV_AT_UID,
  87                 MSG_AUXV_AT_EUID,               MSG_AUXV_AT_GID,
  88                 MSG_AUXV_AT_EGID,               MSG_AUXV_AT_PLATFORM,
  89                 MSG_AUXV_AT_HWCAP,              MSG_AUXV_AT_CLKTCK,
  90                 MSG_AUXV_AT_FPUCW,              MSG_AUXV_AT_DCACHEBSIZE,
  91                 MSG_AUXV_AT_ICACHEBSIZE,        MSG_AUXV_AT_UCACHEBSIZE,
  92                 MSG_AUXV_AT_IGNOREPPC
  93         };
  94         static const conv_ds_msg_t ds_types_0_22 = {
  95             CONV_DS_MSG_INIT(0, types_0_22) };
  96 
  97         static const Msg        types_2000_2011[] = {
  98                 MSG_AUXV_AT_SUN_UID,            MSG_AUXV_AT_SUN_RUID,
  99                 MSG_AUXV_AT_SUN_GID,            MSG_AUXV_AT_SUN_RGID,
 100                 MSG_AUXV_AT_SUN_LDELF,          MSG_AUXV_AT_SUN_LDSHDR,
 101                 MSG_AUXV_AT_SUN_LDNAME,         MSG_AUXV_AT_SUN_LPAGESZ,
 102                 MSG_AUXV_AT_SUN_PLATFORM,       MSG_AUXV_AT_SUN_HWCAP,
 103                 MSG_AUXV_AT_SUN_IFLUSH,         MSG_AUXV_AT_SUN_CPU
 104         };
 105         static const conv_ds_msg_t ds_types_2000_2011 = {
 106             CONV_DS_MSG_INIT(2000, types_2000_2011) };
 107 
 108         static const Msg        types_2014_2023[] = {
 109                 MSG_AUXV_AT_SUN_EXECNAME,       MSG_AUXV_AT_SUN_MMU,
 110                 MSG_AUXV_AT_SUN_LDDATA,         MSG_AUXV_AT_SUN_AUXFLAGS,
 111                 MSG_AUXV_AT_SUN_EMULATOR,       MSG_AUXV_AT_SUN_BRANDNAME,
 112                 MSG_AUXV_AT_SUN_BRAND_AUX1,     MSG_AUXV_AT_SUN_BRAND_AUX2,
 113                 MSG_AUXV_AT_SUN_BRAND_AUX3,     MSG_AUXV_AT_SUN_HWCAP2,
 114         };
 115         static const conv_ds_msg_t ds_types_2014_2023 = {
 116             CONV_DS_MSG_INIT(2014, types_2014_2023) };
 117 
 118         static const conv_ds_t  *ds[] = {
 119                 CONV_DS_ADDR(ds_types_0_22), CONV_DS_ADDR(ds_types_2000_2011),
 120                 CONV_DS_ADDR(ds_types_2014_2023), NULL };
 121 
 122         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, type, ds, fmt_flags,
 123             inv_buf));
 124 }
 125 
 126 
 127 const char *
 128 conv_cnote_signal(Word sig, Conv_fmt_flags_t fmt_flags,
 129     Conv_inv_buf_t *inv_buf)
 130 {
 131         static const Msg        sigarr[] = {
 132                 MSG_SIGHUP,             MSG_SIGINT,
 133                 MSG_SIGQUIT,            MSG_SIGILL,
 134                 MSG_SIGTRAP,            MSG_SIGABRT,
 135                 MSG_SIGEMT,             MSG_SIGFPE,
 136                 MSG_SIGKILL,            MSG_SIGBUS,
 137                 MSG_SIGSEGV,            MSG_SIGSYS,
 138                 MSG_SIGPIPE,            MSG_SIGALRM,
 139                 MSG_SIGTERM,            MSG_SIGUSR1,
 140                 MSG_SIGUSR2,            MSG_SIGCHLD,
 141                 MSG_SIGPWR,             MSG_SIGWINCH,
 142                 MSG_SIGURG,             MSG_SIGPOLL,
 143                 MSG_SIGSTOP,            MSG_SIGTSTP,
 144                 MSG_SIGCONT,            MSG_SIGTTIN,
 145                 MSG_SIGTTOU,            MSG_SIGVTALRM,
 146                 MSG_SIGPROF,            MSG_SIGXCPU,
 147                 MSG_SIGXFSZ,            MSG_SIGWAITING,
 148                 MSG_SIGLWP,             MSG_SIGFREEZE,
 149                 MSG_SIGTHAW,            MSG_SIGCANCEL,
 150                 MSG_SIGLOST,            MSG_SIGXRES,
 151                 MSG_SIGJVM1,            MSG_SIGJVM2,
 152         };
 153         static const conv_ds_msg_t ds_sigarr = {
 154             CONV_DS_MSG_INIT(SIGHUP, sigarr) };
 155 
 156         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_sigarr), NULL };
 157 
 158         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, sig, ds, fmt_flags,
 159             inv_buf));
 160 }
 161 
 162 
 163 const char *
 164 conv_cnote_fault(Word flt, Conv_fmt_flags_t fmt_flags,
 165     Conv_inv_buf_t *inv_buf)
 166 {
 167         static const Msg        fltarr[] = {
 168                 MSG_FLTILL,             MSG_FLTPRIV,
 169                 MSG_FLTBPT,             MSG_FLTTRACE,
 170                 MSG_FLTACCESS,          MSG_FLTBOUNDS,
 171                 MSG_FLTIOVF,            MSG_FLTIZDIV,
 172                 MSG_FLTFPE,             MSG_FLTSTACK,
 173                 MSG_FLTPAGE,            MSG_FLTWATCH,
 174                 MSG_FLTCPCOVF
 175 
 176         };
 177         static const conv_ds_msg_t ds_fltarr = {
 178             CONV_DS_MSG_INIT(FLTILL, fltarr) };
 179 
 180         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_fltarr), NULL };
 181 
 182         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, flt, ds, fmt_flags,
 183             inv_buf));
 184 }
 185 
 186 
 187 const char *
 188 conv_cnote_syscall(Word sysnum, Conv_fmt_flags_t fmt_flags,
 189     Conv_inv_buf_t *inv_buf)
 190 {
 191         static const Msg        sysnumarr[] = {
 192                 MSG_SYS_EXIT,                   MSG_SYS_2,
 193                 MSG_SYS_READ,                   MSG_SYS_WRITE,
 194                 MSG_SYS_OPEN,                   MSG_SYS_CLOSE,
 195                 MSG_SYS_7,                      MSG_SYS_8,
 196                 MSG_SYS_LINK,                   MSG_SYS_UNLINK,
 197                 MSG_SYS_11,                     MSG_SYS_CHDIR,
 198                 MSG_SYS_TIME,                   MSG_SYS_MKNOD,
 199                 MSG_SYS_CHMOD,                  MSG_SYS_CHOWN,
 200                 MSG_SYS_BRK,                    MSG_SYS_STAT,
 201                 MSG_SYS_LSEEK,                  MSG_SYS_GETPID,
 202                 MSG_SYS_MOUNT,                  MSG_SYS_22,
 203                 MSG_SYS_SETUID,                 MSG_SYS_GETUID,
 204                 MSG_SYS_STIME,                  MSG_SYS_PCSAMPLE,
 205                 MSG_SYS_ALARM,                  MSG_SYS_FSTAT,
 206                 MSG_SYS_PAUSE,                  MSG_SYS_30,
 207                 MSG_SYS_STTY,                   MSG_SYS_GTTY,
 208                 MSG_SYS_ACCESS,                 MSG_SYS_NICE,
 209                 MSG_SYS_STATFS,                 MSG_SYS_SYNC,
 210                 MSG_SYS_KILL,                   MSG_SYS_FSTATFS,
 211                 MSG_SYS_PGRPSYS,                MSG_SYS_UUCOPYSTR,
 212                 MSG_SYS_41,                     MSG_SYS_PIPE,
 213                 MSG_SYS_TIMES,                  MSG_SYS_PROFIL,
 214                 MSG_SYS_FACCESSAT,              MSG_SYS_SETGID,
 215                 MSG_SYS_GETGID,                 MSG_SYS_48,
 216                 MSG_SYS_MSGSYS,                 MSG_SYS_SYSI86,
 217                 MSG_SYS_ACCT,                   MSG_SYS_SHMSYS,
 218                 MSG_SYS_SEMSYS,                 MSG_SYS_IOCTL,
 219                 MSG_SYS_UADMIN,                 MSG_SYS_FCHOWNAT,
 220                 MSG_SYS_UTSSYS,                 MSG_SYS_FDSYNC,
 221                 MSG_SYS_EXECVE,                 MSG_SYS_UMASK,
 222                 MSG_SYS_CHROOT,                 MSG_SYS_FCNTL,
 223                 MSG_SYS_ULIMIT,                 MSG_SYS_RENAMEAT,
 224                 MSG_SYS_UNLINKAT,               MSG_SYS_FSTATAT,
 225                 MSG_SYS_FSTATAT64,              MSG_SYS_OPENAT,
 226                 MSG_SYS_OPENAT64,               MSG_SYS_TASKSYS,
 227                 MSG_SYS_ACCTCTL,                MSG_SYS_EXACCTSYS,
 228                 MSG_SYS_GETPAGESIZES,           MSG_SYS_RCTLSYS,
 229                 MSG_SYS_SIDSYS,                 MSG_SYS_76,
 230                 MSG_SYS_LWP_PARK,               MSG_SYS_SENDFILEV,
 231                 MSG_SYS_RMDIR,                  MSG_SYS_MKDIR,
 232                 MSG_SYS_GETDENTS,               MSG_SYS_PRIVSYS,
 233                 MSG_SYS_UCREDSYS,               MSG_SYS_SYSFS,
 234                 MSG_SYS_GETMSG,                 MSG_SYS_PUTMSG,
 235                 MSG_SYS_87,                     MSG_SYS_LSTAT,
 236                 MSG_SYS_SYMLINK,                MSG_SYS_READLINK,
 237                 MSG_SYS_SETGROUPS,              MSG_SYS_GETGROUPS,
 238                 MSG_SYS_FCHMOD,                 MSG_SYS_FCHOWN,
 239                 MSG_SYS_SIGPROCMASK,            MSG_SYS_SIGSUSPEND,
 240                 MSG_SYS_SIGALTSTACK,            MSG_SYS_SIGACTION,
 241                 MSG_SYS_SIGPENDING,             MSG_SYS_CONTEXT,
 242                 MSG_SYS_101,                    MSG_SYS_102,
 243                 MSG_SYS_STATVFS,                MSG_SYS_FSTATVFS,
 244                 MSG_SYS_GETLOADAVG,             MSG_SYS_NFSSYS,
 245                 MSG_SYS_WAITID,                 MSG_SYS_SIGSENDSYS,
 246                 MSG_SYS_HRTSYS,                 MSG_SYS_UTIMESYS,
 247                 MSG_SYS_SIGRESEND,              MSG_SYS_PRIOCNTLSYS,
 248                 MSG_SYS_PATHCONF,               MSG_SYS_MINCORE,
 249                 MSG_SYS_MMAP,                   MSG_SYS_MPROTECT,
 250                 MSG_SYS_MUNMAP,                 MSG_SYS_FPATHCONF,
 251                 MSG_SYS_VFORK,                  MSG_SYS_FCHDIR,
 252                 MSG_SYS_READV,                  MSG_SYS_WRITEV,
 253                 MSG_SYS_123,                    MSG_SYS_124,
 254                 MSG_SYS_125,                    MSG_SYS_126,
 255                 MSG_SYS_MMAPOBJ,                MSG_SYS_SETRLIMIT,
 256                 MSG_SYS_GETRLIMIT,              MSG_SYS_LCHOWN,
 257                 MSG_SYS_MEMCNTL,                MSG_SYS_GETPMSG,
 258                 MSG_SYS_PUTPMSG,                MSG_SYS_RENAME,
 259                 MSG_SYS_UNAME,                  MSG_SYS_SETEGID,
 260                 MSG_SYS_SYSCONFIG,              MSG_SYS_ADJTIME,
 261                 MSG_SYS_SYSTEMINFO,             MSG_SYS_SHAREFS,
 262                 MSG_SYS_SETEUID,                MSG_SYS_FORKSYS,
 263                 MSG_SYS_143,                    MSG_SYS_SIGTIMEDWAIT,
 264                 MSG_SYS_LWP_INFO,               MSG_SYS_YIELD,
 265                 MSG_SYS_147,                    MSG_SYS_LWP_SEMA_POST,
 266                 MSG_SYS_LWP_SEMA_TRYWAIT,       MSG_SYS_LWP_DETACH,
 267                 MSG_SYS_CORECTL,                MSG_SYS_MODCTL,
 268                 MSG_SYS_FCHROOT,                MSG_SYS_154,
 269                 MSG_SYS_VHANGUP,                MSG_SYS_GETTIMEOFDAY,
 270                 MSG_SYS_GETITIMER,              MSG_SYS_SETITIMER,
 271                 MSG_SYS_LWP_CREATE,             MSG_SYS_LWP_EXIT,
 272                 MSG_SYS_LWP_SUSPEND,            MSG_SYS_LWP_CONTINUE,
 273                 MSG_SYS_LWP_KILL,               MSG_SYS_LWP_SELF,
 274                 MSG_SYS_LWP_SIGMASK,            MSG_SYS_LWP_PRIVATE,
 275                 MSG_SYS_LWP_WAIT,               MSG_SYS_LWP_MUTEX_WAKEUP,
 276                 MSG_SYS_169,                    MSG_SYS_LWP_COND_WAIT,
 277                 MSG_SYS_LWP_COND_SIGNAL,        MSG_SYS_LWP_COND_BROADCAST,
 278                 MSG_SYS_PREAD,                  MSG_SYS_PWRITE,
 279                 MSG_SYS_LLSEEK,                 MSG_SYS_INST_SYNC,
 280                 MSG_SYS_BRAND,                  MSG_SYS_KAIO,
 281                 MSG_SYS_CPC,                    MSG_SYS_LGRPSYS,
 282                 MSG_SYS_RUSAGESYS,              MSG_SYS_PORT,
 283                 MSG_SYS_POLLSYS,                MSG_SYS_LABELSYS,
 284                 MSG_SYS_ACL,                    MSG_SYS_AUDITSYS,
 285                 MSG_SYS_PROCESSOR_BIND,         MSG_SYS_PROCESSOR_INFO,
 286                 MSG_SYS_P_ONLINE,               MSG_SYS_SIGQUEUE,
 287                 MSG_SYS_CLOCK_GETTIME,          MSG_SYS_CLOCK_SETTIME,
 288                 MSG_SYS_CLOCK_GETRES,           MSG_SYS_TIMER_CREATE,
 289                 MSG_SYS_TIMER_DELETE,           MSG_SYS_TIMER_SETTIME,
 290                 MSG_SYS_TIMER_GETTIME,          MSG_SYS_TIMER_GETOVERRUN,
 291                 MSG_SYS_NANOSLEEP,              MSG_SYS_FACL,
 292                 MSG_SYS_DOOR,                   MSG_SYS_SETREUID,
 293                 MSG_SYS_SETREGID,               MSG_SYS_INSTALL_UTRAP,
 294                 MSG_SYS_SIGNOTIFY,              MSG_SYS_SCHEDCTL,
 295                 MSG_SYS_PSET,                   MSG_SYS_SPARC_UTRAP_INSTALL,
 296                 MSG_SYS_RESOLVEPATH,            MSG_SYS_LWP_MUTEX_TIMEDLOCK,
 297                 MSG_SYS_LWP_SEMA_TIMEDWAIT,     MSG_SYS_LWP_RWLOCK_SYS,
 298                 MSG_SYS_GETDENTS64,             MSG_SYS_MMAP64,
 299                 MSG_SYS_STAT64,                 MSG_SYS_LSTAT64,
 300                 MSG_SYS_FSTAT64,                MSG_SYS_STATVFS64,
 301                 MSG_SYS_FSTATVFS64,             MSG_SYS_SETRLIMIT64,
 302                 MSG_SYS_GETRLIMIT64,            MSG_SYS_PREAD64,
 303                 MSG_SYS_PWRITE64,               MSG_SYS_224,
 304                 MSG_SYS_OPEN64,                 MSG_SYS_RPCSYS,
 305                 MSG_SYS_ZONE,                   MSG_SYS_AUTOFSSYS,
 306                 MSG_SYS_GETCWD,                 MSG_SYS_SO_SOCKET,
 307                 MSG_SYS_SO_SOCKETPAIR,          MSG_SYS_BIND,
 308                 MSG_SYS_LISTEN,                 MSG_SYS_ACCEPT,
 309                 MSG_SYS_CONNECT,                MSG_SYS_SHUTDOWN,
 310                 MSG_SYS_RECV,                   MSG_SYS_RECVFROM,
 311                 MSG_SYS_RECVMSG,                MSG_SYS_SEND,
 312                 MSG_SYS_SENDMSG,                MSG_SYS_SENDTO,
 313                 MSG_SYS_GETPEERNAME,            MSG_SYS_GETSOCKNAME,
 314                 MSG_SYS_GETSOCKOPT,             MSG_SYS_SETSOCKOPT,
 315                 MSG_SYS_SOCKCONFIG,             MSG_SYS_NTP_GETTIME,
 316                 MSG_SYS_NTP_ADJTIME,            MSG_SYS_LWP_MUTEX_UNLOCK,
 317                 MSG_SYS_LWP_MUTEX_TRYLOCK,      MSG_SYS_LWP_MUTEX_REGISTER,
 318                 MSG_SYS_CLADM,                  MSG_SYS_UUCOPY,
 319                 MSG_SYS_UMOUNT2
 320         };
 321         static const conv_ds_msg_t ds_sysnumarr = {
 322             CONV_DS_MSG_INIT(1, sysnumarr) };
 323 
 324         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_sysnumarr), NULL };
 325 
 326         int     use_num = 0;
 327 
 328         /*
 329          * Range check, and handle the unused values in the middle
 330          * of the range. Although the missing values have strings,
 331          * we still prefer to format them, because those strings are
 332          * decimal, and the default behavior, unless the CONV_FMT_DECIMAL
 333          * flag is set, is to display such things in hex.
 334          */
 335         switch (sysnum) {
 336         case 0:
 337         case 2:
 338         case 7:
 339         case 8:
 340         case 11:
 341         case 22:
 342         case 30:
 343         case 41:
 344         case 48:
 345         case 76:
 346         case 87:
 347         case 101:
 348         case 102:
 349         case 123:
 350         case 124:
 351         case 125:
 352         case 126:
 353         case 143:
 354         case 147:
 355         case 154:
 356         case 169:
 357         case 224:
 358                 use_num = 1;
 359                 break;
 360         default:
 361                 use_num = (sysnum > SYS_umount2);
 362                 break;
 363         }
 364         if (use_num)
 365                 return (conv_invalid_val(inv_buf, sysnum, fmt_flags));
 366 
 367         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, sysnum, ds, fmt_flags,
 368             inv_buf));
 369 }
 370 
 371 
 372 const char *
 373 conv_cnote_errno(int errno_val, Conv_fmt_flags_t fmt_flags,
 374     Conv_inv_buf_t *inv_buf)
 375 {
 376         static const Msg        errarr_1_74[74] = {
 377                 MSG_ERRNO_EPERM,                MSG_ERRNO_ENOENT,
 378                 MSG_ERRNO_ESRCH,                MSG_ERRNO_EINTR,
 379                 MSG_ERRNO_EIO,                  MSG_ERRNO_ENXIO,
 380                 MSG_ERRNO_E2BIG,                MSG_ERRNO_ENOEXEC,
 381                 MSG_ERRNO_EBADF,                MSG_ERRNO_ECHILD,
 382                 MSG_ERRNO_EAGAIN,               MSG_ERRNO_ENOMEM,
 383                 MSG_ERRNO_EACCES,               MSG_ERRNO_EFAULT,
 384                 MSG_ERRNO_ENOTBLK,              MSG_ERRNO_EBUSY,
 385                 MSG_ERRNO_EEXIST,               MSG_ERRNO_EXDEV,
 386                 MSG_ERRNO_ENODEV,               MSG_ERRNO_ENOTDIR,
 387                 MSG_ERRNO_EISDIR,               MSG_ERRNO_EINVAL,
 388                 MSG_ERRNO_ENFILE,               MSG_ERRNO_EMFILE,
 389                 MSG_ERRNO_ENOTTY,               MSG_ERRNO_ETXTBSY,
 390                 MSG_ERRNO_EFBIG,                MSG_ERRNO_ENOSPC,
 391                 MSG_ERRNO_ESPIPE,               MSG_ERRNO_EROFS,
 392                 MSG_ERRNO_EMLINK,               MSG_ERRNO_EPIPE,
 393                 MSG_ERRNO_EDOM,                 MSG_ERRNO_ERANGE,
 394                 MSG_ERRNO_ENOMSG,               MSG_ERRNO_EIDRM,
 395                 MSG_ERRNO_ECHRNG,               MSG_ERRNO_EL2NSYNC,
 396                 MSG_ERRNO_EL3HLT,               MSG_ERRNO_EL3RST,
 397                 MSG_ERRNO_ELNRNG,               MSG_ERRNO_EUNATCH,
 398                 MSG_ERRNO_ENOCSI,               MSG_ERRNO_EL2HLT,
 399                 MSG_ERRNO_EDEADLK,              MSG_ERRNO_ENOLCK,
 400                 MSG_ERRNO_ECANCELED,            MSG_ERRNO_ENOTSUP,
 401                 MSG_ERRNO_EDQUOT,               MSG_ERRNO_EBADE,
 402                 MSG_ERRNO_EBADR,                MSG_ERRNO_EXFULL,
 403                 MSG_ERRNO_ENOANO,               MSG_ERRNO_EBADRQC,
 404                 MSG_ERRNO_EBADSLT,              MSG_ERRNO_EDEADLOCK,
 405                 MSG_ERRNO_EBFONT,               MSG_ERRNO_EOWNERDEAD,
 406                 MSG_ERRNO_ENOTRECOVERABLE,      MSG_ERRNO_ENOSTR,
 407                 MSG_ERRNO_ENODATA,              MSG_ERRNO_ETIME,
 408                 MSG_ERRNO_ENOSR,                MSG_ERRNO_ENONET,
 409                 MSG_ERRNO_ENOPKG,               MSG_ERRNO_EREMOTE,
 410                 MSG_ERRNO_ENOLINK,              MSG_ERRNO_EADV,
 411                 MSG_ERRNO_ESRMNT,               MSG_ERRNO_ECOMM,
 412                 MSG_ERRNO_EPROTO,               MSG_ERRNO_ELOCKUNMAPPED,
 413                 MSG_ERRNO_ENOTACTIVE,           MSG_ERRNO_EMULTIHOP
 414         };
 415         static const conv_ds_msg_t ds_errarr_1_74 = {
 416             CONV_DS_MSG_INIT(1, errarr_1_74) };
 417 
 418         static const Msg        errarr_77_99[23] = {
 419                 MSG_ERRNO_EBADMSG,              MSG_ERRNO_ENAMETOOLONG,
 420                 MSG_ERRNO_EOVERFLOW,            MSG_ERRNO_ENOTUNIQ,
 421                 MSG_ERRNO_EBADFD,               MSG_ERRNO_EREMCHG,
 422                 MSG_ERRNO_ELIBACC,              MSG_ERRNO_ELIBBAD,
 423                 MSG_ERRNO_ELIBSCN,              MSG_ERRNO_ELIBMAX,
 424                 MSG_ERRNO_ELIBEXEC,             MSG_ERRNO_EILSEQ,
 425                 MSG_ERRNO_ENOSYS,               MSG_ERRNO_ELOOP,
 426                 MSG_ERRNO_ERESTART,             MSG_ERRNO_ESTRPIPE,
 427                 MSG_ERRNO_ENOTEMPTY,            MSG_ERRNO_EUSERS,
 428                 MSG_ERRNO_ENOTSOCK,             MSG_ERRNO_EDESTADDRREQ,
 429                 MSG_ERRNO_EMSGSIZE,             MSG_ERRNO_EPROTOTYPE,
 430                 MSG_ERRNO_ENOPROTOOPT
 431         };
 432         static const conv_ds_msg_t ds_errarr_77_99 = {
 433             CONV_DS_MSG_INIT(77, errarr_77_99) };
 434 
 435         static const Msg        errarr_120_134[15] = {
 436                 MSG_ERRNO_EPROTONOSUPPORT,      MSG_ERRNO_ESOCKTNOSUPPORT,
 437                 MSG_ERRNO_EOPNOTSUPP,           MSG_ERRNO_EPFNOSUPPORT,
 438                 MSG_ERRNO_EAFNOSUPPORT,         MSG_ERRNO_EADDRINUSE,
 439                 MSG_ERRNO_EADDRNOTAVAIL,        MSG_ERRNO_ENETDOWN,
 440                 MSG_ERRNO_ENETUNREACH,          MSG_ERRNO_ENETRESET,
 441                 MSG_ERRNO_ECONNABORTED,         MSG_ERRNO_ECONNRESET,
 442                 MSG_ERRNO_ENOBUFS,              MSG_ERRNO_EISCONN,
 443                 MSG_ERRNO_ENOTCONN
 444         };
 445         static const conv_ds_msg_t ds_errarr_120_134 = {
 446             CONV_DS_MSG_INIT(120, errarr_120_134) };
 447 
 448         static const Msg        errarr_143_151[9] = {
 449                 MSG_ERRNO_ESHUTDOWN,            MSG_ERRNO_ETOOMANYREFS,
 450                 MSG_ERRNO_ETIMEDOUT,            MSG_ERRNO_ECONNREFUSED,
 451                 MSG_ERRNO_EHOSTDOWN,            MSG_ERRNO_EHOSTUNREACH,
 452                 MSG_ERRNO_EALREADY,             MSG_ERRNO_EINPROGRESS,
 453                 MSG_ERRNO_ESTALE
 454         };
 455         static const conv_ds_msg_t ds_errarr_143_151 = {
 456             CONV_DS_MSG_INIT(143, errarr_143_151) };
 457 
 458         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_errarr_1_74),
 459                 CONV_DS_ADDR(ds_errarr_77_99), CONV_DS_ADDR(ds_errarr_120_134),
 460                 CONV_DS_ADDR(ds_errarr_143_151), NULL };
 461 
 462 
 463         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, errno_val, ds, fmt_flags,
 464             inv_buf));
 465 }
 466 
 467 
 468 const char *
 469 conv_cnote_pr_dmodel(Word dmodel, Conv_fmt_flags_t fmt_flags,
 470     Conv_inv_buf_t *inv_buf)
 471 {
 472         static const Msg        models[] = {
 473                 MSG_PR_MODEL_UNKNOWN,
 474                 MSG_PR_MODEL_ILP32,
 475                 MSG_PR_MODEL_LP64
 476         };
 477         static const conv_ds_msg_t ds_models = {
 478             CONV_DS_MSG_INIT(PR_MODEL_UNKNOWN, models) };
 479         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_models), NULL };
 480 
 481         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, dmodel, ds, fmt_flags,
 482             inv_buf));
 483 }
 484 
 485 
 486 const char *
 487 conv_cnote_pr_why(short why, Conv_fmt_flags_t fmt_flags,
 488     Conv_inv_buf_t *inv_buf)
 489 {
 490         static const Msg        why_arr[] = {
 491                 MSG_PR_WHY_REQUESTED,
 492                 MSG_PR_WHY_SIGNALLED,
 493                 MSG_PR_WHY_SYSENTRY,
 494                 MSG_PR_WHY_SYSEXIT,
 495                 MSG_PR_WHY_JOBCONTROL,
 496                 MSG_PR_WHY_FAULTED,
 497                 MSG_PR_WHY_SUSPENDED,
 498                 MSG_PR_WHY_CHECKPOINT
 499         };
 500         static const conv_ds_msg_t ds_why_arr = {
 501             CONV_DS_MSG_INIT(1, why_arr) };
 502         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_why_arr), NULL };
 503 
 504         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, why, ds, fmt_flags,
 505             inv_buf));
 506 }
 507 
 508 
 509 const char *
 510 conv_cnote_pr_what(short why, short what, Conv_fmt_flags_t fmt_flags,
 511     Conv_inv_buf_t *inv_buf)
 512 {
 513         /*
 514          * The meaning of pr_what depends on the corresponding
 515          * value of pr_why, as discussed in the proc(4) manpage.
 516          */
 517         switch (why) {
 518         case PR_SIGNALLED:
 519         case PR_JOBCONTROL:
 520                 return (conv_cnote_signal(what, fmt_flags, inv_buf));
 521         case PR_SYSENTRY:
 522         case PR_SYSEXIT:
 523                 return (conv_cnote_syscall(what, fmt_flags, inv_buf));
 524         case PR_FAULTED:
 525                 return (conv_cnote_fault(what, fmt_flags, inv_buf));
 526         };
 527 
 528         return (conv_invalid_val(inv_buf, what, fmt_flags));
 529 }
 530 
 531 
 532 /*
 533  * Return the name of the general purpose register indexed by
 534  * regno in the pr_reg array of lwpstatus_t (<sys/procfs.h>).
 535  */
 536 const char *
 537 conv_cnote_pr_regname(Half mach, int regno, Conv_fmt_flags_t fmt_flags,
 538     Conv_inv_buf_t *inv_buf)
 539 {
 540         static const Msg        sparc_gen_reg[32] = {
 541                 MSG_REG_SPARC_G0,               MSG_REG_SPARC_G1,
 542                 MSG_REG_SPARC_G2,               MSG_REG_SPARC_G3,
 543                 MSG_REG_SPARC_G4,               MSG_REG_SPARC_G5,
 544                 MSG_REG_SPARC_G6,               MSG_REG_SPARC_G7,
 545                 MSG_REG_SPARC_O0,               MSG_REG_SPARC_O1,
 546                 MSG_REG_SPARC_O2,               MSG_REG_SPARC_O3,
 547                 MSG_REG_SPARC_O4,               MSG_REG_SPARC_O5,
 548                 MSG_REG_SPARC_O6,               MSG_REG_SPARC_O7,
 549                 MSG_REG_SPARC_L0,               MSG_REG_SPARC_L1,
 550                 MSG_REG_SPARC_L2,               MSG_REG_SPARC_L3,
 551                 MSG_REG_SPARC_L4,               MSG_REG_SPARC_L5,
 552                 MSG_REG_SPARC_L6,               MSG_REG_SPARC_L7,
 553                 MSG_REG_SPARC_I0,               MSG_REG_SPARC_I1,
 554                 MSG_REG_SPARC_I2,               MSG_REG_SPARC_I3,
 555                 MSG_REG_SPARC_I4,               MSG_REG_SPARC_I5,
 556                 MSG_REG_SPARC_I6,               MSG_REG_SPARC_I7
 557         };
 558         static const conv_ds_msg_t ds_sparc_gen_reg = {
 559             CONV_DS_MSG_INIT(0, sparc_gen_reg) };
 560 
 561         static const Msg        sparc_32_37_reg[6] = {
 562                 MSG_REG_SPARC_PSR,              MSG_REG_SPARC_PC,
 563                 MSG_REG_SPARC_nPC,              MSG_REG_SPARC_Y,
 564                 MSG_REG_SPARC_WIM,              MSG_REG_SPARC_TBR
 565         };
 566         static const conv_ds_msg_t ds_sparc_32_37_reg = {
 567             CONV_DS_MSG_INIT(32, sparc_32_37_reg) };
 568 
 569         static const Msg        sparcv9_32_37_reg[6] = {
 570                 MSG_REG_SPARC_CCR,              MSG_REG_SPARC_PC,
 571                 MSG_REG_SPARC_nPC,              MSG_REG_SPARC_Y,
 572                 MSG_REG_SPARC_ASI,              MSG_REG_SPARC_FPRS
 573         };
 574         static const conv_ds_msg_t ds_sparcv9_32_37_reg = {
 575             CONV_DS_MSG_INIT(32, sparcv9_32_37_reg) };
 576 
 577         static const Msg        amd64_reg[28] = {
 578                 MSG_REG_AMD64_R15,              MSG_REG_AMD64_R14,
 579                 MSG_REG_AMD64_R13,              MSG_REG_AMD64_R12,
 580                 MSG_REG_AMD64_R11,              MSG_REG_AMD64_R10,
 581                 MSG_REG_AMD64_R9,               MSG_REG_AMD64_R8,
 582                 MSG_REG_AMD64_RDI,              MSG_REG_AMD64_RSI,
 583                 MSG_REG_AMD64_RBP,              MSG_REG_AMD64_RBX,
 584                 MSG_REG_AMD64_RDX,              MSG_REG_AMD64_RCX,
 585                 MSG_REG_AMD64_RAX,              MSG_REG_AMD64_TRAPNO,
 586                 MSG_REG_AMD64_ERR,              MSG_REG_AMD64_RIP,
 587                 MSG_REG_AMD64_CS,               MSG_REG_AMD64_RFL,
 588                 MSG_REG_AMD64_RSP,              MSG_REG_AMD64_SS,
 589                 MSG_REG_AMD64_FS,               MSG_REG_AMD64_GS,
 590                 MSG_REG_AMD64_ES,               MSG_REG_AMD64_DS,
 591                 MSG_REG_AMD64_FSBASE,           MSG_REG_AMD64_GSBASE
 592         };
 593         static const conv_ds_msg_t ds_amd64_reg = {
 594             CONV_DS_MSG_INIT(0, amd64_reg) };
 595 
 596         static const Msg        i86_reg[19] = {
 597                 MSG_REG_I86_GS,                 MSG_REG_I86_FS,
 598                 MSG_REG_I86_ES,                 MSG_REG_I86_DS,
 599                 MSG_REG_I86_EDI,                MSG_REG_I86_ESI,
 600                 MSG_REG_I86_EBP,                MSG_REG_I86_ESP,
 601                 MSG_REG_I86_EBX,                MSG_REG_I86_EDX,
 602                 MSG_REG_I86_ECX,                MSG_REG_I86_EAX,
 603                 MSG_REG_I86_TRAPNO,             MSG_REG_I86_ERR,
 604                 MSG_REG_I86_EIP,                MSG_REG_I86_CS,
 605                 MSG_REG_I86_EFL,                MSG_REG_I86_UESP,
 606                 MSG_REG_I86_SS
 607         };
 608         static const conv_ds_msg_t ds_i86_reg = {
 609             CONV_DS_MSG_INIT(0, i86_reg) };
 610 
 611 
 612         static const conv_ds_t  *ds_sparc[] = {
 613                 CONV_DS_ADDR(ds_sparc_gen_reg),
 614                 CONV_DS_ADDR(ds_sparc_32_37_reg),
 615                 NULL
 616         };
 617         static const conv_ds_t  *ds_sparcv9[] = {
 618                 CONV_DS_ADDR(ds_sparc_gen_reg),
 619                 CONV_DS_ADDR(ds_sparcv9_32_37_reg),
 620                 NULL
 621         };
 622         static const conv_ds_t  *ds_amd64[] = {
 623                 CONV_DS_ADDR(ds_amd64_reg), NULL };
 624         static const conv_ds_t  *ds_i86[] = {
 625                 CONV_DS_ADDR(ds_i86_reg), NULL };
 626 
 627         const conv_ds_t **ds;
 628 
 629         switch (mach) {
 630         case EM_386:
 631                 ds = ds_i86;
 632                 break;
 633 
 634         case EM_AMD64:
 635                 ds = ds_amd64;
 636                 break;
 637 
 638         case EM_SPARC:
 639         case EM_SPARC32PLUS:
 640                 ds = ds_sparc;
 641                 break;
 642 
 643         case EM_SPARCV9:
 644                 ds = ds_sparcv9;
 645                 break;
 646 
 647         default:
 648                 return (conv_invalid_val(inv_buf, regno, fmt_flags));
 649         }
 650 
 651         return (conv_map_ds(ELFOSABI_NONE, mach, regno, ds, fmt_flags,
 652             inv_buf));
 653 }
 654 
 655 const char *
 656 conv_cnote_pr_stype(Word stype, Conv_fmt_flags_t fmt_flags,
 657     Conv_inv_buf_t *inv_buf)
 658 {
 659         static const Msg        types[] = {
 660                 MSG_SOBJ_NONE,          MSG_SOBJ_MUTEX,
 661                 MSG_SOBJ_RWLOCK,        MSG_SOBJ_CV,
 662                 MSG_SOBJ_SEMA,          MSG_SOBJ_USER,
 663                 MSG_SOBJ_USER_PI,       MSG_SOBJ_SHUTTLE
 664         };
 665         static const conv_ds_msg_t ds_types = { CONV_DS_MSG_INIT(0, types) };
 666         static const conv_ds_t  *ds[] = { CONV_DS_ADDR(ds_types), NULL };
 667 
 668 
 669         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, stype, ds, fmt_flags,
 670             inv_buf));
 671 }
 672 
 673 
 674 const char *
 675 conv_cnote_priv(int priv, Conv_fmt_flags_t fmt_flags,
 676     Conv_inv_buf_t *inv_buf)
 677 {
 678         const char *fmt;
 679 
 680         /*
 681          * The PRIV_ constants defined in <sys/priv.h> are unusual
 682          * in that they are negative values. The libconv code is all
 683          * built around the Word type, which is unsigned. Rather than
 684          * modify libconv for this one case, we simply handle
 685          * these constants differently that the usual approach,
 686          * and stay away from conv_invalid_val() and conv_map_ds().
 687          */
 688         switch (priv) {
 689         case PRIV_ALL:
 690                 return (MSG_ORIG(MSG_PRIV_ALL));
 691         case PRIV_MULTIPLE:
 692                 return (MSG_ORIG(MSG_PRIV_MULTIPLE));
 693         case PRIV_NONE:
 694                 return (MSG_ORIG(MSG_PRIV_NONE));
 695         case PRIV_ALLZONE:
 696                 return (MSG_ORIG(MSG_PRIV_ALLZONE));
 697         case PRIV_GLOBAL:
 698                 return (MSG_ORIG(MSG_PRIV_GLOBAL));
 699         }
 700 
 701         fmt = (fmt_flags & CONV_FMT_DECIMAL) ?
 702             MSG_ORIG(MSG_FMT_INT) : MSG_ORIG(MSG_FMT_HEXINT);
 703         (void) snprintf(inv_buf->buf, sizeof (inv_buf->buf), fmt, priv);
 704         return (inv_buf->buf);
 705 }
 706 
 707 
 708 const char *
 709 conv_cnote_psetid(int id, Conv_fmt_flags_t fmt_flags,
 710     Conv_inv_buf_t *inv_buf)
 711 {
 712         const char *fmt;
 713 
 714         /*
 715          * The PS_ constants defined in <sys/pset.h> are unusual
 716          * in that they are negative values. The libconv code is all
 717          * built around the Word type, which is unsigned. Rather than
 718          * modify libconv for this one case, we simply handle
 719          * these constants differently that the usual approach,
 720          * and stay away from conv_invalid_val() and conv_map_ds().
 721          */
 722         switch (id) {
 723         case PS_NONE:
 724                 return (MSG_ORIG(MSG_PS_NONE));
 725         case PS_QUERY:
 726                 return (MSG_ORIG(MSG_PS_QUERY));
 727         case PS_MYID:
 728                 return (MSG_ORIG(MSG_PS_MYID));
 729         case PS_SOFT:
 730                 return (MSG_ORIG(MSG_PS_SOFT));
 731         case PS_HARD:
 732                 return (MSG_ORIG(MSG_PS_HARD));
 733         case PS_QUERY_TYPE:
 734                 return (MSG_ORIG(MSG_PS_QUERY_TYPE));
 735         }
 736 
 737         fmt = (fmt_flags & CONV_FMT_DECIMAL) ?
 738             MSG_ORIG(MSG_FMT_INT) : MSG_ORIG(MSG_FMT_HEXINT);
 739         (void) snprintf(inv_buf->buf, sizeof (inv_buf->buf), fmt, id);
 740         return (inv_buf->buf);
 741 }
 742 
 743 
 744 /*
 745  * Return a string describing the si_code field of
 746  * the siginfo_t struct.
 747  *
 748  * The meaning of si_code is dependent on both the target
 749  * machine (mach) as well as the signal (sig).
 750  */
 751 const char *
 752 conv_cnote_si_code(Half mach, int sig, int si_code,
 753     Conv_fmt_flags_t fmt_flags, Conv_inv_buf_t *inv_buf)
 754 {
 755 
 756         /* Values of si_code for user generated signals */
 757         static const Msg        user_arr[6] = {
 758                 MSG_SI_USER,            MSG_SI_LWP,
 759                 MSG_SI_QUEUE,           MSG_SI_TIMER,
 760                 MSG_SI_ASYNCIO,         MSG_SI_MESGQ
 761         };
 762         static const conv_ds_msg_t ds_msg_user_arr = {
 763             CONV_DS_MSG_INIT(0, user_arr) };
 764         static const conv_ds_t  *ds_user_arr[] = {
 765                 CONV_DS_ADDR(ds_msg_user_arr), NULL };
 766 
 767 
 768         /*
 769          * Architecture dependent system generated signals. All
 770          * versions of Solaris use the same set of these values.
 771          */
 772         static const Msg        trap_arr[6] = {
 773                 MSG_SI_TRAP_BRKPT,      MSG_SI_TRAP_TRACE,
 774                 MSG_SI_TRAP_RWATCH,     MSG_SI_TRAP_WWATCH,
 775                 MSG_SI_TRAP_XWATCH,     MSG_SI_TRAP_DTRACE
 776         };
 777         static const conv_ds_msg_t ds_msg_trap_arr = {
 778             CONV_DS_MSG_INIT(1, trap_arr) };
 779         static const conv_ds_t  *ds_trap_arr[] = {
 780                 CONV_DS_ADDR(ds_msg_trap_arr), NULL };
 781 
 782         static const Msg        cld_arr[6] = {
 783                 MSG_SI_CLD_EXITED,      MSG_SI_CLD_KILLED,
 784                 MSG_SI_CLD_DUMPED,      MSG_SI_CLD_TRAPPED,
 785                 MSG_SI_CLD_STOPPED,     MSG_SI_CLD_CONTINUED
 786         };
 787         static const conv_ds_msg_t ds_msg_cld_arr = {
 788             CONV_DS_MSG_INIT(1, cld_arr) };
 789         static const conv_ds_t  *ds_cld_arr[] = {
 790                 CONV_DS_ADDR(ds_msg_cld_arr), NULL };
 791 
 792         static const Msg        poll_arr[6] = {
 793                 MSG_SI_POLL_IN,         MSG_SI_POLL_OUT,
 794                 MSG_SI_POLL_MSG,        MSG_SI_POLL_ERR,
 795                 MSG_SI_POLL_PRI,        MSG_SI_POLL_HUP
 796         };
 797         static const conv_ds_msg_t ds_msg_poll_arr = {
 798             CONV_DS_MSG_INIT(1, poll_arr) };
 799         static const conv_ds_t  *ds_poll_arr[] = {
 800                 CONV_DS_ADDR(ds_msg_poll_arr), NULL };
 801 
 802         /*
 803          * Architecture dependent system generated signals.
 804          * These items (ILL, EMT, FPE, SEGV, BUS) are platform
 805          * dependent. Some architectures have extra codes.
 806          * The same name may have a different integer value.
 807          * Multiple arrays are used when they differ, and one
 808          * array when all the architectures agree.
 809          */
 810 
 811         /* ILL */
 812         static const Msg        ill_arr[8] = {
 813                 MSG_SI_ILL_ILLOPC,      MSG_SI_ILL_ILLOPN,
 814                 MSG_SI_ILL_ILLADR,      MSG_SI_ILL_ILLTRP,
 815                 MSG_SI_ILL_PRVOPC,      MSG_SI_ILL_PRVREG,
 816                 MSG_SI_ILL_COPROC,      MSG_SI_ILL_BADSTK
 817         };
 818         static const conv_ds_msg_t ds_msg_ill_arr = {
 819             CONV_DS_MSG_INIT(1, ill_arr) };
 820         static const conv_ds_t  *ds_ill_arr[] = {
 821                 CONV_DS_ADDR(ds_msg_ill_arr), NULL };
 822 
 823         /* EMT */
 824         static const Msg        emt_arr_sparc[2] = {
 825                 MSG_SI_EMT_TAGOVF,      MSG_SI_EMT_CPCOVF
 826         };
 827         static const conv_ds_msg_t ds_msg_emt_arr_sparc = {
 828             CONV_DS_MSG_INIT(1, emt_arr_sparc) };
 829         static const conv_ds_t  *ds_emt_arr_sparc[] = {
 830                 CONV_DS_ADDR(ds_msg_emt_arr_sparc), NULL };
 831 
 832         static const Msg        emt_arr_x86[1] = {
 833                 MSG_SI_EMT_CPCOVF
 834         };
 835         static const conv_ds_msg_t ds_msg_emt_arr_x86 = {
 836             CONV_DS_MSG_INIT(1, emt_arr_x86) };
 837         static const conv_ds_t  *ds_emt_arr_x86[] = {
 838                 CONV_DS_ADDR(ds_msg_emt_arr_x86), NULL };
 839 
 840 
 841         /* FPE */
 842         static const Msg        fpe_arr_sparc[8] = {
 843                 MSG_SI_FPE_INTDIV,      MSG_SI_FPE_INTOVF,
 844                 MSG_SI_FPE_FLTDIV,      MSG_SI_FPE_FLTOVF,
 845                 MSG_SI_FPE_FLTUND,      MSG_SI_FPE_FLTRES,
 846                 MSG_SI_FPE_FLTINV,      MSG_SI_FPE_FLTSUB
 847         };
 848         static const conv_ds_msg_t ds_msg_fpe_arr_sparc = {
 849             CONV_DS_MSG_INIT(1, fpe_arr_sparc) };
 850         static const conv_ds_t  *ds_fpe_arr_sparc[] = {
 851                 CONV_DS_ADDR(ds_msg_fpe_arr_sparc), NULL };
 852 
 853         static const Msg        fpe_arr_x86[9] = {
 854                 MSG_SI_FPE_INTDIV,      MSG_SI_FPE_INTOVF,
 855                 MSG_SI_FPE_FLTDIV,      MSG_SI_FPE_FLTOVF,
 856                 MSG_SI_FPE_FLTUND,      MSG_SI_FPE_FLTRES,
 857                 MSG_SI_FPE_FLTINV,      MSG_SI_FPE_FLTSUB,
 858                 MSG_SI_FPE_FLTDEN
 859         };
 860         static const conv_ds_msg_t ds_msg_fpe_arr_x86 = {
 861             CONV_DS_MSG_INIT(1, fpe_arr_x86) };
 862         static const conv_ds_t  *ds_fpe_arr_x86[] = {
 863                 CONV_DS_ADDR(ds_msg_fpe_arr_x86), NULL };
 864 
 865         /* SEGV */
 866         static const Msg        segv_arr[2] = {
 867                 MSG_SI_SEGV_MAPERR,     MSG_SI_SEGV_ACCERR
 868         };
 869         static const conv_ds_msg_t ds_msg_segv_arr = {
 870             CONV_DS_MSG_INIT(1, segv_arr) };
 871         static const conv_ds_t  *ds_segv_arr[] = {
 872                 CONV_DS_ADDR(ds_msg_segv_arr), NULL };
 873 
 874         /* BUS */
 875         static const Msg        bus_arr[3] = {
 876                 MSG_SI_BUS_ADRALN,      MSG_SI_BUS_ADRERR,
 877                 MSG_SI_BUS_OBJERR
 878         };
 879         static const conv_ds_msg_t ds_msg_bus_arr = {
 880             CONV_DS_MSG_INIT(1, bus_arr) };
 881         static const conv_ds_t  *ds_bus_arr[] = {
 882                 CONV_DS_ADDR(ds_msg_bus_arr), NULL };
 883 
 884         enum { ARCH_NONE, ARCH_X86, ARCH_SPARC } arch;
 885 
 886 
 887         /* Handle the si_code values that do not depend on the signal */
 888         switch (si_code) {
 889         case SI_NOINFO:
 890                 return (MSG_ORIG(MSG_SI_NOINFO));
 891         case SI_DTRACE:
 892                 return (MSG_ORIG(MSG_SI_DTRACE));
 893         case SI_RCTL:
 894                 return (MSG_ORIG(MSG_SI_RCTL));
 895         default:
 896                 /* User generated signal codes are <= 0 */
 897                 if (si_code <= 0) {
 898                         int ndx = -si_code;
 899 
 900                         /*
 901                          * If no signal was delivered, and si_code is
 902                          * 0, return "0" rather than "SI_USER".
 903                          */
 904                         if ((si_code == 0) && (sig == 0))
 905                                 return (MSG_ORIG(MSG_GBL_ZERO));
 906 
 907                         if (ndx >= ARRAY_NELTS(user_arr)) {
 908                                 const char *fmt;
 909 
 910                                 fmt = (fmt_flags & CONV_FMT_DECIMAL) ?
 911                                     MSG_ORIG(MSG_FMT_INT) :
 912                                     MSG_ORIG(MSG_FMT_HEXINT);
 913 
 914                                 (void) snprintf(inv_buf->buf,
 915                                     sizeof (inv_buf->buf), fmt, si_code);
 916                                 return (inv_buf->buf);
 917                         }
 918                         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, ndx,
 919                             ds_user_arr, fmt_flags, inv_buf));
 920                 }
 921         }
 922 
 923         /*
 924          * If we didn't return above, then this is a
 925          * system generated signal, and the meaning of si_code
 926          * depends on the signal that was delivered, and possibly
 927          * on the target architecture.
 928          */
 929         switch (mach) {
 930         case EM_386:
 931         case EM_AMD64:
 932                 arch = ARCH_X86;
 933                 break;
 934 
 935         case EM_SPARC:
 936         case EM_SPARC32PLUS:
 937         case EM_SPARCV9:
 938                 arch = ARCH_X86;
 939                 break;
 940 
 941         default:
 942                 arch = ARCH_NONE;
 943                 break;
 944         }
 945 
 946         switch (sig) {
 947         case SIGTRAP:
 948                 return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 949                     ds_trap_arr, fmt_flags, inv_buf));
 950 
 951         case SIGCLD:
 952                 return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 953                     ds_cld_arr, fmt_flags, inv_buf));
 954 
 955         case SIGPOLL:
 956                 return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 957                     ds_poll_arr, fmt_flags, inv_buf));
 958 
 959         case SIGILL:
 960                 return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 961                     ds_ill_arr, fmt_flags, inv_buf));
 962 
 963         case SIGEMT:
 964                 switch (arch) {
 965                 case ARCH_SPARC:
 966                         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 967                             ds_emt_arr_sparc, fmt_flags, inv_buf));
 968                 case ARCH_X86:
 969                         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 970                             ds_emt_arr_x86, fmt_flags, inv_buf));
 971                 }
 972                 break;
 973 
 974         case SIGFPE:
 975                 switch (arch) {
 976                 case ARCH_SPARC:
 977                         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 978                             ds_fpe_arr_sparc, fmt_flags, inv_buf));
 979                 case ARCH_X86:
 980                         return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 981                             ds_fpe_arr_x86, fmt_flags, inv_buf));
 982                 }
 983                 break;
 984 
 985         case SIGSEGV:
 986                 return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 987                     ds_segv_arr, fmt_flags, inv_buf));
 988 
 989         case SIGBUS:
 990                 return (conv_map_ds(ELFOSABI_NONE, EM_NONE, si_code,
 991                     ds_bus_arr, fmt_flags, inv_buf));
 992         }
 993 
 994         /* If not recognized, format as a number */
 995         return (conv_invalid_val(inv_buf, si_code, fmt_flags));
 996 
 997 }
 998 
 999 
1000 #define AUXAFFLGSZ      CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1001         MSG_AUXV_AF_SUN_SETUGID_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1002         MSG_AUXV_AF_SUN_HWCAPVERIFY_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1003         MSG_AUXV_AF_SUN_NOPLM_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1004         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1005 
1006 /*
1007  * Ensure that Conv_cnote_auxv_af_buf_t is large enough:
1008  *
1009  * AUXAFFLGSZ is the real minimum size of the buffer required by
1010  * conv_cnote_auxv_af(). However, Conv_cnote_auxv_af_buf_t
1011  * uses CONV_CNOTE_AUXV_AF_BUFSIZE to set the buffer size. We do
1012  * things this way because the definition of AUXAFFLGSZ uses information
1013  * that is not available in the environment of other programs
1014  * that include the conv.h header file.
1015  */
1016 #if (CONV_CNOTE_AUXV_AF_BUFSIZE != AUXAFFLGSZ) && !defined(__lint)
1017 #define REPORT_BUFSIZE AUXAFFLGSZ
1018 #include "report_bufsize.h"
1019 #error "CONV_CNOTE_AUXV_AF_BUFSIZE does not match AUXAFFLGSZ"
1020 #endif
1021 
1022 const char *
1023 conv_cnote_auxv_af(Word flags, Conv_fmt_flags_t fmt_flags,
1024     Conv_cnote_auxv_af_buf_t *cnote_auxv_af_buf)
1025 {
1026         static const Val_desc vda[] = {
1027                 { AF_SUN_SETUGID,       MSG_AUXV_AF_SUN_SETUGID },
1028                 { AF_SUN_HWCAPVERIFY,   MSG_AUXV_AF_SUN_HWCAPVERIFY },
1029                 { AF_SUN_NOPLM,         MSG_AUXV_AF_SUN_NOPLM },
1030                 { 0,                    0 }
1031         };
1032         static CONV_EXPN_FIELD_ARG conv_arg = {
1033             NULL, sizeof (cnote_auxv_af_buf->buf) };
1034 
1035         if (flags == 0)
1036                 return (MSG_ORIG(MSG_GBL_ZERO));
1037 
1038         conv_arg.buf = cnote_auxv_af_buf->buf;
1039         conv_arg.oflags = conv_arg.rflags = flags;
1040         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1041 
1042         return ((const char *)cnote_auxv_af_buf->buf);
1043 }
1044 
1045 
1046 #define CCFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1047         MSG_CC_CONTENT_STACK_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1048         MSG_CC_CONTENT_HEAP_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1049         MSG_CC_CONTENT_SHFILE_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1050         MSG_CC_CONTENT_SHANON_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1051         MSG_CC_CONTENT_TEXT_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1052         MSG_CC_CONTENT_DATA_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1053         MSG_CC_CONTENT_RODATA_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1054         MSG_CC_CONTENT_ANON_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1055         MSG_CC_CONTENT_SHM_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1056         MSG_CC_CONTENT_ISM_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1057         MSG_CC_CONTENT_DISM_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1058         MSG_CC_CONTENT_CTF_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1059         MSG_CC_CONTENT_SYMTAB_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1060         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1061 
1062 /*
1063  * Ensure that Conv_cnote_cc_content_buf_t is large enough:
1064  *
1065  * CCFLGSZ is the real minimum size of the buffer required by
1066  * conv_cnote_cc_content(). However, Conv_cnote_cc_content_buf_t
1067  * uses CONV_CNOTE_CC_CONTENT_BUFSIZE to set the buffer size. We do
1068  * things this way because the definition of CCFLGSZ uses information
1069  * that is not available in the environment of other programs
1070  * that include the conv.h header file.
1071  */
1072 #if (CONV_CNOTE_CC_CONTENT_BUFSIZE != CCFLGSZ) && !defined(__lint)
1073 #define REPORT_BUFSIZE CCFLGSZ
1074 #include "report_bufsize.h"
1075 #error "CONV_CNOTE_CC_CONTENT_BUFSIZE does not match CCFLGSZ"
1076 #endif
1077 
1078 const char *
1079 conv_cnote_cc_content(Lword flags, Conv_fmt_flags_t fmt_flags,
1080     Conv_cnote_cc_content_buf_t *cnote_cc_content_buf)
1081 {
1082         /*
1083          * Note: core_content_t is a 64-bit integer value, but our
1084          * conv_expn_field() logic is all built around 32-bit
1085          * Word values. This will probably need changing someday,
1086          * but for now, we make do with the 32-bit engine. This works
1087          * because the number of bits actually assigned in
1088          * the core_content_t data type (<sys/corectl.h>) bits within
1089          * 32-bits.
1090          *
1091          * The downside is that any bits set in the upper half of
1092          * the flags will be ignored. At the time of this writing,
1093          * that can only occur via core file corruption, which presumably
1094          * would be evident in other ways.
1095          */
1096         static const Val_desc vda[] = {
1097                 { (Word) CC_CONTENT_STACK,      MSG_CC_CONTENT_STACK },
1098                 { (Word) CC_CONTENT_HEAP,       MSG_CC_CONTENT_HEAP },
1099                 { (Word) CC_CONTENT_SHFILE,     MSG_CC_CONTENT_SHFILE },
1100                 { (Word) CC_CONTENT_SHANON,     MSG_CC_CONTENT_SHANON },
1101                 { (Word) CC_CONTENT_TEXT,       MSG_CC_CONTENT_TEXT },
1102                 { (Word) CC_CONTENT_DATA,       MSG_CC_CONTENT_DATA },
1103                 { (Word) CC_CONTENT_RODATA,     MSG_CC_CONTENT_RODATA },
1104                 { (Word) CC_CONTENT_ANON,       MSG_CC_CONTENT_ANON },
1105                 { (Word) CC_CONTENT_SHM,        MSG_CC_CONTENT_SHM },
1106                 { (Word) CC_CONTENT_ISM,        MSG_CC_CONTENT_ISM },
1107                 { (Word) CC_CONTENT_DISM,       MSG_CC_CONTENT_DISM },
1108                 { (Word) CC_CONTENT_CTF,        MSG_CC_CONTENT_CTF },
1109                 { (Word) CC_CONTENT_SYMTAB,     MSG_CC_CONTENT_SYMTAB },
1110                 { 0,                    0 }
1111         };
1112         static CONV_EXPN_FIELD_ARG conv_arg = {
1113             NULL, sizeof (cnote_cc_content_buf->buf) };
1114 
1115         if (flags == 0)
1116                 return (MSG_ORIG(MSG_GBL_ZERO));
1117 
1118         conv_arg.buf = cnote_cc_content_buf->buf;
1119         conv_arg.oflags = conv_arg.rflags = flags;
1120         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1121 
1122         return ((const char *)cnote_cc_content_buf->buf);
1123 }
1124 
1125 
1126 #define PRFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1127         MSG_PR_FLAGS_STOPPED_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1128         MSG_PR_FLAGS_ISTOP_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1129         MSG_PR_FLAGS_DSTOP_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1130         MSG_PR_FLAGS_STEP_SIZE          + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1131         MSG_PR_FLAGS_ASLEEP_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1132         MSG_PR_FLAGS_PCINVAL_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1133         MSG_PR_FLAGS_ASLWP_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1134         MSG_PR_FLAGS_AGENT_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1135         MSG_PR_FLAGS_DETACH_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1136         MSG_PR_FLAGS_DAEMON_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1137         MSG_PR_FLAGS_IDLE_SIZE          + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1138         MSG_PR_FLAGS_ISSYS_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1139         MSG_PR_FLAGS_VFORKP_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1140         MSG_PR_FLAGS_ORPHAN_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1141         MSG_PR_FLAGS_NOSIGCHLD_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1142         MSG_PR_FLAGS_WAITPID_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1143         MSG_PR_FLAGS_FORK_SIZE          + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1144         MSG_PR_FLAGS_RLC_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1145         MSG_PR_FLAGS_KLC_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1146         MSG_PR_FLAGS_ASYNC_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1147         MSG_PR_FLAGS_MSACCT_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1148         MSG_PR_FLAGS_BPTADJ_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1149         MSG_PR_FLAGS_PTRACE_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1150         MSG_PR_FLAGS_MSFORK_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1151         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1152 
1153 /*
1154  * Ensure that Conv_cnote_pr_flags_buf_t is large enough:
1155  *
1156  * PRFLGSZ is the real minimum size of the buffer required by
1157  * conv_cnote_pr_flags(). However, Conv_cnote_pr_flags_buf_t
1158  * uses CONV_CNOTE_PR_FLAGS_BUFSIZE to set the buffer size. We do
1159  * things this way because the definition of PRFLGSZ uses information
1160  * that is not available in the environment of other programs
1161  * that include the conv.h header file.
1162  */
1163 #if (CONV_CNOTE_PR_FLAGS_BUFSIZE != PRFLGSZ) && !defined(__lint)
1164 #define REPORT_BUFSIZE PRFLGSZ
1165 #include "report_bufsize.h"
1166 #error "CONV_CNOTE_PR_FLAGS_BUFSIZE does not match PRFLGSZ"
1167 #endif
1168 
1169 const char *
1170 conv_cnote_pr_flags(int flags, Conv_fmt_flags_t fmt_flags,
1171     Conv_cnote_pr_flags_buf_t *cnote_pr_flags_buf)
1172 {
1173         static const Val_desc vda[] = {
1174                 { PR_STOPPED,           MSG_PR_FLAGS_STOPPED },
1175                 { PR_ISTOP,             MSG_PR_FLAGS_ISTOP },
1176                 { PR_DSTOP,             MSG_PR_FLAGS_DSTOP },
1177                 { PR_STEP,              MSG_PR_FLAGS_STEP },
1178                 { PR_ASLEEP,            MSG_PR_FLAGS_ASLEEP },
1179                 { PR_PCINVAL,           MSG_PR_FLAGS_PCINVAL },
1180                 { PR_ASLWP,             MSG_PR_FLAGS_ASLWP },
1181                 { PR_AGENT,             MSG_PR_FLAGS_AGENT },
1182                 { PR_DETACH,            MSG_PR_FLAGS_DETACH },
1183                 { PR_DAEMON,            MSG_PR_FLAGS_DAEMON },
1184                 { PR_IDLE,              MSG_PR_FLAGS_IDLE },
1185                 { PR_ISSYS,             MSG_PR_FLAGS_ISSYS },
1186                 { PR_VFORKP,            MSG_PR_FLAGS_VFORKP },
1187                 { PR_ORPHAN,            MSG_PR_FLAGS_ORPHAN },
1188                 { PR_NOSIGCHLD,         MSG_PR_FLAGS_NOSIGCHLD },
1189                 { PR_WAITPID,           MSG_PR_FLAGS_WAITPID },
1190                 { PR_FORK,              MSG_PR_FLAGS_FORK },
1191                 { PR_RLC,               MSG_PR_FLAGS_RLC },
1192                 { PR_KLC,               MSG_PR_FLAGS_KLC },
1193                 { PR_ASYNC,             MSG_PR_FLAGS_ASYNC },
1194                 { PR_MSACCT,            MSG_PR_FLAGS_MSACCT },
1195                 { PR_BPTADJ,            MSG_PR_FLAGS_BPTADJ },
1196                 { PR_PTRACE,            MSG_PR_FLAGS_PTRACE },
1197                 { PR_MSFORK,            MSG_PR_FLAGS_MSFORK },
1198                 { 0,                    0 }
1199         };
1200         static CONV_EXPN_FIELD_ARG conv_arg = {
1201             NULL, sizeof (cnote_pr_flags_buf->buf) };
1202 
1203         if (flags == 0)
1204                 return (MSG_ORIG(MSG_GBL_ZERO));
1205 
1206         conv_arg.buf = cnote_pr_flags_buf->buf;
1207         conv_arg.oflags = conv_arg.rflags = flags;
1208         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1209 
1210         return ((const char *)cnote_pr_flags_buf->buf);
1211 }
1212 
1213 
1214 #define OLDPRFLGSZ      CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1215         MSG_PR_FLAGS_STOPPED_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1216         MSG_PR_FLAGS_ISTOP_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1217         MSG_PR_FLAGS_DSTOP_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1218         MSG_PR_FLAGS_ASLEEP_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1219         MSG_PR_FLAGS_FORK_SIZE          + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1220         MSG_PR_FLAGS_RLC_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1221         MSG_PR_FLAGS_PTRACE_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1222         MSG_PR_FLAGS_PCINVAL_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1223         MSG_PR_FLAGS_ISSYS_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1224         MSG_PR_FLAGS_STEP_SIZE          + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1225         MSG_PR_FLAGS_KLC_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1226         MSG_PR_FLAGS_ASYNC_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1227         MSG_PR_FLAGS_PCOMPAT_SIZE       + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1228         MSG_PR_FLAGS_MSACCT_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1229         MSG_PR_FLAGS_BPTADJ_SIZE        + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1230         MSG_PR_FLAGS_ASLWP_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1231         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1232 
1233 /*
1234  * Ensure that Conv_cnote_old_pr_flags_buf_t is large enough:
1235  *
1236  * OLDPRFLGSZ is the real minimum size of the buffer required by
1237  * conv_cnote_old_pr_flags(). However, Conv_cnote_old_pr_flags_buf_t
1238  * uses CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE to set the buffer size. We do
1239  * things this way because the definition of OLDPRFLGSZ uses information
1240  * that is not available in the environment of other programs
1241  * that include the conv.h header file.
1242  */
1243 #if (CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE != OLDPRFLGSZ) && !defined(__lint)
1244 #define REPORT_BUFSIZE OLDPRFLGSZ
1245 #include "report_bufsize.h"
1246 #error "CONV_CNOTE_OLD_PR_FLAGS_BUFSIZE does not match OLDPRFLGSZ"
1247 #endif
1248 
1249 const char *
1250 conv_cnote_old_pr_flags(int flags, Conv_fmt_flags_t fmt_flags,
1251     Conv_cnote_old_pr_flags_buf_t *cnote_old_pr_flags_buf)
1252 {
1253         /*
1254          * <sys/old_procfs.h> defines names for many of these flags
1255          * that are also defined in <sys/procfs.h>, but with different
1256          * values. To avoid confusion, we don't include <sys/old_procfs.h>,
1257          * and specify the values directly.
1258          */
1259         static const Val_desc vda[] = {
1260                 { 0x0001,               MSG_PR_FLAGS_STOPPED },
1261                 { 0x0002,               MSG_PR_FLAGS_ISTOP },
1262                 { 0x0004,               MSG_PR_FLAGS_DSTOP },
1263                 { 0x0008,               MSG_PR_FLAGS_ASLEEP },
1264                 { 0x0010,               MSG_PR_FLAGS_FORK },
1265                 { 0x0020,               MSG_PR_FLAGS_RLC },
1266                 { 0x0040,               MSG_PR_FLAGS_PTRACE },
1267                 { 0x0080,               MSG_PR_FLAGS_PCINVAL },
1268                 { 0x0100,               MSG_PR_FLAGS_ISSYS },
1269                 { 0x0200,               MSG_PR_FLAGS_STEP },
1270                 { 0x0400,               MSG_PR_FLAGS_KLC },
1271                 { 0x0800,               MSG_PR_FLAGS_ASYNC },
1272                 { 0x1000,               MSG_PR_FLAGS_PCOMPAT },
1273                 { 0x2000,               MSG_PR_FLAGS_MSACCT },
1274                 { 0x4000,               MSG_PR_FLAGS_BPTADJ },
1275                 { 0x8000,               MSG_PR_FLAGS_ASLWP },
1276                 { 0,                    0 }
1277         };
1278         static CONV_EXPN_FIELD_ARG conv_arg = {
1279             NULL, sizeof (cnote_old_pr_flags_buf->buf) };
1280 
1281         if (flags == 0)
1282                 return (MSG_ORIG(MSG_GBL_ZERO));
1283 
1284         conv_arg.buf = cnote_old_pr_flags_buf->buf;
1285         conv_arg.oflags = conv_arg.rflags = flags;
1286         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1287 
1288         return ((const char *)cnote_old_pr_flags_buf->buf);
1289 }
1290 
1291 
1292 #define PROCFLGSZ       CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1293         MSG_PROC_FLAG_SSYS_SIZE         + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1294         MSG_PROC_FLAG_SMSACCT_SIZE      + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1295         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1296 
1297 /*
1298  * Ensure that Conv_cnote_proc_flag_buf_t is large enough:
1299  *
1300  * PROCFLGSZ is the real minimum size of the buffer required by
1301  * conv_cnote_proc_flag(). However, Conv_cnote_proc_flag_buf_t
1302  * uses CONV_CNOTE_PROC_FLAG_BUFSIZE to set the buffer size. We do
1303  * things this way because the definition of PROCFLGSZ uses information
1304  * that is not available in the environment of other programs
1305  * that include the conv.h header file.
1306  */
1307 #if (CONV_CNOTE_PROC_FLAG_BUFSIZE != PROCFLGSZ) && !defined(__lint)
1308 #define REPORT_BUFSIZE PROCFLGSZ
1309 #include "report_bufsize.h"
1310 #error "CONV_CNOTE_PROC_FLAG_BUFSIZE does not match PROCFLGSZ"
1311 #endif
1312 
1313 const char *
1314 conv_cnote_proc_flag(int flags, Conv_fmt_flags_t fmt_flags,
1315     Conv_cnote_proc_flag_buf_t *cnote_proc_flag_buf)
1316 {
1317         /*
1318          * Most of the proc flags are implementation dependant, and can
1319          * change between releases. As such, we do not attempt to translate
1320          * them to symbolic form, but simply report them in hex form.
1321          * However, SMSACCT and SSYS are special, and their bit values
1322          * are maintained between releases so they can be used in the
1323          * psinfo_t.p_flag field. We therefore translate these items.
1324          *
1325          * See <system/proc.h>
1326          *
1327          * Note: We don't want to include <sys/proc.h> in this file, because
1328          * it redefines 'struct list', which we have defined in sgs.h. As
1329          * SMSACCT and SSYS are stable public values, we simply use
1330          * their numeric value.
1331          */
1332         static const Val_desc vda[] = {
1333                 { 0x00000001,           MSG_PROC_FLAG_SSYS },
1334                 { 0x02000000,           MSG_PROC_FLAG_SMSACCT },
1335                 { 0,                    0 }
1336         };
1337         static CONV_EXPN_FIELD_ARG conv_arg = {
1338             NULL, sizeof (cnote_proc_flag_buf->buf) };
1339 
1340         if (flags == 0)
1341                 return (MSG_ORIG(MSG_GBL_ZERO));
1342 
1343         conv_arg.buf = cnote_proc_flag_buf->buf;
1344         conv_arg.oflags = conv_arg.rflags = flags;
1345         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1346 
1347         return ((const char *)cnote_proc_flag_buf->buf);
1348 }
1349 
1350 
1351 #define SAFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1352         MSG_SA_ONSTACK_SIZE             + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1353         MSG_SA_RESETHAND_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1354         MSG_SA_RESTART_SIZE             + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1355         MSG_SA_SIGINFO_SIZE             + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1356         MSG_SA_NODEFER_SIZE             + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1357         MSG_SA_NOCLDWAIT_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1358         MSG_SA_NOCLDSTOP_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1359         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1360 
1361 /*
1362  * Ensure that Conv_cnote_sa_flags_buf_t is large enough:
1363  *
1364  * SAFLGSZ is the real minimum size of the buffer required by
1365  * conv_cnote_sa_flags(). However, Conv_cnote_sa_flags_buf_t
1366  * uses CONV_CNOTE_SA_FLAGS_BUFSIZE to set the buffer size. We do
1367  * things this way because the definition of SAFLGSZ uses information
1368  * that is not available in the environment of other programs
1369  * that include the conv.h header file.
1370  */
1371 #if (CONV_CNOTE_SA_FLAGS_BUFSIZE != SAFLGSZ) && !defined(__lint)
1372 #define REPORT_BUFSIZE SAFLGSZ
1373 #include "report_bufsize.h"
1374 #error "CONV_CNOTE_SA_FLAGS_BUFSIZE does not match SAFLGSZ"
1375 #endif
1376 
1377 const char *
1378 conv_cnote_sa_flags(int flags, Conv_fmt_flags_t fmt_flags,
1379     Conv_cnote_sa_flags_buf_t *cnote_sa_flags_buf)
1380 {
1381         static const Val_desc vda[] = {
1382                 { SA_ONSTACK,           MSG_SA_ONSTACK },
1383                 { SA_RESETHAND,         MSG_SA_RESETHAND },
1384                 { SA_RESTART,           MSG_SA_RESTART },
1385                 { SA_SIGINFO,           MSG_SA_SIGINFO },
1386                 { SA_NODEFER,           MSG_SA_NODEFER },
1387                 { SA_NOCLDWAIT,         MSG_SA_NOCLDWAIT },
1388                 { SA_NOCLDSTOP,         MSG_SA_NOCLDSTOP },
1389                 { 0,                    0 }
1390         };
1391         static CONV_EXPN_FIELD_ARG conv_arg = {
1392             NULL, sizeof (cnote_sa_flags_buf->buf) };
1393 
1394         if (flags == 0)
1395                 return (MSG_ORIG(MSG_GBL_ZERO));
1396 
1397         conv_arg.buf = cnote_sa_flags_buf->buf;
1398         conv_arg.oflags = conv_arg.rflags = flags;
1399         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1400 
1401         return ((const char *)cnote_sa_flags_buf->buf);
1402 }
1403 
1404 
1405 #define SSFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1406         MSG_SS_ONSTACK_SIZE             + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1407         MSG_SS_DISABLE_SIZE             + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1408         CONV_INV_BUFSIZE                + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1409 
1410 /*
1411  * Ensure that Conv_cnote_ss_flags_buf_t is large enough:
1412  *
1413  * SSFLGSZ is the real minimum size of the buffer required by
1414  * conv_cnote_ss_flags(). However, Conv_cnote_ss_flags_buf_t
1415  * uses CONV_CNOTE_SS_FLAGS_BUFSIZE to set the buffer size. We do
1416  * things this way because the definition of SSFLGSZ uses information
1417  * that is not available in the environment of other programs
1418  * that include the conv.h header file.
1419  */
1420 #if (CONV_CNOTE_SS_FLAGS_BUFSIZE != SSFLGSZ) && !defined(__lint)
1421 #define REPORT_BUFSIZE SSFLGSZ
1422 #include "report_bufsize.h"
1423 #error "CONV_CNOTE_SS_FLAGS_BUFSIZE does not match SSFLGSZ"
1424 #endif
1425 
1426 const char *
1427 conv_cnote_ss_flags(int flags, Conv_fmt_flags_t fmt_flags,
1428     Conv_cnote_ss_flags_buf_t *cnote_ss_flags_buf)
1429 {
1430         static const Val_desc vda[] = {
1431                 { SS_ONSTACK,           MSG_SS_ONSTACK },
1432                 { SS_DISABLE,           MSG_SS_DISABLE },
1433                 { 0,                    0 }
1434         };
1435         static CONV_EXPN_FIELD_ARG conv_arg = {
1436             NULL, sizeof (cnote_ss_flags_buf->buf) };
1437 
1438         if (flags == 0)
1439                 return (MSG_ORIG(MSG_GBL_ZERO));
1440 
1441         conv_arg.buf = cnote_ss_flags_buf->buf;
1442         conv_arg.oflags = conv_arg.rflags = flags;
1443         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
1444 
1445         return ((const char *)cnote_ss_flags_buf->buf);
1446 }
1447 
1448 
1449 /*
1450  * Solaris has a variety of types that use bitmasks to represent
1451  * sets of things like signals (sigset_t), faults (fltset_t), and
1452  * system calls (sysset_t). These types use arrays of unsigned 32-bit
1453  * integers to represent the set. These are public types that
1454  * cannot be changed, so they are generously oversized to allow
1455  * for future growth. Hence, there are usually unused bits.
1456  *
1457  * conv_bitmaskset() generalizes the process of displaying these items.
1458  */
1459 
1460 typedef struct {
1461         const Val_desc  *vdp;           /* NULL, or bitmask description */
1462         uint32_t        unused_bits;    /* Mask of undefined bits */
1463 } conv_bitmaskset_desc_t;
1464 
1465 /*
1466  * entry:
1467  *      n_mask - # of 32-bit masks that make up this bitmask type.
1468  *      maskarr - Array of n_mask 32-bit mask values
1469  *      bitmask_descarr - Array of n_mask bitmask_desc_t descriptors,
1470  *              one for each mask, specifying the bitmask names, and
1471  *              a mask of the bits that are not defined by the system.
1472  *      fmt_flags - CONV_FMT_* values, used to specify formatting details.
1473  *      conv_buf - Buffer to receive formatted results
1474  *      conv_buf_size - Size of conv_buf, including room for NULL termination
1475  */
1476 static const char *
1477 conv_bitmaskset(uint32_t *maskarr, int n_mask,
1478     const conv_bitmaskset_desc_t *bitmask_descarr, Conv_fmt_flags_t fmt_flags,
1479     char *conv_buf, size_t conv_buf_size)
1480 {
1481         CONV_EXPN_FIELD_ARG     conv_arg;
1482         int     i, need_sep = 0;
1483 
1484         /* If every bit of every mask is 0, return 0 as the result */
1485         for (i = 0; i < n_mask; i++)
1486                 if (maskarr[i] != 0)
1487                         break;
1488         if (i == n_mask)
1489                 return (MSG_ORIG(MSG_GBL_ZERO));
1490 
1491         /*
1492          * At least one bit is non-zero. Move through the masks
1493          * and process each one.
1494          */
1495         (void) memset(&conv_arg, 0, sizeof (conv_arg));
1496         conv_arg.bufsize = conv_buf_size;
1497         conv_arg.buf = conv_buf;
1498         if ((fmt_flags & CONV_FMT_NOBKT) == 0) {
1499                 *conv_arg.buf++ = '[';
1500                 *conv_arg.buf++ = ' ';
1501                 conv_arg.bufsize -= 2;
1502         }
1503 
1504         /*
1505          * conv_expn_field() orders its output with the most significant
1506          * bits on the left. To preserve this ordering across the
1507          * subwords or our "virtual bitmask", we need to process
1508          * the sub-words in the same order, from most significant down
1509          * to least significant. Since unassigned bits tend to be at
1510          * the MSB end of the word, we process the unused bits first.
1511          *
1512          * One implication of this is that the caller should not use
1513          * the unassigned bits for "abandoned" bits in the middle of
1514          * a used range, but should instead define the string for
1515          * that bit as being the string representation of that decimal
1516          * value (i.e. "65"). That will cause the bit to be properly
1517          * sorted among the named bits to either side of it.
1518          */
1519         for (i = 0; i < n_mask; i++) {
1520                 size_t          n;
1521                 uint32_t        mask, unused_bits;
1522                 const int       bits_per_mask = sizeof (mask) * 8;
1523 
1524                 mask = maskarr[i];
1525                 unused_bits = mask & bitmask_descarr[i].unused_bits;
1526                 mask &= ~unused_bits;
1527 
1528                 if (mask != 0) {
1529 
1530                         conv_arg.oflags = conv_arg.rflags = mask;
1531                         if (need_sep) {
1532                                 *conv_arg.buf++ = ' ';
1533                                 conv_arg.bufsize--;
1534                         }
1535                         need_sep = 1;
1536                         (void) conv_expn_field(&conv_arg,
1537                             bitmask_descarr[i].vdp, fmt_flags | CONV_FMT_NOBKT);
1538                         n = strlen(conv_arg.buf);
1539                         conv_arg.bufsize -= n;
1540                         conv_arg.buf += n;
1541                 }
1542 
1543                 if (unused_bits != 0) {
1544                         uint32_t        bit = 0x00000001;
1545                         int             j;
1546 
1547                         for (j = 1; j <= bits_per_mask; j++, bit *= 2) {
1548                                 if ((unused_bits & bit) == 0)
1549                                         continue;
1550 
1551                                 if (need_sep) {
1552                                         *conv_arg.buf++ = ' ';
1553                                         conv_arg.bufsize--;
1554                                 }
1555                                 need_sep = 1;
1556                                 n = snprintf(conv_arg.buf, conv_arg.bufsize,
1557                                     MSG_ORIG(MSG_FMT_WORD),
1558                                     EC_WORD(j + (bits_per_mask * i)));
1559                                 conv_arg.buf += n;
1560                                 conv_arg.bufsize -= n;
1561                         }
1562                 }
1563         }
1564         if ((fmt_flags & CONV_FMT_NOBKT) == 0) {
1565                 *conv_arg.buf++ = ' ';
1566                 *conv_arg.buf++ = ']';
1567         }
1568         *conv_arg.buf = '\0';
1569 
1570         return ((const char *) conv_buf);
1571 }
1572 
1573 
1574 #define SIGSET_FLAGSZ   CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1575         /* sigset_t [0] - Signals [1 - 32] */ \
1576         MSG_SIGHUP_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1577         MSG_SIGINT_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1578         MSG_SIGQUIT_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1579         MSG_SIGILL_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1580         MSG_SIGTRAP_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1581         MSG_SIGABRT_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1582         MSG_SIGEMT_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1583         MSG_SIGFPE_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1584         MSG_SIGKILL_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1585         MSG_SIGBUS_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1586         MSG_SIGSEGV_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1587         MSG_SIGSYS_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1588         MSG_SIGPIPE_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1589         MSG_SIGALRM_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1590         MSG_SIGTERM_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1591         MSG_SIGUSR1_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1592         MSG_SIGUSR2_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1593         MSG_SIGCHLD_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1594         MSG_SIGPWR_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1595         MSG_SIGWINCH_ALT_SIZE   + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1596         MSG_SIGURG_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1597         MSG_SIGPOLL_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1598         MSG_SIGSTOP_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1599         MSG_SIGTSTP_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1600         MSG_SIGCONT_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1601         MSG_SIGTTIN_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1602         MSG_SIGTTOU_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1603         MSG_SIGVTALRM_ALT_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1604         MSG_SIGPROF_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1605         MSG_SIGXCPU_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1606         MSG_SIGXFSZ_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1607         MSG_SIGWAITING_ALT_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1608         \
1609         /* \
1610          * sigset_t [1] - Signals [33 - 64] \
1611          * There are 24 unused bits, each of which needs two \
1612          * characters plus a separator. \
1613          */ \
1614         MSG_SIGLWP_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1615         MSG_SIGFREEZE_ALT_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1616         MSG_SIGTHAW_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1617         MSG_SIGCANCEL_ALT_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1618         MSG_SIGLOST_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1619         MSG_SIGXRES_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1620         MSG_SIGJVM1_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1621         MSG_SIGJVM2_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1622         (24 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1623         \
1624         /* \
1625          * sigset_t [2] - Signals [65 - 96] \
1626          * There are 32 unused bits, each of which needs two \
1627          * characters plus a separator. \
1628          */ \
1629         (32 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1630         \
1631         /* \
1632          * sigset_t [2] - Signals [97 - 128] \
1633          * There are 32 unused bits. Three of these need two \
1634          * characters, and 29 need 3. Each one needs a separator. \
1635          */ \
1636         (3 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1637         (29 * (3 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1638         \
1639         CONV_INV_BUFSIZE        + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1640 
1641 /*
1642  * Ensure that Conv_cnote_sigset_buf_t is large enough:
1643  *
1644  * SIGSET_FLAGSZ is the real minimum size of the buffer required by
1645  * conv_cnote_sigset(). However, Conv_cnote_sigset_buf_t
1646  * uses CONV_CNOTE_SIGSET_BUFSIZE to set the buffer size. We do
1647  * things this way because the definition of SIGSET_FLAGSZ uses information
1648  * that is not available in the environment of other programs
1649  * that include the conv.h header file.
1650  */
1651 #if (CONV_CNOTE_SIGSET_BUFSIZE != SIGSET_FLAGSZ) && !defined(__lint)
1652 #define REPORT_BUFSIZE SIGSET_FLAGSZ
1653 #include "report_bufsize.h"
1654 #error "CONV_CNOTE_SIGSET_BUFSIZE does not match SIGSET_FLAGSZ"
1655 #endif
1656 
1657 const char *
1658 conv_cnote_sigset(uint32_t *maskarr, int n_mask,
1659     Conv_fmt_flags_t fmt_flags, Conv_cnote_sigset_buf_t *cnote_sigset_buf)
1660 {
1661 #define N_MASK 4
1662 
1663         static const Val_desc vda0[] = {
1664                 { 0x00000001,           MSG_SIGHUP_ALT },
1665                 { 0x00000002,           MSG_SIGINT_ALT },
1666                 { 0x00000004,           MSG_SIGQUIT_ALT },
1667                 { 0x00000008,           MSG_SIGILL_ALT },
1668                 { 0x00000010,           MSG_SIGTRAP_ALT },
1669                 { 0x00000020,           MSG_SIGABRT_ALT },
1670                 { 0x00000040,           MSG_SIGEMT_ALT },
1671                 { 0x00000080,           MSG_SIGFPE_ALT },
1672                 { 0x00000100,           MSG_SIGKILL_ALT },
1673                 { 0x00000200,           MSG_SIGBUS_ALT },
1674                 { 0x00000400,           MSG_SIGSEGV_ALT },
1675                 { 0x00000800,           MSG_SIGSYS_ALT },
1676                 { 0x00001000,           MSG_SIGPIPE_ALT },
1677                 { 0x00002000,           MSG_SIGALRM_ALT },
1678                 { 0x00004000,           MSG_SIGTERM_ALT },
1679                 { 0x00008000,           MSG_SIGUSR1_ALT },
1680                 { 0x00010000,           MSG_SIGUSR2_ALT },
1681                 { 0x00020000,           MSG_SIGCHLD_ALT },
1682                 { 0x00040000,           MSG_SIGPWR_ALT },
1683                 { 0x00080000,           MSG_SIGWINCH_ALT },
1684                 { 0x00100000,           MSG_SIGURG_ALT },
1685                 { 0x00200000,           MSG_SIGPOLL_ALT },
1686                 { 0x00400000,           MSG_SIGSTOP_ALT },
1687                 { 0x00800000,           MSG_SIGTSTP_ALT },
1688                 { 0x01000000,           MSG_SIGCONT_ALT },
1689                 { 0x02000000,           MSG_SIGTTIN_ALT },
1690                 { 0x04000000,           MSG_SIGTTOU_ALT },
1691                 { 0x08000000,           MSG_SIGVTALRM_ALT },
1692                 { 0x10000000,           MSG_SIGPROF_ALT },
1693                 { 0x20000000,           MSG_SIGXCPU_ALT },
1694                 { 0x40000000,           MSG_SIGXFSZ_ALT },
1695                 { 0x80000000,           MSG_SIGWAITING_ALT },
1696                 { 0,                    0 }
1697         };
1698         static const Val_desc vda1[] = {
1699                 { 0x00000001,           MSG_SIGLWP_ALT },
1700                 { 0x00000002,           MSG_SIGFREEZE_ALT },
1701                 { 0x00000004,           MSG_SIGTHAW_ALT },
1702                 { 0x00000008,           MSG_SIGCANCEL_ALT },
1703                 { 0x00000010,           MSG_SIGLOST_ALT },
1704                 { 0x00000020,           MSG_SIGXRES_ALT },
1705                 { 0x00000040,           MSG_SIGJVM1_ALT },
1706                 { 0x00000080,           MSG_SIGJVM2_ALT },
1707                 { 0,                    0 }
1708         };
1709         static const conv_bitmaskset_desc_t bitmask_desc[N_MASK] = {
1710                 { vda0, 0 },
1711                 { vda1, 0xffffff00 },
1712                 { NULL, 0xffffffff },
1713                 { NULL, 0xffffffff }
1714         };
1715 
1716         if (n_mask > N_MASK)
1717                 n_mask = N_MASK;
1718         return (conv_bitmaskset(maskarr, n_mask, bitmask_desc, fmt_flags,
1719             cnote_sigset_buf->buf, CONV_CNOTE_SIGSET_BUFSIZE));
1720 
1721 #undef N_MASK
1722 }
1723 
1724 
1725 #define FLTSET_FLAGSZ   CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1726         /* \
1727          * fltset_t[0] - Faults [1 - 32] \
1728          * There are 19 unused bits, each of which needs two \
1729          * characters plus a separator. \
1730          */ \
1731         MSG_FLTILL_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1732         MSG_FLTPRIV_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1733         MSG_FLTBPT_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1734         MSG_FLTTRACE_ALT_SIZE   + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1735         MSG_FLTACCESS_ALT_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1736         MSG_FLTBOUNDS_ALT_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1737         MSG_FLTIOVF_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1738         MSG_FLTIZDIV_ALT_SIZE   + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1739         MSG_FLTFPE_ALT_SIZE     + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1740         MSG_FLTSTACK_ALT_SIZE   + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1741         MSG_FLTPAGE_ALT_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1742         MSG_FLTWATCH_ALT_SIZE   + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1743         MSG_FLTCPCOVF_ALT_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
1744         (19 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1745         /* \
1746          * fltset_t [1] - Faults [33 - 64] \
1747          * There are 32 unused bits, each of which needs two \
1748          * characters plus a separator. \
1749          */ \
1750         (32 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1751         /* \
1752          * fltset_t [2] - Faults [65 - 96] \
1753          * There are 32 unused bits, each of which needs two \
1754          * characters plus a separator. \
1755          */ \
1756         (32 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1757         /* \
1758          * fltset_t [3] - Faults [97 - 128] \
1759          * There are 32 unused bits. Three of these need two \
1760          * characters, and 29 need 3. Each one needs a separator. \
1761          */ \
1762         (3 * (2 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1763         (29 * (3 + CONV_EXPN_FIELD_DEF_SEP_SIZE)) + \
1764         \
1765         CONV_INV_BUFSIZE        + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
1766 
1767 /*
1768  * Ensure that Conv_cnote_fltset_buf_t is large enough:
1769  *
1770  * FLTSET_FLAGSZ is the real minimum size of the buffer required by
1771  * conv_cnote_fltset(). However, Conv_cnote_fltset_buf_t
1772  * uses CONV_CNOTE_FLTSET_BUFSIZE to set the buffer size. We do
1773  * things this way because the definition of FLTSET_FLAGSZ uses information
1774  * that is not available in the environment of other programs
1775  * that include the conv.h header file.
1776  */
1777 #if (CONV_CNOTE_FLTSET_BUFSIZE != FLTSET_FLAGSZ) && !defined(__lint)
1778 #define REPORT_BUFSIZE FLTSET_FLAGSZ
1779 #include "report_bufsize.h"
1780 #error "CONV_CNOTE_FLTSET_BUFSIZE does not match FLTSET_FLAGSZ"
1781 #endif
1782 
1783 const char *
1784 conv_cnote_fltset(uint32_t *maskarr, int n_mask,
1785     Conv_fmt_flags_t fmt_flags, Conv_cnote_fltset_buf_t *cnote_fltset_buf)
1786 {
1787 #define N_MASK 4
1788 
1789         static const Val_desc vda0[] = {
1790                 { 0x00000001,           MSG_FLTILL_ALT },
1791                 { 0x00000002,           MSG_FLTPRIV_ALT },
1792                 { 0x00000004,           MSG_FLTBPT_ALT },
1793                 { 0x00000008,           MSG_FLTTRACE_ALT },
1794                 { 0x00000010,           MSG_FLTACCESS_ALT },
1795                 { 0x00000020,           MSG_FLTBOUNDS_ALT },
1796                 { 0x00000040,           MSG_FLTIOVF_ALT },
1797                 { 0x00000080,           MSG_FLTIZDIV_ALT },
1798                 { 0x00000100,           MSG_FLTFPE_ALT },
1799                 { 0x00000200,           MSG_FLTSTACK_ALT },
1800                 { 0x00000400,           MSG_FLTPAGE_ALT },
1801                 { 0x00000800,           MSG_FLTWATCH_ALT },
1802                 { 0x00001000,           MSG_FLTCPCOVF_ALT },
1803                 { 0,                    0 }
1804         };
1805         static const conv_bitmaskset_desc_t bitmask_desc[N_MASK] = {
1806                 { vda0, 0xffffe000 },
1807                 { NULL, 0xffffffff },
1808                 { NULL, 0xffffffff },
1809                 { NULL, 0xffffffff }
1810         };
1811 
1812         if (n_mask > N_MASK)
1813                 n_mask = N_MASK;
1814         return (conv_bitmaskset(maskarr, n_mask, bitmask_desc, fmt_flags,
1815             cnote_fltset_buf->buf, CONV_CNOTE_FLTSET_BUFSIZE));
1816 
1817 #undef N_MASK
1818 }
1819 
1820 
1821 
1822 #define SYSSET_FLAGSZ   CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
1823         (512 * CONV_EXPN_FIELD_DEF_SEP_SIZE) + \
1824         \
1825         /* sysset_t[0] - System Calls [1 - 32] */ \
1826         MSG_SYS_EXIT_ALT_SIZE                   /* 1 */ + \
1827         MSG_SYS_2_SIZE                          /* 2 (unused) */ + \
1828         MSG_SYS_READ_ALT_SIZE                   /* 3 */ + \
1829         MSG_SYS_WRITE_ALT_SIZE                  /* 4 */ + \
1830         MSG_SYS_OPEN_ALT_SIZE                   /* 5 */ + \
1831         MSG_SYS_CLOSE_ALT_SIZE                  /* 6 */ + \
1832         MSG_SYS_7_SIZE                          /* 7 (unused) */ + \
1833         MSG_SYS_8_SIZE                          /* 8 (unused) */ + \
1834         MSG_SYS_LINK_ALT_SIZE                   /* 9 */ + \
1835         MSG_SYS_UNLINK_ALT_SIZE                 /* 10 */ + \
1836         MSG_SYS_11_SIZE                         /* 11 (unused) */ + \
1837         MSG_SYS_CHDIR_ALT_SIZE                  /* 12 */ + \
1838         MSG_SYS_TIME_ALT_SIZE                   /* 13 */ + \
1839         MSG_SYS_MKNOD_ALT_SIZE                  /* 14 */ + \
1840         MSG_SYS_CHMOD_ALT_SIZE                  /* 15 */ + \
1841         MSG_SYS_CHOWN_ALT_SIZE                  /* 16 */ + \
1842         MSG_SYS_BRK_ALT_SIZE                    /* 17 */ + \
1843         MSG_SYS_STAT_ALT_SIZE                   /* 18 */ + \
1844         MSG_SYS_LSEEK_ALT_SIZE                  /* 19 */ + \
1845         MSG_SYS_GETPID_ALT_SIZE                 /* 20 */ + \
1846         MSG_SYS_MOUNT_ALT_SIZE                  /* 21 */ + \
1847         MSG_SYS_22_SIZE                         /* 22 (unused) */ + \
1848         MSG_SYS_SETUID_ALT_SIZE                 /* 23 */ + \
1849         MSG_SYS_GETUID_ALT_SIZE                 /* 24 */ + \
1850         MSG_SYS_STIME_ALT_SIZE                  /* 25 */ + \
1851         MSG_SYS_PCSAMPLE_ALT_SIZE               /* 26 */ + \
1852         MSG_SYS_ALARM_ALT_SIZE                  /* 27 */ + \
1853         MSG_SYS_FSTAT_ALT_SIZE                  /* 28 */ + \
1854         MSG_SYS_PAUSE_ALT_SIZE                  /* 29 */ + \
1855         MSG_SYS_30_SIZE                         /* 30 (unused) */ + \
1856         MSG_SYS_STTY_ALT_SIZE                   /* 31 */ + \
1857         MSG_SYS_GTTY_ALT_SIZE                   /* 32 */ + \
1858         \
1859         /* sysset_t[1] - System Calls [33 - 64] */ \
1860         MSG_SYS_ACCESS_ALT_SIZE                 /* 33 */ + \
1861         MSG_SYS_NICE_ALT_SIZE                   /* 34 */ + \
1862         MSG_SYS_STATFS_ALT_SIZE                 /* 35 */ + \
1863         MSG_SYS_SYNC_ALT_SIZE                   /* 36 */ + \
1864         MSG_SYS_KILL_ALT_SIZE                   /* 37 */ + \
1865         MSG_SYS_FSTATFS_ALT_SIZE                /* 38 */ + \
1866         MSG_SYS_PGRPSYS_ALT_SIZE                /* 39 */ + \
1867         MSG_SYS_UUCOPYSTR_ALT_SIZE              /* 40 */ + \
1868         MSG_SYS_41_SIZE                         /* 41 (unused) */ + \
1869         MSG_SYS_PIPE_ALT_SIZE                   /* 42 */ + \
1870         MSG_SYS_TIMES_ALT_SIZE                  /* 43 */ + \
1871         MSG_SYS_PROFIL_ALT_SIZE                 /* 44 */ + \
1872         MSG_SYS_FACCESSAT_ALT_SIZE              /* 45 */ + \
1873         MSG_SYS_SETGID_ALT_SIZE                 /* 46 */ + \
1874         MSG_SYS_GETGID_ALT_SIZE                 /* 47 */ + \
1875         MSG_SYS_48_SIZE                         /* 48 (unused) */ + \
1876         MSG_SYS_MSGSYS_ALT_SIZE                 /* 49 */ + \
1877         MSG_SYS_SYSI86_ALT_SIZE                 /* 50 */ + \
1878         MSG_SYS_ACCT_ALT_SIZE                   /* 51 */ + \
1879         MSG_SYS_SHMSYS_ALT_SIZE                 /* 52 */ + \
1880         MSG_SYS_SEMSYS_ALT_SIZE                 /* 53 */ + \
1881         MSG_SYS_IOCTL_ALT_SIZE                  /* 54 */ + \
1882         MSG_SYS_UADMIN_ALT_SIZE                 /* 55 */ + \
1883         MSG_SYS_FCHOWNAT_ALT_SIZE               /* 56 */ + \
1884         MSG_SYS_UTSSYS_ALT_SIZE                 /* 57 */ + \
1885         MSG_SYS_FDSYNC_ALT_SIZE                 /* 58 */ + \
1886         MSG_SYS_EXECVE_ALT_SIZE                 /* 59 */ + \
1887         MSG_SYS_UMASK_ALT_SIZE                  /* 60 */ + \
1888         MSG_SYS_CHROOT_ALT_SIZE                 /* 61 */ + \
1889         MSG_SYS_FCNTL_ALT_SIZE                  /* 62 */ + \
1890         MSG_SYS_ULIMIT_ALT_SIZE                 /* 63 */ + \
1891         MSG_SYS_RENAMEAT_ALT_SIZE               /* 64 */ + \
1892         \
1893         /* sysset_t[2] - System Calls [65 - 96] */ \
1894         MSG_SYS_UNLINKAT_ALT_SIZE               /* 65 */ + \
1895         MSG_SYS_FSTATAT_ALT_SIZE                /* 66 */ + \
1896         MSG_SYS_FSTATAT64_ALT_SIZE              /* 67 */ + \
1897         MSG_SYS_OPENAT_ALT_SIZE                 /* 68 */ + \
1898         MSG_SYS_OPENAT64_ALT_SIZE               /* 69 */ + \
1899         MSG_SYS_TASKSYS_ALT_SIZE                /* 70 */ + \
1900         MSG_SYS_ACCTCTL_ALT_SIZE                /* 71 */ + \
1901         MSG_SYS_EXACCTSYS_ALT_SIZE              /* 72 */ + \
1902         MSG_SYS_GETPAGESIZES_ALT_SIZE           /* 73 */ + \
1903         MSG_SYS_RCTLSYS_ALT_SIZE                /* 74 */ + \
1904         MSG_SYS_SIDSYS_ALT_SIZE                 /* 75 */ + \
1905         MSG_SYS_76_SIZE                         /* 76 (unused) */ + \
1906         MSG_SYS_LWP_PARK_ALT_SIZE               /* 77 */ + \
1907         MSG_SYS_SENDFILEV_ALT_SIZE              /* 78 */ + \
1908         MSG_SYS_RMDIR_ALT_SIZE                  /* 79 */ + \
1909         MSG_SYS_MKDIR_ALT_SIZE                  /* 80 */ + \
1910         MSG_SYS_GETDENTS_ALT_SIZE               /* 81 */ + \
1911         MSG_SYS_PRIVSYS_ALT_SIZE                /* 82 */ + \
1912         MSG_SYS_UCREDSYS_ALT_SIZE               /* 83 */ + \
1913         MSG_SYS_SYSFS_ALT_SIZE                  /* 84 */ + \
1914         MSG_SYS_GETMSG_ALT_SIZE                 /* 85 */ + \
1915         MSG_SYS_PUTMSG_ALT_SIZE                 /* 86 */ + \
1916         MSG_SYS_87_SIZE                         /* 87 (unused) */ + \
1917         MSG_SYS_LSTAT_ALT_SIZE                  /* 88 */ + \
1918         MSG_SYS_SYMLINK_ALT_SIZE                /* 89 */ + \
1919         MSG_SYS_READLINK_ALT_SIZE               /* 90 */ + \
1920         MSG_SYS_SETGROUPS_ALT_SIZE              /* 91 */ + \
1921         MSG_SYS_GETGROUPS_ALT_SIZE              /* 92 */ + \
1922         MSG_SYS_FCHMOD_ALT_SIZE                 /* 93 */ + \
1923         MSG_SYS_FCHOWN_ALT_SIZE                 /* 94 */ + \
1924         MSG_SYS_SIGPROCMASK_ALT_SIZE            /* 95 */ + \
1925         MSG_SYS_SIGSUSPEND_ALT_SIZE             /* 96 */ + \
1926         \
1927         /* sysset_t[3] - System Calls [97 - 128] */ \
1928         MSG_SYS_SIGALTSTACK_ALT_SIZE            /* 97 */ + \
1929         MSG_SYS_SIGACTION_ALT_SIZE              /* 98 */ + \
1930         MSG_SYS_SIGPENDING_ALT_SIZE             /* 99 */ + \
1931         MSG_SYS_CONTEXT_ALT_SIZE                /* 100 */ + \
1932         MSG_SYS_101_SIZE                        /* 101 (unused) */ + \
1933         MSG_SYS_102_SIZE                        /* 102 (unused) */ + \
1934         MSG_SYS_STATVFS_ALT_SIZE                /* 103 */ + \
1935         MSG_SYS_FSTATVFS_ALT_SIZE               /* 104 */ + \
1936         MSG_SYS_GETLOADAVG_ALT_SIZE             /* 105 */ + \
1937         MSG_SYS_NFSSYS_ALT_SIZE                 /* 106 */ + \
1938         MSG_SYS_WAITID_ALT_SIZE                 /* 107 */ + \
1939         MSG_SYS_SIGSENDSYS_ALT_SIZE             /* 108 */ + \
1940         MSG_SYS_HRTSYS_ALT_SIZE                 /* 109 */ + \
1941         MSG_SYS_UTIMESYS_ALT_SIZE               /* 110 */ + \
1942         MSG_SYS_SIGRESEND_ALT_SIZE              /* 111 */ + \
1943         MSG_SYS_PRIOCNTLSYS_ALT_SIZE            /* 112 */ + \
1944         MSG_SYS_PATHCONF_ALT_SIZE               /* 113 */ + \
1945         MSG_SYS_MINCORE_ALT_SIZE                /* 114 */ + \
1946         MSG_SYS_MMAP_ALT_SIZE                   /* 115 */ + \
1947         MSG_SYS_MPROTECT_ALT_SIZE               /* 116 */ + \
1948         MSG_SYS_MUNMAP_ALT_SIZE                 /* 117 */ + \
1949         MSG_SYS_FPATHCONF_ALT_SIZE              /* 118 */ + \
1950         MSG_SYS_VFORK_ALT_SIZE                  /* 119 */ + \
1951         MSG_SYS_FCHDIR_ALT_SIZE                 /* 120 */ + \
1952         MSG_SYS_READV_ALT_SIZE                  /* 121 */ + \
1953         MSG_SYS_WRITEV_ALT_SIZE                 /* 122 */ + \
1954         MSG_SYS_123_SIZE                        /* 123 (unused) */ + \
1955         MSG_SYS_124_SIZE                        /* 124 (unused) */ + \
1956         MSG_SYS_125_SIZE                        /* 125 (unused) */ + \
1957         MSG_SYS_126_SIZE                        /* 126 (unused) */ + \
1958         MSG_SYS_MMAPOBJ_ALT_SIZE                /* 127 */ + \
1959         MSG_SYS_SETRLIMIT_ALT_SIZE              /* 128 */ + \
1960         \
1961         /* sysset_t[4] - System Calls [129 - 160] */ \
1962         MSG_SYS_GETRLIMIT_ALT_SIZE              /* 129 */ + \
1963         MSG_SYS_LCHOWN_ALT_SIZE                 /* 130 */ + \
1964         MSG_SYS_MEMCNTL_ALT_SIZE                /* 131 */ + \
1965         MSG_SYS_GETPMSG_ALT_SIZE                /* 132 */ + \
1966         MSG_SYS_PUTPMSG_ALT_SIZE                /* 133 */ + \
1967         MSG_SYS_RENAME_ALT_SIZE                 /* 134 */ + \
1968         MSG_SYS_UNAME_ALT_SIZE                  /* 135 */ + \
1969         MSG_SYS_SETEGID_ALT_SIZE                /* 136 */ + \
1970         MSG_SYS_SYSCONFIG_ALT_SIZE              /* 137 */ + \
1971         MSG_SYS_ADJTIME_ALT_SIZE                /* 138 */ + \
1972         MSG_SYS_SYSTEMINFO_ALT_SIZE             /* 139 */ + \
1973         MSG_SYS_SHAREFS_ALT_SIZE                /* 140 */ + \
1974         MSG_SYS_SETEUID_ALT_SIZE                /* 141 */ + \
1975         MSG_SYS_FORKSYS_ALT_SIZE                /* 142 */ + \
1976         MSG_SYS_143_SIZE                        /* 143 (unused) */ + \
1977         MSG_SYS_SIGTIMEDWAIT_ALT_SIZE           /* 144 */ + \
1978         MSG_SYS_LWP_INFO_ALT_SIZE               /* 145 */ + \
1979         MSG_SYS_YIELD_ALT_SIZE                  /* 146 */ + \
1980         MSG_SYS_147_SIZE                        /* 147 (unused) */ + \
1981         MSG_SYS_LWP_SEMA_POST_ALT_SIZE          /* 148 */ + \
1982         MSG_SYS_LWP_SEMA_TRYWAIT_ALT_SIZE       /* 149 */ + \
1983         MSG_SYS_LWP_DETACH_ALT_SIZE             /* 150 */ + \
1984         MSG_SYS_CORECTL_ALT_SIZE                /* 151 */ + \
1985         MSG_SYS_MODCTL_ALT_SIZE                 /* 152 */ + \
1986         MSG_SYS_FCHROOT_ALT_SIZE                /* 153 */ + \
1987         MSG_SYS_154_SIZE                        /* 154 (unused) */ + \
1988         MSG_SYS_VHANGUP_ALT_SIZE                /* 155 */ + \
1989         MSG_SYS_GETTIMEOFDAY_ALT_SIZE           /* 156 */ + \
1990         MSG_SYS_GETITIMER_ALT_SIZE              /* 157 */ + \
1991         MSG_SYS_SETITIMER_ALT_SIZE              /* 158 */ + \
1992         MSG_SYS_LWP_CREATE_ALT_SIZE             /* 159 */ + \
1993         MSG_SYS_LWP_EXIT_ALT_SIZE               /* 160 */ + \
1994         \
1995         /* sysset_t[5] - System Calls [161 - 192] */ \
1996         MSG_SYS_LWP_SUSPEND_ALT_SIZE            /* 161 */ + \
1997         MSG_SYS_LWP_CONTINUE_ALT_SIZE           /* 162 */ + \
1998         MSG_SYS_LWP_KILL_ALT_SIZE               /* 163 */ + \
1999         MSG_SYS_LWP_SELF_ALT_SIZE               /* 164 */ + \
2000         MSG_SYS_LWP_SIGMASK_ALT_SIZE            /* 165 */ + \
2001         MSG_SYS_LWP_PRIVATE_ALT_SIZE            /* 166 */ + \
2002         MSG_SYS_LWP_WAIT_ALT_SIZE               /* 167 */ + \
2003         MSG_SYS_LWP_MUTEX_WAKEUP_ALT_SIZE       /* 168 */ + \
2004         MSG_SYS_169_SIZE                        /* 169 (unused) */ + \
2005         MSG_SYS_LWP_COND_WAIT_ALT_SIZE          /* 170 */ + \
2006         MSG_SYS_LWP_COND_SIGNAL_ALT_SIZE        /* 171 */ + \
2007         MSG_SYS_LWP_COND_BROADCAST_ALT_SIZE     /* 172 */ + \
2008         MSG_SYS_PREAD_ALT_SIZE                  /* 173 */ + \
2009         MSG_SYS_PWRITE_ALT_SIZE                 /* 174 */ + \
2010         MSG_SYS_LLSEEK_ALT_SIZE                 /* 175 */ + \
2011         MSG_SYS_INST_SYNC_ALT_SIZE              /* 176 */ + \
2012         MSG_SYS_BRAND_ALT_SIZE                  /* 177 */ + \
2013         MSG_SYS_KAIO_ALT_SIZE                   /* 178 */ + \
2014         MSG_SYS_CPC_ALT_SIZE                    /* 179 */ + \
2015         MSG_SYS_LGRPSYS_ALT_SIZE                /* 180 */ + \
2016         MSG_SYS_RUSAGESYS_ALT_SIZE              /* 181 */ + \
2017         MSG_SYS_PORT_ALT_SIZE                   /* 182 */ + \
2018         MSG_SYS_POLLSYS_ALT_SIZE                /* 183 */ + \
2019         MSG_SYS_LABELSYS_ALT_SIZE               /* 184 */ + \
2020         MSG_SYS_ACL_ALT_SIZE                    /* 185 */ + \
2021         MSG_SYS_AUDITSYS_ALT_SIZE               /* 186 */ + \
2022         MSG_SYS_PROCESSOR_BIND_ALT_SIZE         /* 187 */ + \
2023         MSG_SYS_PROCESSOR_INFO_ALT_SIZE         /* 188 */ + \
2024         MSG_SYS_P_ONLINE_ALT_SIZE               /* 189 */ + \
2025         MSG_SYS_SIGQUEUE_ALT_SIZE               /* 190 */ + \
2026         MSG_SYS_CLOCK_GETTIME_ALT_SIZE          /* 191 */ + \
2027         MSG_SYS_CLOCK_SETTIME_ALT_SIZE          /* 192 */ + \
2028         \
2029         /* sysset_t[6] - System Calls [193 - 224] */ \
2030         MSG_SYS_CLOCK_GETRES_ALT_SIZE           /* 193 */ + \
2031         MSG_SYS_TIMER_CREATE_ALT_SIZE           /* 194 */ + \
2032         MSG_SYS_TIMER_DELETE_ALT_SIZE           /* 195 */ + \
2033         MSG_SYS_TIMER_SETTIME_ALT_SIZE          /* 196 */ + \
2034         MSG_SYS_TIMER_GETTIME_ALT_SIZE          /* 197 */ + \
2035         MSG_SYS_TIMER_GETOVERRUN_ALT_SIZE       /* 198 */ + \
2036         MSG_SYS_NANOSLEEP_ALT_SIZE              /* 199 */ + \
2037         MSG_SYS_FACL_ALT_SIZE                   /* 200 */ + \
2038         MSG_SYS_DOOR_ALT_SIZE                   /* 201 */ + \
2039         MSG_SYS_SETREUID_ALT_SIZE               /* 202 */ + \
2040         MSG_SYS_SETREGID_ALT_SIZE               /* 203 */ + \
2041         MSG_SYS_INSTALL_UTRAP_ALT_SIZE          /* 204 */ + \
2042         MSG_SYS_SIGNOTIFY_ALT_SIZE              /* 205 */ + \
2043         MSG_SYS_SCHEDCTL_ALT_SIZE               /* 206 */ + \
2044         MSG_SYS_PSET_ALT_SIZE                   /* 207 */ + \
2045         MSG_SYS_SPARC_UTRAP_INSTALL_ALT_SIZE    /* 208 */ + \
2046         MSG_SYS_RESOLVEPATH_ALT_SIZE            /* 209 */ + \
2047         MSG_SYS_LWP_MUTEX_TIMEDLOCK_ALT_SIZE    /* 210 */ + \
2048         MSG_SYS_LWP_SEMA_TIMEDWAIT_ALT_SIZE     /* 211 */ + \
2049         MSG_SYS_LWP_RWLOCK_SYS_ALT_SIZE         /* 212 */ + \
2050         MSG_SYS_GETDENTS64_ALT_SIZE             /* 213 */ + \
2051         MSG_SYS_MMAP64_ALT_SIZE                 /* 214 */ + \
2052         MSG_SYS_STAT64_ALT_SIZE                 /* 215 */ + \
2053         MSG_SYS_LSTAT64_ALT_SIZE                /* 216 */ + \
2054         MSG_SYS_FSTAT64_ALT_SIZE                /* 217 */ + \
2055         MSG_SYS_STATVFS64_ALT_SIZE              /* 218 */ + \
2056         MSG_SYS_FSTATVFS64_ALT_SIZE             /* 219 */ + \
2057         MSG_SYS_SETRLIMIT64_ALT_SIZE            /* 220 */ + \
2058         MSG_SYS_GETRLIMIT64_ALT_SIZE            /* 221 */ + \
2059         MSG_SYS_PREAD64_ALT_SIZE                /* 222 */ + \
2060         MSG_SYS_PWRITE64_ALT_SIZE               /* 223 */ + \
2061         MSG_SYS_224_SIZE                        /* 224 (unused) */ + \
2062         \
2063         /* sysset_t[7] - System Calls [225 - 256] */ \
2064         MSG_SYS_OPEN64_ALT_SIZE                 /* 225 */ + \
2065         MSG_SYS_RPCSYS_ALT_SIZE                 /* 226 */ + \
2066         MSG_SYS_ZONE_ALT_SIZE                   /* 227 */ + \
2067         MSG_SYS_AUTOFSSYS_ALT_SIZE              /* 228 */ + \
2068         MSG_SYS_GETCWD_ALT_SIZE                 /* 229 */ + \
2069         MSG_SYS_SO_SOCKET_ALT_SIZE              /* 230 */ + \
2070         MSG_SYS_SO_SOCKETPAIR_ALT_SIZE          /* 231 */ + \
2071         MSG_SYS_BIND_ALT_SIZE                   /* 232 */ + \
2072         MSG_SYS_LISTEN_ALT_SIZE                 /* 233 */ + \
2073         MSG_SYS_ACCEPT_ALT_SIZE                 /* 234 */ + \
2074         MSG_SYS_CONNECT_ALT_SIZE                /* 235 */ + \
2075         MSG_SYS_SHUTDOWN_ALT_SIZE               /* 236 */ + \
2076         MSG_SYS_RECV_ALT_SIZE                   /* 237 */ + \
2077         MSG_SYS_RECVFROM_ALT_SIZE               /* 238 */ + \
2078         MSG_SYS_RECVMSG_ALT_SIZE                /* 239 */ + \
2079         MSG_SYS_SEND_ALT_SIZE                   /* 240 */ + \
2080         MSG_SYS_SENDMSG_ALT_SIZE                /* 241 */ + \
2081         MSG_SYS_SENDTO_ALT_SIZE                 /* 242 */ + \
2082         MSG_SYS_GETPEERNAME_ALT_SIZE            /* 243 */ + \
2083         MSG_SYS_GETSOCKNAME_ALT_SIZE            /* 244 */ + \
2084         MSG_SYS_GETSOCKOPT_ALT_SIZE             /* 245 */ + \
2085         MSG_SYS_SETSOCKOPT_ALT_SIZE             /* 246 */ + \
2086         MSG_SYS_SOCKCONFIG_ALT_SIZE             /* 247 */ + \
2087         MSG_SYS_NTP_GETTIME_ALT_SIZE            /* 248 */ + \
2088         MSG_SYS_NTP_ADJTIME_ALT_SIZE            /* 249 */ + \
2089         MSG_SYS_LWP_MUTEX_UNLOCK_ALT_SIZE       /* 250 */ + \
2090         MSG_SYS_LWP_MUTEX_TRYLOCK_ALT_SIZE      /* 251 */ + \
2091         MSG_SYS_LWP_MUTEX_REGISTER_ALT_SIZE     /* 252 */ + \
2092         MSG_SYS_CLADM_ALT_SIZE                  /* 253 */ + \
2093         MSG_SYS_UUCOPY_ALT_SIZE                 /* 254 */ + \
2094         MSG_SYS_UMOUNT2_ALT_SIZE                /* 255 */ + \
2095         3                                       /* 256 (unused) */ + \
2096         \
2097         /* sysset_t[8] - System Calls [257 - 288] */ \
2098         (32 * 3)                                /* 257 - 288 (unused) */ + \
2099         \
2100         /* sysset_t[9] - System Calls [289 - 320] */ \
2101         (32 * 3)                                /* 289 - 320 (unused) */ + \
2102         \
2103         /* sysset_t[10] - System Calls [321 - 352] */ \
2104         (32 * 3)                                /* 321 - 352 (unused) */ + \
2105         \
2106         /* sysset_t[11] - System Calls [353 - 384] */ \
2107         (32 * 3)                                /* 353 - 384 (unused) */ + \
2108         \
2109         /* sysset_t[12] - System Calls [385 - 416] */ \
2110         (32 * 3)                                /* 385 - 416 (unused) */ + \
2111         \
2112         /* sysset_t[13] - System Calls [417 - 448] */ \
2113         (32 * 3)                                /* 417 - 448 (unused) */ + \
2114         \
2115         /* sysset_t[14] - System Calls [449 - 480] */ \
2116         (32 * 3)                                /* 449 - 480 (unused) */ + \
2117         \
2118         /* sysset_t[15] - System Calls [481 - 512] */ \
2119         (32 * 3)                                /* 481 - 512 (unused) */ + \
2120         \
2121         CONV_INV_BUFSIZE        + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
2122 
2123 /*
2124  * Ensure that Conv_cnote_sysset_buf_t is large enough:
2125  *
2126  * SYSSET_FLAGSZ is the real minimum size of the buffer required by
2127  * conv_cnote_sysset(). However, Conv_cnote_sysset_buf_t
2128  * uses CONV_CNOTE_SYSSET_BUFSIZE to set the buffer size. We do
2129  * things this way because the definition of SYSSET_FLAGSZ uses information
2130  * that is not available in the environment of other programs
2131  * that include the conv.h header file.
2132  */
2133 #if (CONV_CNOTE_SYSSET_BUFSIZE != SYSSET_FLAGSZ) && !defined(__lint)
2134 #define REPORT_BUFSIZE SYSSET_FLAGSZ
2135 #include "report_bufsize.h"
2136 #error "CONV_CNOTE_SYSSET_BUFSIZE does not match SYSSET_FLAGSZ"
2137 #endif
2138 
2139 const char *
2140 conv_cnote_sysset(uint32_t *maskarr, int n_mask,
2141     Conv_fmt_flags_t fmt_flags, Conv_cnote_sysset_buf_t *cnote_sysset_buf)
2142 {
2143 #define N_MASK 16
2144 
2145         static const Val_desc vda0[] = {        /* System Calls [1 - 32] */
2146                 { 0x00000001,   MSG_SYS_EXIT_ALT },
2147                 { 0x00000002,   MSG_SYS_2 },
2148                 { 0x00000004,   MSG_SYS_READ_ALT },
2149                 { 0x00000008,   MSG_SYS_WRITE_ALT },
2150                 { 0x00000010,   MSG_SYS_OPEN_ALT },
2151                 { 0x00000020,   MSG_SYS_CLOSE_ALT },
2152                 { 0x00000040,   MSG_SYS_7 },
2153                 { 0x00000080,   MSG_SYS_8 },
2154                 { 0x00000100,   MSG_SYS_LINK_ALT },
2155                 { 0x00000200,   MSG_SYS_UNLINK_ALT },
2156                 { 0x00000400,   MSG_SYS_11 },
2157                 { 0x00000800,   MSG_SYS_CHDIR_ALT },
2158                 { 0x00001000,   MSG_SYS_TIME_ALT },
2159                 { 0x00002000,   MSG_SYS_MKNOD_ALT },
2160                 { 0x00004000,   MSG_SYS_CHMOD_ALT },
2161                 { 0x00008000,   MSG_SYS_CHOWN_ALT },
2162                 { 0x00010000,   MSG_SYS_BRK_ALT },
2163                 { 0x00020000,   MSG_SYS_STAT_ALT },
2164                 { 0x00040000,   MSG_SYS_LSEEK_ALT },
2165                 { 0x00080000,   MSG_SYS_GETPID_ALT },
2166                 { 0x00100000,   MSG_SYS_MOUNT_ALT },
2167                 { 0x00200000,   MSG_SYS_22 },
2168                 { 0x00400000,   MSG_SYS_SETUID_ALT },
2169                 { 0x00800000,   MSG_SYS_GETUID_ALT },
2170                 { 0x01000000,   MSG_SYS_STIME_ALT },
2171                 { 0x02000000,   MSG_SYS_PCSAMPLE_ALT },
2172                 { 0x04000000,   MSG_SYS_ALARM_ALT },
2173                 { 0x08000000,   MSG_SYS_FSTAT_ALT },
2174                 { 0x10000000,   MSG_SYS_PAUSE_ALT },
2175                 { 0x20000000,   MSG_SYS_30 },
2176                 { 0x40000000,   MSG_SYS_STTY_ALT },
2177                 { 0x80000000,   MSG_SYS_GTTY_ALT },
2178                 { 0,            0 }
2179         };
2180         static const Val_desc vda1[] = {        /* System Calls [33 - 64] */
2181                 { 0x00000001,   MSG_SYS_ACCESS_ALT },
2182                 { 0x00000002,   MSG_SYS_NICE_ALT },
2183                 { 0x00000004,   MSG_SYS_STATFS_ALT },
2184                 { 0x00000008,   MSG_SYS_SYNC_ALT },
2185                 { 0x00000010,   MSG_SYS_KILL_ALT },
2186                 { 0x00000020,   MSG_SYS_FSTATFS_ALT },
2187                 { 0x00000040,   MSG_SYS_PGRPSYS_ALT },
2188                 { 0x00000080,   MSG_SYS_UUCOPYSTR_ALT },
2189                 { 0x00000100,   MSG_SYS_41 },
2190                 { 0x00000200,   MSG_SYS_PIPE_ALT },
2191                 { 0x00000400,   MSG_SYS_TIMES_ALT },
2192                 { 0x00000800,   MSG_SYS_PROFIL_ALT },
2193                 { 0x00001000,   MSG_SYS_FACCESSAT_ALT },
2194                 { 0x00002000,   MSG_SYS_SETGID_ALT },
2195                 { 0x00004000,   MSG_SYS_GETGID_ALT },
2196                 { 0x00008000,   MSG_SYS_48 },
2197                 { 0x00010000,   MSG_SYS_MSGSYS_ALT },
2198                 { 0x00020000,   MSG_SYS_SYSI86_ALT },
2199                 { 0x00040000,   MSG_SYS_ACCT_ALT },
2200                 { 0x00080000,   MSG_SYS_SHMSYS_ALT },
2201                 { 0x00100000,   MSG_SYS_SEMSYS_ALT },
2202                 { 0x00200000,   MSG_SYS_IOCTL_ALT },
2203                 { 0x00400000,   MSG_SYS_UADMIN_ALT },
2204                 { 0x00800000,   MSG_SYS_FCHOWNAT_ALT },
2205                 { 0x01000000,   MSG_SYS_UTSSYS_ALT },
2206                 { 0x0200000,    MSG_SYS_FDSYNC_ALT },
2207                 { 0x04000000,   MSG_SYS_EXECVE_ALT },
2208                 { 0x08000000,   MSG_SYS_UMASK_ALT },
2209                 { 0x10000000,   MSG_SYS_CHROOT_ALT },
2210                 { 0x20000000,   MSG_SYS_FCNTL_ALT },
2211                 { 0x40000000,   MSG_SYS_ULIMIT_ALT },
2212                 { 0x80000000,   MSG_SYS_RENAMEAT_ALT },
2213                 { 0,            0 }
2214         };
2215         static const Val_desc vda2[] = {        /* System Calls [65 - 96] */
2216                 { 0x00000001,   MSG_SYS_UNLINKAT_ALT },
2217                 { 0x00000002,   MSG_SYS_FSTATAT_ALT },
2218                 { 0x00000004,   MSG_SYS_FSTATAT64_ALT },
2219                 { 0x00000008,   MSG_SYS_OPENAT_ALT },
2220                 { 0x00000010,   MSG_SYS_OPENAT64_ALT },
2221                 { 0x00000020,   MSG_SYS_TASKSYS_ALT },
2222                 { 0x00000040,   MSG_SYS_ACCTCTL_ALT },
2223                 { 0x00000080,   MSG_SYS_EXACCTSYS_ALT },
2224                 { 0x00000100,   MSG_SYS_GETPAGESIZES_ALT },
2225                 { 0x00000200,   MSG_SYS_RCTLSYS_ALT },
2226                 { 0x00000400,   MSG_SYS_SIDSYS_ALT },
2227                 { 0x00000800,   MSG_SYS_76 },
2228                 { 0x00001000,   MSG_SYS_LWP_PARK_ALT },
2229                 { 0x00002000,   MSG_SYS_SENDFILEV_ALT },
2230                 { 0x00004000,   MSG_SYS_RMDIR_ALT },
2231                 { 0x00008000,   MSG_SYS_MKDIR_ALT },
2232                 { 0x00010000,   MSG_SYS_GETDENTS_ALT },
2233                 { 0x00020000,   MSG_SYS_PRIVSYS_ALT },
2234                 { 0x00040000,   MSG_SYS_UCREDSYS_ALT },
2235                 { 0x00080000,   MSG_SYS_SYSFS_ALT },
2236                 { 0x00100000,   MSG_SYS_GETMSG_ALT },
2237                 { 0x00200000,   MSG_SYS_PUTMSG_ALT },
2238                 { 0x00400000,   MSG_SYS_87 },
2239                 { 0x00800000,   MSG_SYS_LSTAT_ALT },
2240                 { 0x01000000,   MSG_SYS_SYMLINK_ALT },
2241                 { 0x02000000,   MSG_SYS_READLINK_ALT },
2242                 { 0x04000000,   MSG_SYS_SETGROUPS_ALT },
2243                 { 0x08000000,   MSG_SYS_GETGROUPS_ALT },
2244                 { 0x10000000,   MSG_SYS_FCHMOD_ALT },
2245                 { 0x20000000,   MSG_SYS_FCHOWN_ALT },
2246                 { 0x40000000,   MSG_SYS_SIGPROCMASK_ALT },
2247                 { 0x80000000,   MSG_SYS_SIGSUSPEND_ALT },
2248                 { 0,            0 }
2249         };
2250         static const Val_desc vda3[] = {        /* System Calls [97 - 128] */
2251                 { 0x00000001,   MSG_SYS_SIGALTSTACK_ALT },
2252                 { 0x00000002,   MSG_SYS_SIGACTION_ALT },
2253                 { 0x00000004,   MSG_SYS_SIGPENDING_ALT },
2254                 { 0x00000008,   MSG_SYS_CONTEXT_ALT },
2255                 { 0x00000010,   MSG_SYS_101 },
2256                 { 0x00000020,   MSG_SYS_102 },
2257                 { 0x00000040,   MSG_SYS_STATVFS_ALT },
2258                 { 0x00000080,   MSG_SYS_FSTATVFS_ALT },
2259                 { 0x00000100,   MSG_SYS_GETLOADAVG_ALT },
2260                 { 0x00000200,   MSG_SYS_NFSSYS_ALT },
2261                 { 0x00000400,   MSG_SYS_WAITID_ALT },
2262                 { 0x00000800,   MSG_SYS_SIGSENDSYS_ALT },
2263                 { 0x00001000,   MSG_SYS_HRTSYS_ALT },
2264                 { 0x00002000,   MSG_SYS_UTIMESYS_ALT },
2265                 { 0x00004000,   MSG_SYS_SIGRESEND_ALT },
2266                 { 0x00008000,   MSG_SYS_PRIOCNTLSYS_ALT },
2267                 { 0x00010000,   MSG_SYS_PATHCONF_ALT },
2268                 { 0x00020000,   MSG_SYS_MINCORE_ALT },
2269                 { 0x00040000,   MSG_SYS_MMAP_ALT },
2270                 { 0x00080000,   MSG_SYS_MPROTECT_ALT },
2271                 { 0x00100000,   MSG_SYS_MUNMAP_ALT },
2272                 { 0x00200000,   MSG_SYS_FPATHCONF_ALT },
2273                 { 0x00400000,   MSG_SYS_VFORK_ALT },
2274                 { 0x00800000,   MSG_SYS_FCHDIR_ALT },
2275                 { 0x01000000,   MSG_SYS_READV_ALT },
2276                 { 0x02000000,   MSG_SYS_WRITEV_ALT },
2277                 { 0x04000000,   MSG_SYS_123 },
2278                 { 0x08000000,   MSG_SYS_124 },
2279                 { 0x10000000,   MSG_SYS_125 },
2280                 { 0x20000000,   MSG_SYS_126 },
2281                 { 0x40000000,   MSG_SYS_MMAPOBJ_ALT },
2282                 { 0x80000000,   MSG_SYS_SETRLIMIT_ALT },
2283                 { 0,                    0 }
2284         };
2285         static const Val_desc vda4[] = {        /* System Calls [129 - 160] */
2286                 { 0x00000001,   MSG_SYS_GETRLIMIT_ALT },
2287                 { 0x00000002,   MSG_SYS_LCHOWN_ALT },
2288                 { 0x00000004,   MSG_SYS_MEMCNTL_ALT },
2289                 { 0x00000008,   MSG_SYS_GETPMSG_ALT },
2290                 { 0x00000010,   MSG_SYS_PUTPMSG_ALT },
2291                 { 0x00000020,   MSG_SYS_RENAME_ALT },
2292                 { 0x00000040,   MSG_SYS_UNAME_ALT },
2293                 { 0x00000080,   MSG_SYS_SETEGID_ALT },
2294                 { 0x00000100,   MSG_SYS_SYSCONFIG_ALT },
2295                 { 0x00000200,   MSG_SYS_ADJTIME_ALT },
2296                 { 0x00000400,   MSG_SYS_SYSTEMINFO_ALT },
2297                 { 0x00000800,   MSG_SYS_SHAREFS_ALT },
2298                 { 0x00001000,   MSG_SYS_SETEUID_ALT },
2299                 { 0x00002000,   MSG_SYS_FORKSYS_ALT },
2300                 { 0x00004000,   MSG_SYS_143 },
2301                 { 0x00008000,   MSG_SYS_SIGTIMEDWAIT_ALT },
2302                 { 0x00010000,   MSG_SYS_LWP_INFO_ALT },
2303                 { 0x00020000,   MSG_SYS_YIELD_ALT },
2304                 { 0x00040000,   MSG_SYS_147 },
2305                 { 0x00080000,   MSG_SYS_LWP_SEMA_POST_ALT },
2306                 { 0x00100000,   MSG_SYS_LWP_SEMA_TRYWAIT_ALT },
2307                 { 0x00200000,   MSG_SYS_LWP_DETACH_ALT },
2308                 { 0x00400000,   MSG_SYS_CORECTL_ALT },
2309                 { 0x00800000,   MSG_SYS_MODCTL_ALT },
2310                 { 0x01000000,   MSG_SYS_FCHROOT_ALT },
2311                 { 0x02000000,   MSG_SYS_154 },
2312                 { 0x04000000,   MSG_SYS_VHANGUP_ALT },
2313                 { 0x08000000,   MSG_SYS_GETTIMEOFDAY_ALT },
2314                 { 0x10000000,   MSG_SYS_GETITIMER_ALT },
2315                 { 0x20000000,   MSG_SYS_SETITIMER_ALT },
2316                 { 0x40000000,   MSG_SYS_LWP_CREATE_ALT },
2317                 { 0x80000000,   MSG_SYS_LWP_EXIT_ALT },
2318                 { 0,            0 }
2319         };
2320         static const Val_desc vda5[] = {        /* System Calls [161 - 192] */
2321                 { 0x00000001,   MSG_SYS_LWP_SUSPEND_ALT },
2322                 { 0x00000002,   MSG_SYS_LWP_CONTINUE_ALT },
2323                 { 0x00000004,   MSG_SYS_LWP_KILL_ALT },
2324                 { 0x00000008,   MSG_SYS_LWP_SELF_ALT },
2325                 { 0x00000010,   MSG_SYS_LWP_SIGMASK_ALT },
2326                 { 0x00000020,   MSG_SYS_LWP_PRIVATE_ALT },
2327                 { 0x00000040,   MSG_SYS_LWP_WAIT_ALT },
2328                 { 0x00000080,   MSG_SYS_LWP_MUTEX_WAKEUP_ALT },
2329                 { 0x00000100,   MSG_SYS_169 },
2330                 { 0x00000200,   MSG_SYS_LWP_COND_WAIT_ALT },
2331                 { 0x00000400,   MSG_SYS_LWP_COND_SIGNAL_ALT },
2332                 { 0x00000800,   MSG_SYS_LWP_COND_BROADCAST_ALT },
2333                 { 0x00001000,   MSG_SYS_PREAD_ALT },
2334                 { 0x00002000,   MSG_SYS_PWRITE_ALT },
2335                 { 0x00004000,   MSG_SYS_LLSEEK_ALT },
2336                 { 0x00008000,   MSG_SYS_INST_SYNC_ALT },
2337                 { 0x00010000,   MSG_SYS_BRAND_ALT },
2338                 { 0x00020000,   MSG_SYS_KAIO_ALT },
2339                 { 0x00040000,   MSG_SYS_CPC_ALT },
2340                 { 0x00080000,   MSG_SYS_LGRPSYS_ALT },
2341                 { 0x00100000,   MSG_SYS_RUSAGESYS_ALT },
2342                 { 0x00200000,   MSG_SYS_PORT_ALT },
2343                 { 0x00400000,   MSG_SYS_POLLSYS_ALT },
2344                 { 0x00800000,   MSG_SYS_LABELSYS_ALT },
2345                 { 0x01000000,   MSG_SYS_ACL_ALT },
2346                 { 0x02000000,   MSG_SYS_AUDITSYS_ALT },
2347                 { 0x04000000,   MSG_SYS_PROCESSOR_BIND_ALT },
2348                 { 0x08000000,   MSG_SYS_PROCESSOR_INFO_ALT },
2349                 { 0x10000000,   MSG_SYS_P_ONLINE_ALT },
2350                 { 0x20000000,   MSG_SYS_SIGQUEUE_ALT },
2351                 { 0x40000000,   MSG_SYS_CLOCK_GETTIME_ALT },
2352                 { 0x80000000,   MSG_SYS_CLOCK_SETTIME_ALT },
2353                 { 0,            0 }
2354         };
2355         static const Val_desc vda6[] = {        /* System Calls [193 - 224] */
2356                 { 0x00000001,   MSG_SYS_CLOCK_GETRES_ALT },
2357                 { 0x00000002,   MSG_SYS_TIMER_CREATE_ALT },
2358                 { 0x00000004,   MSG_SYS_TIMER_DELETE_ALT },
2359                 { 0x00000008,   MSG_SYS_TIMER_SETTIME_ALT },
2360                 { 0x00000010,   MSG_SYS_TIMER_GETTIME_ALT },
2361                 { 0x00000020,   MSG_SYS_TIMER_GETOVERRUN_ALT },
2362                 { 0x00000040,   MSG_SYS_NANOSLEEP_ALT },
2363                 { 0x00000080,   MSG_SYS_FACL_ALT },
2364                 { 0x00000100,   MSG_SYS_DOOR_ALT },
2365                 { 0x00000200,   MSG_SYS_SETREUID_ALT },
2366                 { 0x00000400,   MSG_SYS_SETREGID_ALT },
2367                 { 0x00000800,   MSG_SYS_INSTALL_UTRAP_ALT },
2368                 { 0x00001000,   MSG_SYS_SIGNOTIFY_ALT },
2369                 { 0x00002000,   MSG_SYS_SCHEDCTL_ALT },
2370                 { 0x00004000,   MSG_SYS_PSET_ALT },
2371                 { 0x00008000,   MSG_SYS_SPARC_UTRAP_INSTALL_ALT },
2372                 { 0x00010000,   MSG_SYS_RESOLVEPATH_ALT },
2373                 { 0x00020000,   MSG_SYS_LWP_MUTEX_TIMEDLOCK_ALT },
2374                 { 0x00040000,   MSG_SYS_LWP_SEMA_TIMEDWAIT_ALT },
2375                 { 0x00080000,   MSG_SYS_LWP_RWLOCK_SYS_ALT },
2376                 { 0x00100000,   MSG_SYS_GETDENTS64_ALT },
2377                 { 0x00200000,   MSG_SYS_MMAP64_ALT },
2378                 { 0x00400000,   MSG_SYS_STAT64_ALT },
2379                 { 0x00800000,   MSG_SYS_LSTAT64_ALT },
2380                 { 0x01000000,   MSG_SYS_FSTAT64_ALT },
2381                 { 0x02000000,   MSG_SYS_STATVFS64_ALT },
2382                 { 0x04000000,   MSG_SYS_FSTATVFS64_ALT },
2383                 { 0x08000000,   MSG_SYS_SETRLIMIT64_ALT },
2384                 { 0x10000000,   MSG_SYS_GETRLIMIT64_ALT },
2385                 { 0x20000000,   MSG_SYS_PREAD64_ALT },
2386                 { 0x40000000,   MSG_SYS_PWRITE64_ALT },
2387                 { 0x80000000,   MSG_SYS_224 },
2388                 { 0,                    0 }
2389         };
2390         static const Val_desc vda7[] = {        /* System Calls [225 - 256] */
2391                 { 0x00000001,   MSG_SYS_OPEN64_ALT },
2392                 { 0x00000002,   MSG_SYS_RPCSYS_ALT },
2393                 { 0x00000004,   MSG_SYS_ZONE_ALT },
2394                 { 0x00000008,   MSG_SYS_AUTOFSSYS_ALT },
2395                 { 0x00000010,   MSG_SYS_GETCWD_ALT },
2396                 { 0x00000020,   MSG_SYS_SO_SOCKET_ALT },
2397                 { 0x00000040,   MSG_SYS_SO_SOCKETPAIR_ALT },
2398                 { 0x00000080,   MSG_SYS_BIND_ALT },
2399                 { 0x00000100,   MSG_SYS_LISTEN_ALT },
2400                 { 0x00000200,   MSG_SYS_ACCEPT_ALT },
2401                 { 0x00000400,   MSG_SYS_CONNECT_ALT },
2402                 { 0x00000800,   MSG_SYS_SHUTDOWN_ALT },
2403                 { 0x00001000,   MSG_SYS_RECV_ALT },
2404                 { 0x00002000,   MSG_SYS_RECVFROM_ALT },
2405                 { 0x00004000,   MSG_SYS_RECVMSG_ALT },
2406                 { 0x00008000,   MSG_SYS_SEND_ALT },
2407                 { 0x00010000,   MSG_SYS_SENDMSG_ALT },
2408                 { 0x00020000,   MSG_SYS_SENDTO_ALT },
2409                 { 0x00040000,   MSG_SYS_GETPEERNAME_ALT },
2410                 { 0x00080000,   MSG_SYS_GETSOCKNAME_ALT },
2411                 { 0x00100000,   MSG_SYS_GETSOCKOPT_ALT },
2412                 { 0x00200000,   MSG_SYS_SETSOCKOPT_ALT },
2413                 { 0x00400000,   MSG_SYS_SOCKCONFIG_ALT },
2414                 { 0x00800000,   MSG_SYS_NTP_GETTIME_ALT },
2415                 { 0x01000000,   MSG_SYS_NTP_ADJTIME_ALT },
2416                 { 0x02000000,   MSG_SYS_LWP_MUTEX_UNLOCK_ALT },
2417                 { 0x04000000,   MSG_SYS_LWP_MUTEX_TRYLOCK_ALT },
2418                 { 0x08000000,   MSG_SYS_LWP_MUTEX_REGISTER_ALT },
2419                 { 0x10000000,   MSG_SYS_CLADM_ALT },
2420                 { 0x20000000,   MSG_SYS_UUCOPY_ALT },
2421                 { 0x40000000,   MSG_SYS_UMOUNT2_ALT },
2422                 /* 256 (unused) */
2423                 { 0,            0 }
2424         };
2425         static const conv_bitmaskset_desc_t bitmask_desc[N_MASK] = {
2426                 { vda0, 0x00000000 },
2427                 { vda1, 0x00000000 },
2428                 { vda2, 0x00000000 },
2429                 { vda3, 0x00000000 },
2430                 { vda4, 0x00000000 },
2431                 { vda5, 0x00000000 },
2432                 { vda6, 0x00000000 },
2433                 { vda7, 0x80000000 },
2434                 { NULL, 0xffffffff },
2435                 { NULL, 0xffffffff },
2436                 { NULL, 0xffffffff },
2437                 { NULL, 0xffffffff },
2438                 { NULL, 0xffffffff },
2439                 { NULL, 0xffffffff },
2440                 { NULL, 0xffffffff },
2441                 { NULL, 0xffffffff }
2442         };
2443 
2444         if (n_mask > N_MASK)
2445                 n_mask = N_MASK;
2446         return (conv_bitmaskset(maskarr, n_mask, bitmask_desc, fmt_flags,
2447             cnote_sysset_buf->buf, CONV_CNOTE_SYSSET_BUFSIZE));
2448 
2449 #undef N_MASK
2450 }
2451 
2452 const char *
2453 conv_cnote_fileflags(uint32_t fileflags, Conv_fmt_flags_t fmt_flags,
2454     char *buf, size_t bufsize)
2455 {
2456         CONV_EXPN_FIELD_ARG arg = { 0 };
2457 
2458         Val_desc vda[] = {
2459                 { 0x0001,       MSG_PR_O_WRONLY },
2460                 { 0x0002,       MSG_PR_O_RDONLY },
2461                 { 0x200000,     MSG_PR_O_SEARCH },
2462                 { 0x400000,     MSG_PR_O_EXEC },
2463                 { 0x0004,       MSG_PR_O_NDELAY },
2464                 { 0x0008,       MSG_PR_O_APPEND },
2465                 { 0x0010,       MSG_PR_O_SYNC },
2466                 { 0x0040,       MSG_PR_O_DSYNC },
2467                 { 0x0080,       MSG_PR_O_NONBLOCK },
2468                 { 0x0100,       MSG_PR_O_CREAT },
2469                 { 0x0200,       MSG_PR_O_TRUNC },
2470                 { 0x0400,       MSG_PR_O_EXCL },
2471                 { 0x0800,       MSG_PR_O_NOCTTY },
2472                 { 0x4000,       MSG_PR_O_XATTR },
2473                 { 0x8000,       MSG_PR_O_RSYNC },
2474                 { 0x2000,       MSG_PR_O_LARGEFILE },
2475                 { 0x20000,      MSG_PR_O_NOFOLLOW },
2476                 { 0x40000,      MSG_PR_O_NOLINKS },
2477                 { 0, NULL },
2478         };
2479 
2480         arg.oflags = arg.rflags = fileflags;
2481         arg.buf = buf;
2482         arg.bufsize = bufsize;
2483 
2484         switch (fileflags & (0x600003)) {
2485         case 0: /* RDONLY */
2486                 vda[0].v_msg = MSG_PR_O_RDONLY;
2487                 arg.oflags |= 1;
2488                 arg.rflags |= 1;
2489                 break;
2490         case 1: /* WRONLY */
2491         case 2: /* RDWR */
2492         case 0x200000:  /* SEARCH */
2493         case 0x400000:
2494                 /* In isolate, treat these as normal bits */
2495                 break;
2496         default:
2497                 /* More than one bit set in this group, emit numerically */
2498                 arg.oflags &= ~(fileflags & 0x600003);
2499         }
2500 
2501         if (fileflags == 0)
2502                 return (MSG_ORIG(MSG_GBL_ZERO));
2503 
2504         (void) conv_expn_field(&arg, vda, fmt_flags);
2505         return (buf);
2506 }
2507 
2508 const char *
2509 conv_cnote_filemode(uint32_t mode, Conv_fmt_flags_t fmt_flags,
2510     char *buf, size_t bufsize)
2511 {
2512         CONV_EXPN_FIELD_ARG arg = { 0 };
2513         Msg s;
2514 
2515         Val_desc vda[] = {
2516                 { 0x1000,       MSG_S_IFIFO },
2517                 { 0x800,        MSG_S_ISUID },
2518                 { 0x400,        MSG_S_ISGID },
2519                 { 0x200,        MSG_S_ISVTX },
2520                 { 0400,         MSG_S_IRUSR },
2521                 { 0200,         MSG_S_IWUSR },
2522                 { 0100,         MSG_S_IXUSR },
2523                 { 0040,         MSG_S_IRGRP },
2524                 { 0020,         MSG_S_IWGRP },
2525                 { 0010,         MSG_S_IXGRP },
2526                 { 0004,         MSG_S_IROTH },
2527                 { 0002,         MSG_S_IWOTH },
2528                 { 0001,         MSG_S_IXOTH },
2529                 { 0, NULL },
2530         };
2531 
2532         arg.oflags = arg.rflags = mode & ~(0xf000);
2533         arg.buf = buf;
2534         arg.bufsize = bufsize;
2535 
2536         switch (mode & (0xf000)) {
2537         case 0x1000:
2538                 s = MSG_S_IFIFO;
2539                 break;
2540         case 0x2000:
2541                 s = MSG_S_IFCHR;
2542                 break;
2543         case 0x4000:
2544                 s = MSG_S_IFDIR;
2545                 break;
2546         case 0x5000:
2547                 s = MSG_S_IFNAM;
2548                 break;
2549         case 0x6000:
2550                 s = MSG_S_IFBLK;
2551                 break;
2552         case 0x8000:
2553                 s = MSG_S_IFREG;
2554                 break;
2555         case 0xA000:
2556                 s = MSG_S_IFLNK;
2557                 break;
2558         case 0xc000:
2559                 s = MSG_S_IFSOCK;
2560                 break;
2561         case 0xd000:
2562                 s = MSG_S_IFDOOR;
2563                 break;
2564         case 0xe000:
2565                 s = MSG_S_IFPORT;
2566                 break;
2567         default:
2568                 s = NULL;
2569                 break;
2570         }
2571 
2572         if (s) {
2573                 arg.oflags |= 0x1000;
2574                 arg.rflags |= 0x1000;
2575                 vda[0].v_msg = s;
2576         } else {
2577                 arg.rflags = mode;
2578         }
2579 
2580         if (mode == 0)
2581                 return (MSG_ORIG(MSG_GBL_ZERO));
2582 
2583         (void) conv_expn_field(&arg, vda, fmt_flags);
2584         return (buf);
2585 }
2586 
2587 
2588 #define PROCSECFLGSZ    CONV_EXPN_FIELD_DEF_PREFIX_SIZE +               \
2589         MSG_ASLR_SIZE           + CONV_EXPN_FIELD_DEF_SEP_SIZE +        \
2590         MSG_FORBIDNULLMAP_SIZE  + CONV_EXPN_FIELD_DEF_SEP_SIZE +        \
2591         MSG_NOEXECSTACK_SIZE    + CONV_EXPN_FIELD_DEF_SEP_SIZE +        \
2592         CONV_INV_BUFSIZE        + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
2593 
2594 /*
2595  * Ensure that Conv_cnote_pr_secflags_buf_t is large enough:
2596  *
2597  * PROCSECFLGSZ is the real minimum size of the buffer required by
2598  * conv_prsecflags(). However, Conv_cnote_pr_secflags_buf_t uses
2599  * CONV_CNOTE_PSECFLAGS_FLAG_BUFSIZE to set the buffer size. We do things this
2600  * way because the definition of PROCSECFLGSZ uses information that is not
2601  * available in the environment of other programs that include the conv.h
2602  * header file.
2603  */
2604 #if (CONV_PRSECFLAGS_BUFSIZE != PROCSECFLGSZ) && !defined(__lint)
2605 #define REPORT_BUFSIZE PROCSECFLGSZ
2606 #include "report_bufsize.h"
2607 #error "CONV_PRSECFLAGS_BUFSIZE does not match PROCSECFLGSZ"
2608 #endif
2609 
2610 const char *
2611 conv_prsecflags(secflagset_t flags, Conv_fmt_flags_t fmt_flags,
2612     Conv_secflags_buf_t *secflags_buf)
2613 {
2614         /*
2615          * The values are initialized later, based on position in this array
2616          */
2617         static Val_desc vda[] = {
2618                 { 0, MSG_ASLR },
2619                 { 0, MSG_FORBIDNULLMAP },
2620                 { 0, MSG_NOEXECSTACK },
2621                 { 0, 0 }
2622         };
2623         static CONV_EXPN_FIELD_ARG conv_arg = {
2624             NULL, sizeof (secflags_buf->buf)
2625         };
2626         int i;
2627 
2628         for (i = 0; vda[i].v_msg != 0; i++)
2629                 vda[i].v_val = secflag_to_bit(i);
2630 
2631         if (flags == 0)
2632                 return (MSG_ORIG(MSG_GBL_ZERO));
2633 
2634         conv_arg.buf = secflags_buf->buf;
2635         conv_arg.oflags = conv_arg.rflags = flags;
2636         (void) conv_expn_field(&conv_arg, vda, fmt_flags);
2637 
2638         return ((const char *)secflags_buf->buf);
2639 }