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