?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge commit 'b1e7e97d3b60469b243b3b2e22c7d8cbd11c7c90'
[unleashed.git] / usr / src / cmd / truss / print.c
blob7c524858dc37a8630b856ede14271b25a4c149ee
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 (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2015, Joyent, Inc. All rights reserved.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /* Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved. */
31
32 #define _SYSCALL32 /* make 32-bit compat headers visible */
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <string.h>
38 #include <signal.h>
39 #include <termio.h>
40 #include <stddef.h>
41 #include <limits.h>
42 #include <fcntl.h>
43 #include <ctype.h>
44 #include <sys/types.h>
45 #include <sys/mman.h>
46 #include <sys/resource.h>
47 #include <sys/ulimit.h>
48 #include <sys/utsname.h>
49 #include <sys/kstat.h>
50 #include <sys/modctl.h>
51 #include <sys/acl.h>
52 #include <stropts.h>
53 #include <sys/isa_defs.h>
54 #include <sys/systeminfo.h>
55 #include <sys/lwp.h>
56 #include <libproc.h>
57 #include <priv.h>
58 #include <sys/aio.h>
59 #include <sys/aiocb.h>
60 #include <sys/corectl.h>
61 #include <sys/cpc_impl.h>
62 #include <sys/priocntl.h>
63 #include <sys/tspriocntl.h>
64 #include <sys/iapriocntl.h>
65 #include <sys/rtpriocntl.h>
66 #include <sys/fsspriocntl.h>
67 #include <sys/fxpriocntl.h>
68 #include <sys/proc.h>
69 #include <netdb.h>
70 #include <nss_dbdefs.h>
71 #include <sys/socketvar.h>
72 #include <netinet/in.h>
73 #include <netinet/tcp.h>
74 #include <netinet/udp.h>
75 #include <netinet/sctp.h>
76 #include <net/route.h>
77 #include <sys/utrap.h>
78 #include <sys/lgrp_user.h>
79 #include <sys/door.h>
80 #include <sys/rctl.h>
81 #include <sys/rctl_impl.h>
82 #include <sys/fork.h>
83 #include <sys/task.h>
84 #include <sys/random.h>
85 #include "ramdata.h"
86 #include "print.h"
87 #include "proto.h"
88 #include "systable.h"
89
90 void grow(private_t *, int nbyte);
91
92 #define GROW(nb) if (pri->sys_leng + (nb) >= pri->sys_ssize) grow(pri, (nb))
93
94
95 /*ARGSUSED*/
96 void
97 prt_nov(private_t *pri, int raw, long val) /* print nothing */
98 {
99 }
100
101 /*ARGSUSED*/
102 void
103 prt_dec(private_t *pri, int raw, long val) /* print as decimal */
104 {
105 GROW(24);
106 if (data_model == PR_MODEL_ILP32)
107 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
108 "%d", (int)val);
109 else
110 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
111 "%ld", val);
112 }
113
114 /*ARGSUSED*/
115 void
116 prt_uns(private_t *pri, int raw, long val) /* print as unsigned decimal */
117 {
118 GROW(24);
119 if (data_model == PR_MODEL_ILP32)
120 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
121 "%u", (int)val);
122 else
123 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
124 "%lu", val);
125 }
126
127 /* print as unsigned decimal, except for -1 */
128 void
129 prt_un1(private_t *pri, int raw, long val)
130 {
131 if ((int)val == -1)
132 prt_dec(pri, raw, val);
133 else
134 prt_uns(pri, raw, val);
135 }
136
137 /*ARGSUSED*/
138 void
139 prt_oct(private_t *pri, int raw, long val) /* print as octal */
140 {
141 GROW(24);
142 if (data_model == PR_MODEL_ILP32)
143 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
144 "%#o", (int)val);
145 else
146 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
147 "%#lo", val);
148 }
149
150 /*ARGSUSED*/
151 void
152 prt_hex(private_t *pri, int raw, long val) /* print as hexadecimal */
153 {
154 GROW(20);
155 if (data_model == PR_MODEL_ILP32)
156 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
157 "0x%.8X", (int)val);
158 else
159 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
160 "0x%.8lX", val);
161 }
162
163 /* print as hexadecimal (half size) */
164 /*ARGSUSED*/
165 void
166 prt_hhx(private_t *pri, int raw, long val)
167 {
168 GROW(20);
169 if (data_model == PR_MODEL_ILP32)
170 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
171 "0x%.4X", (int)val);
172 else
173 pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
174 "0x%.4lX", val);
175 }
176
177 /* print as decimal if small, else hexadecimal */
178 /*ARGSUSED*/
179 void
180 prt_dex(private_t *pri, int raw, long val)
181 {
182 if (val & 0xff000000)
183 prt_hex(pri, 0, val);
184 else
185 prt_dec(pri, 0, val);
186 }
187
188 /* print long long offset */
189 /*ARGSUSED*/
190 void
191 prt_llo(private_t *pri, int raw, long val1, long val2)
192 {
193 int hival;
194 int loval;
195
196 #ifdef _LONG_LONG_LTOH
197 hival = (int)val2;
198 loval = (int)val1;
199 #else
200 hival = (int)val1;
201 loval = (int)val2;
202 #endif
203
204 if (hival == 0) {
205 prt_dex(pri, 0, loval);
206 } else {
207 GROW(18);
208 pri->sys_leng +=
209 sprintf(pri->sys_string + pri->sys_leng, "0x%.8X%.8X",
210 hival, loval);
211 }
212 }
213
214 void
215 escape_string(private_t *pri, const char *s)
216 {
217 /*
218 * We want to avoid outputting unprintable characters that may
219 * destroy the user's terminal. So we do one pass to find any
220 * unprintable characters, size the array appropriately, and
221 * then walk each character by hand. Those that are unprintable
222 * are replaced by a hex escape (\xNN). We also escape quotes for
223 * completeness.
224 */
225 int i, unprintable, quotes;
226 size_t len = strlen(s);
227 for (i = 0, unprintable = 0, quotes = 0; i < len; i++) {
228 if (!isprint(s[i]))
229 unprintable++;
230 if (s[i] == '"')
231 quotes++;
232 }
233
234 GROW(len + 3 * unprintable + quotes + 2);
235
236 pri->sys_string[pri->sys_leng++] = '"';
237 for (i = 0; i < len; i++) {
238 if (s[i] == '"')
239 pri->sys_string[pri->sys_leng++] = '\\';
240
241 if (isprint(s[i])) {
242 pri->sys_string[pri->sys_leng++] = s[i];
243 } else {
244 pri->sys_leng += sprintf(pri->sys_string +
245 pri->sys_leng, "\\x%02x", (uint8_t)s[i]);
246 }
247 }
248 pri->sys_string[pri->sys_leng++] = '"';
249 }
250
251 void
252 prt_stg(private_t *pri, int raw, long val) /* print as string */
253 {
254 char *s = raw? NULL : fetchstring(pri, (long)val, PATH_MAX);
255
256 if (s == NULL)
257 prt_hex(pri, 0, val);
258 else
259 escape_string(pri, s);
260 }
261
262 /* print as string returned from syscall */
263 void
264 prt_rst(private_t *pri, int raw, long val)
265 {
266 char *s = (raw || pri->Errno)? NULL :
267 fetchstring(pri, (long)val, PATH_MAX);
268
269 if (s == NULL)
270 prt_hex(pri, 0, val);
271 else {
272 GROW((int)strlen(s) + 2);
273 pri->sys_leng += snprintf(pri->sys_string + pri->sys_leng,
274 pri->sys_ssize - pri->sys_leng, "\"%s\"", s);
275 }
276 }
277
278 /* print contents of readlink() buffer */
279 void
280 prt_rlk(private_t *pri, int raw, long val)
281 {
282 char *s = (raw || pri->Errno || pri->Rval1 <= 0)? NULL :
283 fetchstring(pri, (long)val,
284 (pri->Rval1 > PATH_MAX)? PATH_MAX : (int)pri->Rval1);
285
286 if (s == NULL)
287 prt_hex(pri, 0, val);
288 else {
289 GROW((int)strlen(s) + 2);
290 pri->sys_leng += snprintf(pri->sys_string + pri->sys_leng,
291 pri->sys_ssize - pri->sys_leng, "\"%s\"", s);
292 }
293 }
294
295 void
296 prt_ioc(private_t *pri, int raw, long val) /* print ioctl code */
297 {
298 const char *s = raw? NULL : ioctlname(pri, (int)val);
299
300 if (s == NULL)
301 prt_hex(pri, 0, val);
302 else
303 outstring(pri, s);
304 }
305
306 void
307 prt_ioa(private_t *pri, int raw, long val) /* print ioctl argument */
308 {
309 const char *s;
310
311 /* cheating -- look at the ioctl() code */
312 switch (pri->sys_args[1]) {
313
314 /* kstat ioctl()s */
315 case KSTAT_IOC_READ:
316 case KSTAT_IOC_WRITE:
317 #ifdef _LP64
318 if (data_model == PR_MODEL_ILP32)
319 prt_stg(pri, raw,
320 val + offsetof(kstat32_t, ks_name[0]));
321 else
322 #endif
323 prt_stg(pri, raw,
324 val + offsetof(kstat_t, ks_name[0]));
325 break;
326
327 /* streams ioctl()s */
328 case I_LOOK:
329 prt_rst(pri, raw, val);
330 break;
331 case I_PUSH:
332 case I_FIND:
333 prt_stg(pri, raw, val);
334 break;
335 case I_LINK:
336 case I_UNLINK:
337 case I_SENDFD:
338 prt_dec(pri, 0, val);
339 break;
340 case I_SRDOPT:
341 if (raw || (s = strrdopt(val)) == NULL)
342 prt_dec(pri, 0, val);
343 else
344 outstring(pri, s);
345 break;
346 case I_SETSIG:
347 if (raw || (s = strevents(pri, val)) == NULL)
348 prt_hex(pri, 0, val);
349 else
350 outstring(pri, s);
351 break;
352 case I_FLUSH:
353 if (raw || (s = strflush(val)) == NULL)
354 prt_dec(pri, 0, val);
355 else
356 outstring(pri, s);
357 break;
358
359 /* tty ioctl()s */
360 case TCSBRK:
361 case TCXONC:
362 case TCFLSH:
363 case TCDSET:
364 prt_dec(pri, 0, val);
365 break;
366
367 default:
368 prt_hex(pri, 0, val);
369 break;
370 }
371 }
372
373 void
374 prt_pip(private_t *pri, int raw, long val) /* print pipe code */
375 {
376 const char *s = NULL;
377
378 if (!raw) {
379 switch (val) {
380 case O_CLOEXEC:
381 s = "O_CLOEXEC";
382 break;
383 case O_NONBLOCK:
384 s = "O_NONBLOCK";
385 break;
386 case O_CLOEXEC|O_NONBLOCK:
387 s = "O_CLOEXEC|O_NONBLOCK";
388 break;
389 }
390 }
391
392 if (s == NULL)
393 prt_dex(pri, 0, val);
394 else
395 outstring(pri, s);
396 }
397
398 void
399 prt_pfd(private_t *pri, int raw, long val) /* print pipe code */
400 {
401 int fds[2];
402 char str[32];
403
404 /* the fds only have meaning if the return value is 0 */
405 if (!raw &&
406 pri->Rval1 >= 0 &&
407 Pread(Proc, fds, sizeof (fds), (long)val) == sizeof (fds)) {
408 (void) snprintf(str, sizeof (str), "[%d,%d]", fds[0], fds[1]);
409 outstring(pri, str);
410 } else {
411 prt_hex(pri, 0, val);
412 }
413 }
414
415 void
416 prt_fcn(private_t *pri, int raw, long val) /* print fcntl code */
417 {
418 const char *s = raw? NULL : fcntlname(val);
419
420 if (s == NULL)
421 prt_dec(pri, 0, val);
422 else
423 outstring(pri, s);
424 }
425
426 void
427 prt_s86(private_t *pri, int raw, long val) /* print sysi86 code */
428 {
429
430 const char *s = raw? NULL : si86name(val);
431
432 if (s == NULL)
433 prt_dec(pri, 0, val);
434 else
435 outstring(pri, s);
436 }
437
438 void
439 prt_uts(private_t *pri, int raw, long val) /* print utssys code */
440 {
441 const char *s = raw? NULL : utscode(val);
442
443 if (s == NULL)
444 prt_dec(pri, 0, val);
445 else
446 outstring(pri, s);
447 }
448
449 void
450 prt_msc(private_t *pri, int raw, long val) /* print msgsys command */
451 {
452 const char *s = raw? NULL : msgcmd(val);
453
454 if (s == NULL)
455 prt_dec(pri, 0, val);
456 else
457 outstring(pri, s);
458 }
459
460 void
461 prt_msf(private_t *pri, int raw, long val) /* print msgsys flags */
462 {
463 const char *s = raw? NULL : msgflags(pri, (int)val);
464
465 if (s == NULL)
466 prt_oct(pri, 0, val);
467 else
468 outstring(pri, s);
469 }
470
471 void
472 prt_smc(private_t *pri, int raw, long val) /* print semsys command */
473 {
474 const char *s = raw? NULL : semcmd(val);
475
476 if (s == NULL)
477 prt_dec(pri, 0, val);
478 else
479 outstring(pri, s);
480 }
481
482 void
483 prt_sef(private_t *pri, int raw, long val) /* print semsys flags */
484 {
485 const char *s = raw? NULL : semflags(pri, (int)val);
486
487 if (s == NULL)
488 prt_oct(pri, 0, val);
489 else
490 outstring(pri, s);
491 }
492
493 void
494 prt_shc(private_t *pri, int raw, long val) /* print shmsys command */
495 {
496 const char *s = raw? NULL : shmcmd(val);
497
498 if (s == NULL)
499 prt_dec(pri, 0, val);
500 else
501 outstring(pri, s);
502 }
503
504 void
505 prt_shf(private_t *pri, int raw, long val) /* print shmsys flags */
506 {
507 const char *s = raw? NULL : shmflags(pri, (int)val);
508
509 if (s == NULL)
510 prt_oct(pri, 0, val);
511 else
512 outstring(pri, s);
513 }
514
515 void
516 prt_sfs(private_t *pri, int raw, long val) /* print sysfs code */
517 {
518 const char *s = raw? NULL : sfsname(val);
519
520 if (s == NULL)
521 prt_dec(pri, 0, val);
522 else
523 outstring(pri, s);
524 }
525
526 void
527 prt_opn(private_t *pri, int raw, long val) /* print open code */
528 {
529 const char *s = raw? NULL : openarg(pri, val);
530
531 if (s == NULL)
532 prt_oct(pri, 0, val);
533 else
534 outstring(pri, s);
535 }
536
537 void
538 prt_sig(private_t *pri, int raw, long val) /* print signal name */
539 {
540 const char *s = raw? NULL : signame(pri, (int)val);
541
542 if (s == NULL)
543 prt_hex(pri, 0, val);
544 else
545 outstring(pri, s);
546 }
547
548 void
549 prt_smf(private_t *pri, int raw, long val) /* print streams message flags */
550 {
551 switch (val) {
552 case 0:
553 prt_dec(pri, 0, val);
554 break;
555 case RS_HIPRI:
556 if (raw)
557 prt_hhx(pri, 0, val);
558 else
559 outstring(pri, "RS_HIPRI");
560 break;
561 default:
562 prt_hhx(pri, 0, val);
563 break;
564 }
565 }
566
567 void
568 prt_mtf(private_t *pri, int raw, long val) /* print mount flags */
569 {
570 const char *s = raw? NULL : mountflags(pri, val);
571
572 if (s == NULL)
573 prt_hex(pri, 0, val);
574 else
575 outstring(pri, s);
576 }
577
578 void
579 prt_mft(private_t *pri, int raw, long val) /* print mount file system type */
580 {
581 if (val >= 0 && val < 256)
582 prt_dec(pri, 0, val);
583 else if (raw)
584 prt_hex(pri, 0, val);
585 else
586 prt_stg(pri, raw, val);
587 }
588
589 #define ISREAD(code) \
590 ((code) == SYS_read || (code) == SYS_pread || (code) == SYS_pread64 || \
591 (code) == SYS_recv || (code) == SYS_recvfrom)
592 #define ISWRITE(code) \
593 ((code) == SYS_write || (code) == SYS_pwrite || \
594 (code) == SYS_pwrite64 || (code) == SYS_send || (code) == SYS_sendto)
595
596 /* print contents of read() or write() I/O buffer */
597 void
598 prt_iob(private_t *pri, int raw, long val)
599 {
600 const lwpstatus_t *Lsp = pri->lwpstat;
601 int syscall = Lsp->pr_what;
602 int fdp1 = pri->sys_args[0] + 1;
603 ssize_t nbyte = ISWRITE(syscall)? pri->sys_args[2] :
604 (pri->Errno? 0 : pri->Rval1);
605 int elsewhere = FALSE; /* TRUE iff dumped elsewhere */
606 char buffer[IOBSIZE];
607
608 pri->iob_buf[0] = '\0';
609
610 if (Lsp->pr_why == PR_SYSEXIT && nbyte > IOBSIZE) {
611 if (ISREAD(syscall))
612 elsewhere = prismember(&readfd, fdp1);
613 else
614 elsewhere = prismember(&writefd, fdp1);
615 }
616
617 if (nbyte <= 0 || elsewhere)
618 prt_hex(pri, 0, val);
619 else {
620 int nb = nbyte > IOBSIZE? IOBSIZE : (int)nbyte;
621
622 if (Pread(Proc, buffer, (size_t)nb, (long)val) != nb)
623 prt_hex(pri, 0, val);
624 else {
625 pri->iob_buf[0] = '"';
626 showbytes(buffer, nb, pri->iob_buf + 1);
627 (void) strlcat(pri->iob_buf,
628 (nb == nbyte)?
629 (const char *)"\"" : (const char *)"\"..",
630 sizeof (pri->iob_buf));
631 if (raw)
632 prt_hex(pri, 0, val);
633 else
634 outstring(pri, pri->iob_buf);
635 }
636 }
637 }
638 #undef ISREAD
639 #undef ISWRITE
640
641 void
642 prt_idt(private_t *pri, int raw, long val) /* print idtype_t, waitid() arg */
643 {
644 const char *s = raw? NULL : idtype_enum(pri, val);
645
646 if (s == NULL)
647 prt_dec(pri, 0, val);
648 else
649 outstring(pri, s);
650 }
651
652 void
653 prt_wop(private_t *pri, int raw, long val) /* print waitid() options */
654 {
655 const char *s = raw? NULL : woptions(pri, (int)val);
656
657 if (s == NULL)
658 prt_oct(pri, 0, val);
659 else
660 outstring(pri, s);
661 }
662
663 void
664 prt_whn(private_t *pri, int raw, long val) /* print lseek() whence argument */
665 {
666 const char *s = raw? NULL : whencearg(val);
667
668 if (s == NULL)
669 prt_dec(pri, 0, val);
670 else
671 outstring(pri, s);
672 }
673
674 /*ARGSUSED*/
675 void
676 prt_spm(private_t *pri, int raw, long val) /* print sigprocmask argument */
677 {
678 const char *s = NULL;
679
680 if (!raw) {
681 switch (val) {
682 case SIG_BLOCK: s = "SIG_BLOCK"; break;
683 case SIG_UNBLOCK: s = "SIG_UNBLOCK"; break;
684 case SIG_SETMASK: s = "SIG_SETMASK"; break;
685 }
686 }
687
688 if (s == NULL)
689 prt_dec(pri, 0, val);
690 else
691 outstring(pri, s);
692 }
693
694 const char *
695 mmap_protect(private_t *pri, long arg)
696 {
697 char *str = pri->code_buf;
698
699 if (arg & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
700 return (NULL);
701
702 if (arg == PROT_NONE)
703 return ("PROT_NONE");
704
705 *str = '\0';
706 if (arg & PROT_READ)
707 (void) strlcat(str, "|PROT_READ", sizeof (pri->code_buf));
708 if (arg & PROT_WRITE)
709 (void) strlcat(str, "|PROT_WRITE", sizeof (pri->code_buf));
710 if (arg & PROT_EXEC)
711 (void) strlcat(str, "|PROT_EXEC", sizeof (pri->code_buf));
712 return ((const char *)(str + 1));
713 }
714
715 const char *
716 mmap_type(private_t *pri, long arg)
717 {
718 char *str = pri->code_buf;
719 size_t used;
720
721 #define CBSIZE sizeof (pri->code_buf)
722 switch (arg & MAP_TYPE) {
723 case MAP_SHARED:
724 used = strlcpy(str, "MAP_SHARED", CBSIZE);
725 break;
726 case MAP_PRIVATE:
727 used = strlcpy(str, "MAP_PRIVATE", CBSIZE);
728 break;
729 default:
730 used = snprintf(str, CBSIZE, "%ld", arg&MAP_TYPE);
731 break;
732 }
733
734 arg &= ~MAP_TYPE;
735
736 if (arg & ~(MAP_FIXED|MAP_RENAME|MAP_NORESERVE|MAP_ANON|MAP_ALIGN|
737 MAP_TEXT|MAP_INITDATA|MAP_32BIT))
738 (void) snprintf(str + used, sizeof (pri->code_buf) - used,
739 "|0x%lX", arg);
740 else {
741 if (arg & MAP_FIXED)
742 (void) strlcat(str, "|MAP_FIXED", CBSIZE);
743 if (arg & MAP_RENAME)
744 (void) strlcat(str, "|MAP_RENAME", CBSIZE);
745 if (arg & MAP_NORESERVE)
746 (void) strlcat(str, "|MAP_NORESERVE", CBSIZE);
747 if (arg & MAP_ANON)
748 (void) strlcat(str, "|MAP_ANON", CBSIZE);
749 if (arg & MAP_ALIGN)
750 (void) strlcat(str, "|MAP_ALIGN", CBSIZE);
751 if (arg & MAP_TEXT)
752 (void) strlcat(str, "|MAP_TEXT", CBSIZE);
753 if (arg & MAP_INITDATA)
754 (void) strlcat(str, "|MAP_INITDATA", CBSIZE);
755 if (arg & MAP_32BIT)
756 (void) strlcat(str, "|MAP_32BIT", CBSIZE);
757 }
758
759 return ((const char *)str);
760 #undef CBSIZE
761 }
762
763 void
764 prt_mpr(private_t *pri, int raw, long val) /* print mmap()/mprotect() flags */
765 {
766 const char *s = raw? NULL : mmap_protect(pri, val);
767
768 if (s == NULL)
769 prt_hhx(pri, 0, val);
770 else
771 outstring(pri, s);
772 }
773
774 void
775 prt_mty(private_t *pri, int raw, long val) /* print mmap() mapping type flags */
776 {
777 const char *s = raw? NULL : mmap_type(pri, val);
778
779 if (s == NULL)
780 prt_hhx(pri, 0, val);
781 else
782 outstring(pri, s);
783 }
784
785 void
786 prt_mob(private_t *pri, int raw, long val) /* print mmapobj() flags */
787 {
788 if (val == 0) {
789 prt_dec(pri, 0, val);
790 } else if (raw || (val & ~(MMOBJ_ALL_FLAGS)) != 0) {
791 prt_hhx(pri, 0, val);
792 } else {
793 #define CBSIZE sizeof (pri->code_buf)
794 char *s = pri->code_buf;
795
796 *s = '\0';
797 if (val & MMOBJ_PADDING)
798 (void) strlcat(s, "|MMOBJ_PADDING", CBSIZE);
799 if (val & MMOBJ_INTERPRET)
800 (void) strlcat(s, "|MMOBJ_INTERPRET", CBSIZE);
801 if (val & MMOBJ_PRIMARY)
802 (void) strlcat(s, "|MMOBJ_PRIMARY", CBSIZE);
803 outstring(pri, s + 1);
804 #undef CBSIZE
805 }
806 }
807
808 /*ARGSUSED*/
809 void
810 prt_mcf(private_t *pri, int raw, long val) /* print memcntl() function */
811 {
812 const char *s = NULL;
813
814 if (!raw) {
815 switch (val) {
816 case MC_SYNC: s = "MC_SYNC"; break;
817 case MC_LOCK: s = "MC_LOCK"; break;
818 case MC_UNLOCK: s = "MC_UNLOCK"; break;
819 case MC_ADVISE: s = "MC_ADVISE"; break;
820 case MC_LOCKAS: s = "MC_LOCKAS"; break;
821 case MC_UNLOCKAS: s = "MC_UNLOCKAS"; break;
822 case MC_HAT_ADVISE: s = "MC_HAT_ADVISE"; break;
823 }
824 }
825
826 if (s == NULL)
827 prt_dec(pri, 0, val);
828 else
829 outstring(pri, s);
830 }
831
832 void
833 prt_mad(private_t *pri, int raw, long val) /* print madvise() argument */
834 {
835 const char *s = NULL;
836
837 if (!raw) {
838 switch (val) {
839 case MADV_NORMAL: s = "MADV_NORMAL"; break;
840 case MADV_RANDOM: s = "MADV_RANDOM"; break;
841 case MADV_SEQUENTIAL: s = "MADV_SEQUENTIAL"; break;
842 case MADV_WILLNEED: s = "MADV_WILLNEED"; break;
843 case MADV_DONTNEED: s = "MADV_DONTNEED"; break;
844 case MADV_FREE: s = "MADV_FREE"; break;
845 case MADV_ACCESS_DEFAULT: s = "MADV_ACCESS_DEFAULT"; break;
846 case MADV_ACCESS_LWP: s = "MADV_ACCESS_LWP"; break;
847 case MADV_ACCESS_MANY: s = "MADV_ACCESS_MANY"; break;
848 case MADV_PURGE: s = "MADV_PURGE"; break;
849 }
850 }
851
852 if (s == NULL)
853 prt_dec(pri, 0, val);
854 else
855 outstring(pri, s);
856 }
857
858 void
859 prt_mc4(private_t *pri, int raw, long val) /* print memcntl() (4th) argument */
860 {
861 if (val == 0)
862 prt_dec(pri, 0, val);
863 else if (raw)
864 prt_hhx(pri, 0, val);
865 else {
866 char *s = NULL;
867
868 #define CBSIZE sizeof (pri->code_buf)
869 /* cheating -- look at memcntl func */
870 switch (pri->sys_args[2]) {
871 case MC_ADVISE:
872 prt_mad(pri, 0, val);
873 return;
874
875 case MC_SYNC:
876 if ((val & ~(MS_SYNC|MS_ASYNC|MS_INVALIDATE)) == 0) {
877 *(s = pri->code_buf) = '\0';
878 if (val & MS_SYNC)
879 (void) strlcat(s, "|MS_SYNC", CBSIZE);
880 if (val & MS_ASYNC)
881 (void) strlcat(s, "|MS_ASYNC", CBSIZE);
882 if (val & MS_INVALIDATE)
883 (void) strlcat(s, "|MS_INVALIDATE",
884 CBSIZE);
885 }
886 break;
887
888 case MC_LOCKAS:
889 case MC_UNLOCKAS:
890 if ((val & ~(MCL_CURRENT|MCL_FUTURE)) == 0) {
891 *(s = pri->code_buf) = '\0';
892 if (val & MCL_CURRENT)
893 (void) strlcat(s, "|MCL_CURRENT",
894 CBSIZE);
895 if (val & MCL_FUTURE)
896 (void) strlcat(s, "|MCL_FUTURE",
897 CBSIZE);
898 }
899 break;
900 }
901 #undef CBSIZE
902
903 if (s == NULL || *s == '\0')
904 prt_hhx(pri, 0, val);
905 else
906 outstring(pri, ++s);
907 }
908 }
909
910 void
911 prt_mc5(private_t *pri, int raw, long val) /* print memcntl() (5th) argument */
912 {
913 char *s;
914
915 #define CBSIZE sizeof (pri->code_buf)
916 if (val == 0)
917 prt_dec(pri, 0, val);
918 else if (raw || (val & ~VALID_ATTR))
919 prt_hhx(pri, 0, val);
920 else {
921 s = pri->code_buf;
922 *s = '\0';
923 if (val & SHARED)
924 (void) strlcat(s, "|SHARED", CBSIZE);
925 if (val & PRIVATE)
926 (void) strlcat(s, "|PRIVATE", CBSIZE);
927 if (val & PROT_READ)
928 (void) strlcat(s, "|PROT_READ", CBSIZE);
929 if (val & PROT_WRITE)
930 (void) strlcat(s, "|PROT_WRITE", CBSIZE);
931 if (val & PROT_EXEC)
932 (void) strlcat(s, "|PROT_EXEC", CBSIZE);
933 if (*s == '\0')
934 prt_hhx(pri, 0, val);
935 else
936 outstring(pri, ++s);
937 }
938 #undef CBSIZE
939 }
940
941 void
942 prt_ulm(private_t *pri, int raw, long val) /* print ulimit() argument */
943 {
944 const char *s = NULL;
945
946 if (!raw) {
947 switch (val) {
948 case UL_GFILLIM: s = "UL_GFILLIM"; break;
949 case UL_SFILLIM: s = "UL_SFILLIM"; break;
950 case UL_GMEMLIM: s = "UL_GMEMLIM"; break;
951 case UL_GDESLIM: s = "UL_GDESLIM"; break;
952 }
953 }
954
955 if (s == NULL)
956 prt_dec(pri, 0, val);
957 else
958 outstring(pri, s);
959 }
960
961 void
962 prt_rlm(private_t *pri, int raw, long val) /* print get/setrlimit() argument */
963 {
964 const char *s = NULL;
965
966 if (!raw) {
967 switch (val) {
968 case RLIMIT_CPU: s = "RLIMIT_CPU"; break;
969 case RLIMIT_FSIZE: s = "RLIMIT_FSIZE"; break;
970 case RLIMIT_DATA: s = "RLIMIT_DATA"; break;
971 case RLIMIT_STACK: s = "RLIMIT_STACK"; break;
972 case RLIMIT_CORE: s = "RLIMIT_CORE"; break;
973 case RLIMIT_NOFILE: s = "RLIMIT_NOFILE"; break;
974 case RLIMIT_VMEM: s = "RLIMIT_VMEM"; break;
975 }
976 }
977
978 if (s == NULL)
979 prt_dec(pri, 0, val);
980 else
981 outstring(pri, s);
982 }
983
984 void
985 prt_cnf(private_t *pri, int raw, long val) /* print sysconfig code */
986 {
987 const char *s = raw? NULL : sconfname(val);
988
989 if (s == NULL)
990 prt_dec(pri, 0, val);
991 else
992 outstring(pri, s);
993 }
994
995 void
996 prt_inf(private_t *pri, int raw, long val) /* print sysinfo code */
997 {
998 const char *s = NULL;
999
1000 if (!raw) {
1001 switch (val) {
1002 case SI_SYSNAME: s = "SI_SYSNAME"; break;
1003 case SI_HOSTNAME: s = "SI_HOSTNAME"; break;
1004 case SI_RELEASE: s = "SI_RELEASE"; break;
1005 case SI_VERSION: s = "SI_VERSION"; break;
1006 case SI_MACHINE: s = "SI_MACHINE"; break;
1007 case SI_ARCHITECTURE: s = "SI_ARCHITECTURE"; break;
1008 case SI_ARCHITECTURE_32:s = "SI_ARCHITECTURE_32"; break;
1009 case SI_ARCHITECTURE_64:s = "SI_ARCHITECTURE_64"; break;
1010 case SI_ARCHITECTURE_K: s = "SI_ARCHITECTURE_K"; break;
1011 case SI_HW_SERIAL: s = "SI_HW_SERIAL"; break;
1012 case SI_HW_PROVIDER: s = "SI_HW_PROVIDER"; break;
1013 case SI_SRPC_DOMAIN: s = "SI_SRPC_DOMAIN"; break;
1014 case SI_SET_HOSTNAME: s = "SI_SET_HOSTNAME"; break;
1015 case SI_SET_SRPC_DOMAIN: s = "SI_SET_SRPC_DOMAIN"; break;
1016 case SI_PLATFORM: s = "SI_PLATFORM"; break;
1017 case SI_ISALIST: s = "SI_ISALIST"; break;
1018 case SI_DHCP_CACHE: s = "SI_DHCP_CACHE"; break;
1019 }
1020 }
1021
1022 if (s == NULL)
1023 prt_dec(pri, 0, val);
1024 else
1025 outstring(pri, s);
1026 }
1027
1028 void
1029 prt_ptc(private_t *pri, int raw, long val) /* print pathconf code */
1030 {
1031 const char *s = raw? NULL : pathconfname(val);
1032
1033 if (s == NULL)
1034 prt_dec(pri, 0, val);
1035 else
1036 outstring(pri, s);
1037 }
1038
1039 void
1040 prt_fui(private_t *pri, int raw, long val) /* print fusers() input argument */
1041 {
1042 const char *s = raw? NULL : fuiname(val);
1043
1044 if (s == NULL)
1045 prt_hhx(pri, 0, val);
1046 else
1047 outstring(pri, s);
1048 }
1049
1050 void
1051 prt_lwf(private_t *pri, int raw, long val) /* print lwp_create() flags */
1052 {
1053 char *s;
1054
1055 if (val == 0)
1056 prt_dec(pri, 0, val);
1057 else if (raw ||
1058 (val & ~(LWP_DAEMON|LWP_DETACHED|LWP_SUSPENDED)))
1059 prt_hhx(pri, 0, val);
1060 else {
1061 #define CBSIZE sizeof (pri->code_buf)
1062 s = pri->code_buf;
1063 *s = '\0';
1064 if (val & LWP_DAEMON)
1065 (void) strlcat(s, "|LWP_DAEMON", CBSIZE);
1066 if (val & LWP_DETACHED)
1067 (void) strlcat(s, "|LWP_DETACHED", CBSIZE);
1068 if (val & LWP_SUSPENDED)
1069 (void) strlcat(s, "|LWP_SUSPENDED", CBSIZE);
1070 outstring(pri, ++s);
1071 #undef CBSIZE
1072 }
1073 }
1074
1075 void
1076 prt_itm(private_t *pri, int raw, long val) /* print [get|set]itimer() arg */
1077 {
1078 const char *s = NULL;
1079
1080 if (!raw) {
1081 switch (val) {
1082 case ITIMER_REAL: s = "ITIMER_REAL"; break;
1083 case ITIMER_VIRTUAL: s = "ITIMER_VIRTUAL"; break;
1084 case ITIMER_PROF: s = "ITIMER_PROF"; break;
1085 #ifdef ITIMER_REALPROF
1086 case ITIMER_REALPROF: s = "ITIMER_REALPROF"; break;
1087 #endif
1088 }
1089 }
1090
1091 if (s == NULL)
1092 prt_dec(pri, 0, val);
1093 else
1094 outstring(pri, s);
1095 }
1096
1097 void
1098 prt_mod(private_t *pri, int raw, long val) /* print modctl() code */
1099 {
1100 const char *s = NULL;
1101
1102 if (!raw) {
1103 switch (val) {
1104 case MODLOAD: s = "MODLOAD"; break;
1105 case MODUNLOAD: s = "MODUNLOAD"; break;
1106 case MODINFO: s = "MODINFO"; break;
1107 case MODRESERVED: s = "MODRESERVED"; break;
1108 case MODSETMINIROOT: s = "MODSETMINIROOT"; break;
1109 case MODADDMAJBIND: s = "MODADDMAJBIND"; break;
1110 case MODGETPATH: s = "MODGETPATH"; break;
1111 case MODGETPATHLEN: s = "MODGETPATHLEN"; break;
1112 case MODREADSYSBIND: s = "MODREADSYSBIND"; break;
1113 case MODGETMAJBIND: s = "MODGETMAJBIND"; break;
1114 case MODGETNAME: s = "MODGETNAME"; break;
1115 case MODSIZEOF_DEVID: s = "MODSIZEOF_DEVID"; break;
1116 case MODGETDEVID: s = "MODGETDEVID"; break;
1117 case MODSIZEOF_MINORNAME: s = "MODSIZEOF_MINORNAME"; break;
1118 case MODGETMINORNAME: s = "MODGETMINORNAME"; break;
1119 case MODGETFBNAME: s = "MODGETFBNAME"; break;
1120 case MODEVENTS: s = "MODEVENTS"; break;
1121 case MODREREADDACF: s = "MODREREADDACF"; break;
1122 case MODLOADDRVCONF: s = "MODLOADDRVCONF"; break;
1123 case MODUNLOADDRVCONF: s = "MODUNLOADDRVCONF"; break;
1124 case MODREMMAJBIND: s = "MODREMMAJBIND"; break;
1125 case MODDEVT2INSTANCE: s = "MODDEVT2INSTANCE"; break;
1126 case MODGETDEVFSPATH_LEN: s = "MODGETDEVFSPATH_LEN"; break;
1127 case MODGETDEVFSPATH: s = "MODGETDEVFSPATH"; break;
1128 case MODDEVID2PATHS: s = "MODDEVID2PATHS"; break;
1129 case MODSETDEVPOLICY: s = "MODSETDEVPOLICY"; break;
1130 case MODGETDEVPOLICY: s = "MODGETDEVPOLICY"; break;
1131 case MODALLOCPRIV: s = "MODALLOCPRIV"; break;
1132 case MODGETDEVPOLICYBYNAME:
1133 s = "MODGETDEVPOLICYBYNAME"; break;
1134 case MODLOADMINORPERM: s = "MODLOADMINORPERM"; break;
1135 case MODADDMINORPERM: s = "MODADDMINORPERM"; break;
1136 case MODREMMINORPERM: s = "MODREMMINORPERM"; break;
1137 case MODREMDRVCLEANUP: s = "MODREMDRVCLEANUP"; break;
1138 case MODDEVEXISTS: s = "MODDEVEXISTS"; break;
1139 case MODDEVREADDIR: s = "MODDEVREADDIR"; break;
1140 case MODDEVEMPTYDIR: s = "MODDEVEMPTYDIR"; break;
1141 case MODDEVNAME: s = "MODDEVNAME"; break;
1142 case MODGETDEVFSPATH_MI_LEN:
1143 s = "MODGETDEVFSPATH_MI_LEN"; break;
1144 case MODGETDEVFSPATH_MI:
1145 s = "MODGETDEVFSPATH_MI"; break;
1146 case MODREMDRVALIAS: s = "MODREMDRVALIAS"; break;
1147 case MODHPOPS: s = "MODHPOPS"; break;
1148 }
1149 }
1150
1151 if (s == NULL)
1152 prt_dec(pri, 0, val);
1153 else
1154 outstring(pri, s);
1155 }
1156
1157 void
1158 prt_acl(private_t *pri, int raw, long val) /* print acl() code */
1159 {
1160 const char *s = NULL;
1161
1162 if (!raw) {
1163 switch (val) {
1164 case GETACL: s = "GETACL"; break;
1165 case SETACL: s = "SETACL"; break;
1166 case GETACLCNT: s = "GETACLCNT"; break;
1167 case ACE_GETACL: s = "ACE_GETACL"; break;
1168 case ACE_SETACL: s = "ACE_SETACL"; break;
1169 case ACE_GETACLCNT: s = "ACE_GETACLCNT"; break;
1170 }
1171 }
1172
1173 if (s == NULL)
1174 prt_dec(pri, 0, val);
1175 else
1176 outstring(pri, s);
1177 }
1178
1179 void
1180 prt_aio(private_t *pri, int raw, long val) /* print kaio() code */
1181 {
1182 const char *s = NULL;
1183 char buf[32];
1184
1185 if (!raw) {
1186 switch (val & ~AIO_POLL_BIT) {
1187 case AIOREAD: s = "AIOREAD"; break;
1188 case AIOWRITE: s = "AIOWRITE"; break;
1189 case AIOWAIT: s = "AIOWAIT"; break;
1190 case AIOCANCEL: s = "AIOCANCEL"; break;
1191 case AIONOTIFY: s = "AIONOTIFY"; break;
1192 case AIOINIT: s = "AIOINIT"; break;
1193 case AIOSTART: s = "AIOSTART"; break;
1194 case AIOLIO: s = "AIOLIO"; break;
1195 case AIOSUSPEND: s = "AIOSUSPEND"; break;
1196 case AIOERROR: s = "AIOERROR"; break;
1197 case AIOLIOWAIT: s = "AIOLIOWAIT"; break;
1198 case AIOAREAD: s = "AIOAREAD"; break;
1199 case AIOAWRITE: s = "AIOAWRITE"; break;
1200 /*
1201 * We have to hardcode the values for the 64-bit versions of
1202 * these calls, because <sys/aio.h> defines them to be identical
1203 * when compiled 64-bit. If our target is 32-bit, we still need
1204 * to decode them correctly.
1205 */
1206 case 13: s = "AIOLIO64"; break;
1207 case 14: s = "AIOSUSPEND64"; break;
1208 case 15: s = "AUIOERROR64"; break;
1209 case 16: s = "AIOLIOWAIT64"; break;
1210 case 17: s = "AIOAREAD64"; break;
1211 case 18: s = "AIOAWRITE64"; break;
1212 case 19: s = "AIOCANCEL64"; break;
1213
1214 /*
1215 * AIOFSYNC doesn't correspond to a syscall.
1216 */
1217 case AIOWAITN: s = "AIOWAITN"; break;
1218 }
1219 if (s != NULL && (val & AIO_POLL_BIT)) {
1220 (void) strlcpy(buf, s, sizeof (buf));
1221 (void) strlcat(buf, "|AIO_POLL_BIT", sizeof (buf));
1222 s = (const char *)buf;
1223 }
1224 }
1225
1226 if (s == NULL)
1227 prt_dec(pri, 0, val);
1228 else
1229 outstring(pri, s);
1230 }
1231
1232 void
1233 prt_cor(private_t *pri, int raw, long val) /* print corectl() subcode */
1234 {
1235 const char *s = NULL;
1236
1237 if (!raw) {
1238 switch (val) {
1239 case CC_SET_OPTIONS:
1240 s = "CC_SET_OPTIONS"; break;
1241 case CC_GET_OPTIONS:
1242 s = "CC_GET_OPTIONS"; break;
1243 case CC_SET_GLOBAL_PATH:
1244 s = "CC_SET_GLOBAL_PATH"; break;
1245 case CC_GET_GLOBAL_PATH:
1246 s = "CC_GET_GLOBAL_PATH"; break;
1247 case CC_SET_PROCESS_PATH:
1248 s = "CC_SET_PROCESS_PATH"; break;
1249 case CC_GET_PROCESS_PATH:
1250 s = "CC_GET_PROCESS_PATH"; break;
1251 case CC_SET_GLOBAL_CONTENT:
1252 s = "CC_SET_GLOBAL_CONTENT"; break;
1253 case CC_GET_GLOBAL_CONTENT:
1254 s = "CC_GET_GLOBAL_CONTENT"; break;
1255 case CC_SET_PROCESS_CONTENT:
1256 s = "CC_SET_PROCESS_CONTENT"; break;
1257 case CC_GET_PROCESS_CONTENT:
1258 s = "CC_GET_PROCESS_CONTENT"; break;
1259 case CC_SET_DEFAULT_PATH:
1260 s = "CC_SET_DEFAULT_PATH"; break;
1261 case CC_GET_DEFAULT_PATH:
1262 s = "CC_GET_DEFAULT_PATH"; break;
1263 case CC_SET_DEFAULT_CONTENT:
1264 s = "CC_SET_DEFAULT_CONTENT"; break;
1265 case CC_GET_DEFAULT_CONTENT:
1266 s = "CC_GET_DEFAULT_CONTENT"; break;
1267 }
1268 }
1269
1270 if (s == NULL)
1271 prt_dec(pri, 0, val);
1272 else
1273 outstring(pri, s);
1274 }
1275
1276 void
1277 prt_cco(private_t *pri, int raw, long val) /* print corectl() options */
1278 {
1279 char *s;
1280
1281 if (val == 0)
1282 prt_dec(pri, 0, val);
1283 else if (raw || (val & ~CC_OPTIONS))
1284 prt_hhx(pri, 0, val);
1285 else {
1286 #define CBSIZE sizeof (pri->code_buf)
1287 s = pri->code_buf;
1288 *s = '\0';
1289 if (val & CC_GLOBAL_PATH)
1290 (void) strlcat(s, "|CC_GLOBAL_PATH", CBSIZE);
1291 if (val & CC_PROCESS_PATH)
1292 (void) strlcat(s, "|CC_PROCESS_PATH", CBSIZE);
1293 if (val & CC_GLOBAL_SETID)
1294 (void) strlcat(s, "|CC_GLOBAL_SETID", CBSIZE);
1295 if (val & CC_PROCESS_SETID)
1296 (void) strlcat(s, "|CC_PROCESS_SETID", CBSIZE);
1297 if (val & CC_GLOBAL_LOG)
1298 (void) strlcat(s, "|CC_GLOBAL_LOG", CBSIZE);
1299 if (*s == '\0')
1300 prt_hhx(pri, 0, val);
1301 else
1302 outstring(pri, ++s);
1303 #undef CBSIZE
1304 }
1305 }
1306
1307 void
1308 prt_ccc(private_t *pri, int raw, long val) /* print corectl() content */
1309 {
1310 core_content_t ccc;
1311
1312 if (Pread(Proc, &ccc, sizeof (ccc), val) != sizeof (ccc))
1313 prt_hex(pri, 0, val);
1314 else if (!raw && proc_content2str(ccc, pri->code_buf,
1315 sizeof (pri->code_buf)) >= 0)
1316 outstring(pri, pri->code_buf);
1317 else
1318 prt_hhx(pri, 0, (long)ccc);
1319 }
1320
1321 void
1322 prt_rcc(private_t *pri, int raw, long val) /* print corectl() ret. cont. */
1323 {
1324 core_content_t ccc;
1325
1326 if (pri->Errno || Pread(Proc, &ccc, sizeof (ccc), val) != sizeof (ccc))
1327 prt_hex(pri, 0, val);
1328 else if (!raw && proc_content2str(ccc, pri->code_buf,
1329 sizeof (pri->code_buf)) >= 0)
1330 outstring(pri, pri->code_buf);
1331 else
1332 prt_hhx(pri, 0, (long)ccc);
1333 }
1334
1335 void
1336 prt_cpc(private_t *pri, int raw, long val) /* print cpc() subcode */
1337 {
1338 const char *s = NULL;
1339
1340 if (!raw) {
1341 switch (val) {
1342 case CPC_BIND: s = "CPC_BIND"; break;
1343 case CPC_SAMPLE: s = "CPC_SAMPLE"; break;
1344 case CPC_INVALIDATE: s = "CPC_INVALIDATE"; break;
1345 case CPC_RELE: s = "CPC_RELE"; break;
1346 case CPC_EVLIST_SIZE: s = "CPC_EVLIST_SIZE"; break;
1347 case CPC_LIST_EVENTS: s = "CPC_LIST_EVENTS"; break;
1348 case CPC_ATTRLIST_SIZE: s = "CPC_ATTRLIST_SIZE"; break;
1349 case CPC_LIST_ATTRS: s = "CPC_LIST_ATTRS"; break;
1350 case CPC_IMPL_NAME: s = "CPC_IMPL_NAME"; break;
1351 case CPC_CPUREF: s = "CPC_CPUREF"; break;
1352 case CPC_USR_EVENTS: s = "CPC_USR_EVENTS"; break;
1353 case CPC_SYS_EVENTS: s = "CPC_SYS_EVENTS"; break;
1354 case CPC_NPIC: s = "CPC_NPIC"; break;
1355 case CPC_CAPS: s = "CPC_CAPS"; break;
1356 case CPC_ENABLE: s = "CPC_ENABLE"; break;
1357 case CPC_DISABLE: s = "CPC_DISABLE"; break;
1358 }
1359 }
1360
1361 if (s == NULL)
1362 prt_dec(pri, 0, val);
1363 else
1364 outstring(pri, s);
1365 }
1366
1367 void
1368 outstring(private_t *pri, const char *s)
1369 {
1370 int len = strlen(s);
1371
1372 GROW(len);
1373 (void) strcpy(pri->sys_string + pri->sys_leng, s);
1374 pri->sys_leng += len;
1375 }
1376
1377 void
1378 grow(private_t *pri, int nbyte) /* reallocate format buffer if necessary */
1379 {
1380 while (pri->sys_leng + nbyte >= pri->sys_ssize)
1381 pri->sys_string = my_realloc(pri->sys_string,
1382 pri->sys_ssize *= 2, "format buffer");
1383 }
1384
1385 void
1386 prt_sqc(private_t *pri, int raw, long val) /* print sigqueue() si_code */
1387 {
1388 const char *s = NULL;
1389
1390 if (!raw) {
1391 switch ((int)val) {
1392 case SI_QUEUE: s = "SI_QUEUE"; break;
1393 case SI_TIMER: s = "SI_TIMER"; break;
1394 case SI_ASYNCIO: s = "SI_ASYNCIO"; break;
1395 case SI_MESGQ: s = "SI_MESGQ"; break;
1396 }
1397 }
1398
1399 if (s == NULL)
1400 prt_dec(pri, 0, val);
1401 else
1402 outstring(pri, s);
1403 }
1404
1405 /*
1406 * print priocntlsys() (key, value) pair key.
1407 */
1408 void
1409 print_pck(private_t *pri, int raw, long val)
1410 {
1411 const char *s = NULL;
1412 char clname[PC_CLNMSZ];
1413
1414 if ((pri->sys_args[2] != PC_GETXPARMS &&
1415 pri->sys_args[2] != PC_SETXPARMS) || val == 0 || raw) {
1416 prt_dec(pri, 0, val);
1417 return;
1418 }
1419
1420 if (pri->sys_args[3] == 0) {
1421 if (val == PC_KY_CLNAME) {
1422 s = "PC_KY_CLNAME";
1423 outstring(pri, s);
1424 } else
1425 prt_dec(pri, 0, val);
1426 return;
1427 }
1428
1429 if (Pread(Proc, &clname, PC_CLNMSZ, pri->sys_args[3]) != PC_CLNMSZ) {
1430 prt_dec(pri, 0, val);
1431 return;
1432 }
1433
1434 if (strcmp(clname, "TS") == 0) {
1435 switch (val) {
1436 case TS_KY_UPRILIM: s = "TS_KY_UPRILIM"; break;
1437 case TS_KY_UPRI: s = "TS_KY_UPRI"; break;
1438 default: break;
1439 }
1440 } else if (strcmp(clname, "IA") == 0) {
1441 switch (val) {
1442 case IA_KY_UPRILIM: s = "IA_KY_UPRILIM"; break;
1443 case IA_KY_UPRI: s = "IA_KY_UPRI"; break;
1444 case IA_KY_MODE: s = "IA_KY_MODE"; break;
1445 default: break;
1446 }
1447 } else if (strcmp(clname, "RT") == 0) {
1448 switch (val) {
1449 case RT_KY_PRI: s = "RT_KY_PRI"; break;
1450 case RT_KY_TQSECS: s = "RT_KY_TQSECS"; break;
1451 case RT_KY_TQNSECS: s = "RT_KY_TQNSECS"; break;
1452 case RT_KY_TQSIG: s = "RT_KY_TQSIG"; break;
1453 default: break;
1454 }
1455 } else if (strcmp(clname, "FSS") == 0) {
1456 switch (val) {
1457 case FSS_KY_UPRILIM: s = "FSS_KY_UPRILIM"; break;
1458 case FSS_KY_UPRI: s = "FSS_KY_UPRI"; break;
1459 default: break;
1460 }
1461 } else if (strcmp(clname, "FX") == 0) {
1462 switch (val) {
1463 case FX_KY_UPRILIM: s = "FX_KY_UPRILIM"; break;
1464 case FX_KY_UPRI: s = "FX_KY_UPRI"; break;
1465 case FX_KY_TQSECS: s = "FX_KY_TQSECS"; break;
1466 case FX_KY_TQNSECS: s = "FX_KY_TQNSECS"; break;
1467 default: break;
1468 }
1469 }
1470
1471 if (s == NULL)
1472 prt_dec(pri, 0, val);
1473 else
1474 outstring(pri, s);
1475 }
1476
1477 /*
1478 * print priocntlsys() fourth argument.
1479 */
1480 /*ARGSUSED*/
1481 void
1482 prt_pc4(private_t *pri, int raw, long val)
1483 {
1484 /* look at pricntlsys function */
1485 if ((pri->sys_args[2] != PC_GETXPARMS &&
1486 pri->sys_args[2] != PC_SETXPARMS))
1487 prt_hex(pri, 0, val);
1488 else if (val)
1489 prt_stg(pri, 0, val);
1490 else
1491 prt_dec(pri, 0, val);
1492 }
1493
1494 /*
1495 * print priocntlsys() (key, value) pairs (5th argument).
1496 */
1497 /*ARGSUSED*/
1498 void
1499 prt_pc5(private_t *pri, int raw, long val)
1500 {
1501 pc_vaparms_t prms;
1502 pc_vaparm_t *vpp = &prms.pc_parms[0];
1503 uint_t cnt;
1504
1505
1506 /* look at pricntlsys function */
1507 if ((pri->sys_args[2] != PC_GETXPARMS &&
1508 pri->sys_args[2] != PC_SETXPARMS) || val == 0) {
1509 prt_dec(pri, 0, 0);
1510 return;
1511 }
1512
1513 if (Pread(Proc, &prms, sizeof (prms), val) != sizeof (prms)) {
1514 prt_hex(pri, 0, val);
1515 return;
1516 }
1517
1518 if ((cnt = prms.pc_vaparmscnt) > PC_VAPARMCNT)
1519 return;
1520
1521 for (; cnt--; vpp++) {
1522 print_pck(pri, 0, vpp->pc_key);
1523 outstring(pri, ", ");
1524 prt_hex(pri, 0, (long)vpp->pc_parm);
1525 outstring(pri, ", ");
1526 }
1527
1528 prt_dec(pri, 0, PC_KY_NULL);
1529 }
1530
1531
1532 void
1533 prt_psflags(private_t *pri, secflagset_t val)
1534 {
1535 char str[1024];
1536
1537 if (val == 0) {
1538 outstring(pri, "0x0");
1539 return;
1540 }
1541
1542 *str = '\0';
1543 if (secflag_isset(val, PROC_SEC_ASLR)) {
1544 (void) strlcat(str, "|PROC_SEC_ASLR", sizeof (str));
1545 secflag_clear(&val, PROC_SEC_ASLR);
1546 }
1547 if (secflag_isset(val, PROC_SEC_FORBIDNULLMAP)) {
1548 (void) strlcat(str, "|PROC_SEC_FORBIDNULLMAP",
1549 sizeof (str));
1550 secflag_clear(&val, PROC_SEC_FORBIDNULLMAP);
1551 }
1552 if (secflag_isset(val, PROC_SEC_NOEXECSTACK)) {
1553 (void) strlcat(str, "|PROC_SEC_NOEXECSTACK",
1554 sizeof (str));
1555 secflag_clear(&val, PROC_SEC_NOEXECSTACK);
1556 }
1557
1558 if (val != 0)
1559 (void) snprintf(str, sizeof (str), "%s|%#x", str, val);
1560
1561 outstring(pri, str + 1);
1562 }
1563
1564 /*
1565 * Print a psecflags(2) delta
1566 */
1567 void
1568 prt_psdelta(private_t *pri, int raw, long value)
1569 {
1570 secflagdelta_t psd;
1571
1572 if ((raw != 0) ||
1573 (Pread(Proc, &psd, sizeof (psd), value) != sizeof (psd))) {
1574 prt_hex(pri, 0, value);
1575 return;
1576 }
1577 outstring(pri, "{ ");
1578 prt_psflags(pri, psd.psd_add);
1579 outstring(pri, ", ");
1580 prt_psflags(pri, psd.psd_rem);
1581 outstring(pri, ", ");
1582 prt_psflags(pri, psd.psd_assign);
1583 outstring(pri, ", ");
1584 outstring(pri, psd.psd_ass_active ? "B_TRUE" : "B_FALSE");
1585 outstring(pri, " }");
1586 }
1587
1588 /*
1589 * Print a psecflagswhich_t
1590 */
1591 void
1592 prt_psfw(private_t *pri, int raw, long value)
1593 {
1594 psecflagwhich_t which = (psecflagwhich_t)value;
1595 char *s;
1596
1597 if (raw != 0) {
1598 prt_dec(pri, 0, value);
1599 return;
1600 }
1601
1602 switch (which) {
1603 case PSF_EFFECTIVE:
1604 s = "PSF_EFFECTIVE";
1605 break;
1606 case PSF_INHERIT:
1607 s = "PSF_INHERIT";
1608 break;
1609 case PSF_LOWER:
1610 s = "PSF_LOWER";
1611 break;
1612 case PSF_UPPER:
1613 s = "PSF_UPPER";
1614 break;
1615 }
1616
1617 if (s == NULL)
1618 prt_dec(pri, 0, value);
1619 else
1620 outstring(pri, s);
1621 }
1622
1623 /*
1624 * Print processor set id, including logical expansion of "special" ids.
1625 */
1626 void
1627 prt_pst(private_t *pri, int raw, long val)
1628 {
1629 const char *s = NULL;
1630
1631 if (!raw) {
1632 switch ((psetid_t)val) {
1633 case PS_NONE: s = "PS_NONE"; break;
1634 case PS_QUERY: s = "PS_QUERY"; break;
1635 case PS_MYID: s = "PS_MYID"; break;
1636 }
1637 }
1638
1639 if (s == NULL)
1640 prt_dec(pri, 0, val);
1641 else
1642 outstring(pri, s);
1643 }
1644
1645 /*
1646 * Print meminfo() argument.
1647 */
1648 /*ARGSUSED*/
1649 void
1650 prt_mif(private_t *pri, int raw, long val)
1651 {
1652 struct meminfo minfo;
1653
1654 #ifdef _LP64
1655 if (data_model == PR_MODEL_ILP32) {
1656 struct meminfo32 minfo32;
1657
1658 if (Pread(Proc, &minfo32, sizeof (struct meminfo32), val) !=
1659 sizeof (struct meminfo32)) {
1660 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */
1661 outstring(pri, ", ");
1662 prt_hex(pri, 0, val);
1663 return;
1664 }
1665 /*
1666 * arrange the arguments in the order that user calls with
1667 */
1668 prt_hex(pri, 0, minfo32.mi_inaddr);
1669 outstring(pri, ", ");
1670 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */
1671 outstring(pri, ", ");
1672 prt_hex(pri, 0, minfo32.mi_info_req);
1673 outstring(pri, ", ");
1674 prt_dec(pri, 0, minfo32.mi_info_count);
1675 outstring(pri, ", ");
1676 prt_hex(pri, 0, minfo32.mi_outdata);
1677 outstring(pri, ", ");
1678 prt_hex(pri, 0, minfo32.mi_validity);
1679 return;
1680 }
1681 #endif
1682 if (Pread(Proc, &minfo, sizeof (struct meminfo), val) !=
1683 sizeof (struct meminfo)) {
1684 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */
1685 outstring(pri, ", ");
1686 prt_hex(pri, 0, val);
1687 return;
1688 }
1689 /*
1690 * arrange the arguments in the order that user calls with
1691 */
1692 prt_hex(pri, 0, (long)minfo.mi_inaddr);
1693 outstring(pri, ", ");
1694 prt_dec(pri, 0, pri->sys_args[1]); /* addr_count */
1695 outstring(pri, ", ");
1696 prt_hex(pri, 0, (long)minfo.mi_info_req);
1697 outstring(pri, ", ");
1698 prt_dec(pri, 0, minfo.mi_info_count);
1699 outstring(pri, ", ");
1700 prt_hex(pri, 0, (long)minfo.mi_outdata);
1701 outstring(pri, ", ");
1702 prt_hex(pri, 0, (long)minfo.mi_validity);
1703 }
1704
1705
1706 /*
1707 * Print so_socket() 1st argument.
1708 */
1709 /*ARGSUSED*/
1710 void
1711 prt_pfm(private_t *pri, int raw, long val)
1712 {
1713 /* Protocol Families have same names as Address Families */
1714 if ((ulong_t)val < MAX_AFCODES) {
1715 outstring(pri, "PF_");
1716 outstring(pri, afcodes[val]);
1717 } else {
1718 prt_dec(pri, 0, val);
1719 }
1720 }
1721
1722 /*
1723 * Print sockconfig() subcode.
1724 */
1725 /*ARGSUSED*/
1726 void
1727 prt_skc(private_t *pri, int raw, long val)
1728 {
1729 const char *s = NULL;
1730
1731 if (!raw) {
1732 switch (val) {
1733 case SOCKCONFIG_ADD_SOCK:
1734 s = "SOCKCONFIG_ADD_SOCK"; break;
1735 case SOCKCONFIG_REMOVE_SOCK:
1736 s = "SOCKCONFIG_REMOVE_SOCK"; break;
1737 case SOCKCONFIG_ADD_FILTER:
1738 s = "SOCKCONFIG_ADD_FILTER"; break;
1739 case SOCKCONFIG_REMOVE_FILTER:
1740 s = "SOCKCONFIG_REMOVE_FILTER"; break;
1741 }
1742 }
1743 if (s == NULL)
1744 prt_dec(pri, 0, val);
1745 else
1746 outstring(pri, s);
1747 }
1748 /*
1749 * Print so_socket() 2nd argument.
1750 */
1751 /*ARGSUSED*/
1752 void
1753 prt_skt(private_t *pri, int raw, long val)
1754 {
1755 const char *s;
1756 long type = val & SOCK_TYPE_MASK;
1757
1758 if ((ulong_t)type <= MAX_SOCKTYPES &&
1759 (s = socktype_codes[type]) != NULL) {
1760 outstring(pri, s);
1761 if ((val & SOCK_CLOEXEC) != 0) {
1762 outstring(pri, "|SOCK_CLOEXEC");
1763 }
1764 } else {
1765 prt_dec(pri, 0, val);
1766 }
1767 }
1768
1769
1770 /*
1771 * Print so_socket() 3rd argument.
1772 */
1773 /*ARGSUSED*/
1774 void
1775 prt_skp(private_t *pri, int raw, long val)
1776 {
1777 const char *s;
1778
1779 /* cheating -- look at the protocol-family */
1780 switch (pri->sys_args[0]) {
1781 case PF_INET6:
1782 case PF_INET: if ((s = ipprotos((int)val)) != NULL) {
1783 outstring(pri, s);
1784 break;
1785 }
1786 /* FALLTHROUGH */
1787 default: prt_dec(pri, 0, val);
1788 break;
1789 }
1790 }
1791
1792
1793 /*
1794 * Print accept4() flags argument.
1795 */
1796 void
1797 prt_acf(private_t *pri, int raw, long val)
1798 {
1799 int first = 1;
1800 if (raw || !val ||
1801 (val & ~(SOCK_CLOEXEC|SOCK_NDELAY|SOCK_NONBLOCK))) {
1802 prt_dex(pri, 0, val);
1803 return;
1804 }
1805
1806 if (val & SOCK_CLOEXEC) {
1807 outstring(pri, "|SOCK_CLOEXEC" + first);
1808 first = 0;
1809 }
1810 if (val & SOCK_NDELAY) {
1811 outstring(pri, "|SOCK_NDELAY" + first);
1812 first = 0;
1813 }
1814 if (val & SOCK_NONBLOCK) {
1815 outstring(pri, "|SOCK_NONBLOCK" + first);
1816 }
1817 }
1818
1819
1820 /*
1821 * Print setsockopt()/getsockopt() 2nd argument.
1822 */
1823 /*ARGSUSED*/
1824 void
1825 prt_sol(private_t *pri, int raw, long val)
1826 {
1827 if (val == SOL_SOCKET) {
1828 outstring(pri, "SOL_SOCKET");
1829 } else if (val == SOL_ROUTE) {
1830 outstring(pri, "SOL_ROUTE");
1831 } else {
1832 const struct protoent *p;
1833 struct protoent res;
1834 char buf[NSS_BUFLEN_PROTOCOLS];
1835
1836 if ((p = getprotobynumber_r(val, &res,
1837 (char *)buf, sizeof (buf))) != NULL)
1838 outstring(pri, p->p_name);
1839 else
1840 prt_dec(pri, 0, val);
1841 }
1842 }
1843
1844
1845 const char *
1846 sol_optname(private_t *pri, long val)
1847 {
1848 #define CBSIZE sizeof (pri->code_buf)
1849 if (val >= SO_SNDBUF) {
1850 switch (val) {
1851 case SO_SNDBUF: return ("SO_SNDBUF");
1852 case SO_RCVBUF: return ("SO_RCVBUF");
1853 case SO_SNDLOWAT: return ("SO_SNDLOWAT");
1854 case SO_RCVLOWAT: return ("SO_RCVLOWAT");
1855 case SO_SNDTIMEO: return ("SO_SNDTIMEO");
1856 case SO_RCVTIMEO: return ("SO_RCVTIMEO");
1857 case SO_ERROR: return ("SO_ERROR");
1858 case SO_TYPE: return ("SO_TYPE");
1859 case SO_PROTOTYPE: return ("SO_PROTOTYPE");
1860 case SO_ALLZONES: return ("SO_ALLZONES");
1861 case SO_VRRP: return ("SO_VRRP");
1862 case SO_EXCLBIND: return ("SO_EXCLBIND");
1863 case SO_DOMAIN: return ("SO_DOMAIN");
1864
1865 default: (void) snprintf(pri->code_buf, CBSIZE,
1866 "0x%lx", val);
1867 return (pri->code_buf);
1868 }
1869 } else {
1870 char *s = pri->code_buf;
1871 size_t used = 1;
1872 long val2;
1873
1874 *s = '\0';
1875 val2 = val & ~(SO_DEBUG|SO_ACCEPTCONN|SO_REUSEADDR|SO_KEEPALIVE|
1876 SO_DONTROUTE|SO_BROADCAST|SO_USELOOPBACK|SO_LINGER|
1877 SO_OOBINLINE|SO_DGRAM_ERRIND|SO_RECVUCRED);
1878 if (val2)
1879 used = snprintf(s, CBSIZE, "|0x%lx", val2);
1880 if (val & SO_DEBUG)
1881 used = strlcat(s, "|SO_DEBUG", CBSIZE);
1882 if (val & SO_ACCEPTCONN)
1883 used = strlcat(s, "|SO_ACCEPTCONN", CBSIZE);
1884 if (val & SO_REUSEADDR)
1885 used = strlcat(s, "|SO_REUSEADDR", CBSIZE);
1886 if (val & SO_KEEPALIVE)
1887 used = strlcat(s, "|SO_KEEPALIVE", CBSIZE);
1888 if (val & SO_DONTROUTE)
1889 used = strlcat(s, "|SO_DONTROUTE", CBSIZE);
1890 if (val & SO_BROADCAST)
1891 used = strlcat(s, "|SO_BROADCAST", CBSIZE);
1892 if (val & SO_USELOOPBACK)
1893 used = strlcat(s, "|SO_USELOOPBACK", CBSIZE);
1894 if (val & SO_LINGER)
1895 used = strlcat(s, "|SO_LINGER", CBSIZE);
1896 if (val & SO_OOBINLINE)
1897 used = strlcat(s, "|SO_OOBINLINE", CBSIZE);
1898 if (val & SO_DGRAM_ERRIND)
1899 used = strlcat(s, "|SO_DGRAM_ERRIND", CBSIZE);
1900 if (val & SO_RECVUCRED)
1901 used = strlcat(s, "|SO_RECVUCRED", CBSIZE);
1902 if (used >= CBSIZE || val == 0)
1903 (void) snprintf(s + 1, CBSIZE-1, "0x%lx", val);
1904 return ((const char *)(s + 1));
1905 }
1906 #undef CBSIZE
1907 }
1908
1909 const char *
1910 route_optname(private_t *pri, long val)
1911 {
1912 switch (val) {
1913 case RT_AWARE:
1914 return ("RT_AWARE");
1915 default:
1916 (void) snprintf(pri->code_buf, sizeof (pri->code_buf),
1917 "0x%lx", val);
1918 return (pri->code_buf);
1919 }
1920 }
1921
1922 const char *
1923 tcp_optname(private_t *pri, long val)
1924 {
1925 switch (val) {
1926 case TCP_NODELAY: return ("TCP_NODELAY");
1927 case TCP_MAXSEG: return ("TCP_MAXSEG");
1928 case TCP_KEEPALIVE: return ("TCP_KEEPALIVE");
1929 case TCP_NOTIFY_THRESHOLD: return ("TCP_NOTIFY_THRESHOLD");
1930 case TCP_ABORT_THRESHOLD: return ("TCP_ABORT_THRESHOLD");
1931 case TCP_CONN_NOTIFY_THRESHOLD: return ("TCP_CONN_NOTIFY_THRESHOLD");
1932 case TCP_CONN_ABORT_THRESHOLD: return ("TCP_CONN_ABORT_THRESHOLD");
1933 case TCP_RECVDSTADDR: return ("TCP_RECVDSTADDR");
1934 case TCP_ANONPRIVBIND: return ("TCP_ANONPRIVBIND");
1935 case TCP_EXCLBIND: return ("TCP_EXCLBIND");
1936 case TCP_INIT_CWND: return ("TCP_INIT_CWND");
1937 case TCP_KEEPALIVE_THRESHOLD: return ("TCP_KEEPALIVE_THRESHOLD");
1938 case TCP_KEEPALIVE_ABORT_THRESHOLD:
1939 return ("TCP_KEEPALIVE_ABORT_THRESHOLD");
1940 case TCP_CORK: return ("TCP_CORK");
1941 case TCP_RTO_INITIAL: return ("TCP_RTO_INITIAL");
1942 case TCP_RTO_MIN: return ("TCP_RTO_MIN");
1943 case TCP_RTO_MAX: return ("TCP_RTO_MAX");
1944 case TCP_LINGER2: return ("TCP_LINGER2");
1945 case TCP_KEEPIDLE: return ("TCP_KEEPIDLE");
1946 case TCP_KEEPCNT: return ("TCP_KEEPCNT");
1947 case TCP_KEEPINTVL: return ("TCP_KEEPINTVL");
1948
1949 default: (void) snprintf(pri->code_buf,
1950 sizeof (pri->code_buf),
1951 "0x%lx", val);
1952 return (pri->code_buf);
1953 }
1954 }
1955
1956
1957 const char *
1958 sctp_optname(private_t *pri, long val)
1959 {
1960 switch (val) {
1961 case SCTP_RTOINFO: return ("SCTP_RTOINFO");
1962 case SCTP_ASSOCINFO: return ("SCTP_ASSOCINFO");
1963 case SCTP_INITMSG: return ("SCTP_INITMSG");
1964 case SCTP_NODELAY: return ("SCTP_NODELAY");
1965 case SCTP_AUTOCLOSE: return ("SCTP_AUTOCLOSE");
1966 case SCTP_SET_PEER_PRIMARY_ADDR:
1967 return ("SCTP_SET_PEER_PRIMARY_ADDR");
1968 case SCTP_PRIMARY_ADDR: return ("SCTP_PRIMARY_ADDR");
1969 case SCTP_ADAPTATION_LAYER: return ("SCTP_ADAPTATION_LAYER");
1970 case SCTP_DISABLE_FRAGMENTS: return ("SCTP_DISABLE_FRAGMENTS");
1971 case SCTP_PEER_ADDR_PARAMS: return ("SCTP_PEER_ADDR_PARAMS");
1972 case SCTP_DEFAULT_SEND_PARAM: return ("SCTP_DEFAULT_SEND_PARAM");
1973 case SCTP_EVENTS: return ("SCTP_EVENTS");
1974 case SCTP_I_WANT_MAPPED_V4_ADDR:
1975 return ("SCTP_I_WANT_MAPPED_V4_ADDR");
1976 case SCTP_MAXSEG: return ("SCTP_MAXSEG");
1977 case SCTP_STATUS: return ("SCTP_STATUS");
1978 case SCTP_GET_PEER_ADDR_INFO: return ("SCTP_GET_PEER_ADDR_INFO");
1979
1980 case SCTP_ADD_ADDR: return ("SCTP_ADD_ADDR");
1981 case SCTP_REM_ADDR: return ("SCTP_REM_ADDR");
1982
1983 default: (void) snprintf(pri->code_buf,
1984 sizeof (pri->code_buf),
1985 "0x%lx", val);
1986 return (pri->code_buf);
1987 }
1988 }
1989
1990
1991 const char *
1992 udp_optname(private_t *pri, long val)
1993 {
1994 switch (val) {
1995 case UDP_CHECKSUM: return ("UDP_CHECKSUM");
1996 case UDP_ANONPRIVBIND: return ("UDP_ANONPRIVBIND");
1997 case UDP_EXCLBIND: return ("UDP_EXCLBIND");
1998 case UDP_RCVHDR: return ("UDP_RCVHDR");
1999 case UDP_NAT_T_ENDPOINT: return ("UDP_NAT_T_ENDPOINT");
2000
2001 default: (void) snprintf(pri->code_buf,
2002 sizeof (pri->code_buf), "0x%lx",
2003 val);
2004 return (pri->code_buf);
2005 }
2006 }
2007
2008
2009 /*
2010 * Print setsockopt()/getsockopt() 3rd argument.
2011 */
2012 /*ARGSUSED*/
2013 void
2014 prt_son(private_t *pri, int raw, long val)
2015 {
2016 /* cheating -- look at the level */
2017 switch (pri->sys_args[1]) {
2018 case SOL_SOCKET: outstring(pri, sol_optname(pri, val));
2019 break;
2020 case SOL_ROUTE: outstring(pri, route_optname(pri, val));
2021 break;
2022 case IPPROTO_TCP: outstring(pri, tcp_optname(pri, val));
2023 break;
2024 case IPPROTO_UDP: outstring(pri, udp_optname(pri, val));
2025 break;
2026 case IPPROTO_SCTP: outstring(pri, sctp_optname(pri, val));
2027 break;
2028 default: prt_dec(pri, 0, val);
2029 break;
2030 }
2031 }
2032
2033
2034 /*
2035 * Print utrap type
2036 */
2037 /*ARGSUSED*/
2038 void
2039 prt_utt(private_t *pri, int raw, long val)
2040 {
2041 const char *s = NULL;
2042
2043
2044 if (s == NULL)
2045 prt_dec(pri, 0, val);
2046 else
2047 outstring(pri, s);
2048 }
2049
2050
2051 /*
2052 * Print utrap handler
2053 */
2054 void
2055 prt_uth(private_t *pri, int raw, long val)
2056 {
2057 const char *s = NULL;
2058
2059 if (!raw) {
2060 switch (val) {
2061 case (long)UTH_NOCHANGE: s = "UTH_NOCHANGE"; break;
2062 }
2063 }
2064
2065 if (s == NULL)
2066 prt_hex(pri, 0, val);
2067 else
2068 outstring(pri, s);
2069 }
2070
2071 const char *
2072 access_flags(private_t *pri, long arg)
2073 {
2074 #define E_OK 010
2075 char *str = pri->code_buf;
2076
2077 if (arg & ~(R_OK|W_OK|X_OK|E_OK))
2078 return (NULL);
2079
2080 /* NB: F_OK == 0 */
2081 if (arg == F_OK)
2082 return ("F_OK");
2083 if (arg == E_OK)
2084 return ("F_OK|E_OK");
2085
2086 *str = '\0';
2087 if (arg & R_OK)
2088 (void) strlcat(str, "|R_OK", sizeof (pri->code_buf));
2089 if (arg & W_OK)
2090 (void) strlcat(str, "|W_OK", sizeof (pri->code_buf));
2091 if (arg & X_OK)
2092 (void) strlcat(str, "|X_OK", sizeof (pri->code_buf));
2093 if (arg & E_OK)
2094 (void) strlcat(str, "|E_OK", sizeof (pri->code_buf));
2095 return ((const char *)(str + 1));
2096 #undef E_OK
2097 }
2098
2099 /*
2100 * Print access() flags.
2101 */
2102 void
2103 prt_acc(private_t *pri, int raw, long val)
2104 {
2105 const char *s = raw? NULL : access_flags(pri, val);
2106
2107 if (s == NULL)
2108 prt_dex(pri, 0, val);
2109 else
2110 outstring(pri, s);
2111 }
2112
2113 /*
2114 * Print shutdown() "how" (2nd) argument
2115 */
2116 void
2117 prt_sht(private_t *pri, int raw, long val)
2118 {
2119 if (raw) {
2120 prt_dex(pri, 0, val);
2121 return;
2122 }
2123 switch (val) {
2124 case SHUT_RD: outstring(pri, "SHUT_RD"); break;
2125 case SHUT_WR: outstring(pri, "SHUT_WR"); break;
2126 case SHUT_RDWR: outstring(pri, "SHUT_RDWR"); break;
2127 default: prt_dec(pri, 0, val); break;
2128 }
2129 }
2130
2131 /*
2132 * Print fcntl() F_SETFL flags (3rd) argument or fdsync flag (2nd arg)
2133 */
2134 static struct fcntl_flags {
2135 long val;
2136 const char *name;
2137 } fcntl_flags[] = {
2138 #define FC_FL(flag) { (long)flag, "|" # flag }
2139 FC_FL(FREVOKED),
2140 FC_FL(FREAD),
2141 FC_FL(FWRITE),
2142 FC_FL(FNDELAY),
2143 FC_FL(FAPPEND),
2144 FC_FL(FSYNC),
2145 FC_FL(FDSYNC),
2146 FC_FL(FRSYNC),
2147 FC_FL(FOFFMAX),
2148 FC_FL(FNONBLOCK),
2149 FC_FL(FCREAT),
2150 FC_FL(FTRUNC),
2151 FC_FL(FEXCL),
2152 FC_FL(FNOCTTY),
2153 FC_FL(FXATTR),
2154 FC_FL(FASYNC),
2155 FC_FL(FNODSYNC)
2156 #undef FC_FL
2157 };
2158
2159 void
2160 prt_ffg(private_t *pri, int raw, long val)
2161 {
2162 #define CBSIZE sizeof (pri->code_buf)
2163 char *s = pri->code_buf;
2164 size_t used = 1;
2165 struct fcntl_flags *fp;
2166
2167 if (raw) {
2168 (void) snprintf(s, CBSIZE, "0x%lx", val);
2169 outstring(pri, s);
2170 return;
2171 }
2172 if (val == 0) {
2173 outstring(pri, "(no flags)");
2174 return;
2175 }
2176
2177 *s = '\0';
2178 for (fp = fcntl_flags;
2179 fp < &fcntl_flags[sizeof (fcntl_flags) / sizeof (*fp)]; fp++) {
2180 if (val & fp->val) {
2181 used = strlcat(s, fp->name, CBSIZE);
2182 val &= ~fp->val;
2183 }
2184 }
2185
2186 if (val != 0 && used <= CBSIZE)
2187 used += snprintf(s + used, CBSIZE - used, "|0x%lx", val);
2188
2189 if (used >= CBSIZE)
2190 (void) snprintf(s + 1, CBSIZE-1, "0x%lx", val);
2191 outstring(pri, s + 1);
2192 #undef CBSIZE
2193 }
2194
2195 void
2196 prt_prs(private_t *pri, int raw, long val)
2197 {
2198 static size_t setsize;
2199 priv_set_t *set = priv_allocset();
2200
2201 if (setsize == 0) {
2202 const priv_impl_info_t *info = getprivimplinfo();
2203 if (info != NULL)
2204 setsize = info->priv_setsize * sizeof (priv_chunk_t);
2205 }
2206
2207 if (setsize != 0 && !raw && set != NULL &&
2208 Pread(Proc, set, setsize, val) == setsize) {
2209 int i;
2210
2211 outstring(pri, "{");
2212 for (i = 0; i < setsize / sizeof (priv_chunk_t); i++) {
2213 char buf[9]; /* 8 hex digits + '\0' */
2214 (void) snprintf(buf, sizeof (buf), "%08x",
2215 ((priv_chunk_t *)set)[i]);
2216 outstring(pri, buf);
2217 }
2218
2219 outstring(pri, "}");
2220 } else {
2221 prt_hex(pri, 0, val);
2222 }
2223
2224 if (set != NULL)
2225 priv_freeset(set);
2226 }
2227
2228 /*
2229 * Print privilege set operation.
2230 */
2231 void
2232 prt_pro(private_t *pri, int raw, long val)
2233 {
2234 const char *s = NULL;
2235
2236 if (!raw) {
2237 switch ((priv_op_t)val) {
2238 case PRIV_ON: s = "PRIV_ON"; break;
2239 case PRIV_OFF: s = "PRIV_OFF"; break;
2240 case PRIV_SET: s = "PRIV_SET"; break;
2241 }
2242 }
2243
2244 if (s == NULL)
2245 prt_dec(pri, 0, val);
2246 else
2247 outstring(pri, s);
2248 }
2249
2250 /*
2251 * Print privilege set name
2252 */
2253 void
2254 prt_prn(private_t *pri, int raw, long val)
2255 {
2256 const char *s = NULL;
2257
2258 if (!raw)
2259 s = priv_getsetbynum((int)val);
2260
2261 if (s == NULL)
2262 prt_dec(pri, 0, val);
2263 else {
2264 char *dup = strdup(s);
2265 char *q;
2266
2267 /* Do the best we can in this case */
2268 if (dup == NULL) {
2269 outstring(pri, s);
2270 return;
2271 }
2272
2273 outstring(pri, "PRIV_");
2274
2275 q = dup;
2276
2277 while (*q != '\0') {
2278 *q = toupper(*q);
2279 q++;
2280 }
2281 outstring(pri, dup);
2282 free(dup);
2283 }
2284 }
2285
2286 /*
2287 * Print process flag names.
2288 */
2289 void
2290 prt_pfl(private_t *pri, int raw, long val)
2291 {
2292 const char *s = NULL;
2293
2294 if (!raw) {
2295 switch ((int)val) {
2296 case PRIV_DEBUG: s = "PRIV_DEBUG"; break;
2297 case PRIV_AWARE: s = "PRIV_AWARE"; break;
2298 case PRIV_XPOLICY: s = "PRIV_XPOLICY"; break;
2299 case PRIV_AWARE_RESET: s = "PRIV_AWARE_RESET"; break;
2300 case PRIV_PFEXEC: s = "PRIV_PFEXEC"; break;
2301 }
2302 }
2303
2304 if (s == NULL)
2305 prt_dec(pri, 0, val);
2306 else
2307 outstring(pri, s);
2308 }
2309
2310 /*
2311 * Print lgrp_affinity_{get,set}() arguments.
2312 */
2313 /*ARGSUSED*/
2314 void
2315 prt_laf(private_t *pri, int raw, long val)
2316 {
2317 lgrp_affinity_args_t laff;
2318
2319 if (Pread(Proc, &laff, sizeof (lgrp_affinity_args_t), val) !=
2320 sizeof (lgrp_affinity_args_t)) {
2321 prt_hex(pri, 0, val);
2322 return;
2323 }
2324 /*
2325 * arrange the arguments in the order that user calls with
2326 */
2327 prt_dec(pri, 0, laff.idtype);
2328 outstring(pri, ", ");
2329 prt_dec(pri, 0, laff.id);
2330 outstring(pri, ", ");
2331 prt_dec(pri, 0, laff.lgrp);
2332 outstring(pri, ", ");
2333 if (pri->sys_args[0] == LGRP_SYS_AFFINITY_SET)
2334 prt_dec(pri, 0, laff.aff);
2335 }
2336
2337 /*
2338 * Print a key_t as IPC_PRIVATE if it is 0.
2339 */
2340 void
2341 prt_key(private_t *pri, int raw, long val)
2342 {
2343 if (!raw && val == 0)
2344 outstring(pri, "IPC_PRIVATE");
2345 else
2346 prt_dec(pri, 0, val);
2347 }
2348
2349
2350 /*
2351 * Print zone_getattr() attribute types.
2352 */
2353 void
2354 prt_zga(private_t *pri, int raw, long val)
2355 {
2356 const char *s = NULL;
2357
2358 if (!raw) {
2359 switch ((int)val) {
2360 case ZONE_ATTR_NAME: s = "ZONE_ATTR_NAME"; break;
2361 case ZONE_ATTR_ROOT: s = "ZONE_ATTR_ROOT"; break;
2362 case ZONE_ATTR_STATUS: s = "ZONE_ATTR_STATUS"; break;
2363 case ZONE_ATTR_PRIVSET: s = "ZONE_ATTR_PRIVSET"; break;
2364 case ZONE_ATTR_UNIQID: s = "ZONE_ATTR_UNIQID"; break;
2365 case ZONE_ATTR_POOLID: s = "ZONE_ATTR_POOLID"; break;
2366 case ZONE_ATTR_INITPID: s = "ZONE_ATTR_INITPID"; break;
2367 case ZONE_ATTR_INITNAME: s = "ZONE_ATTR_INITNAME"; break;
2368 case ZONE_ATTR_BOOTARGS: s = "ZONE_ATTR_BOOTARGS"; break;
2369 case ZONE_ATTR_BRAND: s = "ZONE_ATTR_BRAND"; break;
2370 case ZONE_ATTR_FLAGS: s = "ZONE_ATTR_FLAGS"; break;
2371 case ZONE_ATTR_PHYS_MCAP: s = "ZONE_ATTR_PHYS_MCAP"; break;
2372 }
2373 }
2374
2375 if (s == NULL)
2376 prt_dec(pri, 0, val);
2377 else
2378 outstring(pri, s);
2379 }
2380
2381 /*
2382 * Print a file descriptor as AT_FDCWD if necessary
2383 */
2384 void
2385 prt_atc(private_t *pri, int raw, long val)
2386 {
2387 if ((int)val == AT_FDCWD) {
2388 if (raw)
2389 prt_hex(pri, 0, (uint_t)AT_FDCWD);
2390 else
2391 outstring(pri, "AT_FDCWD");
2392 } else {
2393 prt_dec(pri, 0, val);
2394 }
2395 }
2396
2397 /*
2398 * Print LIO_XX flags
2399 */
2400 void
2401 prt_lio(private_t *pri, int raw, long val)
2402 {
2403 if (raw)
2404 prt_dec(pri, 0, val);
2405 else if (val == LIO_WAIT)
2406 outstring(pri, "LIO_WAIT");
2407 else if (val == LIO_NOWAIT)
2408 outstring(pri, "LIO_NOWAIT");
2409 else
2410 prt_dec(pri, 0, val);
2411 }
2412
2413 const char *
2414 door_flags(private_t *pri, long val)
2415 {
2416 door_attr_t attr = (door_attr_t)val;
2417 char *str = pri->code_buf;
2418
2419 *str = '\0';
2420 #define PROCESS_FLAG(flg) \
2421 if (attr & flg) { \
2422 (void) strlcat(str, "|" #flg, sizeof (pri->code_buf)); \
2423 attr &= ~flg; \
2424 }
2425
2426 PROCESS_FLAG(DOOR_UNREF);
2427 PROCESS_FLAG(DOOR_UNREF_MULTI);
2428 PROCESS_FLAG(DOOR_PRIVATE);
2429 PROCESS_FLAG(DOOR_REFUSE_DESC);
2430 PROCESS_FLAG(DOOR_NO_CANCEL);
2431 PROCESS_FLAG(DOOR_LOCAL);
2432 PROCESS_FLAG(DOOR_REVOKED);
2433 PROCESS_FLAG(DOOR_IS_UNREF);
2434 #undef PROCESS_FLAG
2435
2436 if (attr != 0 || *str == '\0') {
2437 size_t len = strlen(str);
2438 (void) snprintf(str + len, sizeof (pri->code_buf) - len,
2439 "|0x%X", attr);
2440 }
2441
2442 return (str + 1);
2443 }
2444
2445 /*
2446 * Print door_create() flags
2447 */
2448 void
2449 prt_dfl(private_t *pri, int raw, long val)
2450 {
2451 if (raw)
2452 prt_hex(pri, 0, val);
2453 else
2454 outstring(pri, door_flags(pri, val));
2455 }
2456
2457 /*
2458 * Print door_*param() param argument
2459 */
2460 void
2461 prt_dpm(private_t *pri, int raw, long val)
2462 {
2463 if (raw)
2464 prt_hex(pri, 0, val);
2465 else if (val == DOOR_PARAM_DESC_MAX)
2466 outstring(pri, "DOOR_PARAM_DESC_MAX");
2467 else if (val == DOOR_PARAM_DATA_MIN)
2468 outstring(pri, "DOOR_PARAM_DATA_MIN");
2469 else if (val == DOOR_PARAM_DATA_MAX)
2470 outstring(pri, "DOOR_PARAM_DATA_MAX");
2471 else
2472 prt_hex(pri, 0, val);
2473 }
2474
2475 /*
2476 * Print rctlsys subcodes
2477 */
2478 void
2479 prt_rsc(private_t *pri, int raw, long val) /* print utssys code */
2480 {
2481 const char *s = raw? NULL : rctlsyscode(val);
2482
2483 if (s == NULL)
2484 prt_dec(pri, 0, val);
2485 else
2486 outstring(pri, s);
2487 }
2488
2489 /*
2490 * Print getrctl flags
2491 */
2492 void
2493 prt_rgf(private_t *pri, int raw, long val)
2494 {
2495 long action = val & (~RCTLSYS_ACTION_MASK);
2496
2497 if (raw)
2498 prt_hex(pri, 0, val);
2499 else if (action == RCTL_FIRST)
2500 outstring(pri, "RCTL_FIRST");
2501 else if (action == RCTL_NEXT)
2502 outstring(pri, "RCTL_NEXT");
2503 else if (action == RCTL_USAGE)
2504 outstring(pri, "RCTL_USAGE");
2505 else
2506 prt_hex(pri, 0, val);
2507 }
2508
2509 /*
2510 * Print setrctl flags
2511 */
2512 void
2513 prt_rsf(private_t *pri, int raw, long val)
2514 {
2515 long action = val & (~RCTLSYS_ACTION_MASK);
2516 long pval = val & RCTL_LOCAL_ACTION_MASK;
2517 char *s = pri->code_buf;
2518
2519 if (raw) {
2520 prt_hex(pri, 0, val);
2521 return;
2522 } else if (action == RCTL_INSERT)
2523 (void) strcpy(s, "RCTL_INSERT");
2524 else if (action == RCTL_DELETE)
2525 (void) strcpy(s, "RCTL_DELETE");
2526 else if (action == RCTL_REPLACE)
2527 (void) strcpy(s, "RCTL_REPLACE");
2528 else {
2529 prt_hex(pri, 0, val);
2530 return;
2531 }
2532
2533 if (pval & RCTL_USE_RECIPIENT_PID) {
2534 pval ^= RCTL_USE_RECIPIENT_PID;
2535 (void) strlcat(s, "|RCTL_USE_RECIPIENT_PID",
2536 sizeof (pri->code_buf));
2537 }
2538
2539 if ((pval & RCTLSYS_ACTION_MASK) != 0)
2540 prt_hex(pri, 0, val);
2541 else if (*s != '\0')
2542 outstring(pri, s);
2543 else
2544 prt_hex(pri, 0, val);
2545 }
2546
2547 /*
2548 * Print rctlctl flags
2549 */
2550 void
2551 prt_rcf(private_t *pri, int raw, long val)
2552 {
2553 long action = val & (~RCTLSYS_ACTION_MASK);
2554
2555 if (raw)
2556 prt_hex(pri, 0, val);
2557 else if (action == RCTLCTL_GET)
2558 outstring(pri, "RCTLCTL_GET");
2559 else if (action == RCTLCTL_SET)
2560 outstring(pri, "RCTLCTL_SET");
2561 else
2562 prt_hex(pri, 0, val);
2563 }
2564
2565 /*
2566 * Print setprojrctl flags
2567 */
2568 void
2569 prt_spf(private_t *pri, int raw, long val)
2570 {
2571 long action = val & TASK_PROJ_MASK;
2572
2573 if (!raw && (action == TASK_PROJ_PURGE))
2574 outstring(pri, "TASK_PROJ_PURGE");
2575 else
2576 prt_hex(pri, 0, val);
2577 }
2578
2579 /*
2580 * Print forkx() flags
2581 */
2582 void
2583 prt_fxf(private_t *pri, int raw, long val)
2584 {
2585 char *str;
2586
2587 if (val == 0)
2588 outstring(pri, "0");
2589 else if (raw || (val & ~(FORK_NOSIGCHLD | FORK_WAITPID)))
2590 prt_hhx(pri, 0, val);
2591 else {
2592 str = pri->code_buf;
2593 *str = '\0';
2594 if (val & FORK_NOSIGCHLD)
2595 (void) strlcat(str, "|FORK_NOSIGCHLD",
2596 sizeof (pri->code_buf));
2597 if (val & FORK_WAITPID)
2598 (void) strlcat(str, "|FORK_WAITPID",
2599 sizeof (pri->code_buf));
2600 outstring(pri, str + 1);
2601 }
2602 }
2603
2604 /*
2605 * Print faccessat() flag
2606 */
2607 void
2608 prt_fat(private_t *pri, int raw, long val)
2609 {
2610 if (val == 0)
2611 outstring(pri, "0");
2612 else if (!raw && val == AT_EACCESS)
2613 outstring(pri, "AT_EACCESS");
2614 else
2615 prt_hex(pri, 0, val);
2616 }
2617
2618 /*
2619 * Print unlinkat() flag
2620 */
2621 void
2622 prt_uat(private_t *pri, int raw, long val)
2623 {
2624 if (val == 0)
2625 outstring(pri, "0");
2626 else if (!raw && val == AT_REMOVEDIR)
2627 outstring(pri, "AT_REMOVEDIR");
2628 else
2629 prt_hex(pri, 0, val);
2630 }
2631
2632 /*
2633 * Print AT_SYMLINK_NOFOLLOW / AT_SYMLINK_FOLLOW flag
2634 */
2635 void
2636 prt_snf(private_t *pri, int raw, long val)
2637 {
2638 if (val == 0)
2639 outstring(pri, "0");
2640 else if (!raw && val == AT_SYMLINK_NOFOLLOW)
2641 outstring(pri, "AT_SYMLINK_NOFOLLOW");
2642 else if (!raw && val == AT_SYMLINK_FOLLOW)
2643 outstring(pri, "AT_SYMLINK_FOLLOW");
2644 else
2645 prt_hex(pri, 0, val);
2646 }
2647
2648 void
2649 prt_grf(private_t *pri, int raw, long val)
2650 {
2651 int first = 1;
2652
2653 if (raw != 0 || val == 0 ||
2654 (val & ~(GRND_NONBLOCK | GRND_RANDOM)) != 0) {
2655 outstring(pri, "0");
2656 return;
2657 }
2658
2659 if (val & GRND_NONBLOCK) {
2660 outstring(pri, "|GRND_NONBLOCK" + first);
2661 first = 0;
2662 }
2663 if (val & GRND_RANDOM) {
2664 outstring(pri, "|GRND_RANDOM" + first);
2665 first = 0;
2666 }
2667 }
2668
2669 /*
2670 * Array of pointers to print functions, one for each format.
2671 */
2672 void (* const Print[])() = {
2673 prt_nov, /* NOV -- no value */
2674 prt_dec, /* DEC -- print value in decimal */
2675 prt_oct, /* OCT -- print value in octal */
2676 prt_hex, /* HEX -- print value in hexadecimal */
2677 prt_dex, /* DEX -- print value in hexadecimal if big enough */
2678 prt_stg, /* STG -- print value as string */
2679 prt_ioc, /* IOC -- print ioctl code */
2680 prt_fcn, /* FCN -- print fcntl code */
2681 prt_s86, /* S86 -- print sysi86 code */
2682 prt_uts, /* UTS -- print utssys code */
2683 prt_opn, /* OPN -- print open code */
2684 prt_sig, /* SIG -- print signal name plus flags */
2685 prt_uat, /* UAT -- print unlinkat() flag */
2686 prt_msc, /* MSC -- print msgsys command */
2687 prt_msf, /* MSF -- print msgsys flags */
2688 prt_smc, /* SMC -- print semsys command */
2689 prt_sef, /* SEF -- print semsys flags */
2690 prt_shc, /* SHC -- print shmsys command */
2691 prt_shf, /* SHF -- print shmsys flags */
2692 prt_fat, /* FAT -- print faccessat( flag */
2693 prt_sfs, /* SFS -- print sysfs code */
2694 prt_rst, /* RST -- print string returned by syscall */
2695 prt_smf, /* SMF -- print streams message flags */
2696 prt_ioa, /* IOA -- print ioctl argument */
2697 prt_pip, /* PIP -- print pipe flags */
2698 prt_mtf, /* MTF -- print mount flags */
2699 prt_mft, /* MFT -- print mount file system type */
2700 prt_iob, /* IOB -- print contents of I/O buffer */
2701 prt_hhx, /* HHX -- print value in hexadecimal (half size) */
2702 prt_wop, /* WOP -- print waitsys() options */
2703 prt_spm, /* SPM -- print sigprocmask argument */
2704 prt_rlk, /* RLK -- print readlink buffer */
2705 prt_mpr, /* MPR -- print mmap()/mprotect() flags */
2706 prt_mty, /* MTY -- print mmap() mapping type flags */
2707 prt_mcf, /* MCF -- print memcntl() function */
2708 prt_mc4, /* MC4 -- print memcntl() (fourth) argument */
2709 prt_mc5, /* MC5 -- print memcntl() (fifth) argument */
2710 prt_mad, /* MAD -- print madvise() argument */
2711 prt_ulm, /* ULM -- print ulimit() argument */
2712 prt_rlm, /* RLM -- print get/setrlimit() argument */
2713 prt_cnf, /* CNF -- print sysconfig() argument */
2714 prt_inf, /* INF -- print sysinfo() argument */
2715 prt_ptc, /* PTC -- print pathconf/fpathconf() argument */
2716 prt_fui, /* FUI -- print fusers() input argument */
2717 prt_idt, /* IDT -- print idtype_t, waitid() argument */
2718 prt_lwf, /* LWF -- print lwp_create() flags */
2719 prt_itm, /* ITM -- print [get|set]itimer() arg */
2720 prt_llo, /* LLO -- print long long offset arg */
2721 prt_mod, /* MOD -- print modctl() subcode */
2722 prt_whn, /* WHN -- print lseek() whence arguiment */
2723 prt_acl, /* ACL -- print acl() code */
2724 prt_aio, /* AIO -- print kaio() code */
2725 prt_uns, /* DEC -- print value in unsigned decimal */
2726 prt_cor, /* COR -- print corectl() subcode */
2727 prt_cco, /* CCO -- print corectl() options */
2728 prt_ccc, /* CCC -- print corectl() content */
2729 prt_rcc, /* RCC -- print corectl() returned content */
2730 prt_cpc, /* CPC -- print cpc() subcode */
2731 prt_sqc, /* SQC -- print sigqueue() si_code argument */
2732 prt_pc4, /* PC4 -- print priocntlsys() (fourth) argument */
2733 prt_pc5, /* PC5 -- print priocntlsys() (key, value) pairs */
2734 prt_pst, /* PST -- print processor set id */
2735 prt_mif, /* MIF -- print meminfo() arguments */
2736 prt_pfm, /* PFM -- print so_socket() proto-family (1st) arg */
2737 prt_skt, /* SKT -- print so_socket() socket-type (2nd) arg */
2738 prt_skp, /* SKP -- print so_socket() protocol (3rd) arg */
2739 prt_sol, /* SOL -- print [sg]etsockopt() level (2nd) arg */
2740 prt_son, /* SON -- print [sg]etsockopt() opt-name (3rd) arg */
2741 prt_utt, /* UTT -- print utrap type */
2742 prt_uth, /* UTH -- print utrap handler */
2743 prt_acc, /* ACC -- print access() flags */
2744 prt_sht, /* SHT -- print shutdown() how (2nd) argument */
2745 prt_ffg, /* FFG -- print fcntl() flags (3rd) argument */
2746 prt_prs, /* PRS -- print privilege set */
2747 prt_pro, /* PRO -- print privilege set operation */
2748 prt_prn, /* PRN -- print privilege set name */
2749 prt_pfl, /* PFL -- print privilege/process flag name */
2750 prt_laf, /* LAF -- print lgrp_affinity arguments */
2751 prt_key, /* KEY -- print key_t 0 as IPC_PRIVATE */
2752 prt_zga, /* ZGA -- print zone_getattr attribute types */
2753 prt_atc, /* ATC -- print AT_FDCWD or file descriptor */
2754 prt_lio, /* LIO -- print LIO_XX flags */
2755 prt_dfl, /* DFL -- print door_create() flags */
2756 prt_dpm, /* DPM -- print DOOR_PARAM_XX flags */
2757 prt_rsc, /* RSC -- print rctlsys() subcodes */
2758 prt_rgf, /* RGF -- print getrctl() flags */
2759 prt_rsf, /* RSF -- print setrctl() flags */
2760 prt_rcf, /* RCF -- print rctlsys_ctl() flags */
2761 prt_fxf, /* FXF -- print forkx() flags */
2762 prt_spf, /* SPF -- print rctlsys_projset() flags */
2763 prt_un1, /* UN1 -- as prt_uns except for -1 */
2764 prt_mob, /* MOB -- print mmapobj() flags */
2765 prt_snf, /* SNF -- print AT_SYMLINK_[NO]FOLLOW flag */
2766 prt_skc, /* SKC -- print sockconfig() subcode */
2767 prt_acf, /* ACF -- print accept4 flags */
2768 prt_pfd, /* PFD -- print pipe fds */
2769 prt_grf, /* GRF -- print getrandom flags */
2770 prt_psdelta, /* PSDLT -- print psecflags(2) delta */
2771 prt_psfw, /* PSFW -- print psecflags(2) set */
2772 prt_dec, /* HID -- hidden argument, make this the last one */
2773 };
Unleashed OS