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