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