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