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