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