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
2609 #define PROCSECFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
2610 MSG_ASLR_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
2611 MSG_FORBIDNULLMAP_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
2612 MSG_NOEXECSTACK_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
2613 CONV_INV_BUFSIZE + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
2614
2615 /*
2616 * Ensure that Conv_cnote_pr_secflags_buf_t is large enough:
2617 *
2618 * PROCSECFLGSZ is the real minimum size of the buffer required by
2619 * conv_prsecflags(). However, Conv_cnote_pr_secflags_buf_t uses
2620 * CONV_CNOTE_PSECFLAGS_FLAG_BUFSIZE to set the buffer size. We do things this
2621 * way because the definition of PROCSECFLGSZ uses information that is not
2622 * available in the environment of other programs that include the conv.h
2623 * header file.
2624 */
2625 #if (CONV_PRSECFLAGS_BUFSIZE != PROCSECFLGSZ) && !defined(__lint)
2626 #define REPORT_BUFSIZE PROCSECFLGSZ
2627 #include "report_bufsize.h"
2628 #error "CONV_PRSECFLAGS_BUFSIZE does not match PROCSECFLGSZ"
2629 #endif
2630
2631 const char *
conv_prsecflags(secflagset_t flags,Conv_fmt_flags_t fmt_flags,Conv_secflags_buf_t * secflags_buf)2632 conv_prsecflags(secflagset_t flags, Conv_fmt_flags_t fmt_flags,
2633 Conv_secflags_buf_t *secflags_buf)
2634 {
2635 /*
2636 * The values are initialized later, based on position in this array
2637 */
2638 static Val_desc vda[] = {
2639 { 0, MSG_ASLR },
2640 { 0, MSG_FORBIDNULLMAP },
2641 { 0, MSG_NOEXECSTACK },
2642 { 0, 0 }
2643 };
2644 static CONV_EXPN_FIELD_ARG conv_arg = {
2645 NULL, sizeof (secflags_buf->buf)
2646 };
2647 int i;
2648
2649 for (i = 0; vda[i].v_msg != 0; i++)
2650 vda[i].v_val = secflag_to_bit(i);
2651
2652 if (flags == 0)
2653 return (MSG_ORIG(MSG_GBL_ZERO));
2654
2655 conv_arg.buf = secflags_buf->buf;
2656 conv_arg.oflags = conv_arg.rflags = flags;
2657 (void) conv_expn_field(&conv_arg, vda, fmt_flags);
2658
2659 return ((const char *)secflags_buf->buf);
2660 }
2661
2662
2663 #define UPANICFLGSZ CONV_EXPN_FIELD_DEF_PREFIX_SIZE + \
2664 MSG_MSG_VALID_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
2665 MSG_MSG_ERROR_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
2666 MSG_MSG_TRUNC_SIZE + CONV_EXPN_FIELD_DEF_SEP_SIZE + \
2667 CONV_INV_BUFSIZE + CONV_EXPN_FIELD_DEF_SUFFIX_SIZE
2668
2669 /*
2670 * Ensure that Conv_upanic_buf_t is large enough:
2671 *
2672 * UPANICFLGSZ is the real minimum size of the buffer required by
2673 * conv_prsecflags(). However, Conv_upanic_buf_t uses CONV_PRUPANIC_BUFSIZE to
2674 * set the buffer size. We do things this way because the definition of
2675 * UPANICFLGSZ uses information that is not available in the environment of
2676 * other programs that include the conv.h header file.
2677 */
2678 #if (CONV_PRUPANIC_BUFSIZE != UPANICFLGSZ)
2679 #define REPORT_BUFSIZE UPANICFLGSZ
2680 #include "report_bufsize.h"
2681 #error "CONV_PRUPANIC_BUFSIZE does not match UPANICFLGSZ"
2682 #endif
2683
2684 const char *
conv_prupanic(uint32_t flags,Conv_fmt_flags_t fmt_flags,Conv_upanic_buf_t * upanic_buf)2685 conv_prupanic(uint32_t flags, Conv_fmt_flags_t fmt_flags,
2686 Conv_upanic_buf_t *upanic_buf)
2687 {
2688 /*
2689 * Unfortunately, we cannot directly use the PRUPANIC_FLAG_* macros here
2690 * because of the fact that this is also built natively and that would
2691 * create an unresolvable flag day.
2692 */
2693 static Val_desc vda[] = {
2694 { 0x01, MSG_MSG_VALID },
2695 { 0x02, MSG_MSG_ERROR },
2696 { 0x04, MSG_MSG_TRUNC },
2697 { 0, 0 }
2698 };
2699 static CONV_EXPN_FIELD_ARG conv_arg = {
2700 NULL, sizeof (upanic_buf->buf)
2701 };
2702
2703 if (flags == 0)
2704 return (MSG_ORIG(MSG_GBL_ZERO));
2705
2706 conv_arg.buf = upanic_buf->buf;
2707 conv_arg.oflags = conv_arg.rflags = flags;
2708 (void) conv_expn_field(&conv_arg, vda, fmt_flags);
2709
2710 return ((const char *)upanic_buf->buf);
2711 }
2712