xref: /onnv-gate/usr/src/cmd/truss/print.c (revision 4217)
10Sstevel@tonic-gate /*
20Sstevel@tonic-gate  * CDDL HEADER START
30Sstevel@tonic-gate  *
40Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
51676Sjpk  * Common Development and Distribution License (the "License").
61676Sjpk  * You may not use this file except in compliance with the License.
70Sstevel@tonic-gate  *
80Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
90Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
100Sstevel@tonic-gate  * See the License for the specific language governing permissions
110Sstevel@tonic-gate  * and limitations under the License.
120Sstevel@tonic-gate  *
130Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
140Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
150Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
160Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
170Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
180Sstevel@tonic-gate  *
190Sstevel@tonic-gate  * CDDL HEADER END
200Sstevel@tonic-gate  */
210Sstevel@tonic-gate /*
223388Skcpoon  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
230Sstevel@tonic-gate  * Use is subject to license terms.
240Sstevel@tonic-gate  */
250Sstevel@tonic-gate 
260Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
270Sstevel@tonic-gate /*	  All Rights Reserved  	*/
280Sstevel@tonic-gate 
290Sstevel@tonic-gate 
300Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
310Sstevel@tonic-gate 
320Sstevel@tonic-gate #define	_SYSCALL32	/* make 32-bit compat headers visible */
330Sstevel@tonic-gate 
340Sstevel@tonic-gate #include <stdio.h>
350Sstevel@tonic-gate #include <stdlib.h>
360Sstevel@tonic-gate #include <unistd.h>
370Sstevel@tonic-gate #include <string.h>
380Sstevel@tonic-gate #include <signal.h>
390Sstevel@tonic-gate #include <termio.h>
400Sstevel@tonic-gate #include <stddef.h>
410Sstevel@tonic-gate #include <limits.h>
420Sstevel@tonic-gate #include <ctype.h>
430Sstevel@tonic-gate #include <sys/types.h>
440Sstevel@tonic-gate #include <sys/mman.h>
450Sstevel@tonic-gate #include <sys/resource.h>
460Sstevel@tonic-gate #include <sys/ulimit.h>
470Sstevel@tonic-gate #include <sys/utsname.h>
480Sstevel@tonic-gate #include <sys/kstat.h>
490Sstevel@tonic-gate #include <sys/modctl.h>
500Sstevel@tonic-gate #include <sys/acl.h>
510Sstevel@tonic-gate #include <stropts.h>
520Sstevel@tonic-gate #include <sys/isa_defs.h>
530Sstevel@tonic-gate #include <sys/systeminfo.h>
540Sstevel@tonic-gate #include <sys/cladm.h>
550Sstevel@tonic-gate #include <sys/lwp.h>
560Sstevel@tonic-gate #include <bsm/audit.h>
570Sstevel@tonic-gate #include <libproc.h>
580Sstevel@tonic-gate #include <priv.h>
590Sstevel@tonic-gate #include <sys/aio.h>
600Sstevel@tonic-gate #include <sys/aiocb.h>
610Sstevel@tonic-gate #include <sys/corectl.h>
620Sstevel@tonic-gate #include <sys/cpc_impl.h>
630Sstevel@tonic-gate #include <sys/priocntl.h>
640Sstevel@tonic-gate #include <sys/tspriocntl.h>
650Sstevel@tonic-gate #include <sys/iapriocntl.h>
660Sstevel@tonic-gate #include <sys/rtpriocntl.h>
670Sstevel@tonic-gate #include <sys/fsspriocntl.h>
680Sstevel@tonic-gate #include <sys/fxpriocntl.h>
690Sstevel@tonic-gate #include <netdb.h>
700Sstevel@tonic-gate #include <nss_dbdefs.h>
710Sstevel@tonic-gate #include <sys/socketvar.h>
720Sstevel@tonic-gate #include <netinet/in.h>
730Sstevel@tonic-gate #include <netinet/tcp.h>
740Sstevel@tonic-gate #include <netinet/udp.h>
750Sstevel@tonic-gate #include <netinet/sctp.h>
760Sstevel@tonic-gate #include <sys/utrap.h>
770Sstevel@tonic-gate #include <sys/lgrp_user.h>
780Sstevel@tonic-gate #include <sys/door.h>
791676Sjpk #include <sys/tsol/tndb.h>
802447Snf202958 #include <sys/rctl.h>
812447Snf202958 #include <sys/rctl_impl.h>
823235Sraf #include <sys/fork.h>
833684Srd117015 #include <sys/task.h>
840Sstevel@tonic-gate #include "ramdata.h"
850Sstevel@tonic-gate #include "print.h"
860Sstevel@tonic-gate #include "proto.h"
870Sstevel@tonic-gate #include "systable.h"
880Sstevel@tonic-gate 
890Sstevel@tonic-gate void grow(private_t *, int nbyte);
900Sstevel@tonic-gate 
910Sstevel@tonic-gate #define	GROW(nb) if (pri->sys_leng + (nb) >= pri->sys_ssize) grow(pri, (nb))
920Sstevel@tonic-gate 
930Sstevel@tonic-gate 
940Sstevel@tonic-gate /*ARGSUSED*/
950Sstevel@tonic-gate void
960Sstevel@tonic-gate prt_nov(private_t *pri, int raw, long val)	/* print nothing */
970Sstevel@tonic-gate {
980Sstevel@tonic-gate }
990Sstevel@tonic-gate 
1000Sstevel@tonic-gate /*ARGSUSED*/
1010Sstevel@tonic-gate void
1020Sstevel@tonic-gate prt_dec(private_t *pri, int raw, long val)	/* print as decimal */
1030Sstevel@tonic-gate {
1040Sstevel@tonic-gate 	GROW(24);
1050Sstevel@tonic-gate 	if (data_model == PR_MODEL_ILP32)
1060Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
107*4217Seschrock 		    "%d", (int)val);
1080Sstevel@tonic-gate 	else
1090Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
110*4217Seschrock 		    "%ld", val);
1110Sstevel@tonic-gate }
1120Sstevel@tonic-gate 
1130Sstevel@tonic-gate /*ARGSUSED*/
1140Sstevel@tonic-gate void
1150Sstevel@tonic-gate prt_uns(private_t *pri, int raw, long val)	/* print as unsigned decimal */
1160Sstevel@tonic-gate {
1170Sstevel@tonic-gate 	GROW(24);
1180Sstevel@tonic-gate 	if (data_model == PR_MODEL_ILP32)
1190Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
120*4217Seschrock 		    "%u", (int)val);
1210Sstevel@tonic-gate 	else
1220Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
123*4217Seschrock 		    "%lu", val);
1240Sstevel@tonic-gate }
1250Sstevel@tonic-gate 
1260Sstevel@tonic-gate /*ARGSUSED*/
1270Sstevel@tonic-gate void
1280Sstevel@tonic-gate prt_oct(private_t *pri, int raw, long val)	/* print as octal */
1290Sstevel@tonic-gate {
1300Sstevel@tonic-gate 	GROW(24);
1310Sstevel@tonic-gate 	if (data_model == PR_MODEL_ILP32)
1320Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
133*4217Seschrock 		    "%#o", (int)val);
1340Sstevel@tonic-gate 	else
1350Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
136*4217Seschrock 		    "%#lo", val);
1370Sstevel@tonic-gate }
1380Sstevel@tonic-gate 
1390Sstevel@tonic-gate /*ARGSUSED*/
1400Sstevel@tonic-gate void
1410Sstevel@tonic-gate prt_hex(private_t *pri, int raw, long val)	/* print as hexadecimal */
1420Sstevel@tonic-gate {
1430Sstevel@tonic-gate 	GROW(20);
1440Sstevel@tonic-gate 	if (data_model == PR_MODEL_ILP32)
1450Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
146*4217Seschrock 		    "0x%.8X", (int)val);
1470Sstevel@tonic-gate 	else
1480Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
149*4217Seschrock 		    "0x%.8lX", val);
1500Sstevel@tonic-gate }
1510Sstevel@tonic-gate 
1520Sstevel@tonic-gate /* print as hexadecimal (half size) */
1530Sstevel@tonic-gate /*ARGSUSED*/
1540Sstevel@tonic-gate void
1550Sstevel@tonic-gate prt_hhx(private_t *pri, int raw, long val)
1560Sstevel@tonic-gate {
1570Sstevel@tonic-gate 	GROW(20);
1580Sstevel@tonic-gate 	if (data_model == PR_MODEL_ILP32)
1590Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
160*4217Seschrock 		    "0x%.4X", (int)val);
1610Sstevel@tonic-gate 	else
1620Sstevel@tonic-gate 		pri->sys_leng += sprintf(pri->sys_string + pri->sys_leng,
163*4217Seschrock 		    "0x%.4lX", val);
1640Sstevel@tonic-gate }
1650Sstevel@tonic-gate 
1660Sstevel@tonic-gate /* print as decimal if small, else hexadecimal */
1670Sstevel@tonic-gate /*ARGSUSED*/
1680Sstevel@tonic-gate void
1690Sstevel@tonic-gate prt_dex(private_t *pri, int raw, long val)
1700Sstevel@tonic-gate {
1710Sstevel@tonic-gate 	if (val & 0xff000000)
1720Sstevel@tonic-gate 		prt_hex(pri, 0, val);
1730Sstevel@tonic-gate 	else
1740Sstevel@tonic-gate 		prt_dec(pri, 0, val);
1750Sstevel@tonic-gate }
1760Sstevel@tonic-gate 
1770Sstevel@tonic-gate /* print long long offset */
1780Sstevel@tonic-gate /*ARGSUSED*/
1790Sstevel@tonic-gate void
1800Sstevel@tonic-gate prt_llo(private_t *pri, int raw, long val1, long val2)
1810Sstevel@tonic-gate {
1820Sstevel@tonic-gate 	int hival;
1830Sstevel@tonic-gate 	int loval;
1840Sstevel@tonic-gate 
1850Sstevel@tonic-gate #ifdef	_LONG_LONG_LTOH
1860Sstevel@tonic-gate 	hival = (int)val2;
1870Sstevel@tonic-gate 	loval = (int)val1;
1880Sstevel@tonic-gate #else
1890Sstevel@tonic-gate 	hival = (int)val1;
1900Sstevel@tonic-gate 	loval = (int)val2;
1910Sstevel@tonic-gate #endif
1920Sstevel@tonic-gate 
193*4217Seschrock 	if (hival == 0) {
1940Sstevel@tonic-gate 		prt_dex(pri, 0, loval);
195*4217Seschrock 	} else {
1960Sstevel@tonic-gate 		GROW(18);
1970Sstevel@tonic-gate 		pri->sys_leng +=
198*4217Seschrock 		    sprintf(pri->sys_string + pri->sys_leng, "0x%.8X%.8X",
199*4217Seschrock 		    hival, loval);
2000Sstevel@tonic-gate 	}
2010Sstevel@tonic-gate }
2020Sstevel@tonic-gate 
2030Sstevel@tonic-gate void
2040Sstevel@tonic-gate escape_string(private_t *pri, const char *s)
2050Sstevel@tonic-gate {
2060Sstevel@tonic-gate 	/*
2070Sstevel@tonic-gate 	 * We want to avoid outputting unprintable characters that may
2080Sstevel@tonic-gate 	 * destroy the user's terminal.  So we do one pass to find any
2090Sstevel@tonic-gate 	 * unprintable characters, size the array appropriately, and
2100Sstevel@tonic-gate 	 * then walk each character by hand.  Those that are unprintable
2110Sstevel@tonic-gate 	 * are replaced by a hex escape (\xNN).  We also escape quotes for
2120Sstevel@tonic-gate 	 * completeness.
2130Sstevel@tonic-gate 	 */
2140Sstevel@tonic-gate 	int i, unprintable, quotes;
2150Sstevel@tonic-gate 	size_t len = strlen(s);
2160Sstevel@tonic-gate 	for (i = 0, unprintable = 0, quotes = 0; i < len; i++) {
2170Sstevel@tonic-gate 		if (!isprint(s[i]))
2180Sstevel@tonic-gate 			unprintable++;
2190Sstevel@tonic-gate 		if (s[i] == '"')
2200Sstevel@tonic-gate 			quotes++;
2210Sstevel@tonic-gate 	}
2220Sstevel@tonic-gate 
2230Sstevel@tonic-gate 	GROW(len + 3 * unprintable + quotes + 2);
2240Sstevel@tonic-gate 
2250Sstevel@tonic-gate 	pri->sys_string[pri->sys_leng++] = '"';
2260Sstevel@tonic-gate 	for (i = 0; i < len; i++) {
2270Sstevel@tonic-gate 		if (s[i] == '"')
2280Sstevel@tonic-gate 			pri->sys_string[pri->sys_leng++] = '\\';
2290Sstevel@tonic-gate 
2300Sstevel@tonic-gate 		if (isprint(s[i])) {
2310Sstevel@tonic-gate 			pri->sys_string[pri->sys_leng++] = s[i];
2320Sstevel@tonic-gate 		} else {
2330Sstevel@tonic-gate 			pri->sys_leng += sprintf(pri->sys_string +
234*4217Seschrock 			    pri->sys_leng, "\\x%02x", (uint8_t)s[i]);
2350Sstevel@tonic-gate 		}
2360Sstevel@tonic-gate 	}
2370Sstevel@tonic-gate 	pri->sys_string[pri->sys_leng++] = '"';
2380Sstevel@tonic-gate }
2390Sstevel@tonic-gate 
2400Sstevel@tonic-gate void
2410Sstevel@tonic-gate prt_stg(private_t *pri, int raw, long val)	/* print as string */
2420Sstevel@tonic-gate {
2430Sstevel@tonic-gate 	char *s = raw? NULL : fetchstring(pri, (long)val, PATH_MAX);
2440Sstevel@tonic-gate 
2450Sstevel@tonic-gate 	if (s == NULL)
2460Sstevel@tonic-gate 		prt_hex(pri, 0, val);
2470Sstevel@tonic-gate 	else
2480Sstevel@tonic-gate 		escape_string(pri, s);
2490Sstevel@tonic-gate }
2500Sstevel@tonic-gate 
2510Sstevel@tonic-gate /* print as string returned from syscall */
2520Sstevel@tonic-gate void
2530Sstevel@tonic-gate prt_rst(private_t *pri, int raw, long val)
2540Sstevel@tonic-gate {
2550Sstevel@tonic-gate 	char *s = (raw || pri->Errno)? NULL :
256*4217Seschrock 	    fetchstring(pri, (long)val, PATH_MAX);
2570Sstevel@tonic-gate 
2580Sstevel@tonic-gate 	if (s == NULL)
2590Sstevel@tonic-gate 		prt_hex(pri, 0, val);
2600Sstevel@tonic-gate 	else {
2610Sstevel@tonic-gate 		GROW((int)strlen(s) + 2);
2620Sstevel@tonic-gate 		pri->sys_leng += snprintf(pri->sys_string + pri->sys_leng,
2630Sstevel@tonic-gate 		    pri->sys_ssize - pri->sys_leng, "\"%s\"", s);
2640Sstevel@tonic-gate 	}
2650Sstevel@tonic-gate }
2660Sstevel@tonic-gate 
2670Sstevel@tonic-gate /* print contents of readlink() buffer */
2680Sstevel@tonic-gate void
2690Sstevel@tonic-gate prt_rlk(private_t *pri, int raw, long val)
2700Sstevel@tonic-gate {
2710Sstevel@tonic-gate 	char *s = (raw || pri->Errno || pri->Rval1 <= 0)? NULL :
272*4217Seschrock 	    fetchstring(pri, (long)val,
273*4217Seschrock 	    (pri->Rval1 > PATH_MAX)? PATH_MAX : (int)pri->Rval1);
2740Sstevel@tonic-gate 
2750Sstevel@tonic-gate 	if (s == NULL)
2760Sstevel@tonic-gate 		prt_hex(pri, 0, val);
2770Sstevel@tonic-gate 	else {
2780Sstevel@tonic-gate 		GROW((int)strlen(s) + 2);
2790Sstevel@tonic-gate 		pri->sys_leng += snprintf(pri->sys_string + pri->sys_leng,
2800Sstevel@tonic-gate 		    pri->sys_ssize - pri->sys_leng, "\"%s\"", s);
2810Sstevel@tonic-gate 	}
2820Sstevel@tonic-gate }
2830Sstevel@tonic-gate 
2840Sstevel@tonic-gate void
2850Sstevel@tonic-gate prt_ioc(private_t *pri, int raw, long val)	/* print ioctl code */
2860Sstevel@tonic-gate {
2870Sstevel@tonic-gate 	const char *s = raw? NULL : ioctlname(pri, (int)val);
2880Sstevel@tonic-gate 
2890Sstevel@tonic-gate 	if (s == NULL)
2900Sstevel@tonic-gate 		prt_hex(pri, 0, val);
2910Sstevel@tonic-gate 	else
2920Sstevel@tonic-gate 		outstring(pri, s);
2930Sstevel@tonic-gate }
2940Sstevel@tonic-gate 
2950Sstevel@tonic-gate void
2960Sstevel@tonic-gate prt_ioa(private_t *pri, int raw, long val)	/* print ioctl argument */
2970Sstevel@tonic-gate {
2980Sstevel@tonic-gate 	const char *s;
2990Sstevel@tonic-gate 
3000Sstevel@tonic-gate 	/* cheating -- look at the ioctl() code */
3010Sstevel@tonic-gate 	switch (pri->sys_args[1]) {
3020Sstevel@tonic-gate 
3030Sstevel@tonic-gate 	/* kstat ioctl()s */
3040Sstevel@tonic-gate 	case KSTAT_IOC_READ:
3050Sstevel@tonic-gate 	case KSTAT_IOC_WRITE:
3060Sstevel@tonic-gate #ifdef _LP64
3070Sstevel@tonic-gate 		if (data_model == PR_MODEL_ILP32)
3080Sstevel@tonic-gate 			prt_stg(pri, raw,
309*4217Seschrock 			    val + offsetof(kstat32_t, ks_name[0]));
3100Sstevel@tonic-gate 		else
3110Sstevel@tonic-gate #endif
3120Sstevel@tonic-gate 			prt_stg(pri, raw,
313*4217Seschrock 			    val + offsetof(kstat_t, ks_name[0]));
3140Sstevel@tonic-gate 		break;
3150Sstevel@tonic-gate 
3160Sstevel@tonic-gate 	/* streams ioctl()s */
3170Sstevel@tonic-gate 	case I_LOOK:
3180Sstevel@tonic-gate 		prt_rst(pri, raw, val);
3190Sstevel@tonic-gate 		break;
3200Sstevel@tonic-gate 	case I_PUSH:
3210Sstevel@tonic-gate 	case I_FIND:
3220Sstevel@tonic-gate 		prt_stg(pri, raw, val);
3230Sstevel@tonic-gate 		break;
3240Sstevel@tonic-gate 	case I_LINK:
3250Sstevel@tonic-gate 	case I_UNLINK:
3260Sstevel@tonic-gate 	case I_SENDFD:
3270Sstevel@tonic-gate 		prt_dec(pri, 0, val);
3280Sstevel@tonic-gate 		break;
3290Sstevel@tonic-gate 	case I_SRDOPT:
3300Sstevel@tonic-gate 		if (raw || (s = strrdopt(val)) == NULL)
3310Sstevel@tonic-gate 			prt_dec(pri, 0, val);
3320Sstevel@tonic-gate 		else
3330Sstevel@tonic-gate 			outstring(pri, s);
3340Sstevel@tonic-gate 		break;
3350Sstevel@tonic-gate 	case I_SETSIG:
3360Sstevel@tonic-gate 		if (raw || (s = strevents(pri, val)) == NULL)
3370Sstevel@tonic-gate 			prt_hex(pri, 0, val);
3380Sstevel@tonic-gate 		else
3390Sstevel@tonic-gate 			outstring(pri, s);
3400Sstevel@tonic-gate 		break;
3410Sstevel@tonic-gate 	case I_FLUSH:
3420Sstevel@tonic-gate 		if (raw || (s = strflush(val)) == NULL)
3430Sstevel@tonic-gate 			prt_dec(pri, 0, val);
3440Sstevel@tonic-gate 		else
3450Sstevel@tonic-gate 			outstring(pri, s);
3460Sstevel@tonic-gate 		break;
3470Sstevel@tonic-gate 
3480Sstevel@tonic-gate 	/* tty ioctl()s */
3490Sstevel@tonic-gate 	case TCSBRK:
3500Sstevel@tonic-gate 	case TCXONC:
3510Sstevel@tonic-gate 	case TCFLSH:
3520Sstevel@tonic-gate 	case TCDSET:
3530Sstevel@tonic-gate 		prt_dec(pri, 0, val);
3540Sstevel@tonic-gate 		break;
3550Sstevel@tonic-gate 
3560Sstevel@tonic-gate 	default:
3570Sstevel@tonic-gate 		prt_hex(pri, 0, val);
3580Sstevel@tonic-gate 		break;
3590Sstevel@tonic-gate 	}
3600Sstevel@tonic-gate }
3610Sstevel@tonic-gate 
3620Sstevel@tonic-gate void
3630Sstevel@tonic-gate prt_fcn(private_t *pri, int raw, long val)	/* print fcntl code */
3640Sstevel@tonic-gate {
3650Sstevel@tonic-gate 	const char *s = raw? NULL : fcntlname(val);
3660Sstevel@tonic-gate 
3670Sstevel@tonic-gate 	if (s == NULL)
3680Sstevel@tonic-gate 		prt_dec(pri, 0, val);
3690Sstevel@tonic-gate 	else
3700Sstevel@tonic-gate 		outstring(pri, s);
3710Sstevel@tonic-gate }
3720Sstevel@tonic-gate 
3730Sstevel@tonic-gate void
3740Sstevel@tonic-gate prt_s86(private_t *pri, int raw, long val)	/* print sysi86 code */
3750Sstevel@tonic-gate {
3760Sstevel@tonic-gate 
3770Sstevel@tonic-gate 	const char *s = raw? NULL : si86name(val);
3780Sstevel@tonic-gate 
3790Sstevel@tonic-gate 	if (s == NULL)
3800Sstevel@tonic-gate 		prt_dec(pri, 0, val);
3810Sstevel@tonic-gate 	else
3820Sstevel@tonic-gate 		outstring(pri, s);
3830Sstevel@tonic-gate }
3840Sstevel@tonic-gate 
3850Sstevel@tonic-gate void
3860Sstevel@tonic-gate prt_uts(private_t *pri, int raw, long val)	/* print utssys code */
3870Sstevel@tonic-gate {
3880Sstevel@tonic-gate 	const char *s = raw? NULL : utscode(val);
3890Sstevel@tonic-gate 
3900Sstevel@tonic-gate 	if (s == NULL)
3910Sstevel@tonic-gate 		prt_dec(pri, 0, val);
3920Sstevel@tonic-gate 	else
3930Sstevel@tonic-gate 		outstring(pri, s);
3940Sstevel@tonic-gate }
3950Sstevel@tonic-gate 
3960Sstevel@tonic-gate void
3970Sstevel@tonic-gate prt_msc(private_t *pri, int raw, long val)	/* print msgsys command */
3980Sstevel@tonic-gate {
3990Sstevel@tonic-gate 	const char *s = raw? NULL : msgcmd(val);
4000Sstevel@tonic-gate 
4010Sstevel@tonic-gate 	if (s == NULL)
4020Sstevel@tonic-gate 		prt_dec(pri, 0, val);
4030Sstevel@tonic-gate 	else
4040Sstevel@tonic-gate 		outstring(pri, s);
4050Sstevel@tonic-gate }
4060Sstevel@tonic-gate 
4070Sstevel@tonic-gate void
4080Sstevel@tonic-gate prt_msf(private_t *pri, int raw, long val)	/* print msgsys flags */
4090Sstevel@tonic-gate {
4100Sstevel@tonic-gate 	const char *s = raw? NULL : msgflags(pri, (int)val);
4110Sstevel@tonic-gate 
4120Sstevel@tonic-gate 	if (s == NULL)
4130Sstevel@tonic-gate 		prt_oct(pri, 0, val);
4140Sstevel@tonic-gate 	else
4150Sstevel@tonic-gate 		outstring(pri, s);
4160Sstevel@tonic-gate }
4170Sstevel@tonic-gate 
4180Sstevel@tonic-gate void
4190Sstevel@tonic-gate prt_smc(private_t *pri, int raw, long val)	/* print semsys command */
4200Sstevel@tonic-gate {
4210Sstevel@tonic-gate 	const char *s = raw? NULL : semcmd(val);
4220Sstevel@tonic-gate 
4230Sstevel@tonic-gate 	if (s == NULL)
4240Sstevel@tonic-gate 		prt_dec(pri, 0, val);
4250Sstevel@tonic-gate 	else
4260Sstevel@tonic-gate 		outstring(pri, s);
4270Sstevel@tonic-gate }
4280Sstevel@tonic-gate 
4290Sstevel@tonic-gate void
4300Sstevel@tonic-gate prt_sef(private_t *pri, int raw, long val)	/* print semsys flags */
4310Sstevel@tonic-gate {
4320Sstevel@tonic-gate 	const char *s = raw? NULL : semflags(pri, (int)val);
4330Sstevel@tonic-gate 
4340Sstevel@tonic-gate 	if (s == NULL)
4350Sstevel@tonic-gate 		prt_oct(pri, 0, val);
4360Sstevel@tonic-gate 	else
4370Sstevel@tonic-gate 		outstring(pri, s);
4380Sstevel@tonic-gate }
4390Sstevel@tonic-gate 
4400Sstevel@tonic-gate void
4410Sstevel@tonic-gate prt_shc(private_t *pri, int raw, long val)	/* print shmsys command */
4420Sstevel@tonic-gate {
4430Sstevel@tonic-gate 	const char *s = raw? NULL : shmcmd(val);
4440Sstevel@tonic-gate 
4450Sstevel@tonic-gate 	if (s == NULL)
4460Sstevel@tonic-gate 		prt_dec(pri, 0, val);
4470Sstevel@tonic-gate 	else
4480Sstevel@tonic-gate 		outstring(pri, s);
4490Sstevel@tonic-gate }
4500Sstevel@tonic-gate 
4510Sstevel@tonic-gate void
4520Sstevel@tonic-gate prt_shf(private_t *pri, int raw, long val)	/* print shmsys flags */
4530Sstevel@tonic-gate {
4540Sstevel@tonic-gate 	const char *s = raw? NULL : shmflags(pri, (int)val);
4550Sstevel@tonic-gate 
4560Sstevel@tonic-gate 	if (s == NULL)
4570Sstevel@tonic-gate 		prt_oct(pri, 0, val);
4580Sstevel@tonic-gate 	else
4590Sstevel@tonic-gate 		outstring(pri, s);
4600Sstevel@tonic-gate }
4610Sstevel@tonic-gate 
4620Sstevel@tonic-gate void
4630Sstevel@tonic-gate prt_sfs(private_t *pri, int raw, long val)	/* print sysfs code */
4640Sstevel@tonic-gate {
4650Sstevel@tonic-gate 	const char *s = raw? NULL : sfsname(val);
4660Sstevel@tonic-gate 
4670Sstevel@tonic-gate 	if (s == NULL)
4680Sstevel@tonic-gate 		prt_dec(pri, 0, val);
4690Sstevel@tonic-gate 	else
4700Sstevel@tonic-gate 		outstring(pri, s);
4710Sstevel@tonic-gate }
4720Sstevel@tonic-gate 
4730Sstevel@tonic-gate void
4740Sstevel@tonic-gate prt_opn(private_t *pri, int raw, long val)	/* print open code */
4750Sstevel@tonic-gate {
4760Sstevel@tonic-gate 	const char *s = raw? NULL : openarg(pri, val);
4770Sstevel@tonic-gate 
4780Sstevel@tonic-gate 	if (s == NULL)
4790Sstevel@tonic-gate 		prt_oct(pri, 0, val);
4800Sstevel@tonic-gate 	else
4810Sstevel@tonic-gate 		outstring(pri, s);
4820Sstevel@tonic-gate }
4830Sstevel@tonic-gate 
4840Sstevel@tonic-gate void
4850Sstevel@tonic-gate prt_sig(private_t *pri, int raw, long val) /* print signal name plus flags */
4860Sstevel@tonic-gate {
4870Sstevel@tonic-gate 	const char *s = raw? NULL : sigarg(pri, (int)val);
4880Sstevel@tonic-gate 
4890Sstevel@tonic-gate 	if (s == NULL)
4900Sstevel@tonic-gate 		prt_hex(pri, 0, val);
4910Sstevel@tonic-gate 	else
4920Sstevel@tonic-gate 		outstring(pri, s);
4930Sstevel@tonic-gate }
4940Sstevel@tonic-gate 
4950Sstevel@tonic-gate /* print signal name, masked with SIGNO_MASK */
4960Sstevel@tonic-gate void
4970Sstevel@tonic-gate prt_six(private_t *pri, int raw, long val)
4980Sstevel@tonic-gate {
4990Sstevel@tonic-gate 	const char *s = raw? NULL : sigarg(pri, (int)val & SIGNO_MASK);
5000Sstevel@tonic-gate 
5010Sstevel@tonic-gate 	if (s == NULL)
5020Sstevel@tonic-gate 		prt_hex(pri, 0, val);
5030Sstevel@tonic-gate 	else
5040Sstevel@tonic-gate 		outstring(pri, s);
5050Sstevel@tonic-gate }
5060Sstevel@tonic-gate 
5070Sstevel@tonic-gate void
5080Sstevel@tonic-gate prt_act(private_t *pri, int raw, long val)	/* print signal action value */
5090Sstevel@tonic-gate {
5100Sstevel@tonic-gate 	const char *s;
5110Sstevel@tonic-gate 
5120Sstevel@tonic-gate 	if (raw)
5130Sstevel@tonic-gate 		s = NULL;
5140Sstevel@tonic-gate 	else if (val == (int)SIG_DFL)
5150Sstevel@tonic-gate 		s = "SIG_DFL";
5160Sstevel@tonic-gate 	else if (val == (int)SIG_IGN)
5170Sstevel@tonic-gate 		s = "SIG_IGN";
5180Sstevel@tonic-gate 	else if (val == (int)SIG_HOLD)
5190Sstevel@tonic-gate 		s = "SIG_HOLD";
5200Sstevel@tonic-gate 	else
5210Sstevel@tonic-gate 		s = NULL;
5220Sstevel@tonic-gate 
5230Sstevel@tonic-gate 	if (s == NULL)
5240Sstevel@tonic-gate 		prt_hex(pri, 0, val);
5250Sstevel@tonic-gate 	else
5260Sstevel@tonic-gate 		outstring(pri, s);
5270Sstevel@tonic-gate }
5280Sstevel@tonic-gate 
5290Sstevel@tonic-gate void
5300Sstevel@tonic-gate prt_smf(private_t *pri, int raw, long val) /* print streams message flags */
5310Sstevel@tonic-gate {
5320Sstevel@tonic-gate 	switch (val) {
5330Sstevel@tonic-gate 	case 0:
5340Sstevel@tonic-gate 		prt_dec(pri, 0, val);
5350Sstevel@tonic-gate 		break;
5360Sstevel@tonic-gate 	case RS_HIPRI:
5370Sstevel@tonic-gate 		if (raw)
5380Sstevel@tonic-gate 			prt_hhx(pri, 0, val);
5390Sstevel@tonic-gate 		else
5400Sstevel@tonic-gate 			outstring(pri, "RS_HIPRI");
5410Sstevel@tonic-gate 		break;
5420Sstevel@tonic-gate 	default:
5430Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
5440Sstevel@tonic-gate 		break;
5450Sstevel@tonic-gate 	}
5460Sstevel@tonic-gate }
5470Sstevel@tonic-gate 
5480Sstevel@tonic-gate void
5490Sstevel@tonic-gate prt_plk(private_t *pri, int raw, long val)	/* print plock code */
5500Sstevel@tonic-gate {
5510Sstevel@tonic-gate 	const char *s = raw? NULL : plockname(val);
5520Sstevel@tonic-gate 
5530Sstevel@tonic-gate 	if (s == NULL)
5540Sstevel@tonic-gate 		prt_dec(pri, 0, val);
5550Sstevel@tonic-gate 	else
5560Sstevel@tonic-gate 		outstring(pri, s);
5570Sstevel@tonic-gate }
5580Sstevel@tonic-gate 
5590Sstevel@tonic-gate void
5600Sstevel@tonic-gate prt_mtf(private_t *pri, int raw, long val)	/* print mount flags */
5610Sstevel@tonic-gate {
5620Sstevel@tonic-gate 	const char *s = raw? NULL : mountflags(pri, val);
5630Sstevel@tonic-gate 
5640Sstevel@tonic-gate 	if (s == NULL)
5650Sstevel@tonic-gate 		prt_hex(pri, 0, val);
5660Sstevel@tonic-gate 	else
5670Sstevel@tonic-gate 		outstring(pri, s);
5680Sstevel@tonic-gate }
5690Sstevel@tonic-gate 
5700Sstevel@tonic-gate void
5710Sstevel@tonic-gate prt_mft(private_t *pri, int raw, long val) /* print mount file system type */
5720Sstevel@tonic-gate {
5730Sstevel@tonic-gate 	if (val >= 0 && val < 256)
5740Sstevel@tonic-gate 		prt_dec(pri, 0, val);
5750Sstevel@tonic-gate 	else if (raw)
5760Sstevel@tonic-gate 		prt_hex(pri, 0, val);
5770Sstevel@tonic-gate 	else
5780Sstevel@tonic-gate 		prt_stg(pri, raw, val);
5790Sstevel@tonic-gate }
5800Sstevel@tonic-gate 
5810Sstevel@tonic-gate #define	ISREAD(code) \
5820Sstevel@tonic-gate 	((code) == SYS_read || (code) == SYS_pread || (code) == SYS_pread64 || \
5830Sstevel@tonic-gate 	(code) == SYS_recv || (code) == SYS_recvfrom)
5840Sstevel@tonic-gate #define	ISWRITE(code) \
5850Sstevel@tonic-gate 	((code) == SYS_write || (code) == SYS_pwrite || \
5860Sstevel@tonic-gate 	(code) == SYS_pwrite64 || (code) == SYS_send || (code) == SYS_sendto)
5870Sstevel@tonic-gate 
5880Sstevel@tonic-gate /* print contents of read() or write() I/O buffer */
5890Sstevel@tonic-gate void
5900Sstevel@tonic-gate prt_iob(private_t *pri, int raw, long val)
5910Sstevel@tonic-gate {
5920Sstevel@tonic-gate 	const lwpstatus_t *Lsp = pri->lwpstat;
5930Sstevel@tonic-gate 	int syscall = Lsp->pr_what;
5940Sstevel@tonic-gate 	int fdp1 = pri->sys_args[0] + 1;
5950Sstevel@tonic-gate 	ssize_t nbyte = ISWRITE(syscall)? pri->sys_args[2] :
596*4217Seschrock 	    (pri->Errno? 0 : pri->Rval1);
5970Sstevel@tonic-gate 	int elsewhere = FALSE;		/* TRUE iff dumped elsewhere */
5980Sstevel@tonic-gate 	char buffer[IOBSIZE];
5990Sstevel@tonic-gate 
6000Sstevel@tonic-gate 	pri->iob_buf[0] = '\0';
6010Sstevel@tonic-gate 
6020Sstevel@tonic-gate 	if (Lsp->pr_why == PR_SYSEXIT && nbyte > IOBSIZE) {
6030Sstevel@tonic-gate 		if (ISREAD(syscall))
6040Sstevel@tonic-gate 			elsewhere = prismember(&readfd, fdp1);
6050Sstevel@tonic-gate 		else
6060Sstevel@tonic-gate 			elsewhere = prismember(&writefd, fdp1);
6070Sstevel@tonic-gate 	}
6080Sstevel@tonic-gate 
6090Sstevel@tonic-gate 	if (nbyte <= 0 || elsewhere)
6100Sstevel@tonic-gate 		prt_hex(pri, 0, val);
6110Sstevel@tonic-gate 	else {
6120Sstevel@tonic-gate 		int nb = nbyte > IOBSIZE? IOBSIZE : (int)nbyte;
6130Sstevel@tonic-gate 
6140Sstevel@tonic-gate 		if (Pread(Proc, buffer, (size_t)nb, (long)val) != nb)
6150Sstevel@tonic-gate 			prt_hex(pri, 0, val);
6160Sstevel@tonic-gate 		else {
6170Sstevel@tonic-gate 			pri->iob_buf[0] = '"';
6180Sstevel@tonic-gate 			showbytes(buffer, nb, pri->iob_buf + 1);
6190Sstevel@tonic-gate 			(void) strlcat(pri->iob_buf,
620*4217Seschrock 			    (nb == nbyte)?
621*4217Seschrock 			    (const char *)"\"" : (const char *)"\"..",
622*4217Seschrock 			    sizeof (pri->iob_buf));
6230Sstevel@tonic-gate 			if (raw)
6240Sstevel@tonic-gate 				prt_hex(pri, 0, val);
6250Sstevel@tonic-gate 			else
6260Sstevel@tonic-gate 				outstring(pri, pri->iob_buf);
6270Sstevel@tonic-gate 		}
6280Sstevel@tonic-gate 	}
6290Sstevel@tonic-gate }
6300Sstevel@tonic-gate #undef	ISREAD
6310Sstevel@tonic-gate #undef	ISWRITE
6320Sstevel@tonic-gate 
6330Sstevel@tonic-gate void
6340Sstevel@tonic-gate prt_idt(private_t *pri, int raw, long val) /* print idtype_t, waitid() arg */
6350Sstevel@tonic-gate {
6360Sstevel@tonic-gate 	const char *s = raw? NULL : idtype_enum(pri, val);
6370Sstevel@tonic-gate 
6380Sstevel@tonic-gate 	if (s == NULL)
6390Sstevel@tonic-gate 		prt_dec(pri, 0, val);
6400Sstevel@tonic-gate 	else
6410Sstevel@tonic-gate 		outstring(pri, s);
6420Sstevel@tonic-gate }
6430Sstevel@tonic-gate 
6440Sstevel@tonic-gate void
6450Sstevel@tonic-gate prt_wop(private_t *pri, int raw, long val)	/* print waitid() options */
6460Sstevel@tonic-gate {
6470Sstevel@tonic-gate 	const char *s = raw? NULL : woptions(pri, (int)val);
6480Sstevel@tonic-gate 
6490Sstevel@tonic-gate 	if (s == NULL)
6500Sstevel@tonic-gate 		prt_oct(pri, 0, val);
6510Sstevel@tonic-gate 	else
6520Sstevel@tonic-gate 		outstring(pri, s);
6530Sstevel@tonic-gate }
6540Sstevel@tonic-gate 
6550Sstevel@tonic-gate void
6560Sstevel@tonic-gate prt_whn(private_t *pri, int raw, long val) /* print lseek() whence argument */
6570Sstevel@tonic-gate {
6580Sstevel@tonic-gate 	const char *s = raw? NULL : whencearg(val);
6590Sstevel@tonic-gate 
6600Sstevel@tonic-gate 	if (s == NULL)
6610Sstevel@tonic-gate 		prt_dec(pri, 0, val);
6620Sstevel@tonic-gate 	else
6630Sstevel@tonic-gate 		outstring(pri, s);
6640Sstevel@tonic-gate }
6650Sstevel@tonic-gate 
6660Sstevel@tonic-gate /*ARGSUSED*/
6670Sstevel@tonic-gate void
6680Sstevel@tonic-gate prt_spm(private_t *pri, int raw, long val)	/* print sigprocmask argument */
6690Sstevel@tonic-gate {
6700Sstevel@tonic-gate 	const char *s = NULL;
6710Sstevel@tonic-gate 
6720Sstevel@tonic-gate 	if (!raw) {
6730Sstevel@tonic-gate 		switch (val) {
6740Sstevel@tonic-gate 		case SIG_BLOCK:		s = "SIG_BLOCK";	break;
6750Sstevel@tonic-gate 		case SIG_UNBLOCK:	s = "SIG_UNBLOCK";	break;
6760Sstevel@tonic-gate 		case SIG_SETMASK:	s = "SIG_SETMASK";	break;
6770Sstevel@tonic-gate 		}
6780Sstevel@tonic-gate 	}
6790Sstevel@tonic-gate 
6800Sstevel@tonic-gate 	if (s == NULL)
6810Sstevel@tonic-gate 		prt_dec(pri, 0, val);
6820Sstevel@tonic-gate 	else
6830Sstevel@tonic-gate 		outstring(pri, s);
6840Sstevel@tonic-gate }
6850Sstevel@tonic-gate 
6860Sstevel@tonic-gate const char *
6870Sstevel@tonic-gate mmap_protect(private_t *pri, long arg)
6880Sstevel@tonic-gate {
6890Sstevel@tonic-gate 	char *str = pri->code_buf;
6900Sstevel@tonic-gate 
6910Sstevel@tonic-gate 	if (arg & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
6920Sstevel@tonic-gate 		return ((char *)NULL);
6930Sstevel@tonic-gate 
6940Sstevel@tonic-gate 	if (arg == PROT_NONE)
6950Sstevel@tonic-gate 		return ("PROT_NONE");
6960Sstevel@tonic-gate 
6970Sstevel@tonic-gate 	*str = '\0';
6980Sstevel@tonic-gate 	if (arg & PROT_READ)
6990Sstevel@tonic-gate 		(void) strlcat(str, "|PROT_READ", sizeof (pri->code_buf));
7000Sstevel@tonic-gate 	if (arg & PROT_WRITE)
7010Sstevel@tonic-gate 		(void) strlcat(str, "|PROT_WRITE", sizeof (pri->code_buf));
7020Sstevel@tonic-gate 	if (arg & PROT_EXEC)
7030Sstevel@tonic-gate 		(void) strlcat(str, "|PROT_EXEC", sizeof (pri->code_buf));
7040Sstevel@tonic-gate 	return ((const char *)(str + 1));
7050Sstevel@tonic-gate }
7060Sstevel@tonic-gate 
7070Sstevel@tonic-gate const char *
7080Sstevel@tonic-gate mmap_type(private_t *pri, long arg)
7090Sstevel@tonic-gate {
7100Sstevel@tonic-gate 	char *str = pri->code_buf;
7110Sstevel@tonic-gate 	size_t used;
7120Sstevel@tonic-gate 
7130Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
7140Sstevel@tonic-gate 	switch (arg & MAP_TYPE) {
7150Sstevel@tonic-gate 	case MAP_SHARED:
7160Sstevel@tonic-gate 		used = strlcpy(str, "MAP_SHARED", CBSIZE);
7170Sstevel@tonic-gate 		break;
7180Sstevel@tonic-gate 	case MAP_PRIVATE:
7190Sstevel@tonic-gate 		used = strlcpy(str, "MAP_PRIVATE", CBSIZE);
7200Sstevel@tonic-gate 		break;
7210Sstevel@tonic-gate 	default:
7220Sstevel@tonic-gate 		used = snprintf(str, CBSIZE, "%ld", arg&MAP_TYPE);
7230Sstevel@tonic-gate 		break;
7240Sstevel@tonic-gate 	}
7250Sstevel@tonic-gate 
7260Sstevel@tonic-gate 	arg &= ~(_MAP_NEW|MAP_TYPE);
7270Sstevel@tonic-gate 
7280Sstevel@tonic-gate 	if (arg & ~(MAP_FIXED|MAP_RENAME|MAP_NORESERVE|MAP_ANON|MAP_ALIGN|
7290Sstevel@tonic-gate 	    MAP_TEXT|MAP_INITDATA))
7300Sstevel@tonic-gate 		(void) snprintf(str + used, sizeof (pri->code_buf) - used,
731*4217Seschrock 		    "|0x%lX", arg);
7320Sstevel@tonic-gate 	else {
7330Sstevel@tonic-gate 		if (arg & MAP_FIXED)
7340Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_FIXED", CBSIZE);
7350Sstevel@tonic-gate 		if (arg & MAP_RENAME)
7360Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_RENAME", CBSIZE);
7370Sstevel@tonic-gate 		if (arg & MAP_NORESERVE)
7380Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_NORESERVE", CBSIZE);
7390Sstevel@tonic-gate 		if (arg & MAP_ANON)
7400Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_ANON", CBSIZE);
7410Sstevel@tonic-gate 		if (arg & MAP_ALIGN)
7420Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_ALIGN", CBSIZE);
7430Sstevel@tonic-gate 		if (arg & MAP_TEXT)
7440Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_TEXT", CBSIZE);
7450Sstevel@tonic-gate 		if (arg & MAP_INITDATA)
7460Sstevel@tonic-gate 			(void) strlcat(str, "|MAP_INITDATA", CBSIZE);
7470Sstevel@tonic-gate 	}
7480Sstevel@tonic-gate 
7490Sstevel@tonic-gate 	return ((const char *)str);
7500Sstevel@tonic-gate #undef CBSIZE
7510Sstevel@tonic-gate }
7520Sstevel@tonic-gate 
7530Sstevel@tonic-gate void
7540Sstevel@tonic-gate prt_mpr(private_t *pri, int raw, long val) /* print mmap()/mprotect() flags */
7550Sstevel@tonic-gate {
7560Sstevel@tonic-gate 	const char *s = raw? NULL : mmap_protect(pri, val);
7570Sstevel@tonic-gate 
7580Sstevel@tonic-gate 	if (s == NULL)
7590Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
7600Sstevel@tonic-gate 	else
7610Sstevel@tonic-gate 		outstring(pri, s);
7620Sstevel@tonic-gate }
7630Sstevel@tonic-gate 
7640Sstevel@tonic-gate void
7650Sstevel@tonic-gate prt_mty(private_t *pri, int raw, long val) /* print mmap() mapping type flags */
7660Sstevel@tonic-gate {
7670Sstevel@tonic-gate 	const char *s = raw? NULL : mmap_type(pri, val);
7680Sstevel@tonic-gate 
7690Sstevel@tonic-gate 	if (s == NULL)
7700Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
7710Sstevel@tonic-gate 	else
7720Sstevel@tonic-gate 		outstring(pri, s);
7730Sstevel@tonic-gate }
7740Sstevel@tonic-gate 
7750Sstevel@tonic-gate /*ARGSUSED*/
7760Sstevel@tonic-gate void
7770Sstevel@tonic-gate prt_mcf(private_t *pri, int raw, long val)	/* print memcntl() function */
7780Sstevel@tonic-gate {
7790Sstevel@tonic-gate 	const char *s = NULL;
7800Sstevel@tonic-gate 
7810Sstevel@tonic-gate 	if (!raw) {
7820Sstevel@tonic-gate 		switch (val) {
7830Sstevel@tonic-gate 		case MC_SYNC:		s = "MC_SYNC";		break;
7840Sstevel@tonic-gate 		case MC_LOCK:		s = "MC_LOCK";		break;
7850Sstevel@tonic-gate 		case MC_UNLOCK:		s = "MC_UNLOCK";	break;
7860Sstevel@tonic-gate 		case MC_ADVISE:		s = "MC_ADVISE";	break;
7870Sstevel@tonic-gate 		case MC_LOCKAS:		s = "MC_LOCKAS";	break;
7880Sstevel@tonic-gate 		case MC_UNLOCKAS:	s = "MC_UNLOCKAS";	break;
7890Sstevel@tonic-gate 		case MC_HAT_ADVISE:	s = "MC_HAT_ADVISE";	break;
7900Sstevel@tonic-gate 		}
7910Sstevel@tonic-gate 	}
7920Sstevel@tonic-gate 
7930Sstevel@tonic-gate 	if (s == NULL)
7940Sstevel@tonic-gate 		prt_dec(pri, 0, val);
7950Sstevel@tonic-gate 	else
7960Sstevel@tonic-gate 		outstring(pri, s);
7970Sstevel@tonic-gate }
7980Sstevel@tonic-gate 
7990Sstevel@tonic-gate void
8000Sstevel@tonic-gate prt_mad(private_t *pri, int raw, long val)	/* print madvise() argument */
8010Sstevel@tonic-gate {
8020Sstevel@tonic-gate 	const char *s = NULL;
8030Sstevel@tonic-gate 
8040Sstevel@tonic-gate 	if (!raw) {
8050Sstevel@tonic-gate 		switch (val) {
8060Sstevel@tonic-gate 		case MADV_NORMAL:	s = "MADV_NORMAL";	break;
8070Sstevel@tonic-gate 		case MADV_RANDOM:	s = "MADV_RANDOM";	break;
8080Sstevel@tonic-gate 		case MADV_SEQUENTIAL:	s = "MADV_SEQUENTIAL";	break;
8090Sstevel@tonic-gate 		case MADV_WILLNEED:	s = "MADV_WILLNEED";	break;
8100Sstevel@tonic-gate 		case MADV_DONTNEED:	s = "MADV_DONTNEED";	break;
8110Sstevel@tonic-gate 		case MADV_FREE:		s = "MADV_FREE";	break;
8120Sstevel@tonic-gate 		case MADV_ACCESS_DEFAULT: s = "MADV_ACCESS_DEFAULT";	break;
8130Sstevel@tonic-gate 		case MADV_ACCESS_LWP:	s = "MADV_ACCESS_LWP";	break;
8140Sstevel@tonic-gate 		case MADV_ACCESS_MANY:	s = "MADV_ACCESS_MANY";	break;
8150Sstevel@tonic-gate 		}
8160Sstevel@tonic-gate 	}
8170Sstevel@tonic-gate 
8180Sstevel@tonic-gate 	if (s == NULL)
8190Sstevel@tonic-gate 		prt_dec(pri, 0, val);
8200Sstevel@tonic-gate 	else
8210Sstevel@tonic-gate 		outstring(pri, s);
8220Sstevel@tonic-gate }
8230Sstevel@tonic-gate 
8240Sstevel@tonic-gate void
8250Sstevel@tonic-gate prt_mc4(private_t *pri, int raw, long val) /* print memcntl() (4th) argument */
8260Sstevel@tonic-gate {
8270Sstevel@tonic-gate 	if (val == 0)
8280Sstevel@tonic-gate 		prt_dec(pri, 0, val);
8290Sstevel@tonic-gate 	else if (raw)
8300Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
8310Sstevel@tonic-gate 	else {
8320Sstevel@tonic-gate 		char *s = NULL;
8330Sstevel@tonic-gate 
8340Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
8350Sstevel@tonic-gate 		/* cheating -- look at memcntl func */
8360Sstevel@tonic-gate 		switch (pri->sys_args[2]) {
8370Sstevel@tonic-gate 		case MC_ADVISE:
8380Sstevel@tonic-gate 			prt_mad(pri, 0, val);
8390Sstevel@tonic-gate 			return;
8400Sstevel@tonic-gate 
8410Sstevel@tonic-gate 		case MC_SYNC:
8420Sstevel@tonic-gate 			if ((val & ~(MS_SYNC|MS_ASYNC|MS_INVALIDATE)) == 0) {
8430Sstevel@tonic-gate 				*(s = pri->code_buf) = '\0';
8440Sstevel@tonic-gate 				if (val & MS_SYNC)
8450Sstevel@tonic-gate 					(void) strlcat(s, "|MS_SYNC", CBSIZE);
8460Sstevel@tonic-gate 				if (val & MS_ASYNC)
8470Sstevel@tonic-gate 					(void) strlcat(s, "|MS_ASYNC", CBSIZE);
8480Sstevel@tonic-gate 				if (val & MS_INVALIDATE)
8490Sstevel@tonic-gate 					(void) strlcat(s, "|MS_INVALIDATE",
850*4217Seschrock 					    CBSIZE);
8510Sstevel@tonic-gate 			}
8520Sstevel@tonic-gate 			break;
8530Sstevel@tonic-gate 
8540Sstevel@tonic-gate 		case MC_LOCKAS:
8550Sstevel@tonic-gate 		case MC_UNLOCKAS:
8560Sstevel@tonic-gate 			if ((val & ~(MCL_CURRENT|MCL_FUTURE)) == 0) {
8570Sstevel@tonic-gate 				*(s = pri->code_buf) = '\0';
8580Sstevel@tonic-gate 				if (val & MCL_CURRENT)
8590Sstevel@tonic-gate 					(void) strlcat(s, "|MCL_CURRENT",
860*4217Seschrock 					    CBSIZE);
8610Sstevel@tonic-gate 				if (val & MCL_FUTURE)
8620Sstevel@tonic-gate 					(void) strlcat(s, "|MCL_FUTURE",
863*4217Seschrock 					    CBSIZE);
8640Sstevel@tonic-gate 			}
8650Sstevel@tonic-gate 			break;
8660Sstevel@tonic-gate 		}
8670Sstevel@tonic-gate #undef CBSIZE
8680Sstevel@tonic-gate 
8690Sstevel@tonic-gate 		if (s == NULL || *s == '\0')
8700Sstevel@tonic-gate 			prt_hhx(pri, 0, val);
8710Sstevel@tonic-gate 		else
8720Sstevel@tonic-gate 			outstring(pri, ++s);
8730Sstevel@tonic-gate 	}
8740Sstevel@tonic-gate }
8750Sstevel@tonic-gate 
8760Sstevel@tonic-gate void
8770Sstevel@tonic-gate prt_mc5(private_t *pri, int raw, long val) /* print memcntl() (5th) argument */
8780Sstevel@tonic-gate {
8790Sstevel@tonic-gate 	char *s;
8800Sstevel@tonic-gate 
8810Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
8820Sstevel@tonic-gate 	if (val == 0)
8830Sstevel@tonic-gate 		prt_dec(pri, 0, val);
8840Sstevel@tonic-gate 	else if (raw || (val & ~VALID_ATTR))
8850Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
8860Sstevel@tonic-gate 	else {
8870Sstevel@tonic-gate 		s = pri->code_buf;
8880Sstevel@tonic-gate 		*s = '\0';
8890Sstevel@tonic-gate 		if (val & SHARED)
8900Sstevel@tonic-gate 			(void) strlcat(s, "|SHARED", CBSIZE);
8910Sstevel@tonic-gate 		if (val & PRIVATE)
8920Sstevel@tonic-gate 			(void) strlcat(s, "|PRIVATE", CBSIZE);
8930Sstevel@tonic-gate 		if (val & PROT_READ)
8940Sstevel@tonic-gate 			(void) strlcat(s, "|PROT_READ", CBSIZE);
8950Sstevel@tonic-gate 		if (val & PROT_WRITE)
8960Sstevel@tonic-gate 			(void) strlcat(s, "|PROT_WRITE", CBSIZE);
8970Sstevel@tonic-gate 		if (val & PROT_EXEC)
8980Sstevel@tonic-gate 			(void) strlcat(s, "|PROT_EXEC", CBSIZE);
8990Sstevel@tonic-gate 		if (*s == '\0')
9000Sstevel@tonic-gate 			prt_hhx(pri, 0, val);
9010Sstevel@tonic-gate 		else
9020Sstevel@tonic-gate 			outstring(pri, ++s);
9030Sstevel@tonic-gate 	}
9040Sstevel@tonic-gate #undef CBSIZE
9050Sstevel@tonic-gate }
9060Sstevel@tonic-gate 
9070Sstevel@tonic-gate void
9080Sstevel@tonic-gate prt_ulm(private_t *pri, int raw, long val)	/* print ulimit() argument */
9090Sstevel@tonic-gate {
9100Sstevel@tonic-gate 	const char *s = NULL;
9110Sstevel@tonic-gate 
9120Sstevel@tonic-gate 	if (!raw) {
9130Sstevel@tonic-gate 		switch (val) {
9140Sstevel@tonic-gate 		case UL_GFILLIM:	s = "UL_GFILLIM";	break;
9150Sstevel@tonic-gate 		case UL_SFILLIM:	s = "UL_SFILLIM";	break;
9160Sstevel@tonic-gate 		case UL_GMEMLIM:	s = "UL_GMEMLIM";	break;
9170Sstevel@tonic-gate 		case UL_GDESLIM:	s = "UL_GDESLIM";	break;
9180Sstevel@tonic-gate 		}
9190Sstevel@tonic-gate 	}
9200Sstevel@tonic-gate 
9210Sstevel@tonic-gate 	if (s == NULL)
9220Sstevel@tonic-gate 		prt_dec(pri, 0, val);
9230Sstevel@tonic-gate 	else
9240Sstevel@tonic-gate 		outstring(pri, s);
9250Sstevel@tonic-gate }
9260Sstevel@tonic-gate 
9270Sstevel@tonic-gate void
9280Sstevel@tonic-gate prt_rlm(private_t *pri, int raw, long val) /* print get/setrlimit() argument */
9290Sstevel@tonic-gate {
9300Sstevel@tonic-gate 	const char *s = NULL;
9310Sstevel@tonic-gate 
9320Sstevel@tonic-gate 	if (!raw) {
9330Sstevel@tonic-gate 		switch (val) {
9340Sstevel@tonic-gate 		case RLIMIT_CPU:	s = "RLIMIT_CPU";	break;
9350Sstevel@tonic-gate 		case RLIMIT_FSIZE:	s = "RLIMIT_FSIZE";	break;
9360Sstevel@tonic-gate 		case RLIMIT_DATA:	s = "RLIMIT_DATA";	break;
9370Sstevel@tonic-gate 		case RLIMIT_STACK:	s = "RLIMIT_STACK";	break;
9380Sstevel@tonic-gate 		case RLIMIT_CORE:	s = "RLIMIT_CORE";	break;
9390Sstevel@tonic-gate 		case RLIMIT_NOFILE:	s = "RLIMIT_NOFILE";	break;
9400Sstevel@tonic-gate 		case RLIMIT_VMEM:	s = "RLIMIT_VMEM";	break;
9410Sstevel@tonic-gate 		}
9420Sstevel@tonic-gate 	}
9430Sstevel@tonic-gate 
9440Sstevel@tonic-gate 	if (s == NULL)
9450Sstevel@tonic-gate 		prt_dec(pri, 0, val);
9460Sstevel@tonic-gate 	else
9470Sstevel@tonic-gate 		outstring(pri, s);
9480Sstevel@tonic-gate }
9490Sstevel@tonic-gate 
9500Sstevel@tonic-gate void
9510Sstevel@tonic-gate prt_cnf(private_t *pri, int raw, long val)	/* print sysconfig code */
9520Sstevel@tonic-gate {
9530Sstevel@tonic-gate 	const char *s = raw? NULL : sconfname(val);
9540Sstevel@tonic-gate 
9550Sstevel@tonic-gate 	if (s == NULL)
9560Sstevel@tonic-gate 		prt_dec(pri, 0, val);
9570Sstevel@tonic-gate 	else
9580Sstevel@tonic-gate 		outstring(pri, s);
9590Sstevel@tonic-gate }
9600Sstevel@tonic-gate 
9610Sstevel@tonic-gate void
9620Sstevel@tonic-gate prt_inf(private_t *pri, int raw, long val)	/* print sysinfo code */
9630Sstevel@tonic-gate {
9640Sstevel@tonic-gate 	const char *s = NULL;
9650Sstevel@tonic-gate 
9660Sstevel@tonic-gate 	if (!raw) {
9670Sstevel@tonic-gate 		switch (val) {
9680Sstevel@tonic-gate 		case SI_SYSNAME:	s = "SI_SYSNAME";	break;
9690Sstevel@tonic-gate 		case SI_HOSTNAME:	s = "SI_HOSTNAME";	break;
9700Sstevel@tonic-gate 		case SI_RELEASE:	s = "SI_RELEASE";	break;
9710Sstevel@tonic-gate 		case SI_VERSION:	s = "SI_VERSION";	break;
9720Sstevel@tonic-gate 		case SI_MACHINE:	s = "SI_MACHINE";	break;
9730Sstevel@tonic-gate 		case SI_ARCHITECTURE:	s = "SI_ARCHITECTURE";	break;
9740Sstevel@tonic-gate 		case SI_ARCHITECTURE_32:s = "SI_ARCHITECTURE_32"; break;
9750Sstevel@tonic-gate 		case SI_ARCHITECTURE_64:s = "SI_ARCHITECTURE_64"; break;
9760Sstevel@tonic-gate 		case SI_ARCHITECTURE_K:	s = "SI_ARCHITECTURE_K"; break;
9770Sstevel@tonic-gate 		case SI_HW_SERIAL:	s = "SI_HW_SERIAL";	break;
9780Sstevel@tonic-gate 		case SI_HW_PROVIDER:	s = "SI_HW_PROVIDER";	break;
9790Sstevel@tonic-gate 		case SI_SRPC_DOMAIN:	s = "SI_SRPC_DOMAIN";	break;
9800Sstevel@tonic-gate 		case SI_SET_HOSTNAME:	s = "SI_SET_HOSTNAME";	break;
9810Sstevel@tonic-gate 		case SI_SET_SRPC_DOMAIN: s = "SI_SET_SRPC_DOMAIN"; break;
9820Sstevel@tonic-gate 		case SI_PLATFORM:	s = "SI_PLATFORM";	break;
9830Sstevel@tonic-gate 		case SI_ISALIST:	s = "SI_ISALIST";	break;
9840Sstevel@tonic-gate 		case SI_DHCP_CACHE:	s = "SI_DHCP_CACHE";	break;
9850Sstevel@tonic-gate 		}
9860Sstevel@tonic-gate 	}
9870Sstevel@tonic-gate 
9880Sstevel@tonic-gate 	if (s == NULL)
9890Sstevel@tonic-gate 		prt_dec(pri, 0, val);
9900Sstevel@tonic-gate 	else
9910Sstevel@tonic-gate 		outstring(pri, s);
9920Sstevel@tonic-gate }
9930Sstevel@tonic-gate 
9940Sstevel@tonic-gate void
9950Sstevel@tonic-gate prt_ptc(private_t *pri, int raw, long val)	/* print pathconf code */
9960Sstevel@tonic-gate {
9970Sstevel@tonic-gate 	const char *s = raw? NULL : pathconfname(val);
9980Sstevel@tonic-gate 
9990Sstevel@tonic-gate 	if (s == NULL)
10000Sstevel@tonic-gate 		prt_dec(pri, 0, val);
10010Sstevel@tonic-gate 	else
10020Sstevel@tonic-gate 		outstring(pri, s);
10030Sstevel@tonic-gate }
10040Sstevel@tonic-gate 
10050Sstevel@tonic-gate void
10060Sstevel@tonic-gate prt_fui(private_t *pri, int raw, long val) /* print fusers() input argument */
10070Sstevel@tonic-gate {
10080Sstevel@tonic-gate 	const char *s = raw? NULL : fuiname(val);
10090Sstevel@tonic-gate 
10100Sstevel@tonic-gate 	if (s == NULL)
10110Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
10120Sstevel@tonic-gate 	else
10130Sstevel@tonic-gate 		outstring(pri, s);
10140Sstevel@tonic-gate }
10150Sstevel@tonic-gate 
10160Sstevel@tonic-gate void
10170Sstevel@tonic-gate prt_lwf(private_t *pri, int raw, long val)	/* print lwp_create() flags */
10180Sstevel@tonic-gate {
10190Sstevel@tonic-gate 	char *s;
10200Sstevel@tonic-gate 
10210Sstevel@tonic-gate 	if (val == 0)
10220Sstevel@tonic-gate 		prt_dec(pri, 0, val);
10230Sstevel@tonic-gate 	else if (raw ||
10240Sstevel@tonic-gate 	    (val & ~(LWP_DAEMON|LWP_DETACHED|LWP_SUSPENDED)))
10250Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
10260Sstevel@tonic-gate 	else {
10270Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
10280Sstevel@tonic-gate 		s = pri->code_buf;
10290Sstevel@tonic-gate 		*s = '\0';
10300Sstevel@tonic-gate 		if (val & LWP_DAEMON)
10310Sstevel@tonic-gate 			(void) strlcat(s, "|LWP_DAEMON", CBSIZE);
10320Sstevel@tonic-gate 		if (val & LWP_DETACHED)
10330Sstevel@tonic-gate 			(void) strlcat(s, "|LWP_DETACHED", CBSIZE);
10340Sstevel@tonic-gate 		if (val & LWP_SUSPENDED)
10350Sstevel@tonic-gate 			(void) strlcat(s, "|LWP_SUSPENDED", CBSIZE);
10360Sstevel@tonic-gate 		outstring(pri, ++s);
10370Sstevel@tonic-gate #undef CBSIZE
10380Sstevel@tonic-gate 	}
10390Sstevel@tonic-gate }
10400Sstevel@tonic-gate 
10410Sstevel@tonic-gate void
10420Sstevel@tonic-gate prt_itm(private_t *pri, int raw, long val) /* print [get|set]itimer() arg */
10430Sstevel@tonic-gate {
10440Sstevel@tonic-gate 	const char *s = NULL;
10450Sstevel@tonic-gate 
10460Sstevel@tonic-gate 	if (!raw) {
10470Sstevel@tonic-gate 		switch (val) {
10480Sstevel@tonic-gate 		case ITIMER_REAL:	s = "ITIMER_REAL";	break;
10490Sstevel@tonic-gate 		case ITIMER_VIRTUAL:	s = "ITIMER_VIRTUAL";	break;
10500Sstevel@tonic-gate 		case ITIMER_PROF:	s = "ITIMER_PROF";	break;
10510Sstevel@tonic-gate #ifdef ITIMER_REALPROF
10520Sstevel@tonic-gate 		case ITIMER_REALPROF:	s = "ITIMER_REALPROF";	break;
10530Sstevel@tonic-gate #endif
10540Sstevel@tonic-gate 		}
10550Sstevel@tonic-gate 	}
10560Sstevel@tonic-gate 
10570Sstevel@tonic-gate 	if (s == NULL)
10580Sstevel@tonic-gate 		prt_dec(pri, 0, val);
10590Sstevel@tonic-gate 	else
10600Sstevel@tonic-gate 		outstring(pri, s);
10610Sstevel@tonic-gate }
10620Sstevel@tonic-gate 
10630Sstevel@tonic-gate void
10640Sstevel@tonic-gate prt_mod(private_t *pri, int raw, long val)	/* print modctl() code */
10650Sstevel@tonic-gate {
10660Sstevel@tonic-gate 	const char *s = NULL;
10670Sstevel@tonic-gate 
10680Sstevel@tonic-gate 	if (!raw) {
10690Sstevel@tonic-gate 		switch (val) {
10700Sstevel@tonic-gate 		case MODLOAD:		s = "MODLOAD";		break;
10710Sstevel@tonic-gate 		case MODUNLOAD:		s = "MODUNLOAD";	break;
10720Sstevel@tonic-gate 		case MODINFO:		s = "MODINFO";		break;
10730Sstevel@tonic-gate 		case MODRESERVED:	s = "MODRESERVED";	break;
10740Sstevel@tonic-gate 		case MODSETMINIROOT:	s = "MODSETMINIROOT";	break;
10750Sstevel@tonic-gate 		case MODADDMAJBIND:	s = "MODADDMAJBIND";	break;
10760Sstevel@tonic-gate 		case MODGETPATH:	s = "MODGETPATH";	break;
10770Sstevel@tonic-gate 		case MODGETPATHLEN:	s = "MODGETPATHLEN";	break;
10780Sstevel@tonic-gate 		case MODREADSYSBIND:	s = "MODREADSYSBIND";	break;
10790Sstevel@tonic-gate 		case MODGETMAJBIND:	s = "MODGETMAJBIND";	break;
10800Sstevel@tonic-gate 		case MODGETNAME:	s = "MODGETNAME";	break;
10810Sstevel@tonic-gate 		case MODSIZEOF_DEVID:	s = "MODSIZEOF_DEVID";	break;
10820Sstevel@tonic-gate 		case MODGETDEVID:	s = "MODGETDEVID";	break;
10830Sstevel@tonic-gate 		case MODSIZEOF_MINORNAME: s = "MODSIZEOF_MINORNAME"; break;
10840Sstevel@tonic-gate 		case MODGETMINORNAME:	s = "MODGETMINORNAME";	break;
10850Sstevel@tonic-gate 		case MODGETFBNAME:	s = "MODGETFBNAME";	break;
10860Sstevel@tonic-gate 		case MODEVENTS:		s = "MODEVENTS";	break;
10870Sstevel@tonic-gate 		case MODREREADDACF:	s = "MODREREADDACF";	break;
10880Sstevel@tonic-gate 		case MODLOADDRVCONF:	s = "MODLOADDRVCONF";	break;
10890Sstevel@tonic-gate 		case MODUNLOADDRVCONF:	s = "MODUNLOADDRVCONF";	break;
10900Sstevel@tonic-gate 		case MODREMMAJBIND:	s = "MODREMMAJBIND";	break;
10910Sstevel@tonic-gate 		case MODDEVT2INSTANCE:	s = "MODDEVT2INSTANCE";	break;
10920Sstevel@tonic-gate 		case MODGETDEVFSPATH_LEN: s = "MODGETDEVFSPATH_LEN"; break;
10930Sstevel@tonic-gate 		case MODGETDEVFSPATH:	s = "MODGETDEVFSPATH";	break;
10940Sstevel@tonic-gate 		case MODDEVID2PATHS:	s = "MODDEVID2PATHS";	break;
10950Sstevel@tonic-gate 		case MODSETDEVPOLICY:	s = "MODSETDEVPOLICY";	break;
10960Sstevel@tonic-gate 		case MODGETDEVPOLICY:	s = "MODGETDEVPOLICY";	break;
10970Sstevel@tonic-gate 		case MODALLOCPRIV:	s = "MODALLOCPRIV";	break;
10980Sstevel@tonic-gate 		case MODGETDEVPOLICYBYNAME:
10990Sstevel@tonic-gate 					s = "MODGETDEVPOLICYBYNAME"; break;
11000Sstevel@tonic-gate 		case MODLOADMINORPERM:	s = "MODLOADMINORPERM"; break;
11010Sstevel@tonic-gate 		case MODADDMINORPERM:	s = "MODADDMINORPERM"; break;
11020Sstevel@tonic-gate 		case MODREMMINORPERM:	s = "MODREMMINORPERM"; break;
11030Sstevel@tonic-gate 		case MODREMDRVCLEANUP:	s = "MODREMDRVCLEANUP"; break;
11042621Sllai1 		case MODDEVEXISTS:	s = "MODDEVEXISTS"; break;
11052621Sllai1 		case MODDEVREADDIR:	s = "MODDEVREADDIR"; break;
11062621Sllai1 		case MODDEVNAME:	s = "MODDEVNAME"; break;
11072723Scth 		case MODGETDEVFSPATH_MI_LEN:
11082723Scth 					s = "MODGETDEVFSPATH_MI_LEN"; break;
11092723Scth 		case MODGETDEVFSPATH_MI:
11102723Scth 					s = "MODGETDEVFSPATH_MI"; break;
11110Sstevel@tonic-gate 		}
11120Sstevel@tonic-gate 	}
11130Sstevel@tonic-gate 
11140Sstevel@tonic-gate 	if (s == NULL)
11150Sstevel@tonic-gate 		prt_dec(pri, 0, val);
11160Sstevel@tonic-gate 	else
11170Sstevel@tonic-gate 		outstring(pri, s);
11180Sstevel@tonic-gate }
11190Sstevel@tonic-gate 
11200Sstevel@tonic-gate void
11210Sstevel@tonic-gate prt_acl(private_t *pri, int raw, long val)	/* print acl() code */
11220Sstevel@tonic-gate {
11230Sstevel@tonic-gate 	const char *s = NULL;
11240Sstevel@tonic-gate 
11250Sstevel@tonic-gate 	if (!raw) {
11260Sstevel@tonic-gate 		switch (val) {
11270Sstevel@tonic-gate 		case GETACL:		s = "GETACL";		break;
11280Sstevel@tonic-gate 		case SETACL:		s = "SETACL";		break;
11290Sstevel@tonic-gate 		case GETACLCNT:		s = "GETACLCNT";	break;
1130789Sahrens 		case ACE_GETACL:	s = "ACE_GETACL";	break;
1131789Sahrens 		case ACE_SETACL:	s = "ACE_SETACL";	break;
1132789Sahrens 		case ACE_GETACLCNT:	s = "ACE_GETACLCNT";	break;
11330Sstevel@tonic-gate 		}
11340Sstevel@tonic-gate 	}
11350Sstevel@tonic-gate 
11360Sstevel@tonic-gate 	if (s == NULL)
11370Sstevel@tonic-gate 		prt_dec(pri, 0, val);
11380Sstevel@tonic-gate 	else
11390Sstevel@tonic-gate 		outstring(pri, s);
11400Sstevel@tonic-gate }
11410Sstevel@tonic-gate 
11420Sstevel@tonic-gate void
11430Sstevel@tonic-gate prt_aio(private_t *pri, int raw, long val)	/* print kaio() code */
11440Sstevel@tonic-gate {
11450Sstevel@tonic-gate 	const char *s = NULL;
11460Sstevel@tonic-gate 	char buf[32];
11470Sstevel@tonic-gate 
11480Sstevel@tonic-gate 	if (!raw) {
11490Sstevel@tonic-gate 		switch (val & ~AIO_POLL_BIT) {
11500Sstevel@tonic-gate 		case AIOREAD:		s = "AIOREAD";		break;
11510Sstevel@tonic-gate 		case AIOWRITE:		s = "AIOWRITE";		break;
11520Sstevel@tonic-gate 		case AIOWAIT:		s = "AIOWAIT";		break;
11530Sstevel@tonic-gate 		case AIOCANCEL:		s = "AIOCANCEL";	break;
11540Sstevel@tonic-gate 		case AIONOTIFY:		s = "AIONOTIFY";	break;
11550Sstevel@tonic-gate 		case AIOINIT:		s = "AIOINIT";		break;
11560Sstevel@tonic-gate 		case AIOSTART:		s = "AIOSTART";		break;
11570Sstevel@tonic-gate 		case AIOLIO:		s = "AIOLIO";		break;
11580Sstevel@tonic-gate 		case AIOSUSPEND:	s = "AIOSUSPEND";	break;
11590Sstevel@tonic-gate 		case AIOERROR:		s = "AIOERROR";		break;
11600Sstevel@tonic-gate 		case AIOLIOWAIT:	s = "AIOLIOWAIT";	break;
11610Sstevel@tonic-gate 		case AIOAREAD:		s = "AIOAREAD";		break;
11620Sstevel@tonic-gate 		case AIOAWRITE:		s = "AIOAWRITE";	break;
11630Sstevel@tonic-gate 		/*
11640Sstevel@tonic-gate 		 * We have to hardcode the values for the 64-bit versions of
11650Sstevel@tonic-gate 		 * these calls, because <sys/aio.h> defines them to be identical
11660Sstevel@tonic-gate 		 * when compiled 64-bit.  If our target is 32-bit, we still need
11670Sstevel@tonic-gate 		 * to decode them correctly.
11680Sstevel@tonic-gate 		 */
11690Sstevel@tonic-gate 		case 13:		s = "AIOLIO64";		break;
11700Sstevel@tonic-gate 		case 14:		s = "AIOSUSPEND64";	break;
11710Sstevel@tonic-gate 		case 15:		s = "AUIOERROR64";	break;
11720Sstevel@tonic-gate 		case 16:		s = "AIOLIOWAIT64";	break;
11730Sstevel@tonic-gate 		case 17:		s = "AIOAREAD64";	break;
11740Sstevel@tonic-gate 		case 18:		s = "AIOAWRITE64";	break;
11750Sstevel@tonic-gate 		case 19:		s = "AIOCANCEL64";	break;
11760Sstevel@tonic-gate 
11770Sstevel@tonic-gate 		/*
11780Sstevel@tonic-gate 		 * AIOFSYNC doesn't correspond to a syscall.
11790Sstevel@tonic-gate 		 */
11800Sstevel@tonic-gate 		case AIOWAITN:		s = "AIOWAITN";		break;
11810Sstevel@tonic-gate 		}
11820Sstevel@tonic-gate 		if (s != NULL && (val & AIO_POLL_BIT)) {
11830Sstevel@tonic-gate 			(void) strlcpy(buf, s, sizeof (buf));
11840Sstevel@tonic-gate 			(void) strlcat(buf, "|AIO_POLL_BIT", sizeof (buf));
11850Sstevel@tonic-gate 			s = (const char *)buf;
11860Sstevel@tonic-gate 		}
11870Sstevel@tonic-gate 	}
11880Sstevel@tonic-gate 
11890Sstevel@tonic-gate 	if (s == NULL)
11900Sstevel@tonic-gate 		prt_dec(pri, 0, val);
11910Sstevel@tonic-gate 	else
11920Sstevel@tonic-gate 		outstring(pri, s);
11930Sstevel@tonic-gate }
11940Sstevel@tonic-gate 
11950Sstevel@tonic-gate void
11960Sstevel@tonic-gate prt_aud(private_t *pri, int raw, long val)	/* print auditsys() code */
11970Sstevel@tonic-gate {
11980Sstevel@tonic-gate 	const char *s = NULL;
11990Sstevel@tonic-gate 
12000Sstevel@tonic-gate 	if (!raw) {
12010Sstevel@tonic-gate 		switch (val) {
12020Sstevel@tonic-gate 		case BSM_GETAUID:	s = "BSM_GETAUID";	break;
12030Sstevel@tonic-gate 		case BSM_SETAUID:	s = "BSM_SETAUID";	break;
12040Sstevel@tonic-gate 		case BSM_GETAUDIT:	s = "BSM_GETAUDIT";	break;
12050Sstevel@tonic-gate 		case BSM_SETAUDIT:	s = "BSM_SETAUDIT";	break;
12060Sstevel@tonic-gate 		case BSM_GETUSERAUDIT:	s = "BSM_GETUSERAUDIT";	break;
12070Sstevel@tonic-gate 		case BSM_SETUSERAUDIT:	s = "BSM_SETUSERAUDIT";	break;
12080Sstevel@tonic-gate 		case BSM_AUDIT:		s = "BSM_AUDIT";	break;
12090Sstevel@tonic-gate 		case BSM_AUDITSVC:	s = "BSM_AUDITSVC";	break;
12100Sstevel@tonic-gate 		case BSM_AUDITON:	s = "BSM_AUDITON";	break;
12110Sstevel@tonic-gate 		case BSM_AUDITCTL:	s = "BSM_AUDITCTL";	break;
12120Sstevel@tonic-gate 		case BSM_GETKERNSTATE:	s = "BSM_GETKERNSTATE";	break;
12130Sstevel@tonic-gate 		case BSM_SETKERNSTATE:	s = "BSM_SETKERNSTATE";	break;
12140Sstevel@tonic-gate 		case BSM_GETPORTAUDIT:	s = "BSM_GETPORTAUDIT";	break;
12150Sstevel@tonic-gate 		case BSM_REVOKE:	s = "BSM_REVOKE";	break;
12160Sstevel@tonic-gate 		case BSM_AUDITSTAT:	s = "BSM_AUDITSTAT";	break;
12170Sstevel@tonic-gate 		case BSM_GETAUDIT_ADDR:	s = "BSM_GETAUDIT_ADDR"; break;
12180Sstevel@tonic-gate 		case BSM_SETAUDIT_ADDR:	s = "BSM_SETAUDIT_ADDR"; break;
12190Sstevel@tonic-gate 		}
12200Sstevel@tonic-gate 	}
12210Sstevel@tonic-gate 
12220Sstevel@tonic-gate 	if (s == NULL)
12230Sstevel@tonic-gate 		prt_dec(pri, 0, val);
12240Sstevel@tonic-gate 	else
12250Sstevel@tonic-gate 		outstring(pri, s);
12260Sstevel@tonic-gate }
12270Sstevel@tonic-gate 
12280Sstevel@tonic-gate void
12290Sstevel@tonic-gate prt_cor(private_t *pri, int raw, long val)	/* print corectl() subcode */
12300Sstevel@tonic-gate {
12310Sstevel@tonic-gate 	const char *s = NULL;
12320Sstevel@tonic-gate 
12330Sstevel@tonic-gate 	if (!raw) {
12340Sstevel@tonic-gate 		switch (val) {
12350Sstevel@tonic-gate 		case CC_SET_OPTIONS:
12360Sstevel@tonic-gate 			s = "CC_SET_OPTIONS";		break;
12370Sstevel@tonic-gate 		case CC_GET_OPTIONS:
12380Sstevel@tonic-gate 			s = "CC_GET_OPTIONS";		break;
12390Sstevel@tonic-gate 		case CC_SET_GLOBAL_PATH:
12400Sstevel@tonic-gate 			s = "CC_SET_GLOBAL_PATH";	break;
12410Sstevel@tonic-gate 		case CC_GET_GLOBAL_PATH:
12420Sstevel@tonic-gate 			s = "CC_GET_GLOBAL_PATH";	break;
12430Sstevel@tonic-gate 		case CC_SET_PROCESS_PATH:
12440Sstevel@tonic-gate 			s = "CC_SET_PROCESS_PATH";	break;
12450Sstevel@tonic-gate 		case CC_GET_PROCESS_PATH:
12460Sstevel@tonic-gate 			s = "CC_GET_PROCESS_PATH";	break;
12470Sstevel@tonic-gate 		case CC_SET_GLOBAL_CONTENT:
12480Sstevel@tonic-gate 			s = "CC_SET_GLOBAL_CONTENT";	break;
12490Sstevel@tonic-gate 		case CC_GET_GLOBAL_CONTENT:
12500Sstevel@tonic-gate 			s = "CC_GET_GLOBAL_CONTENT";	break;
12510Sstevel@tonic-gate 		case CC_SET_PROCESS_CONTENT:
12520Sstevel@tonic-gate 			s = "CC_SET_PROCESS_CONTENT";	break;
12530Sstevel@tonic-gate 		case CC_GET_PROCESS_CONTENT:
12540Sstevel@tonic-gate 			s = "CC_GET_PROCESS_CONTENT";	break;
12550Sstevel@tonic-gate 		case CC_SET_DEFAULT_PATH:
12560Sstevel@tonic-gate 			s = "CC_SET_DEFAULT_PATH";	break;
12570Sstevel@tonic-gate 		case CC_GET_DEFAULT_PATH:
12580Sstevel@tonic-gate 			s = "CC_GET_DEFAULT_PATH";	break;
12590Sstevel@tonic-gate 		case CC_SET_DEFAULT_CONTENT:
12600Sstevel@tonic-gate 			s = "CC_SET_DEFAULT_CONTENT";	break;
12610Sstevel@tonic-gate 		case CC_GET_DEFAULT_CONTENT:
12620Sstevel@tonic-gate 			s = "CC_GET_DEFAULT_CONTENT";	break;
12630Sstevel@tonic-gate 		}
12640Sstevel@tonic-gate 	}
12650Sstevel@tonic-gate 
12660Sstevel@tonic-gate 	if (s == NULL)
12670Sstevel@tonic-gate 		prt_dec(pri, 0, val);
12680Sstevel@tonic-gate 	else
12690Sstevel@tonic-gate 		outstring(pri, s);
12700Sstevel@tonic-gate }
12710Sstevel@tonic-gate 
12720Sstevel@tonic-gate void
12730Sstevel@tonic-gate prt_cco(private_t *pri, int raw, long val)	/* print corectl() options */
12740Sstevel@tonic-gate {
12750Sstevel@tonic-gate 	char *s;
12760Sstevel@tonic-gate 
12770Sstevel@tonic-gate 	if (val == 0)
12780Sstevel@tonic-gate 		prt_dec(pri, 0, val);
12790Sstevel@tonic-gate 	else if (raw || (val & ~CC_OPTIONS))
12800Sstevel@tonic-gate 		prt_hhx(pri, 0, val);
12810Sstevel@tonic-gate 	else {
12820Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
12830Sstevel@tonic-gate 		s = pri->code_buf;
12840Sstevel@tonic-gate 		*s = '\0';
12850Sstevel@tonic-gate 		if (val & CC_GLOBAL_PATH)
12860Sstevel@tonic-gate 			(void) strlcat(s, "|CC_GLOBAL_PATH", CBSIZE);
12870Sstevel@tonic-gate 		if (val & CC_PROCESS_PATH)
12880Sstevel@tonic-gate 			(void) strlcat(s, "|CC_PROCESS_PATH", CBSIZE);
12890Sstevel@tonic-gate 		if (val & CC_GLOBAL_SETID)
12900Sstevel@tonic-gate 			(void) strlcat(s, "|CC_GLOBAL_SETID", CBSIZE);
12910Sstevel@tonic-gate 		if (val & CC_PROCESS_SETID)
12920Sstevel@tonic-gate 			(void) strlcat(s, "|CC_PROCESS_SETID", CBSIZE);
12930Sstevel@tonic-gate 		if (val & CC_GLOBAL_LOG)
12940Sstevel@tonic-gate 			(void) strlcat(s, "|CC_GLOBAL_LOG", CBSIZE);
12950Sstevel@tonic-gate 		if (*s == '\0')
12960Sstevel@tonic-gate 			prt_hhx(pri, 0, val);
12970Sstevel@tonic-gate 		else
12980Sstevel@tonic-gate 			outstring(pri, ++s);
12990Sstevel@tonic-gate #undef CBSIZE
13000Sstevel@tonic-gate 	}
13010Sstevel@tonic-gate }
13020Sstevel@tonic-gate 
13030Sstevel@tonic-gate void
13040Sstevel@tonic-gate prt_ccc(private_t *pri, int raw, long val)	/* print corectl() content */
13050Sstevel@tonic-gate {
13060Sstevel@tonic-gate 	core_content_t ccc;
13070Sstevel@tonic-gate 
13080Sstevel@tonic-gate 	if (Pread(Proc, &ccc, sizeof (ccc), val) != sizeof (ccc))
13090Sstevel@tonic-gate 		prt_hex(pri, 0, val);
13100Sstevel@tonic-gate 	else if (!raw && proc_content2str(ccc, pri->code_buf,
13110Sstevel@tonic-gate 	    sizeof (pri->code_buf)) >= 0)
13120Sstevel@tonic-gate 		outstring(pri, pri->code_buf);
13130Sstevel@tonic-gate 	else
13140Sstevel@tonic-gate 		prt_hhx(pri, 0, (long)ccc);
13150Sstevel@tonic-gate }
13160Sstevel@tonic-gate 
13170Sstevel@tonic-gate void
13180Sstevel@tonic-gate prt_rcc(private_t *pri, int raw, long val)	/* print corectl() ret. cont. */
13190Sstevel@tonic-gate {
13200Sstevel@tonic-gate 	core_content_t ccc;
13210Sstevel@tonic-gate 
13220Sstevel@tonic-gate 	if (pri->Errno || Pread(Proc, &ccc, sizeof (ccc), val) != sizeof (ccc))
13230Sstevel@tonic-gate 		prt_hex(pri, 0, val);
13240Sstevel@tonic-gate 	else if (!raw && proc_content2str(ccc, pri->code_buf,
13250Sstevel@tonic-gate 	    sizeof (pri->code_buf)) >= 0)
13260Sstevel@tonic-gate 		outstring(pri, pri->code_buf);
13270Sstevel@tonic-gate 	else
13280Sstevel@tonic-gate 		prt_hhx(pri, 0, (long)ccc);
13290Sstevel@tonic-gate }
13300Sstevel@tonic-gate 
13310Sstevel@tonic-gate void
13320Sstevel@tonic-gate prt_cpc(private_t *pri, int raw, long val)	/* print cpc() subcode */
13330Sstevel@tonic-gate {
13340Sstevel@tonic-gate 	const char *s = NULL;
13350Sstevel@tonic-gate 
13360Sstevel@tonic-gate 	if (!raw) {
13370Sstevel@tonic-gate 		switch (val) {
13380Sstevel@tonic-gate 		case CPC_BIND:		s = "CPC_BIND";		break;
13390Sstevel@tonic-gate 		case CPC_SAMPLE:	s = "CPC_SAMPLE";	break;
13400Sstevel@tonic-gate 		case CPC_INVALIDATE:	s = "CPC_INVALIDATE";	break;
13410Sstevel@tonic-gate 		case CPC_RELE:		s = "CPC_RELE";		break;
13420Sstevel@tonic-gate 		case CPC_EVLIST_SIZE:	s = "CPC_EVLIST_SIZE";	break;
13430Sstevel@tonic-gate 		case CPC_LIST_EVENTS:	s = "CPC_LIST_EVENTS";	break;
13440Sstevel@tonic-gate 		case CPC_ATTRLIST_SIZE:	s = "CPC_ATTRLIST_SIZE"; break;
13450Sstevel@tonic-gate 		case CPC_LIST_ATTRS:	s = "CPC_LIST_ATTRS";	break;
13460Sstevel@tonic-gate 		case CPC_IMPL_NAME:	s = "CPC_IMPL_NAME";	break;
13470Sstevel@tonic-gate 		case CPC_CPUREF:	s = "CPC_CPUREF";	break;
13480Sstevel@tonic-gate 		case CPC_USR_EVENTS:	s = "CPC_USR_EVENTS";	break;
13490Sstevel@tonic-gate 		case CPC_SYS_EVENTS:	s = "CPC_SYS_EVENTS";	break;
13500Sstevel@tonic-gate 		case CPC_NPIC:		s = "CPC_NPIC";		break;
13510Sstevel@tonic-gate 		case CPC_CAPS:		s = "CPC_CAPS";		break;
13520Sstevel@tonic-gate 		case CPC_ENABLE:	s = "CPC_ENABLE";	break;
13530Sstevel@tonic-gate 		case CPC_DISABLE:	s = "CPC_DISABLE";	break;
13540Sstevel@tonic-gate 		}
13550Sstevel@tonic-gate 	}
13560Sstevel@tonic-gate 
13570Sstevel@tonic-gate 	if (s == NULL)
13580Sstevel@tonic-gate 		prt_dec(pri, 0, val);
13590Sstevel@tonic-gate 	else
13600Sstevel@tonic-gate 		outstring(pri, s);
13610Sstevel@tonic-gate }
13620Sstevel@tonic-gate 
13630Sstevel@tonic-gate void
13640Sstevel@tonic-gate outstring(private_t *pri, const char *s)
13650Sstevel@tonic-gate {
13660Sstevel@tonic-gate 	int len = strlen(s);
13670Sstevel@tonic-gate 
13680Sstevel@tonic-gate 	GROW(len);
13690Sstevel@tonic-gate 	(void) strcpy(pri->sys_string + pri->sys_leng, s);
13700Sstevel@tonic-gate 	pri->sys_leng += len;
13710Sstevel@tonic-gate }
13720Sstevel@tonic-gate 
13730Sstevel@tonic-gate void
13740Sstevel@tonic-gate grow(private_t *pri, int nbyte)	/* reallocate format buffer if necessary */
13750Sstevel@tonic-gate {
13760Sstevel@tonic-gate 	while (pri->sys_leng + nbyte >= pri->sys_ssize)
13770Sstevel@tonic-gate 		pri->sys_string = my_realloc(pri->sys_string,
1378*4217Seschrock 		    pri->sys_ssize *= 2, "format buffer");
13790Sstevel@tonic-gate }
13800Sstevel@tonic-gate 
13810Sstevel@tonic-gate void
13820Sstevel@tonic-gate prt_clc(private_t *pri, int raw, long val)
13830Sstevel@tonic-gate {
13840Sstevel@tonic-gate 	const char *s = NULL;
13850Sstevel@tonic-gate 
13860Sstevel@tonic-gate 	if (!raw) {
13870Sstevel@tonic-gate 		switch (val) {
13880Sstevel@tonic-gate 		case CL_INITIALIZE:	s = "CL_INITIALIZE";	break;
13890Sstevel@tonic-gate 		case CL_CONFIG:		s = "CL_CONFIG";	break;
13900Sstevel@tonic-gate 		}
13910Sstevel@tonic-gate 	}
13920Sstevel@tonic-gate 
13930Sstevel@tonic-gate 	if (s == NULL)
13940Sstevel@tonic-gate 		prt_dec(pri, 0, val);
13950Sstevel@tonic-gate 	else
13960Sstevel@tonic-gate 		outstring(pri, s);
13970Sstevel@tonic-gate }
13980Sstevel@tonic-gate 
13990Sstevel@tonic-gate void
14000Sstevel@tonic-gate prt_clf(private_t *pri, int raw, long val)
14010Sstevel@tonic-gate {
14020Sstevel@tonic-gate 	const char *s = NULL;
14030Sstevel@tonic-gate 
14040Sstevel@tonic-gate 	if (!raw) {
14050Sstevel@tonic-gate 		switch (pri->sys_args[0]) {
14060Sstevel@tonic-gate 		case CL_CONFIG:
14070Sstevel@tonic-gate 			switch (pri->sys_args[1]) {
14080Sstevel@tonic-gate 			case CL_NODEID:
14090Sstevel@tonic-gate 				s = "CL_NODEID";		break;
14100Sstevel@tonic-gate 			case CL_HIGHEST_NODEID:
14110Sstevel@tonic-gate 				s = "CL_HIGHEST_NODEID";	break;
14120Sstevel@tonic-gate 			}
14130Sstevel@tonic-gate 			break;
14140Sstevel@tonic-gate 		case CL_INITIALIZE:
14150Sstevel@tonic-gate 			switch (pri->sys_args[1]) {
14160Sstevel@tonic-gate 			case CL_GET_BOOTFLAG:
14170Sstevel@tonic-gate 				s = "CL_GET_BOOTFLAG";		break;
14180Sstevel@tonic-gate 			}
14190Sstevel@tonic-gate 			break;
14200Sstevel@tonic-gate 		}
14210Sstevel@tonic-gate 	}
14220Sstevel@tonic-gate 
14230Sstevel@tonic-gate 	if (s == NULL)
14240Sstevel@tonic-gate 		prt_dec(pri, 0, val);
14250Sstevel@tonic-gate 	else
14260Sstevel@tonic-gate 		outstring(pri, s);
14270Sstevel@tonic-gate }
14280Sstevel@tonic-gate 
14290Sstevel@tonic-gate void
14300Sstevel@tonic-gate prt_sqc(private_t *pri, int raw, long val)	/* print sigqueue() si_code */
14310Sstevel@tonic-gate {
14320Sstevel@tonic-gate 	const char *s = NULL;
14330Sstevel@tonic-gate 
14340Sstevel@tonic-gate 	if (!raw) {
14350Sstevel@tonic-gate 		switch ((int)val) {
14360Sstevel@tonic-gate 		case SI_QUEUE:		s = "SI_QUEUE";		break;
14370Sstevel@tonic-gate 		case SI_TIMER:		s = "SI_TIMER";		break;
14380Sstevel@tonic-gate 		case SI_ASYNCIO:	s = "SI_ASYNCIO";	break;
14390Sstevel@tonic-gate 		case SI_MESGQ:		s = "SI_MESGQ";		break;
14400Sstevel@tonic-gate 		}
14410Sstevel@tonic-gate 	}
14420Sstevel@tonic-gate 
14430Sstevel@tonic-gate 	if (s == NULL)
14440Sstevel@tonic-gate 		prt_dec(pri, 0, val);
14450Sstevel@tonic-gate 	else
14460Sstevel@tonic-gate 		outstring(pri, s);
14470Sstevel@tonic-gate }
14480Sstevel@tonic-gate 
14490Sstevel@tonic-gate /*
14500Sstevel@tonic-gate  * print priocntlsys() (key, value) pair key.
14510Sstevel@tonic-gate  */
14520Sstevel@tonic-gate void
14530Sstevel@tonic-gate print_pck(private_t *pri, int raw, long val)
14540Sstevel@tonic-gate {
14550Sstevel@tonic-gate 	const char	*s = NULL;
14560Sstevel@tonic-gate 	char		clname[PC_CLNMSZ];
14570Sstevel@tonic-gate 
14580Sstevel@tonic-gate 	if ((pri->sys_args[2] != PC_GETXPARMS &&
14590Sstevel@tonic-gate 	    pri->sys_args[2] != PC_SETXPARMS) || val == 0 || raw) {
14600Sstevel@tonic-gate 		prt_dec(pri, 0, val);
14610Sstevel@tonic-gate 		return;
14620Sstevel@tonic-gate 	}
14630Sstevel@tonic-gate 
14640Sstevel@tonic-gate 	if (pri->sys_args[3] == NULL) {
14650Sstevel@tonic-gate 		if (val == PC_KY_CLNAME) {
14660Sstevel@tonic-gate 			s = "PC_KY_CLNAME";
14670Sstevel@tonic-gate 			outstring(pri, s);
14680Sstevel@tonic-gate 		} else
14690Sstevel@tonic-gate 			prt_dec(pri, 0, val);
14700Sstevel@tonic-gate 		return;
14710Sstevel@tonic-gate 	}
14720Sstevel@tonic-gate 
14730Sstevel@tonic-gate 	if (Pread(Proc, &clname, PC_CLNMSZ, pri->sys_args[3]) != PC_CLNMSZ) {
14740Sstevel@tonic-gate 		prt_dec(pri, 0, val);
14750Sstevel@tonic-gate 		return;
14760Sstevel@tonic-gate 	}
14770Sstevel@tonic-gate 
14780Sstevel@tonic-gate 	if (strcmp(clname, "TS") == 0) {
14790Sstevel@tonic-gate 		switch (val) {
14800Sstevel@tonic-gate 		case TS_KY_UPRILIM: 	s = "TS_KY_UPRILIM";	break;
14810Sstevel@tonic-gate 		case TS_KY_UPRI:	s = "TS_KY_UPRI";	break;
14820Sstevel@tonic-gate 		default:					break;
14830Sstevel@tonic-gate 		}
14840Sstevel@tonic-gate 	} else if (strcmp(clname, "IA") == 0) {
14850Sstevel@tonic-gate 		switch (val) {
14860Sstevel@tonic-gate 		case IA_KY_UPRILIM: 	s = "IA_KY_UPRILIM";	break;
14870Sstevel@tonic-gate 		case IA_KY_UPRI:	s = "IA_KY_UPRI";	break;
14880Sstevel@tonic-gate 		case IA_KY_MODE:	s = "IA_KY_MODE";	break;
14890Sstevel@tonic-gate 		default:					break;
14900Sstevel@tonic-gate 		}
14910Sstevel@tonic-gate 	} else if (strcmp(clname, "RT") == 0) {
14920Sstevel@tonic-gate 		switch (val) {
14930Sstevel@tonic-gate 		case RT_KY_PRI: 	s = "RT_KY_PRI";	break;
14940Sstevel@tonic-gate 		case RT_KY_TQSECS:	s = "RT_KY_TQSECS";	break;
14950Sstevel@tonic-gate 		case RT_KY_TQNSECS:	s = "RT_KY_TQNSECS";	break;
14960Sstevel@tonic-gate 		case RT_KY_TQSIG:	s = "RT_KY_TQSIG";	break;
14970Sstevel@tonic-gate 		default:					break;
14980Sstevel@tonic-gate 		}
14990Sstevel@tonic-gate 	} else if (strcmp(clname, "FSS") == 0) {
15000Sstevel@tonic-gate 		switch (val) {
15010Sstevel@tonic-gate 		case FSS_KY_UPRILIM: 	s = "FSS_KY_UPRILIM";	break;
15020Sstevel@tonic-gate 		case FSS_KY_UPRI:	s = "FSS_KY_UPRI";	break;
15030Sstevel@tonic-gate 		default:					break;
15040Sstevel@tonic-gate 		}
15050Sstevel@tonic-gate 	} else if (strcmp(clname, "FX") == 0) {
15060Sstevel@tonic-gate 		switch (val) {
15070Sstevel@tonic-gate 		case FX_KY_UPRILIM: 	s = "FX_KY_UPRILIM";	break;
15080Sstevel@tonic-gate 		case FX_KY_UPRI:	s = "FX_KY_UPRI";	break;
15090Sstevel@tonic-gate 		case FX_KY_TQSECS:	s = "FX_KY_TQSECS";	break;
15100Sstevel@tonic-gate 		case FX_KY_TQNSECS:	s = "FX_KY_TQNSECS";	break;
15110Sstevel@tonic-gate 		default:					break;
15120Sstevel@tonic-gate 		}
15130Sstevel@tonic-gate 	}
15140Sstevel@tonic-gate 
15150Sstevel@tonic-gate 	if (s == NULL)
15160Sstevel@tonic-gate 		prt_dec(pri, 0, val);
15170Sstevel@tonic-gate 	else
15180Sstevel@tonic-gate 		outstring(pri, s);
15190Sstevel@tonic-gate }
15200Sstevel@tonic-gate 
15210Sstevel@tonic-gate /*
15220Sstevel@tonic-gate  * print priocntlsys() fourth argument.
15230Sstevel@tonic-gate  */
15240Sstevel@tonic-gate /*ARGSUSED*/
15250Sstevel@tonic-gate void
15260Sstevel@tonic-gate prt_pc4(private_t *pri, int raw, long val)
15270Sstevel@tonic-gate {
15280Sstevel@tonic-gate 	/* look at pricntlsys function */
15290Sstevel@tonic-gate 	if ((pri->sys_args[2] != PC_GETXPARMS &&
15300Sstevel@tonic-gate 	    pri->sys_args[2] != PC_SETXPARMS))
15310Sstevel@tonic-gate 		prt_hex(pri, 0, val);
15320Sstevel@tonic-gate 	else if (val)
15330Sstevel@tonic-gate 		prt_stg(pri, 0, val);
15340Sstevel@tonic-gate 	else
15350Sstevel@tonic-gate 		prt_dec(pri, 0, val);
15360Sstevel@tonic-gate }
15370Sstevel@tonic-gate 
15380Sstevel@tonic-gate /*
15390Sstevel@tonic-gate  * print priocntlsys() (key, value) pairs (5th argument).
15400Sstevel@tonic-gate  */
15410Sstevel@tonic-gate /*ARGSUSED*/
15420Sstevel@tonic-gate void
15430Sstevel@tonic-gate prt_pc5(private_t *pri, int raw, long val)
15440Sstevel@tonic-gate {
15450Sstevel@tonic-gate 	pc_vaparms_t	prms;
15460Sstevel@tonic-gate 	pc_vaparm_t	*vpp = &prms.pc_parms[0];
15470Sstevel@tonic-gate 	uint_t		cnt;
15480Sstevel@tonic-gate 
15490Sstevel@tonic-gate 
15500Sstevel@tonic-gate 	/* look at pricntlsys function */
15510Sstevel@tonic-gate 	if ((pri->sys_args[2] != PC_GETXPARMS &&
15520Sstevel@tonic-gate 	    pri->sys_args[2] != PC_SETXPARMS) || val == 0) {
15530Sstevel@tonic-gate 		prt_dec(pri, 0, 0);
15540Sstevel@tonic-gate 		return;
15550Sstevel@tonic-gate 	}
15560Sstevel@tonic-gate 
15570Sstevel@tonic-gate 	if (Pread(Proc, &prms, sizeof (prms), val) != sizeof (prms)) {
15580Sstevel@tonic-gate 		prt_hex(pri, 0, val);
15590Sstevel@tonic-gate 		return;
15600Sstevel@tonic-gate 	}
15610Sstevel@tonic-gate 
15620Sstevel@tonic-gate 	if ((cnt = prms.pc_vaparmscnt) > PC_VAPARMCNT)
15630Sstevel@tonic-gate 		return;
15640Sstevel@tonic-gate 
15650Sstevel@tonic-gate 	for (; cnt--; vpp++) {
15660Sstevel@tonic-gate 		print_pck(pri, 0, vpp->pc_key);
15670Sstevel@tonic-gate 		outstring(pri, ", ");
15680Sstevel@tonic-gate 		prt_hex(pri, 0, (long)vpp->pc_parm);
15690Sstevel@tonic-gate 		outstring(pri, ", ");
15700Sstevel@tonic-gate 	}
15710Sstevel@tonic-gate 
15720Sstevel@tonic-gate 	prt_dec(pri, 0, PC_KY_NULL);
15730Sstevel@tonic-gate }
15740Sstevel@tonic-gate 
15750Sstevel@tonic-gate /*
15760Sstevel@tonic-gate  * Print processor set id, including logical expansion of "special" ids.
15770Sstevel@tonic-gate  */
15780Sstevel@tonic-gate void
15790Sstevel@tonic-gate prt_pst(private_t *pri, int raw, long val)
15800Sstevel@tonic-gate {
15810Sstevel@tonic-gate 	const char *s = NULL;
15820Sstevel@tonic-gate 
15830Sstevel@tonic-gate 	if (!raw) {
15840Sstevel@tonic-gate 		switch ((psetid_t)val) {
15850Sstevel@tonic-gate 		case PS_NONE:		s = "PS_NONE";		break;
15860Sstevel@tonic-gate 		case PS_QUERY:		s = "PS_QUERY";		break;
15870Sstevel@tonic-gate 		case PS_MYID:		s = "PS_MYID";		break;
15880Sstevel@tonic-gate 		}
15890Sstevel@tonic-gate 	}
15900Sstevel@tonic-gate 
15910Sstevel@tonic-gate 	if (s == NULL)
15920Sstevel@tonic-gate 		prt_dec(pri, 0, val);
15930Sstevel@tonic-gate 	else
15940Sstevel@tonic-gate 		outstring(pri, s);
15950Sstevel@tonic-gate }
15960Sstevel@tonic-gate 
15970Sstevel@tonic-gate /*
15980Sstevel@tonic-gate  * Print meminfo() argument.
15990Sstevel@tonic-gate  */
16000Sstevel@tonic-gate /*ARGSUSED*/
16010Sstevel@tonic-gate void
16020Sstevel@tonic-gate prt_mif(private_t *pri, int raw, long val)
16030Sstevel@tonic-gate {
16040Sstevel@tonic-gate 	struct meminfo	minfo;
16050Sstevel@tonic-gate 
16060Sstevel@tonic-gate #ifdef _LP64
16070Sstevel@tonic-gate 	if (data_model == PR_MODEL_ILP32) {
16080Sstevel@tonic-gate 		struct meminfo32 minfo32;
16090Sstevel@tonic-gate 
16100Sstevel@tonic-gate 		if (Pread(Proc, &minfo32, sizeof (struct meminfo32), val) !=
16110Sstevel@tonic-gate 			sizeof (struct meminfo32)) {
16120Sstevel@tonic-gate 			prt_dec(pri, 0, pri->sys_args[1]);	/* addr_count */
16130Sstevel@tonic-gate 			outstring(pri, ", ");
16140Sstevel@tonic-gate 			prt_hex(pri, 0, val);
16150Sstevel@tonic-gate 			return;
16160Sstevel@tonic-gate 		}
16170Sstevel@tonic-gate 		/*
16180Sstevel@tonic-gate 		 * arrange the arguments in the order that user calls with
16190Sstevel@tonic-gate 		 */
16200Sstevel@tonic-gate 		prt_hex(pri, 0, minfo32.mi_inaddr);
16210Sstevel@tonic-gate 		outstring(pri, ", ");
16220Sstevel@tonic-gate 		prt_dec(pri, 0, pri->sys_args[1]);	/* addr_count */
16230Sstevel@tonic-gate 		outstring(pri, ", ");
16240Sstevel@tonic-gate 		prt_hex(pri, 0, minfo32.mi_info_req);
16250Sstevel@tonic-gate 		outstring(pri, ", ");
16260Sstevel@tonic-gate 		prt_dec(pri, 0, minfo32.mi_info_count);
16270Sstevel@tonic-gate 		outstring(pri, ", ");
16280Sstevel@tonic-gate 		prt_hex(pri, 0, minfo32.mi_outdata);
16290Sstevel@tonic-gate 		outstring(pri, ", ");
16300Sstevel@tonic-gate 		prt_hex(pri, 0, minfo32.mi_validity);
16310Sstevel@tonic-gate 		return;
16320Sstevel@tonic-gate 	}
16330Sstevel@tonic-gate #endif
16340Sstevel@tonic-gate 	if (Pread(Proc, &minfo, sizeof (struct meminfo), val) !=
16350Sstevel@tonic-gate 		sizeof (struct meminfo)) {
16360Sstevel@tonic-gate 		prt_dec(pri, 0, pri->sys_args[1]);	/* addr_count */
16370Sstevel@tonic-gate 		outstring(pri, ", ");
16380Sstevel@tonic-gate 		prt_hex(pri, 0, val);
16390Sstevel@tonic-gate 		return;
16400Sstevel@tonic-gate 	}
16410Sstevel@tonic-gate 	/*
16420Sstevel@tonic-gate 	 * arrange the arguments in the order that user calls with
16430Sstevel@tonic-gate 	 */
16440Sstevel@tonic-gate 	prt_hex(pri, 0, (long)minfo.mi_inaddr);
16450Sstevel@tonic-gate 	outstring(pri, ", ");
16460Sstevel@tonic-gate 	prt_dec(pri, 0, pri->sys_args[1]);	/* addr_count */
16470Sstevel@tonic-gate 	outstring(pri, ", ");
16480Sstevel@tonic-gate 	prt_hex(pri, 0, (long)minfo.mi_info_req);
16490Sstevel@tonic-gate 	outstring(pri, ", ");
16500Sstevel@tonic-gate 	prt_dec(pri, 0, minfo.mi_info_count);
16510Sstevel@tonic-gate 	outstring(pri, ", ");
16520Sstevel@tonic-gate 	prt_hex(pri, 0, (long)minfo.mi_outdata);
16530Sstevel@tonic-gate 	outstring(pri, ", ");
16540Sstevel@tonic-gate 	prt_hex(pri, 0, (long)minfo.mi_validity);
16550Sstevel@tonic-gate }
16560Sstevel@tonic-gate 
16570Sstevel@tonic-gate 
16580Sstevel@tonic-gate /*
16590Sstevel@tonic-gate  * Print so_socket() 1st argument.
16600Sstevel@tonic-gate  */
16610Sstevel@tonic-gate /*ARGSUSED*/
16620Sstevel@tonic-gate void
16630Sstevel@tonic-gate prt_pfm(private_t *pri, int raw, long val)
16640Sstevel@tonic-gate {
16650Sstevel@tonic-gate 	/* Protocol Families have same names as Address Families */
16660Sstevel@tonic-gate 	if ((ulong_t)val < MAX_AFCODES) {
16670Sstevel@tonic-gate 		outstring(pri, "PF_");
16680Sstevel@tonic-gate 		outstring(pri, afcodes[val]);
16690Sstevel@tonic-gate 	} else {
16700Sstevel@tonic-gate 		prt_dec(pri, 0, val);
16710Sstevel@tonic-gate 	}
16720Sstevel@tonic-gate }
16730Sstevel@tonic-gate 
16740Sstevel@tonic-gate 
16750Sstevel@tonic-gate /*
16760Sstevel@tonic-gate  * Print so_socket() 2nd argument.
16770Sstevel@tonic-gate  */
16780Sstevel@tonic-gate /*ARGSUSED*/
16790Sstevel@tonic-gate void
16800Sstevel@tonic-gate prt_skt(private_t *pri, int raw, long val)
16810Sstevel@tonic-gate {
16820Sstevel@tonic-gate 	const char *s;
16830Sstevel@tonic-gate 
16840Sstevel@tonic-gate 	if ((ulong_t)val <= MAX_SOCKTYPES && (s = socktype_codes[val]) != NULL)
16850Sstevel@tonic-gate 		outstring(pri, s);
16860Sstevel@tonic-gate 	else
16870Sstevel@tonic-gate 		prt_dec(pri, 0, val);
16880Sstevel@tonic-gate }
16890Sstevel@tonic-gate 
16900Sstevel@tonic-gate 
16910Sstevel@tonic-gate /*
16920Sstevel@tonic-gate  * Print so_socket() 3rd argument.
16930Sstevel@tonic-gate  */
16940Sstevel@tonic-gate /*ARGSUSED*/
16950Sstevel@tonic-gate void
16960Sstevel@tonic-gate prt_skp(private_t *pri, int raw, long val)
16970Sstevel@tonic-gate {
16980Sstevel@tonic-gate 	const char *s;
16990Sstevel@tonic-gate 
17000Sstevel@tonic-gate 	/* cheating -- look at the protocol-family */
17010Sstevel@tonic-gate 	switch (pri->sys_args[0]) {
17020Sstevel@tonic-gate 	case PF_INET6:
17030Sstevel@tonic-gate 	case PF_INET:
17040Sstevel@tonic-gate 	case PF_NCA:	if ((s = ipprotos((int)val)) != NULL) {
17050Sstevel@tonic-gate 				outstring(pri, s);
17060Sstevel@tonic-gate 				break;
17070Sstevel@tonic-gate 			}
17080Sstevel@tonic-gate 			/* FALLTHROUGH */
17090Sstevel@tonic-gate 	default:	prt_dec(pri, 0, val);
17100Sstevel@tonic-gate 			break;
17110Sstevel@tonic-gate 	}
17120Sstevel@tonic-gate }
17130Sstevel@tonic-gate 
17140Sstevel@tonic-gate 
17150Sstevel@tonic-gate /*
17160Sstevel@tonic-gate  * Print so_socket() 5th argument.
17170Sstevel@tonic-gate  */
17180Sstevel@tonic-gate /*ARGSUSED*/
17190Sstevel@tonic-gate void
17200Sstevel@tonic-gate prt_skv(private_t *pri, int raw, long val)
17210Sstevel@tonic-gate {
17220Sstevel@tonic-gate 	switch (val) {
17230Sstevel@tonic-gate 	case SOV_STREAM:	outstring(pri, "SOV_STREAM");	break;
17240Sstevel@tonic-gate 	case SOV_DEFAULT:	outstring(pri, "SOV_DEFAULT");	break;
17250Sstevel@tonic-gate 	case SOV_SOCKSTREAM:	outstring(pri, "SOV_SOCKSTREAM");	break;
17260Sstevel@tonic-gate 	case SOV_SOCKBSD:	outstring(pri, "SOV_SOCKBSD");	break;
17270Sstevel@tonic-gate 	case SOV_XPG4_2:	outstring(pri, "SOV_XPG4_2");	break;
17280Sstevel@tonic-gate 	default:		prt_dec(pri, 0, val);		break;
17290Sstevel@tonic-gate 	}
17300Sstevel@tonic-gate }
17310Sstevel@tonic-gate 
17320Sstevel@tonic-gate 
17330Sstevel@tonic-gate /*
17340Sstevel@tonic-gate  * Print setsockopt()/getsockopt() 2nd argument.
17350Sstevel@tonic-gate  */
17360Sstevel@tonic-gate /*ARGSUSED*/
17370Sstevel@tonic-gate void
17380Sstevel@tonic-gate prt_sol(private_t *pri, int raw, long val)
17390Sstevel@tonic-gate {
17400Sstevel@tonic-gate 	if (val == SOL_SOCKET) {
17410Sstevel@tonic-gate 		outstring(pri, "SOL_SOCKET");
17420Sstevel@tonic-gate 	} else {
17430Sstevel@tonic-gate 		const struct protoent *p;
17440Sstevel@tonic-gate 		struct protoent res;
17450Sstevel@tonic-gate 		char buf[NSS_BUFLEN_PROTOCOLS];
17460Sstevel@tonic-gate 
17470Sstevel@tonic-gate 		if ((p = getprotobynumber_r(val, &res,
17480Sstevel@tonic-gate 		    (char *)buf, sizeof (buf))) != NULL)
17490Sstevel@tonic-gate 			outstring(pri, p->p_name);
17500Sstevel@tonic-gate 		else
17510Sstevel@tonic-gate 			prt_dec(pri, 0, val);
17520Sstevel@tonic-gate 	}
17530Sstevel@tonic-gate }
17540Sstevel@tonic-gate 
17550Sstevel@tonic-gate 
17560Sstevel@tonic-gate const char *
17570Sstevel@tonic-gate sol_optname(private_t *pri, long val)
17580Sstevel@tonic-gate {
17590Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
17600Sstevel@tonic-gate 	if (val >= SO_SNDBUF) {
17610Sstevel@tonic-gate 		switch (val) {
17620Sstevel@tonic-gate 		case SO_SNDBUF:		return ("SO_SNDBUF");
17630Sstevel@tonic-gate 		case SO_RCVBUF:		return ("SO_RCVBUF");
17640Sstevel@tonic-gate 		case SO_SNDLOWAT:	return ("SO_SNDLOWAT");
17650Sstevel@tonic-gate 		case SO_RCVLOWAT:	return ("SO_RCVLOWAT");
17660Sstevel@tonic-gate 		case SO_SNDTIMEO:	return ("SO_SNDTIMEO");
17670Sstevel@tonic-gate 		case SO_RCVTIMEO:	return ("SO_RCVTIMEO");
17680Sstevel@tonic-gate 		case SO_ERROR:		return ("SO_ERROR");
17690Sstevel@tonic-gate 		case SO_TYPE:		return ("SO_TYPE");
17700Sstevel@tonic-gate 		case SO_PROTOTYPE:	return ("SO_PROTOTYPE");
17712263Ssommerfe 		case SO_ALLZONES:	return ("SO_ALLZONES");
17722429Skcpoon 		case SO_EXCLBIND:	return ("SO_EXCLBIND");
17733388Skcpoon 		case SO_DOMAIN:		return ("SO_DOMAIN");
17740Sstevel@tonic-gate 
17750Sstevel@tonic-gate 		default:		(void) snprintf(pri->code_buf, CBSIZE,
1776*4217Seschrock 					    "0x%lx", val);
17770Sstevel@tonic-gate 					return (pri->code_buf);
17780Sstevel@tonic-gate 		}
17790Sstevel@tonic-gate 	} else {
17800Sstevel@tonic-gate 		char *s = pri->code_buf;
17810Sstevel@tonic-gate 		size_t used = 1;
17820Sstevel@tonic-gate 		long val2;
17830Sstevel@tonic-gate 
17840Sstevel@tonic-gate 		*s = '\0';
17850Sstevel@tonic-gate 		val2 = val & ~(SO_DEBUG|SO_ACCEPTCONN|SO_REUSEADDR|SO_KEEPALIVE|
17860Sstevel@tonic-gate 		    SO_DONTROUTE|SO_BROADCAST|SO_USELOOPBACK|SO_LINGER|
17870Sstevel@tonic-gate 		    SO_OOBINLINE|SO_DGRAM_ERRIND|SO_RECVUCRED);
17880Sstevel@tonic-gate 		if (val2)
17890Sstevel@tonic-gate 			used = snprintf(s, CBSIZE, "|0x%lx", val2);
17900Sstevel@tonic-gate 		if (val & SO_DEBUG)
17910Sstevel@tonic-gate 			used = strlcat(s, "|SO_DEBUG", CBSIZE);
17920Sstevel@tonic-gate 		if (val & SO_ACCEPTCONN)
17930Sstevel@tonic-gate 			used = strlcat(s, "|SO_ACCEPTCONN", CBSIZE);
17940Sstevel@tonic-gate 		if (val & SO_REUSEADDR)
17950Sstevel@tonic-gate 			used = strlcat(s, "|SO_REUSEADDR", CBSIZE);
17960Sstevel@tonic-gate 		if (val & SO_KEEPALIVE)
17970Sstevel@tonic-gate 			used = strlcat(s, "|SO_KEEPALIVE", CBSIZE);
17980Sstevel@tonic-gate 		if (val & SO_DONTROUTE)
17990Sstevel@tonic-gate 			used = strlcat(s, "|SO_DONTROUTE", CBSIZE);
18000Sstevel@tonic-gate 		if (val & SO_BROADCAST)
18010Sstevel@tonic-gate 			used = strlcat(s, "|SO_BROADCAST", CBSIZE);
18020Sstevel@tonic-gate 		if (val & SO_USELOOPBACK)
18030Sstevel@tonic-gate 			used = strlcat(s, "|SO_USELOOPBACK", CBSIZE);
18040Sstevel@tonic-gate 		if (val & SO_LINGER)
18050Sstevel@tonic-gate 			used = strlcat(s, "|SO_LINGER", CBSIZE);
18060Sstevel@tonic-gate 		if (val & SO_OOBINLINE)
18070Sstevel@tonic-gate 			used = strlcat(s, "|SO_OOBINLINE", CBSIZE);
18080Sstevel@tonic-gate 		if (val & SO_DGRAM_ERRIND)
18090Sstevel@tonic-gate 			used = strlcat(s, "|SO_DGRAM_ERRIND", CBSIZE);
18100Sstevel@tonic-gate 		if (val & SO_RECVUCRED)
18110Sstevel@tonic-gate 			used = strlcat(s, "|SO_RECVUCRED", CBSIZE);
18120Sstevel@tonic-gate 		if (used >= CBSIZE || val == 0)
18130Sstevel@tonic-gate 			(void) snprintf(s + 1, CBSIZE-1, "0x%lx", val);
18140Sstevel@tonic-gate 		return ((const char *)(s + 1));
18150Sstevel@tonic-gate 	}
18160Sstevel@tonic-gate #undef CBSIZE
18170Sstevel@tonic-gate }
18180Sstevel@tonic-gate 
18190Sstevel@tonic-gate 
18200Sstevel@tonic-gate const char *
18210Sstevel@tonic-gate tcp_optname(private_t *pri, long val)
18220Sstevel@tonic-gate {
18230Sstevel@tonic-gate 	switch (val) {
18240Sstevel@tonic-gate 	case TCP_NODELAY:		return ("TCP_NODELAY");
18250Sstevel@tonic-gate 	case TCP_MAXSEG:		return ("TCP_MAXSEG");
18260Sstevel@tonic-gate 	case TCP_KEEPALIVE:		return ("TCP_KEEPALIVE");
18270Sstevel@tonic-gate 	case TCP_NOTIFY_THRESHOLD:	return ("TCP_NOTIFY_THRESHOLD");
18280Sstevel@tonic-gate 	case TCP_ABORT_THRESHOLD:	return ("TCP_ABORT_THRESHOLD");
18290Sstevel@tonic-gate 	case TCP_CONN_NOTIFY_THRESHOLD:	return ("TCP_CONN_NOTIFY_THRESHOLD");
18300Sstevel@tonic-gate 	case TCP_CONN_ABORT_THRESHOLD:	return ("TCP_CONN_ABORT_THRESHOLD");
18310Sstevel@tonic-gate 	case TCP_RECVDSTADDR:		return ("TCP_RECVDSTADDR");
18320Sstevel@tonic-gate 	case TCP_ANONPRIVBIND:		return ("TCP_ANONPRIVBIND");
18330Sstevel@tonic-gate 	case TCP_EXCLBIND:		return ("TCP_EXCLBIND");
1834649Skcpoon 	case TCP_INIT_CWND:		return ("TCP_INIT_CWND");
1835649Skcpoon 	case TCP_KEEPALIVE_THRESHOLD:	return ("TCP_KEEPALIVE_THRESHOLD");
1836649Skcpoon 	case TCP_KEEPALIVE_ABORT_THRESHOLD:
1837649Skcpoon 		return ("TCP_KEEPALIVE_ABORT_THRESHOLD");
1838649Skcpoon 	case TCP_CORK:			return ("TCP_CORK");
18390Sstevel@tonic-gate 
18400Sstevel@tonic-gate 	default:			(void) snprintf(pri->code_buf,
18410Sstevel@tonic-gate 					    sizeof (pri->code_buf),
18420Sstevel@tonic-gate 					    "0x%lx", val);
18430Sstevel@tonic-gate 					return (pri->code_buf);
18440Sstevel@tonic-gate 	}
18450Sstevel@tonic-gate }
18460Sstevel@tonic-gate 
18470Sstevel@tonic-gate 
18480Sstevel@tonic-gate const char *
18490Sstevel@tonic-gate sctp_optname(private_t *pri, long val)
18500Sstevel@tonic-gate {
18510Sstevel@tonic-gate 	switch (val) {
18520Sstevel@tonic-gate 	case SCTP_RTOINFO:		return ("SCTP_RTOINFO");
18530Sstevel@tonic-gate 	case SCTP_ASSOCINFO:		return ("SCTP_ASSOCINFO");
18540Sstevel@tonic-gate 	case SCTP_INITMSG:		return ("SCTP_INITMSG");
18550Sstevel@tonic-gate 	case SCTP_NODELAY:		return ("SCTP_NODELAY");
18560Sstevel@tonic-gate 	case SCTP_AUTOCLOSE:		return ("SCTP_AUTOCLOSE");
18570Sstevel@tonic-gate 	case SCTP_SET_PEER_PRIMARY_ADDR:
18580Sstevel@tonic-gate 		return ("SCTP_SET_PEER_PRIMARY_ADDR");
18590Sstevel@tonic-gate 	case SCTP_PRIMARY_ADDR:		return ("SCTP_PRIMARY_ADDR");
18600Sstevel@tonic-gate 	case SCTP_ADAPTION_LAYER:	return ("SCTP_ADAPTION_LAYER");
18610Sstevel@tonic-gate 	case SCTP_DISABLE_FRAGMENTS:	return ("SCTP_DISABLE_FRAGMENTS");
18620Sstevel@tonic-gate 	case SCTP_PEER_ADDR_PARAMS:	return ("SCTP_PEER_ADDR_PARAMS");
18630Sstevel@tonic-gate 	case SCTP_DEFAULT_SEND_PARAM:	return ("SCTP_DEFAULT_SEND_PARAM");
18640Sstevel@tonic-gate 	case SCTP_EVENTS:		return ("SCTP_EVENTS");
18650Sstevel@tonic-gate 	case SCTP_I_WANT_MAPPED_V4_ADDR:
18660Sstevel@tonic-gate 		return ("SCTP_I_WANT_MAPPED_V4_ADDR");
18670Sstevel@tonic-gate 	case SCTP_MAXSEG:		return ("SCTP_MAXSEG");
18680Sstevel@tonic-gate 	case SCTP_STATUS:		return ("SCTP_STATUS");
18690Sstevel@tonic-gate 	case SCTP_GET_PEER_ADDR_INFO:	return ("SCTP_GET_PEER_ADDR_INFO");
18700Sstevel@tonic-gate 
18710Sstevel@tonic-gate 	case SCTP_ADD_ADDR:		return ("SCTP_ADD_ADDR");
18720Sstevel@tonic-gate 	case SCTP_REM_ADDR:		return ("SCTP_REM_ADDR");
18730Sstevel@tonic-gate 
18740Sstevel@tonic-gate 	default:			(void) snprintf(pri->code_buf,
18750Sstevel@tonic-gate 					    sizeof (pri->code_buf),
18760Sstevel@tonic-gate 					    "0x%lx", val);
18770Sstevel@tonic-gate 					return (pri->code_buf);
18780Sstevel@tonic-gate 	}
18790Sstevel@tonic-gate }
18800Sstevel@tonic-gate 
18810Sstevel@tonic-gate 
18820Sstevel@tonic-gate const char *
18830Sstevel@tonic-gate udp_optname(private_t *pri, long val)
18840Sstevel@tonic-gate {
1885649Skcpoon 	switch (val) {
1886649Skcpoon 	case UDP_CHECKSUM:		return ("UDP_CHECKSUM");
1887649Skcpoon 	case UDP_ANONPRIVBIND:		return ("UDP_ANONPRIVBIND");
1888649Skcpoon 	case UDP_EXCLBIND:		return ("UDP_EXCLBIND");
1889649Skcpoon 	case UDP_RCVHDR:		return ("UDP_RCVHDR");
18900Sstevel@tonic-gate 
1891649Skcpoon 	default:			(void) snprintf(pri->code_buf,
1892649Skcpoon 					    sizeof (pri->code_buf), "0x%lx",
1893649Skcpoon 					    val);
1894649Skcpoon 					return (pri->code_buf);
1895649Skcpoon 	}
18960Sstevel@tonic-gate }
18970Sstevel@tonic-gate 
18980Sstevel@tonic-gate 
18990Sstevel@tonic-gate /*
19000Sstevel@tonic-gate  * Print setsockopt()/getsockopt() 3rd argument.
19010Sstevel@tonic-gate  */
19020Sstevel@tonic-gate /*ARGSUSED*/
19030Sstevel@tonic-gate void
19040Sstevel@tonic-gate prt_son(private_t *pri, int raw, long val)
19050Sstevel@tonic-gate {
19060Sstevel@tonic-gate 	/* cheating -- look at the level */
19070Sstevel@tonic-gate 	switch (pri->sys_args[1]) {
19080Sstevel@tonic-gate 	case SOL_SOCKET:	outstring(pri, sol_optname(pri, val));
19090Sstevel@tonic-gate 				break;
19100Sstevel@tonic-gate 	case IPPROTO_TCP:	outstring(pri, tcp_optname(pri, val));
19110Sstevel@tonic-gate 				break;
19120Sstevel@tonic-gate 	case IPPROTO_UDP:	outstring(pri, udp_optname(pri, val));
19130Sstevel@tonic-gate 				break;
19140Sstevel@tonic-gate 	case IPPROTO_SCTP:	outstring(pri, sctp_optname(pri, val));
19150Sstevel@tonic-gate 				break;
19160Sstevel@tonic-gate 	default:		prt_dec(pri, 0, val);
19170Sstevel@tonic-gate 				break;
19180Sstevel@tonic-gate 	}
19190Sstevel@tonic-gate }
19200Sstevel@tonic-gate 
19210Sstevel@tonic-gate 
19220Sstevel@tonic-gate /*
19230Sstevel@tonic-gate  * Print utrap type
19240Sstevel@tonic-gate  */
19250Sstevel@tonic-gate /*ARGSUSED*/
19260Sstevel@tonic-gate void
19270Sstevel@tonic-gate prt_utt(private_t *pri, int raw, long val)
19280Sstevel@tonic-gate {
19290Sstevel@tonic-gate 	const char *s = NULL;
19300Sstevel@tonic-gate 
19310Sstevel@tonic-gate #ifdef __sparc
19320Sstevel@tonic-gate 	if (!raw) {
19330Sstevel@tonic-gate 		switch (val) {
19340Sstevel@tonic-gate 		case UT_INSTRUCTION_DISABLED:
19350Sstevel@tonic-gate 			s = "UT_INSTRUCTION_DISABLED"; break;
19360Sstevel@tonic-gate 		case UT_INSTRUCTION_ERROR:
19370Sstevel@tonic-gate 			s = "UT_INSTRUCTION_ERROR"; break;
19380Sstevel@tonic-gate 		case UT_INSTRUCTION_PROTECTION:
19390Sstevel@tonic-gate 			s = "UT_INSTRUCTION_PROTECTION"; break;
19400Sstevel@tonic-gate 		case UT_ILLTRAP_INSTRUCTION:
19410Sstevel@tonic-gate 			s = "UT_ILLTRAP_INSTRUCTION"; break;
19420Sstevel@tonic-gate 		case UT_ILLEGAL_INSTRUCTION:
19430Sstevel@tonic-gate 			s = "UT_ILLEGAL_INSTRUCTION"; break;
19440Sstevel@tonic-gate 		case UT_PRIVILEGED_OPCODE:
19450Sstevel@tonic-gate 			s = "UT_PRIVILEGED_OPCODE"; break;
19460Sstevel@tonic-gate 		case UT_FP_DISABLED:
19470Sstevel@tonic-gate 			s = "UT_FP_DISABLED"; break;
19480Sstevel@tonic-gate 		case UT_FP_EXCEPTION_IEEE_754:
19490Sstevel@tonic-gate 			s = "UT_FP_EXCEPTION_IEEE_754"; break;
19500Sstevel@tonic-gate 		case UT_FP_EXCEPTION_OTHER:
19510Sstevel@tonic-gate 			s = "UT_FP_EXCEPTION_OTHER"; break;
19520Sstevel@tonic-gate 		case UT_TAG_OVERFLOW:
19530Sstevel@tonic-gate 			s = "UT_TAG_OVERFLOW"; break;
19540Sstevel@tonic-gate 		case UT_DIVISION_BY_ZERO:
19550Sstevel@tonic-gate 			s = "UT_DIVISION_BY_ZERO"; break;
19560Sstevel@tonic-gate 		case UT_DATA_EXCEPTION:
19570Sstevel@tonic-gate 			s = "UT_DATA_EXCEPTION"; break;
19580Sstevel@tonic-gate 		case UT_DATA_ERROR:
19590Sstevel@tonic-gate 			s = "UT_DATA_ERROR"; break;
19600Sstevel@tonic-gate 		case UT_DATA_PROTECTION:
19610Sstevel@tonic-gate 			s = "UT_DATA_PROTECTION"; break;
19620Sstevel@tonic-gate 		case UT_MEM_ADDRESS_NOT_ALIGNED:
19630Sstevel@tonic-gate 			s = "UT_MEM_ADDRESS_NOT_ALIGNED"; break;
19640Sstevel@tonic-gate 		case UT_PRIVILEGED_ACTION:
19650Sstevel@tonic-gate 			s = "UT_PRIVILEGED_ACTION"; break;
19660Sstevel@tonic-gate 		case UT_ASYNC_DATA_ERROR:
19670Sstevel@tonic-gate 			s = "UT_ASYNC_DATA_ERROR"; break;
19680Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_16:
19690Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_16"; break;
19700Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_17:
19710Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_17"; break;
19720Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_18:
19730Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_18"; break;
19740Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_19:
19750Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_19"; break;
19760Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_20:
19770Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_20"; break;
19780Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_21:
19790Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_21"; break;
19800Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_22:
19810Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_22"; break;
19820Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_23:
19830Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_23"; break;
19840Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_24:
19850Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_24"; break;
19860Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_25:
19870Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_25"; break;
19880Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_26:
19890Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_26"; break;
19900Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_27:
19910Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_27"; break;
19920Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_28:
19930Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_28"; break;
19940Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_29:
19950Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_29"; break;
19960Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_30:
19970Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_30"; break;
19980Sstevel@tonic-gate 		case UT_TRAP_INSTRUCTION_31:
19990Sstevel@tonic-gate 			s = "UT_TRAP_INSTRUCTION_31"; break;
20000Sstevel@tonic-gate 		}
20010Sstevel@tonic-gate 	}
20020Sstevel@tonic-gate #endif /* __sparc */
20030Sstevel@tonic-gate 
20040Sstevel@tonic-gate 	if (s == NULL)
20050Sstevel@tonic-gate 		prt_dec(pri, 0, val);
20060Sstevel@tonic-gate 	else
20070Sstevel@tonic-gate 		outstring(pri, s);
20080Sstevel@tonic-gate }
20090Sstevel@tonic-gate 
20100Sstevel@tonic-gate 
20110Sstevel@tonic-gate /*
20120Sstevel@tonic-gate  * Print utrap handler
20130Sstevel@tonic-gate  */
20140Sstevel@tonic-gate void
20150Sstevel@tonic-gate prt_uth(private_t *pri, int raw, long val)
20160Sstevel@tonic-gate {
20170Sstevel@tonic-gate 	const char *s = NULL;
20180Sstevel@tonic-gate 
20190Sstevel@tonic-gate 	if (!raw) {
20200Sstevel@tonic-gate 		switch (val) {
20210Sstevel@tonic-gate 		case (long)UTH_NOCHANGE:	s = "UTH_NOCHANGE"; break;
20220Sstevel@tonic-gate 		}
20230Sstevel@tonic-gate 	}
20240Sstevel@tonic-gate 
20250Sstevel@tonic-gate 	if (s == NULL)
20260Sstevel@tonic-gate 		prt_hex(pri, 0, val);
20270Sstevel@tonic-gate 	else
20280Sstevel@tonic-gate 		outstring(pri, s);
20290Sstevel@tonic-gate }
20300Sstevel@tonic-gate 
20310Sstevel@tonic-gate const char *
20320Sstevel@tonic-gate access_flags(private_t *pri, long arg)
20330Sstevel@tonic-gate {
20340Sstevel@tonic-gate #define	E_OK 010
20350Sstevel@tonic-gate 	char *str = pri->code_buf;
20360Sstevel@tonic-gate 
20370Sstevel@tonic-gate 	if (arg & ~(R_OK|W_OK|X_OK|E_OK))
20380Sstevel@tonic-gate 		return (NULL);
20390Sstevel@tonic-gate 
20400Sstevel@tonic-gate 	/* NB: F_OK == 0 */
20410Sstevel@tonic-gate 	if (arg == F_OK)
20420Sstevel@tonic-gate 		return ("F_OK");
20430Sstevel@tonic-gate 	if (arg == E_OK)
20440Sstevel@tonic-gate 		return ("F_OK|E_OK");
20450Sstevel@tonic-gate 
20460Sstevel@tonic-gate 	*str = '\0';
20470Sstevel@tonic-gate 	if (arg & R_OK)
20480Sstevel@tonic-gate 		(void) strlcat(str, "|R_OK", sizeof (pri->code_buf));
20490Sstevel@tonic-gate 	if (arg & W_OK)
20500Sstevel@tonic-gate 		(void) strlcat(str, "|W_OK", sizeof (pri->code_buf));
20510Sstevel@tonic-gate 	if (arg & X_OK)
20520Sstevel@tonic-gate 		(void) strlcat(str, "|X_OK", sizeof (pri->code_buf));
20530Sstevel@tonic-gate 	if (arg & E_OK)
20540Sstevel@tonic-gate 		(void) strlcat(str, "|E_OK", sizeof (pri->code_buf));
20550Sstevel@tonic-gate 	return ((const char *)(str + 1));
20560Sstevel@tonic-gate #undef E_OK
20570Sstevel@tonic-gate }
20580Sstevel@tonic-gate 
20590Sstevel@tonic-gate /*
20600Sstevel@tonic-gate  * Print access() flags.
20610Sstevel@tonic-gate  */
20620Sstevel@tonic-gate void
20630Sstevel@tonic-gate prt_acc(private_t *pri, int raw, long val)
20640Sstevel@tonic-gate {
20650Sstevel@tonic-gate 	const char *s = raw? NULL : access_flags(pri, val);
20660Sstevel@tonic-gate 
20670Sstevel@tonic-gate 	if (s == NULL)
20680Sstevel@tonic-gate 		prt_dex(pri, 0, val);
20690Sstevel@tonic-gate 	else
20700Sstevel@tonic-gate 		outstring(pri, s);
20710Sstevel@tonic-gate }
20720Sstevel@tonic-gate 
20730Sstevel@tonic-gate /*
20740Sstevel@tonic-gate  * Print shutdown() "how" (2nd) argument
20750Sstevel@tonic-gate  */
20760Sstevel@tonic-gate void
20770Sstevel@tonic-gate prt_sht(private_t *pri, int raw, long val)
20780Sstevel@tonic-gate {
20790Sstevel@tonic-gate 	if (raw) {
20800Sstevel@tonic-gate 		prt_dex(pri, 0, val);
20810Sstevel@tonic-gate 		return;
20820Sstevel@tonic-gate 	}
20830Sstevel@tonic-gate 	switch (val) {
20840Sstevel@tonic-gate 	case SHUT_RD:	outstring(pri, "SHUT_RD");	break;
20850Sstevel@tonic-gate 	case SHUT_WR:	outstring(pri, "SHUT_WR");	break;
20860Sstevel@tonic-gate 	case SHUT_RDWR:	outstring(pri, "SHUT_RDWR");	break;
20870Sstevel@tonic-gate 	default:	prt_dec(pri, 0, val);		break;
20880Sstevel@tonic-gate 	}
20890Sstevel@tonic-gate }
20900Sstevel@tonic-gate 
20910Sstevel@tonic-gate /*
20920Sstevel@tonic-gate  * Print fcntl() F_SETFL flags (3rd) argument or fdsync flag (2nd arg)
20930Sstevel@tonic-gate  */
20940Sstevel@tonic-gate static struct fcntl_flags {
20950Sstevel@tonic-gate 	long		val;
20960Sstevel@tonic-gate 	const char	*name;
20970Sstevel@tonic-gate } fcntl_flags[] = {
20980Sstevel@tonic-gate #define	FC_FL(flag)	{ (long)flag, "|" # flag }
20990Sstevel@tonic-gate #ifdef C2_AUDIT
21000Sstevel@tonic-gate 	FC_FL(FREVOKED),
21010Sstevel@tonic-gate #endif
21020Sstevel@tonic-gate 	FC_FL(FREAD),
21030Sstevel@tonic-gate 	FC_FL(FWRITE),
21040Sstevel@tonic-gate 	FC_FL(FNDELAY),
21050Sstevel@tonic-gate 	FC_FL(FAPPEND),
21060Sstevel@tonic-gate 	FC_FL(FSYNC),
21070Sstevel@tonic-gate 	FC_FL(FDSYNC),
21080Sstevel@tonic-gate 	FC_FL(FRSYNC),
21090Sstevel@tonic-gate 	FC_FL(FOFFMAX),
21100Sstevel@tonic-gate 	FC_FL(FNONBLOCK),
21110Sstevel@tonic-gate 	FC_FL(FCREAT),
21120Sstevel@tonic-gate 	FC_FL(FTRUNC),
21130Sstevel@tonic-gate 	FC_FL(FEXCL),
21140Sstevel@tonic-gate 	FC_FL(FNOCTTY),
21150Sstevel@tonic-gate 	FC_FL(FXATTR),
21160Sstevel@tonic-gate 	FC_FL(FASYNC),
21170Sstevel@tonic-gate 	FC_FL(FNODSYNC)
21180Sstevel@tonic-gate #undef FC_FL
21190Sstevel@tonic-gate };
21200Sstevel@tonic-gate 
21210Sstevel@tonic-gate void
21220Sstevel@tonic-gate prt_ffg(private_t *pri, int raw, long val)
21230Sstevel@tonic-gate {
21240Sstevel@tonic-gate #define	CBSIZE	sizeof (pri->code_buf)
21250Sstevel@tonic-gate 	char *s = pri->code_buf;
21260Sstevel@tonic-gate 	size_t used = 1;
21270Sstevel@tonic-gate 	struct fcntl_flags *fp;
21280Sstevel@tonic-gate 
21290Sstevel@tonic-gate 	if (raw) {
21300Sstevel@tonic-gate 		(void) snprintf(s, CBSIZE, "0x%lx", val);
21310Sstevel@tonic-gate 		outstring(pri, s);
21320Sstevel@tonic-gate 		return;
21330Sstevel@tonic-gate 	}
21340Sstevel@tonic-gate 	if (val == 0) {
21350Sstevel@tonic-gate 		outstring(pri, "(no flags)");
21360Sstevel@tonic-gate 		return;
21370Sstevel@tonic-gate 	}
21380Sstevel@tonic-gate 
21390Sstevel@tonic-gate 	*s = '\0';
21400Sstevel@tonic-gate 	for (fp = fcntl_flags;
21410Sstevel@tonic-gate 	    fp < &fcntl_flags[sizeof (fcntl_flags) / sizeof (*fp)]; fp++) {
21420Sstevel@tonic-gate 		if (val & fp->val) {
21430Sstevel@tonic-gate 			used = strlcat(s, fp->name, CBSIZE);
21440Sstevel@tonic-gate 			val &= ~fp->val;
21450Sstevel@tonic-gate 		}
21460Sstevel@tonic-gate 	}
21470Sstevel@tonic-gate 
21480Sstevel@tonic-gate 	if (val != 0 && used <= CBSIZE)
21490Sstevel@tonic-gate 		used += snprintf(s + used, CBSIZE - used, "|0x%lx", val);
21500Sstevel@tonic-gate 
21510Sstevel@tonic-gate 	if (used >= CBSIZE)
21520Sstevel@tonic-gate 		(void) snprintf(s + 1, CBSIZE-1, "0x%lx", val);
21530Sstevel@tonic-gate 	outstring(pri, s + 1);
21540Sstevel@tonic-gate #undef CBSIZE
21550Sstevel@tonic-gate }
21560Sstevel@tonic-gate 
21570Sstevel@tonic-gate void
21580Sstevel@tonic-gate prt_prs(private_t *pri, int raw, long val)
21590Sstevel@tonic-gate {
21600Sstevel@tonic-gate 	static size_t setsize;
21610Sstevel@tonic-gate 	priv_set_t *set = priv_allocset();
21620Sstevel@tonic-gate 
21630Sstevel@tonic-gate 	if (setsize == 0) {
21640Sstevel@tonic-gate 		const priv_impl_info_t *info = getprivimplinfo();
21650Sstevel@tonic-gate 		if (info != NULL)
21660Sstevel@tonic-gate 			setsize = info->priv_setsize * sizeof (priv_chunk_t);
21670Sstevel@tonic-gate 	}
21680Sstevel@tonic-gate 
21690Sstevel@tonic-gate 	if (setsize != 0 && !raw && set != NULL &&
21700Sstevel@tonic-gate 	    Pread(Proc, set, setsize, val) == setsize) {
21710Sstevel@tonic-gate 		int i;
21720Sstevel@tonic-gate 
21730Sstevel@tonic-gate 		outstring(pri, "{");
21740Sstevel@tonic-gate 		for (i = 0; i < setsize / sizeof (priv_chunk_t); i++) {
21750Sstevel@tonic-gate 			char buf[9];	/* 8 hex digits + '\0' */
21760Sstevel@tonic-gate 			(void) snprintf(buf, sizeof (buf), "%08x",
21770Sstevel@tonic-gate 			    ((priv_chunk_t *)set)[i]);
21780Sstevel@tonic-gate 			outstring(pri, buf);
21790Sstevel@tonic-gate 		}
21800Sstevel@tonic-gate 
21810Sstevel@tonic-gate 		outstring(pri, "}");
21820Sstevel@tonic-gate 	} else {
21830Sstevel@tonic-gate 		prt_hex(pri, 0, val);
21840Sstevel@tonic-gate 	}
21850Sstevel@tonic-gate 
21860Sstevel@tonic-gate 	if (set != NULL)
21870Sstevel@tonic-gate 		priv_freeset(set);
21880Sstevel@tonic-gate }
21890Sstevel@tonic-gate 
21900Sstevel@tonic-gate /*
21910Sstevel@tonic-gate  * Print privilege set operation.
21920Sstevel@tonic-gate  */
21930Sstevel@tonic-gate void
21940Sstevel@tonic-gate prt_pro(private_t *pri, int raw, long val)
21950Sstevel@tonic-gate {
21960Sstevel@tonic-gate 	const char *s = NULL;
21970Sstevel@tonic-gate 
21980Sstevel@tonic-gate 	if (!raw) {
21990Sstevel@tonic-gate 		switch ((priv_op_t)val) {
22000Sstevel@tonic-gate 		case PRIV_ON:		s = "PRIV_ON";		break;
22010Sstevel@tonic-gate 		case PRIV_OFF:		s = "PRIV_OFF";		break;
22020Sstevel@tonic-gate 		case PRIV_SET:		s = "PRIV_SET";		break;
22030Sstevel@tonic-gate 		}
22040Sstevel@tonic-gate 	}
22050Sstevel@tonic-gate 
22060Sstevel@tonic-gate 	if (s == NULL)
22070Sstevel@tonic-gate 		prt_dec(pri, 0, val);
22080Sstevel@tonic-gate 	else
22090Sstevel@tonic-gate 		outstring(pri, s);
22100Sstevel@tonic-gate }
22110Sstevel@tonic-gate 
22120Sstevel@tonic-gate /*
22130Sstevel@tonic-gate  * Print privilege set name
22140Sstevel@tonic-gate  */
22150Sstevel@tonic-gate void
22160Sstevel@tonic-gate prt_prn(private_t *pri, int raw, long val)
22170Sstevel@tonic-gate {
22180Sstevel@tonic-gate 	const char *s = NULL;
22190Sstevel@tonic-gate 
22200Sstevel@tonic-gate 	if (!raw)
22210Sstevel@tonic-gate 		s = priv_getsetbynum((int)val);
22220Sstevel@tonic-gate 
22230Sstevel@tonic-gate 	if (s == NULL)
22240Sstevel@tonic-gate 		prt_dec(pri, 0, val);
22250Sstevel@tonic-gate 	else {
22260Sstevel@tonic-gate 		char *dup = strdup(s);
22270Sstevel@tonic-gate 		char *q;
22280Sstevel@tonic-gate 
22290Sstevel@tonic-gate 		/* Do the best we can in this case */
22300Sstevel@tonic-gate 		if (dup == NULL) {
22310Sstevel@tonic-gate 			outstring(pri, s);
22320Sstevel@tonic-gate 			return;
22330Sstevel@tonic-gate 		}
22340Sstevel@tonic-gate 
22350Sstevel@tonic-gate 		outstring(pri, "PRIV_");
22360Sstevel@tonic-gate 
22370Sstevel@tonic-gate 		q = dup;
22380Sstevel@tonic-gate 
22390Sstevel@tonic-gate 		while (*q != '\0') {
22400Sstevel@tonic-gate 			*q = toupper(*q);
22410Sstevel@tonic-gate 			q++;
22420Sstevel@tonic-gate 		}
22430Sstevel@tonic-gate 		outstring(pri, dup);
22440Sstevel@tonic-gate 		free(dup);
22450Sstevel@tonic-gate 	}
22460Sstevel@tonic-gate }
22470Sstevel@tonic-gate 
22480Sstevel@tonic-gate /*
22490Sstevel@tonic-gate  * Print process flag names.
22500Sstevel@tonic-gate  */
22510Sstevel@tonic-gate void
22520Sstevel@tonic-gate prt_pfl(private_t *pri, int raw, long val)
22530Sstevel@tonic-gate {
22540Sstevel@tonic-gate 	const char *s = NULL;
22550Sstevel@tonic-gate 
22560Sstevel@tonic-gate 	if (!raw) {
22570Sstevel@tonic-gate 		switch ((int)val) {
22580Sstevel@tonic-gate 		case PRIV_DEBUG:	s = "PRIV_DEBUG";	break;
22590Sstevel@tonic-gate 		case PRIV_AWARE:	s = "PRIV_AWARE";	break;
22600Sstevel@tonic-gate 		}
22610Sstevel@tonic-gate 	}
22620Sstevel@tonic-gate 
22630Sstevel@tonic-gate 	if (s == NULL)
22640Sstevel@tonic-gate 		prt_dec(pri, 0, val);
22650Sstevel@tonic-gate 	else
22660Sstevel@tonic-gate 		outstring(pri, s);
22670Sstevel@tonic-gate }
22680Sstevel@tonic-gate 
22690Sstevel@tonic-gate /*
22700Sstevel@tonic-gate  * Print lgrp_affinity_{get,set}() arguments.
22710Sstevel@tonic-gate  */
22720Sstevel@tonic-gate /*ARGSUSED*/
22730Sstevel@tonic-gate void
22740Sstevel@tonic-gate prt_laf(private_t *pri, int raw, long val)
22750Sstevel@tonic-gate {
22760Sstevel@tonic-gate 	lgrp_affinity_args_t	laff;
22770Sstevel@tonic-gate 
22780Sstevel@tonic-gate 	if (Pread(Proc, &laff, sizeof (lgrp_affinity_args_t), val) !=
2279*4217Seschrock 	    sizeof (lgrp_affinity_args_t)) {
22800Sstevel@tonic-gate 		prt_hex(pri, 0, val);
22810Sstevel@tonic-gate 		return;
22820Sstevel@tonic-gate 	}
22830Sstevel@tonic-gate 	/*
22840Sstevel@tonic-gate 	 * arrange the arguments in the order that user calls with
22850Sstevel@tonic-gate 	 */
22860Sstevel@tonic-gate 	prt_dec(pri, 0, laff.idtype);
22870Sstevel@tonic-gate 	outstring(pri, ", ");
22880Sstevel@tonic-gate 	prt_dec(pri, 0, laff.id);
22890Sstevel@tonic-gate 	outstring(pri, ", ");
22900Sstevel@tonic-gate 	prt_dec(pri, 0, laff.lgrp);
22910Sstevel@tonic-gate 	outstring(pri, ", ");
22920Sstevel@tonic-gate 	if (pri->sys_args[0] == LGRP_SYS_AFFINITY_SET)
22930Sstevel@tonic-gate 		prt_dec(pri, 0, laff.aff);
22940Sstevel@tonic-gate }
22950Sstevel@tonic-gate 
22960Sstevel@tonic-gate /*
22970Sstevel@tonic-gate  * Print a key_t as IPC_PRIVATE if it is 0.
22980Sstevel@tonic-gate  */
22990Sstevel@tonic-gate void
23000Sstevel@tonic-gate prt_key(private_t *pri, int raw, long val)
23010Sstevel@tonic-gate {
23020Sstevel@tonic-gate 	if (!raw && val == 0)
23030Sstevel@tonic-gate 		outstring(pri, "IPC_PRIVATE");
23040Sstevel@tonic-gate 	else
23050Sstevel@tonic-gate 		prt_dec(pri, 0, val);
23060Sstevel@tonic-gate }
23070Sstevel@tonic-gate 
23080Sstevel@tonic-gate 
23090Sstevel@tonic-gate /*
23100Sstevel@tonic-gate  * Print zone_getattr() attribute types.
23110Sstevel@tonic-gate  */
23120Sstevel@tonic-gate void
23130Sstevel@tonic-gate prt_zga(private_t *pri, int raw, long val)
23140Sstevel@tonic-gate {
23150Sstevel@tonic-gate 	const char *s = NULL;
23160Sstevel@tonic-gate 
23170Sstevel@tonic-gate 	if (!raw) {
23180Sstevel@tonic-gate 		switch ((int)val) {
23190Sstevel@tonic-gate 		case ZONE_ATTR_NAME:	s = "ZONE_ATTR_NAME";	break;
23200Sstevel@tonic-gate 		case ZONE_ATTR_ROOT:	s = "ZONE_ATTR_ROOT";	break;
23210Sstevel@tonic-gate 		case ZONE_ATTR_STATUS:	s = "ZONE_ATTR_STATUS";	break;
23220Sstevel@tonic-gate 		case ZONE_ATTR_PRIVSET:	s = "ZONE_ATTR_PRIVSET"; break;
23230Sstevel@tonic-gate 		case ZONE_ATTR_UNIQID:	s = "ZONE_ATTR_UNIQID"; break;
23240Sstevel@tonic-gate 		case ZONE_ATTR_POOLID:	s = "ZONE_ATTR_POOLID"; break;
23250Sstevel@tonic-gate 		case ZONE_ATTR_INITPID:	s = "ZONE_ATTR_INITPID"; break;
23261676Sjpk 		case ZONE_ATTR_SLBL:	s = "ZONE_ATTR_SLBL"; break;
23272267Sdp 		case ZONE_ATTR_INITNAME:	s = "ZONE_ATTR_INITNAME"; break;
23282267Sdp 		case ZONE_ATTR_BOOTARGS:	s = "ZONE_ATTR_BOOTARGS"; break;
23293009Snn35248 		case ZONE_ATTR_BRAND:	s = "ZONE_ATTR_BRAND"; break;
23303448Sdh155122 		case ZONE_ATTR_FLAGS:	s = "ZONE_ATTR_FLAGS"; break;
23313247Sgjelinek 		case ZONE_ATTR_PHYS_MCAP: s = "ZONE_ATTR_PHYS_MCAP"; break;
23320Sstevel@tonic-gate 		}
23330Sstevel@tonic-gate 	}
23340Sstevel@tonic-gate 
23350Sstevel@tonic-gate 	if (s == NULL)
23360Sstevel@tonic-gate 		prt_dec(pri, 0, val);
23370Sstevel@tonic-gate 	else
23380Sstevel@tonic-gate 		outstring(pri, s);
23390Sstevel@tonic-gate }
23400Sstevel@tonic-gate 
23410Sstevel@tonic-gate /*
23420Sstevel@tonic-gate  * Print a file descriptor as AT_FDCWD if necessary
23430Sstevel@tonic-gate  */
23440Sstevel@tonic-gate void
23450Sstevel@tonic-gate prt_atc(private_t *pri, int raw, long val)
23460Sstevel@tonic-gate {
23470Sstevel@tonic-gate 	if (!raw && val == AT_FDCWD)
23480Sstevel@tonic-gate 		outstring(pri, "AT_FDCWD");
23490Sstevel@tonic-gate 	else
23500Sstevel@tonic-gate 		prt_dec(pri, 0, val);
23510Sstevel@tonic-gate }
23520Sstevel@tonic-gate 
23530Sstevel@tonic-gate /*
23541676Sjpk  * Print Trusted Networking database operation codes (labelsys; tn*)
23551676Sjpk  */
23561676Sjpk static void
23571676Sjpk prt_tnd(private_t *pri, int raw, long val)
23581676Sjpk {
23591676Sjpk 	const char *s = NULL;
23601676Sjpk 
23611676Sjpk 	if (!raw) {
23621676Sjpk 		switch ((tsol_dbops_t)val) {
23631676Sjpk 		case TNDB_NOOP:		s = "TNDB_NOOP";	break;
23641676Sjpk 		case TNDB_LOAD:		s = "TNDB_LOAD";	break;
23651676Sjpk 		case TNDB_DELETE:	s = "TNDB_DELETE";	break;
23661676Sjpk 		case TNDB_FLUSH:	s = "TNDB_FLUSH";	break;
23671676Sjpk 		case TNDB_GET:		s = "TNDB_GET";		break;
23681676Sjpk 		}
23691676Sjpk 	}
23701676Sjpk 
23711676Sjpk 	if (s == NULL)
23721676Sjpk 		prt_dec(pri, 0, val);
23731676Sjpk 	else
23741676Sjpk 		outstring(pri, s);
23751676Sjpk }
23761676Sjpk 
23771676Sjpk /*
23780Sstevel@tonic-gate  * Print LIO_XX flags
23790Sstevel@tonic-gate  */
23800Sstevel@tonic-gate void
23810Sstevel@tonic-gate prt_lio(private_t *pri, int raw, long val)
23820Sstevel@tonic-gate {
23830Sstevel@tonic-gate 	if (raw)
23840Sstevel@tonic-gate 		prt_dec(pri, 0, val);
23850Sstevel@tonic-gate 	else if (val == LIO_WAIT)
23860Sstevel@tonic-gate 		outstring(pri, "LIO_WAIT");
23870Sstevel@tonic-gate 	else if (val == LIO_NOWAIT)
23880Sstevel@tonic-gate 		outstring(pri, "LIO_NOWAIT");
23890Sstevel@tonic-gate 	else
23900Sstevel@tonic-gate 		prt_dec(pri, 0, val);
23910Sstevel@tonic-gate }
23920Sstevel@tonic-gate 
23930Sstevel@tonic-gate const char *
23940Sstevel@tonic-gate door_flags(private_t *pri, long val)
23950Sstevel@tonic-gate {
23960Sstevel@tonic-gate 	door_attr_t attr = (door_attr_t)val;
23970Sstevel@tonic-gate 	char *str = pri->code_buf;
23980Sstevel@tonic-gate 
23990Sstevel@tonic-gate 	*str = '\0';
24000Sstevel@tonic-gate #define	PROCESS_FLAG(flg)						\
24010Sstevel@tonic-gate 	if (attr & flg) {						\
24020Sstevel@tonic-gate 		(void) strlcat(str, "|" #flg, sizeof (pri->code_buf));	\
24030Sstevel@tonic-gate 		attr &= ~flg;						\
24040Sstevel@tonic-gate 	}
24050Sstevel@tonic-gate 
24060Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_UNREF);
24070Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_UNREF_MULTI);
24080Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_PRIVATE);
24090Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_REFUSE_DESC);
24100Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_NO_CANCEL);
24110Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_LOCAL);
24120Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_REVOKED);
24130Sstevel@tonic-gate 	PROCESS_FLAG(DOOR_IS_UNREF);
24140Sstevel@tonic-gate #undef PROCESS_FLAG
24150Sstevel@tonic-gate 
24160Sstevel@tonic-gate 	if (attr != 0 || *str == '\0') {
24170Sstevel@tonic-gate 		size_t len = strlen(str);
24180Sstevel@tonic-gate 		(void) snprintf(str + len, sizeof (pri->code_buf) - len,
24190Sstevel@tonic-gate 		    "|0x%X", attr);
24200Sstevel@tonic-gate 	}
24210Sstevel@tonic-gate 
24220Sstevel@tonic-gate 	return (str + 1);
24230Sstevel@tonic-gate }
24240Sstevel@tonic-gate 
24250Sstevel@tonic-gate /*
24260Sstevel@tonic-gate  * Print door_create() flags
24270Sstevel@tonic-gate  */
24280Sstevel@tonic-gate void
24290Sstevel@tonic-gate prt_dfl(private_t *pri, int raw, long val)
24300Sstevel@tonic-gate {
24310Sstevel@tonic-gate 	if (raw)
24320Sstevel@tonic-gate 		prt_hex(pri, 0, val);
24330Sstevel@tonic-gate 	else
24340Sstevel@tonic-gate 		outstring(pri, door_flags(pri, val));
24350Sstevel@tonic-gate }
24360Sstevel@tonic-gate 
24370Sstevel@tonic-gate /*
24380Sstevel@tonic-gate  * Print door_*param() param argument
24390Sstevel@tonic-gate  */
24400Sstevel@tonic-gate void
24410Sstevel@tonic-gate prt_dpm(private_t *pri, int raw, long val)
24420Sstevel@tonic-gate {
24430Sstevel@tonic-gate 	if (raw)
24440Sstevel@tonic-gate 		prt_hex(pri, 0, val);
24450Sstevel@tonic-gate 	else if (val == DOOR_PARAM_DESC_MAX)
24460Sstevel@tonic-gate 		outstring(pri, "DOOR_PARAM_DESC_MAX");
24470Sstevel@tonic-gate 	else if (val == DOOR_PARAM_DATA_MIN)
24480Sstevel@tonic-gate 		outstring(pri, "DOOR_PARAM_DATA_MIN");
24490Sstevel@tonic-gate 	else if (val == DOOR_PARAM_DATA_MAX)
24500Sstevel@tonic-gate 		outstring(pri, "DOOR_PARAM_DATA_MAX");
24510Sstevel@tonic-gate 	else
24520Sstevel@tonic-gate 		prt_hex(pri, 0, val);
24530Sstevel@tonic-gate }
24540Sstevel@tonic-gate 
24550Sstevel@tonic-gate /*
24562447Snf202958  * Print rctlsys subcodes
24572447Snf202958  */
24582447Snf202958 void
24592447Snf202958 prt_rsc(private_t *pri, int raw, long val)	/* print utssys code */
24602447Snf202958 {
24612447Snf202958 	const char *s = raw? NULL : rctlsyscode(val);
24622447Snf202958 
24632447Snf202958 	if (s == NULL)
24642447Snf202958 		prt_dec(pri, 0, val);
24652447Snf202958 	else
24662447Snf202958 		outstring(pri, s);
24672447Snf202958 }
24682447Snf202958 
24692447Snf202958 /*
24702447Snf202958  * Print getrctl flags
24712447Snf202958  */
24722447Snf202958 void
24732447Snf202958 prt_rgf(private_t *pri, int raw, long val)
24742447Snf202958 {
24752447Snf202958 	long action = val & (~RCTLSYS_ACTION_MASK);
24762447Snf202958 
24772447Snf202958 	if (raw)
24782447Snf202958 		prt_hex(pri, 0, val);
24792447Snf202958 	else if (action == RCTL_FIRST)
24802447Snf202958 		outstring(pri, "RCTL_FIRST");
24812447Snf202958 	else if (action == RCTL_NEXT)
24822447Snf202958 		outstring(pri, "RCTL_NEXT");
24832447Snf202958 	else if (action == RCTL_USAGE)
24842447Snf202958 		outstring(pri, "RCTL_USAGE");
24852447Snf202958 	else
24862447Snf202958 		prt_hex(pri, 0, val);
24872447Snf202958 }
24882447Snf202958 
24892447Snf202958 /*
24902447Snf202958  * Print setrctl flags
24912447Snf202958  */
24922447Snf202958 void
24932447Snf202958 prt_rsf(private_t *pri, int raw, long val)
24942447Snf202958 {
24952447Snf202958 	long action = val & (~RCTLSYS_ACTION_MASK);
24962447Snf202958 	long pval = val & RCTL_LOCAL_ACTION_MASK;
24972447Snf202958 	char *s = pri->code_buf;
24982447Snf202958 
24992447Snf202958 	if (raw) {
25002447Snf202958 		prt_hex(pri, 0, val);
25012447Snf202958 		return;
25022447Snf202958 	} else if (action == RCTL_INSERT)
25032447Snf202958 		(void) strcpy(s, "RCTL_INSERT");
25042447Snf202958 	else if (action == RCTL_DELETE)
25052447Snf202958 		(void) strcpy(s, "RCTL_DELETE");
25062447Snf202958 	else if (action == RCTL_REPLACE)
25072447Snf202958 		(void) strcpy(s, "RCTL_REPLACE");
25082447Snf202958 	else {
25092447Snf202958 		prt_hex(pri, 0, val);
25102447Snf202958 		return;
25112447Snf202958 	}
25122447Snf202958 
25132447Snf202958 	if (pval & RCTL_USE_RECIPIENT_PID) {
25142447Snf202958 		pval ^= RCTL_USE_RECIPIENT_PID;
25152447Snf202958 		(void) strlcat(s, "|RCTL_USE_RECIPIENT_PID",
25162447Snf202958 		    sizeof (pri->code_buf));
25172447Snf202958 	}
25182447Snf202958 
25192447Snf202958 	if ((pval & RCTLSYS_ACTION_MASK) != 0)
25202447Snf202958 		prt_hex(pri, 0, val);
25212447Snf202958 	else if (*s != '\0')
25222447Snf202958 		outstring(pri, s);
25232447Snf202958 	else
25242447Snf202958 		prt_hex(pri, 0, val);
25252447Snf202958 }
25262447Snf202958 
25272447Snf202958 /*
25282447Snf202958  * Print rctlctl flags
25292447Snf202958  */
25302447Snf202958 void
25312447Snf202958 prt_rcf(private_t *pri, int raw, long val)
25322447Snf202958 {
25332447Snf202958 	long action = val & (~RCTLSYS_ACTION_MASK);
25342447Snf202958 
25352447Snf202958 	if (raw)
25362447Snf202958 		prt_hex(pri, 0, val);
25372447Snf202958 	else if (action == RCTLCTL_GET)
25382447Snf202958 		outstring(pri, "RCTLCTL_GET");
25392447Snf202958 	else if (action == RCTLCTL_SET)
25402447Snf202958 		outstring(pri, "RCTLCTL_SET");
25412447Snf202958 	else
25422447Snf202958 		prt_hex(pri, 0, val);
25432447Snf202958 }
25442447Snf202958 
25453235Sraf /*
25463684Srd117015  * Print setprojrctl flags
25473684Srd117015  */
25483684Srd117015 void
25493684Srd117015 prt_spf(private_t *pri, int raw, long val)
25503684Srd117015 {
25513684Srd117015 	long action = val & TASK_PROJ_MASK;
25523684Srd117015 
25533684Srd117015 	if (!raw && (action == TASK_PROJ_PURGE))
25543684Srd117015 		outstring(pri, "TASK_PROJ_PURGE");
25553684Srd117015 	else
25563684Srd117015 		prt_hex(pri, 0, val);
25573684Srd117015 }
25583684Srd117015 
25593684Srd117015 /*
25603235Sraf  * Print forkx() flags
25613235Sraf  */
25623235Sraf void
25633235Sraf prt_fxf(private_t *pri, int raw, long val)
25643235Sraf {
25653235Sraf 	char *str;
25663235Sraf 
25673235Sraf 	if (val == 0)
25683235Sraf 		outstring(pri, "0");
25693235Sraf 	else if (raw || (val & ~(FORK_NOSIGCHLD | FORK_WAITPID)))
25703235Sraf 		prt_hhx(pri, 0, val);
25713235Sraf 	else {
25723235Sraf 		str = pri->code_buf;
25733235Sraf 		*str = '\0';
25743235Sraf 		if (val & FORK_NOSIGCHLD)
25753235Sraf 			(void) strlcat(str, "|FORK_NOSIGCHLD",
25763235Sraf 			    sizeof (pri->code_buf));
25773235Sraf 		if (val & FORK_WAITPID)
25783235Sraf 			(void) strlcat(str, "|FORK_WAITPID",
25793235Sraf 			    sizeof (pri->code_buf));
25803235Sraf 		outstring(pri, str + 1);
25813235Sraf 	}
25823235Sraf }
25832447Snf202958 
25842447Snf202958 /*
25850Sstevel@tonic-gate  * Array of pointers to print functions, one for each format.
25860Sstevel@tonic-gate  */
25870Sstevel@tonic-gate void (* const Print[])() = {
25880Sstevel@tonic-gate 	prt_nov,	/* NOV -- no value */
25890Sstevel@tonic-gate 	prt_dec,	/* DEC -- print value in decimal */
25900Sstevel@tonic-gate 	prt_oct,	/* OCT -- print value in octal */
25910Sstevel@tonic-gate 	prt_hex,	/* HEX -- print value in hexadecimal */
25920Sstevel@tonic-gate 	prt_dex,	/* DEX -- print value in hexadecimal if big enough */
25930Sstevel@tonic-gate 	prt_stg,	/* STG -- print value as string */
25940Sstevel@tonic-gate 	prt_ioc,	/* IOC -- print ioctl code */
25950Sstevel@tonic-gate 	prt_fcn,	/* FCN -- print fcntl code */
25960Sstevel@tonic-gate 	prt_s86,	/* S86 -- print sysi86 code */
25970Sstevel@tonic-gate 	prt_uts,	/* UTS -- print utssys code */
25980Sstevel@tonic-gate 	prt_opn,	/* OPN -- print open code */
25990Sstevel@tonic-gate 	prt_sig,	/* SIG -- print signal name plus flags */
26000Sstevel@tonic-gate 	prt_act,	/* ACT -- print signal action value */
26010Sstevel@tonic-gate 	prt_msc,	/* MSC -- print msgsys command */
26020Sstevel@tonic-gate 	prt_msf,	/* MSF -- print msgsys flags */
26030Sstevel@tonic-gate 	prt_smc,	/* SMC -- print semsys command */
26040Sstevel@tonic-gate 	prt_sef,	/* SEF -- print semsys flags */
26050Sstevel@tonic-gate 	prt_shc,	/* SHC -- print shmsys command */
26060Sstevel@tonic-gate 	prt_shf,	/* SHF -- print shmsys flags */
26070Sstevel@tonic-gate 	prt_plk,	/* PLK -- print plock code */
26080Sstevel@tonic-gate 	prt_sfs,	/* SFS -- print sysfs code */
26090Sstevel@tonic-gate 	prt_rst,	/* RST -- print string returned by syscall */
26100Sstevel@tonic-gate 	prt_smf,	/* SMF -- print streams message flags */
26110Sstevel@tonic-gate 	prt_ioa,	/* IOA -- print ioctl argument */
26120Sstevel@tonic-gate 	prt_six,	/* SIX -- print signal, masked with SIGNO_MASK */
26130Sstevel@tonic-gate 	prt_mtf,	/* MTF -- print mount flags */
26140Sstevel@tonic-gate 	prt_mft,	/* MFT -- print mount file system type */
26150Sstevel@tonic-gate 	prt_iob,	/* IOB -- print contents of I/O buffer */
26160Sstevel@tonic-gate 	prt_hhx,	/* HHX -- print value in hexadecimal (half size) */
26170Sstevel@tonic-gate 	prt_wop,	/* WOP -- print waitsys() options */
26180Sstevel@tonic-gate 	prt_spm,	/* SPM -- print sigprocmask argument */
26190Sstevel@tonic-gate 	prt_rlk,	/* RLK -- print readlink buffer */
26200Sstevel@tonic-gate 	prt_mpr,	/* MPR -- print mmap()/mprotect() flags */
26210Sstevel@tonic-gate 	prt_mty,	/* MTY -- print mmap() mapping type flags */
26220Sstevel@tonic-gate 	prt_mcf,	/* MCF -- print memcntl() function */
26230Sstevel@tonic-gate 	prt_mc4,	/* MC4 -- print memcntl() (fourth) argument */
26240Sstevel@tonic-gate 	prt_mc5,	/* MC5 -- print memcntl() (fifth) argument */
26250Sstevel@tonic-gate 	prt_mad,	/* MAD -- print madvise() argument */
26260Sstevel@tonic-gate 	prt_ulm,	/* ULM -- print ulimit() argument */
26270Sstevel@tonic-gate 	prt_rlm,	/* RLM -- print get/setrlimit() argument */
26280Sstevel@tonic-gate 	prt_cnf,	/* CNF -- print sysconfig() argument */
26290Sstevel@tonic-gate 	prt_inf,	/* INF -- print sysinfo() argument */
26300Sstevel@tonic-gate 	prt_ptc,	/* PTC -- print pathconf/fpathconf() argument */
26310Sstevel@tonic-gate 	prt_fui,	/* FUI -- print fusers() input argument */
26320Sstevel@tonic-gate 	prt_idt,	/* IDT -- print idtype_t, waitid() argument */
26330Sstevel@tonic-gate 	prt_lwf,	/* LWF -- print lwp_create() flags */
26340Sstevel@tonic-gate 	prt_itm,	/* ITM -- print [get|set]itimer() arg */
26350Sstevel@tonic-gate 	prt_llo,	/* LLO -- print long long offset arg */
26360Sstevel@tonic-gate 	prt_mod,	/* MOD -- print modctl() subcode */
26370Sstevel@tonic-gate 	prt_whn,	/* WHN -- print lseek() whence arguiment */
26380Sstevel@tonic-gate 	prt_acl,	/* ACL -- print acl() code */
26390Sstevel@tonic-gate 	prt_aio,	/* AIO -- print kaio() code */
26400Sstevel@tonic-gate 	prt_aud,	/* AUD -- print auditsys() code */
26410Sstevel@tonic-gate 	prt_uns,	/* DEC -- print value in unsigned decimal */
26420Sstevel@tonic-gate 	prt_clc,	/* CLC -- print cladm command argument */
26430Sstevel@tonic-gate 	prt_clf,	/* CLF -- print cladm flag argument */
26440Sstevel@tonic-gate 	prt_cor,	/* COR -- print corectl() subcode */
26450Sstevel@tonic-gate 	prt_cco,	/* CCO -- print corectl() options */
26460Sstevel@tonic-gate 	prt_ccc,	/* CCC -- print corectl() content */
26470Sstevel@tonic-gate 	prt_rcc,	/* RCC -- print corectl() returned content */
26480Sstevel@tonic-gate 	prt_cpc,	/* CPC -- print cpc() subcode */
26490Sstevel@tonic-gate 	prt_sqc,	/* SQC -- print sigqueue() si_code argument */
26500Sstevel@tonic-gate 	prt_pc4,	/* PC4 -- print priocntlsys() (fourth) argument */
26510Sstevel@tonic-gate 	prt_pc5,	/* PC5 -- print priocntlsys() (key, value) pairs */
26520Sstevel@tonic-gate 	prt_pst,	/* PST -- print processor set id */
26530Sstevel@tonic-gate 	prt_mif,	/* MIF -- print meminfo() arguments */
26540Sstevel@tonic-gate 	prt_pfm,	/* PFM -- print so_socket() proto-family (1st) arg */
26550Sstevel@tonic-gate 	prt_skt,	/* SKT -- print so_socket() socket-type (2nd) arg */
26560Sstevel@tonic-gate 	prt_skp,	/* SKP -- print so_socket() protocol (3rd) arg */
26570Sstevel@tonic-gate 	prt_skv,	/* SKV -- print socket version arg */
26580Sstevel@tonic-gate 	prt_sol,	/* SOL -- print [sg]etsockopt() level (2nd) arg */
26590Sstevel@tonic-gate 	prt_son,	/* SON -- print [sg]etsockopt() opt-name (3rd) arg */
26600Sstevel@tonic-gate 	prt_utt,	/* UTT -- print utrap type */
26610Sstevel@tonic-gate 	prt_uth,	/* UTH -- print utrap handler */
26620Sstevel@tonic-gate 	prt_acc,	/* ACC -- print access() flags */
26630Sstevel@tonic-gate 	prt_sht,	/* SHT -- print shutdown() how (2nd) argument */
26640Sstevel@tonic-gate 	prt_ffg,	/* FFG -- print fcntl() flags (3rd) argument */
26650Sstevel@tonic-gate 	prt_prs,	/* PRS -- print privilege set */
26660Sstevel@tonic-gate 	prt_pro,	/* PRO -- print privilege set operation */
26670Sstevel@tonic-gate 	prt_prn,	/* PRN -- print privilege set name */
26680Sstevel@tonic-gate 	prt_pfl,	/* PFL -- print privilege/process flag name */
26690Sstevel@tonic-gate 	prt_laf,	/* LAF -- print lgrp_affinity arguments */
26700Sstevel@tonic-gate 	prt_key,	/* KEY -- print key_t 0 as IPC_PRIVATE */
26710Sstevel@tonic-gate 	prt_zga,	/* ZGA -- print zone_getattr attribute types */
26720Sstevel@tonic-gate 	prt_atc,	/* ATC -- print AT_FDCWD or file descriptor */
26730Sstevel@tonic-gate 	prt_lio,	/* LIO -- print LIO_XX flags */
26740Sstevel@tonic-gate 	prt_dfl,	/* DFL -- print door_create() flags */
26750Sstevel@tonic-gate 	prt_dpm,	/* DPM -- print DOOR_PARAM_XX flags */
26761676Sjpk 	prt_tnd,	/* TND -- print trusted network data base opcode */
26772447Snf202958 	prt_rsc,	/* RSC -- print rctlsys() subcodes */
26782447Snf202958 	prt_rgf,	/* RGF -- print getrctl() flags */
26792447Snf202958 	prt_rsf,	/* RSF -- print setrctl() flags */
26802447Snf202958 	prt_rcf,	/* RCF -- print rctlsys_ctl() flags */
26813235Sraf 	prt_fxf,	/* FXF -- print forkx() flags */
26823684Srd117015 	prt_spf,	/* SPF -- print rctlsys_projset() flags */
26830Sstevel@tonic-gate 	prt_dec,	/* HID -- hidden argument, make this the last one */
26840Sstevel@tonic-gate };
2685