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.
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.
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]
23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2015, Joyent, Inc. All rights reserved.
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
30 /* Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved. */
32 #define _SYSCALL32 /* make 32-bit compat headers visible */
44 #include <sys/types.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>
53 #include <sys/isa_defs.h>
54 #include <sys/systeminfo.h>
55 #include <sys/cladm.h>
57 #include <bsm/audit.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>
71 #include <nss_dbdefs.h>
72 #include <sys/socketvar.h>
73 #include <netinet/in.h>
74 #include <netinet/tcp.h>
75 #include <netinet/udp.h>
76 #include <netinet/sctp.h>
77 #include <net/route.h>
78 #include <sys/utrap.h>
79 #include <sys/lgrp_user.h>
81 #include <sys/tsol/tndb.h>
83 #include <sys/rctl_impl.h>
86 #include <sys/random.h>
92 void grow(private_t
*, int nbyte
);
94 #define GROW(nb) if (pri->sys_leng + (nb) >= pri->sys_ssize) grow(pri, (nb))
99 prt_nov(private_t
*pri
, int raw
, long val
) /* print nothing */
105 prt_dec(private_t
*pri
, int raw
, long val
) /* print as decimal */
108 if (data_model
== PR_MODEL_ILP32
)
109 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
112 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
118 prt_uns(private_t
*pri
, int raw
, long val
) /* print as unsigned decimal */
121 if (data_model
== PR_MODEL_ILP32
)
122 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
125 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
129 /* print as unsigned decimal, except for -1 */
131 prt_un1(private_t
*pri
, int raw
, long val
)
134 prt_dec(pri
, raw
, val
);
136 prt_uns(pri
, raw
, val
);
141 prt_oct(private_t
*pri
, int raw
, long val
) /* print as octal */
144 if (data_model
== PR_MODEL_ILP32
)
145 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
148 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
154 prt_hex(private_t
*pri
, int raw
, long val
) /* print as hexadecimal */
157 if (data_model
== PR_MODEL_ILP32
)
158 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
161 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
165 /* print as hexadecimal (half size) */
168 prt_hhx(private_t
*pri
, int raw
, long val
)
171 if (data_model
== PR_MODEL_ILP32
)
172 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
175 pri
->sys_leng
+= sprintf(pri
->sys_string
+ pri
->sys_leng
,
179 /* print as decimal if small, else hexadecimal */
182 prt_dex(private_t
*pri
, int raw
, long val
)
184 if (val
& 0xff000000)
185 prt_hex(pri
, 0, val
);
187 prt_dec(pri
, 0, val
);
190 /* print long long offset */
193 prt_llo(private_t
*pri
, int raw
, long val1
, long val2
)
198 #ifdef _LONG_LONG_LTOH
207 prt_dex(pri
, 0, loval
);
211 sprintf(pri
->sys_string
+ pri
->sys_leng
, "0x%.8X%.8X",
217 escape_string(private_t
*pri
, const char *s
)
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
227 int i
, unprintable
, quotes
;
228 size_t len
= strlen(s
);
229 for (i
= 0, unprintable
= 0, quotes
= 0; i
< len
; i
++) {
236 GROW(len
+ 3 * unprintable
+ quotes
+ 2);
238 pri
->sys_string
[pri
->sys_leng
++] = '"';
239 for (i
= 0; i
< len
; i
++) {
241 pri
->sys_string
[pri
->sys_leng
++] = '\\';
244 pri
->sys_string
[pri
->sys_leng
++] = s
[i
];
246 pri
->sys_leng
+= sprintf(pri
->sys_string
+
247 pri
->sys_leng
, "\\x%02x", (uint8_t)s
[i
]);
250 pri
->sys_string
[pri
->sys_leng
++] = '"';
254 prt_stg(private_t
*pri
, int raw
, long val
) /* print as string */
256 char *s
= raw
? NULL
: fetchstring(pri
, (long)val
, PATH_MAX
);
259 prt_hex(pri
, 0, val
);
261 escape_string(pri
, s
);
264 /* print as string returned from syscall */
266 prt_rst(private_t
*pri
, int raw
, long val
)
268 char *s
= (raw
|| pri
->Errno
)? NULL
:
269 fetchstring(pri
, (long)val
, PATH_MAX
);
272 prt_hex(pri
, 0, val
);
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
);
280 /* print contents of readlink() buffer */
282 prt_rlk(private_t
*pri
, int raw
, long val
)
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
);
289 prt_hex(pri
, 0, val
);
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
);
298 prt_ioc(private_t
*pri
, int raw
, long val
) /* print ioctl code */
300 const char *s
= raw
? NULL
: ioctlname(pri
, (int)val
);
303 prt_hex(pri
, 0, val
);
309 prt_ioa(private_t
*pri
, int raw
, long val
) /* print ioctl argument */
313 /* cheating -- look at the ioctl() code */
314 switch (pri
->sys_args
[1]) {
318 case KSTAT_IOC_WRITE
:
320 if (data_model
== PR_MODEL_ILP32
)
322 val
+ offsetof(kstat32_t
, ks_name
[0]));
326 val
+ offsetof(kstat_t
, ks_name
[0]));
329 /* streams ioctl()s */
331 prt_rst(pri
, raw
, val
);
335 prt_stg(pri
, raw
, val
);
340 prt_dec(pri
, 0, val
);
343 if (raw
|| (s
= strrdopt(val
)) == NULL
)
344 prt_dec(pri
, 0, val
);
349 if (raw
|| (s
= strevents(pri
, val
)) == NULL
)
350 prt_hex(pri
, 0, val
);
355 if (raw
|| (s
= strflush(val
)) == NULL
)
356 prt_dec(pri
, 0, val
);
366 prt_dec(pri
, 0, val
);
370 prt_hex(pri
, 0, val
);
376 prt_pip(private_t
*pri
, int raw
, long val
) /* print pipe code */
378 const char *s
= NULL
;
388 case O_CLOEXEC
|O_NONBLOCK
:
389 s
= "O_CLOEXEC|O_NONBLOCK";
395 prt_dex(pri
, 0, val
);
401 prt_pfd(private_t
*pri
, int raw
, long val
) /* print pipe code */
406 /* the fds only have meaning if the return value is 0 */
409 Pread(Proc
, fds
, sizeof (fds
), (long)val
) == sizeof (fds
)) {
410 (void) snprintf(str
, sizeof (str
), "[%d,%d]", fds
[0], fds
[1]);
413 prt_hex(pri
, 0, val
);
418 prt_fcn(private_t
*pri
, int raw
, long val
) /* print fcntl code */
420 const char *s
= raw
? NULL
: fcntlname(val
);
423 prt_dec(pri
, 0, val
);
429 prt_s86(private_t
*pri
, int raw
, long val
) /* print sysi86 code */
432 const char *s
= raw
? NULL
: si86name(val
);
435 prt_dec(pri
, 0, val
);
441 prt_uts(private_t
*pri
, int raw
, long val
) /* print utssys code */
443 const char *s
= raw
? NULL
: utscode(val
);
446 prt_dec(pri
, 0, val
);
452 prt_msc(private_t
*pri
, int raw
, long val
) /* print msgsys command */
454 const char *s
= raw
? NULL
: msgcmd(val
);
457 prt_dec(pri
, 0, val
);
463 prt_msf(private_t
*pri
, int raw
, long val
) /* print msgsys flags */
465 const char *s
= raw
? NULL
: msgflags(pri
, (int)val
);
468 prt_oct(pri
, 0, val
);
474 prt_smc(private_t
*pri
, int raw
, long val
) /* print semsys command */
476 const char *s
= raw
? NULL
: semcmd(val
);
479 prt_dec(pri
, 0, val
);
485 prt_sef(private_t
*pri
, int raw
, long val
) /* print semsys flags */
487 const char *s
= raw
? NULL
: semflags(pri
, (int)val
);
490 prt_oct(pri
, 0, val
);
496 prt_shc(private_t
*pri
, int raw
, long val
) /* print shmsys command */
498 const char *s
= raw
? NULL
: shmcmd(val
);
501 prt_dec(pri
, 0, val
);
507 prt_shf(private_t
*pri
, int raw
, long val
) /* print shmsys flags */
509 const char *s
= raw
? NULL
: shmflags(pri
, (int)val
);
512 prt_oct(pri
, 0, val
);
518 prt_sfs(private_t
*pri
, int raw
, long val
) /* print sysfs code */
520 const char *s
= raw
? NULL
: sfsname(val
);
523 prt_dec(pri
, 0, val
);
529 prt_opn(private_t
*pri
, int raw
, long val
) /* print open code */
531 const char *s
= raw
? NULL
: openarg(pri
, val
);
534 prt_oct(pri
, 0, val
);
540 prt_sig(private_t
*pri
, int raw
, long val
) /* print signal name */
542 const char *s
= raw
? NULL
: signame(pri
, (int)val
);
545 prt_hex(pri
, 0, val
);
551 prt_smf(private_t
*pri
, int raw
, long val
) /* print streams message flags */
555 prt_dec(pri
, 0, val
);
559 prt_hhx(pri
, 0, val
);
561 outstring(pri
, "RS_HIPRI");
564 prt_hhx(pri
, 0, val
);
570 prt_mtf(private_t
*pri
, int raw
, long val
) /* print mount flags */
572 const char *s
= raw
? NULL
: mountflags(pri
, val
);
575 prt_hex(pri
, 0, val
);
581 prt_mft(private_t
*pri
, int raw
, long val
) /* print mount file system type */
583 if (val
>= 0 && val
< 256)
584 prt_dec(pri
, 0, val
);
586 prt_hex(pri
, 0, val
);
588 prt_stg(pri
, raw
, val
);
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)
598 /* print contents of read() or write() I/O buffer */
600 prt_iob(private_t
*pri
, int raw
, long val
)
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
];
610 pri
->iob_buf
[0] = '\0';
612 if (Lsp
->pr_why
== PR_SYSEXIT
&& nbyte
> IOBSIZE
) {
614 elsewhere
= prismember(&readfd
, fdp1
);
616 elsewhere
= prismember(&writefd
, fdp1
);
619 if (nbyte
<= 0 || elsewhere
)
620 prt_hex(pri
, 0, val
);
622 int nb
= nbyte
> IOBSIZE
? IOBSIZE
: (int)nbyte
;
624 if (Pread(Proc
, buffer
, (size_t)nb
, (long)val
) != nb
)
625 prt_hex(pri
, 0, val
);
627 pri
->iob_buf
[0] = '"';
628 showbytes(buffer
, nb
, pri
->iob_buf
+ 1);
629 (void) strlcat(pri
->iob_buf
,
631 (const char *)"\"" : (const char *)"\"..",
632 sizeof (pri
->iob_buf
));
634 prt_hex(pri
, 0, val
);
636 outstring(pri
, pri
->iob_buf
);
644 prt_idt(private_t
*pri
, int raw
, long val
) /* print idtype_t, waitid() arg */
646 const char *s
= raw
? NULL
: idtype_enum(pri
, val
);
649 prt_dec(pri
, 0, val
);
655 prt_wop(private_t
*pri
, int raw
, long val
) /* print waitid() options */
657 const char *s
= raw
? NULL
: woptions(pri
, (int)val
);
660 prt_oct(pri
, 0, val
);
666 prt_whn(private_t
*pri
, int raw
, long val
) /* print lseek() whence argument */
668 const char *s
= raw
? NULL
: whencearg(val
);
671 prt_dec(pri
, 0, val
);
678 prt_spm(private_t
*pri
, int raw
, long val
) /* print sigprocmask argument */
680 const char *s
= NULL
;
684 case SIG_BLOCK
: s
= "SIG_BLOCK"; break;
685 case SIG_UNBLOCK
: s
= "SIG_UNBLOCK"; break;
686 case SIG_SETMASK
: s
= "SIG_SETMASK"; break;
691 prt_dec(pri
, 0, val
);
697 mmap_protect(private_t
*pri
, long arg
)
699 char *str
= pri
->code_buf
;
701 if (arg
& ~(PROT_READ
|PROT_WRITE
|PROT_EXEC
))
702 return ((char *)NULL
);
704 if (arg
== PROT_NONE
)
705 return ("PROT_NONE");
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
));
713 (void) strlcat(str
, "|PROT_EXEC", sizeof (pri
->code_buf
));
714 return ((const char *)(str
+ 1));
718 mmap_type(private_t
*pri
, long arg
)
720 char *str
= pri
->code_buf
;
723 #define CBSIZE sizeof (pri->code_buf)
724 switch (arg
& MAP_TYPE
) {
726 used
= strlcpy(str
, "MAP_SHARED", CBSIZE
);
729 used
= strlcpy(str
, "MAP_PRIVATE", CBSIZE
);
732 used
= snprintf(str
, CBSIZE
, "%ld", arg
&MAP_TYPE
);
736 arg
&= ~(_MAP_NEW
|MAP_TYPE
);
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
,
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
);
750 (void) strlcat(str
, "|MAP_ANON", CBSIZE
);
752 (void) strlcat(str
, "|MAP_ALIGN", CBSIZE
);
754 (void) strlcat(str
, "|MAP_TEXT", CBSIZE
);
755 if (arg
& MAP_INITDATA
)
756 (void) strlcat(str
, "|MAP_INITDATA", CBSIZE
);
758 (void) strlcat(str
, "|MAP_32BIT", CBSIZE
);
761 return ((const char *)str
);
766 prt_mpr(private_t
*pri
, int raw
, long val
) /* print mmap()/mprotect() flags */
768 const char *s
= raw
? NULL
: mmap_protect(pri
, val
);
771 prt_hhx(pri
, 0, val
);
777 prt_mty(private_t
*pri
, int raw
, long val
) /* print mmap() mapping type flags */
779 const char *s
= raw
? NULL
: mmap_type(pri
, val
);
782 prt_hhx(pri
, 0, val
);
788 prt_mob(private_t
*pri
, int raw
, long val
) /* print mmapobj() flags */
791 prt_dec(pri
, 0, val
);
792 else if (raw
|| (val
& ~(MMOBJ_PADDING
|MMOBJ_INTERPRET
)) != 0)
793 prt_hhx(pri
, 0, val
);
795 #define CBSIZE sizeof (pri->code_buf)
796 char *s
= pri
->code_buf
;
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);
810 prt_mcf(private_t
*pri
, int raw
, long val
) /* print memcntl() function */
812 const char *s
= NULL
;
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;
827 prt_dec(pri
, 0, val
);
833 prt_mad(private_t
*pri
, int raw
, long val
) /* print madvise() argument */
835 const char *s
= NULL
;
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;
852 prt_dec(pri
, 0, val
);
858 prt_mc4(private_t
*pri
, int raw
, long val
) /* print memcntl() (4th) argument */
861 prt_dec(pri
, 0, val
);
863 prt_hhx(pri
, 0, val
);
867 #define CBSIZE sizeof (pri->code_buf)
868 /* cheating -- look at memcntl func */
869 switch (pri
->sys_args
[2]) {
871 prt_mad(pri
, 0, val
);
875 if ((val
& ~(MS_SYNC
|MS_ASYNC
|MS_INVALIDATE
)) == 0) {
876 *(s
= pri
->code_buf
) = '\0';
878 (void) strlcat(s
, "|MS_SYNC", CBSIZE
);
880 (void) strlcat(s
, "|MS_ASYNC", CBSIZE
);
881 if (val
& MS_INVALIDATE
)
882 (void) strlcat(s
, "|MS_INVALIDATE",
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",
894 if (val
& MCL_FUTURE
)
895 (void) strlcat(s
, "|MCL_FUTURE",
902 if (s
== NULL
|| *s
== '\0')
903 prt_hhx(pri
, 0, val
);
910 prt_mc5(private_t
*pri
, int raw
, long val
) /* print memcntl() (5th) argument */
914 #define CBSIZE sizeof (pri->code_buf)
916 prt_dec(pri
, 0, val
);
917 else if (raw
|| (val
& ~VALID_ATTR
))
918 prt_hhx(pri
, 0, val
);
923 (void) strlcat(s
, "|SHARED", CBSIZE
);
925 (void) strlcat(s
, "|PRIVATE", CBSIZE
);
927 (void) strlcat(s
, "|PROT_READ", CBSIZE
);
928 if (val
& PROT_WRITE
)
929 (void) strlcat(s
, "|PROT_WRITE", CBSIZE
);
931 (void) strlcat(s
, "|PROT_EXEC", CBSIZE
);
933 prt_hhx(pri
, 0, val
);
941 prt_ulm(private_t
*pri
, int raw
, long val
) /* print ulimit() argument */
943 const char *s
= NULL
;
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;
955 prt_dec(pri
, 0, val
);
961 prt_rlm(private_t
*pri
, int raw
, long val
) /* print get/setrlimit() argument */
963 const char *s
= NULL
;
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;
978 prt_dec(pri
, 0, val
);
984 prt_cnf(private_t
*pri
, int raw
, long val
) /* print sysconfig code */
986 const char *s
= raw
? NULL
: sconfname(val
);
989 prt_dec(pri
, 0, val
);
995 prt_inf(private_t
*pri
, int raw
, long val
) /* print sysinfo code */
997 const char *s
= NULL
;
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;
1022 prt_dec(pri
, 0, val
);
1028 prt_ptc(private_t
*pri
, int raw
, long val
) /* print pathconf code */
1030 const char *s
= raw
? NULL
: pathconfname(val
);
1033 prt_dec(pri
, 0, val
);
1039 prt_fui(private_t
*pri
, int raw
, long val
) /* print fusers() input argument */
1041 const char *s
= raw
? NULL
: fuiname(val
);
1044 prt_hhx(pri
, 0, val
);
1050 prt_lwf(private_t
*pri
, int raw
, long val
) /* print lwp_create() flags */
1055 prt_dec(pri
, 0, val
);
1057 (val
& ~(LWP_DAEMON
|LWP_DETACHED
|LWP_SUSPENDED
)))
1058 prt_hhx(pri
, 0, val
);
1060 #define CBSIZE sizeof (pri->code_buf)
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
);
1075 prt_itm(private_t
*pri
, int raw
, long val
) /* print [get|set]itimer() arg */
1077 const char *s
= NULL
;
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;
1091 prt_dec(pri
, 0, val
);
1097 prt_mod(private_t
*pri
, int raw
, long val
) /* print modctl() code */
1099 const char *s
= NULL
;
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;
1151 prt_dec(pri
, 0, val
);
1157 prt_acl(private_t
*pri
, int raw
, long val
) /* print acl() code */
1159 const char *s
= NULL
;
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;
1173 prt_dec(pri
, 0, val
);
1179 prt_aio(private_t
*pri
, int raw
, long val
) /* print kaio() code */
1181 const char *s
= NULL
;
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;
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.
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;
1214 * AIOFSYNC doesn't correspond to a syscall.
1216 case AIOWAITN
: s
= "AIOWAITN"; break;
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
;
1226 prt_dec(pri
, 0, val
);
1232 prt_aud(private_t
*pri
, int raw
, long val
) /* print auditsys() code */
1234 const char *s
= NULL
;
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;
1250 prt_dec(pri
, 0, val
);
1256 prt_cor(private_t
*pri
, int raw
, long val
) /* print corectl() subcode */
1258 const char *s
= NULL
;
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;
1294 prt_dec(pri
, 0, val
);
1300 prt_cco(private_t
*pri
, int raw
, long val
) /* print corectl() options */
1305 prt_dec(pri
, 0, val
);
1306 else if (raw
|| (val
& ~CC_OPTIONS
))
1307 prt_hhx(pri
, 0, val
);
1309 #define CBSIZE sizeof (pri->code_buf)
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
);
1323 prt_hhx(pri
, 0, val
);
1325 outstring(pri
, ++s
);
1331 prt_ccc(private_t
*pri
, int raw
, long val
) /* print corectl() content */
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
);
1341 prt_hhx(pri
, 0, (long)ccc
);
1345 prt_rcc(private_t
*pri
, int raw
, long val
) /* print corectl() ret. cont. */
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
);
1355 prt_hhx(pri
, 0, (long)ccc
);
1359 prt_cpc(private_t
*pri
, int raw
, long val
) /* print cpc() subcode */
1361 const char *s
= NULL
;
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;
1385 prt_dec(pri
, 0, val
);
1391 outstring(private_t
*pri
, const char *s
)
1393 int len
= strlen(s
);
1396 (void) strcpy(pri
->sys_string
+ pri
->sys_leng
, s
);
1397 pri
->sys_leng
+= len
;
1401 grow(private_t
*pri
, int nbyte
) /* reallocate format buffer if necessary */
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");
1409 prt_clc(private_t
*pri
, int raw
, long val
)
1411 const char *s
= NULL
;
1415 case CL_INITIALIZE
: s
= "CL_INITIALIZE"; break;
1416 case CL_CONFIG
: s
= "CL_CONFIG"; break;
1421 prt_dec(pri
, 0, val
);
1427 prt_clf(private_t
*pri
, int raw
, long val
)
1429 const char *s
= NULL
;
1432 switch (pri
->sys_args
[0]) {
1434 switch (pri
->sys_args
[1]) {
1436 s
= "CL_NODEID"; break;
1437 case CL_HIGHEST_NODEID
:
1438 s
= "CL_HIGHEST_NODEID"; break;
1442 switch (pri
->sys_args
[1]) {
1443 case CL_GET_BOOTFLAG
:
1444 s
= "CL_GET_BOOTFLAG"; break;
1451 prt_dec(pri
, 0, val
);
1457 prt_sqc(private_t
*pri
, int raw
, long val
) /* print sigqueue() si_code */
1459 const char *s
= NULL
;
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;
1471 prt_dec(pri
, 0, val
);
1477 * print priocntlsys() (key, value) pair key.
1480 print_pck(private_t
*pri
, int raw
, long val
)
1482 const char *s
= NULL
;
1483 char clname
[PC_CLNMSZ
];
1485 if ((pri
->sys_args
[2] != PC_GETXPARMS
&&
1486 pri
->sys_args
[2] != PC_SETXPARMS
) || val
== 0 || raw
) {
1487 prt_dec(pri
, 0, val
);
1491 if (pri
->sys_args
[3] == NULL
) {
1492 if (val
== PC_KY_CLNAME
) {
1496 prt_dec(pri
, 0, val
);
1500 if (Pread(Proc
, &clname
, PC_CLNMSZ
, pri
->sys_args
[3]) != PC_CLNMSZ
) {
1501 prt_dec(pri
, 0, val
);
1505 if (strcmp(clname
, "TS") == 0) {
1507 case TS_KY_UPRILIM
: s
= "TS_KY_UPRILIM"; break;
1508 case TS_KY_UPRI
: s
= "TS_KY_UPRI"; break;
1511 } else if (strcmp(clname
, "IA") == 0) {
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;
1518 } else if (strcmp(clname
, "RT") == 0) {
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;
1526 } else if (strcmp(clname
, "FSS") == 0) {
1528 case FSS_KY_UPRILIM
: s
= "FSS_KY_UPRILIM"; break;
1529 case FSS_KY_UPRI
: s
= "FSS_KY_UPRI"; break;
1532 } else if (strcmp(clname
, "FX") == 0) {
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;
1543 prt_dec(pri
, 0, val
);
1549 * print priocntlsys() fourth argument.
1553 prt_pc4(private_t
*pri
, int raw
, long val
)
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
);
1560 prt_stg(pri
, 0, val
);
1562 prt_dec(pri
, 0, val
);
1566 * print priocntlsys() (key, value) pairs (5th argument).
1570 prt_pc5(private_t
*pri
, int raw
, long val
)
1573 pc_vaparm_t
*vpp
= &prms
.pc_parms
[0];
1577 /* look at pricntlsys function */
1578 if ((pri
->sys_args
[2] != PC_GETXPARMS
&&
1579 pri
->sys_args
[2] != PC_SETXPARMS
) || val
== 0) {
1584 if (Pread(Proc
, &prms
, sizeof (prms
), val
) != sizeof (prms
)) {
1585 prt_hex(pri
, 0, val
);
1589 if ((cnt
= prms
.pc_vaparmscnt
) > PC_VAPARMCNT
)
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
, ", ");
1599 prt_dec(pri
, 0, PC_KY_NULL
);
1603 * Print processor set id, including logical expansion of "special" ids.
1606 prt_pst(private_t
*pri
, int raw
, long val
)
1608 const char *s
= NULL
;
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;
1619 prt_dec(pri
, 0, val
);
1625 * Print meminfo() argument.
1629 prt_mif(private_t
*pri
, int raw
, long val
)
1631 struct meminfo minfo
;
1634 if (data_model
== PR_MODEL_ILP32
) {
1635 struct meminfo32 minfo32
;
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
);
1645 * arrange the arguments in the order that user calls with
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
);
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
);
1669 * arrange the arguments in the order that user calls with
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
);
1686 * Print so_socket() 1st argument.
1690 prt_pfm(private_t
*pri
, int raw
, long val
)
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
]);
1697 prt_dec(pri
, 0, val
);
1702 * Print sockconfig() subcode.
1706 prt_skc(private_t
*pri
, int raw
, long val
)
1708 const char *s
= NULL
;
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;
1723 prt_dec(pri
, 0, val
);
1728 * Print so_socket() 2nd argument.
1732 prt_skt(private_t
*pri
, int raw
, long val
)
1735 long type
= val
& SOCK_TYPE_MASK
;
1737 if ((ulong_t
)type
<= MAX_SOCKTYPES
&&
1738 (s
= socktype_codes
[type
]) != NULL
) {
1740 if ((val
& SOCK_CLOEXEC
) != 0) {
1741 outstring(pri
, "|SOCK_CLOEXEC");
1744 prt_dec(pri
, 0, val
);
1750 * Print so_socket() 3rd argument.
1754 prt_skp(private_t
*pri
, int raw
, long val
)
1758 /* cheating -- look at the protocol-family */
1759 switch (pri
->sys_args
[0]) {
1762 case PF_NCA
: if ((s
= ipprotos((int)val
)) != NULL
) {
1767 default: prt_dec(pri
, 0, val
);
1774 * Print so_socket() 5th argument.
1778 prt_skv(private_t
*pri
, int raw
, long 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;
1791 * Print accept4() flags argument.
1794 prt_acf(private_t
*pri
, int raw
, long val
)
1798 (val
& ~(SOCK_CLOEXEC
|SOCK_NDELAY
|SOCK_NONBLOCK
))) {
1799 prt_dex(pri
, 0, val
);
1803 if (val
& SOCK_CLOEXEC
) {
1804 outstring(pri
, "|SOCK_CLOEXEC" + first
);
1807 if (val
& SOCK_NDELAY
) {
1808 outstring(pri
, "|SOCK_NDELAY" + first
);
1811 if (val
& SOCK_NONBLOCK
) {
1812 outstring(pri
, "|SOCK_NONBLOCK" + first
);
1818 * Print setsockopt()/getsockopt() 2nd argument.
1822 prt_sol(private_t
*pri
, int raw
, long val
)
1824 if (val
== SOL_SOCKET
) {
1825 outstring(pri
, "SOL_SOCKET");
1826 } else if (val
== SOL_ROUTE
) {
1827 outstring(pri
, "SOL_ROUTE");
1829 const struct protoent
*p
;
1830 struct protoent res
;
1831 char buf
[NSS_BUFLEN_PROTOCOLS
];
1833 if ((p
= getprotobynumber_r(val
, &res
,
1834 (char *)buf
, sizeof (buf
))) != NULL
)
1835 outstring(pri
, p
->p_name
);
1837 prt_dec(pri
, 0, val
);
1843 sol_optname(private_t
*pri
, long val
)
1845 #define CBSIZE sizeof (pri->code_buf)
1846 if (val
>= SO_SNDBUF
) {
1848 case SO_SNDBUF
: return ("SO_SNDBUF");
1849 case SO_RCVBUF
: return ("SO_RCVBUF");
1850 case SO_SNDLOWAT
: return ("SO_SNDLOWAT");
1851 case SO_RCVLOWAT
: return ("SO_RCVLOWAT");
1852 case SO_SNDTIMEO
: return ("SO_SNDTIMEO");
1853 case SO_RCVTIMEO
: return ("SO_RCVTIMEO");
1854 case SO_ERROR
: return ("SO_ERROR");
1855 case SO_TYPE
: return ("SO_TYPE");
1856 case SO_PROTOTYPE
: return ("SO_PROTOTYPE");
1857 case SO_ANON_MLP
: return ("SO_ANON_MLP");
1858 case SO_MAC_EXEMPT
: return ("SO_MAC_EXEMPT");
1859 case SO_ALLZONES
: return ("SO_ALLZONES");
1860 case SO_MAC_IMPLICIT
: return ("SO_MAC_IMPLICIT");
1861 case SO_VRRP
: return ("SO_VRRP");
1862 case SO_EXCLBIND
: return ("SO_EXCLBIND");
1863 case SO_DOMAIN
: return ("SO_DOMAIN");
1865 default: (void) snprintf(pri
->code_buf
, CBSIZE
,
1867 return (pri
->code_buf
);
1870 char *s
= pri
->code_buf
;
1875 val2
= val
& ~(SO_DEBUG
|SO_ACCEPTCONN
|SO_REUSEADDR
|SO_KEEPALIVE
|
1876 SO_DONTROUTE
|SO_BROADCAST
|SO_USELOOPBACK
|SO_LINGER
|
1877 SO_OOBINLINE
|SO_DGRAM_ERRIND
|SO_RECVUCRED
);
1879 used
= snprintf(s
, CBSIZE
, "|0x%lx", val2
);
1881 used
= strlcat(s
, "|SO_DEBUG", CBSIZE
);
1882 if (val
& SO_ACCEPTCONN
)
1883 used
= strlcat(s
, "|SO_ACCEPTCONN", CBSIZE
);
1884 if (val
& SO_REUSEADDR
)
1885 used
= strlcat(s
, "|SO_REUSEADDR", CBSIZE
);
1886 if (val
& SO_KEEPALIVE
)
1887 used
= strlcat(s
, "|SO_KEEPALIVE", CBSIZE
);
1888 if (val
& SO_DONTROUTE
)
1889 used
= strlcat(s
, "|SO_DONTROUTE", CBSIZE
);
1890 if (val
& SO_BROADCAST
)
1891 used
= strlcat(s
, "|SO_BROADCAST", CBSIZE
);
1892 if (val
& SO_USELOOPBACK
)
1893 used
= strlcat(s
, "|SO_USELOOPBACK", CBSIZE
);
1894 if (val
& SO_LINGER
)
1895 used
= strlcat(s
, "|SO_LINGER", CBSIZE
);
1896 if (val
& SO_OOBINLINE
)
1897 used
= strlcat(s
, "|SO_OOBINLINE", CBSIZE
);
1898 if (val
& SO_DGRAM_ERRIND
)
1899 used
= strlcat(s
, "|SO_DGRAM_ERRIND", CBSIZE
);
1900 if (val
& SO_RECVUCRED
)
1901 used
= strlcat(s
, "|SO_RECVUCRED", CBSIZE
);
1902 if (used
>= CBSIZE
|| val
== 0)
1903 (void) snprintf(s
+ 1, CBSIZE
-1, "0x%lx", val
);
1904 return ((const char *)(s
+ 1));
1910 route_optname(private_t
*pri
, long val
)
1914 return ("RT_AWARE");
1916 (void) snprintf(pri
->code_buf
, sizeof (pri
->code_buf
),
1918 return (pri
->code_buf
);
1923 tcp_optname(private_t
*pri
, long val
)
1926 case TCP_NODELAY
: return ("TCP_NODELAY");
1927 case TCP_MAXSEG
: return ("TCP_MAXSEG");
1928 case TCP_KEEPALIVE
: return ("TCP_KEEPALIVE");
1929 case TCP_NOTIFY_THRESHOLD
: return ("TCP_NOTIFY_THRESHOLD");
1930 case TCP_ABORT_THRESHOLD
: return ("TCP_ABORT_THRESHOLD");
1931 case TCP_CONN_NOTIFY_THRESHOLD
: return ("TCP_CONN_NOTIFY_THRESHOLD");
1932 case TCP_CONN_ABORT_THRESHOLD
: return ("TCP_CONN_ABORT_THRESHOLD");
1933 case TCP_RECVDSTADDR
: return ("TCP_RECVDSTADDR");
1934 case TCP_ANONPRIVBIND
: return ("TCP_ANONPRIVBIND");
1935 case TCP_EXCLBIND
: return ("TCP_EXCLBIND");
1936 case TCP_INIT_CWND
: return ("TCP_INIT_CWND");
1937 case TCP_KEEPALIVE_THRESHOLD
: return ("TCP_KEEPALIVE_THRESHOLD");
1938 case TCP_KEEPALIVE_ABORT_THRESHOLD
:
1939 return ("TCP_KEEPALIVE_ABORT_THRESHOLD");
1940 case TCP_CORK
: return ("TCP_CORK");
1941 case TCP_RTO_INITIAL
: return ("TCP_RTO_INITIAL");
1942 case TCP_RTO_MIN
: return ("TCP_RTO_MIN");
1943 case TCP_RTO_MAX
: return ("TCP_RTO_MAX");
1944 case TCP_LINGER2
: return ("TCP_LINGER2");
1945 case TCP_KEEPIDLE
: return ("TCP_KEEPIDLE");
1946 case TCP_KEEPCNT
: return ("TCP_KEEPCNT");
1947 case TCP_KEEPINTVL
: return ("TCP_KEEPINTVL");
1949 default: (void) snprintf(pri
->code_buf
,
1950 sizeof (pri
->code_buf
),
1952 return (pri
->code_buf
);
1958 sctp_optname(private_t
*pri
, long val
)
1961 case SCTP_RTOINFO
: return ("SCTP_RTOINFO");
1962 case SCTP_ASSOCINFO
: return ("SCTP_ASSOCINFO");
1963 case SCTP_INITMSG
: return ("SCTP_INITMSG");
1964 case SCTP_NODELAY
: return ("SCTP_NODELAY");
1965 case SCTP_AUTOCLOSE
: return ("SCTP_AUTOCLOSE");
1966 case SCTP_SET_PEER_PRIMARY_ADDR
:
1967 return ("SCTP_SET_PEER_PRIMARY_ADDR");
1968 case SCTP_PRIMARY_ADDR
: return ("SCTP_PRIMARY_ADDR");
1969 case SCTP_ADAPTATION_LAYER
: return ("SCTP_ADAPTATION_LAYER");
1970 case SCTP_DISABLE_FRAGMENTS
: return ("SCTP_DISABLE_FRAGMENTS");
1971 case SCTP_PEER_ADDR_PARAMS
: return ("SCTP_PEER_ADDR_PARAMS");
1972 case SCTP_DEFAULT_SEND_PARAM
: return ("SCTP_DEFAULT_SEND_PARAM");
1973 case SCTP_EVENTS
: return ("SCTP_EVENTS");
1974 case SCTP_I_WANT_MAPPED_V4_ADDR
:
1975 return ("SCTP_I_WANT_MAPPED_V4_ADDR");
1976 case SCTP_MAXSEG
: return ("SCTP_MAXSEG");
1977 case SCTP_STATUS
: return ("SCTP_STATUS");
1978 case SCTP_GET_PEER_ADDR_INFO
: return ("SCTP_GET_PEER_ADDR_INFO");
1980 case SCTP_ADD_ADDR
: return ("SCTP_ADD_ADDR");
1981 case SCTP_REM_ADDR
: return ("SCTP_REM_ADDR");
1983 default: (void) snprintf(pri
->code_buf
,
1984 sizeof (pri
->code_buf
),
1986 return (pri
->code_buf
);
1992 udp_optname(private_t
*pri
, long val
)
1995 case UDP_CHECKSUM
: return ("UDP_CHECKSUM");
1996 case UDP_ANONPRIVBIND
: return ("UDP_ANONPRIVBIND");
1997 case UDP_EXCLBIND
: return ("UDP_EXCLBIND");
1998 case UDP_RCVHDR
: return ("UDP_RCVHDR");
1999 case UDP_NAT_T_ENDPOINT
: return ("UDP_NAT_T_ENDPOINT");
2001 default: (void) snprintf(pri
->code_buf
,
2002 sizeof (pri
->code_buf
), "0x%lx",
2004 return (pri
->code_buf
);
2010 * Print setsockopt()/getsockopt() 3rd argument.
2014 prt_son(private_t
*pri
, int raw
, long val
)
2016 /* cheating -- look at the level */
2017 switch (pri
->sys_args
[1]) {
2018 case SOL_SOCKET
: outstring(pri
, sol_optname(pri
, val
));
2020 case SOL_ROUTE
: outstring(pri
, route_optname(pri
, val
));
2022 case IPPROTO_TCP
: outstring(pri
, tcp_optname(pri
, val
));
2024 case IPPROTO_UDP
: outstring(pri
, udp_optname(pri
, val
));
2026 case IPPROTO_SCTP
: outstring(pri
, sctp_optname(pri
, val
));
2028 default: prt_dec(pri
, 0, val
);
2039 prt_utt(private_t
*pri
, int raw
, long val
)
2041 const char *s
= NULL
;
2046 case UT_INSTRUCTION_DISABLED
:
2047 s
= "UT_INSTRUCTION_DISABLED"; break;
2048 case UT_INSTRUCTION_ERROR
:
2049 s
= "UT_INSTRUCTION_ERROR"; break;
2050 case UT_INSTRUCTION_PROTECTION
:
2051 s
= "UT_INSTRUCTION_PROTECTION"; break;
2052 case UT_ILLTRAP_INSTRUCTION
:
2053 s
= "UT_ILLTRAP_INSTRUCTION"; break;
2054 case UT_ILLEGAL_INSTRUCTION
:
2055 s
= "UT_ILLEGAL_INSTRUCTION"; break;
2056 case UT_PRIVILEGED_OPCODE
:
2057 s
= "UT_PRIVILEGED_OPCODE"; break;
2058 case UT_FP_DISABLED
:
2059 s
= "UT_FP_DISABLED"; break;
2060 case UT_FP_EXCEPTION_IEEE_754
:
2061 s
= "UT_FP_EXCEPTION_IEEE_754"; break;
2062 case UT_FP_EXCEPTION_OTHER
:
2063 s
= "UT_FP_EXCEPTION_OTHER"; break;
2064 case UT_TAG_OVERFLOW
:
2065 s
= "UT_TAG_OVERFLOW"; break;
2066 case UT_DIVISION_BY_ZERO
:
2067 s
= "UT_DIVISION_BY_ZERO"; break;
2068 case UT_DATA_EXCEPTION
:
2069 s
= "UT_DATA_EXCEPTION"; break;
2071 s
= "UT_DATA_ERROR"; break;
2072 case UT_DATA_PROTECTION
:
2073 s
= "UT_DATA_PROTECTION"; break;
2074 case UT_MEM_ADDRESS_NOT_ALIGNED
:
2075 s
= "UT_MEM_ADDRESS_NOT_ALIGNED"; break;
2076 case UT_PRIVILEGED_ACTION
:
2077 s
= "UT_PRIVILEGED_ACTION"; break;
2078 case UT_ASYNC_DATA_ERROR
:
2079 s
= "UT_ASYNC_DATA_ERROR"; break;
2080 case UT_TRAP_INSTRUCTION_16
:
2081 s
= "UT_TRAP_INSTRUCTION_16"; break;
2082 case UT_TRAP_INSTRUCTION_17
:
2083 s
= "UT_TRAP_INSTRUCTION_17"; break;
2084 case UT_TRAP_INSTRUCTION_18
:
2085 s
= "UT_TRAP_INSTRUCTION_18"; break;
2086 case UT_TRAP_INSTRUCTION_19
:
2087 s
= "UT_TRAP_INSTRUCTION_19"; break;
2088 case UT_TRAP_INSTRUCTION_20
:
2089 s
= "UT_TRAP_INSTRUCTION_20"; break;
2090 case UT_TRAP_INSTRUCTION_21
:
2091 s
= "UT_TRAP_INSTRUCTION_21"; break;
2092 case UT_TRAP_INSTRUCTION_22
:
2093 s
= "UT_TRAP_INSTRUCTION_22"; break;
2094 case UT_TRAP_INSTRUCTION_23
:
2095 s
= "UT_TRAP_INSTRUCTION_23"; break;
2096 case UT_TRAP_INSTRUCTION_24
:
2097 s
= "UT_TRAP_INSTRUCTION_24"; break;
2098 case UT_TRAP_INSTRUCTION_25
:
2099 s
= "UT_TRAP_INSTRUCTION_25"; break;
2100 case UT_TRAP_INSTRUCTION_26
:
2101 s
= "UT_TRAP_INSTRUCTION_26"; break;
2102 case UT_TRAP_INSTRUCTION_27
:
2103 s
= "UT_TRAP_INSTRUCTION_27"; break;
2104 case UT_TRAP_INSTRUCTION_28
:
2105 s
= "UT_TRAP_INSTRUCTION_28"; break;
2106 case UT_TRAP_INSTRUCTION_29
:
2107 s
= "UT_TRAP_INSTRUCTION_29"; break;
2108 case UT_TRAP_INSTRUCTION_30
:
2109 s
= "UT_TRAP_INSTRUCTION_30"; break;
2110 case UT_TRAP_INSTRUCTION_31
:
2111 s
= "UT_TRAP_INSTRUCTION_31"; break;
2114 #endif /* __sparc */
2117 prt_dec(pri
, 0, val
);
2124 * Print utrap handler
2127 prt_uth(private_t
*pri
, int raw
, long val
)
2129 const char *s
= NULL
;
2133 case (long)UTH_NOCHANGE
: s
= "UTH_NOCHANGE"; break;
2138 prt_hex(pri
, 0, val
);
2144 access_flags(private_t
*pri
, long arg
)
2147 char *str
= pri
->code_buf
;
2149 if (arg
& ~(R_OK
|W_OK
|X_OK
|E_OK
))
2156 return ("F_OK|E_OK");
2160 (void) strlcat(str
, "|R_OK", sizeof (pri
->code_buf
));
2162 (void) strlcat(str
, "|W_OK", sizeof (pri
->code_buf
));
2164 (void) strlcat(str
, "|X_OK", sizeof (pri
->code_buf
));
2166 (void) strlcat(str
, "|E_OK", sizeof (pri
->code_buf
));
2167 return ((const char *)(str
+ 1));
2172 * Print access() flags.
2175 prt_acc(private_t
*pri
, int raw
, long val
)
2177 const char *s
= raw
? NULL
: access_flags(pri
, val
);
2180 prt_dex(pri
, 0, val
);
2186 * Print shutdown() "how" (2nd) argument
2189 prt_sht(private_t
*pri
, int raw
, long val
)
2192 prt_dex(pri
, 0, val
);
2196 case SHUT_RD
: outstring(pri
, "SHUT_RD"); break;
2197 case SHUT_WR
: outstring(pri
, "SHUT_WR"); break;
2198 case SHUT_RDWR
: outstring(pri
, "SHUT_RDWR"); break;
2199 default: prt_dec(pri
, 0, val
); break;
2204 * Print fcntl() F_SETFL flags (3rd) argument or fdsync flag (2nd arg)
2206 static struct fcntl_flags
{
2210 #define FC_FL(flag) { (long)flag, "|" # flag }
2232 prt_ffg(private_t
*pri
, int raw
, long val
)
2234 #define CBSIZE sizeof (pri->code_buf)
2235 char *s
= pri
->code_buf
;
2237 struct fcntl_flags
*fp
;
2240 (void) snprintf(s
, CBSIZE
, "0x%lx", val
);
2245 outstring(pri
, "(no flags)");
2250 for (fp
= fcntl_flags
;
2251 fp
< &fcntl_flags
[sizeof (fcntl_flags
) / sizeof (*fp
)]; fp
++) {
2252 if (val
& fp
->val
) {
2253 used
= strlcat(s
, fp
->name
, CBSIZE
);
2258 if (val
!= 0 && used
<= CBSIZE
)
2259 used
+= snprintf(s
+ used
, CBSIZE
- used
, "|0x%lx", val
);
2262 (void) snprintf(s
+ 1, CBSIZE
-1, "0x%lx", val
);
2263 outstring(pri
, s
+ 1);
2268 prt_prs(private_t
*pri
, int raw
, long val
)
2270 static size_t setsize
;
2271 priv_set_t
*set
= priv_allocset();
2274 const priv_impl_info_t
*info
= getprivimplinfo();
2276 setsize
= info
->priv_setsize
* sizeof (priv_chunk_t
);
2279 if (setsize
!= 0 && !raw
&& set
!= NULL
&&
2280 Pread(Proc
, set
, setsize
, val
) == setsize
) {
2283 outstring(pri
, "{");
2284 for (i
= 0; i
< setsize
/ sizeof (priv_chunk_t
); i
++) {
2285 char buf
[9]; /* 8 hex digits + '\0' */
2286 (void) snprintf(buf
, sizeof (buf
), "%08x",
2287 ((priv_chunk_t
*)set
)[i
]);
2288 outstring(pri
, buf
);
2291 outstring(pri
, "}");
2293 prt_hex(pri
, 0, val
);
2301 * Print privilege set operation.
2304 prt_pro(private_t
*pri
, int raw
, long val
)
2306 const char *s
= NULL
;
2309 switch ((priv_op_t
)val
) {
2310 case PRIV_ON
: s
= "PRIV_ON"; break;
2311 case PRIV_OFF
: s
= "PRIV_OFF"; break;
2312 case PRIV_SET
: s
= "PRIV_SET"; break;
2317 prt_dec(pri
, 0, val
);
2323 * Print privilege set name
2326 prt_prn(private_t
*pri
, int raw
, long val
)
2328 const char *s
= NULL
;
2331 s
= priv_getsetbynum((int)val
);
2334 prt_dec(pri
, 0, val
);
2336 char *dup
= strdup(s
);
2339 /* Do the best we can in this case */
2345 outstring(pri
, "PRIV_");
2349 while (*q
!= '\0') {
2353 outstring(pri
, dup
);
2359 * Print process flag names.
2362 prt_pfl(private_t
*pri
, int raw
, long val
)
2364 const char *s
= NULL
;
2368 case PRIV_DEBUG
: s
= "PRIV_DEBUG"; break;
2369 case PRIV_AWARE
: s
= "PRIV_AWARE"; break;
2370 case PRIV_XPOLICY
: s
= "PRIV_XPOLICY"; break;
2371 case PRIV_AWARE_RESET
: s
= "PRIV_AWARE_RESET"; break;
2372 case PRIV_PFEXEC
: s
= "PRIV_PFEXEC"; break;
2373 case NET_MAC_AWARE
: s
= "NET_MAC_AWARE"; break;
2374 case NET_MAC_AWARE_INHERIT
:
2375 s
= "NET_MAC_AWARE_INHERIT";
2381 prt_dec(pri
, 0, val
);
2387 * Print lgrp_affinity_{get,set}() arguments.
2391 prt_laf(private_t
*pri
, int raw
, long val
)
2393 lgrp_affinity_args_t laff
;
2395 if (Pread(Proc
, &laff
, sizeof (lgrp_affinity_args_t
), val
) !=
2396 sizeof (lgrp_affinity_args_t
)) {
2397 prt_hex(pri
, 0, val
);
2401 * arrange the arguments in the order that user calls with
2403 prt_dec(pri
, 0, laff
.idtype
);
2404 outstring(pri
, ", ");
2405 prt_dec(pri
, 0, laff
.id
);
2406 outstring(pri
, ", ");
2407 prt_dec(pri
, 0, laff
.lgrp
);
2408 outstring(pri
, ", ");
2409 if (pri
->sys_args
[0] == LGRP_SYS_AFFINITY_SET
)
2410 prt_dec(pri
, 0, laff
.aff
);
2414 * Print a key_t as IPC_PRIVATE if it is 0.
2417 prt_key(private_t
*pri
, int raw
, long val
)
2419 if (!raw
&& val
== 0)
2420 outstring(pri
, "IPC_PRIVATE");
2422 prt_dec(pri
, 0, val
);
2427 * Print zone_getattr() attribute types.
2430 prt_zga(private_t
*pri
, int raw
, long val
)
2432 const char *s
= NULL
;
2436 case ZONE_ATTR_NAME
: s
= "ZONE_ATTR_NAME"; break;
2437 case ZONE_ATTR_ROOT
: s
= "ZONE_ATTR_ROOT"; break;
2438 case ZONE_ATTR_STATUS
: s
= "ZONE_ATTR_STATUS"; break;
2439 case ZONE_ATTR_PRIVSET
: s
= "ZONE_ATTR_PRIVSET"; break;
2440 case ZONE_ATTR_UNIQID
: s
= "ZONE_ATTR_UNIQID"; break;
2441 case ZONE_ATTR_POOLID
: s
= "ZONE_ATTR_POOLID"; break;
2442 case ZONE_ATTR_INITPID
: s
= "ZONE_ATTR_INITPID"; break;
2443 case ZONE_ATTR_SLBL
: s
= "ZONE_ATTR_SLBL"; break;
2444 case ZONE_ATTR_INITNAME
: s
= "ZONE_ATTR_INITNAME"; break;
2445 case ZONE_ATTR_BOOTARGS
: s
= "ZONE_ATTR_BOOTARGS"; break;
2446 case ZONE_ATTR_BRAND
: s
= "ZONE_ATTR_BRAND"; break;
2447 case ZONE_ATTR_FLAGS
: s
= "ZONE_ATTR_FLAGS"; break;
2448 case ZONE_ATTR_PHYS_MCAP
: s
= "ZONE_ATTR_PHYS_MCAP"; break;
2453 prt_dec(pri
, 0, val
);
2459 * Print a file descriptor as AT_FDCWD if necessary
2462 prt_atc(private_t
*pri
, int raw
, long val
)
2464 if ((int)val
== AT_FDCWD
) {
2466 prt_hex(pri
, 0, (uint_t
)AT_FDCWD
);
2468 outstring(pri
, "AT_FDCWD");
2470 prt_dec(pri
, 0, val
);
2475 * Print Trusted Networking database operation codes (labelsys; tn*)
2478 prt_tnd(private_t
*pri
, int raw
, long val
)
2480 const char *s
= NULL
;
2483 switch ((tsol_dbops_t
)val
) {
2484 case TNDB_NOOP
: s
= "TNDB_NOOP"; break;
2485 case TNDB_LOAD
: s
= "TNDB_LOAD"; break;
2486 case TNDB_DELETE
: s
= "TNDB_DELETE"; break;
2487 case TNDB_FLUSH
: s
= "TNDB_FLUSH"; break;
2488 case TNDB_GET
: s
= "TNDB_GET"; break;
2493 prt_dec(pri
, 0, val
);
2499 * Print LIO_XX flags
2502 prt_lio(private_t
*pri
, int raw
, long val
)
2505 prt_dec(pri
, 0, val
);
2506 else if (val
== LIO_WAIT
)
2507 outstring(pri
, "LIO_WAIT");
2508 else if (val
== LIO_NOWAIT
)
2509 outstring(pri
, "LIO_NOWAIT");
2511 prt_dec(pri
, 0, val
);
2515 door_flags(private_t
*pri
, long val
)
2517 door_attr_t attr
= (door_attr_t
)val
;
2518 char *str
= pri
->code_buf
;
2521 #define PROCESS_FLAG(flg) \
2523 (void) strlcat(str, "|" #flg, sizeof (pri->code_buf)); \
2527 PROCESS_FLAG(DOOR_UNREF
);
2528 PROCESS_FLAG(DOOR_UNREF_MULTI
);
2529 PROCESS_FLAG(DOOR_PRIVATE
);
2530 PROCESS_FLAG(DOOR_REFUSE_DESC
);
2531 PROCESS_FLAG(DOOR_NO_CANCEL
);
2532 PROCESS_FLAG(DOOR_LOCAL
);
2533 PROCESS_FLAG(DOOR_REVOKED
);
2534 PROCESS_FLAG(DOOR_IS_UNREF
);
2537 if (attr
!= 0 || *str
== '\0') {
2538 size_t len
= strlen(str
);
2539 (void) snprintf(str
+ len
, sizeof (pri
->code_buf
) - len
,
2547 * Print door_create() flags
2550 prt_dfl(private_t
*pri
, int raw
, long val
)
2553 prt_hex(pri
, 0, val
);
2555 outstring(pri
, door_flags(pri
, val
));
2559 * Print door_*param() param argument
2562 prt_dpm(private_t
*pri
, int raw
, long val
)
2565 prt_hex(pri
, 0, val
);
2566 else if (val
== DOOR_PARAM_DESC_MAX
)
2567 outstring(pri
, "DOOR_PARAM_DESC_MAX");
2568 else if (val
== DOOR_PARAM_DATA_MIN
)
2569 outstring(pri
, "DOOR_PARAM_DATA_MIN");
2570 else if (val
== DOOR_PARAM_DATA_MAX
)
2571 outstring(pri
, "DOOR_PARAM_DATA_MAX");
2573 prt_hex(pri
, 0, val
);
2577 * Print rctlsys subcodes
2580 prt_rsc(private_t
*pri
, int raw
, long val
) /* print utssys code */
2582 const char *s
= raw
? NULL
: rctlsyscode(val
);
2585 prt_dec(pri
, 0, val
);
2591 * Print getrctl flags
2594 prt_rgf(private_t
*pri
, int raw
, long val
)
2596 long action
= val
& (~RCTLSYS_ACTION_MASK
);
2599 prt_hex(pri
, 0, val
);
2600 else if (action
== RCTL_FIRST
)
2601 outstring(pri
, "RCTL_FIRST");
2602 else if (action
== RCTL_NEXT
)
2603 outstring(pri
, "RCTL_NEXT");
2604 else if (action
== RCTL_USAGE
)
2605 outstring(pri
, "RCTL_USAGE");
2607 prt_hex(pri
, 0, val
);
2611 * Print setrctl flags
2614 prt_rsf(private_t
*pri
, int raw
, long val
)
2616 long action
= val
& (~RCTLSYS_ACTION_MASK
);
2617 long pval
= val
& RCTL_LOCAL_ACTION_MASK
;
2618 char *s
= pri
->code_buf
;
2621 prt_hex(pri
, 0, val
);
2623 } else if (action
== RCTL_INSERT
)
2624 (void) strcpy(s
, "RCTL_INSERT");
2625 else if (action
== RCTL_DELETE
)
2626 (void) strcpy(s
, "RCTL_DELETE");
2627 else if (action
== RCTL_REPLACE
)
2628 (void) strcpy(s
, "RCTL_REPLACE");
2630 prt_hex(pri
, 0, val
);
2634 if (pval
& RCTL_USE_RECIPIENT_PID
) {
2635 pval
^= RCTL_USE_RECIPIENT_PID
;
2636 (void) strlcat(s
, "|RCTL_USE_RECIPIENT_PID",
2637 sizeof (pri
->code_buf
));
2640 if ((pval
& RCTLSYS_ACTION_MASK
) != 0)
2641 prt_hex(pri
, 0, val
);
2642 else if (*s
!= '\0')
2645 prt_hex(pri
, 0, val
);
2649 * Print rctlctl flags
2652 prt_rcf(private_t
*pri
, int raw
, long val
)
2654 long action
= val
& (~RCTLSYS_ACTION_MASK
);
2657 prt_hex(pri
, 0, val
);
2658 else if (action
== RCTLCTL_GET
)
2659 outstring(pri
, "RCTLCTL_GET");
2660 else if (action
== RCTLCTL_SET
)
2661 outstring(pri
, "RCTLCTL_SET");
2663 prt_hex(pri
, 0, val
);
2667 * Print setprojrctl flags
2670 prt_spf(private_t
*pri
, int raw
, long val
)
2672 long action
= val
& TASK_PROJ_MASK
;
2674 if (!raw
&& (action
== TASK_PROJ_PURGE
))
2675 outstring(pri
, "TASK_PROJ_PURGE");
2677 prt_hex(pri
, 0, val
);
2681 * Print forkx() flags
2684 prt_fxf(private_t
*pri
, int raw
, long val
)
2689 outstring(pri
, "0");
2690 else if (raw
|| (val
& ~(FORK_NOSIGCHLD
| FORK_WAITPID
)))
2691 prt_hhx(pri
, 0, val
);
2693 str
= pri
->code_buf
;
2695 if (val
& FORK_NOSIGCHLD
)
2696 (void) strlcat(str
, "|FORK_NOSIGCHLD",
2697 sizeof (pri
->code_buf
));
2698 if (val
& FORK_WAITPID
)
2699 (void) strlcat(str
, "|FORK_WAITPID",
2700 sizeof (pri
->code_buf
));
2701 outstring(pri
, str
+ 1);
2706 * Print faccessat() flag
2709 prt_fat(private_t
*pri
, int raw
, long val
)
2712 outstring(pri
, "0");
2713 else if (!raw
&& val
== AT_EACCESS
)
2714 outstring(pri
, "AT_EACCESS");
2716 prt_hex(pri
, 0, val
);
2720 * Print unlinkat() flag
2723 prt_uat(private_t
*pri
, int raw
, long val
)
2726 outstring(pri
, "0");
2727 else if (!raw
&& val
== AT_REMOVEDIR
)
2728 outstring(pri
, "AT_REMOVEDIR");
2730 prt_hex(pri
, 0, val
);
2734 * Print AT_SYMLINK_NOFOLLOW / AT_SYMLINK_FOLLOW flag
2737 prt_snf(private_t
*pri
, int raw
, long val
)
2740 outstring(pri
, "0");
2741 else if (!raw
&& val
== AT_SYMLINK_NOFOLLOW
)
2742 outstring(pri
, "AT_SYMLINK_NOFOLLOW");
2743 else if (!raw
&& val
== AT_SYMLINK_FOLLOW
)
2744 outstring(pri
, "AT_SYMLINK_FOLLOW");
2746 prt_hex(pri
, 0, val
);
2750 prt_grf(private_t
*pri
, int raw
, long val
)
2754 if (raw
!= 0 || val
== 0 ||
2755 (val
& ~(GRND_NONBLOCK
| GRND_RANDOM
)) != 0) {
2756 outstring(pri
, "0");
2760 if (val
& GRND_NONBLOCK
) {
2761 outstring(pri
, "|GRND_NONBLOCK" + first
);
2764 if (val
& GRND_RANDOM
) {
2765 outstring(pri
, "|GRND_RANDOM" + first
);
2771 * Array of pointers to print functions, one for each format.
2773 void (* const Print
[])() = {
2774 prt_nov
, /* NOV -- no value */
2775 prt_dec
, /* DEC -- print value in decimal */
2776 prt_oct
, /* OCT -- print value in octal */
2777 prt_hex
, /* HEX -- print value in hexadecimal */
2778 prt_dex
, /* DEX -- print value in hexadecimal if big enough */
2779 prt_stg
, /* STG -- print value as string */
2780 prt_ioc
, /* IOC -- print ioctl code */
2781 prt_fcn
, /* FCN -- print fcntl code */
2782 prt_s86
, /* S86 -- print sysi86 code */
2783 prt_uts
, /* UTS -- print utssys code */
2784 prt_opn
, /* OPN -- print open code */
2785 prt_sig
, /* SIG -- print signal name plus flags */
2786 prt_uat
, /* UAT -- print unlinkat() flag */
2787 prt_msc
, /* MSC -- print msgsys command */
2788 prt_msf
, /* MSF -- print msgsys flags */
2789 prt_smc
, /* SMC -- print semsys command */
2790 prt_sef
, /* SEF -- print semsys flags */
2791 prt_shc
, /* SHC -- print shmsys command */
2792 prt_shf
, /* SHF -- print shmsys flags */
2793 prt_fat
, /* FAT -- print faccessat( flag */
2794 prt_sfs
, /* SFS -- print sysfs code */
2795 prt_rst
, /* RST -- print string returned by syscall */
2796 prt_smf
, /* SMF -- print streams message flags */
2797 prt_ioa
, /* IOA -- print ioctl argument */
2798 prt_pip
, /* PIP -- print pipe flags */
2799 prt_mtf
, /* MTF -- print mount flags */
2800 prt_mft
, /* MFT -- print mount file system type */
2801 prt_iob
, /* IOB -- print contents of I/O buffer */
2802 prt_hhx
, /* HHX -- print value in hexadecimal (half size) */
2803 prt_wop
, /* WOP -- print waitsys() options */
2804 prt_spm
, /* SPM -- print sigprocmask argument */
2805 prt_rlk
, /* RLK -- print readlink buffer */
2806 prt_mpr
, /* MPR -- print mmap()/mprotect() flags */
2807 prt_mty
, /* MTY -- print mmap() mapping type flags */
2808 prt_mcf
, /* MCF -- print memcntl() function */
2809 prt_mc4
, /* MC4 -- print memcntl() (fourth) argument */
2810 prt_mc5
, /* MC5 -- print memcntl() (fifth) argument */
2811 prt_mad
, /* MAD -- print madvise() argument */
2812 prt_ulm
, /* ULM -- print ulimit() argument */
2813 prt_rlm
, /* RLM -- print get/setrlimit() argument */
2814 prt_cnf
, /* CNF -- print sysconfig() argument */
2815 prt_inf
, /* INF -- print sysinfo() argument */
2816 prt_ptc
, /* PTC -- print pathconf/fpathconf() argument */
2817 prt_fui
, /* FUI -- print fusers() input argument */
2818 prt_idt
, /* IDT -- print idtype_t, waitid() argument */
2819 prt_lwf
, /* LWF -- print lwp_create() flags */
2820 prt_itm
, /* ITM -- print [get|set]itimer() arg */
2821 prt_llo
, /* LLO -- print long long offset arg */
2822 prt_mod
, /* MOD -- print modctl() subcode */
2823 prt_whn
, /* WHN -- print lseek() whence arguiment */
2824 prt_acl
, /* ACL -- print acl() code */
2825 prt_aio
, /* AIO -- print kaio() code */
2826 prt_aud
, /* AUD -- print auditsys() code */
2827 prt_uns
, /* DEC -- print value in unsigned decimal */
2828 prt_clc
, /* CLC -- print cladm command argument */
2829 prt_clf
, /* CLF -- print cladm flag argument */
2830 prt_cor
, /* COR -- print corectl() subcode */
2831 prt_cco
, /* CCO -- print corectl() options */
2832 prt_ccc
, /* CCC -- print corectl() content */
2833 prt_rcc
, /* RCC -- print corectl() returned content */
2834 prt_cpc
, /* CPC -- print cpc() subcode */
2835 prt_sqc
, /* SQC -- print sigqueue() si_code argument */
2836 prt_pc4
, /* PC4 -- print priocntlsys() (fourth) argument */
2837 prt_pc5
, /* PC5 -- print priocntlsys() (key, value) pairs */
2838 prt_pst
, /* PST -- print processor set id */
2839 prt_mif
, /* MIF -- print meminfo() arguments */
2840 prt_pfm
, /* PFM -- print so_socket() proto-family (1st) arg */
2841 prt_skt
, /* SKT -- print so_socket() socket-type (2nd) arg */
2842 prt_skp
, /* SKP -- print so_socket() protocol (3rd) arg */
2843 prt_skv
, /* SKV -- print socket version arg */
2844 prt_sol
, /* SOL -- print [sg]etsockopt() level (2nd) arg */
2845 prt_son
, /* SON -- print [sg]etsockopt() opt-name (3rd) arg */
2846 prt_utt
, /* UTT -- print utrap type */
2847 prt_uth
, /* UTH -- print utrap handler */
2848 prt_acc
, /* ACC -- print access() flags */
2849 prt_sht
, /* SHT -- print shutdown() how (2nd) argument */
2850 prt_ffg
, /* FFG -- print fcntl() flags (3rd) argument */
2851 prt_prs
, /* PRS -- print privilege set */
2852 prt_pro
, /* PRO -- print privilege set operation */
2853 prt_prn
, /* PRN -- print privilege set name */
2854 prt_pfl
, /* PFL -- print privilege/process flag name */
2855 prt_laf
, /* LAF -- print lgrp_affinity arguments */
2856 prt_key
, /* KEY -- print key_t 0 as IPC_PRIVATE */
2857 prt_zga
, /* ZGA -- print zone_getattr attribute types */
2858 prt_atc
, /* ATC -- print AT_FDCWD or file descriptor */
2859 prt_lio
, /* LIO -- print LIO_XX flags */
2860 prt_dfl
, /* DFL -- print door_create() flags */
2861 prt_dpm
, /* DPM -- print DOOR_PARAM_XX flags */
2862 prt_tnd
, /* TND -- print trusted network data base opcode */
2863 prt_rsc
, /* RSC -- print rctlsys() subcodes */
2864 prt_rgf
, /* RGF -- print getrctl() flags */
2865 prt_rsf
, /* RSF -- print setrctl() flags */
2866 prt_rcf
, /* RCF -- print rctlsys_ctl() flags */
2867 prt_fxf
, /* FXF -- print forkx() flags */
2868 prt_spf
, /* SPF -- print rctlsys_projset() flags */
2869 prt_un1
, /* UN1 -- as prt_uns except for -1 */
2870 prt_mob
, /* MOB -- print mmapobj() flags */
2871 prt_snf
, /* SNF -- print AT_SYMLINK_[NO]FOLLOW flag */
2872 prt_skc
, /* SKC -- print sockconfig() subcode */
2873 prt_acf
, /* ACF -- print accept4 flags */
2874 prt_pfd
, /* PFD -- print pipe fds */
2875 prt_grf
, /* GRF -- print getrandom flags */
2876 prt_dec
, /* HID -- hidden argument, make this the last one */