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