xref: /illumos-gate/usr/src/cmd/truss/expound.c (revision 35da9b40de771fd808b01a5fb71cd70f7ce33567)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
52caf0dcdSrshoaib  * Common Development and Distribution License (the "License").
62caf0dcdSrshoaib  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
212caf0dcdSrshoaib 
227c478bd9Sstevel@tonic-gate /*
23*35da9b40SPavel Filipensky  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
287c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #define	_SYSCALL32
317c478bd9Sstevel@tonic-gate 
327c478bd9Sstevel@tonic-gate #include <stdio.h>
337c478bd9Sstevel@tonic-gate #include <stdlib.h>
347c478bd9Sstevel@tonic-gate #include <unistd.h>
357c478bd9Sstevel@tonic-gate #include <ctype.h>
367c478bd9Sstevel@tonic-gate #include <sys/types.h>
377c478bd9Sstevel@tonic-gate #include <sys/mman.h>
387c478bd9Sstevel@tonic-gate #include <libproc.h>
397c478bd9Sstevel@tonic-gate #include <string.h>
407c478bd9Sstevel@tonic-gate #include <limits.h>
417c478bd9Sstevel@tonic-gate #include <sys/statfs.h>
427c478bd9Sstevel@tonic-gate #include <sys/times.h>
437c478bd9Sstevel@tonic-gate #include <sys/timex.h>
447c478bd9Sstevel@tonic-gate #include <sys/utssys.h>
457c478bd9Sstevel@tonic-gate #include <sys/utsname.h>
467c478bd9Sstevel@tonic-gate #include <sys/ipc.h>
477c478bd9Sstevel@tonic-gate #include <sys/ipc_impl.h>
487c478bd9Sstevel@tonic-gate #include <sys/msg.h>
497c478bd9Sstevel@tonic-gate #include <sys/msg_impl.h>
507c478bd9Sstevel@tonic-gate #include <sys/sem.h>
517c478bd9Sstevel@tonic-gate #include <sys/sem_impl.h>
527c478bd9Sstevel@tonic-gate #include <sys/shm.h>
537c478bd9Sstevel@tonic-gate #include <sys/shm_impl.h>
547c478bd9Sstevel@tonic-gate #include <sys/dirent.h>
557c478bd9Sstevel@tonic-gate #include <sys/utime.h>
567c478bd9Sstevel@tonic-gate #include <ustat.h>
577c478bd9Sstevel@tonic-gate #include <fcntl.h>
587c478bd9Sstevel@tonic-gate #include <time.h>
597c478bd9Sstevel@tonic-gate #include <sys/termios.h>
607c478bd9Sstevel@tonic-gate #include <sys/termiox.h>
617c478bd9Sstevel@tonic-gate #include <sys/termio.h>
627c478bd9Sstevel@tonic-gate #include <sys/ttold.h>
637c478bd9Sstevel@tonic-gate #include <sys/jioctl.h>
647c478bd9Sstevel@tonic-gate #include <sys/filio.h>
657c478bd9Sstevel@tonic-gate #include <stropts.h>
667c478bd9Sstevel@tonic-gate #include <poll.h>
677c478bd9Sstevel@tonic-gate #include <sys/uio.h>
687c478bd9Sstevel@tonic-gate #include <sys/resource.h>
697c478bd9Sstevel@tonic-gate #include <sys/statvfs.h>
707c478bd9Sstevel@tonic-gate #include <sys/time.h>
717c478bd9Sstevel@tonic-gate #include <sys/aio.h>
727c478bd9Sstevel@tonic-gate #include <sys/socket.h>
737c478bd9Sstevel@tonic-gate #include <netinet/in.h>
747c478bd9Sstevel@tonic-gate #include <sys/un.h>
757c478bd9Sstevel@tonic-gate #include <sys/byteorder.h>
767c478bd9Sstevel@tonic-gate #include <arpa/inet.h>
777c478bd9Sstevel@tonic-gate #include <sys/audioio.h>
787c478bd9Sstevel@tonic-gate #include <sys/cladm.h>
797c478bd9Sstevel@tonic-gate #include <sys/synch.h>
807c478bd9Sstevel@tonic-gate #include <sys/synch32.h>
817c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
827c478bd9Sstevel@tonic-gate #include <sys/sendfile.h>
837c478bd9Sstevel@tonic-gate #include <priv.h>
847c478bd9Sstevel@tonic-gate #include <ucred.h>
857c478bd9Sstevel@tonic-gate #include <sys/ucred.h>
867c478bd9Sstevel@tonic-gate #include <sys/port_impl.h>
87821c4a97Sdp #include <sys/zone.h>
88821c4a97Sdp #include <sys/priv_impl.h>
89821c4a97Sdp #include <sys/priv.h>
9045916cd2Sjpk #include <tsol/label.h>
91aa4a4f3bSnf #include <sys/nvpair.h>
92aa4a4f3bSnf #include <libnvpair.h>
93532877c4Srd #include <sys/rctl_impl.h>
947c478bd9Sstevel@tonic-gate 
957c478bd9Sstevel@tonic-gate #include "ramdata.h"
967c478bd9Sstevel@tonic-gate #include "systable.h"
977c478bd9Sstevel@tonic-gate #include "proto.h"
987c478bd9Sstevel@tonic-gate 
997c478bd9Sstevel@tonic-gate void	show_sigset(private_t *, long, const char *);
1007c478bd9Sstevel@tonic-gate void	show_ioctl(private_t *, int, long);
1017c478bd9Sstevel@tonic-gate 
1023b862e9aSRoger A. Faulkner static void
1033b862e9aSRoger A. Faulkner mk_ctime(char *str, size_t maxsize, time_t value)
1043b862e9aSRoger A. Faulkner {
1053b862e9aSRoger A. Faulkner 	(void) strftime(str, maxsize, "%b %e %H:%M:%S %Z %Y",
1063b862e9aSRoger A. Faulkner 	    localtime(&value));
1073b862e9aSRoger A. Faulkner }
1083b862e9aSRoger A. Faulkner 
1097c478bd9Sstevel@tonic-gate void
1107c478bd9Sstevel@tonic-gate prtime(private_t *pri, const char *name, time_t value)
1117c478bd9Sstevel@tonic-gate {
1127c478bd9Sstevel@tonic-gate 	char str[80];
1137c478bd9Sstevel@tonic-gate 
1143b862e9aSRoger A. Faulkner 	mk_ctime(str, sizeof (str), value);
1153b862e9aSRoger A. Faulkner 	(void) printf("%s\t%s%s  [ %lu ]\n",
1167c478bd9Sstevel@tonic-gate 	    pri->pname,
1177c478bd9Sstevel@tonic-gate 	    name,
1187c478bd9Sstevel@tonic-gate 	    str,
1193b862e9aSRoger A. Faulkner 	    value);
1207c478bd9Sstevel@tonic-gate }
1217c478bd9Sstevel@tonic-gate 
1227c478bd9Sstevel@tonic-gate void
1233b862e9aSRoger A. Faulkner prtimeval(private_t *pri, const char *name, struct timeval *value)
1247c478bd9Sstevel@tonic-gate {
1253b862e9aSRoger A. Faulkner 	char str[80];
1263b862e9aSRoger A. Faulkner 
1273b862e9aSRoger A. Faulkner 	mk_ctime(str, sizeof (str), value->tv_sec);
1283b862e9aSRoger A. Faulkner 	(void) printf("%s\t%s%s  [ %lu.%6.6lu ]\n",
1293b862e9aSRoger A. Faulkner 	    pri->pname,
1303b862e9aSRoger A. Faulkner 	    name,
1313b862e9aSRoger A. Faulkner 	    str,
1323b862e9aSRoger A. Faulkner 	    value->tv_sec,
1333b862e9aSRoger A. Faulkner 	    value->tv_usec);
1347c478bd9Sstevel@tonic-gate }
1357c478bd9Sstevel@tonic-gate 
1367c478bd9Sstevel@tonic-gate void
1373b862e9aSRoger A. Faulkner prtimestruc(private_t *pri, const char *name, timestruc_t *value)
1383b862e9aSRoger A. Faulkner {
1393b862e9aSRoger A. Faulkner 	char str[80];
1403b862e9aSRoger A. Faulkner 
1413b862e9aSRoger A. Faulkner 	mk_ctime(str, sizeof (str), value->tv_sec);
1423b862e9aSRoger A. Faulkner 	(void) printf("%s\t%s%s  [ %lu.%9.9lu ]\n",
1433b862e9aSRoger A. Faulkner 	    pri->pname,
1443b862e9aSRoger A. Faulkner 	    name,
1453b862e9aSRoger A. Faulkner 	    str,
1463b862e9aSRoger A. Faulkner 	    value->tv_sec,
1473b862e9aSRoger A. Faulkner 	    value->tv_nsec);
1483b862e9aSRoger A. Faulkner }
1493b862e9aSRoger A. Faulkner 
1503b862e9aSRoger A. Faulkner static void
1517c478bd9Sstevel@tonic-gate show_utime(private_t *pri)
1527c478bd9Sstevel@tonic-gate {
1537c478bd9Sstevel@tonic-gate 	long offset;
1547c478bd9Sstevel@tonic-gate 	struct utimbuf utimbuf;
1557c478bd9Sstevel@tonic-gate 
1567c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 2 || (offset = pri->sys_args[1]) == NULL)
1577c478bd9Sstevel@tonic-gate 		return;
1587c478bd9Sstevel@tonic-gate 
1597c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
1607c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset)
1617c478bd9Sstevel@tonic-gate 		    != sizeof (utimbuf))
1627c478bd9Sstevel@tonic-gate 			return;
1637c478bd9Sstevel@tonic-gate 	} else {
1647c478bd9Sstevel@tonic-gate 		struct utimbuf32 utimbuf32;
1657c478bd9Sstevel@tonic-gate 
1667c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset)
1677c478bd9Sstevel@tonic-gate 		    != sizeof (utimbuf32))
1687c478bd9Sstevel@tonic-gate 			return;
1697c478bd9Sstevel@tonic-gate 
1707c478bd9Sstevel@tonic-gate 		utimbuf.actime = (time_t)utimbuf32.actime;
1717c478bd9Sstevel@tonic-gate 		utimbuf.modtime = (time_t)utimbuf32.modtime;
1727c478bd9Sstevel@tonic-gate 	}
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate 	/* print access and modification times */
1753b862e9aSRoger A. Faulkner 	prtime(pri, "at = ", utimbuf.actime);
1763b862e9aSRoger A. Faulkner 	prtime(pri, "mt = ", utimbuf.modtime);
1777c478bd9Sstevel@tonic-gate }
1787c478bd9Sstevel@tonic-gate 
1793b862e9aSRoger A. Faulkner static void
1803b862e9aSRoger A. Faulkner show_utimes(private_t *pri, long offset)
1817c478bd9Sstevel@tonic-gate {
1827c478bd9Sstevel@tonic-gate 	struct {
1837c478bd9Sstevel@tonic-gate 		struct timeval	atime;
1847c478bd9Sstevel@tonic-gate 		struct timeval	mtime;
1857c478bd9Sstevel@tonic-gate 	} utimbuf;
1867c478bd9Sstevel@tonic-gate 
1873b862e9aSRoger A. Faulkner 	if (offset == 0)
1887c478bd9Sstevel@tonic-gate 		return;
1897c478bd9Sstevel@tonic-gate 
1907c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
1917c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset)
1927c478bd9Sstevel@tonic-gate 		    != sizeof (utimbuf))
1937c478bd9Sstevel@tonic-gate 			return;
1947c478bd9Sstevel@tonic-gate 	} else {
1957c478bd9Sstevel@tonic-gate 		struct {
1967c478bd9Sstevel@tonic-gate 			struct timeval32 atime;
1977c478bd9Sstevel@tonic-gate 			struct timeval32 mtime;
1987c478bd9Sstevel@tonic-gate 		} utimbuf32;
1997c478bd9Sstevel@tonic-gate 
2007c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset)
2017c478bd9Sstevel@tonic-gate 		    != sizeof (utimbuf32))
2027c478bd9Sstevel@tonic-gate 			return;
2037c478bd9Sstevel@tonic-gate 
2047c478bd9Sstevel@tonic-gate 		TIMEVAL32_TO_TIMEVAL(&utimbuf.atime, &utimbuf32.atime);
2057c478bd9Sstevel@tonic-gate 		TIMEVAL32_TO_TIMEVAL(&utimbuf.mtime, &utimbuf32.mtime);
2067c478bd9Sstevel@tonic-gate 	}
2077c478bd9Sstevel@tonic-gate 
2087c478bd9Sstevel@tonic-gate 	/* print access and modification times */
2093b862e9aSRoger A. Faulkner 	prtimeval(pri, "at = ", &utimbuf.atime);
2103b862e9aSRoger A. Faulkner 	prtimeval(pri, "mt = ", &utimbuf.mtime);
2113b862e9aSRoger A. Faulkner }
2123b862e9aSRoger A. Faulkner 
2133b862e9aSRoger A. Faulkner static void
2143b862e9aSRoger A. Faulkner show_utimens(private_t *pri, long offset)
2153b862e9aSRoger A. Faulkner {
2163b862e9aSRoger A. Faulkner 	struct {
2173b862e9aSRoger A. Faulkner 		timespec_t atime;
2183b862e9aSRoger A. Faulkner 		timespec_t mtime;
2193b862e9aSRoger A. Faulkner 	} utimbuf;
2203b862e9aSRoger A. Faulkner 
2213b862e9aSRoger A. Faulkner 	if (offset == 0)
2223b862e9aSRoger A. Faulkner 		return;
2233b862e9aSRoger A. Faulkner 
2243b862e9aSRoger A. Faulkner 	if (data_model == PR_MODEL_NATIVE) {
2253b862e9aSRoger A. Faulkner 		if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset)
2263b862e9aSRoger A. Faulkner 		    != sizeof (utimbuf))
2273b862e9aSRoger A. Faulkner 			return;
2283b862e9aSRoger A. Faulkner 	} else {
2293b862e9aSRoger A. Faulkner 		struct {
2303b862e9aSRoger A. Faulkner 			timespec32_t atime;
2313b862e9aSRoger A. Faulkner 			timespec32_t mtime;
2323b862e9aSRoger A. Faulkner 		} utimbuf32;
2333b862e9aSRoger A. Faulkner 
2343b862e9aSRoger A. Faulkner 		if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset)
2353b862e9aSRoger A. Faulkner 		    != sizeof (utimbuf32))
2363b862e9aSRoger A. Faulkner 			return;
2373b862e9aSRoger A. Faulkner 
2383b862e9aSRoger A. Faulkner 		TIMESPEC32_TO_TIMESPEC(&utimbuf.atime, &utimbuf32.atime);
2393b862e9aSRoger A. Faulkner 		TIMESPEC32_TO_TIMESPEC(&utimbuf.mtime, &utimbuf32.mtime);
2403b862e9aSRoger A. Faulkner 	}
2413b862e9aSRoger A. Faulkner 
2423b862e9aSRoger A. Faulkner 	/* print access and modification times */
2433b862e9aSRoger A. Faulkner 	if (utimbuf.atime.tv_nsec == UTIME_OMIT)
2443b862e9aSRoger A. Faulkner 		(void) printf("%s\tat = UTIME_OMIT\n", pri->pname);
2453b862e9aSRoger A. Faulkner 	else if (utimbuf.atime.tv_nsec == UTIME_NOW)
2463b862e9aSRoger A. Faulkner 		(void) printf("%s\tat = UTIME_NOW\n", pri->pname);
2473b862e9aSRoger A. Faulkner 	else
2483b862e9aSRoger A. Faulkner 		prtimestruc(pri, "at = ", &utimbuf.atime);
2493b862e9aSRoger A. Faulkner 	if (utimbuf.mtime.tv_nsec == UTIME_OMIT)
2503b862e9aSRoger A. Faulkner 		(void) printf("%s\tmt = UTIME_OMIT\n", pri->pname);
2513b862e9aSRoger A. Faulkner 	else if (utimbuf.mtime.tv_nsec == UTIME_NOW)
2523b862e9aSRoger A. Faulkner 		(void) printf("%s\tmt = UTIME_NOW\n", pri->pname);
2533b862e9aSRoger A. Faulkner 	else
254*35da9b40SPavel Filipensky 		prtimestruc(pri, "mt = ", &utimbuf.mtime);
2557c478bd9Sstevel@tonic-gate }
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate void
2587c478bd9Sstevel@tonic-gate show_timeofday(private_t *pri)
2597c478bd9Sstevel@tonic-gate {
2607c478bd9Sstevel@tonic-gate 	struct timeval tod;
2617c478bd9Sstevel@tonic-gate 	long offset;
2627c478bd9Sstevel@tonic-gate 
2637c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
2647c478bd9Sstevel@tonic-gate 		return;
2657c478bd9Sstevel@tonic-gate 
2667c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
2677c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &tod, sizeof (tod), offset)
2687c478bd9Sstevel@tonic-gate 		    != sizeof (tod))
2697c478bd9Sstevel@tonic-gate 			return;
2707c478bd9Sstevel@tonic-gate 	} else {
2717c478bd9Sstevel@tonic-gate 		struct timeval32 tod32;
2727c478bd9Sstevel@tonic-gate 
2737c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &tod32, sizeof (tod32), offset)
2747c478bd9Sstevel@tonic-gate 		    != sizeof (tod32))
2757c478bd9Sstevel@tonic-gate 			return;
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate 		TIMEVAL32_TO_TIMEVAL(&tod, &tod32);
2787c478bd9Sstevel@tonic-gate 	}
2797c478bd9Sstevel@tonic-gate 
2803b862e9aSRoger A. Faulkner 	prtimeval(pri, "time: ", &tod);
2817c478bd9Sstevel@tonic-gate }
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate void
2847c478bd9Sstevel@tonic-gate show_itimerval(private_t *pri, long offset, const char *name)
2857c478bd9Sstevel@tonic-gate {
2867c478bd9Sstevel@tonic-gate 	struct itimerval itimerval;
2877c478bd9Sstevel@tonic-gate 
2883b862e9aSRoger A. Faulkner 	if (offset == 0)
2897c478bd9Sstevel@tonic-gate 		return;
2907c478bd9Sstevel@tonic-gate 
2917c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
2927c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &itimerval, sizeof (itimerval), offset)
2937c478bd9Sstevel@tonic-gate 		    != sizeof (itimerval))
2947c478bd9Sstevel@tonic-gate 			return;
2957c478bd9Sstevel@tonic-gate 	} else {
2967c478bd9Sstevel@tonic-gate 		struct itimerval32 itimerval32;
2977c478bd9Sstevel@tonic-gate 
2987c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &itimerval32, sizeof (itimerval32), offset)
2997c478bd9Sstevel@tonic-gate 		    != sizeof (itimerval32))
3007c478bd9Sstevel@tonic-gate 			return;
3017c478bd9Sstevel@tonic-gate 
3027c478bd9Sstevel@tonic-gate 		ITIMERVAL32_TO_ITIMERVAL(&itimerval, &itimerval32);
3037c478bd9Sstevel@tonic-gate 	}
3047c478bd9Sstevel@tonic-gate 
3057c478bd9Sstevel@tonic-gate 	(void) printf(
3067c478bd9Sstevel@tonic-gate 	    "%s\t%s:  interval: %4ld.%6.6ld sec  value: %4ld.%6.6ld sec\n",
3077c478bd9Sstevel@tonic-gate 	    pri->pname,
3087c478bd9Sstevel@tonic-gate 	    name,
3097c478bd9Sstevel@tonic-gate 	    itimerval.it_interval.tv_sec,
3107c478bd9Sstevel@tonic-gate 	    itimerval.it_interval.tv_usec,
3117c478bd9Sstevel@tonic-gate 	    itimerval.it_value.tv_sec,
3127c478bd9Sstevel@tonic-gate 	    itimerval.it_value.tv_usec);
3137c478bd9Sstevel@tonic-gate }
3147c478bd9Sstevel@tonic-gate 
3157c478bd9Sstevel@tonic-gate void
3167c478bd9Sstevel@tonic-gate show_timeval(private_t *pri, long offset, const char *name)
3177c478bd9Sstevel@tonic-gate {
3187c478bd9Sstevel@tonic-gate 	struct timeval timeval;
3197c478bd9Sstevel@tonic-gate 
3203b862e9aSRoger A. Faulkner 	if (offset == 0)
3217c478bd9Sstevel@tonic-gate 		return;
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
3247c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &timeval, sizeof (timeval), offset)
3257c478bd9Sstevel@tonic-gate 		    != sizeof (timeval))
3267c478bd9Sstevel@tonic-gate 			return;
3277c478bd9Sstevel@tonic-gate 	} else {
3287c478bd9Sstevel@tonic-gate 		struct timeval32 timeval32;
3297c478bd9Sstevel@tonic-gate 
3307c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &timeval32, sizeof (timeval32), offset)
3317c478bd9Sstevel@tonic-gate 		    != sizeof (timeval32))
3327c478bd9Sstevel@tonic-gate 			return;
3337c478bd9Sstevel@tonic-gate 
3347c478bd9Sstevel@tonic-gate 		TIMEVAL32_TO_TIMEVAL(&timeval, &timeval32);
3357c478bd9Sstevel@tonic-gate 	}
3367c478bd9Sstevel@tonic-gate 
3377c478bd9Sstevel@tonic-gate 	(void) printf(
3387c478bd9Sstevel@tonic-gate 	    "%s\t%s: %ld.%6.6ld sec\n",
3397c478bd9Sstevel@tonic-gate 	    pri->pname,
3407c478bd9Sstevel@tonic-gate 	    name,
3417c478bd9Sstevel@tonic-gate 	    timeval.tv_sec,
3427c478bd9Sstevel@tonic-gate 	    timeval.tv_usec);
3437c478bd9Sstevel@tonic-gate }
3447c478bd9Sstevel@tonic-gate 
3457c478bd9Sstevel@tonic-gate void
3467c478bd9Sstevel@tonic-gate show_timestruc(private_t *pri, long offset, const char *name)
3477c478bd9Sstevel@tonic-gate {
3487c478bd9Sstevel@tonic-gate 	timestruc_t timestruc;
3497c478bd9Sstevel@tonic-gate 
3503b862e9aSRoger A. Faulkner 	if (offset == 0)
3517c478bd9Sstevel@tonic-gate 		return;
3527c478bd9Sstevel@tonic-gate 
3537c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
3547c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &timestruc, sizeof (timestruc), offset)
3557c478bd9Sstevel@tonic-gate 		    != sizeof (timestruc))
3567c478bd9Sstevel@tonic-gate 			return;
3577c478bd9Sstevel@tonic-gate 	} else {
3587c478bd9Sstevel@tonic-gate 		timestruc32_t timestruc32;
3597c478bd9Sstevel@tonic-gate 
3607c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &timestruc32, sizeof (timestruc32), offset)
3617c478bd9Sstevel@tonic-gate 		    != sizeof (timestruc32))
3627c478bd9Sstevel@tonic-gate 			return;
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 		TIMESPEC32_TO_TIMESPEC(&timestruc, &timestruc32);
3657c478bd9Sstevel@tonic-gate 	}
3667c478bd9Sstevel@tonic-gate 
3677c478bd9Sstevel@tonic-gate 	(void) printf(
3687c478bd9Sstevel@tonic-gate 	    "%s\t%s: %ld.%9.9ld sec\n",
3697c478bd9Sstevel@tonic-gate 	    pri->pname,
3707c478bd9Sstevel@tonic-gate 	    name,
3717c478bd9Sstevel@tonic-gate 	    timestruc.tv_sec,
3727c478bd9Sstevel@tonic-gate 	    timestruc.tv_nsec);
3737c478bd9Sstevel@tonic-gate }
3747c478bd9Sstevel@tonic-gate 
3757c478bd9Sstevel@tonic-gate void
3767c478bd9Sstevel@tonic-gate show_stime(private_t *pri)
3777c478bd9Sstevel@tonic-gate {
3787c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 1) {
3797c478bd9Sstevel@tonic-gate 		/* print new system time */
3807c478bd9Sstevel@tonic-gate 		prtime(pri, "systime = ", (time_t)pri->sys_args[0]);
3817c478bd9Sstevel@tonic-gate 	}
3827c478bd9Sstevel@tonic-gate }
3837c478bd9Sstevel@tonic-gate 
3847c478bd9Sstevel@tonic-gate void
3857c478bd9Sstevel@tonic-gate show_times(private_t *pri)
3867c478bd9Sstevel@tonic-gate {
3877c478bd9Sstevel@tonic-gate 	long hz = sysconf(_SC_CLK_TCK);
3887c478bd9Sstevel@tonic-gate 	long offset;
3897c478bd9Sstevel@tonic-gate 	struct tms tms;
3907c478bd9Sstevel@tonic-gate 
3917c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
3927c478bd9Sstevel@tonic-gate 		return;
3937c478bd9Sstevel@tonic-gate 
3947c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
3957c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &tms, sizeof (tms), offset)
3967c478bd9Sstevel@tonic-gate 		    != sizeof (tms))
3977c478bd9Sstevel@tonic-gate 			return;
3987c478bd9Sstevel@tonic-gate 	} else {
3997c478bd9Sstevel@tonic-gate 		struct tms32 tms32;
4007c478bd9Sstevel@tonic-gate 
4017c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &tms32, sizeof (tms32), offset)
4027c478bd9Sstevel@tonic-gate 		    != sizeof (tms32))
4037c478bd9Sstevel@tonic-gate 			return;
4047c478bd9Sstevel@tonic-gate 
4057c478bd9Sstevel@tonic-gate 		/*
4067c478bd9Sstevel@tonic-gate 		 * This looks a bit odd (since the values are actually
4077c478bd9Sstevel@tonic-gate 		 * signed), but we need to suppress sign extension to
4087c478bd9Sstevel@tonic-gate 		 * preserve compatibility (we've always printed these
4097c478bd9Sstevel@tonic-gate 		 * numbers as unsigned quantities).
4107c478bd9Sstevel@tonic-gate 		 */
4117c478bd9Sstevel@tonic-gate 		tms.tms_utime = (unsigned)tms32.tms_utime;
4127c478bd9Sstevel@tonic-gate 		tms.tms_stime = (unsigned)tms32.tms_stime;
4137c478bd9Sstevel@tonic-gate 		tms.tms_cutime = (unsigned)tms32.tms_cutime;
4147c478bd9Sstevel@tonic-gate 		tms.tms_cstime = (unsigned)tms32.tms_cstime;
4157c478bd9Sstevel@tonic-gate 	}
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate 	(void) printf(
4187c478bd9Sstevel@tonic-gate 	    "%s\tutim=%-6lu stim=%-6lu cutim=%-6lu cstim=%-6lu (HZ=%ld)\n",
4197c478bd9Sstevel@tonic-gate 	    pri->pname,
4207c478bd9Sstevel@tonic-gate 	    tms.tms_utime,
4217c478bd9Sstevel@tonic-gate 	    tms.tms_stime,
4227c478bd9Sstevel@tonic-gate 	    tms.tms_cutime,
4237c478bd9Sstevel@tonic-gate 	    tms.tms_cstime,
4247c478bd9Sstevel@tonic-gate 	    hz);
4257c478bd9Sstevel@tonic-gate }
4267c478bd9Sstevel@tonic-gate 
4277c478bd9Sstevel@tonic-gate void
4287c478bd9Sstevel@tonic-gate show_uname(private_t *pri, long offset)
4297c478bd9Sstevel@tonic-gate {
4307c478bd9Sstevel@tonic-gate 	/*
4317c478bd9Sstevel@tonic-gate 	 * Old utsname buffer (no longer accessible in <sys/utsname.h>).
4327c478bd9Sstevel@tonic-gate 	 */
4337c478bd9Sstevel@tonic-gate 	struct {
4347c478bd9Sstevel@tonic-gate 		char	sysname[9];
4357c478bd9Sstevel@tonic-gate 		char	nodename[9];
4367c478bd9Sstevel@tonic-gate 		char	release[9];
4377c478bd9Sstevel@tonic-gate 		char	version[9];
4387c478bd9Sstevel@tonic-gate 		char	machine[9];
4397c478bd9Sstevel@tonic-gate 	} ubuf;
4407c478bd9Sstevel@tonic-gate 
4417c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
4427c478bd9Sstevel@tonic-gate 	    Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
4437c478bd9Sstevel@tonic-gate 		(void) printf(
444019c3c43Sraf 		    "%s\tsys=%-9.9snod=%-9.9srel=%-9.9sver=%-9.9smch=%.9s\n",
445019c3c43Sraf 		    pri->pname,
446019c3c43Sraf 		    ubuf.sysname,
447019c3c43Sraf 		    ubuf.nodename,
448019c3c43Sraf 		    ubuf.release,
449019c3c43Sraf 		    ubuf.version,
450019c3c43Sraf 		    ubuf.machine);
4517c478bd9Sstevel@tonic-gate 	}
4527c478bd9Sstevel@tonic-gate }
4537c478bd9Sstevel@tonic-gate 
4547c478bd9Sstevel@tonic-gate /* XX64 -- definition of 'struct ustat' is strange -- check out the defn */
4557c478bd9Sstevel@tonic-gate void
4567c478bd9Sstevel@tonic-gate show_ustat(private_t *pri, long offset)
4577c478bd9Sstevel@tonic-gate {
4587c478bd9Sstevel@tonic-gate 	struct ustat ubuf;
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
4617c478bd9Sstevel@tonic-gate 	    Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
4627c478bd9Sstevel@tonic-gate 		(void) printf(
463019c3c43Sraf 		    "%s\ttfree=%-6ld tinode=%-5lu fname=%-6.6s fpack=%-.6s\n",
464019c3c43Sraf 		    pri->pname,
465019c3c43Sraf 		    ubuf.f_tfree,
466019c3c43Sraf 		    ubuf.f_tinode,
467019c3c43Sraf 		    ubuf.f_fname,
468019c3c43Sraf 		    ubuf.f_fpack);
4697c478bd9Sstevel@tonic-gate 	}
4707c478bd9Sstevel@tonic-gate }
4717c478bd9Sstevel@tonic-gate 
4727c478bd9Sstevel@tonic-gate #ifdef _LP64
4737c478bd9Sstevel@tonic-gate void
4747c478bd9Sstevel@tonic-gate show_ustat32(private_t *pri, long offset)
4757c478bd9Sstevel@tonic-gate {
4767c478bd9Sstevel@tonic-gate 	struct ustat32 ubuf;
4777c478bd9Sstevel@tonic-gate 
4787c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
4797c478bd9Sstevel@tonic-gate 	    Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
4807c478bd9Sstevel@tonic-gate 		(void) printf(
481019c3c43Sraf 		    "%s\ttfree=%-6d tinode=%-5u fname=%-6.6s fpack=%-.6s\n",
482019c3c43Sraf 		    pri->pname,
483019c3c43Sraf 		    ubuf.f_tfree,
484019c3c43Sraf 		    ubuf.f_tinode,
485019c3c43Sraf 		    ubuf.f_fname,
486019c3c43Sraf 		    ubuf.f_fpack);
4877c478bd9Sstevel@tonic-gate 	}
4887c478bd9Sstevel@tonic-gate }
4897c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
4907c478bd9Sstevel@tonic-gate 
4917c478bd9Sstevel@tonic-gate void
4927c478bd9Sstevel@tonic-gate show_fusers(private_t *pri, long offset, long nproc)
4937c478bd9Sstevel@tonic-gate {
4947c478bd9Sstevel@tonic-gate 	f_user_t fubuf;
4957c478bd9Sstevel@tonic-gate 	int serial = (nproc > 4);
4967c478bd9Sstevel@tonic-gate 
4973b862e9aSRoger A. Faulkner 	if (offset == 0)
4987c478bd9Sstevel@tonic-gate 		return;
4997c478bd9Sstevel@tonic-gate 
5007c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
5017c478bd9Sstevel@tonic-gate 	if (serial)
5027c478bd9Sstevel@tonic-gate 		Eserialize();
5037c478bd9Sstevel@tonic-gate 
5047c478bd9Sstevel@tonic-gate 	while (nproc > 0 &&
5057c478bd9Sstevel@tonic-gate 	    Pread(Proc, &fubuf, sizeof (fubuf), offset) == sizeof (fubuf)) {
506f48205beScasper 		(void) printf("%s\tpid=%-5d uid=%-5u flags=%s\n",
5077c478bd9Sstevel@tonic-gate 		    pri->pname,
5087c478bd9Sstevel@tonic-gate 		    (int)fubuf.fu_pid,
509f48205beScasper 		    fubuf.fu_uid,
5107c478bd9Sstevel@tonic-gate 		    fuflags(pri, fubuf.fu_flags));
5117c478bd9Sstevel@tonic-gate 		nproc--;
5127c478bd9Sstevel@tonic-gate 		offset += sizeof (fubuf);
5137c478bd9Sstevel@tonic-gate 	}
5147c478bd9Sstevel@tonic-gate 
5157c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
5167c478bd9Sstevel@tonic-gate 	if (serial)
5177c478bd9Sstevel@tonic-gate 		Xserialize();
5187c478bd9Sstevel@tonic-gate }
5197c478bd9Sstevel@tonic-gate 
5207c478bd9Sstevel@tonic-gate void
5217c478bd9Sstevel@tonic-gate show_utssys(private_t *pri, long r0)
5227c478bd9Sstevel@tonic-gate {
5237c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 3) {
5247c478bd9Sstevel@tonic-gate 		switch (pri->sys_args[2]) {
5257c478bd9Sstevel@tonic-gate 		case UTS_UNAME:
5267c478bd9Sstevel@tonic-gate 			show_uname(pri, (long)pri->sys_args[0]);
5277c478bd9Sstevel@tonic-gate 			break;
5287c478bd9Sstevel@tonic-gate 		case UTS_USTAT:
5297c478bd9Sstevel@tonic-gate 			show_ustat(pri, (long)pri->sys_args[0]);
5307c478bd9Sstevel@tonic-gate 			break;
5317c478bd9Sstevel@tonic-gate 		case UTS_FUSERS:
5327c478bd9Sstevel@tonic-gate 			show_fusers(pri, (long)pri->sys_args[3], r0);
5337c478bd9Sstevel@tonic-gate 			break;
5347c478bd9Sstevel@tonic-gate 		}
5357c478bd9Sstevel@tonic-gate 	}
5367c478bd9Sstevel@tonic-gate }
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate #ifdef _LP64
5397c478bd9Sstevel@tonic-gate void
5407c478bd9Sstevel@tonic-gate show_utssys32(private_t *pri, long r0)
5417c478bd9Sstevel@tonic-gate {
5427c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 3) {
5437c478bd9Sstevel@tonic-gate 		switch (pri->sys_args[2]) {
5447c478bd9Sstevel@tonic-gate 		case UTS_UNAME:
5457c478bd9Sstevel@tonic-gate 			show_uname(pri, (long)pri->sys_args[0]);
5467c478bd9Sstevel@tonic-gate 			break;
5477c478bd9Sstevel@tonic-gate 		case UTS_USTAT:
5487c478bd9Sstevel@tonic-gate 			show_ustat32(pri, (long)pri->sys_args[0]);
5497c478bd9Sstevel@tonic-gate 			break;
5507c478bd9Sstevel@tonic-gate 		case UTS_FUSERS:
5517c478bd9Sstevel@tonic-gate 			show_fusers(pri, (long)pri->sys_args[3], r0);
5527c478bd9Sstevel@tonic-gate 			break;
5537c478bd9Sstevel@tonic-gate 		}
5547c478bd9Sstevel@tonic-gate 	}
5557c478bd9Sstevel@tonic-gate }
5567c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
5577c478bd9Sstevel@tonic-gate 
5587c478bd9Sstevel@tonic-gate void
5597c478bd9Sstevel@tonic-gate show_cladm(private_t *pri, int code, int function, long offset)
5607c478bd9Sstevel@tonic-gate {
5617c478bd9Sstevel@tonic-gate 	int	arg;
5627c478bd9Sstevel@tonic-gate 
5637c478bd9Sstevel@tonic-gate 	switch (code) {
5647c478bd9Sstevel@tonic-gate 	case CL_INITIALIZE:
5657c478bd9Sstevel@tonic-gate 		switch (function) {
5667c478bd9Sstevel@tonic-gate 		case CL_GET_BOOTFLAG:
5677c478bd9Sstevel@tonic-gate 			if (Pread(Proc, &arg, sizeof (arg), offset)
5687c478bd9Sstevel@tonic-gate 			    == sizeof (arg)) {
5697c478bd9Sstevel@tonic-gate 				if (arg & CLUSTER_CONFIGURED)
5707c478bd9Sstevel@tonic-gate 					(void) printf("%s\tbootflags="
5717c478bd9Sstevel@tonic-gate 					    "CLUSTER_CONFIGURED", pri->pname);
5727c478bd9Sstevel@tonic-gate 				if (arg & CLUSTER_BOOTED)
5737c478bd9Sstevel@tonic-gate 					(void) printf("|CLUSTER_BOOTED\n");
5747c478bd9Sstevel@tonic-gate 			}
5757c478bd9Sstevel@tonic-gate 			break;
5767c478bd9Sstevel@tonic-gate 		}
5777c478bd9Sstevel@tonic-gate 		break;
5787c478bd9Sstevel@tonic-gate 	case CL_CONFIG:
5797c478bd9Sstevel@tonic-gate 		switch (function) {
5807c478bd9Sstevel@tonic-gate 		case CL_NODEID:
5817c478bd9Sstevel@tonic-gate 		case CL_HIGHEST_NODEID:
5827c478bd9Sstevel@tonic-gate 			if (Pread(Proc, &arg, sizeof (arg), offset)
5837c478bd9Sstevel@tonic-gate 			    == sizeof (arg))
5847c478bd9Sstevel@tonic-gate 				(void) printf("%s\tnodeid=%d\n",
585019c3c43Sraf 				    pri->pname, arg);
5867c478bd9Sstevel@tonic-gate 		}
5877c478bd9Sstevel@tonic-gate 		break;
5887c478bd9Sstevel@tonic-gate 	}
5897c478bd9Sstevel@tonic-gate }
5907c478bd9Sstevel@tonic-gate 
591883492d5Sraf #define	ALL_LOCK_TYPES						\
592883492d5Sraf 	(USYNC_PROCESS | LOCK_ERRORCHECK | LOCK_RECURSIVE | 	\
593883492d5Sraf 	LOCK_PRIO_INHERIT | LOCK_PRIO_PROTECT | LOCK_ROBUST | 	\
594883492d5Sraf 	USYNC_PROCESS_ROBUST)
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate /* return cv and mutex types */
5977c478bd9Sstevel@tonic-gate const char *
5987c478bd9Sstevel@tonic-gate synch_type(private_t *pri, uint_t type)
5997c478bd9Sstevel@tonic-gate {
6007c478bd9Sstevel@tonic-gate 	char *str = pri->code_buf;
6017c478bd9Sstevel@tonic-gate 
6027c478bd9Sstevel@tonic-gate 	if (type & USYNC_PROCESS)
6037c478bd9Sstevel@tonic-gate 		(void) strcpy(str, "USYNC_PROCESS");
6047c478bd9Sstevel@tonic-gate 	else
6057c478bd9Sstevel@tonic-gate 		(void) strcpy(str, "USYNC_THREAD");
6067c478bd9Sstevel@tonic-gate 
6077c478bd9Sstevel@tonic-gate 	if (type & LOCK_ERRORCHECK)
6087c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|LOCK_ERRORCHECK");
6097c478bd9Sstevel@tonic-gate 	if (type & LOCK_RECURSIVE)
6107c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|LOCK_RECURSIVE");
6117c478bd9Sstevel@tonic-gate 	if (type & LOCK_PRIO_INHERIT)
6127c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|LOCK_PRIO_INHERIT");
6137c478bd9Sstevel@tonic-gate 	if (type & LOCK_PRIO_PROTECT)
6147c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|LOCK_PRIO_PROTECT");
615883492d5Sraf 	if (type & LOCK_ROBUST)
616883492d5Sraf 		(void) strcat(str, "|LOCK_ROBUST");
617883492d5Sraf 	if (type & USYNC_PROCESS_ROBUST)
618883492d5Sraf 		(void) strcat(str, "|USYNC_PROCESS_ROBUST");
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate 	if ((type &= ~ALL_LOCK_TYPES) != 0)
6217c478bd9Sstevel@tonic-gate 		(void) sprintf(str + strlen(str), "|0x%.4X", type);
6227c478bd9Sstevel@tonic-gate 
6237c478bd9Sstevel@tonic-gate 	return ((const char *)str);
6247c478bd9Sstevel@tonic-gate }
6257c478bd9Sstevel@tonic-gate 
6267c478bd9Sstevel@tonic-gate void
6277c478bd9Sstevel@tonic-gate show_mutex(private_t *pri, long offset)
6287c478bd9Sstevel@tonic-gate {
6297c478bd9Sstevel@tonic-gate 	lwp_mutex_t mutex;
6307c478bd9Sstevel@tonic-gate 
6317c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &mutex, sizeof (mutex), offset) == sizeof (mutex)) {
6327c478bd9Sstevel@tonic-gate 		(void) printf("%s\tmutex type: %s\n",
633019c3c43Sraf 		    pri->pname,
634019c3c43Sraf 		    synch_type(pri, mutex.mutex_type));
6357c478bd9Sstevel@tonic-gate 	}
6367c478bd9Sstevel@tonic-gate }
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate void
6397c478bd9Sstevel@tonic-gate show_condvar(private_t *pri, long offset)
6407c478bd9Sstevel@tonic-gate {
6417c478bd9Sstevel@tonic-gate 	lwp_cond_t condvar;
6427c478bd9Sstevel@tonic-gate 
6437c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &condvar, sizeof (condvar), offset)
6447c478bd9Sstevel@tonic-gate 	    == sizeof (condvar)) {
6457c478bd9Sstevel@tonic-gate 		(void) printf("%s\tcondvar type: %s\n",
646019c3c43Sraf 		    pri->pname,
647019c3c43Sraf 		    synch_type(pri, condvar.cond_type));
6487c478bd9Sstevel@tonic-gate 	}
6497c478bd9Sstevel@tonic-gate }
6507c478bd9Sstevel@tonic-gate 
6517c478bd9Sstevel@tonic-gate void
6527c478bd9Sstevel@tonic-gate show_sema(private_t *pri, long offset)
6537c478bd9Sstevel@tonic-gate {
6547c478bd9Sstevel@tonic-gate 	lwp_sema_t sema;
6557c478bd9Sstevel@tonic-gate 
6567c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &sema, sizeof (sema), offset) == sizeof (sema)) {
6577c478bd9Sstevel@tonic-gate 		(void) printf("%s\tsema type: %s  count = %u\n",
658019c3c43Sraf 		    pri->pname,
659019c3c43Sraf 		    synch_type(pri, sema.sema_type),
660019c3c43Sraf 		    sema.sema_count);
6617c478bd9Sstevel@tonic-gate 	}
6627c478bd9Sstevel@tonic-gate }
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate void
6657c478bd9Sstevel@tonic-gate show_rwlock(private_t *pri, long offset)
6667c478bd9Sstevel@tonic-gate {
6677c478bd9Sstevel@tonic-gate 	lwp_rwlock_t rwlock;
6687c478bd9Sstevel@tonic-gate 
6697c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &rwlock, sizeof (rwlock), offset) == sizeof (rwlock)) {
6707c478bd9Sstevel@tonic-gate 		(void) printf("%s\trwlock type: %s  readers = %d\n",
671019c3c43Sraf 		    pri->pname,
672019c3c43Sraf 		    synch_type(pri, rwlock.rwlock_type),
673019c3c43Sraf 		    rwlock.rwlock_readers);
6747c478bd9Sstevel@tonic-gate 	}
6757c478bd9Sstevel@tonic-gate }
6767c478bd9Sstevel@tonic-gate 
6777c478bd9Sstevel@tonic-gate /* represent character as itself ('c') or octal (012) */
6787c478bd9Sstevel@tonic-gate char *
6797c478bd9Sstevel@tonic-gate show_char(char *buf, int c)
6807c478bd9Sstevel@tonic-gate {
6817c478bd9Sstevel@tonic-gate 	const char *fmt;
6827c478bd9Sstevel@tonic-gate 
6837c478bd9Sstevel@tonic-gate 	if (c >= ' ' && c < 0177)
6847c478bd9Sstevel@tonic-gate 		fmt = "'%c'";
6857c478bd9Sstevel@tonic-gate 	else
6867c478bd9Sstevel@tonic-gate 		fmt = "%.3o";
6877c478bd9Sstevel@tonic-gate 
6887c478bd9Sstevel@tonic-gate 	(void) sprintf(buf, fmt, c&0xff);
6897c478bd9Sstevel@tonic-gate 	return (buf);
6907c478bd9Sstevel@tonic-gate }
6917c478bd9Sstevel@tonic-gate 
6927c478bd9Sstevel@tonic-gate void
6937c478bd9Sstevel@tonic-gate show_termio(private_t *pri, long offset)
6947c478bd9Sstevel@tonic-gate {
6957c478bd9Sstevel@tonic-gate 	struct termio termio;
6967c478bd9Sstevel@tonic-gate 	char cbuf[8];
6977c478bd9Sstevel@tonic-gate 	int i;
6987c478bd9Sstevel@tonic-gate 
6997c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &termio, sizeof (termio), offset) == sizeof (termio)) {
7007c478bd9Sstevel@tonic-gate 		(void) printf(
7017c478bd9Sstevel@tonic-gate 		"%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o line=%d\n",
702019c3c43Sraf 		    pri->pname,
703019c3c43Sraf 		    termio.c_iflag,
704019c3c43Sraf 		    termio.c_oflag,
705019c3c43Sraf 		    termio.c_cflag,
706019c3c43Sraf 		    termio.c_lflag,
707019c3c43Sraf 		    termio.c_line);
7087c478bd9Sstevel@tonic-gate 		(void) printf("%s\t    cc: ", pri->pname);
7097c478bd9Sstevel@tonic-gate 		for (i = 0; i < NCC; i++)
7107c478bd9Sstevel@tonic-gate 			(void) printf(" %s",
711019c3c43Sraf 			    show_char(cbuf, (int)termio.c_cc[i]));
7127c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
7137c478bd9Sstevel@tonic-gate 	}
7147c478bd9Sstevel@tonic-gate }
7157c478bd9Sstevel@tonic-gate 
7167c478bd9Sstevel@tonic-gate void
7177c478bd9Sstevel@tonic-gate show_termios(private_t *pri, long offset)
7187c478bd9Sstevel@tonic-gate {
7197c478bd9Sstevel@tonic-gate 	struct termios termios;
7207c478bd9Sstevel@tonic-gate 	char cbuf[8];
7217c478bd9Sstevel@tonic-gate 	int i;
7227c478bd9Sstevel@tonic-gate 
7237c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &termios, sizeof (termios), offset)
7247c478bd9Sstevel@tonic-gate 	    == sizeof (termios)) {
7257c478bd9Sstevel@tonic-gate 		(void) printf(
726019c3c43Sraf 		    "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o\n",
727019c3c43Sraf 		    pri->pname,
728019c3c43Sraf 		    termios.c_iflag,
729019c3c43Sraf 		    termios.c_oflag,
730019c3c43Sraf 		    termios.c_cflag,
731019c3c43Sraf 		    termios.c_lflag);
7327c478bd9Sstevel@tonic-gate 		(void) printf("%s\t    cc: ", pri->pname);
7337c478bd9Sstevel@tonic-gate 		for (i = 0; i < NCCS; i++) {
7347c478bd9Sstevel@tonic-gate 			if (i == NCC)	/* show new chars on new line */
7357c478bd9Sstevel@tonic-gate 				(void) printf("\n%s\t\t", pri->pname);
7367c478bd9Sstevel@tonic-gate 			(void) printf(" %s",
737019c3c43Sraf 			    show_char(cbuf, (int)termios.c_cc[i]));
7387c478bd9Sstevel@tonic-gate 		}
7397c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
7407c478bd9Sstevel@tonic-gate 	}
7417c478bd9Sstevel@tonic-gate }
7427c478bd9Sstevel@tonic-gate 
7437c478bd9Sstevel@tonic-gate void
7447c478bd9Sstevel@tonic-gate show_termiox(private_t *pri, long offset)
7457c478bd9Sstevel@tonic-gate {
7467c478bd9Sstevel@tonic-gate 	struct termiox termiox;
7477c478bd9Sstevel@tonic-gate 	int i;
7487c478bd9Sstevel@tonic-gate 
7497c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &termiox, sizeof (termiox), offset)
7507c478bd9Sstevel@tonic-gate 	    == sizeof (termiox)) {
7517c478bd9Sstevel@tonic-gate 		(void) printf("%s\thflag=0%.3o cflag=0%.3o rflag=0%.3o",
752019c3c43Sraf 		    pri->pname,
753019c3c43Sraf 		    termiox.x_hflag,
754019c3c43Sraf 		    termiox.x_cflag,
755019c3c43Sraf 		    termiox.x_rflag[0]);
7567c478bd9Sstevel@tonic-gate 		for (i = 1; i < NFF; i++)
7577c478bd9Sstevel@tonic-gate 			(void) printf(",0%.3o", termiox.x_rflag[i]);
7587c478bd9Sstevel@tonic-gate 		(void) printf(" sflag=0%.3o\n",
759019c3c43Sraf 		    termiox.x_sflag);
7607c478bd9Sstevel@tonic-gate 	}
7617c478bd9Sstevel@tonic-gate }
7627c478bd9Sstevel@tonic-gate 
7637c478bd9Sstevel@tonic-gate void
7647c478bd9Sstevel@tonic-gate show_sgttyb(private_t *pri, long offset)
7657c478bd9Sstevel@tonic-gate {
7667c478bd9Sstevel@tonic-gate 	struct sgttyb sgttyb;
7677c478bd9Sstevel@tonic-gate 
7687c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &sgttyb, sizeof (sgttyb), offset) == sizeof (sgttyb)) {
7697c478bd9Sstevel@tonic-gate 		char erase[8];
7707c478bd9Sstevel@tonic-gate 		char kill[8];
7717c478bd9Sstevel@tonic-gate 
7727c478bd9Sstevel@tonic-gate 		(void) printf(
7737c478bd9Sstevel@tonic-gate 		"%s\tispeed=%-2d ospeed=%-2d erase=%s kill=%s flags=0x%.8x\n",
774019c3c43Sraf 		    pri->pname,
775019c3c43Sraf 		    sgttyb.sg_ispeed&0xff,
776019c3c43Sraf 		    sgttyb.sg_ospeed&0xff,
777019c3c43Sraf 		    show_char(erase, sgttyb.sg_erase),
778019c3c43Sraf 		    show_char(kill, sgttyb.sg_kill),
779019c3c43Sraf 		    sgttyb.sg_flags);
7807c478bd9Sstevel@tonic-gate 	}
7817c478bd9Sstevel@tonic-gate }
7827c478bd9Sstevel@tonic-gate 
7837c478bd9Sstevel@tonic-gate void
7847c478bd9Sstevel@tonic-gate show_ltchars(private_t *pri, long offset)
7857c478bd9Sstevel@tonic-gate {
7867c478bd9Sstevel@tonic-gate 	struct ltchars ltchars;
7877c478bd9Sstevel@tonic-gate 	char *p;
7887c478bd9Sstevel@tonic-gate 	char cbuf[8];
7897c478bd9Sstevel@tonic-gate 	int i;
7907c478bd9Sstevel@tonic-gate 
7917c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &ltchars, sizeof (ltchars), offset)
7927c478bd9Sstevel@tonic-gate 	    == sizeof (ltchars)) {
7937c478bd9Sstevel@tonic-gate 		(void) printf("%s\t    cc: ", pri->pname);
7947c478bd9Sstevel@tonic-gate 		for (p = (char *)&ltchars, i = 0; i < sizeof (ltchars); i++)
7957c478bd9Sstevel@tonic-gate 			(void) printf(" %s", show_char(cbuf, (int)*p++));
7967c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
7977c478bd9Sstevel@tonic-gate 	}
7987c478bd9Sstevel@tonic-gate }
7997c478bd9Sstevel@tonic-gate 
8007c478bd9Sstevel@tonic-gate void
8017c478bd9Sstevel@tonic-gate show_tchars(private_t *pri, long offset)
8027c478bd9Sstevel@tonic-gate {
8037c478bd9Sstevel@tonic-gate 	struct tchars tchars;
8047c478bd9Sstevel@tonic-gate 	char *p;
8057c478bd9Sstevel@tonic-gate 	char cbuf[8];
8067c478bd9Sstevel@tonic-gate 	int i;
8077c478bd9Sstevel@tonic-gate 
8087c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &tchars, sizeof (tchars), offset) == sizeof (tchars)) {
8097c478bd9Sstevel@tonic-gate 		(void) printf("%s\t    cc: ", pri->pname);
8107c478bd9Sstevel@tonic-gate 		for (p = (char *)&tchars, i = 0; i < sizeof (tchars); i++)
8117c478bd9Sstevel@tonic-gate 			(void) printf(" %s", show_char(cbuf, (int)*p++));
8127c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
8137c478bd9Sstevel@tonic-gate 	}
8147c478bd9Sstevel@tonic-gate }
8157c478bd9Sstevel@tonic-gate 
8167c478bd9Sstevel@tonic-gate void
8177c478bd9Sstevel@tonic-gate show_termcb(private_t *pri, long offset)
8187c478bd9Sstevel@tonic-gate {
8197c478bd9Sstevel@tonic-gate 	struct termcb termcb;
8207c478bd9Sstevel@tonic-gate 
8217c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &termcb, sizeof (termcb), offset) == sizeof (termcb)) {
8227c478bd9Sstevel@tonic-gate 		(void) printf(
823019c3c43Sraf 		    "%s\tflgs=0%.2o termt=%d crow=%d ccol=%d vrow=%d lrow=%d\n",
824019c3c43Sraf 		    pri->pname,
825019c3c43Sraf 		    termcb.st_flgs&0xff,
826019c3c43Sraf 		    termcb.st_termt&0xff,
827019c3c43Sraf 		    termcb.st_crow&0xff,
828019c3c43Sraf 		    termcb.st_ccol&0xff,
829019c3c43Sraf 		    termcb.st_vrow&0xff,
830019c3c43Sraf 		    termcb.st_lrow&0xff);
8317c478bd9Sstevel@tonic-gate 	}
8327c478bd9Sstevel@tonic-gate }
8337c478bd9Sstevel@tonic-gate 
8347c478bd9Sstevel@tonic-gate /* integer value pointed to by ioctl() arg */
8357c478bd9Sstevel@tonic-gate void
8367c478bd9Sstevel@tonic-gate show_strint(private_t *pri, int code, long offset)
8377c478bd9Sstevel@tonic-gate {
8387c478bd9Sstevel@tonic-gate 	int val;
8397c478bd9Sstevel@tonic-gate 
8407c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) {
8417c478bd9Sstevel@tonic-gate 		const char *s = NULL;
8427c478bd9Sstevel@tonic-gate 
8437c478bd9Sstevel@tonic-gate 		switch (code) {		/* interpret these symbolically */
8447c478bd9Sstevel@tonic-gate 		case I_GRDOPT:
8457c478bd9Sstevel@tonic-gate 			s = strrdopt(val);
8467c478bd9Sstevel@tonic-gate 			break;
8477c478bd9Sstevel@tonic-gate 		case I_GETSIG:
8487c478bd9Sstevel@tonic-gate 			s = strevents(pri, val);
8497c478bd9Sstevel@tonic-gate 			break;
8507c478bd9Sstevel@tonic-gate 		case TIOCFLUSH:
8517c478bd9Sstevel@tonic-gate 			s = tiocflush(pri, val);
8527c478bd9Sstevel@tonic-gate 			break;
8537c478bd9Sstevel@tonic-gate 		}
8547c478bd9Sstevel@tonic-gate 
8557c478bd9Sstevel@tonic-gate 		if (s == NULL)
8567c478bd9Sstevel@tonic-gate 			(void) printf("%s\t0x%.8lX: %d\n",
857019c3c43Sraf 			    pri->pname, offset, val);
8587c478bd9Sstevel@tonic-gate 		else
8597c478bd9Sstevel@tonic-gate 			(void) printf("%s\t0x%.8lX: %s\n",
860019c3c43Sraf 			    pri->pname, offset, s);
8617c478bd9Sstevel@tonic-gate 	}
8627c478bd9Sstevel@tonic-gate }
8637c478bd9Sstevel@tonic-gate 
8647c478bd9Sstevel@tonic-gate void
8657c478bd9Sstevel@tonic-gate show_strioctl(private_t *pri, long offset)
8667c478bd9Sstevel@tonic-gate {
8677c478bd9Sstevel@tonic-gate 	struct strioctl strioctl;
8687c478bd9Sstevel@tonic-gate 
8697c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strioctl, sizeof (strioctl), offset) ==
8707c478bd9Sstevel@tonic-gate 	    sizeof (strioctl)) {
8717c478bd9Sstevel@tonic-gate 		(void) printf(
872019c3c43Sraf 		    "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n",
873019c3c43Sraf 		    pri->pname,
874019c3c43Sraf 		    ioctlname(pri, strioctl.ic_cmd),
875019c3c43Sraf 		    strioctl.ic_timout,
876019c3c43Sraf 		    strioctl.ic_len,
877019c3c43Sraf 		    (long)strioctl.ic_dp);
8787c478bd9Sstevel@tonic-gate 
8797c478bd9Sstevel@tonic-gate 		if (pri->recur++ == 0)	/* avoid indefinite recursion */
8807c478bd9Sstevel@tonic-gate 			show_ioctl(pri, strioctl.ic_cmd,
881019c3c43Sraf 			    (long)strioctl.ic_dp);
8827c478bd9Sstevel@tonic-gate 		--pri->recur;
8837c478bd9Sstevel@tonic-gate 	}
8847c478bd9Sstevel@tonic-gate }
8857c478bd9Sstevel@tonic-gate 
8867c478bd9Sstevel@tonic-gate #ifdef _LP64
8877c478bd9Sstevel@tonic-gate void
8887c478bd9Sstevel@tonic-gate show_strioctl32(private_t *pri, long offset)
8897c478bd9Sstevel@tonic-gate {
8907c478bd9Sstevel@tonic-gate 	struct strioctl32 strioctl;
8917c478bd9Sstevel@tonic-gate 
8927c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strioctl, sizeof (strioctl), offset) ==
8937c478bd9Sstevel@tonic-gate 	    sizeof (strioctl)) {
8947c478bd9Sstevel@tonic-gate 		(void) printf(
895019c3c43Sraf 		    "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n",
896019c3c43Sraf 		    pri->pname,
897019c3c43Sraf 		    ioctlname(pri, strioctl.ic_cmd),
898019c3c43Sraf 		    strioctl.ic_timout,
899019c3c43Sraf 		    strioctl.ic_len,
900019c3c43Sraf 		    (long)strioctl.ic_dp);
9017c478bd9Sstevel@tonic-gate 
9027c478bd9Sstevel@tonic-gate 		if (pri->recur++ == 0)	/* avoid indefinite recursion */
9037c478bd9Sstevel@tonic-gate 			show_ioctl(pri, strioctl.ic_cmd,
904019c3c43Sraf 			    (long)strioctl.ic_dp);
9057c478bd9Sstevel@tonic-gate 		--pri->recur;
9067c478bd9Sstevel@tonic-gate 	}
9077c478bd9Sstevel@tonic-gate }
9087c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
9097c478bd9Sstevel@tonic-gate 
9107c478bd9Sstevel@tonic-gate void
9117c478bd9Sstevel@tonic-gate print_strbuf(private_t *pri, struct strbuf *sp, const char *name, int dump)
9127c478bd9Sstevel@tonic-gate {
9137c478bd9Sstevel@tonic-gate 	(void) printf(
914019c3c43Sraf 	    "%s\t%s:  maxlen=%-4d len=%-4d buf=0x%.8lX",
915019c3c43Sraf 	    pri->pname,
916019c3c43Sraf 	    name,
917019c3c43Sraf 	    sp->maxlen,
918019c3c43Sraf 	    sp->len,
919019c3c43Sraf 	    (long)sp->buf);
9207c478bd9Sstevel@tonic-gate 	/*
9217c478bd9Sstevel@tonic-gate 	 * Should we show the buffer contents?
9227c478bd9Sstevel@tonic-gate 	 * Keyed to the '-r fds' and '-w fds' options?
9237c478bd9Sstevel@tonic-gate 	 */
9247c478bd9Sstevel@tonic-gate 	if (sp->buf == NULL || sp->len <= 0)
9257c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
9267c478bd9Sstevel@tonic-gate 	else {
9277c478bd9Sstevel@tonic-gate 		int nb = (sp->len > 8)? 8 : sp->len;
9287c478bd9Sstevel@tonic-gate 		char buffer[8];
9297c478bd9Sstevel@tonic-gate 		char obuf[40];
9307c478bd9Sstevel@tonic-gate 
9317c478bd9Sstevel@tonic-gate 		if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) {
9327c478bd9Sstevel@tonic-gate 			(void) strcpy(obuf, ": \"");
9337c478bd9Sstevel@tonic-gate 			showbytes(buffer, nb, obuf+3);
9347c478bd9Sstevel@tonic-gate 			(void) strcat(obuf,
935019c3c43Sraf 			    (nb == sp->len)?
936019c3c43Sraf 			    (const char *)"\"" : (const char *)"\"..");
9377c478bd9Sstevel@tonic-gate 			(void) fputs(obuf, stdout);
9387c478bd9Sstevel@tonic-gate 		}
9397c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
9407c478bd9Sstevel@tonic-gate 		if (dump && sp->len > 8)
9417c478bd9Sstevel@tonic-gate 			showbuffer(pri, (long)sp->buf, (long)sp->len);
9427c478bd9Sstevel@tonic-gate 	}
9437c478bd9Sstevel@tonic-gate }
9447c478bd9Sstevel@tonic-gate 
9457c478bd9Sstevel@tonic-gate #ifdef _LP64
9467c478bd9Sstevel@tonic-gate void
9477c478bd9Sstevel@tonic-gate print_strbuf32(private_t *pri, struct strbuf32 *sp, const char *name, int dump)
9487c478bd9Sstevel@tonic-gate {
9497c478bd9Sstevel@tonic-gate 	(void) printf(
950019c3c43Sraf 	    "%s\t%s:  maxlen=%-4d len=%-4d buf=0x%.8lX",
951019c3c43Sraf 	    pri->pname,
952019c3c43Sraf 	    name,
953019c3c43Sraf 	    sp->maxlen,
954019c3c43Sraf 	    sp->len,
955019c3c43Sraf 	    (long)sp->buf);
9567c478bd9Sstevel@tonic-gate 	/*
9577c478bd9Sstevel@tonic-gate 	 * Should we show the buffer contents?
9587c478bd9Sstevel@tonic-gate 	 * Keyed to the '-r fds' and '-w fds' options?
9597c478bd9Sstevel@tonic-gate 	 */
9607c478bd9Sstevel@tonic-gate 	if (sp->buf == NULL || sp->len <= 0)
9617c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
9627c478bd9Sstevel@tonic-gate 	else {
9637c478bd9Sstevel@tonic-gate 		int nb = (sp->len > 8)? 8 : sp->len;
9647c478bd9Sstevel@tonic-gate 		char buffer[8];
9657c478bd9Sstevel@tonic-gate 		char obuf[40];
9667c478bd9Sstevel@tonic-gate 
9677c478bd9Sstevel@tonic-gate 		if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) {
9687c478bd9Sstevel@tonic-gate 			(void) strcpy(obuf, ": \"");
9697c478bd9Sstevel@tonic-gate 			showbytes(buffer, nb, obuf+3);
9707c478bd9Sstevel@tonic-gate 			(void) strcat(obuf,
971019c3c43Sraf 			    (nb == sp->len)?
972019c3c43Sraf 			    (const char *)"\"" : (const char *)"\"..");
9737c478bd9Sstevel@tonic-gate 			(void) fputs(obuf, stdout);
9747c478bd9Sstevel@tonic-gate 		}
9757c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
9767c478bd9Sstevel@tonic-gate 		if (dump && sp->len > 8)
9777c478bd9Sstevel@tonic-gate 			showbuffer(pri, (long)sp->buf, (long)sp->len);
9787c478bd9Sstevel@tonic-gate 	}
9797c478bd9Sstevel@tonic-gate }
9807c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
9817c478bd9Sstevel@tonic-gate 
9827c478bd9Sstevel@tonic-gate /* strpeek and strfdinsert flags word */
9837c478bd9Sstevel@tonic-gate const char *
9847c478bd9Sstevel@tonic-gate strflags(private_t *pri, int flags)
9857c478bd9Sstevel@tonic-gate {
9867c478bd9Sstevel@tonic-gate 	const char *s;
9877c478bd9Sstevel@tonic-gate 
9887c478bd9Sstevel@tonic-gate 	switch (flags) {
9897c478bd9Sstevel@tonic-gate 	case 0:
9907c478bd9Sstevel@tonic-gate 		s = "0";
9917c478bd9Sstevel@tonic-gate 		break;
9927c478bd9Sstevel@tonic-gate 	case RS_HIPRI:
9937c478bd9Sstevel@tonic-gate 		s = "RS_HIPRI";
9947c478bd9Sstevel@tonic-gate 		break;
9957c478bd9Sstevel@tonic-gate 	default:
9967c478bd9Sstevel@tonic-gate 		(void) sprintf(pri->code_buf, "0x%.4X", flags);
9977c478bd9Sstevel@tonic-gate 		s = pri->code_buf;
9987c478bd9Sstevel@tonic-gate 	}
9997c478bd9Sstevel@tonic-gate 
10007c478bd9Sstevel@tonic-gate 	return (s);
10017c478bd9Sstevel@tonic-gate }
10027c478bd9Sstevel@tonic-gate 
10037c478bd9Sstevel@tonic-gate void
10047c478bd9Sstevel@tonic-gate show_strpeek(private_t *pri, long offset)
10057c478bd9Sstevel@tonic-gate {
10067c478bd9Sstevel@tonic-gate 	struct strpeek strpeek;
10077c478bd9Sstevel@tonic-gate 
10087c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strpeek, sizeof (strpeek), offset)
10097c478bd9Sstevel@tonic-gate 	    == sizeof (strpeek)) {
10107c478bd9Sstevel@tonic-gate 
10117c478bd9Sstevel@tonic-gate 		print_strbuf(pri, &strpeek.ctlbuf, "ctl", FALSE);
10127c478bd9Sstevel@tonic-gate 		print_strbuf(pri, &strpeek.databuf, "dat", FALSE);
10137c478bd9Sstevel@tonic-gate 
10147c478bd9Sstevel@tonic-gate 		(void) printf("%s\tflags=%s\n",
1015019c3c43Sraf 		    pri->pname,
1016019c3c43Sraf 		    strflags(pri, strpeek.flags));
10177c478bd9Sstevel@tonic-gate 	}
10187c478bd9Sstevel@tonic-gate }
10197c478bd9Sstevel@tonic-gate 
10207c478bd9Sstevel@tonic-gate #ifdef _LP64
10217c478bd9Sstevel@tonic-gate void
10227c478bd9Sstevel@tonic-gate show_strpeek32(private_t *pri, long offset)
10237c478bd9Sstevel@tonic-gate {
10247c478bd9Sstevel@tonic-gate 	struct strpeek32 strpeek;
10257c478bd9Sstevel@tonic-gate 
10267c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strpeek, sizeof (strpeek), offset)
10277c478bd9Sstevel@tonic-gate 	    == sizeof (strpeek)) {
10287c478bd9Sstevel@tonic-gate 
10297c478bd9Sstevel@tonic-gate 		print_strbuf32(pri, &strpeek.ctlbuf, "ctl", FALSE);
10307c478bd9Sstevel@tonic-gate 		print_strbuf32(pri, &strpeek.databuf, "dat", FALSE);
10317c478bd9Sstevel@tonic-gate 
10327c478bd9Sstevel@tonic-gate 		(void) printf("%s\tflags=%s\n",
1033019c3c43Sraf 		    pri->pname,
1034019c3c43Sraf 		    strflags(pri, strpeek.flags));
10357c478bd9Sstevel@tonic-gate 	}
10367c478bd9Sstevel@tonic-gate }
10377c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
10387c478bd9Sstevel@tonic-gate 
10397c478bd9Sstevel@tonic-gate void
10407c478bd9Sstevel@tonic-gate show_strfdinsert(private_t *pri, long offset)
10417c478bd9Sstevel@tonic-gate {
10427c478bd9Sstevel@tonic-gate 	struct strfdinsert strfdinsert;
10437c478bd9Sstevel@tonic-gate 
10447c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) ==
10457c478bd9Sstevel@tonic-gate 	    sizeof (strfdinsert)) {
10467c478bd9Sstevel@tonic-gate 
10477c478bd9Sstevel@tonic-gate 		print_strbuf(pri, &strfdinsert.ctlbuf, "ctl", FALSE);
10487c478bd9Sstevel@tonic-gate 		print_strbuf(pri, &strfdinsert.databuf, "dat", FALSE);
10497c478bd9Sstevel@tonic-gate 
10507c478bd9Sstevel@tonic-gate 		(void) printf("%s\tflags=%s fildes=%d offset=%d\n",
1051019c3c43Sraf 		    pri->pname,
1052019c3c43Sraf 		    strflags(pri, strfdinsert.flags),
1053019c3c43Sraf 		    strfdinsert.fildes,
1054019c3c43Sraf 		    strfdinsert.offset);
10557c478bd9Sstevel@tonic-gate 	}
10567c478bd9Sstevel@tonic-gate }
10577c478bd9Sstevel@tonic-gate 
10587c478bd9Sstevel@tonic-gate #ifdef _LP64
10597c478bd9Sstevel@tonic-gate void
10607c478bd9Sstevel@tonic-gate show_strfdinsert32(private_t *pri, long offset)
10617c478bd9Sstevel@tonic-gate {
10627c478bd9Sstevel@tonic-gate 	struct strfdinsert32 strfdinsert;
10637c478bd9Sstevel@tonic-gate 
10647c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) ==
10657c478bd9Sstevel@tonic-gate 	    sizeof (strfdinsert)) {
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate 		print_strbuf32(pri, &strfdinsert.ctlbuf, "ctl", FALSE);
10687c478bd9Sstevel@tonic-gate 		print_strbuf32(pri, &strfdinsert.databuf, "dat", FALSE);
10697c478bd9Sstevel@tonic-gate 
10707c478bd9Sstevel@tonic-gate 		(void) printf("%s\tflags=%s fildes=%d offset=%d\n",
1071019c3c43Sraf 		    pri->pname,
1072019c3c43Sraf 		    strflags(pri, strfdinsert.flags),
1073019c3c43Sraf 		    strfdinsert.fildes,
1074019c3c43Sraf 		    strfdinsert.offset);
10757c478bd9Sstevel@tonic-gate 	}
10767c478bd9Sstevel@tonic-gate }
10777c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
10787c478bd9Sstevel@tonic-gate 
10797c478bd9Sstevel@tonic-gate void
10807c478bd9Sstevel@tonic-gate show_strrecvfd(private_t *pri, long offset)
10817c478bd9Sstevel@tonic-gate {
10827c478bd9Sstevel@tonic-gate 	struct strrecvfd strrecvfd;
10837c478bd9Sstevel@tonic-gate 
10847c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strrecvfd, sizeof (strrecvfd), offset) ==
10857c478bd9Sstevel@tonic-gate 	    sizeof (strrecvfd)) {
10867c478bd9Sstevel@tonic-gate 		(void) printf(
1087019c3c43Sraf 		    "%s\tfd=%-5d uid=%-5u gid=%u\n",
1088019c3c43Sraf 		    pri->pname,
1089019c3c43Sraf 		    strrecvfd.fd,
1090019c3c43Sraf 		    strrecvfd.uid,
1091019c3c43Sraf 		    strrecvfd.gid);
10927c478bd9Sstevel@tonic-gate 	}
10937c478bd9Sstevel@tonic-gate }
10947c478bd9Sstevel@tonic-gate 
10957c478bd9Sstevel@tonic-gate void
10967c478bd9Sstevel@tonic-gate show_strlist(private_t *pri, long offset)
10977c478bd9Sstevel@tonic-gate {
10987c478bd9Sstevel@tonic-gate 	struct str_list strlist;
10997c478bd9Sstevel@tonic-gate 	struct str_mlist list;
11007c478bd9Sstevel@tonic-gate 	int count;
11017c478bd9Sstevel@tonic-gate 
11027c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strlist, sizeof (strlist), offset) ==
11037c478bd9Sstevel@tonic-gate 	    sizeof (strlist)) {
11047c478bd9Sstevel@tonic-gate 		(void) printf("%s\tnmods=%d  modlist=0x%.8lX\n",
1105019c3c43Sraf 		    pri->pname,
1106019c3c43Sraf 		    strlist.sl_nmods,
1107019c3c43Sraf 		    (long)strlist.sl_modlist);
11087c478bd9Sstevel@tonic-gate 
11097c478bd9Sstevel@tonic-gate 		count = strlist.sl_nmods;
11107c478bd9Sstevel@tonic-gate 		offset = (long)strlist.sl_modlist;
11117c478bd9Sstevel@tonic-gate 		while (!interrupt && --count >= 0) {
11127c478bd9Sstevel@tonic-gate 			if (Pread(Proc, &list, sizeof (list), offset) !=
11137c478bd9Sstevel@tonic-gate 			    sizeof (list))
11147c478bd9Sstevel@tonic-gate 				break;
11157c478bd9Sstevel@tonic-gate 			(void) printf("%s\t\t\"%.*s\"\n",
1116019c3c43Sraf 			    pri->pname,
1117019c3c43Sraf 			    (int)sizeof (list.l_name),
1118019c3c43Sraf 			    list.l_name);
11197c478bd9Sstevel@tonic-gate 			offset += sizeof (struct str_mlist);
11207c478bd9Sstevel@tonic-gate 		}
11217c478bd9Sstevel@tonic-gate 	}
11227c478bd9Sstevel@tonic-gate }
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate #ifdef _LP64
11257c478bd9Sstevel@tonic-gate void
11267c478bd9Sstevel@tonic-gate show_strlist32(private_t *pri, long offset)
11277c478bd9Sstevel@tonic-gate {
11287c478bd9Sstevel@tonic-gate 	struct str_list32 strlist;
11297c478bd9Sstevel@tonic-gate 	struct str_mlist list;
11307c478bd9Sstevel@tonic-gate 	int count;
11317c478bd9Sstevel@tonic-gate 
11327c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strlist, sizeof (strlist), offset) ==
11337c478bd9Sstevel@tonic-gate 	    sizeof (strlist)) {
11347c478bd9Sstevel@tonic-gate 		(void) printf("%s\tnmods=%d  modlist=0x%.8lX\n",
1135019c3c43Sraf 		    pri->pname,
1136019c3c43Sraf 		    strlist.sl_nmods,
1137019c3c43Sraf 		    (long)strlist.sl_modlist);
11387c478bd9Sstevel@tonic-gate 
11397c478bd9Sstevel@tonic-gate 		count = strlist.sl_nmods;
11407c478bd9Sstevel@tonic-gate 		offset = (long)strlist.sl_modlist;
11417c478bd9Sstevel@tonic-gate 		while (!interrupt && --count >= 0) {
11427c478bd9Sstevel@tonic-gate 			if (Pread(Proc, &list, sizeof (list), offset) !=
11437c478bd9Sstevel@tonic-gate 			    sizeof (list))
11447c478bd9Sstevel@tonic-gate 				break;
11457c478bd9Sstevel@tonic-gate 			(void) printf("%s\t\t\"%.*s\"\n",
1146019c3c43Sraf 			    pri->pname,
1147019c3c43Sraf 			    (int)sizeof (list.l_name),
1148019c3c43Sraf 			    list.l_name);
11497c478bd9Sstevel@tonic-gate 			offset += sizeof (struct str_mlist);
11507c478bd9Sstevel@tonic-gate 		}
11517c478bd9Sstevel@tonic-gate 	}
11527c478bd9Sstevel@tonic-gate }
11537c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
11547c478bd9Sstevel@tonic-gate 
11557c478bd9Sstevel@tonic-gate void
11567c478bd9Sstevel@tonic-gate show_jwinsize(private_t *pri, long offset)
11577c478bd9Sstevel@tonic-gate {
11587c478bd9Sstevel@tonic-gate 	struct jwinsize jwinsize;
11597c478bd9Sstevel@tonic-gate 
11607c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &jwinsize, sizeof (jwinsize), offset) ==
11617c478bd9Sstevel@tonic-gate 	    sizeof (jwinsize)) {
11627c478bd9Sstevel@tonic-gate 		(void) printf(
1163019c3c43Sraf 		    "%s\tbytesx=%-3u bytesy=%-3u bitsx=%-3u bitsy=%-3u\n",
1164019c3c43Sraf 		    pri->pname,
1165019c3c43Sraf 		    (unsigned)jwinsize.bytesx,
1166019c3c43Sraf 		    (unsigned)jwinsize.bytesy,
1167019c3c43Sraf 		    (unsigned)jwinsize.bitsx,
1168019c3c43Sraf 		    (unsigned)jwinsize.bitsy);
11697c478bd9Sstevel@tonic-gate 	}
11707c478bd9Sstevel@tonic-gate }
11717c478bd9Sstevel@tonic-gate 
11727c478bd9Sstevel@tonic-gate void
11737c478bd9Sstevel@tonic-gate show_winsize(private_t *pri, long offset)
11747c478bd9Sstevel@tonic-gate {
11757c478bd9Sstevel@tonic-gate 	struct winsize winsize;
11767c478bd9Sstevel@tonic-gate 
11777c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &winsize, sizeof (winsize), offset)
11787c478bd9Sstevel@tonic-gate 	    == sizeof (winsize)) {
11797c478bd9Sstevel@tonic-gate 		(void) printf(
1180019c3c43Sraf 		    "%s\trow=%-3d col=%-3d xpixel=%-3d ypixel=%-3d\n",
1181019c3c43Sraf 		    pri->pname,
1182019c3c43Sraf 		    winsize.ws_row,
1183019c3c43Sraf 		    winsize.ws_col,
1184019c3c43Sraf 		    winsize.ws_xpixel,
1185019c3c43Sraf 		    winsize.ws_ypixel);
11867c478bd9Sstevel@tonic-gate 	}
11877c478bd9Sstevel@tonic-gate }
11887c478bd9Sstevel@tonic-gate 
11897c478bd9Sstevel@tonic-gate struct audio_stuff {
11907c478bd9Sstevel@tonic-gate 	uint_t	bit;
11917c478bd9Sstevel@tonic-gate 	const char *str;
11927c478bd9Sstevel@tonic-gate };
11937c478bd9Sstevel@tonic-gate 
11947c478bd9Sstevel@tonic-gate const struct audio_stuff audio_output_ports[] = {
11957c478bd9Sstevel@tonic-gate 	{ AUDIO_SPEAKER, "SPEAKER" },
11967c478bd9Sstevel@tonic-gate 	{ AUDIO_HEADPHONE, "HEADPHONE" },
11977c478bd9Sstevel@tonic-gate 	{ AUDIO_LINE_OUT, "LINE_OUT" },
11987c478bd9Sstevel@tonic-gate 	{ AUDIO_SPDIF_OUT, "SPDIF_OUT" },
11997c478bd9Sstevel@tonic-gate 	{ AUDIO_AUX1_OUT, "AUX1_OUT" },
12007c478bd9Sstevel@tonic-gate 	{ AUDIO_AUX2_OUT, "AUX2_OUT" },
12017c478bd9Sstevel@tonic-gate 	{ 0, NULL }
12027c478bd9Sstevel@tonic-gate };
12037c478bd9Sstevel@tonic-gate 
12047c478bd9Sstevel@tonic-gate const struct audio_stuff audio_input_ports[] = {
12057c478bd9Sstevel@tonic-gate 	{ AUDIO_MICROPHONE, "MICROPHONE" },
12067c478bd9Sstevel@tonic-gate 	{ AUDIO_LINE_IN, "LINE_IN" },
12077c478bd9Sstevel@tonic-gate 	{ AUDIO_CD, "CD" },
12087c478bd9Sstevel@tonic-gate 	{ AUDIO_SPDIF_IN, "SPDIF_IN" },
12097c478bd9Sstevel@tonic-gate 	{ AUDIO_AUX1_IN, "AUX1_IN" },
12107c478bd9Sstevel@tonic-gate 	{ AUDIO_AUX2_IN, "AUX2_IN" },
12117c478bd9Sstevel@tonic-gate 	{ AUDIO_CODEC_LOOPB_IN, "CODEC_LOOPB_IN" },
12127c478bd9Sstevel@tonic-gate 	{ AUDIO_SUNVTS, "SUNVTS" },
12137c478bd9Sstevel@tonic-gate 	{ 0, NULL }
12147c478bd9Sstevel@tonic-gate };
12157c478bd9Sstevel@tonic-gate 
12167c478bd9Sstevel@tonic-gate static const struct audio_stuff audio_hw_features[] = {
12177c478bd9Sstevel@tonic-gate 	{ AUDIO_HWFEATURE_DUPLEX, "DUPLEX" },
12187c478bd9Sstevel@tonic-gate 	{ AUDIO_HWFEATURE_MSCODEC, "MSCODEC" },
12197c478bd9Sstevel@tonic-gate 	{ AUDIO_HWFEATURE_IN2OUT, "IN2OUT" },
12207c478bd9Sstevel@tonic-gate 	{ AUDIO_HWFEATURE_PLAY, "PLAY" },
12217c478bd9Sstevel@tonic-gate 	{ AUDIO_HWFEATURE_RECORD, "RECORD" },
12227c478bd9Sstevel@tonic-gate 	{ 0, NULL }
12237c478bd9Sstevel@tonic-gate };
12247c478bd9Sstevel@tonic-gate 
12257c478bd9Sstevel@tonic-gate static const struct audio_stuff audio_sw_features[] = {
12267c478bd9Sstevel@tonic-gate 	{ AUDIO_SWFEATURE_MIXER, "MIXER" },
12277c478bd9Sstevel@tonic-gate 	{ 0, NULL }
12287c478bd9Sstevel@tonic-gate };
12297c478bd9Sstevel@tonic-gate 
12307c478bd9Sstevel@tonic-gate void
12317c478bd9Sstevel@tonic-gate show_audio_features(const private_t *pri,
12327c478bd9Sstevel@tonic-gate 	const struct audio_stuff *audio_porttab, uint_t features,
12337c478bd9Sstevel@tonic-gate 	const char *name)
12347c478bd9Sstevel@tonic-gate {
12357c478bd9Sstevel@tonic-gate 	(void) printf("%s\t%s=", pri->pname, name);
12367c478bd9Sstevel@tonic-gate 	if (features == 0) {
12377c478bd9Sstevel@tonic-gate 		(void) printf("0\n");
12387c478bd9Sstevel@tonic-gate 		return;
12397c478bd9Sstevel@tonic-gate 	}
12407c478bd9Sstevel@tonic-gate 
12417c478bd9Sstevel@tonic-gate 	for (; audio_porttab->bit != 0; ++audio_porttab) {
12427c478bd9Sstevel@tonic-gate 		if (features & audio_porttab->bit) {
12437c478bd9Sstevel@tonic-gate 			(void) printf(audio_porttab->str);
12447c478bd9Sstevel@tonic-gate 			features &= ~audio_porttab->bit;
12457c478bd9Sstevel@tonic-gate 			if (features)
12467c478bd9Sstevel@tonic-gate 				(void) putchar('|');
12477c478bd9Sstevel@tonic-gate 		}
12487c478bd9Sstevel@tonic-gate 	}
12497c478bd9Sstevel@tonic-gate 	if (features)
12507c478bd9Sstevel@tonic-gate 		(void) printf("0x%x", features);
12517c478bd9Sstevel@tonic-gate 	(void) putchar('\n');
12527c478bd9Sstevel@tonic-gate }
12537c478bd9Sstevel@tonic-gate 
12547c478bd9Sstevel@tonic-gate void
12557c478bd9Sstevel@tonic-gate show_audio_ports(private_t *pri, const char *mode,
12567c478bd9Sstevel@tonic-gate 	const char *field, uint_t ports)
12577c478bd9Sstevel@tonic-gate {
12587c478bd9Sstevel@tonic-gate 	const struct audio_stuff *audio_porttab;
12597c478bd9Sstevel@tonic-gate 
12607c478bd9Sstevel@tonic-gate 	(void) printf("%s\t%s\t%s=", pri->pname, mode, field);
12617c478bd9Sstevel@tonic-gate 	if (ports == 0) {
12627c478bd9Sstevel@tonic-gate 		(void) printf("0\n");
12637c478bd9Sstevel@tonic-gate 		return;
12647c478bd9Sstevel@tonic-gate 	}
12657c478bd9Sstevel@tonic-gate 	if (*mode == 'p')
12667c478bd9Sstevel@tonic-gate 		audio_porttab = audio_output_ports;
12677c478bd9Sstevel@tonic-gate 	else
12687c478bd9Sstevel@tonic-gate 		audio_porttab = audio_input_ports;
12697c478bd9Sstevel@tonic-gate 	for (; audio_porttab->bit != 0; ++audio_porttab) {
12707c478bd9Sstevel@tonic-gate 		if (ports & audio_porttab->bit) {
12717c478bd9Sstevel@tonic-gate 			(void) printf(audio_porttab->str);
12727c478bd9Sstevel@tonic-gate 			ports &= ~audio_porttab->bit;
12737c478bd9Sstevel@tonic-gate 			if (ports)
12747c478bd9Sstevel@tonic-gate 				(void) putchar('|');
12757c478bd9Sstevel@tonic-gate 		}
12767c478bd9Sstevel@tonic-gate 	}
12777c478bd9Sstevel@tonic-gate 	if (ports)
12787c478bd9Sstevel@tonic-gate 		(void) printf("0x%x", ports);
12797c478bd9Sstevel@tonic-gate 	(void) putchar('\n');
12807c478bd9Sstevel@tonic-gate }
12817c478bd9Sstevel@tonic-gate 
12827c478bd9Sstevel@tonic-gate void
12837c478bd9Sstevel@tonic-gate show_audio_prinfo(private_t *pri, const char *mode, struct audio_prinfo *au_pr)
12847c478bd9Sstevel@tonic-gate {
12857c478bd9Sstevel@tonic-gate 	const char *s;
12867c478bd9Sstevel@tonic-gate 
12877c478bd9Sstevel@tonic-gate 	/*
12887c478bd9Sstevel@tonic-gate 	 * The following values describe the audio data encoding.
12897c478bd9Sstevel@tonic-gate 	 */
12907c478bd9Sstevel@tonic-gate 
12917c478bd9Sstevel@tonic-gate 	(void) printf("%s\t%s\tsample_rate=%u channels=%u precision=%u\n",
1292019c3c43Sraf 	    pri->pname, mode,
1293019c3c43Sraf 	    au_pr->sample_rate,
1294019c3c43Sraf 	    au_pr->channels,
1295019c3c43Sraf 	    au_pr->precision);
12967c478bd9Sstevel@tonic-gate 
12977c478bd9Sstevel@tonic-gate 	s = NULL;
12987c478bd9Sstevel@tonic-gate 	switch (au_pr->encoding) {
12997c478bd9Sstevel@tonic-gate 	case AUDIO_ENCODING_NONE:	s = "NONE";	break;
13007c478bd9Sstevel@tonic-gate 	case AUDIO_ENCODING_ULAW:	s = "ULAW";	break;
13017c478bd9Sstevel@tonic-gate 	case AUDIO_ENCODING_ALAW:	s = "ALAW";	break;
13027c478bd9Sstevel@tonic-gate 	case AUDIO_ENCODING_LINEAR:	s = "LINEAR";	break;
13037c478bd9Sstevel@tonic-gate 	case AUDIO_ENCODING_DVI:	s = "DVI";	break;
13047c478bd9Sstevel@tonic-gate 	case AUDIO_ENCODING_LINEAR8:	s = "LINEAR8";	break;
13057c478bd9Sstevel@tonic-gate 	}
13067c478bd9Sstevel@tonic-gate 	if (s)
13077c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s\tencoding=%s\n", pri->pname, mode, s);
13087c478bd9Sstevel@tonic-gate 	else {
13097c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s\tencoding=%u\n",
1310019c3c43Sraf 		    pri->pname, mode, au_pr->encoding);
13117c478bd9Sstevel@tonic-gate 	}
13127c478bd9Sstevel@tonic-gate 
13137c478bd9Sstevel@tonic-gate 	/*
13147c478bd9Sstevel@tonic-gate 	 * The following values control audio device configuration
13157c478bd9Sstevel@tonic-gate 	 */
13167c478bd9Sstevel@tonic-gate 
13177c478bd9Sstevel@tonic-gate 	(void) printf(
1318019c3c43Sraf 	    "%s\t%s\tgain=%u buffer_size=%u\n",
1319019c3c43Sraf 	    pri->pname, mode,
1320019c3c43Sraf 	    au_pr->gain,
1321019c3c43Sraf 	    au_pr->buffer_size);
13227c478bd9Sstevel@tonic-gate 	show_audio_ports(pri, mode, "port", au_pr->port);
13237c478bd9Sstevel@tonic-gate 	show_audio_ports(pri, mode, "avail_ports", au_pr->avail_ports);
13247c478bd9Sstevel@tonic-gate 	show_audio_ports(pri, mode, "mod_ports", au_pr->mod_ports);
13257c478bd9Sstevel@tonic-gate 
13267c478bd9Sstevel@tonic-gate 	/*
13277c478bd9Sstevel@tonic-gate 	 * The following values describe driver state
13287c478bd9Sstevel@tonic-gate 	 */
13297c478bd9Sstevel@tonic-gate 
13307c478bd9Sstevel@tonic-gate 	(void) printf("%s\t%s\tsamples=%u eof=%u pause=%u error=%u\n",
1331019c3c43Sraf 	    pri->pname, mode,
1332019c3c43Sraf 	    au_pr->samples,
1333019c3c43Sraf 	    au_pr->eof,
1334019c3c43Sraf 	    au_pr->pause,
1335019c3c43Sraf 	    au_pr->error);
13367c478bd9Sstevel@tonic-gate 	(void) printf("%s\t%s\twaiting=%u balance=%u minordev=%u\n",
1337019c3c43Sraf 	    pri->pname, mode,
1338019c3c43Sraf 	    au_pr->waiting,
1339019c3c43Sraf 	    au_pr->balance,
1340019c3c43Sraf 	    au_pr->minordev);
13417c478bd9Sstevel@tonic-gate 
13427c478bd9Sstevel@tonic-gate 	/*
13437c478bd9Sstevel@tonic-gate 	 * The following values are read-only state flags
13447c478bd9Sstevel@tonic-gate 	 */
13457c478bd9Sstevel@tonic-gate 	(void) printf("%s\t%s\topen=%u active=%u\n",
1346019c3c43Sraf 	    pri->pname, mode,
1347019c3c43Sraf 	    au_pr->open,
1348019c3c43Sraf 	    au_pr->active);
13497c478bd9Sstevel@tonic-gate }
13507c478bd9Sstevel@tonic-gate 
13517c478bd9Sstevel@tonic-gate void
13527c478bd9Sstevel@tonic-gate show_audio_info(private_t *pri, long offset)
13537c478bd9Sstevel@tonic-gate {
13547c478bd9Sstevel@tonic-gate 	struct audio_info au;
13557c478bd9Sstevel@tonic-gate 
13567c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &au, sizeof (au), offset) == sizeof (au)) {
13577c478bd9Sstevel@tonic-gate 		show_audio_prinfo(pri, "play", &au.play);
13587c478bd9Sstevel@tonic-gate 		show_audio_prinfo(pri, "record", &au.record);
13597c478bd9Sstevel@tonic-gate 		(void) printf("%s\tmonitor_gain=%u output_muted=%u\n",
1360019c3c43Sraf 		    pri->pname, au.monitor_gain, au.output_muted);
13617c478bd9Sstevel@tonic-gate 		show_audio_features(pri, audio_hw_features, au.hw_features,
13627c478bd9Sstevel@tonic-gate 		    "hw_features");
13637c478bd9Sstevel@tonic-gate 		show_audio_features(pri, audio_sw_features, au.sw_features,
13647c478bd9Sstevel@tonic-gate 		    "sw_features");
13657c478bd9Sstevel@tonic-gate 		show_audio_features(pri, audio_sw_features,
13667c478bd9Sstevel@tonic-gate 		    au.sw_features_enabled, "sw_features_enabled");
13677c478bd9Sstevel@tonic-gate 	}
13687c478bd9Sstevel@tonic-gate }
13697c478bd9Sstevel@tonic-gate 
13707c478bd9Sstevel@tonic-gate void
13717c478bd9Sstevel@tonic-gate show_ioctl(private_t *pri, int code, long offset)
13727c478bd9Sstevel@tonic-gate {
13737c478bd9Sstevel@tonic-gate 	int lp64 = (data_model == PR_MODEL_LP64);
13747c478bd9Sstevel@tonic-gate 	int err = pri->Errno;	/* don't display output parameters */
13757c478bd9Sstevel@tonic-gate 				/* for a failed system call */
13767c478bd9Sstevel@tonic-gate #ifndef _LP64
13777c478bd9Sstevel@tonic-gate 	if (lp64)
13787c478bd9Sstevel@tonic-gate 		return;
13797c478bd9Sstevel@tonic-gate #endif
13803b862e9aSRoger A. Faulkner 	if (offset == 0)
13817c478bd9Sstevel@tonic-gate 		return;
13827c478bd9Sstevel@tonic-gate 
13837c478bd9Sstevel@tonic-gate 	switch (code) {
13847c478bd9Sstevel@tonic-gate 	case TCGETA:
13857c478bd9Sstevel@tonic-gate 		if (err)
13867c478bd9Sstevel@tonic-gate 			break;
13877c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
13887c478bd9Sstevel@tonic-gate 	case TCSETA:
13897c478bd9Sstevel@tonic-gate 	case TCSETAW:
13907c478bd9Sstevel@tonic-gate 	case TCSETAF:
13917c478bd9Sstevel@tonic-gate 		show_termio(pri, offset);
13927c478bd9Sstevel@tonic-gate 		break;
13937c478bd9Sstevel@tonic-gate 	case TCGETS:
13947c478bd9Sstevel@tonic-gate 		if (err)
13957c478bd9Sstevel@tonic-gate 			break;
13967c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
13977c478bd9Sstevel@tonic-gate 	case TCSETS:
13987c478bd9Sstevel@tonic-gate 	case TCSETSW:
13997c478bd9Sstevel@tonic-gate 	case TCSETSF:
14007c478bd9Sstevel@tonic-gate 		show_termios(pri, offset);
14017c478bd9Sstevel@tonic-gate 		break;
14027c478bd9Sstevel@tonic-gate 	case TCGETX:
14037c478bd9Sstevel@tonic-gate 		if (err)
14047c478bd9Sstevel@tonic-gate 			break;
14057c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
14067c478bd9Sstevel@tonic-gate 	case TCSETX:
14077c478bd9Sstevel@tonic-gate 	case TCSETXW:
14087c478bd9Sstevel@tonic-gate 	case TCSETXF:
14097c478bd9Sstevel@tonic-gate 		show_termiox(pri, offset);
14107c478bd9Sstevel@tonic-gate 		break;
14117c478bd9Sstevel@tonic-gate 	case TIOCGETP:
14127c478bd9Sstevel@tonic-gate 		if (err)
14137c478bd9Sstevel@tonic-gate 			break;
14147c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
14157c478bd9Sstevel@tonic-gate 	case TIOCSETN:
14167c478bd9Sstevel@tonic-gate 	case TIOCSETP:
14177c478bd9Sstevel@tonic-gate 		show_sgttyb(pri, offset);
14187c478bd9Sstevel@tonic-gate 		break;
14197c478bd9Sstevel@tonic-gate 	case TIOCGLTC:
14207c478bd9Sstevel@tonic-gate 		if (err)
14217c478bd9Sstevel@tonic-gate 			break;
14227c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
14237c478bd9Sstevel@tonic-gate 	case TIOCSLTC:
14247c478bd9Sstevel@tonic-gate 		show_ltchars(pri, offset);
14257c478bd9Sstevel@tonic-gate 		break;
14267c478bd9Sstevel@tonic-gate 	case TIOCGETC:
14277c478bd9Sstevel@tonic-gate 		if (err)
14287c478bd9Sstevel@tonic-gate 			break;
14297c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
14307c478bd9Sstevel@tonic-gate 	case TIOCSETC:
14317c478bd9Sstevel@tonic-gate 		show_tchars(pri, offset);
14327c478bd9Sstevel@tonic-gate 		break;
14337c478bd9Sstevel@tonic-gate 	case LDGETT:
14347c478bd9Sstevel@tonic-gate 		if (err)
14357c478bd9Sstevel@tonic-gate 			break;
14367c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
14377c478bd9Sstevel@tonic-gate 	case LDSETT:
14387c478bd9Sstevel@tonic-gate 		show_termcb(pri, offset);
14397c478bd9Sstevel@tonic-gate 		break;
14407c478bd9Sstevel@tonic-gate 	/* streams ioctl()s */
14417c478bd9Sstevel@tonic-gate #if 0
14427c478bd9Sstevel@tonic-gate 		/* these are displayed as strings in the arg list */
14437c478bd9Sstevel@tonic-gate 		/* by prt_ioa().  don't display them again here */
14447c478bd9Sstevel@tonic-gate 	case I_PUSH:
14457c478bd9Sstevel@tonic-gate 	case I_LOOK:
14467c478bd9Sstevel@tonic-gate 	case I_FIND:
14477c478bd9Sstevel@tonic-gate 		/* these are displayed as decimal in the arg list */
14487c478bd9Sstevel@tonic-gate 		/* by prt_ioa().  don't display them again here */
14497c478bd9Sstevel@tonic-gate 	case I_LINK:
14507c478bd9Sstevel@tonic-gate 	case I_UNLINK:
14517c478bd9Sstevel@tonic-gate 	case I_SENDFD:
14527c478bd9Sstevel@tonic-gate 		/* these are displayed symbolically in the arg list */
14537c478bd9Sstevel@tonic-gate 		/* by prt_ioa().  don't display them again here */
14547c478bd9Sstevel@tonic-gate 	case I_SRDOPT:
14557c478bd9Sstevel@tonic-gate 	case I_SETSIG:
14567c478bd9Sstevel@tonic-gate 	case I_FLUSH:
14577c478bd9Sstevel@tonic-gate 		break;
14587c478bd9Sstevel@tonic-gate 		/* this one just ignores the argument */
14597c478bd9Sstevel@tonic-gate 	case I_POP:
14607c478bd9Sstevel@tonic-gate 		break;
14617c478bd9Sstevel@tonic-gate #endif
14627c478bd9Sstevel@tonic-gate 		/* these return something in an int pointed to by arg */
14637c478bd9Sstevel@tonic-gate 	case I_NREAD:
14647c478bd9Sstevel@tonic-gate 	case I_GRDOPT:
14657c478bd9Sstevel@tonic-gate 	case I_GETSIG:
14667c478bd9Sstevel@tonic-gate 	case TIOCGSID:
14677c478bd9Sstevel@tonic-gate 	case TIOCGPGRP:
14687c478bd9Sstevel@tonic-gate 	case TIOCLGET:
14697c478bd9Sstevel@tonic-gate 	case FIONREAD:
14707c478bd9Sstevel@tonic-gate 	case FIORDCHK:
14717c478bd9Sstevel@tonic-gate 		if (err)
14727c478bd9Sstevel@tonic-gate 			break;
14737c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
14747c478bd9Sstevel@tonic-gate 		/* these pass something in an int pointed to by arg */
14757c478bd9Sstevel@tonic-gate 	case TIOCSPGRP:
14767c478bd9Sstevel@tonic-gate 	case TIOCFLUSH:
14777c478bd9Sstevel@tonic-gate 	case TIOCLBIS:
14787c478bd9Sstevel@tonic-gate 	case TIOCLBIC:
14797c478bd9Sstevel@tonic-gate 	case TIOCLSET:
14807c478bd9Sstevel@tonic-gate 		show_strint(pri, code, offset);
14817c478bd9Sstevel@tonic-gate 		break;
14827c478bd9Sstevel@tonic-gate 		/* these all point to structures */
14837c478bd9Sstevel@tonic-gate 	case I_STR:
14847c478bd9Sstevel@tonic-gate #ifdef _LP64
14857c478bd9Sstevel@tonic-gate 		if (lp64)
14867c478bd9Sstevel@tonic-gate 			show_strioctl(pri, offset);
14877c478bd9Sstevel@tonic-gate 		else
14887c478bd9Sstevel@tonic-gate 			show_strioctl32(pri, offset);
14897c478bd9Sstevel@tonic-gate #else
14907c478bd9Sstevel@tonic-gate 		show_strioctl(pri, offset);
14917c478bd9Sstevel@tonic-gate #endif
14927c478bd9Sstevel@tonic-gate 		break;
14937c478bd9Sstevel@tonic-gate 	case I_PEEK:
14947c478bd9Sstevel@tonic-gate #ifdef _LP64
14957c478bd9Sstevel@tonic-gate 		if (lp64)
14967c478bd9Sstevel@tonic-gate 			show_strpeek(pri, offset);
14977c478bd9Sstevel@tonic-gate 		else
14987c478bd9Sstevel@tonic-gate 			show_strpeek32(pri, offset);
14997c478bd9Sstevel@tonic-gate #else
15007c478bd9Sstevel@tonic-gate 		show_strpeek(pri, offset);
15017c478bd9Sstevel@tonic-gate #endif
15027c478bd9Sstevel@tonic-gate 		break;
15037c478bd9Sstevel@tonic-gate 	case I_FDINSERT:
15047c478bd9Sstevel@tonic-gate #ifdef _LP64
15057c478bd9Sstevel@tonic-gate 		if (lp64)
15067c478bd9Sstevel@tonic-gate 			show_strfdinsert(pri, offset);
15077c478bd9Sstevel@tonic-gate 		else
15087c478bd9Sstevel@tonic-gate 			show_strfdinsert32(pri, offset);
15097c478bd9Sstevel@tonic-gate #else
15107c478bd9Sstevel@tonic-gate 		show_strfdinsert(pri, offset);
15117c478bd9Sstevel@tonic-gate #endif
15127c478bd9Sstevel@tonic-gate 		break;
15137c478bd9Sstevel@tonic-gate 	case I_RECVFD:
15147c478bd9Sstevel@tonic-gate 		if (err)
15157c478bd9Sstevel@tonic-gate 			break;
15167c478bd9Sstevel@tonic-gate 		show_strrecvfd(pri, offset);
15177c478bd9Sstevel@tonic-gate 		break;
15187c478bd9Sstevel@tonic-gate 	case I_LIST:
15197c478bd9Sstevel@tonic-gate 		if (err)
15207c478bd9Sstevel@tonic-gate 			break;
15217c478bd9Sstevel@tonic-gate #ifdef _LP64
15227c478bd9Sstevel@tonic-gate 		if (lp64)
15237c478bd9Sstevel@tonic-gate 			show_strlist(pri, offset);
15247c478bd9Sstevel@tonic-gate 		else
15257c478bd9Sstevel@tonic-gate 			show_strlist32(pri, offset);
15267c478bd9Sstevel@tonic-gate #else
15277c478bd9Sstevel@tonic-gate 		show_strlist(pri, offset);
15287c478bd9Sstevel@tonic-gate #endif
15297c478bd9Sstevel@tonic-gate 		break;
15307c478bd9Sstevel@tonic-gate 	case JWINSIZE:
15317c478bd9Sstevel@tonic-gate 		if (err)
15327c478bd9Sstevel@tonic-gate 			break;
15337c478bd9Sstevel@tonic-gate 		show_jwinsize(pri, offset);
15347c478bd9Sstevel@tonic-gate 		break;
15357c478bd9Sstevel@tonic-gate 	case TIOCGWINSZ:
15367c478bd9Sstevel@tonic-gate 		if (err)
15377c478bd9Sstevel@tonic-gate 			break;
15387c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
15397c478bd9Sstevel@tonic-gate 	case TIOCSWINSZ:
15407c478bd9Sstevel@tonic-gate 		show_winsize(pri, offset);
15417c478bd9Sstevel@tonic-gate 		break;
15427c478bd9Sstevel@tonic-gate 	case AUDIO_GETINFO:
15437c478bd9Sstevel@tonic-gate 	case (int)AUDIO_SETINFO:
15447c478bd9Sstevel@tonic-gate 		show_audio_info(pri, offset);
15457c478bd9Sstevel@tonic-gate 		break;
15467c478bd9Sstevel@tonic-gate 
15477c478bd9Sstevel@tonic-gate 	default:
15487c478bd9Sstevel@tonic-gate 		if (code & IOC_INOUT) {
15497c478bd9Sstevel@tonic-gate 			const char *str = ioctldatastruct(code);
15507c478bd9Sstevel@tonic-gate 
15517c478bd9Sstevel@tonic-gate 			(void) printf("\t\t%s",
15527c478bd9Sstevel@tonic-gate 			    (code & IOC_INOUT) == IOC_INOUT ? "write/read" :
15537c478bd9Sstevel@tonic-gate 			    code & IOC_IN ? "write" : "read");
15547c478bd9Sstevel@tonic-gate 			if (str != NULL) {
15557c478bd9Sstevel@tonic-gate 				(void) printf(" (struct %s)\n", str);
15567c478bd9Sstevel@tonic-gate 			} else {
15577c478bd9Sstevel@tonic-gate 				(void) printf(" %d bytes\n",
15587c478bd9Sstevel@tonic-gate 				    (code >> 16) & IOCPARM_MASK);
15597c478bd9Sstevel@tonic-gate 			}
15607c478bd9Sstevel@tonic-gate 		}
15617c478bd9Sstevel@tonic-gate 	}
15627c478bd9Sstevel@tonic-gate }
15637c478bd9Sstevel@tonic-gate 
15647c478bd9Sstevel@tonic-gate void
15657c478bd9Sstevel@tonic-gate show_statvfs(private_t *pri)
15667c478bd9Sstevel@tonic-gate {
15677c478bd9Sstevel@tonic-gate 	long offset;
15687c478bd9Sstevel@tonic-gate 	struct statvfs statvfs;
15697c478bd9Sstevel@tonic-gate 	char *cp;
15707c478bd9Sstevel@tonic-gate 
15717c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL &&
15727c478bd9Sstevel@tonic-gate 	    Pread(Proc, &statvfs, sizeof (statvfs), offset)
15737c478bd9Sstevel@tonic-gate 	    == sizeof (statvfs)) {
15747c478bd9Sstevel@tonic-gate 		(void) printf(
15757c478bd9Sstevel@tonic-gate 		"%s\tbsize=%-10lu frsize=%-9lu blocks=%-8llu bfree=%-9llu\n",
1576019c3c43Sraf 		    pri->pname,
1577019c3c43Sraf 		    statvfs.f_bsize,
1578019c3c43Sraf 		    statvfs.f_frsize,
1579019c3c43Sraf 		    (u_longlong_t)statvfs.f_blocks,
1580019c3c43Sraf 		    (u_longlong_t)statvfs.f_bfree);
15817c478bd9Sstevel@tonic-gate 		(void) printf(
15827c478bd9Sstevel@tonic-gate 		"%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n",
1583019c3c43Sraf 		    pri->pname,
1584019c3c43Sraf 		    (u_longlong_t)statvfs.f_bavail,
1585019c3c43Sraf 		    (u_longlong_t)statvfs.f_files,
1586019c3c43Sraf 		    (u_longlong_t)statvfs.f_ffree,
1587019c3c43Sraf 		    (u_longlong_t)statvfs.f_favail);
15887c478bd9Sstevel@tonic-gate 		(void) printf(
1589019c3c43Sraf 		    "%s\tfsid=0x%-9.4lX basetype=%-7.16s namemax=%ld\n",
1590019c3c43Sraf 		    pri->pname,
1591019c3c43Sraf 		    statvfs.f_fsid,
1592019c3c43Sraf 		    statvfs.f_basetype,
1593019c3c43Sraf 		    (long)statvfs.f_namemax);
15947c478bd9Sstevel@tonic-gate 		(void) printf(
1595019c3c43Sraf 		    "%s\tflag=%s\n",
1596019c3c43Sraf 		    pri->pname,
1597019c3c43Sraf 		    svfsflags(pri, (ulong_t)statvfs.f_flag));
15987c478bd9Sstevel@tonic-gate 		cp = statvfs.f_fstr + strlen(statvfs.f_fstr);
15997c478bd9Sstevel@tonic-gate 		if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 &&
16007c478bd9Sstevel@tonic-gate 		    *(cp+1) != '\0')
16017c478bd9Sstevel@tonic-gate 			*cp = ' ';
16027c478bd9Sstevel@tonic-gate 		(void) printf("%s\tfstr=\"%.*s\"\n",
1603019c3c43Sraf 		    pri->pname,
1604019c3c43Sraf 		    (int)sizeof (statvfs.f_fstr),
1605019c3c43Sraf 		    statvfs.f_fstr);
16067c478bd9Sstevel@tonic-gate 	}
16077c478bd9Sstevel@tonic-gate }
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate #ifdef _LP64
16107c478bd9Sstevel@tonic-gate void
16117c478bd9Sstevel@tonic-gate show_statvfs32(private_t *pri)
16127c478bd9Sstevel@tonic-gate {
16137c478bd9Sstevel@tonic-gate 	long offset;
16147c478bd9Sstevel@tonic-gate 	struct statvfs32 statvfs;
16157c478bd9Sstevel@tonic-gate 	char *cp;
16167c478bd9Sstevel@tonic-gate 
16177c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL &&
16187c478bd9Sstevel@tonic-gate 	    Pread(Proc, &statvfs, sizeof (statvfs), offset)
16197c478bd9Sstevel@tonic-gate 	    == sizeof (statvfs)) {
16207c478bd9Sstevel@tonic-gate 		(void) printf(
1621019c3c43Sraf 		    "%s\tbsize=%-10u frsize=%-9u blocks=%-8u bfree=%-9u\n",
1622019c3c43Sraf 		    pri->pname,
1623019c3c43Sraf 		    statvfs.f_bsize,
1624019c3c43Sraf 		    statvfs.f_frsize,
1625019c3c43Sraf 		    statvfs.f_blocks,
1626019c3c43Sraf 		    statvfs.f_bfree);
16277c478bd9Sstevel@tonic-gate 		(void) printf(
1628019c3c43Sraf 		    "%s\tbavail=%-9u files=%-10u ffree=%-9u favail=%-9u\n",
1629019c3c43Sraf 		    pri->pname,
1630019c3c43Sraf 		    statvfs.f_bavail,
1631019c3c43Sraf 		    statvfs.f_files,
1632019c3c43Sraf 		    statvfs.f_ffree,
1633019c3c43Sraf 		    statvfs.f_favail);
16347c478bd9Sstevel@tonic-gate 		(void) printf(
1635019c3c43Sraf 		    "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n",
1636019c3c43Sraf 		    pri->pname,
1637019c3c43Sraf 		    statvfs.f_fsid,
1638019c3c43Sraf 		    statvfs.f_basetype,
1639019c3c43Sraf 		    (int)statvfs.f_namemax);
16407c478bd9Sstevel@tonic-gate 		(void) printf(
1641019c3c43Sraf 		    "%s\tflag=%s\n",
1642019c3c43Sraf 		    pri->pname,
1643019c3c43Sraf 		    svfsflags(pri, (ulong_t)statvfs.f_flag));
16447c478bd9Sstevel@tonic-gate 		cp = statvfs.f_fstr + strlen(statvfs.f_fstr);
16457c478bd9Sstevel@tonic-gate 		if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 &&
16467c478bd9Sstevel@tonic-gate 		    *(cp+1) != '\0')
16477c478bd9Sstevel@tonic-gate 			*cp = ' ';
16487c478bd9Sstevel@tonic-gate 		(void) printf("%s\tfstr=\"%.*s\"\n",
1649019c3c43Sraf 		    pri->pname,
1650019c3c43Sraf 		    (int)sizeof (statvfs.f_fstr),
1651019c3c43Sraf 		    statvfs.f_fstr);
16527c478bd9Sstevel@tonic-gate 	}
16537c478bd9Sstevel@tonic-gate }
16547c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
16557c478bd9Sstevel@tonic-gate 
16567c478bd9Sstevel@tonic-gate void
16577c478bd9Sstevel@tonic-gate show_statvfs64(private_t *pri)
16587c478bd9Sstevel@tonic-gate {
16597c478bd9Sstevel@tonic-gate 	long offset;
16607c478bd9Sstevel@tonic-gate 	struct statvfs64_32 statvfs;
16617c478bd9Sstevel@tonic-gate 	char *cp;
16627c478bd9Sstevel@tonic-gate 
16637c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL &&
16647c478bd9Sstevel@tonic-gate 	    Pread(Proc, &statvfs, sizeof (statvfs), offset)
16657c478bd9Sstevel@tonic-gate 	    == sizeof (statvfs)) {
16667c478bd9Sstevel@tonic-gate 		(void) printf(
1667019c3c43Sraf 		    "%s\tbsize=%-10u frsize=%-9u blocks=%-8llu bfree=%-9llu\n",
1668019c3c43Sraf 		    pri->pname,
1669019c3c43Sraf 		    statvfs.f_bsize,
1670019c3c43Sraf 		    statvfs.f_frsize,
1671019c3c43Sraf 		    (u_longlong_t)statvfs.f_blocks,
1672019c3c43Sraf 		    (u_longlong_t)statvfs.f_bfree);
16737c478bd9Sstevel@tonic-gate 		(void) printf(
16747c478bd9Sstevel@tonic-gate 		"%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n",
1675019c3c43Sraf 		    pri->pname,
1676019c3c43Sraf 		    (u_longlong_t)statvfs.f_bavail,
1677019c3c43Sraf 		    (u_longlong_t)statvfs.f_files,
1678019c3c43Sraf 		    (u_longlong_t)statvfs.f_ffree,
1679019c3c43Sraf 		    (u_longlong_t)statvfs.f_favail);
16807c478bd9Sstevel@tonic-gate 		(void) printf(
1681019c3c43Sraf 		    "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n",
1682019c3c43Sraf 		    pri->pname,
1683019c3c43Sraf 		    statvfs.f_fsid,
1684019c3c43Sraf 		    statvfs.f_basetype,
1685019c3c43Sraf 		    (int)statvfs.f_namemax);
16867c478bd9Sstevel@tonic-gate 		(void) printf(
1687019c3c43Sraf 		    "%s\tflag=%s\n",
1688019c3c43Sraf 		    pri->pname,
1689019c3c43Sraf 		    svfsflags(pri, (ulong_t)statvfs.f_flag));
16907c478bd9Sstevel@tonic-gate 		cp = statvfs.f_fstr + strlen(statvfs.f_fstr);
16917c478bd9Sstevel@tonic-gate 		if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 &&
16927c478bd9Sstevel@tonic-gate 		    *(cp+1) != '\0')
16937c478bd9Sstevel@tonic-gate 			*cp = ' ';
16947c478bd9Sstevel@tonic-gate 		(void) printf("%s\tfstr=\"%.*s\"\n",
1695019c3c43Sraf 		    pri->pname,
1696019c3c43Sraf 		    (int)sizeof (statvfs.f_fstr),
1697019c3c43Sraf 		    statvfs.f_fstr);
16987c478bd9Sstevel@tonic-gate 	}
16997c478bd9Sstevel@tonic-gate }
17007c478bd9Sstevel@tonic-gate 
17017c478bd9Sstevel@tonic-gate void
17027c478bd9Sstevel@tonic-gate show_statfs(private_t *pri)
17037c478bd9Sstevel@tonic-gate {
17047c478bd9Sstevel@tonic-gate 	long offset;
17057c478bd9Sstevel@tonic-gate 	struct statfs statfs;
17067c478bd9Sstevel@tonic-gate 
17077c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL &&
17087c478bd9Sstevel@tonic-gate 	    Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) {
17097c478bd9Sstevel@tonic-gate 		(void) printf(
17107c478bd9Sstevel@tonic-gate 		"%s\tfty=%d bsz=%ld fsz=%ld blk=%ld bfr=%ld fil=%lu ffr=%lu\n",
1711019c3c43Sraf 		    pri->pname,
1712019c3c43Sraf 		    statfs.f_fstyp,
1713019c3c43Sraf 		    statfs.f_bsize,
1714019c3c43Sraf 		    statfs.f_frsize,
1715019c3c43Sraf 		    statfs.f_blocks,
1716019c3c43Sraf 		    statfs.f_bfree,
1717019c3c43Sraf 		    statfs.f_files,
1718019c3c43Sraf 		    statfs.f_ffree);
17197c478bd9Sstevel@tonic-gate 		(void) printf("%s\t    fname=%.6s fpack=%.6s\n",
1720019c3c43Sraf 		    pri->pname,
1721019c3c43Sraf 		    statfs.f_fname,
1722019c3c43Sraf 		    statfs.f_fpack);
17237c478bd9Sstevel@tonic-gate 	}
17247c478bd9Sstevel@tonic-gate }
17257c478bd9Sstevel@tonic-gate 
17267c478bd9Sstevel@tonic-gate #ifdef _LP64
17277c478bd9Sstevel@tonic-gate void
17287c478bd9Sstevel@tonic-gate show_statfs32(private_t *pri)
17297c478bd9Sstevel@tonic-gate {
17307c478bd9Sstevel@tonic-gate 	long offset;
17317c478bd9Sstevel@tonic-gate 	struct statfs32 statfs;
17327c478bd9Sstevel@tonic-gate 
17337c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL &&
17347c478bd9Sstevel@tonic-gate 	    Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) {
17357c478bd9Sstevel@tonic-gate 		(void) printf(
1736019c3c43Sraf 		    "%s\tfty=%d bsz=%d fsz=%d blk=%d bfr=%d fil=%u ffr=%u\n",
1737019c3c43Sraf 		    pri->pname,
1738019c3c43Sraf 		    statfs.f_fstyp,
1739019c3c43Sraf 		    statfs.f_bsize,
1740019c3c43Sraf 		    statfs.f_frsize,
1741019c3c43Sraf 		    statfs.f_blocks,
1742019c3c43Sraf 		    statfs.f_bfree,
1743019c3c43Sraf 		    statfs.f_files,
1744019c3c43Sraf 		    statfs.f_ffree);
17457c478bd9Sstevel@tonic-gate 		(void) printf("%s\t    fname=%.6s fpack=%.6s\n",
1746019c3c43Sraf 		    pri->pname,
1747019c3c43Sraf 		    statfs.f_fname,
1748019c3c43Sraf 		    statfs.f_fpack);
17497c478bd9Sstevel@tonic-gate 	}
17507c478bd9Sstevel@tonic-gate }
17517c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
17527c478bd9Sstevel@tonic-gate 
17537c478bd9Sstevel@tonic-gate void
17547c478bd9Sstevel@tonic-gate show_flock32(private_t *pri, long offset)
17557c478bd9Sstevel@tonic-gate {
17567c478bd9Sstevel@tonic-gate 	struct flock32 flock;
17577c478bd9Sstevel@tonic-gate 
17587c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) {
17597c478bd9Sstevel@tonic-gate 		const char *str = NULL;
17607c478bd9Sstevel@tonic-gate 
17617c478bd9Sstevel@tonic-gate 		(void) printf("%s\ttyp=", pri->pname);
17627c478bd9Sstevel@tonic-gate 
17637c478bd9Sstevel@tonic-gate 		switch (flock.l_type) {
17647c478bd9Sstevel@tonic-gate 		case F_RDLCK:
17657c478bd9Sstevel@tonic-gate 			str = "F_RDLCK";
17667c478bd9Sstevel@tonic-gate 			break;
17677c478bd9Sstevel@tonic-gate 		case F_WRLCK:
17687c478bd9Sstevel@tonic-gate 			str = "F_WRLCK";
17697c478bd9Sstevel@tonic-gate 			break;
17707c478bd9Sstevel@tonic-gate 		case F_UNLCK:
17717c478bd9Sstevel@tonic-gate 			str = "F_UNLCK";
17727c478bd9Sstevel@tonic-gate 			break;
17737c478bd9Sstevel@tonic-gate 		}
17747c478bd9Sstevel@tonic-gate 		if (str != NULL)
17757c478bd9Sstevel@tonic-gate 			(void) printf("%s", str);
17767c478bd9Sstevel@tonic-gate 		else
17777c478bd9Sstevel@tonic-gate 			(void) printf("%-7d", flock.l_type);
17787c478bd9Sstevel@tonic-gate 
17797c478bd9Sstevel@tonic-gate 		str = whencearg(flock.l_whence);
17807c478bd9Sstevel@tonic-gate 		if (str != NULL)
17817c478bd9Sstevel@tonic-gate 			(void) printf("  whence=%s", str);
17827c478bd9Sstevel@tonic-gate 		else
17837c478bd9Sstevel@tonic-gate 			(void) printf("  whence=%-8u", flock.l_whence);
17847c478bd9Sstevel@tonic-gate 
17857c478bd9Sstevel@tonic-gate 		(void) printf(
1786019c3c43Sraf 		    " start=%-5d len=%-5d sys=%-2u pid=%d\n",
1787019c3c43Sraf 		    flock.l_start,
1788019c3c43Sraf 		    flock.l_len,
1789019c3c43Sraf 		    flock.l_sysid,
1790019c3c43Sraf 		    flock.l_pid);
17917c478bd9Sstevel@tonic-gate 	}
17927c478bd9Sstevel@tonic-gate }
17937c478bd9Sstevel@tonic-gate 
17947c478bd9Sstevel@tonic-gate void
17957c478bd9Sstevel@tonic-gate show_flock64(private_t *pri, long offset)
17967c478bd9Sstevel@tonic-gate {
17977c478bd9Sstevel@tonic-gate 	struct flock64 flock;
17987c478bd9Sstevel@tonic-gate 
17997c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) {
18007c478bd9Sstevel@tonic-gate 		const char *str = NULL;
18017c478bd9Sstevel@tonic-gate 
18027c478bd9Sstevel@tonic-gate 		(void) printf("%s\ttyp=", pri->pname);
18037c478bd9Sstevel@tonic-gate 
18047c478bd9Sstevel@tonic-gate 		switch (flock.l_type) {
18057c478bd9Sstevel@tonic-gate 		case F_RDLCK:
18067c478bd9Sstevel@tonic-gate 			str = "F_RDLCK";
18077c478bd9Sstevel@tonic-gate 			break;
18087c478bd9Sstevel@tonic-gate 		case F_WRLCK:
18097c478bd9Sstevel@tonic-gate 			str = "F_WRLCK";
18107c478bd9Sstevel@tonic-gate 			break;
18117c478bd9Sstevel@tonic-gate 		case F_UNLCK:
18127c478bd9Sstevel@tonic-gate 			str = "F_UNLCK";
18137c478bd9Sstevel@tonic-gate 			break;
18147c478bd9Sstevel@tonic-gate 		}
18157c478bd9Sstevel@tonic-gate 		if (str != NULL)
18167c478bd9Sstevel@tonic-gate 			(void) printf("%s", str);
18177c478bd9Sstevel@tonic-gate 		else
18187c478bd9Sstevel@tonic-gate 			(void) printf("%-7d", flock.l_type);
18197c478bd9Sstevel@tonic-gate 
18207c478bd9Sstevel@tonic-gate 		str = whencearg(flock.l_whence);
18217c478bd9Sstevel@tonic-gate 		if (str != NULL)
18227c478bd9Sstevel@tonic-gate 			(void) printf("  whence=%s", str);
18237c478bd9Sstevel@tonic-gate 		else
18247c478bd9Sstevel@tonic-gate 			(void) printf("  whence=%-8u", flock.l_whence);
18257c478bd9Sstevel@tonic-gate 
18267c478bd9Sstevel@tonic-gate 		(void) printf(
1827019c3c43Sraf 		    " start=%-5lld len=%-5lld sys=%-2u pid=%d\n",
1828019c3c43Sraf 		    (long long)flock.l_start,
1829019c3c43Sraf 		    (long long)flock.l_len,
1830019c3c43Sraf 		    flock.l_sysid,
1831019c3c43Sraf 		    (int)flock.l_pid);
18327c478bd9Sstevel@tonic-gate 	}
18337c478bd9Sstevel@tonic-gate }
18347c478bd9Sstevel@tonic-gate 
18357c478bd9Sstevel@tonic-gate void
18367c478bd9Sstevel@tonic-gate show_share(private_t *pri, long offset)
18377c478bd9Sstevel@tonic-gate {
18387c478bd9Sstevel@tonic-gate 	struct fshare fshare;
18397c478bd9Sstevel@tonic-gate 
18407c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &fshare, sizeof (fshare), offset) == sizeof (fshare)) {
18417c478bd9Sstevel@tonic-gate 		const char *str = NULL;
18427c478bd9Sstevel@tonic-gate 		int manddny = 0;
18437c478bd9Sstevel@tonic-gate 
18447c478bd9Sstevel@tonic-gate 		(void) printf("%s\taccess=", pri->pname);
18457c478bd9Sstevel@tonic-gate 
18467c478bd9Sstevel@tonic-gate 		switch (fshare.f_access) {
18477c478bd9Sstevel@tonic-gate 		case F_RDACC:
18487c478bd9Sstevel@tonic-gate 			str = "F_RDACC";
18497c478bd9Sstevel@tonic-gate 			break;
18507c478bd9Sstevel@tonic-gate 		case F_WRACC:
18517c478bd9Sstevel@tonic-gate 			str = "F_WRACC";
18527c478bd9Sstevel@tonic-gate 			break;
18537c478bd9Sstevel@tonic-gate 		case F_RWACC:
18547c478bd9Sstevel@tonic-gate 			str = "F_RWACC";
18557c478bd9Sstevel@tonic-gate 			break;
18567c478bd9Sstevel@tonic-gate 		}
18577c478bd9Sstevel@tonic-gate 		if (str != NULL)
18587c478bd9Sstevel@tonic-gate 			(void) printf("%s", str);
18597c478bd9Sstevel@tonic-gate 		else
18607c478bd9Sstevel@tonic-gate 			(void) printf("%-7d", fshare.f_access);
18617c478bd9Sstevel@tonic-gate 
18627c478bd9Sstevel@tonic-gate 		str = NULL;
18637c478bd9Sstevel@tonic-gate 		if (fshare.f_deny & F_MANDDNY) {
18647c478bd9Sstevel@tonic-gate 			fshare.f_deny &= ~F_MANDDNY;
18657c478bd9Sstevel@tonic-gate 			manddny = 1;
18667c478bd9Sstevel@tonic-gate 		}
18677c478bd9Sstevel@tonic-gate 		switch (fshare.f_deny) {
18687c478bd9Sstevel@tonic-gate 		case F_NODNY:
18697c478bd9Sstevel@tonic-gate 			str = "F_NODNY";
18707c478bd9Sstevel@tonic-gate 			break;
18717c478bd9Sstevel@tonic-gate 		case F_RDDNY:
18727c478bd9Sstevel@tonic-gate 			str = "F_RDDNY";
18737c478bd9Sstevel@tonic-gate 			break;
18747c478bd9Sstevel@tonic-gate 		case F_WRDNY:
18757c478bd9Sstevel@tonic-gate 			str = "F_WRDNY";
18767c478bd9Sstevel@tonic-gate 			break;
18777c478bd9Sstevel@tonic-gate 		case F_RWDNY:
18787c478bd9Sstevel@tonic-gate 			str = "F_RWDNY";
18797c478bd9Sstevel@tonic-gate 			break;
18807c478bd9Sstevel@tonic-gate 		case F_COMPAT:
18817c478bd9Sstevel@tonic-gate 			str = "F_COMPAT";
18827c478bd9Sstevel@tonic-gate 			break;
18837c478bd9Sstevel@tonic-gate 		}
18847c478bd9Sstevel@tonic-gate 		if (str != NULL) {
18857c478bd9Sstevel@tonic-gate 			if (manddny)
18867c478bd9Sstevel@tonic-gate 				(void) printf("  deny=F_MANDDNY|%s", str);
18877c478bd9Sstevel@tonic-gate 			else
18887c478bd9Sstevel@tonic-gate 				(void) printf("  deny=%s", str);
18897c478bd9Sstevel@tonic-gate 		} else {
18907c478bd9Sstevel@tonic-gate 			(void) printf("  deny=0x%x", manddny?
1891019c3c43Sraf 			    fshare.f_deny | F_MANDDNY : fshare.f_deny);
18927c478bd9Sstevel@tonic-gate 		}
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate 		(void) printf("  id=%x\n", fshare.f_id);
18957c478bd9Sstevel@tonic-gate 	}
18967c478bd9Sstevel@tonic-gate }
18977c478bd9Sstevel@tonic-gate 
18987c478bd9Sstevel@tonic-gate void
18997c478bd9Sstevel@tonic-gate show_ffg(private_t *pri)
19007c478bd9Sstevel@tonic-gate {
19017c478bd9Sstevel@tonic-gate 	(void) putchar('\t');
19027c478bd9Sstevel@tonic-gate 	(void) putchar('\t');
19037c478bd9Sstevel@tonic-gate 	prt_ffg(pri, 0, pri->Rval1);
19047c478bd9Sstevel@tonic-gate 	(void) puts(pri->sys_string);
19057c478bd9Sstevel@tonic-gate }
19067c478bd9Sstevel@tonic-gate 
19077c478bd9Sstevel@tonic-gate /* print values in fcntl() pointed-to structure */
19087c478bd9Sstevel@tonic-gate void
19097c478bd9Sstevel@tonic-gate show_fcntl(private_t *pri)
19107c478bd9Sstevel@tonic-gate {
19117c478bd9Sstevel@tonic-gate 	long offset;
19127c478bd9Sstevel@tonic-gate 
19137c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 2 && pri->sys_args[1] == F_GETFL) {
19147c478bd9Sstevel@tonic-gate 		show_ffg(pri);
19157c478bd9Sstevel@tonic-gate 		return;
19167c478bd9Sstevel@tonic-gate 	}
19177c478bd9Sstevel@tonic-gate 
19187c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 3 || (offset = pri->sys_args[2]) == NULL)
19197c478bd9Sstevel@tonic-gate 		return;
19207c478bd9Sstevel@tonic-gate 
19217c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[1]) {
19227c478bd9Sstevel@tonic-gate #ifdef _LP64
19237c478bd9Sstevel@tonic-gate 	case F_GETLK:
19247c478bd9Sstevel@tonic-gate 	case F_SETLK:
19257c478bd9Sstevel@tonic-gate 	case F_SETLKW:
19267c478bd9Sstevel@tonic-gate 	case F_FREESP:
19277c478bd9Sstevel@tonic-gate 	case F_ALLOCSP:
19287c478bd9Sstevel@tonic-gate 	case F_SETLK_NBMAND:
19297c478bd9Sstevel@tonic-gate 		if (data_model == PR_MODEL_LP64)
19307c478bd9Sstevel@tonic-gate 			show_flock64(pri, offset);
19317c478bd9Sstevel@tonic-gate 		else
19327c478bd9Sstevel@tonic-gate 			show_flock32(pri, offset);
19337c478bd9Sstevel@tonic-gate 		break;
19347c478bd9Sstevel@tonic-gate 	case 33:	/* F_GETLK64 */
19357c478bd9Sstevel@tonic-gate 	case 34:	/* F_SETLK64 */
19367c478bd9Sstevel@tonic-gate 	case 35:	/* F_SETLKW64 */
19377c478bd9Sstevel@tonic-gate 	case 27:	/* F_FREESP64 */
1938019c3c43Sraf 	case 28:	/* F_ALLOCSP64 */
19397c478bd9Sstevel@tonic-gate 	case 44:	/* F_SETLK64_NBMAND */
19407c478bd9Sstevel@tonic-gate 		show_flock64(pri, offset);
19417c478bd9Sstevel@tonic-gate 		break;
19427c478bd9Sstevel@tonic-gate #else	/* _LP64 */
19437c478bd9Sstevel@tonic-gate 	case F_GETLK:
19447c478bd9Sstevel@tonic-gate 	case F_SETLK:
19457c478bd9Sstevel@tonic-gate 	case F_SETLKW:
19467c478bd9Sstevel@tonic-gate 	case F_FREESP:
19477c478bd9Sstevel@tonic-gate 	case F_ALLOCSP:
19487c478bd9Sstevel@tonic-gate 	case F_SETLK_NBMAND:
19497c478bd9Sstevel@tonic-gate 		show_flock32(pri, offset);
19507c478bd9Sstevel@tonic-gate 		break;
19517c478bd9Sstevel@tonic-gate 	case F_GETLK64:
19527c478bd9Sstevel@tonic-gate 	case F_SETLK64:
19537c478bd9Sstevel@tonic-gate 	case F_SETLKW64:
19547c478bd9Sstevel@tonic-gate 	case F_FREESP64:
1955019c3c43Sraf 	case F_ALLOCSP64:
19567c478bd9Sstevel@tonic-gate 	case F_SETLK64_NBMAND:
19577c478bd9Sstevel@tonic-gate 		show_flock64(pri, offset);
19587c478bd9Sstevel@tonic-gate 		break;
19597c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
19607c478bd9Sstevel@tonic-gate 	case F_SHARE:
19617c478bd9Sstevel@tonic-gate 	case F_UNSHARE:
19627c478bd9Sstevel@tonic-gate 		show_share(pri, offset);
19637c478bd9Sstevel@tonic-gate 		break;
19647c478bd9Sstevel@tonic-gate 	}
19657c478bd9Sstevel@tonic-gate }
19667c478bd9Sstevel@tonic-gate 
19677c478bd9Sstevel@tonic-gate void
19687c478bd9Sstevel@tonic-gate show_strbuf(private_t *pri, long offset, const char *name, int dump)
19697c478bd9Sstevel@tonic-gate {
19707c478bd9Sstevel@tonic-gate 	struct strbuf strbuf;
19717c478bd9Sstevel@tonic-gate 
19727c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf))
19737c478bd9Sstevel@tonic-gate 		print_strbuf(pri, &strbuf, name, dump);
19747c478bd9Sstevel@tonic-gate }
19757c478bd9Sstevel@tonic-gate 
19767c478bd9Sstevel@tonic-gate #ifdef _LP64
19777c478bd9Sstevel@tonic-gate void
19787c478bd9Sstevel@tonic-gate show_strbuf32(private_t *pri, long offset, const char *name, int dump)
19797c478bd9Sstevel@tonic-gate {
19807c478bd9Sstevel@tonic-gate 	struct strbuf32 strbuf;
19817c478bd9Sstevel@tonic-gate 
19827c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf))
19837c478bd9Sstevel@tonic-gate 		print_strbuf32(pri, &strbuf, name, dump);
19847c478bd9Sstevel@tonic-gate }
19857c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
19867c478bd9Sstevel@tonic-gate 
19877c478bd9Sstevel@tonic-gate void
19887c478bd9Sstevel@tonic-gate show_gp_msg(private_t *pri, int what)
19897c478bd9Sstevel@tonic-gate {
19907c478bd9Sstevel@tonic-gate 	long offset;
19917c478bd9Sstevel@tonic-gate 	int dump = FALSE;
19927c478bd9Sstevel@tonic-gate 	int fdp1 = pri->sys_args[0] + 1;
19937c478bd9Sstevel@tonic-gate 
19947c478bd9Sstevel@tonic-gate 	switch (what) {
19957c478bd9Sstevel@tonic-gate 	case SYS_getmsg:
19967c478bd9Sstevel@tonic-gate 	case SYS_getpmsg:
19977c478bd9Sstevel@tonic-gate 		if (pri->Errno == 0 && prismember(&readfd, fdp1))
19987c478bd9Sstevel@tonic-gate 			dump = TRUE;
19997c478bd9Sstevel@tonic-gate 		break;
20007c478bd9Sstevel@tonic-gate 	case SYS_putmsg:
20017c478bd9Sstevel@tonic-gate 	case SYS_putpmsg:
20027c478bd9Sstevel@tonic-gate 		if (prismember(&writefd, fdp1))
20037c478bd9Sstevel@tonic-gate 			dump = TRUE;
20047c478bd9Sstevel@tonic-gate 		break;
20057c478bd9Sstevel@tonic-gate 	}
20067c478bd9Sstevel@tonic-gate 
20077c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
20087c478bd9Sstevel@tonic-gate 	if (dump)
20097c478bd9Sstevel@tonic-gate 		Eserialize();
20107c478bd9Sstevel@tonic-gate 
20117c478bd9Sstevel@tonic-gate #ifdef _LP64
20127c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL) {
20137c478bd9Sstevel@tonic-gate 		if (data_model == PR_MODEL_LP64)
20147c478bd9Sstevel@tonic-gate 			show_strbuf(pri, offset, "ctl", dump);
20157c478bd9Sstevel@tonic-gate 		else
20167c478bd9Sstevel@tonic-gate 			show_strbuf32(pri, offset, "ctl", dump);
20177c478bd9Sstevel@tonic-gate 	}
20187c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL) {
20197c478bd9Sstevel@tonic-gate 		if (data_model == PR_MODEL_LP64)
20207c478bd9Sstevel@tonic-gate 			show_strbuf(pri, offset, "dat", dump);
20217c478bd9Sstevel@tonic-gate 		else
20227c478bd9Sstevel@tonic-gate 			show_strbuf32(pri, offset, "dat", dump);
20237c478bd9Sstevel@tonic-gate 	}
20247c478bd9Sstevel@tonic-gate #else	/* _LP64 */
20257c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL)
20267c478bd9Sstevel@tonic-gate 		show_strbuf(pri, offset, "ctl", dump);
20277c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL)
20287c478bd9Sstevel@tonic-gate 		show_strbuf(pri, offset, "dat", dump);
20297c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
20307c478bd9Sstevel@tonic-gate 
20317c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
20327c478bd9Sstevel@tonic-gate 	if (dump)
20337c478bd9Sstevel@tonic-gate 		Xserialize();
20347c478bd9Sstevel@tonic-gate }
20357c478bd9Sstevel@tonic-gate 
20367c478bd9Sstevel@tonic-gate void
20377c478bd9Sstevel@tonic-gate show_int(private_t *pri, long offset, const char *name)
20387c478bd9Sstevel@tonic-gate {
20397c478bd9Sstevel@tonic-gate 	int value;
20407c478bd9Sstevel@tonic-gate 
20417c478bd9Sstevel@tonic-gate 	if (offset != 0 &&
20427c478bd9Sstevel@tonic-gate 	    Pread(Proc, &value, sizeof (value), offset) == sizeof (value))
20437c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s:\t%d\n",
2044019c3c43Sraf 		    pri->pname,
2045019c3c43Sraf 		    name,
2046019c3c43Sraf 		    value);
20477c478bd9Sstevel@tonic-gate }
20487c478bd9Sstevel@tonic-gate 
20497c478bd9Sstevel@tonic-gate void
20507c478bd9Sstevel@tonic-gate show_hhex_int(private_t *pri, long offset, const char *name)
20517c478bd9Sstevel@tonic-gate {
20527c478bd9Sstevel@tonic-gate 	int value;
20537c478bd9Sstevel@tonic-gate 
20547c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &value, sizeof (value), offset) == sizeof (value))
20557c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s:\t0x%.4X\n",
2056019c3c43Sraf 		    pri->pname,
2057019c3c43Sraf 		    name,
2058019c3c43Sraf 		    value);
20597c478bd9Sstevel@tonic-gate }
20607c478bd9Sstevel@tonic-gate 
20617c478bd9Sstevel@tonic-gate #define	ALL_POLL_FLAGS	(POLLIN|POLLPRI|POLLOUT| \
20627c478bd9Sstevel@tonic-gate 	POLLRDNORM|POLLRDBAND|POLLWRBAND|POLLERR|POLLHUP|POLLNVAL)
20637c478bd9Sstevel@tonic-gate 
20647c478bd9Sstevel@tonic-gate const char *
20657c478bd9Sstevel@tonic-gate pollevent(private_t *pri, int arg)
20667c478bd9Sstevel@tonic-gate {
20677c478bd9Sstevel@tonic-gate 	char *str = pri->code_buf;
20687c478bd9Sstevel@tonic-gate 
20697c478bd9Sstevel@tonic-gate 	if (arg == 0)
20707c478bd9Sstevel@tonic-gate 		return ("0");
20717c478bd9Sstevel@tonic-gate 	if (arg & ~ALL_POLL_FLAGS) {
20727c478bd9Sstevel@tonic-gate 		(void) sprintf(str, "0x%-5X", arg);
20737c478bd9Sstevel@tonic-gate 		return ((const char *)str);
20747c478bd9Sstevel@tonic-gate 	}
20757c478bd9Sstevel@tonic-gate 
20767c478bd9Sstevel@tonic-gate 	*str = '\0';
20777c478bd9Sstevel@tonic-gate 	if (arg & POLLIN)
20787c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLIN");
20797c478bd9Sstevel@tonic-gate 	if (arg & POLLPRI)
20807c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLPRI");
20817c478bd9Sstevel@tonic-gate 	if (arg & POLLOUT)
20827c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLOUT");
20837c478bd9Sstevel@tonic-gate 	if (arg & POLLRDNORM)
20847c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLRDNORM");
20857c478bd9Sstevel@tonic-gate 	if (arg & POLLRDBAND)
20867c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLRDBAND");
20877c478bd9Sstevel@tonic-gate 	if (arg & POLLWRBAND)
20887c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLWRBAND");
20897c478bd9Sstevel@tonic-gate 	if (arg & POLLERR)
20907c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLERR");
20917c478bd9Sstevel@tonic-gate 	if (arg & POLLHUP)
20927c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLHUP");
20937c478bd9Sstevel@tonic-gate 	if (arg & POLLNVAL)
20947c478bd9Sstevel@tonic-gate 		(void) strcat(str, "|POLLNVAL");
20957c478bd9Sstevel@tonic-gate 
20967c478bd9Sstevel@tonic-gate 	return ((const char *)(str+1));
20977c478bd9Sstevel@tonic-gate }
20987c478bd9Sstevel@tonic-gate 
20997c478bd9Sstevel@tonic-gate static void
21007c478bd9Sstevel@tonic-gate show_one_pollfd(private_t *pri, struct pollfd *ppollfd)
21017c478bd9Sstevel@tonic-gate {
21027c478bd9Sstevel@tonic-gate 	/*
21037c478bd9Sstevel@tonic-gate 	 * can't print both events and revents in same printf.
21047c478bd9Sstevel@tonic-gate 	 * pollevent() returns a pointer to a TSD location.
21057c478bd9Sstevel@tonic-gate 	 */
21067c478bd9Sstevel@tonic-gate 	(void) printf("%s\tfd=%-2d ev=%s",
21077c478bd9Sstevel@tonic-gate 	    pri->pname, ppollfd->fd, pollevent(pri, ppollfd->events));
21087c478bd9Sstevel@tonic-gate 	(void) printf(" rev=%s\n", pollevent(pri, ppollfd->revents));
21097c478bd9Sstevel@tonic-gate }
21107c478bd9Sstevel@tonic-gate 
21117c478bd9Sstevel@tonic-gate static void
21127c478bd9Sstevel@tonic-gate show_all_pollfds(private_t *pri, long offset, int nfds)
21137c478bd9Sstevel@tonic-gate {
21147c478bd9Sstevel@tonic-gate 	struct pollfd pollfd[2];
21157c478bd9Sstevel@tonic-gate 	int skip = -1;
21167c478bd9Sstevel@tonic-gate 
21177c478bd9Sstevel@tonic-gate 	for (; nfds && !interrupt; nfds--, offset += sizeof (struct pollfd)) {
21187c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &pollfd[0], sizeof (struct pollfd), offset) !=
21197c478bd9Sstevel@tonic-gate 		    sizeof (struct pollfd))
21207c478bd9Sstevel@tonic-gate 			continue;
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 		if (skip >= 0 && pollfd[0].fd == pollfd[1].fd &&
21237c478bd9Sstevel@tonic-gate 		    pollfd[0].events == pollfd[1].events &&
21247c478bd9Sstevel@tonic-gate 		    pollfd[0].revents == pollfd[1].revents) {
21257c478bd9Sstevel@tonic-gate 			skip++;
21267c478bd9Sstevel@tonic-gate 			continue;
21277c478bd9Sstevel@tonic-gate 		}
21287c478bd9Sstevel@tonic-gate 
21297c478bd9Sstevel@tonic-gate 		if (skip > 0)
21307c478bd9Sstevel@tonic-gate 			(void) printf("%s\t...last pollfd structure"
21317c478bd9Sstevel@tonic-gate 			    " repeated %d time%s...\n",
21327c478bd9Sstevel@tonic-gate 			    pri->pname, skip, (skip == 1 ? "" : "s"));
21337c478bd9Sstevel@tonic-gate 
21347c478bd9Sstevel@tonic-gate 		skip = 0;
21357c478bd9Sstevel@tonic-gate 		show_one_pollfd(pri, &pollfd[0]);
21367c478bd9Sstevel@tonic-gate 		pollfd[1] = pollfd[0];
21377c478bd9Sstevel@tonic-gate 	}
21387c478bd9Sstevel@tonic-gate 
21397c478bd9Sstevel@tonic-gate 	if (skip > 0)
21407c478bd9Sstevel@tonic-gate 		(void) printf(
21417c478bd9Sstevel@tonic-gate 		    "%s\t...last pollfd structure repeated %d time%s...\n",
21427c478bd9Sstevel@tonic-gate 		    pri->pname, skip, (skip == 1 ? "" : "s"));
21437c478bd9Sstevel@tonic-gate }
21447c478bd9Sstevel@tonic-gate 
21457c478bd9Sstevel@tonic-gate void
21467c478bd9Sstevel@tonic-gate show_poll(private_t *pri)
21477c478bd9Sstevel@tonic-gate {
21487c478bd9Sstevel@tonic-gate 	long offset;
21497c478bd9Sstevel@tonic-gate 	int nfds;
21507c478bd9Sstevel@tonic-gate 	int serial = 0;
21517c478bd9Sstevel@tonic-gate 
21527c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 2 || (offset = pri->sys_args[0]) == NULL ||
21537c478bd9Sstevel@tonic-gate 	    (nfds = pri->sys_args[1]) <= 0)
21547c478bd9Sstevel@tonic-gate 		return;
21557c478bd9Sstevel@tonic-gate 
21567c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
21577c478bd9Sstevel@tonic-gate 	if (nfds > 32) {
21587c478bd9Sstevel@tonic-gate 		Eserialize();
21597c478bd9Sstevel@tonic-gate 		serial = 1;
21607c478bd9Sstevel@tonic-gate 	}
21617c478bd9Sstevel@tonic-gate 
21627c478bd9Sstevel@tonic-gate 	show_all_pollfds(pri, offset, nfds);
21637c478bd9Sstevel@tonic-gate 
21647c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
21657c478bd9Sstevel@tonic-gate 	if (serial)
21667c478bd9Sstevel@tonic-gate 		Xserialize();
21677c478bd9Sstevel@tonic-gate }
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate void
21707c478bd9Sstevel@tonic-gate show_pollsys(private_t *pri)
21717c478bd9Sstevel@tonic-gate {
21727c478bd9Sstevel@tonic-gate 	long offset;
21737c478bd9Sstevel@tonic-gate 	int nfds;
21747c478bd9Sstevel@tonic-gate 	int serial = 0;
21757c478bd9Sstevel@tonic-gate 
21767c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 2)
21777c478bd9Sstevel@tonic-gate 		return;
21787c478bd9Sstevel@tonic-gate 
21797c478bd9Sstevel@tonic-gate 	offset = pri->sys_args[0];
21807c478bd9Sstevel@tonic-gate 	nfds = pri->sys_args[1];
21817c478bd9Sstevel@tonic-gate 
21827c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
21837c478bd9Sstevel@tonic-gate 	if (offset != NULL && nfds > 32) {
21847c478bd9Sstevel@tonic-gate 		Eserialize();
21857c478bd9Sstevel@tonic-gate 		serial = 1;
21867c478bd9Sstevel@tonic-gate 	}
21877c478bd9Sstevel@tonic-gate 
21887c478bd9Sstevel@tonic-gate 	if (offset != NULL && nfds > 0)
21897c478bd9Sstevel@tonic-gate 		show_all_pollfds(pri, offset, nfds);
21907c478bd9Sstevel@tonic-gate 
21917c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs > 2)
21927c478bd9Sstevel@tonic-gate 		show_timestruc(pri, (long)pri->sys_args[2], "timeout");
21937c478bd9Sstevel@tonic-gate 
21947c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs > 3)
21957c478bd9Sstevel@tonic-gate 		show_sigset(pri, (long)pri->sys_args[3], "sigmask");
21967c478bd9Sstevel@tonic-gate 
21977c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
21987c478bd9Sstevel@tonic-gate 	if (serial)
21997c478bd9Sstevel@tonic-gate 		Xserialize();
22007c478bd9Sstevel@tonic-gate }
22017c478bd9Sstevel@tonic-gate 
22027c478bd9Sstevel@tonic-gate static void
22037c478bd9Sstevel@tonic-gate show_perm64(private_t *pri, struct ipc_perm64 *ip)
22047c478bd9Sstevel@tonic-gate {
2205f48205beScasper 	(void) printf("%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u z=%-5d "
22067c478bd9Sstevel@tonic-gate 	    "m=0%.6o key=%d projid=%-5d\n",
22077c478bd9Sstevel@tonic-gate 	    pri->pname,
2208f48205beScasper 	    ip->ipcx_uid,
2209f48205beScasper 	    ip->ipcx_gid,
2210f48205beScasper 	    ip->ipcx_cuid,
2211f48205beScasper 	    ip->ipcx_cgid,
22127c478bd9Sstevel@tonic-gate 	    (int)ip->ipcx_zoneid,
22137c478bd9Sstevel@tonic-gate 	    (unsigned int)ip->ipcx_mode,
22147c478bd9Sstevel@tonic-gate 	    ip->ipcx_key,
22157c478bd9Sstevel@tonic-gate 	    (int)ip->ipcx_projid);
22167c478bd9Sstevel@tonic-gate }
22177c478bd9Sstevel@tonic-gate 
22187c478bd9Sstevel@tonic-gate void
22197c478bd9Sstevel@tonic-gate show_perm(private_t *pri, struct ipc_perm *ip)
22207c478bd9Sstevel@tonic-gate {
22217c478bd9Sstevel@tonic-gate 	(void) printf(
2222019c3c43Sraf 	    "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n",
2223019c3c43Sraf 	    pri->pname,
2224019c3c43Sraf 	    ip->uid,
2225019c3c43Sraf 	    ip->gid,
2226019c3c43Sraf 	    ip->cuid,
2227019c3c43Sraf 	    ip->cgid,
2228019c3c43Sraf 	    (int)ip->mode,
2229019c3c43Sraf 	    ip->seq,
2230019c3c43Sraf 	    ip->key);
22317c478bd9Sstevel@tonic-gate }
22327c478bd9Sstevel@tonic-gate 
22337c478bd9Sstevel@tonic-gate #ifdef _LP64
22347c478bd9Sstevel@tonic-gate void
22357c478bd9Sstevel@tonic-gate show_perm32(private_t *pri, struct ipc_perm32 *ip)
22367c478bd9Sstevel@tonic-gate {
22377c478bd9Sstevel@tonic-gate 	(void) printf(
2238019c3c43Sraf 	    "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n",
2239019c3c43Sraf 	    pri->pname,
2240019c3c43Sraf 	    ip->uid,
2241019c3c43Sraf 	    ip->gid,
2242019c3c43Sraf 	    ip->cuid,
2243019c3c43Sraf 	    ip->cgid,
2244019c3c43Sraf 	    ip->mode,
2245019c3c43Sraf 	    ip->seq,
2246019c3c43Sraf 	    ip->key);
22477c478bd9Sstevel@tonic-gate }
22487c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
22497c478bd9Sstevel@tonic-gate 
22507c478bd9Sstevel@tonic-gate static void
22517c478bd9Sstevel@tonic-gate show_msgctl64(private_t *pri, long offset)
22527c478bd9Sstevel@tonic-gate {
22537c478bd9Sstevel@tonic-gate 	struct msqid_ds64 msgq;
22547c478bd9Sstevel@tonic-gate 
22557c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
22567c478bd9Sstevel@tonic-gate 	    Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) {
22577c478bd9Sstevel@tonic-gate 		show_perm64(pri, &msgq.msgx_perm);
22587c478bd9Sstevel@tonic-gate 
22597c478bd9Sstevel@tonic-gate 		(void) printf("%s\tbytes=%-5llu msgs=%-5llu maxby=%-5llu "
22607c478bd9Sstevel@tonic-gate 		    "lspid=%-5d lrpid=%-5d\n", pri->pname,
22617c478bd9Sstevel@tonic-gate 		    (unsigned long long)msgq.msgx_cbytes,
22627c478bd9Sstevel@tonic-gate 		    (unsigned long long)msgq.msgx_qnum,
22637c478bd9Sstevel@tonic-gate 		    (unsigned long long)msgq.msgx_qbytes,
22647c478bd9Sstevel@tonic-gate 		    (int)msgq.msgx_lspid,
22657c478bd9Sstevel@tonic-gate 		    (int)msgq.msgx_lrpid);
22667c478bd9Sstevel@tonic-gate 
22677c478bd9Sstevel@tonic-gate 		prtime(pri, "    st = ", (time_t)msgq.msgx_stime);
22687c478bd9Sstevel@tonic-gate 		prtime(pri, "    rt = ", (time_t)msgq.msgx_rtime);
22697c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", (time_t)msgq.msgx_ctime);
22707c478bd9Sstevel@tonic-gate 	}
22717c478bd9Sstevel@tonic-gate }
22727c478bd9Sstevel@tonic-gate 
22737c478bd9Sstevel@tonic-gate void
22747c478bd9Sstevel@tonic-gate show_msgctl(private_t *pri, long offset)
22757c478bd9Sstevel@tonic-gate {
22767c478bd9Sstevel@tonic-gate 	struct msqid_ds msgq;
22777c478bd9Sstevel@tonic-gate 
22787c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
22797c478bd9Sstevel@tonic-gate 	    Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) {
22807c478bd9Sstevel@tonic-gate 		show_perm(pri, &msgq.msg_perm);
22817c478bd9Sstevel@tonic-gate 
22827c478bd9Sstevel@tonic-gate 		(void) printf(
22837c478bd9Sstevel@tonic-gate 	"%s\tbytes=%-5lu msgs=%-5lu maxby=%-5lu lspid=%-5u lrpid=%-5u\n",
2284019c3c43Sraf 		    pri->pname,
2285019c3c43Sraf 		    msgq.msg_cbytes,
2286019c3c43Sraf 		    msgq.msg_qnum,
2287019c3c43Sraf 		    msgq.msg_qbytes,
2288019c3c43Sraf 		    (int)msgq.msg_lspid,
2289019c3c43Sraf 		    (int)msgq.msg_lrpid);
22907c478bd9Sstevel@tonic-gate 
22917c478bd9Sstevel@tonic-gate 		prtime(pri, "    st = ", msgq.msg_stime);
22927c478bd9Sstevel@tonic-gate 		prtime(pri, "    rt = ", msgq.msg_rtime);
22937c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", msgq.msg_ctime);
22947c478bd9Sstevel@tonic-gate 	}
22957c478bd9Sstevel@tonic-gate }
22967c478bd9Sstevel@tonic-gate 
22977c478bd9Sstevel@tonic-gate #ifdef _LP64
22987c478bd9Sstevel@tonic-gate void
22997c478bd9Sstevel@tonic-gate show_msgctl32(private_t *pri, long offset)
23007c478bd9Sstevel@tonic-gate {
23017c478bd9Sstevel@tonic-gate 	struct msqid_ds32 msgq;
23027c478bd9Sstevel@tonic-gate 
23037c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
23047c478bd9Sstevel@tonic-gate 	    Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) {
23057c478bd9Sstevel@tonic-gate 		show_perm32(pri, &msgq.msg_perm);
23067c478bd9Sstevel@tonic-gate 
23077c478bd9Sstevel@tonic-gate 		(void) printf(
23087c478bd9Sstevel@tonic-gate 	"%s\tbytes=%-5u msgs=%-5u maxby=%-5u lspid=%-5u lrpid=%-5u\n",
2309019c3c43Sraf 		    pri->pname,
2310019c3c43Sraf 		    msgq.msg_cbytes,
2311019c3c43Sraf 		    msgq.msg_qnum,
2312019c3c43Sraf 		    msgq.msg_qbytes,
2313019c3c43Sraf 		    msgq.msg_lspid,
2314019c3c43Sraf 		    msgq.msg_lrpid);
23157c478bd9Sstevel@tonic-gate 
23167c478bd9Sstevel@tonic-gate 		prtime(pri, "    st = ", msgq.msg_stime);
23177c478bd9Sstevel@tonic-gate 		prtime(pri, "    rt = ", msgq.msg_rtime);
23187c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", msgq.msg_ctime);
23197c478bd9Sstevel@tonic-gate 	}
23207c478bd9Sstevel@tonic-gate }
23217c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
23227c478bd9Sstevel@tonic-gate 
23237c478bd9Sstevel@tonic-gate void
23247c478bd9Sstevel@tonic-gate show_msgbuf(private_t *pri, long offset, long msgsz)
23257c478bd9Sstevel@tonic-gate {
23267c478bd9Sstevel@tonic-gate 	struct msgbuf msgb;
23277c478bd9Sstevel@tonic-gate 
23287c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
23297c478bd9Sstevel@tonic-gate 	    Pread(Proc, &msgb, sizeof (msgb.mtype), offset) ==
23307c478bd9Sstevel@tonic-gate 	    sizeof (msgb.mtype)) {
23317c478bd9Sstevel@tonic-gate 		/* enter region of lengthy output */
23327c478bd9Sstevel@tonic-gate 		if (msgsz > MYBUFSIZ / 4)
23337c478bd9Sstevel@tonic-gate 			Eserialize();
23347c478bd9Sstevel@tonic-gate 
23357c478bd9Sstevel@tonic-gate 		(void) printf("%s\tmtype=%lu  mtext[]=\n",
2336019c3c43Sraf 		    pri->pname,
2337019c3c43Sraf 		    msgb.mtype);
23387c478bd9Sstevel@tonic-gate 		showbuffer(pri,
2339019c3c43Sraf 		    (long)(offset + sizeof (msgb.mtype)), msgsz);
23407c478bd9Sstevel@tonic-gate 
23417c478bd9Sstevel@tonic-gate 		/* exit region of lengthy output */
23427c478bd9Sstevel@tonic-gate 		if (msgsz > MYBUFSIZ / 4)
23437c478bd9Sstevel@tonic-gate 			Xserialize();
23447c478bd9Sstevel@tonic-gate 	}
23457c478bd9Sstevel@tonic-gate }
23467c478bd9Sstevel@tonic-gate 
23477c478bd9Sstevel@tonic-gate #ifdef _LP64
23487c478bd9Sstevel@tonic-gate void
23497c478bd9Sstevel@tonic-gate show_msgbuf32(private_t *pri, long offset, long msgsz)
23507c478bd9Sstevel@tonic-gate {
23517c478bd9Sstevel@tonic-gate 	struct ipcmsgbuf32 msgb;
23527c478bd9Sstevel@tonic-gate 
23537c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
23547c478bd9Sstevel@tonic-gate 	    Pread(Proc, &msgb, sizeof (msgb.mtype), offset) ==
23557c478bd9Sstevel@tonic-gate 	    sizeof (msgb.mtype)) {
23567c478bd9Sstevel@tonic-gate 		/* enter region of lengthy output */
23577c478bd9Sstevel@tonic-gate 		if (msgsz > MYBUFSIZ / 4)
23587c478bd9Sstevel@tonic-gate 			Eserialize();
23597c478bd9Sstevel@tonic-gate 
23607c478bd9Sstevel@tonic-gate 		(void) printf("%s\tmtype=%u  mtext[]=\n",
2361019c3c43Sraf 		    pri->pname,
2362019c3c43Sraf 		    msgb.mtype);
23637c478bd9Sstevel@tonic-gate 		showbuffer(pri,
2364019c3c43Sraf 		    (long)(offset + sizeof (msgb.mtype)), msgsz);
23657c478bd9Sstevel@tonic-gate 
23667c478bd9Sstevel@tonic-gate 		/* exit region of lengthy output */
23677c478bd9Sstevel@tonic-gate 		if (msgsz > MYBUFSIZ / 4)
23687c478bd9Sstevel@tonic-gate 			Xserialize();
23697c478bd9Sstevel@tonic-gate 	}
23707c478bd9Sstevel@tonic-gate }
23717c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
23727c478bd9Sstevel@tonic-gate 
23737c478bd9Sstevel@tonic-gate #ifdef _LP64
23747c478bd9Sstevel@tonic-gate void
23757c478bd9Sstevel@tonic-gate show_msgsys(private_t *pri, long msgsz)
23767c478bd9Sstevel@tonic-gate {
23777c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[0]) {
23787c478bd9Sstevel@tonic-gate 	case 0:			/* msgget() */
23797c478bd9Sstevel@tonic-gate 		break;
23807c478bd9Sstevel@tonic-gate 	case 1:			/* msgctl() */
23817c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3) {
23827c478bd9Sstevel@tonic-gate 			switch (pri->sys_args[2]) {
23837c478bd9Sstevel@tonic-gate 			case IPC_STAT:
23847c478bd9Sstevel@tonic-gate 				if (pri->Errno)
23857c478bd9Sstevel@tonic-gate 					break;
23867c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
23877c478bd9Sstevel@tonic-gate 			case IPC_SET:
23887c478bd9Sstevel@tonic-gate 				if (data_model == PR_MODEL_LP64)
23897c478bd9Sstevel@tonic-gate 					show_msgctl(pri,
2390019c3c43Sraf 					    (long)pri->sys_args[3]);
23917c478bd9Sstevel@tonic-gate 				else
23927c478bd9Sstevel@tonic-gate 					show_msgctl32(pri,
2393019c3c43Sraf 					    (long)pri->sys_args[3]);
23947c478bd9Sstevel@tonic-gate 				break;
23957c478bd9Sstevel@tonic-gate 			case IPC_STAT64:
23967c478bd9Sstevel@tonic-gate 				if (pri->Errno)
23977c478bd9Sstevel@tonic-gate 					break;
23987c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
23997c478bd9Sstevel@tonic-gate 			case IPC_SET64:
24007c478bd9Sstevel@tonic-gate 				show_msgctl64(pri, (long)pri->sys_args[3]);
24017c478bd9Sstevel@tonic-gate 				break;
24027c478bd9Sstevel@tonic-gate 			}
24037c478bd9Sstevel@tonic-gate 		}
24047c478bd9Sstevel@tonic-gate 		break;
24057c478bd9Sstevel@tonic-gate 	case 2:			/* msgrcv() */
24067c478bd9Sstevel@tonic-gate 		if (!pri->Errno && pri->sys_nargs > 2) {
24077c478bd9Sstevel@tonic-gate 			if (data_model == PR_MODEL_LP64)
24087c478bd9Sstevel@tonic-gate 				show_msgbuf(pri, pri->sys_args[2], msgsz);
24097c478bd9Sstevel@tonic-gate 			else
24107c478bd9Sstevel@tonic-gate 				show_msgbuf32(pri, pri->sys_args[2], msgsz);
24117c478bd9Sstevel@tonic-gate 		}
24127c478bd9Sstevel@tonic-gate 		break;
24137c478bd9Sstevel@tonic-gate 	case 3:			/* msgsnd() */
24147c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3) {
24157c478bd9Sstevel@tonic-gate 			if (data_model == PR_MODEL_LP64)
24167c478bd9Sstevel@tonic-gate 				show_msgbuf(pri, pri->sys_args[2],
2417019c3c43Sraf 				    pri->sys_args[3]);
24187c478bd9Sstevel@tonic-gate 			else
24197c478bd9Sstevel@tonic-gate 				show_msgbuf32(pri, pri->sys_args[2],
2420019c3c43Sraf 				    pri->sys_args[3]);
24217c478bd9Sstevel@tonic-gate 		}
24227c478bd9Sstevel@tonic-gate 		break;
24237c478bd9Sstevel@tonic-gate 	case 4:			/* msgids() */
24247c478bd9Sstevel@tonic-gate 	case 5:			/* msgsnap() */
24257c478bd9Sstevel@tonic-gate 	default:		/* unexpected subcode */
24267c478bd9Sstevel@tonic-gate 		break;
24277c478bd9Sstevel@tonic-gate 	}
24287c478bd9Sstevel@tonic-gate }
24297c478bd9Sstevel@tonic-gate #else	/* _LP64 */
24307c478bd9Sstevel@tonic-gate void
24317c478bd9Sstevel@tonic-gate show_msgsys(private_t *pri, long msgsz)
24327c478bd9Sstevel@tonic-gate {
24337c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[0]) {
24347c478bd9Sstevel@tonic-gate 	case 0:			/* msgget() */
24357c478bd9Sstevel@tonic-gate 		break;
24367c478bd9Sstevel@tonic-gate 	case 1:			/* msgctl() */
24377c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3) {
24387c478bd9Sstevel@tonic-gate 			switch (pri->sys_args[2]) {
24397c478bd9Sstevel@tonic-gate 			case IPC_STAT:
24407c478bd9Sstevel@tonic-gate 				if (pri->Errno)
24417c478bd9Sstevel@tonic-gate 					break;
24427c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
24437c478bd9Sstevel@tonic-gate 			case IPC_SET:
24447c478bd9Sstevel@tonic-gate 				show_msgctl(pri, (long)pri->sys_args[3]);
24457c478bd9Sstevel@tonic-gate 				break;
24467c478bd9Sstevel@tonic-gate 			case IPC_STAT64:
24477c478bd9Sstevel@tonic-gate 				if (pri->Errno)
24487c478bd9Sstevel@tonic-gate 					break;
24497c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
24507c478bd9Sstevel@tonic-gate 			case IPC_SET64:
24517c478bd9Sstevel@tonic-gate 				show_msgctl64(pri, (long)pri->sys_args[3]);
24527c478bd9Sstevel@tonic-gate 				break;
24537c478bd9Sstevel@tonic-gate 			}
24547c478bd9Sstevel@tonic-gate 		}
24557c478bd9Sstevel@tonic-gate 		break;
24567c478bd9Sstevel@tonic-gate 	case 2:			/* msgrcv() */
24577c478bd9Sstevel@tonic-gate 		if (!pri->Errno && pri->sys_nargs > 2)
24587c478bd9Sstevel@tonic-gate 			show_msgbuf(pri, pri->sys_args[2], msgsz);
24597c478bd9Sstevel@tonic-gate 		break;
24607c478bd9Sstevel@tonic-gate 	case 3:			/* msgsnd() */
24617c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3)
24627c478bd9Sstevel@tonic-gate 			show_msgbuf(pri, pri->sys_args[2],
2463019c3c43Sraf 			    pri->sys_args[3]);
24647c478bd9Sstevel@tonic-gate 		break;
24657c478bd9Sstevel@tonic-gate 	case 4:			/* msgids() */
24667c478bd9Sstevel@tonic-gate 	case 5:			/* msgsnap() */
24677c478bd9Sstevel@tonic-gate 	default:		/* unexpected subcode */
24687c478bd9Sstevel@tonic-gate 		break;
24697c478bd9Sstevel@tonic-gate 	}
24707c478bd9Sstevel@tonic-gate }
24717c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
24727c478bd9Sstevel@tonic-gate 
24737c478bd9Sstevel@tonic-gate static void
24747c478bd9Sstevel@tonic-gate show_semctl64(private_t *pri, long offset)
24757c478bd9Sstevel@tonic-gate {
24767c478bd9Sstevel@tonic-gate 	struct semid_ds64 semds;
24777c478bd9Sstevel@tonic-gate 
24787c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
24797c478bd9Sstevel@tonic-gate 	    Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) {
24807c478bd9Sstevel@tonic-gate 		show_perm64(pri, &semds.semx_perm);
24817c478bd9Sstevel@tonic-gate 
24827c478bd9Sstevel@tonic-gate 		(void) printf("%s\tnsems=%u\n", pri->pname, semds.semx_nsems);
24837c478bd9Sstevel@tonic-gate 
24847c478bd9Sstevel@tonic-gate 		prtime(pri, "    ot = ", (time_t)semds.semx_otime);
24857c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", (time_t)semds.semx_ctime);
24867c478bd9Sstevel@tonic-gate 	}
24877c478bd9Sstevel@tonic-gate }
24887c478bd9Sstevel@tonic-gate 
24897c478bd9Sstevel@tonic-gate void
24907c478bd9Sstevel@tonic-gate show_semctl(private_t *pri, long offset)
24917c478bd9Sstevel@tonic-gate {
24927c478bd9Sstevel@tonic-gate 	struct semid_ds semds;
24937c478bd9Sstevel@tonic-gate 
24947c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
24957c478bd9Sstevel@tonic-gate 	    Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) {
24967c478bd9Sstevel@tonic-gate 		show_perm(pri, &semds.sem_perm);
24977c478bd9Sstevel@tonic-gate 
24987c478bd9Sstevel@tonic-gate 		(void) printf("%s\tnsems=%u\n",
2499019c3c43Sraf 		    pri->pname,
2500019c3c43Sraf 		    semds.sem_nsems);
25017c478bd9Sstevel@tonic-gate 
25027c478bd9Sstevel@tonic-gate 		prtime(pri, "    ot = ", semds.sem_otime);
25037c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", semds.sem_ctime);
25047c478bd9Sstevel@tonic-gate 	}
25057c478bd9Sstevel@tonic-gate }
25067c478bd9Sstevel@tonic-gate 
25077c478bd9Sstevel@tonic-gate #ifdef _LP64
25087c478bd9Sstevel@tonic-gate void
25097c478bd9Sstevel@tonic-gate show_semctl32(private_t *pri, long offset)
25107c478bd9Sstevel@tonic-gate {
25117c478bd9Sstevel@tonic-gate 	struct semid_ds32 semds;
25127c478bd9Sstevel@tonic-gate 
25137c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
25147c478bd9Sstevel@tonic-gate 	    Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) {
25157c478bd9Sstevel@tonic-gate 		show_perm32(pri, &semds.sem_perm);
25167c478bd9Sstevel@tonic-gate 
25177c478bd9Sstevel@tonic-gate 		(void) printf("%s\tnsems=%u\n",
2518019c3c43Sraf 		    pri->pname,
2519019c3c43Sraf 		    semds.sem_nsems);
25207c478bd9Sstevel@tonic-gate 
25217c478bd9Sstevel@tonic-gate 		prtime(pri, "    ot = ", semds.sem_otime);
25227c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", semds.sem_ctime);
25237c478bd9Sstevel@tonic-gate 	}
25247c478bd9Sstevel@tonic-gate }
25257c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
25267c478bd9Sstevel@tonic-gate 
25277c478bd9Sstevel@tonic-gate void
25287c478bd9Sstevel@tonic-gate show_semop(private_t *pri, long offset, long nsops, long timeout)
25297c478bd9Sstevel@tonic-gate {
25307c478bd9Sstevel@tonic-gate 	struct sembuf sembuf;
25317c478bd9Sstevel@tonic-gate 	const char *str;
25327c478bd9Sstevel@tonic-gate 
25333b862e9aSRoger A. Faulkner 	if (offset == 0)
25347c478bd9Sstevel@tonic-gate 		return;
25357c478bd9Sstevel@tonic-gate 
25367c478bd9Sstevel@tonic-gate 	if (nsops > 40)		/* let's not be ridiculous */
25377c478bd9Sstevel@tonic-gate 		nsops = 40;
25387c478bd9Sstevel@tonic-gate 
25397c478bd9Sstevel@tonic-gate 	for (; nsops > 0 && !interrupt; --nsops, offset += sizeof (sembuf)) {
25407c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &sembuf, sizeof (sembuf), offset) !=
25417c478bd9Sstevel@tonic-gate 		    sizeof (sembuf))
25427c478bd9Sstevel@tonic-gate 			break;
25437c478bd9Sstevel@tonic-gate 
25447c478bd9Sstevel@tonic-gate 		(void) printf("%s\tsemnum=%-5u semop=%-5d semflg=",
2545019c3c43Sraf 		    pri->pname,
2546019c3c43Sraf 		    sembuf.sem_num,
2547019c3c43Sraf 		    sembuf.sem_op);
25487c478bd9Sstevel@tonic-gate 
25497c478bd9Sstevel@tonic-gate 		if (sembuf.sem_flg == 0)
25507c478bd9Sstevel@tonic-gate 			(void) printf("0\n");
25517c478bd9Sstevel@tonic-gate 		else if ((str = semflags(pri, sembuf.sem_flg)) != NULL)
25527c478bd9Sstevel@tonic-gate 			(void) printf("%s\n", str);
25537c478bd9Sstevel@tonic-gate 		else
25547c478bd9Sstevel@tonic-gate 			(void) printf("0%.6o\n", sembuf.sem_flg);
25557c478bd9Sstevel@tonic-gate 	}
25567c478bd9Sstevel@tonic-gate 	if (timeout)
25577c478bd9Sstevel@tonic-gate 		show_timestruc(pri, timeout, "timeout");
25587c478bd9Sstevel@tonic-gate }
25597c478bd9Sstevel@tonic-gate 
25607c478bd9Sstevel@tonic-gate void
25617c478bd9Sstevel@tonic-gate show_semsys(private_t *pri)
25627c478bd9Sstevel@tonic-gate {
25637c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[0]) {
25647c478bd9Sstevel@tonic-gate 	case 0:			/* semctl() */
25657c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 4) {
25667c478bd9Sstevel@tonic-gate 			switch (pri->sys_args[3]) {
25677c478bd9Sstevel@tonic-gate 			case IPC_STAT:
25687c478bd9Sstevel@tonic-gate 				if (pri->Errno)
25697c478bd9Sstevel@tonic-gate 					break;
25707c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
25717c478bd9Sstevel@tonic-gate 			case IPC_SET:
25727c478bd9Sstevel@tonic-gate #ifdef _LP64
25737c478bd9Sstevel@tonic-gate 				if (data_model == PR_MODEL_LP64)
25747c478bd9Sstevel@tonic-gate 					show_semctl(pri,
2575019c3c43Sraf 					    (long)pri->sys_args[4]);
25767c478bd9Sstevel@tonic-gate 				else
25777c478bd9Sstevel@tonic-gate 					show_semctl32(pri,
2578019c3c43Sraf 					    (long)pri->sys_args[4]);
25797c478bd9Sstevel@tonic-gate #else
25807c478bd9Sstevel@tonic-gate 				show_semctl(pri, (long)pri->sys_args[4]);
25817c478bd9Sstevel@tonic-gate #endif
25827c478bd9Sstevel@tonic-gate 				break;
25837c478bd9Sstevel@tonic-gate 			case IPC_STAT64:
25847c478bd9Sstevel@tonic-gate 				if (pri->Errno)
25857c478bd9Sstevel@tonic-gate 					break;
25867c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
25877c478bd9Sstevel@tonic-gate 			case IPC_SET64:
25887c478bd9Sstevel@tonic-gate 				show_semctl64(pri, (long)pri->sys_args[4]);
25897c478bd9Sstevel@tonic-gate 				break;
25907c478bd9Sstevel@tonic-gate 			}
25917c478bd9Sstevel@tonic-gate 		}
25927c478bd9Sstevel@tonic-gate 		break;
25937c478bd9Sstevel@tonic-gate 	case 1:			/* semget() */
25947c478bd9Sstevel@tonic-gate 		break;
25957c478bd9Sstevel@tonic-gate 	case 2:			/* semop() */
25967c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3)
25977c478bd9Sstevel@tonic-gate 			show_semop(pri, (long)pri->sys_args[2],
2598019c3c43Sraf 			    pri->sys_args[3], 0);
25997c478bd9Sstevel@tonic-gate 		break;
26007c478bd9Sstevel@tonic-gate 	case 3:			/* semids() */
26017c478bd9Sstevel@tonic-gate 		break;
26027c478bd9Sstevel@tonic-gate 	case 4:			/* semtimedop() */
26037c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 4)
26047c478bd9Sstevel@tonic-gate 			show_semop(pri, (long)pri->sys_args[2],
2605019c3c43Sraf 			    pri->sys_args[3], pri->sys_args[4]);
26067c478bd9Sstevel@tonic-gate 		break;
26077c478bd9Sstevel@tonic-gate 	default:		/* unexpected subcode */
26087c478bd9Sstevel@tonic-gate 		break;
26097c478bd9Sstevel@tonic-gate 	}
26107c478bd9Sstevel@tonic-gate }
26117c478bd9Sstevel@tonic-gate 
26127c478bd9Sstevel@tonic-gate static void
26137c478bd9Sstevel@tonic-gate show_shmctl64(private_t *pri, long offset)
26147c478bd9Sstevel@tonic-gate {
26157c478bd9Sstevel@tonic-gate 	struct shmid_ds64 shmds;
26167c478bd9Sstevel@tonic-gate 
26177c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
26187c478bd9Sstevel@tonic-gate 	    Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) {
26197c478bd9Sstevel@tonic-gate 		show_perm64(pri, &shmds.shmx_perm);
26207c478bd9Sstevel@tonic-gate 
26217c478bd9Sstevel@tonic-gate 		(void) printf(
26227c478bd9Sstevel@tonic-gate 		    "%s\tsize=%-6llu lpid=%-5d cpid=%-5d na=%-5llu cna=%llu\n",
26237c478bd9Sstevel@tonic-gate 		    pri->pname,
26247c478bd9Sstevel@tonic-gate 		    (unsigned long long)shmds.shmx_segsz,
26257c478bd9Sstevel@tonic-gate 		    (int)shmds.shmx_lpid,
26267c478bd9Sstevel@tonic-gate 		    (int)shmds.shmx_cpid,
26277c478bd9Sstevel@tonic-gate 		    (unsigned long long)shmds.shmx_nattch,
26287c478bd9Sstevel@tonic-gate 		    (unsigned long long)shmds.shmx_cnattch);
26297c478bd9Sstevel@tonic-gate 
26307c478bd9Sstevel@tonic-gate 		prtime(pri, "    at = ", (time_t)shmds.shmx_atime);
26317c478bd9Sstevel@tonic-gate 		prtime(pri, "    dt = ", (time_t)shmds.shmx_dtime);
26327c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", (time_t)shmds.shmx_ctime);
26337c478bd9Sstevel@tonic-gate 	}
26347c478bd9Sstevel@tonic-gate }
26357c478bd9Sstevel@tonic-gate 
26367c478bd9Sstevel@tonic-gate void
26377c478bd9Sstevel@tonic-gate show_shmctl(private_t *pri, long offset)
26387c478bd9Sstevel@tonic-gate {
26397c478bd9Sstevel@tonic-gate 	struct shmid_ds shmds;
26407c478bd9Sstevel@tonic-gate 
26417c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
26427c478bd9Sstevel@tonic-gate 	    Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) {
26437c478bd9Sstevel@tonic-gate 		show_perm(pri, &shmds.shm_perm);
26447c478bd9Sstevel@tonic-gate 
26457c478bd9Sstevel@tonic-gate 		(void) printf(
2646019c3c43Sraf 		    "%s\tsize=%-6lu lpid=%-5u cpid=%-5u na=%-5lu cna=%lu\n",
2647019c3c43Sraf 		    pri->pname,
2648019c3c43Sraf 		    (ulong_t)shmds.shm_segsz,
2649019c3c43Sraf 		    (int)shmds.shm_lpid,
2650019c3c43Sraf 		    (int)shmds.shm_cpid,
2651019c3c43Sraf 		    shmds.shm_nattch,
2652019c3c43Sraf 		    shmds.shm_cnattch);
26537c478bd9Sstevel@tonic-gate 
26547c478bd9Sstevel@tonic-gate 		prtime(pri, "    at = ", shmds.shm_atime);
26557c478bd9Sstevel@tonic-gate 		prtime(pri, "    dt = ", shmds.shm_dtime);
26567c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", shmds.shm_ctime);
26577c478bd9Sstevel@tonic-gate 	}
26587c478bd9Sstevel@tonic-gate }
26597c478bd9Sstevel@tonic-gate 
26607c478bd9Sstevel@tonic-gate #ifdef _LP64
26617c478bd9Sstevel@tonic-gate void
26627c478bd9Sstevel@tonic-gate show_shmctl32(private_t *pri, long offset)
26637c478bd9Sstevel@tonic-gate {
26647c478bd9Sstevel@tonic-gate 	struct shmid_ds32 shmds;
26657c478bd9Sstevel@tonic-gate 
26667c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
26677c478bd9Sstevel@tonic-gate 	    Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) {
26687c478bd9Sstevel@tonic-gate 		show_perm32(pri, &shmds.shm_perm);
26697c478bd9Sstevel@tonic-gate 
26707c478bd9Sstevel@tonic-gate 		(void) printf(
2671019c3c43Sraf 		    "%s\tsize=%-6u lpid=%-5u cpid=%-5u na=%-5u cna=%u\n",
2672019c3c43Sraf 		    pri->pname,
2673019c3c43Sraf 		    shmds.shm_segsz,
2674019c3c43Sraf 		    shmds.shm_lpid,
2675019c3c43Sraf 		    shmds.shm_cpid,
2676019c3c43Sraf 		    shmds.shm_nattch,
2677019c3c43Sraf 		    shmds.shm_cnattch);
26787c478bd9Sstevel@tonic-gate 
26797c478bd9Sstevel@tonic-gate 		prtime(pri, "    at = ", shmds.shm_atime);
26807c478bd9Sstevel@tonic-gate 		prtime(pri, "    dt = ", shmds.shm_dtime);
26817c478bd9Sstevel@tonic-gate 		prtime(pri, "    ct = ", shmds.shm_ctime);
26827c478bd9Sstevel@tonic-gate 	}
26837c478bd9Sstevel@tonic-gate }
26847c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
26857c478bd9Sstevel@tonic-gate 
26867c478bd9Sstevel@tonic-gate void
26877c478bd9Sstevel@tonic-gate show_shmsys(private_t *pri)
26887c478bd9Sstevel@tonic-gate {
26897c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[0]) {
26907c478bd9Sstevel@tonic-gate 	case 0:			/* shmat() */
26917c478bd9Sstevel@tonic-gate 		break;
26927c478bd9Sstevel@tonic-gate 	case 1:			/* shmctl() */
26937c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3) {
26947c478bd9Sstevel@tonic-gate 			switch (pri->sys_args[2]) {
26957c478bd9Sstevel@tonic-gate 			case IPC_STAT:
26967c478bd9Sstevel@tonic-gate 				if (pri->Errno)
26977c478bd9Sstevel@tonic-gate 					break;
26987c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
26997c478bd9Sstevel@tonic-gate 			case IPC_SET:
27007c478bd9Sstevel@tonic-gate #ifdef _LP64
27017c478bd9Sstevel@tonic-gate 				if (data_model == PR_MODEL_LP64)
27027c478bd9Sstevel@tonic-gate 					show_shmctl(pri,
2703019c3c43Sraf 					    (long)pri->sys_args[3]);
27047c478bd9Sstevel@tonic-gate 				else
27057c478bd9Sstevel@tonic-gate 					show_shmctl32(pri,
2706019c3c43Sraf 					    (long)pri->sys_args[3]);
27077c478bd9Sstevel@tonic-gate #else
27087c478bd9Sstevel@tonic-gate 				show_shmctl(pri, (long)pri->sys_args[3]);
27097c478bd9Sstevel@tonic-gate #endif
27107c478bd9Sstevel@tonic-gate 				break;
27117c478bd9Sstevel@tonic-gate 			case IPC_STAT64:
27127c478bd9Sstevel@tonic-gate 				if (pri->Errno)
27137c478bd9Sstevel@tonic-gate 					break;
27147c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
27157c478bd9Sstevel@tonic-gate 			case IPC_SET64:
27167c478bd9Sstevel@tonic-gate 				show_shmctl64(pri, (long)pri->sys_args[3]);
27177c478bd9Sstevel@tonic-gate 				break;
27187c478bd9Sstevel@tonic-gate 			}
27197c478bd9Sstevel@tonic-gate 		}
27207c478bd9Sstevel@tonic-gate 		break;
27217c478bd9Sstevel@tonic-gate 	case 2:			/* shmdt() */
27227c478bd9Sstevel@tonic-gate 	case 3:			/* shmget() */
27237c478bd9Sstevel@tonic-gate 	case 4:			/* shmids() */
27247c478bd9Sstevel@tonic-gate 	default:		/* unexpected subcode */
27257c478bd9Sstevel@tonic-gate 		break;
27267c478bd9Sstevel@tonic-gate 	}
27277c478bd9Sstevel@tonic-gate }
27287c478bd9Sstevel@tonic-gate 
27297c478bd9Sstevel@tonic-gate void
27307c478bd9Sstevel@tonic-gate show_groups(private_t *pri, long offset, long count)
27317c478bd9Sstevel@tonic-gate {
27327c478bd9Sstevel@tonic-gate 	int groups[100];
27337c478bd9Sstevel@tonic-gate 
27347c478bd9Sstevel@tonic-gate 	if (count > 100)
27357c478bd9Sstevel@tonic-gate 		count = 100;
27367c478bd9Sstevel@tonic-gate 
27377c478bd9Sstevel@tonic-gate 	if (count > 0 && offset != NULL &&
27387c478bd9Sstevel@tonic-gate 	    Pread(Proc, &groups[0], count*sizeof (int), offset) ==
27397c478bd9Sstevel@tonic-gate 	    count*sizeof (int)) {
27407c478bd9Sstevel@tonic-gate 		int n;
27417c478bd9Sstevel@tonic-gate 
27427c478bd9Sstevel@tonic-gate 		(void) printf("%s\t", pri->pname);
27437c478bd9Sstevel@tonic-gate 		for (n = 0; !interrupt && n < count; n++) {
27447c478bd9Sstevel@tonic-gate 			if (n != 0 && n%10 == 0)
27457c478bd9Sstevel@tonic-gate 				(void) printf("\n%s\t", pri->pname);
27467c478bd9Sstevel@tonic-gate 			(void) printf(" %5d", groups[n]);
27477c478bd9Sstevel@tonic-gate 		}
27487c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
27497c478bd9Sstevel@tonic-gate 	}
27507c478bd9Sstevel@tonic-gate }
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate /*
27537c478bd9Sstevel@tonic-gate  * This assumes that a sigset_t is simply an array of ints.
27547c478bd9Sstevel@tonic-gate  */
27557c478bd9Sstevel@tonic-gate char *
27567c478bd9Sstevel@tonic-gate sigset_string(private_t *pri, sigset_t *sp)
27577c478bd9Sstevel@tonic-gate {
27587c478bd9Sstevel@tonic-gate 	char *s = pri->code_buf;
27597c478bd9Sstevel@tonic-gate 	int n = sizeof (*sp) / sizeof (int32_t);
27607c478bd9Sstevel@tonic-gate 	int32_t *lp = (int32_t *)sp;
27617c478bd9Sstevel@tonic-gate 
27627c478bd9Sstevel@tonic-gate 	while (--n >= 0) {
27637c478bd9Sstevel@tonic-gate 		int32_t val = *lp++;
27647c478bd9Sstevel@tonic-gate 
27657c478bd9Sstevel@tonic-gate 		if (val == 0)
27667c478bd9Sstevel@tonic-gate 			s += sprintf(s, " 0");
27677c478bd9Sstevel@tonic-gate 		else
27687c478bd9Sstevel@tonic-gate 			s += sprintf(s, " 0x%.8X", val);
27697c478bd9Sstevel@tonic-gate 	}
27707c478bd9Sstevel@tonic-gate 
27717c478bd9Sstevel@tonic-gate 	return (pri->code_buf);
27727c478bd9Sstevel@tonic-gate }
27737c478bd9Sstevel@tonic-gate 
27747c478bd9Sstevel@tonic-gate void
27757c478bd9Sstevel@tonic-gate show_sigset(private_t *pri, long offset, const char *name)
27767c478bd9Sstevel@tonic-gate {
27777c478bd9Sstevel@tonic-gate 	sigset_t sigset;
27787c478bd9Sstevel@tonic-gate 
27797c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
27807c478bd9Sstevel@tonic-gate 	    Pread(Proc, &sigset, sizeof (sigset), offset) == sizeof (sigset)) {
27817c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s =%s\n",
2782019c3c43Sraf 		    pri->pname, name, sigset_string(pri, &sigset));
27837c478bd9Sstevel@tonic-gate 	}
27847c478bd9Sstevel@tonic-gate }
27857c478bd9Sstevel@tonic-gate 
27867c478bd9Sstevel@tonic-gate #ifdef _LP64
27877c478bd9Sstevel@tonic-gate void
27887c478bd9Sstevel@tonic-gate show_sigaltstack32(private_t *pri, long offset, const char *name)
27897c478bd9Sstevel@tonic-gate {
27907c478bd9Sstevel@tonic-gate 	struct sigaltstack32 altstack;
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
27937c478bd9Sstevel@tonic-gate 	    Pread(Proc, &altstack, sizeof (altstack), offset) ==
27947c478bd9Sstevel@tonic-gate 	    sizeof (altstack)) {
27957c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s: sp=0x%.8X size=%u flags=0x%.4X\n",
2796019c3c43Sraf 		    pri->pname,
2797019c3c43Sraf 		    name,
2798019c3c43Sraf 		    altstack.ss_sp,
2799019c3c43Sraf 		    altstack.ss_size,
2800019c3c43Sraf 		    altstack.ss_flags);
28017c478bd9Sstevel@tonic-gate 	}
28027c478bd9Sstevel@tonic-gate }
28037c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
28047c478bd9Sstevel@tonic-gate 
28057c478bd9Sstevel@tonic-gate void
28067c478bd9Sstevel@tonic-gate show_sigaltstack(private_t *pri, long offset, const char *name)
28077c478bd9Sstevel@tonic-gate {
28087c478bd9Sstevel@tonic-gate 	struct sigaltstack altstack;
28097c478bd9Sstevel@tonic-gate 
28107c478bd9Sstevel@tonic-gate #ifdef _LP64
28117c478bd9Sstevel@tonic-gate 	if (data_model != PR_MODEL_LP64) {
28127c478bd9Sstevel@tonic-gate 		show_sigaltstack32(pri, offset, name);
28137c478bd9Sstevel@tonic-gate 		return;
28147c478bd9Sstevel@tonic-gate 	}
28157c478bd9Sstevel@tonic-gate #endif
28167c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
28177c478bd9Sstevel@tonic-gate 	    Pread(Proc, &altstack, sizeof (altstack), offset) ==
28187c478bd9Sstevel@tonic-gate 	    sizeof (altstack)) {
28197c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%s: sp=0x%.8lX size=%lu flags=0x%.4X\n",
2820019c3c43Sraf 		    pri->pname,
2821019c3c43Sraf 		    name,
2822019c3c43Sraf 		    (ulong_t)altstack.ss_sp,
2823019c3c43Sraf 		    (ulong_t)altstack.ss_size,
2824019c3c43Sraf 		    altstack.ss_flags);
28257c478bd9Sstevel@tonic-gate 	}
28267c478bd9Sstevel@tonic-gate }
28277c478bd9Sstevel@tonic-gate 
28287c478bd9Sstevel@tonic-gate #ifdef _LP64
28297c478bd9Sstevel@tonic-gate void
28307c478bd9Sstevel@tonic-gate show_sigaction32(private_t *pri, long offset, const char *name, long odisp)
28317c478bd9Sstevel@tonic-gate {
28327c478bd9Sstevel@tonic-gate 	struct sigaction32 sigaction;
28337c478bd9Sstevel@tonic-gate 
28347c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
28357c478bd9Sstevel@tonic-gate 	    Pread(Proc, &sigaction, sizeof (sigaction), offset) ==
28367c478bd9Sstevel@tonic-gate 	    sizeof (sigaction)) {
28377c478bd9Sstevel@tonic-gate 		/* This is stupid, we shouldn't have to do this */
28387c478bd9Sstevel@tonic-gate 		if (odisp != NULL)
28397c478bd9Sstevel@tonic-gate 			sigaction.sa_handler = (caddr32_t)odisp;
28407c478bd9Sstevel@tonic-gate 		(void) printf(
2841019c3c43Sraf 		    "%s    %s: hand = 0x%.8X mask =%s flags = 0x%.4X\n",
2842019c3c43Sraf 		    pri->pname,
2843019c3c43Sraf 		    name,
2844019c3c43Sraf 		    sigaction.sa_handler,
2845019c3c43Sraf 		    sigset_string(pri, (sigset_t *)&sigaction.sa_mask),
2846019c3c43Sraf 		    sigaction.sa_flags);
28477c478bd9Sstevel@tonic-gate 	}
28487c478bd9Sstevel@tonic-gate }
28497c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
28507c478bd9Sstevel@tonic-gate 
28517c478bd9Sstevel@tonic-gate void
28527c478bd9Sstevel@tonic-gate show_sigaction(private_t *pri, long offset, const char *name, long odisp)
28537c478bd9Sstevel@tonic-gate {
28547c478bd9Sstevel@tonic-gate 	struct sigaction sigaction;
28557c478bd9Sstevel@tonic-gate 
28567c478bd9Sstevel@tonic-gate #ifdef _LP64
28577c478bd9Sstevel@tonic-gate 	if (data_model != PR_MODEL_LP64) {
28587c478bd9Sstevel@tonic-gate 		show_sigaction32(pri, offset, name, odisp);
28597c478bd9Sstevel@tonic-gate 		return;
28607c478bd9Sstevel@tonic-gate 	}
28617c478bd9Sstevel@tonic-gate #endif
28627c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
28637c478bd9Sstevel@tonic-gate 	    Pread(Proc, &sigaction, sizeof (sigaction), offset) ==
28647c478bd9Sstevel@tonic-gate 	    sizeof (sigaction)) {
28657c478bd9Sstevel@tonic-gate 		/* This is stupid, we shouldn't have to do this */
28667c478bd9Sstevel@tonic-gate 		if (odisp != NULL)
28677c478bd9Sstevel@tonic-gate 			sigaction.sa_handler = (void (*)())odisp;
28687c478bd9Sstevel@tonic-gate 		(void) printf(
2869019c3c43Sraf 		    "%s    %s: hand = 0x%.8lX mask =%s flags = 0x%.4X\n",
2870019c3c43Sraf 		    pri->pname,
2871019c3c43Sraf 		    name,
2872019c3c43Sraf 		    (long)sigaction.sa_handler,
2873019c3c43Sraf 		    sigset_string(pri, &sigaction.sa_mask),
2874019c3c43Sraf 		    sigaction.sa_flags);
28757c478bd9Sstevel@tonic-gate 	}
28767c478bd9Sstevel@tonic-gate }
28777c478bd9Sstevel@tonic-gate 
28787c478bd9Sstevel@tonic-gate #ifdef _LP64
28797c478bd9Sstevel@tonic-gate void
28807c478bd9Sstevel@tonic-gate print_siginfo32(private_t *pri, const siginfo32_t *sip)
28817c478bd9Sstevel@tonic-gate {
28827c478bd9Sstevel@tonic-gate 	const char *code = NULL;
28837c478bd9Sstevel@tonic-gate 
28847c478bd9Sstevel@tonic-gate 	(void) printf("%s      siginfo: %s", pri->pname,
2885019c3c43Sraf 	    signame(pri, sip->si_signo));
28867c478bd9Sstevel@tonic-gate 
28877c478bd9Sstevel@tonic-gate 	if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) {
28887c478bd9Sstevel@tonic-gate 		(void) printf(" pid=%d uid=%d", sip->si_pid, sip->si_uid);
28897c478bd9Sstevel@tonic-gate 		if (sip->si_code != 0)
28907c478bd9Sstevel@tonic-gate 			(void) printf(" code=%d", sip->si_code);
28917c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
28927c478bd9Sstevel@tonic-gate 		return;
28937c478bd9Sstevel@tonic-gate 	}
28947c478bd9Sstevel@tonic-gate 
28957c478bd9Sstevel@tonic-gate 	switch (sip->si_signo) {
28967c478bd9Sstevel@tonic-gate 	default:
28977c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
28987c478bd9Sstevel@tonic-gate 		return;
28997c478bd9Sstevel@tonic-gate 	case SIGILL:
29007c478bd9Sstevel@tonic-gate 	case SIGTRAP:
29017c478bd9Sstevel@tonic-gate 	case SIGFPE:
29027c478bd9Sstevel@tonic-gate 	case SIGSEGV:
29037c478bd9Sstevel@tonic-gate 	case SIGBUS:
29047c478bd9Sstevel@tonic-gate 	case SIGEMT:
29057c478bd9Sstevel@tonic-gate 	case SIGCLD:
29067c478bd9Sstevel@tonic-gate 	case SIGPOLL:
29077c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
29087c478bd9Sstevel@tonic-gate 		break;
29097c478bd9Sstevel@tonic-gate 	}
29107c478bd9Sstevel@tonic-gate 
29117c478bd9Sstevel@tonic-gate 	switch (sip->si_signo) {
29127c478bd9Sstevel@tonic-gate 	case SIGILL:
29137c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29147c478bd9Sstevel@tonic-gate 		case ILL_ILLOPC:	code = "ILL_ILLOPC";	break;
29157c478bd9Sstevel@tonic-gate 		case ILL_ILLOPN:	code = "ILL_ILLOPN";	break;
29167c478bd9Sstevel@tonic-gate 		case ILL_ILLADR:	code = "ILL_ILLADR";	break;
29177c478bd9Sstevel@tonic-gate 		case ILL_ILLTRP:	code = "ILL_ILLTRP";	break;
29187c478bd9Sstevel@tonic-gate 		case ILL_PRVOPC:	code = "ILL_PRVOPC";	break;
29197c478bd9Sstevel@tonic-gate 		case ILL_PRVREG:	code = "ILL_PRVREG";	break;
29207c478bd9Sstevel@tonic-gate 		case ILL_COPROC:	code = "ILL_COPROC";	break;
29217c478bd9Sstevel@tonic-gate 		case ILL_BADSTK:	code = "ILL_BADSTK";	break;
29227c478bd9Sstevel@tonic-gate 		}
29237c478bd9Sstevel@tonic-gate 		break;
29247c478bd9Sstevel@tonic-gate 	case SIGTRAP:
29257c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29267c478bd9Sstevel@tonic-gate 		case TRAP_BRKPT:	code = "TRAP_BRKPT";	break;
29277c478bd9Sstevel@tonic-gate 		case TRAP_TRACE:	code = "TRAP_TRACE";	break;
29287c478bd9Sstevel@tonic-gate 		case TRAP_RWATCH:	code = "TRAP_RWATCH";	break;
29297c478bd9Sstevel@tonic-gate 		case TRAP_WWATCH:	code = "TRAP_WWATCH";	break;
29307c478bd9Sstevel@tonic-gate 		case TRAP_XWATCH:	code = "TRAP_XWATCH";	break;
29317c478bd9Sstevel@tonic-gate 		case TRAP_DTRACE:	code = "TRAP_DTRACE";	break;
29327c478bd9Sstevel@tonic-gate 		}
29337c478bd9Sstevel@tonic-gate 		break;
29347c478bd9Sstevel@tonic-gate 	case SIGFPE:
29357c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29367c478bd9Sstevel@tonic-gate 		case FPE_INTDIV:	code = "FPE_INTDIV";	break;
29377c478bd9Sstevel@tonic-gate 		case FPE_INTOVF:	code = "FPE_INTOVF";	break;
29387c478bd9Sstevel@tonic-gate 		case FPE_FLTDIV:	code = "FPE_FLTDIV";	break;
29397c478bd9Sstevel@tonic-gate 		case FPE_FLTOVF:	code = "FPE_FLTOVF";	break;
29407c478bd9Sstevel@tonic-gate 		case FPE_FLTUND:	code = "FPE_FLTUND";	break;
29417c478bd9Sstevel@tonic-gate 		case FPE_FLTRES:	code = "FPE_FLTRES";	break;
29427c478bd9Sstevel@tonic-gate 		case FPE_FLTINV:	code = "FPE_FLTINV";	break;
29437c478bd9Sstevel@tonic-gate 		case FPE_FLTSUB:	code = "FPE_FLTSUB";	break;
29447c478bd9Sstevel@tonic-gate #if defined(FPE_FLTDEN)
29457c478bd9Sstevel@tonic-gate 		case FPE_FLTDEN:	code = "FPE_FLTDEN";	break;
29467c478bd9Sstevel@tonic-gate #endif
29477c478bd9Sstevel@tonic-gate 		}
29487c478bd9Sstevel@tonic-gate 		break;
29497c478bd9Sstevel@tonic-gate 	case SIGSEGV:
29507c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29517c478bd9Sstevel@tonic-gate 		case SEGV_MAPERR:	code = "SEGV_MAPERR";	break;
29527c478bd9Sstevel@tonic-gate 		case SEGV_ACCERR:	code = "SEGV_ACCERR";	break;
29537c478bd9Sstevel@tonic-gate 		}
29547c478bd9Sstevel@tonic-gate 		break;
29557c478bd9Sstevel@tonic-gate 	case SIGEMT:
29567c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29577c478bd9Sstevel@tonic-gate #ifdef EMT_TAGOVF
29587c478bd9Sstevel@tonic-gate 		case EMT_TAGOVF:	code = "EMT_TAGOVF";	break;
29597c478bd9Sstevel@tonic-gate #endif
29607c478bd9Sstevel@tonic-gate 		case EMT_CPCOVF:	code = "EMT_CPCOVF";	break;
29617c478bd9Sstevel@tonic-gate 		}
29627c478bd9Sstevel@tonic-gate 		break;
29637c478bd9Sstevel@tonic-gate 	case SIGBUS:
29647c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29657c478bd9Sstevel@tonic-gate 		case BUS_ADRALN:	code = "BUS_ADRALN";	break;
29667c478bd9Sstevel@tonic-gate 		case BUS_ADRERR:	code = "BUS_ADRERR";	break;
29677c478bd9Sstevel@tonic-gate 		case BUS_OBJERR:	code = "BUS_OBJERR";	break;
29687c478bd9Sstevel@tonic-gate 		}
29697c478bd9Sstevel@tonic-gate 		break;
29707c478bd9Sstevel@tonic-gate 	case SIGCLD:
29717c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29727c478bd9Sstevel@tonic-gate 		case CLD_EXITED:	code = "CLD_EXITED";	break;
29737c478bd9Sstevel@tonic-gate 		case CLD_KILLED:	code = "CLD_KILLED";	break;
29747c478bd9Sstevel@tonic-gate 		case CLD_DUMPED:	code = "CLD_DUMPED";	break;
29757c478bd9Sstevel@tonic-gate 		case CLD_TRAPPED:	code = "CLD_TRAPPED";	break;
29767c478bd9Sstevel@tonic-gate 		case CLD_STOPPED:	code = "CLD_STOPPED";	break;
29777c478bd9Sstevel@tonic-gate 		case CLD_CONTINUED:	code = "CLD_CONTINUED";	break;
29787c478bd9Sstevel@tonic-gate 		}
29797c478bd9Sstevel@tonic-gate 		break;
29807c478bd9Sstevel@tonic-gate 	case SIGPOLL:
29817c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
29827c478bd9Sstevel@tonic-gate 		case POLL_IN:		code = "POLL_IN";	break;
29837c478bd9Sstevel@tonic-gate 		case POLL_OUT:		code = "POLL_OUT";	break;
29847c478bd9Sstevel@tonic-gate 		case POLL_MSG:		code = "POLL_MSG";	break;
29857c478bd9Sstevel@tonic-gate 		case POLL_ERR:		code = "POLL_ERR";	break;
29867c478bd9Sstevel@tonic-gate 		case POLL_PRI:		code = "POLL_PRI";	break;
29877c478bd9Sstevel@tonic-gate 		case POLL_HUP:		code = "POLL_HUP";	break;
29887c478bd9Sstevel@tonic-gate 		}
29897c478bd9Sstevel@tonic-gate 		break;
29907c478bd9Sstevel@tonic-gate 	}
29917c478bd9Sstevel@tonic-gate 
29927c478bd9Sstevel@tonic-gate 	if (code == NULL) {
29937c478bd9Sstevel@tonic-gate 		(void) sprintf(pri->code_buf, "code=%d", sip->si_code);
29947c478bd9Sstevel@tonic-gate 		code = (const char *)pri->code_buf;
29957c478bd9Sstevel@tonic-gate 	}
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 	switch (sip->si_signo) {
29987c478bd9Sstevel@tonic-gate 	case SIGILL:
29997c478bd9Sstevel@tonic-gate 	case SIGTRAP:
30007c478bd9Sstevel@tonic-gate 	case SIGFPE:
30017c478bd9Sstevel@tonic-gate 	case SIGSEGV:
30027c478bd9Sstevel@tonic-gate 	case SIGBUS:
30037c478bd9Sstevel@tonic-gate 	case SIGEMT:
30047c478bd9Sstevel@tonic-gate 		(void) printf(" %s addr=0x%.8X",
3005019c3c43Sraf 		    code,
3006019c3c43Sraf 		    sip->si_addr);
30077c478bd9Sstevel@tonic-gate 		break;
30087c478bd9Sstevel@tonic-gate 	case SIGCLD:
30097c478bd9Sstevel@tonic-gate 		(void) printf(" %s pid=%d status=0x%.4X",
3010019c3c43Sraf 		    code,
3011019c3c43Sraf 		    sip->si_pid,
3012019c3c43Sraf 		    sip->si_status);
30137c478bd9Sstevel@tonic-gate 		break;
30147c478bd9Sstevel@tonic-gate 	case SIGPOLL:
30157c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
30167c478bd9Sstevel@tonic-gate 		(void) printf(" %s fd=%d band=%d",
3017019c3c43Sraf 		    code,
3018019c3c43Sraf 		    sip->si_fd,
3019019c3c43Sraf 		    sip->si_band);
30207c478bd9Sstevel@tonic-gate 		break;
30217c478bd9Sstevel@tonic-gate 	}
30227c478bd9Sstevel@tonic-gate 
30237c478bd9Sstevel@tonic-gate 	if (sip->si_errno != 0) {
30247c478bd9Sstevel@tonic-gate 		const char *ename = errname(sip->si_errno);
30257c478bd9Sstevel@tonic-gate 
30267c478bd9Sstevel@tonic-gate 		(void) printf(" errno=%d", sip->si_errno);
30277c478bd9Sstevel@tonic-gate 		if (ename != NULL)
30287c478bd9Sstevel@tonic-gate 			(void) printf("(%s)", ename);
30297c478bd9Sstevel@tonic-gate 	}
30307c478bd9Sstevel@tonic-gate 
30317c478bd9Sstevel@tonic-gate 	(void) fputc('\n', stdout);
30327c478bd9Sstevel@tonic-gate }
30337c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
30347c478bd9Sstevel@tonic-gate 
30357c478bd9Sstevel@tonic-gate void
30367c478bd9Sstevel@tonic-gate print_siginfo(private_t *pri, const siginfo_t *sip)
30377c478bd9Sstevel@tonic-gate {
30387c478bd9Sstevel@tonic-gate 	const char *code = NULL;
30397c478bd9Sstevel@tonic-gate 
30407c478bd9Sstevel@tonic-gate 	(void) printf("%s      siginfo: %s", pri->pname,
3041019c3c43Sraf 	    signame(pri, sip->si_signo));
30427c478bd9Sstevel@tonic-gate 
30437c478bd9Sstevel@tonic-gate 	if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) {
3044f48205beScasper 		(void) printf(" pid=%d uid=%u",
30457c478bd9Sstevel@tonic-gate 		    (int)sip->si_pid,
3046f48205beScasper 		    sip->si_uid);
30477c478bd9Sstevel@tonic-gate 		if (sip->si_code != 0)
30487c478bd9Sstevel@tonic-gate 			(void) printf(" code=%d", sip->si_code);
30497c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
30507c478bd9Sstevel@tonic-gate 		return;
30517c478bd9Sstevel@tonic-gate 	}
30527c478bd9Sstevel@tonic-gate 
30537c478bd9Sstevel@tonic-gate 	switch (sip->si_signo) {
30547c478bd9Sstevel@tonic-gate 	default:
30557c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
30567c478bd9Sstevel@tonic-gate 		return;
30577c478bd9Sstevel@tonic-gate 	case SIGILL:
30587c478bd9Sstevel@tonic-gate 	case SIGTRAP:
30597c478bd9Sstevel@tonic-gate 	case SIGFPE:
30607c478bd9Sstevel@tonic-gate 	case SIGSEGV:
30617c478bd9Sstevel@tonic-gate 	case SIGBUS:
30627c478bd9Sstevel@tonic-gate 	case SIGEMT:
30637c478bd9Sstevel@tonic-gate 	case SIGCLD:
30647c478bd9Sstevel@tonic-gate 	case SIGPOLL:
30657c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
30667c478bd9Sstevel@tonic-gate 		break;
30677c478bd9Sstevel@tonic-gate 	}
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate 	switch (sip->si_signo) {
30707c478bd9Sstevel@tonic-gate 	case SIGILL:
30717c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
30727c478bd9Sstevel@tonic-gate 		case ILL_ILLOPC:	code = "ILL_ILLOPC";	break;
30737c478bd9Sstevel@tonic-gate 		case ILL_ILLOPN:	code = "ILL_ILLOPN";	break;
30747c478bd9Sstevel@tonic-gate 		case ILL_ILLADR:	code = "ILL_ILLADR";	break;
30757c478bd9Sstevel@tonic-gate 		case ILL_ILLTRP:	code = "ILL_ILLTRP";	break;
30767c478bd9Sstevel@tonic-gate 		case ILL_PRVOPC:	code = "ILL_PRVOPC";	break;
30777c478bd9Sstevel@tonic-gate 		case ILL_PRVREG:	code = "ILL_PRVREG";	break;
30787c478bd9Sstevel@tonic-gate 		case ILL_COPROC:	code = "ILL_COPROC";	break;
30797c478bd9Sstevel@tonic-gate 		case ILL_BADSTK:	code = "ILL_BADSTK";	break;
30807c478bd9Sstevel@tonic-gate 		}
30817c478bd9Sstevel@tonic-gate 		break;
30827c478bd9Sstevel@tonic-gate 	case SIGTRAP:
30837c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
30847c478bd9Sstevel@tonic-gate 		case TRAP_BRKPT:	code = "TRAP_BRKPT";	break;
30857c478bd9Sstevel@tonic-gate 		case TRAP_TRACE:	code = "TRAP_TRACE";	break;
30867c478bd9Sstevel@tonic-gate 		case TRAP_RWATCH:	code = "TRAP_RWATCH";	break;
30877c478bd9Sstevel@tonic-gate 		case TRAP_WWATCH:	code = "TRAP_WWATCH";	break;
30887c478bd9Sstevel@tonic-gate 		case TRAP_XWATCH:	code = "TRAP_XWATCH";	break;
30897c478bd9Sstevel@tonic-gate 		case TRAP_DTRACE:	code = "TRAP_DTRACE";	break;
30907c478bd9Sstevel@tonic-gate 		}
30917c478bd9Sstevel@tonic-gate 		break;
30927c478bd9Sstevel@tonic-gate 	case SIGFPE:
30937c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
30947c478bd9Sstevel@tonic-gate 		case FPE_INTDIV:	code = "FPE_INTDIV";	break;
30957c478bd9Sstevel@tonic-gate 		case FPE_INTOVF:	code = "FPE_INTOVF";	break;
30967c478bd9Sstevel@tonic-gate 		case FPE_FLTDIV:	code = "FPE_FLTDIV";	break;
30977c478bd9Sstevel@tonic-gate 		case FPE_FLTOVF:	code = "FPE_FLTOVF";	break;
30987c478bd9Sstevel@tonic-gate 		case FPE_FLTUND:	code = "FPE_FLTUND";	break;
30997c478bd9Sstevel@tonic-gate 		case FPE_FLTRES:	code = "FPE_FLTRES";	break;
31007c478bd9Sstevel@tonic-gate 		case FPE_FLTINV:	code = "FPE_FLTINV";	break;
31017c478bd9Sstevel@tonic-gate 		case FPE_FLTSUB:	code = "FPE_FLTSUB";	break;
31027c478bd9Sstevel@tonic-gate #if defined(FPE_FLTDEN)
31037c478bd9Sstevel@tonic-gate 		case FPE_FLTDEN:	code = "FPE_FLTDEN";	break;
31047c478bd9Sstevel@tonic-gate #endif
31057c478bd9Sstevel@tonic-gate 		}
31067c478bd9Sstevel@tonic-gate 		break;
31077c478bd9Sstevel@tonic-gate 	case SIGSEGV:
31087c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
31097c478bd9Sstevel@tonic-gate 		case SEGV_MAPERR:	code = "SEGV_MAPERR";	break;
31107c478bd9Sstevel@tonic-gate 		case SEGV_ACCERR:	code = "SEGV_ACCERR";	break;
31117c478bd9Sstevel@tonic-gate 		}
31127c478bd9Sstevel@tonic-gate 		break;
31137c478bd9Sstevel@tonic-gate 	case SIGEMT:
31147c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
31157c478bd9Sstevel@tonic-gate #ifdef EMT_TAGOVF
31167c478bd9Sstevel@tonic-gate 		case EMT_TAGOVF:	code = "EMT_TAGOVF";	break;
31177c478bd9Sstevel@tonic-gate #endif
31187c478bd9Sstevel@tonic-gate 		case EMT_CPCOVF:	code = "EMT_CPCOVF";	break;
31197c478bd9Sstevel@tonic-gate 		}
31207c478bd9Sstevel@tonic-gate 		break;
31217c478bd9Sstevel@tonic-gate 	case SIGBUS:
31227c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
31237c478bd9Sstevel@tonic-gate 		case BUS_ADRALN:	code = "BUS_ADRALN";	break;
31247c478bd9Sstevel@tonic-gate 		case BUS_ADRERR:	code = "BUS_ADRERR";	break;
31257c478bd9Sstevel@tonic-gate 		case BUS_OBJERR:	code = "BUS_OBJERR";	break;
31267c478bd9Sstevel@tonic-gate 		}
31277c478bd9Sstevel@tonic-gate 		break;
31287c478bd9Sstevel@tonic-gate 	case SIGCLD:
31297c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
31307c478bd9Sstevel@tonic-gate 		case CLD_EXITED:	code = "CLD_EXITED";	break;
31317c478bd9Sstevel@tonic-gate 		case CLD_KILLED:	code = "CLD_KILLED";	break;
31327c478bd9Sstevel@tonic-gate 		case CLD_DUMPED:	code = "CLD_DUMPED";	break;
31337c478bd9Sstevel@tonic-gate 		case CLD_TRAPPED:	code = "CLD_TRAPPED";	break;
31347c478bd9Sstevel@tonic-gate 		case CLD_STOPPED:	code = "CLD_STOPPED";	break;
31357c478bd9Sstevel@tonic-gate 		case CLD_CONTINUED:	code = "CLD_CONTINUED";	break;
31367c478bd9Sstevel@tonic-gate 		}
31377c478bd9Sstevel@tonic-gate 		break;
31387c478bd9Sstevel@tonic-gate 	case SIGPOLL:
31397c478bd9Sstevel@tonic-gate 		switch (sip->si_code) {
31407c478bd9Sstevel@tonic-gate 		case POLL_IN:		code = "POLL_IN";	break;
31417c478bd9Sstevel@tonic-gate 		case POLL_OUT:		code = "POLL_OUT";	break;
31427c478bd9Sstevel@tonic-gate 		case POLL_MSG:		code = "POLL_MSG";	break;
31437c478bd9Sstevel@tonic-gate 		case POLL_ERR:		code = "POLL_ERR";	break;
31447c478bd9Sstevel@tonic-gate 		case POLL_PRI:		code = "POLL_PRI";	break;
31457c478bd9Sstevel@tonic-gate 		case POLL_HUP:		code = "POLL_HUP";	break;
31467c478bd9Sstevel@tonic-gate 		}
31477c478bd9Sstevel@tonic-gate 		break;
31487c478bd9Sstevel@tonic-gate 	}
31497c478bd9Sstevel@tonic-gate 
31507c478bd9Sstevel@tonic-gate 	if (code == NULL) {
31517c478bd9Sstevel@tonic-gate 		(void) sprintf(pri->code_buf, "code=%d", sip->si_code);
31527c478bd9Sstevel@tonic-gate 		code = (const char *)pri->code_buf;
31537c478bd9Sstevel@tonic-gate 	}
31547c478bd9Sstevel@tonic-gate 
31557c478bd9Sstevel@tonic-gate 	switch (sip->si_signo) {
31567c478bd9Sstevel@tonic-gate 	case SIGILL:
31577c478bd9Sstevel@tonic-gate 	case SIGTRAP:
31587c478bd9Sstevel@tonic-gate 	case SIGFPE:
31597c478bd9Sstevel@tonic-gate 	case SIGSEGV:
31607c478bd9Sstevel@tonic-gate 	case SIGBUS:
31617c478bd9Sstevel@tonic-gate 	case SIGEMT:
31627c478bd9Sstevel@tonic-gate 		(void) printf(" %s addr=0x%.8lX",
3163019c3c43Sraf 		    code,
3164019c3c43Sraf 		    (long)sip->si_addr);
31657c478bd9Sstevel@tonic-gate 		break;
31667c478bd9Sstevel@tonic-gate 	case SIGCLD:
31677c478bd9Sstevel@tonic-gate 		(void) printf(" %s pid=%d status=0x%.4X",
3168019c3c43Sraf 		    code,
3169019c3c43Sraf 		    (int)sip->si_pid,
3170019c3c43Sraf 		    sip->si_status);
31717c478bd9Sstevel@tonic-gate 		break;
31727c478bd9Sstevel@tonic-gate 	case SIGPOLL:
31737c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
31747c478bd9Sstevel@tonic-gate 		(void) printf(" %s fd=%d band=%ld",
3175019c3c43Sraf 		    code,
3176019c3c43Sraf 		    sip->si_fd,
3177019c3c43Sraf 		    sip->si_band);
31787c478bd9Sstevel@tonic-gate 		break;
31797c478bd9Sstevel@tonic-gate 	}
31807c478bd9Sstevel@tonic-gate 
31817c478bd9Sstevel@tonic-gate 	if (sip->si_errno != 0) {
31827c478bd9Sstevel@tonic-gate 		const char *ename = errname(sip->si_errno);
31837c478bd9Sstevel@tonic-gate 
31847c478bd9Sstevel@tonic-gate 		(void) printf(" errno=%d", sip->si_errno);
31857c478bd9Sstevel@tonic-gate 		if (ename != NULL)
31867c478bd9Sstevel@tonic-gate 			(void) printf("(%s)", ename);
31877c478bd9Sstevel@tonic-gate 	}
31887c478bd9Sstevel@tonic-gate 
31897c478bd9Sstevel@tonic-gate 	(void) fputc('\n', stdout);
31907c478bd9Sstevel@tonic-gate }
31917c478bd9Sstevel@tonic-gate 
31927c478bd9Sstevel@tonic-gate #ifdef _LP64
31937c478bd9Sstevel@tonic-gate void
31947c478bd9Sstevel@tonic-gate show_siginfo32(private_t *pri, long offset)
31957c478bd9Sstevel@tonic-gate {
31967c478bd9Sstevel@tonic-gate 	struct siginfo32 siginfo;
31977c478bd9Sstevel@tonic-gate 
31987c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
31997c478bd9Sstevel@tonic-gate 	    Pread(Proc, &siginfo, sizeof (siginfo), offset) == sizeof (siginfo))
32007c478bd9Sstevel@tonic-gate 		print_siginfo32(pri, &siginfo);
32017c478bd9Sstevel@tonic-gate }
32027c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
32037c478bd9Sstevel@tonic-gate 
32047c478bd9Sstevel@tonic-gate void
32057c478bd9Sstevel@tonic-gate show_siginfo(private_t *pri, long offset)
32067c478bd9Sstevel@tonic-gate {
32077c478bd9Sstevel@tonic-gate 	struct siginfo siginfo;
32087c478bd9Sstevel@tonic-gate 
32097c478bd9Sstevel@tonic-gate #ifdef _LP64
32107c478bd9Sstevel@tonic-gate 	if (data_model != PR_MODEL_LP64) {
32117c478bd9Sstevel@tonic-gate 		show_siginfo32(pri, offset);
32127c478bd9Sstevel@tonic-gate 		return;
32137c478bd9Sstevel@tonic-gate 	}
32147c478bd9Sstevel@tonic-gate #endif
32157c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
32167c478bd9Sstevel@tonic-gate 	    Pread(Proc, &siginfo, sizeof (siginfo), offset) == sizeof (siginfo))
32177c478bd9Sstevel@tonic-gate 		print_siginfo(pri, &siginfo);
32187c478bd9Sstevel@tonic-gate }
32197c478bd9Sstevel@tonic-gate 
32207c478bd9Sstevel@tonic-gate void
32217c478bd9Sstevel@tonic-gate show_bool(private_t *pri, long offset, int count)
32227c478bd9Sstevel@tonic-gate {
32237c478bd9Sstevel@tonic-gate 	int serial = (count > MYBUFSIZ / 4);
32247c478bd9Sstevel@tonic-gate 
32257c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
32267c478bd9Sstevel@tonic-gate 	if (serial)
32277c478bd9Sstevel@tonic-gate 		Eserialize();
32287c478bd9Sstevel@tonic-gate 
32297c478bd9Sstevel@tonic-gate 	while (count > 0) {
32307c478bd9Sstevel@tonic-gate 		char buf[32];
32317c478bd9Sstevel@tonic-gate 		int nb = (count < 32)? count : 32;
32327c478bd9Sstevel@tonic-gate 		int i;
32337c478bd9Sstevel@tonic-gate 
32347c478bd9Sstevel@tonic-gate 		if (Pread(Proc, buf, (size_t)nb, offset) != nb)
32357c478bd9Sstevel@tonic-gate 			break;
32367c478bd9Sstevel@tonic-gate 
32377c478bd9Sstevel@tonic-gate 		(void) printf("%s   ", pri->pname);
32387c478bd9Sstevel@tonic-gate 		for (i = 0; i < nb; i++)
32397c478bd9Sstevel@tonic-gate 			(void) printf(" %d", buf[i]);
32407c478bd9Sstevel@tonic-gate 		(void) fputc('\n', stdout);
32417c478bd9Sstevel@tonic-gate 
32427c478bd9Sstevel@tonic-gate 		count -= nb;
32437c478bd9Sstevel@tonic-gate 		offset += nb;
32447c478bd9Sstevel@tonic-gate 	}
32457c478bd9Sstevel@tonic-gate 
32467c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
32477c478bd9Sstevel@tonic-gate 	if (serial)
32487c478bd9Sstevel@tonic-gate 		Xserialize();
32497c478bd9Sstevel@tonic-gate }
32507c478bd9Sstevel@tonic-gate 
32517c478bd9Sstevel@tonic-gate #ifdef _LP64
32527c478bd9Sstevel@tonic-gate void
32537c478bd9Sstevel@tonic-gate show_iovec32(private_t *pri, long offset, int niov, int showbuf, long count)
32547c478bd9Sstevel@tonic-gate {
32557c478bd9Sstevel@tonic-gate 	iovec32_t iovec[16];
32567c478bd9Sstevel@tonic-gate 	iovec32_t *ip;
32577c478bd9Sstevel@tonic-gate 	long nb;
32587c478bd9Sstevel@tonic-gate 	int serial = (count > MYBUFSIZ / 4 && showbuf);
32597c478bd9Sstevel@tonic-gate 
32607c478bd9Sstevel@tonic-gate 	if (niov > 16)		/* is this the real limit? */
32617c478bd9Sstevel@tonic-gate 		niov = 16;
32627c478bd9Sstevel@tonic-gate 
32637c478bd9Sstevel@tonic-gate 	if (offset != NULL && niov > 0 &&
32647c478bd9Sstevel@tonic-gate 	    Pread(Proc, &iovec[0], niov*sizeof (iovec32_t), offset)
32657c478bd9Sstevel@tonic-gate 	    == niov*sizeof (iovec32_t)) {
32667c478bd9Sstevel@tonic-gate 		/* enter region of lengthy output */
32677c478bd9Sstevel@tonic-gate 		if (serial)
32687c478bd9Sstevel@tonic-gate 			Eserialize();
32697c478bd9Sstevel@tonic-gate 
32707c478bd9Sstevel@tonic-gate 		for (ip = &iovec[0]; niov-- && !interrupt; ip++) {
32717c478bd9Sstevel@tonic-gate 			(void) printf("%s\tiov_base = 0x%.8X  iov_len = %d\n",
3272019c3c43Sraf 			    pri->pname,
3273019c3c43Sraf 			    ip->iov_base,
3274019c3c43Sraf 			    ip->iov_len);
32757c478bd9Sstevel@tonic-gate 			if ((nb = count) > 0) {
32767c478bd9Sstevel@tonic-gate 				if (nb > ip->iov_len)
32777c478bd9Sstevel@tonic-gate 					nb = ip->iov_len;
32787c478bd9Sstevel@tonic-gate 				if (nb > 0)
32797c478bd9Sstevel@tonic-gate 					count -= nb;
32807c478bd9Sstevel@tonic-gate 			}
32817c478bd9Sstevel@tonic-gate 			if (showbuf && nb > 0)
32827c478bd9Sstevel@tonic-gate 				showbuffer(pri, (long)ip->iov_base, nb);
32837c478bd9Sstevel@tonic-gate 		}
32847c478bd9Sstevel@tonic-gate 
32857c478bd9Sstevel@tonic-gate 		/* exit region of lengthy output */
32867c478bd9Sstevel@tonic-gate 		if (serial)
32877c478bd9Sstevel@tonic-gate 			Xserialize();
32887c478bd9Sstevel@tonic-gate 	}
32897c478bd9Sstevel@tonic-gate }
32907c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
32917c478bd9Sstevel@tonic-gate 
32927c478bd9Sstevel@tonic-gate void
32937c478bd9Sstevel@tonic-gate show_iovec(private_t *pri, long offset, long niov, int showbuf, long count)
32947c478bd9Sstevel@tonic-gate {
32957c478bd9Sstevel@tonic-gate 	iovec_t iovec[16];
32967c478bd9Sstevel@tonic-gate 	iovec_t *ip;
32977c478bd9Sstevel@tonic-gate 	long nb;
32987c478bd9Sstevel@tonic-gate 	int serial = (count > MYBUFSIZ / 4 && showbuf);
32997c478bd9Sstevel@tonic-gate 
33007c478bd9Sstevel@tonic-gate #ifdef _LP64
33017c478bd9Sstevel@tonic-gate 	if (data_model != PR_MODEL_LP64) {
33027c478bd9Sstevel@tonic-gate 		show_iovec32(pri, offset, niov, showbuf, count);
33037c478bd9Sstevel@tonic-gate 		return;
33047c478bd9Sstevel@tonic-gate 	}
33057c478bd9Sstevel@tonic-gate #endif
33067c478bd9Sstevel@tonic-gate 	if (niov > 16)		/* is this the real limit? */
33077c478bd9Sstevel@tonic-gate 		niov = 16;
33087c478bd9Sstevel@tonic-gate 
33097c478bd9Sstevel@tonic-gate 	if (offset != NULL && niov > 0 &&
33107c478bd9Sstevel@tonic-gate 	    Pread(Proc, &iovec[0], niov*sizeof (iovec_t), offset)
33117c478bd9Sstevel@tonic-gate 	    == niov*sizeof (iovec_t)) {
33127c478bd9Sstevel@tonic-gate 		/* enter region of lengthy output */
33137c478bd9Sstevel@tonic-gate 		if (serial)
33147c478bd9Sstevel@tonic-gate 			Eserialize();
33157c478bd9Sstevel@tonic-gate 
33167c478bd9Sstevel@tonic-gate 		for (ip = &iovec[0]; niov-- && !interrupt; ip++) {
33177c478bd9Sstevel@tonic-gate 			(void) printf("%s\tiov_base = 0x%.8lX  iov_len = %lu\n",
3318019c3c43Sraf 			    pri->pname,
3319019c3c43Sraf 			    (long)ip->iov_base,
3320019c3c43Sraf 			    ip->iov_len);
33217c478bd9Sstevel@tonic-gate 			if ((nb = count) > 0) {
33227c478bd9Sstevel@tonic-gate 				if (nb > ip->iov_len)
33237c478bd9Sstevel@tonic-gate 					nb = ip->iov_len;
33247c478bd9Sstevel@tonic-gate 				if (nb > 0)
33257c478bd9Sstevel@tonic-gate 					count -= nb;
33267c478bd9Sstevel@tonic-gate 			}
33277c478bd9Sstevel@tonic-gate 			if (showbuf && nb > 0)
33287c478bd9Sstevel@tonic-gate 				showbuffer(pri, (long)ip->iov_base, nb);
33297c478bd9Sstevel@tonic-gate 		}
33307c478bd9Sstevel@tonic-gate 
33317c478bd9Sstevel@tonic-gate 		/* exit region of lengthy output */
33327c478bd9Sstevel@tonic-gate 		if (serial)
33337c478bd9Sstevel@tonic-gate 			Xserialize();
33347c478bd9Sstevel@tonic-gate 	}
33357c478bd9Sstevel@tonic-gate }
33367c478bd9Sstevel@tonic-gate 
33377c478bd9Sstevel@tonic-gate void
33387c478bd9Sstevel@tonic-gate show_dents32(private_t *pri, long offset, long count)
33397c478bd9Sstevel@tonic-gate {
33407c478bd9Sstevel@tonic-gate 	long buf[MYBUFSIZ / sizeof (long)];
33417c478bd9Sstevel@tonic-gate 	struct dirent32 *dp;
33427c478bd9Sstevel@tonic-gate 	int serial = (count > 100);
33437c478bd9Sstevel@tonic-gate 
33443b862e9aSRoger A. Faulkner 	if (offset == 0)
33457c478bd9Sstevel@tonic-gate 		return;
33467c478bd9Sstevel@tonic-gate 
33477c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
33487c478bd9Sstevel@tonic-gate 	if (serial)
33497c478bd9Sstevel@tonic-gate 		Eserialize();
33507c478bd9Sstevel@tonic-gate 
33517c478bd9Sstevel@tonic-gate 	while (count > 0 && !interrupt) {
33527c478bd9Sstevel@tonic-gate 		int nb = count < MYBUFSIZ? (int)count : MYBUFSIZ;
33537c478bd9Sstevel@tonic-gate 
33547c478bd9Sstevel@tonic-gate 		if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) <= 0)
33557c478bd9Sstevel@tonic-gate 			break;
33567c478bd9Sstevel@tonic-gate 
33577c478bd9Sstevel@tonic-gate 		dp = (struct dirent32 *)&buf[0];
33587c478bd9Sstevel@tonic-gate 		if (nb < (int)(dp->d_name - (char *)dp))
33597c478bd9Sstevel@tonic-gate 			break;
33607c478bd9Sstevel@tonic-gate 		if ((unsigned)nb < dp->d_reclen) {
33617c478bd9Sstevel@tonic-gate 			/* getdents() error? */
33627c478bd9Sstevel@tonic-gate 			(void) printf(
3363019c3c43Sraf 			    "%s    ino=%-5u off=%-4d rlen=%-3d\n",
3364019c3c43Sraf 			    pri->pname,
3365019c3c43Sraf 			    dp->d_ino,
3366019c3c43Sraf 			    dp->d_off,
3367019c3c43Sraf 			    dp->d_reclen);
33687c478bd9Sstevel@tonic-gate 			break;
33697c478bd9Sstevel@tonic-gate 		}
33707c478bd9Sstevel@tonic-gate 
33717c478bd9Sstevel@tonic-gate 		while (!interrupt &&
33727c478bd9Sstevel@tonic-gate 		    nb >= (int)(dp->d_name - (char *)dp) &&
33737c478bd9Sstevel@tonic-gate 		    (unsigned)nb >= dp->d_reclen) {
33747c478bd9Sstevel@tonic-gate 			(void) printf(
3375019c3c43Sraf 			    "%s    ino=%-5u off=%-4d rlen=%-3d \"%.*s\"\n",
3376019c3c43Sraf 			    pri->pname,
3377019c3c43Sraf 			    dp->d_ino,
3378019c3c43Sraf 			    dp->d_off,
3379019c3c43Sraf 			    dp->d_reclen,
3380019c3c43Sraf 			    dp->d_reclen - (int)(dp->d_name - (char *)dp),
3381019c3c43Sraf 			    dp->d_name);
33827c478bd9Sstevel@tonic-gate 			nb -= dp->d_reclen;
33837c478bd9Sstevel@tonic-gate 			count -= dp->d_reclen;
33847c478bd9Sstevel@tonic-gate 			offset += dp->d_reclen;
33857c478bd9Sstevel@tonic-gate 			/* LINTED improper alignment */
33867c478bd9Sstevel@tonic-gate 			dp = (struct dirent32 *)((char *)dp + dp->d_reclen);
33877c478bd9Sstevel@tonic-gate 		}
33887c478bd9Sstevel@tonic-gate 	}
33897c478bd9Sstevel@tonic-gate 
33907c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
33917c478bd9Sstevel@tonic-gate 	if (serial)
33927c478bd9Sstevel@tonic-gate 		Xserialize();
33937c478bd9Sstevel@tonic-gate }
33947c478bd9Sstevel@tonic-gate 
33957c478bd9Sstevel@tonic-gate void
33967c478bd9Sstevel@tonic-gate show_dents64(private_t *pri, long offset, long count)
33977c478bd9Sstevel@tonic-gate {
33987c478bd9Sstevel@tonic-gate 	long long buf[MYBUFSIZ / sizeof (long long)];
33997c478bd9Sstevel@tonic-gate 	struct dirent64 *dp;
34007c478bd9Sstevel@tonic-gate 	int serial = (count > 100);
34017c478bd9Sstevel@tonic-gate 
34023b862e9aSRoger A. Faulkner 	if (offset == 0)
34037c478bd9Sstevel@tonic-gate 		return;
34047c478bd9Sstevel@tonic-gate 
34057c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
34067c478bd9Sstevel@tonic-gate 	if (serial)
34077c478bd9Sstevel@tonic-gate 		Eserialize();
34087c478bd9Sstevel@tonic-gate 
34097c478bd9Sstevel@tonic-gate 	while (count > 0 && !interrupt) {
34107c478bd9Sstevel@tonic-gate 		int nb = count < MYBUFSIZ? (int)count : MYBUFSIZ;
34117c478bd9Sstevel@tonic-gate 
34127c478bd9Sstevel@tonic-gate 		if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) <= 0)
34137c478bd9Sstevel@tonic-gate 			break;
34147c478bd9Sstevel@tonic-gate 
34157c478bd9Sstevel@tonic-gate 		dp = (struct dirent64 *)&buf[0];
34167c478bd9Sstevel@tonic-gate 		if (nb < (int)(dp->d_name - (char *)dp))
34177c478bd9Sstevel@tonic-gate 			break;
34187c478bd9Sstevel@tonic-gate 		if ((unsigned)nb < dp->d_reclen) {
34197c478bd9Sstevel@tonic-gate 			/* getdents() error? */
34207c478bd9Sstevel@tonic-gate 			(void) printf(
3421019c3c43Sraf 			    "%s    ino=%-5llu off=%-4lld rlen=%-3d\n",
3422019c3c43Sraf 			    pri->pname,
3423019c3c43Sraf 			    (long long)dp->d_ino,
3424019c3c43Sraf 			    (long long)dp->d_off,
3425019c3c43Sraf 			    dp->d_reclen);
34267c478bd9Sstevel@tonic-gate 			break;
34277c478bd9Sstevel@tonic-gate 		}
34287c478bd9Sstevel@tonic-gate 
34297c478bd9Sstevel@tonic-gate 		while (!interrupt &&
34307c478bd9Sstevel@tonic-gate 		    nb >= (int)(dp->d_name - (char *)dp) &&
34317c478bd9Sstevel@tonic-gate 		    (unsigned)nb >= dp->d_reclen) {
34327c478bd9Sstevel@tonic-gate 			(void) printf(
3433019c3c43Sraf 			    "%s    ino=%-5llu off=%-4lld rlen=%-3d \"%.*s\"\n",
3434019c3c43Sraf 			    pri->pname,
3435019c3c43Sraf 			    (long long)dp->d_ino,
3436019c3c43Sraf 			    (long long)dp->d_off,
3437019c3c43Sraf 			    dp->d_reclen,
3438019c3c43Sraf 			    dp->d_reclen - (int)(dp->d_name - (char *)dp),
3439019c3c43Sraf 			    dp->d_name);
34407c478bd9Sstevel@tonic-gate 			nb -= dp->d_reclen;
34417c478bd9Sstevel@tonic-gate 			count -= dp->d_reclen;
34427c478bd9Sstevel@tonic-gate 			offset += dp->d_reclen;
34437c478bd9Sstevel@tonic-gate 			/* LINTED improper alignment */
34447c478bd9Sstevel@tonic-gate 			dp = (struct dirent64 *)((char *)dp + dp->d_reclen);
34457c478bd9Sstevel@tonic-gate 		}
34467c478bd9Sstevel@tonic-gate 	}
34477c478bd9Sstevel@tonic-gate 
34487c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
34497c478bd9Sstevel@tonic-gate 	if (serial)
34507c478bd9Sstevel@tonic-gate 		Xserialize();
34517c478bd9Sstevel@tonic-gate }
34527c478bd9Sstevel@tonic-gate 
34537c478bd9Sstevel@tonic-gate void
34547c478bd9Sstevel@tonic-gate show_rlimit32(private_t *pri, long offset)
34557c478bd9Sstevel@tonic-gate {
34567c478bd9Sstevel@tonic-gate 	struct rlimit32 rlimit;
34577c478bd9Sstevel@tonic-gate 
34587c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
34597c478bd9Sstevel@tonic-gate 	    Pread(Proc, &rlimit, sizeof (rlimit), offset) == sizeof (rlimit)) {
34607c478bd9Sstevel@tonic-gate 		(void) printf("%s\t", pri->pname);
34617c478bd9Sstevel@tonic-gate 		switch (rlimit.rlim_cur) {
34627c478bd9Sstevel@tonic-gate 		case RLIM32_INFINITY:
34637c478bd9Sstevel@tonic-gate 			(void) fputs("cur = RLIM_INFINITY", stdout);
34647c478bd9Sstevel@tonic-gate 			break;
34657c478bd9Sstevel@tonic-gate 		case RLIM32_SAVED_MAX:
34667c478bd9Sstevel@tonic-gate 			(void) fputs("cur = RLIM_SAVED_MAX", stdout);
34677c478bd9Sstevel@tonic-gate 			break;
34687c478bd9Sstevel@tonic-gate 		case RLIM32_SAVED_CUR:
34697c478bd9Sstevel@tonic-gate 			(void) fputs("cur = RLIM_SAVED_CUR", stdout);
34707c478bd9Sstevel@tonic-gate 			break;
34717c478bd9Sstevel@tonic-gate 		default:
34727c478bd9Sstevel@tonic-gate 			(void) printf("cur = %lu", (long)rlimit.rlim_cur);
34737c478bd9Sstevel@tonic-gate 			break;
34747c478bd9Sstevel@tonic-gate 		}
34757c478bd9Sstevel@tonic-gate 		switch (rlimit.rlim_max) {
34767c478bd9Sstevel@tonic-gate 		case RLIM32_INFINITY:
34777c478bd9Sstevel@tonic-gate 			(void) fputs("  max = RLIM_INFINITY\n", stdout);
34787c478bd9Sstevel@tonic-gate 			break;
34797c478bd9Sstevel@tonic-gate 		case RLIM32_SAVED_MAX:
34807c478bd9Sstevel@tonic-gate 			(void) fputs("  max = RLIM_SAVED_MAX\n", stdout);
34817c478bd9Sstevel@tonic-gate 			break;
34827c478bd9Sstevel@tonic-gate 		case RLIM32_SAVED_CUR:
34837c478bd9Sstevel@tonic-gate 			(void) fputs("  max = RLIM_SAVED_CUR\n", stdout);
34847c478bd9Sstevel@tonic-gate 			break;
34857c478bd9Sstevel@tonic-gate 		default:
34867c478bd9Sstevel@tonic-gate 			(void) printf("  max = %lu\n", (long)rlimit.rlim_max);
34877c478bd9Sstevel@tonic-gate 			break;
34887c478bd9Sstevel@tonic-gate 		}
34897c478bd9Sstevel@tonic-gate 	}
34907c478bd9Sstevel@tonic-gate }
34917c478bd9Sstevel@tonic-gate 
34927c478bd9Sstevel@tonic-gate void
34937c478bd9Sstevel@tonic-gate show_rlimit64(private_t *pri, long offset)
34947c478bd9Sstevel@tonic-gate {
34957c478bd9Sstevel@tonic-gate 	struct rlimit64 rlimit;
34967c478bd9Sstevel@tonic-gate 
34977c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
34987c478bd9Sstevel@tonic-gate 	    Pread(Proc, &rlimit, sizeof (rlimit), offset) == sizeof (rlimit)) {
34997c478bd9Sstevel@tonic-gate 		(void) printf("%s\t", pri->pname);
35007c478bd9Sstevel@tonic-gate 		switch (rlimit.rlim_cur) {
35017c478bd9Sstevel@tonic-gate 		case RLIM64_INFINITY:
35027c478bd9Sstevel@tonic-gate 			(void) fputs("cur = RLIM64_INFINITY", stdout);
35037c478bd9Sstevel@tonic-gate 			break;
35047c478bd9Sstevel@tonic-gate 		case RLIM64_SAVED_MAX:
35057c478bd9Sstevel@tonic-gate 			(void) fputs("cur = RLIM64_SAVED_MAX", stdout);
35067c478bd9Sstevel@tonic-gate 			break;
35077c478bd9Sstevel@tonic-gate 		case RLIM64_SAVED_CUR:
35087c478bd9Sstevel@tonic-gate 			(void) fputs("cur = RLIM64_SAVED_CUR", stdout);
35097c478bd9Sstevel@tonic-gate 			break;
35107c478bd9Sstevel@tonic-gate 		default:
35117c478bd9Sstevel@tonic-gate 			(void) printf("cur = %llu",
35127c478bd9Sstevel@tonic-gate 			    (unsigned long long)rlimit.rlim_cur);
35137c478bd9Sstevel@tonic-gate 			break;
35147c478bd9Sstevel@tonic-gate 		}
35157c478bd9Sstevel@tonic-gate 		switch (rlimit.rlim_max) {
35167c478bd9Sstevel@tonic-gate 		case RLIM64_INFINITY:
35177c478bd9Sstevel@tonic-gate 			(void) fputs("  max = RLIM64_INFINITY\n", stdout);
35187c478bd9Sstevel@tonic-gate 			break;
35197c478bd9Sstevel@tonic-gate 		case RLIM64_SAVED_MAX:
35207c478bd9Sstevel@tonic-gate 			(void) fputs("  max = RLIM64_SAVED_MAX\n", stdout);
35217c478bd9Sstevel@tonic-gate 			break;
35227c478bd9Sstevel@tonic-gate 		case RLIM64_SAVED_CUR:
35237c478bd9Sstevel@tonic-gate 			(void) fputs("  max = RLIM64_SAVED_CUR\n", stdout);
35247c478bd9Sstevel@tonic-gate 			break;
35257c478bd9Sstevel@tonic-gate 		default:
35267c478bd9Sstevel@tonic-gate 			(void) printf("  max = %llu\n",
35277c478bd9Sstevel@tonic-gate 			    (unsigned long long)rlimit.rlim_max);
35287c478bd9Sstevel@tonic-gate 			break;
35297c478bd9Sstevel@tonic-gate 		}
35307c478bd9Sstevel@tonic-gate 	}
35317c478bd9Sstevel@tonic-gate }
35327c478bd9Sstevel@tonic-gate 
35337c478bd9Sstevel@tonic-gate void
35347c478bd9Sstevel@tonic-gate show_nuname(private_t *pri, long offset)
35357c478bd9Sstevel@tonic-gate {
35367c478bd9Sstevel@tonic-gate 	struct utsname ubuf;
35377c478bd9Sstevel@tonic-gate 
35387c478bd9Sstevel@tonic-gate 	if (offset != NULL &&
35397c478bd9Sstevel@tonic-gate 	    Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
35407c478bd9Sstevel@tonic-gate 		(void) printf(
3541019c3c43Sraf 		    "%s\tsys=%s nod=%s rel=%s ver=%s mch=%s\n",
3542019c3c43Sraf 		    pri->pname,
3543019c3c43Sraf 		    ubuf.sysname,
3544019c3c43Sraf 		    ubuf.nodename,
3545019c3c43Sraf 		    ubuf.release,
3546019c3c43Sraf 		    ubuf.version,
3547019c3c43Sraf 		    ubuf.machine);
35487c478bd9Sstevel@tonic-gate 	}
35497c478bd9Sstevel@tonic-gate }
35507c478bd9Sstevel@tonic-gate 
35517c478bd9Sstevel@tonic-gate void
35527c478bd9Sstevel@tonic-gate show_adjtime(private_t *pri, long off1, long off2)
35537c478bd9Sstevel@tonic-gate {
35547c478bd9Sstevel@tonic-gate 	show_timeval(pri, off1, "   delta");
35557c478bd9Sstevel@tonic-gate 	show_timeval(pri, off2, "olddelta");
35567c478bd9Sstevel@tonic-gate }
35577c478bd9Sstevel@tonic-gate 
35587c478bd9Sstevel@tonic-gate void
35597c478bd9Sstevel@tonic-gate show_sockaddr(private_t *pri,
35607c478bd9Sstevel@tonic-gate 	const char *str, long addroff, long lenoff, long len)
35617c478bd9Sstevel@tonic-gate {
35627c478bd9Sstevel@tonic-gate 	/*
35637c478bd9Sstevel@tonic-gate 	 * A buffer large enough for PATH_MAX size AF_UNIX address, which is
35647c478bd9Sstevel@tonic-gate 	 * also large enough to store a sockaddr_in or a sockaddr_in6.
35657c478bd9Sstevel@tonic-gate 	 */
35667c478bd9Sstevel@tonic-gate 	long buf[(sizeof (short) + PATH_MAX + sizeof (long) - 1)
3567019c3c43Sraf 	    / sizeof (long)];
35687c478bd9Sstevel@tonic-gate 	struct sockaddr *sa = (struct sockaddr *)buf;
35697c478bd9Sstevel@tonic-gate 	struct sockaddr_in *sin = (struct sockaddr_in *)buf;
35707c478bd9Sstevel@tonic-gate 	struct sockaddr_un *soun = (struct sockaddr_un *)buf;
35717c478bd9Sstevel@tonic-gate 	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
35727c478bd9Sstevel@tonic-gate 	char addrbuf[INET6_ADDRSTRLEN];
35737c478bd9Sstevel@tonic-gate 
35747c478bd9Sstevel@tonic-gate 	if (lenoff != 0) {
35757c478bd9Sstevel@tonic-gate 		uint_t ilen;
35767c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &ilen, sizeof (ilen), lenoff) != sizeof (ilen))
35777c478bd9Sstevel@tonic-gate 			return;
35787c478bd9Sstevel@tonic-gate 		len = ilen;
35797c478bd9Sstevel@tonic-gate 	}
35807c478bd9Sstevel@tonic-gate 
35817c478bd9Sstevel@tonic-gate 	if (len >= sizeof (buf))	/* protect against ridiculous length */
35827c478bd9Sstevel@tonic-gate 		len = sizeof (buf) - 1;
35837c478bd9Sstevel@tonic-gate 	if (Pread(Proc, buf, len, addroff) != len)
35847c478bd9Sstevel@tonic-gate 		return;
35857c478bd9Sstevel@tonic-gate 
35867c478bd9Sstevel@tonic-gate 	switch (sa->sa_family) {
35877c478bd9Sstevel@tonic-gate 	case AF_INET6:
35887c478bd9Sstevel@tonic-gate 		(void) printf("%s\tAF_INET6  %s = %s  port = %u\n",
35897c478bd9Sstevel@tonic-gate 		    pri->pname, str,
35907c478bd9Sstevel@tonic-gate 		    inet_ntop(AF_INET6, &sin6->sin6_addr, addrbuf,
3591019c3c43Sraf 		    sizeof (addrbuf)),
35927c478bd9Sstevel@tonic-gate 		    ntohs(sin6->sin6_port));
35937c478bd9Sstevel@tonic-gate 		(void) printf("%s\tscope id = %u  source id = 0x%x\n"
35947c478bd9Sstevel@tonic-gate 		    "%s\tflow class = 0x%02x  flow label = 0x%05x\n",
35957c478bd9Sstevel@tonic-gate 		    pri->pname, ntohl(sin6->sin6_scope_id),
35967c478bd9Sstevel@tonic-gate 		    ntohl(sin6->__sin6_src_id),
35977c478bd9Sstevel@tonic-gate 		    pri->pname,
35987c478bd9Sstevel@tonic-gate 		    ntohl((sin6->sin6_flowinfo & IPV6_FLOWINFO_TCLASS) >> 20),
35997c478bd9Sstevel@tonic-gate 		    ntohl(sin6->sin6_flowinfo & IPV6_FLOWINFO_FLOWLABEL));
36007c478bd9Sstevel@tonic-gate 		break;
36017c478bd9Sstevel@tonic-gate 	case AF_INET:
36027c478bd9Sstevel@tonic-gate 		(void) printf("%s\tAF_%s  %s = %s  port = %u\n",
36032caf0dcdSrshoaib 		    pri->pname, "INET",
36047c478bd9Sstevel@tonic-gate 		    str, inet_ntop(AF_INET, &sin->sin_addr, addrbuf,
36057c478bd9Sstevel@tonic-gate 		    sizeof (addrbuf)), ntohs(sin->sin_port));
36067c478bd9Sstevel@tonic-gate 		break;
36077c478bd9Sstevel@tonic-gate 	case AF_UNIX:
36087c478bd9Sstevel@tonic-gate 		len -= sizeof (soun->sun_family);
36097c478bd9Sstevel@tonic-gate 		if (len >= 0) {
36107c478bd9Sstevel@tonic-gate 			/* Null terminate */
36117c478bd9Sstevel@tonic-gate 			soun->sun_path[len] = NULL;
36127c478bd9Sstevel@tonic-gate 			(void) printf("%s\tAF_UNIX  %s = %s\n", pri->pname,
3613019c3c43Sraf 			    str, soun->sun_path);
36147c478bd9Sstevel@tonic-gate 		}
36157c478bd9Sstevel@tonic-gate 		break;
36167c478bd9Sstevel@tonic-gate 	}
36177c478bd9Sstevel@tonic-gate }
36187c478bd9Sstevel@tonic-gate 
36197c478bd9Sstevel@tonic-gate void
36207c478bd9Sstevel@tonic-gate show_msghdr(private_t *pri, long offset)
36217c478bd9Sstevel@tonic-gate {
362281006e0fSja 	const lwpstatus_t *Lsp = pri->lwpstat;
362381006e0fSja 	int what = Lsp->pr_what;
362481006e0fSja 	int err = pri->Errno;
36257c478bd9Sstevel@tonic-gate 	struct msghdr msg;
362681006e0fSja 	int showbuf = FALSE;
362781006e0fSja 	int i = pri->sys_args[0]+1;
362881006e0fSja 	long nb = (what == SYS_recvmsg)? pri->Rval1 : 32*1024;
36297c478bd9Sstevel@tonic-gate 
36307c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &msg, sizeof (msg), offset) != sizeof (msg))
36317c478bd9Sstevel@tonic-gate 		return;
363281006e0fSja 
36337c478bd9Sstevel@tonic-gate 	if (msg.msg_name != NULL && msg.msg_namelen != 0)
36347c478bd9Sstevel@tonic-gate 		show_sockaddr(pri, "msg_name",
3635019c3c43Sraf 		    (long)msg.msg_name, 0, (long)msg.msg_namelen);
363681006e0fSja 
363781006e0fSja 	/*
363881006e0fSja 	 * Print the iovec if the syscall was successful and the fd is
363981006e0fSja 	 * part of the set being traced.
364081006e0fSja 	 */
364181006e0fSja 	if ((what == SYS_recvmsg && !err &&
364281006e0fSja 	    prismember(&readfd, i)) ||
364381006e0fSja 	    (what == SYS_sendmsg &&
364481006e0fSja 	    prismember(&writefd, i)))
364581006e0fSja 		showbuf = TRUE;
364681006e0fSja 
364781006e0fSja 	show_iovec(pri, (long)msg.msg_iov, msg.msg_iovlen, showbuf, nb);
364881006e0fSja 
36497c478bd9Sstevel@tonic-gate }
36507c478bd9Sstevel@tonic-gate 
36517c478bd9Sstevel@tonic-gate #ifdef _LP64
36527c478bd9Sstevel@tonic-gate void
36537c478bd9Sstevel@tonic-gate show_msghdr32(private_t *pri, long offset)
36547c478bd9Sstevel@tonic-gate {
36557c478bd9Sstevel@tonic-gate 	struct msghdr32 {
36567c478bd9Sstevel@tonic-gate 		caddr32_t	msg_name;
365781006e0fSja 		uint32_t	msg_namelen;
365881006e0fSja 		caddr32_t 	msg_iov;
365981006e0fSja 		int32_t		msg_iovlen;
36607c478bd9Sstevel@tonic-gate 	} msg;
366181006e0fSja 	const lwpstatus_t *Lsp = pri->lwpstat;
366281006e0fSja 	int what = Lsp->pr_what;
366381006e0fSja 	int err = pri->Errno;
366481006e0fSja 	int showbuf = FALSE;
366581006e0fSja 	int i = pri->sys_args[0]+1;
366681006e0fSja 	long nb = (what == SYS_recvmsg)? pri->Rval1 : 32*1024;
36677c478bd9Sstevel@tonic-gate 
36687c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &msg, sizeof (msg), offset) != sizeof (msg))
36697c478bd9Sstevel@tonic-gate 		return;
367081006e0fSja 
36717c478bd9Sstevel@tonic-gate 	if (msg.msg_name != NULL && msg.msg_namelen != 0)
36727c478bd9Sstevel@tonic-gate 		show_sockaddr(pri, "msg_name",
3673019c3c43Sraf 		    (long)msg.msg_name, 0, (long)msg.msg_namelen);
367481006e0fSja 	/*
367581006e0fSja 	 * Print the iovec if the syscall was successful and the fd is
367681006e0fSja 	 * part of the set being traced.
367781006e0fSja 	 */
367881006e0fSja 	if ((what == SYS_recvmsg && !err &&
367981006e0fSja 	    prismember(&readfd, i)) ||
368081006e0fSja 	    (what == SYS_sendmsg &&
368181006e0fSja 	    prismember(&writefd, i)))
368281006e0fSja 		showbuf = TRUE;
368381006e0fSja 
368481006e0fSja 	show_iovec32(pri, (long)msg.msg_iov, msg.msg_iovlen, showbuf, nb);
368581006e0fSja 
36867c478bd9Sstevel@tonic-gate }
36877c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
36887c478bd9Sstevel@tonic-gate 
36897c478bd9Sstevel@tonic-gate static void
36907c478bd9Sstevel@tonic-gate show_doorargs(private_t *pri, long offset)
36917c478bd9Sstevel@tonic-gate {
36927c478bd9Sstevel@tonic-gate 	door_arg_t args;
36937c478bd9Sstevel@tonic-gate 
36947c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
36957c478bd9Sstevel@tonic-gate 		(void) printf("%s\tdata_ptr=0x%lX data_size=%lu\n",
36967c478bd9Sstevel@tonic-gate 		    pri->pname,
36977c478bd9Sstevel@tonic-gate 		    (ulong_t)args.data_ptr,
36987c478bd9Sstevel@tonic-gate 		    (ulong_t)args.data_size);
36997c478bd9Sstevel@tonic-gate 		(void) printf("%s\tdesc_ptr=0x%lX desc_num=%u\n",
37007c478bd9Sstevel@tonic-gate 		    pri->pname,
37017c478bd9Sstevel@tonic-gate 		    (ulong_t)args.desc_ptr,
37027c478bd9Sstevel@tonic-gate 		    args.desc_num);
37037c478bd9Sstevel@tonic-gate 		(void) printf("%s\trbuf=0x%lX rsize=%lu\n",
37047c478bd9Sstevel@tonic-gate 		    pri->pname,
37057c478bd9Sstevel@tonic-gate 		    (ulong_t)args.rbuf,
37067c478bd9Sstevel@tonic-gate 		    (ulong_t)args.rsize);
37077c478bd9Sstevel@tonic-gate 	}
37087c478bd9Sstevel@tonic-gate }
37097c478bd9Sstevel@tonic-gate 
37107c478bd9Sstevel@tonic-gate static void
37117c478bd9Sstevel@tonic-gate show_ucred_privsets(private_t *pri, ucred_t *uc)
37127c478bd9Sstevel@tonic-gate {
37137c478bd9Sstevel@tonic-gate 	int i = 0;
37147c478bd9Sstevel@tonic-gate 	const priv_set_t *s;
37157c478bd9Sstevel@tonic-gate 	priv_ptype_t sn;
37167c478bd9Sstevel@tonic-gate 	char *str;
37177c478bd9Sstevel@tonic-gate 
37187c478bd9Sstevel@tonic-gate 	while ((sn = priv_getsetbynum(i++)) != NULL) {
37197c478bd9Sstevel@tonic-gate 		s = ucred_getprivset(uc, sn);
37207c478bd9Sstevel@tonic-gate 
37217c478bd9Sstevel@tonic-gate 		if (s == NULL)
37227c478bd9Sstevel@tonic-gate 			continue;
37237c478bd9Sstevel@tonic-gate 
37247c478bd9Sstevel@tonic-gate 		(void) printf("%s\t%c: %s\n",
37257c478bd9Sstevel@tonic-gate 		    pri->pname,
37267c478bd9Sstevel@tonic-gate 		    *sn,
37277c478bd9Sstevel@tonic-gate 		    str = priv_set_to_str(s, ',', PRIV_STR_SHORT));
37287c478bd9Sstevel@tonic-gate 
37297c478bd9Sstevel@tonic-gate 		free(str);
37307c478bd9Sstevel@tonic-gate 	}
37317c478bd9Sstevel@tonic-gate }
37327c478bd9Sstevel@tonic-gate 
37337c478bd9Sstevel@tonic-gate static void
37347c478bd9Sstevel@tonic-gate show_ucred(private_t *pri, long offset)
37357c478bd9Sstevel@tonic-gate {
37367c478bd9Sstevel@tonic-gate 	ucred_t *uc = _ucred_alloc();
37377c478bd9Sstevel@tonic-gate 	size_t sz;
37387c478bd9Sstevel@tonic-gate 
37397c478bd9Sstevel@tonic-gate 	if (uc == NULL)
37407c478bd9Sstevel@tonic-gate 		return;
37417c478bd9Sstevel@tonic-gate 
37427c478bd9Sstevel@tonic-gate 	sz = Pread(Proc, uc, uc->uc_size, offset);
37437c478bd9Sstevel@tonic-gate 
37447c478bd9Sstevel@tonic-gate 	/*
37457c478bd9Sstevel@tonic-gate 	 * A new uc_size is read, it could be smaller than the previously
37467c478bd9Sstevel@tonic-gate 	 * value.  We accept short reads that fill the whole header.
37477c478bd9Sstevel@tonic-gate 	 */
37487c478bd9Sstevel@tonic-gate 	if (sz >= sizeof (ucred_t) && sz >= uc->uc_size) {
3749f48205beScasper 		(void) printf("%s\teuid=%u egid=%u\n",
37507c478bd9Sstevel@tonic-gate 		    pri->pname,
3751f48205beScasper 		    ucred_geteuid(uc),
3752f48205beScasper 		    ucred_getegid(uc));
3753f48205beScasper 		(void) printf("%s\truid=%u rgid=%u\n",
37547c478bd9Sstevel@tonic-gate 		    pri->pname,
3755f48205beScasper 		    ucred_getruid(uc),
3756f48205beScasper 		    ucred_getrgid(uc));
37577c478bd9Sstevel@tonic-gate 		(void) printf("%s\tpid=%d zoneid=%d\n",
37587c478bd9Sstevel@tonic-gate 		    pri->pname,
37597c478bd9Sstevel@tonic-gate 		    (int)ucred_getpid(uc),
37607c478bd9Sstevel@tonic-gate 		    (int)ucred_getzoneid(uc));
37617c478bd9Sstevel@tonic-gate 		show_ucred_privsets(pri, uc);
37627c478bd9Sstevel@tonic-gate 	}
37637c478bd9Sstevel@tonic-gate 	ucred_free(uc);
37647c478bd9Sstevel@tonic-gate }
37657c478bd9Sstevel@tonic-gate 
37667c478bd9Sstevel@tonic-gate static void
3767821c4a97Sdp show_privset(private_t *pri, long offset, size_t size, char *label)
37687c478bd9Sstevel@tonic-gate {
37697c478bd9Sstevel@tonic-gate 	priv_set_t *tmp = priv_allocset();
37707c478bd9Sstevel@tonic-gate 	size_t sz;
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate 	if (tmp == NULL)
37737c478bd9Sstevel@tonic-gate 		return;
37747c478bd9Sstevel@tonic-gate 
37757c478bd9Sstevel@tonic-gate 	sz = Pread(Proc, tmp, size, offset);
37767c478bd9Sstevel@tonic-gate 
37777c478bd9Sstevel@tonic-gate 	if (sz == size) {
37787c478bd9Sstevel@tonic-gate 		char *str = priv_set_to_str(tmp, ',', PRIV_STR_SHORT);
37797c478bd9Sstevel@tonic-gate 		if (str != NULL) {
3780821c4a97Sdp 			(void) printf("%s\t%s%s\n", pri->pname, label, str);
37817c478bd9Sstevel@tonic-gate 			free(str);
37827c478bd9Sstevel@tonic-gate 		}
37837c478bd9Sstevel@tonic-gate 	}
37847c478bd9Sstevel@tonic-gate 	priv_freeset(tmp);
37857c478bd9Sstevel@tonic-gate }
37867c478bd9Sstevel@tonic-gate 
37877c478bd9Sstevel@tonic-gate static void
37887c478bd9Sstevel@tonic-gate show_doorinfo(private_t *pri, long offset)
37897c478bd9Sstevel@tonic-gate {
37907c478bd9Sstevel@tonic-gate 	door_info_t info;
37917c478bd9Sstevel@tonic-gate 	door_attr_t attr;
37927c478bd9Sstevel@tonic-gate 
37937c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &info, sizeof (info), offset) != sizeof (info))
37947c478bd9Sstevel@tonic-gate 		return;
37957c478bd9Sstevel@tonic-gate 	(void) printf("%s\ttarget=%d proc=0x%llX data=0x%llX\n",
37967c478bd9Sstevel@tonic-gate 	    pri->pname,
37977c478bd9Sstevel@tonic-gate 	    (int)info.di_target,
37987c478bd9Sstevel@tonic-gate 	    info.di_proc,
37997c478bd9Sstevel@tonic-gate 	    info.di_data);
38007c478bd9Sstevel@tonic-gate 	attr = info.di_attributes;
38017c478bd9Sstevel@tonic-gate 	(void) printf("%s\tattributes=%s\n", pri->pname, door_flags(pri, attr));
38027c478bd9Sstevel@tonic-gate 	(void) printf("%s\tuniquifier=%llu\n", pri->pname, info.di_uniquifier);
38037c478bd9Sstevel@tonic-gate }
38047c478bd9Sstevel@tonic-gate 
38057c478bd9Sstevel@tonic-gate static void
38067c478bd9Sstevel@tonic-gate show_doorparam(private_t *pri, long offset)
38077c478bd9Sstevel@tonic-gate {
38087c478bd9Sstevel@tonic-gate 	ulong_t val;
38097c478bd9Sstevel@tonic-gate 
38107c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) {
38117c478bd9Sstevel@tonic-gate 		(void) printf("%s\tvalue=%lu\n",
38127c478bd9Sstevel@tonic-gate 		    pri->pname,
38137c478bd9Sstevel@tonic-gate 		    val);
38147c478bd9Sstevel@tonic-gate 	}
38157c478bd9Sstevel@tonic-gate }
38167c478bd9Sstevel@tonic-gate 
38177c478bd9Sstevel@tonic-gate #ifdef _LP64
38187c478bd9Sstevel@tonic-gate 
38197c478bd9Sstevel@tonic-gate static void
38207c478bd9Sstevel@tonic-gate show_doorargs32(private_t *pri, long offset)
38217c478bd9Sstevel@tonic-gate {
38227c478bd9Sstevel@tonic-gate 	struct door_arg32 args;
38237c478bd9Sstevel@tonic-gate 
38247c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
38257c478bd9Sstevel@tonic-gate 		(void) printf("%s\tdata_ptr=%X data_size=%u\n",
38267c478bd9Sstevel@tonic-gate 		    pri->pname,
38277c478bd9Sstevel@tonic-gate 		    args.data_ptr,
38287c478bd9Sstevel@tonic-gate 		    args.data_size);
38297c478bd9Sstevel@tonic-gate 		(void) printf("%s\tdesc_ptr=0x%X desc_num=%u\n",
38307c478bd9Sstevel@tonic-gate 		    pri->pname,
38317c478bd9Sstevel@tonic-gate 		    args.desc_ptr,
38327c478bd9Sstevel@tonic-gate 		    args.desc_num);
38337c478bd9Sstevel@tonic-gate 		(void) printf("%s\trbuf=0x%X rsize=%u\n",
38347c478bd9Sstevel@tonic-gate 		    pri->pname,
38357c478bd9Sstevel@tonic-gate 		    args.rbuf,
38367c478bd9Sstevel@tonic-gate 		    args.rsize);
38377c478bd9Sstevel@tonic-gate 	}
38387c478bd9Sstevel@tonic-gate }
38397c478bd9Sstevel@tonic-gate 
38407c478bd9Sstevel@tonic-gate static void
38417c478bd9Sstevel@tonic-gate show_doorparam32(private_t *pri, long offset)
38427c478bd9Sstevel@tonic-gate {
38437c478bd9Sstevel@tonic-gate 	uint_t val;
38447c478bd9Sstevel@tonic-gate 
38457c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) {
38467c478bd9Sstevel@tonic-gate 		(void) printf("%s\tvalue=%u\n",
38477c478bd9Sstevel@tonic-gate 		    pri->pname,
38487c478bd9Sstevel@tonic-gate 		    val);
38497c478bd9Sstevel@tonic-gate 	}
38507c478bd9Sstevel@tonic-gate }
38517c478bd9Sstevel@tonic-gate 
38527c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
38537c478bd9Sstevel@tonic-gate 
38547c478bd9Sstevel@tonic-gate static void
38557c478bd9Sstevel@tonic-gate show_doors(private_t *pri)
38567c478bd9Sstevel@tonic-gate {
38577c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[5]) {
38587c478bd9Sstevel@tonic-gate 	case DOOR_CALL:
38597c478bd9Sstevel@tonic-gate #ifdef _LP64
38607c478bd9Sstevel@tonic-gate 		if (data_model == PR_MODEL_LP64)
38617c478bd9Sstevel@tonic-gate 			show_doorargs(pri, (long)pri->sys_args[1]);
38627c478bd9Sstevel@tonic-gate 		else
38637c478bd9Sstevel@tonic-gate 			show_doorargs32(pri, (long)pri->sys_args[1]);
38647c478bd9Sstevel@tonic-gate #else
38657c478bd9Sstevel@tonic-gate 		show_doorargs(pri, (long)pri->sys_args[1]);
38667c478bd9Sstevel@tonic-gate #endif
38677c478bd9Sstevel@tonic-gate 		break;
38687c478bd9Sstevel@tonic-gate 	case DOOR_UCRED:
38697c478bd9Sstevel@tonic-gate 		if (!pri->Errno)
38707c478bd9Sstevel@tonic-gate 			show_ucred(pri, (long)pri->sys_args[0]);
38717c478bd9Sstevel@tonic-gate 		break;
38727c478bd9Sstevel@tonic-gate 	case DOOR_INFO:
38737c478bd9Sstevel@tonic-gate 		if (!pri->Errno)
38747c478bd9Sstevel@tonic-gate 			show_doorinfo(pri, (long)pri->sys_args[1]);
38757c478bd9Sstevel@tonic-gate 		break;
38767c478bd9Sstevel@tonic-gate 	case DOOR_GETPARAM:
38777c478bd9Sstevel@tonic-gate 		if (!pri->Errno) {
38787c478bd9Sstevel@tonic-gate #ifdef _LP64
38797c478bd9Sstevel@tonic-gate 			if (data_model == PR_MODEL_LP64)
38807c478bd9Sstevel@tonic-gate 				show_doorparam(pri, (long)pri->sys_args[2]);
38817c478bd9Sstevel@tonic-gate 			else
38827c478bd9Sstevel@tonic-gate 				show_doorparam32(pri, (long)pri->sys_args[2]);
38837c478bd9Sstevel@tonic-gate #else
38847c478bd9Sstevel@tonic-gate 			show_doorparam(pri, (long)pri->sys_args[2]);
38857c478bd9Sstevel@tonic-gate #endif
38867c478bd9Sstevel@tonic-gate 		}
38877c478bd9Sstevel@tonic-gate 		break;
38887c478bd9Sstevel@tonic-gate 	}
38897c478bd9Sstevel@tonic-gate }
38907c478bd9Sstevel@tonic-gate 
38917c478bd9Sstevel@tonic-gate static void
38927c478bd9Sstevel@tonic-gate show_portargs(private_t *pri, long offset)
38937c478bd9Sstevel@tonic-gate {
38947c478bd9Sstevel@tonic-gate 	port_event_t args;
38957c478bd9Sstevel@tonic-gate 
38967c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
38977c478bd9Sstevel@tonic-gate 		(void) printf("%s\tevents=0x%x source=%u\n",
38987c478bd9Sstevel@tonic-gate 		    pri->pname,
38997c478bd9Sstevel@tonic-gate 		    args.portev_events,
39007c478bd9Sstevel@tonic-gate 		    args.portev_source);
39017c478bd9Sstevel@tonic-gate 		(void) printf("%s\tobject=0x%p user=0x%p\n",
39027c478bd9Sstevel@tonic-gate 		    pri->pname,
39037c478bd9Sstevel@tonic-gate 		    (void *)args.portev_object,
39047c478bd9Sstevel@tonic-gate 		    (void *)args.portev_user);
39057c478bd9Sstevel@tonic-gate 	}
39067c478bd9Sstevel@tonic-gate }
39077c478bd9Sstevel@tonic-gate 
39087c478bd9Sstevel@tonic-gate 
39097c478bd9Sstevel@tonic-gate #ifdef _LP64
39107c478bd9Sstevel@tonic-gate 
39117c478bd9Sstevel@tonic-gate static void
39127c478bd9Sstevel@tonic-gate show_portargs32(private_t *pri, long offset)
39137c478bd9Sstevel@tonic-gate {
39147c478bd9Sstevel@tonic-gate 	port_event32_t args;
39157c478bd9Sstevel@tonic-gate 
39167c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
39177c478bd9Sstevel@tonic-gate 		(void) printf("%s\tevents=0x%x source=%u\n",
39187c478bd9Sstevel@tonic-gate 		    pri->pname,
39197c478bd9Sstevel@tonic-gate 		    args.portev_events,
39207c478bd9Sstevel@tonic-gate 		    args.portev_source);
39217c478bd9Sstevel@tonic-gate 		(void) printf("%s\tobject=0x%x user=0x%x\n",
39227c478bd9Sstevel@tonic-gate 		    pri->pname,
39237c478bd9Sstevel@tonic-gate 		    args.portev_object,
39247c478bd9Sstevel@tonic-gate 		    args.portev_user);
39257c478bd9Sstevel@tonic-gate 	}
39267c478bd9Sstevel@tonic-gate }
39277c478bd9Sstevel@tonic-gate 
39287c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
39297c478bd9Sstevel@tonic-gate 
39307c478bd9Sstevel@tonic-gate static void
39317c478bd9Sstevel@tonic-gate show_ports(private_t *pri)
39327c478bd9Sstevel@tonic-gate {
39337c478bd9Sstevel@tonic-gate 	switch (pri->sys_args[0]) {
39347c478bd9Sstevel@tonic-gate 	case PORT_GET:
39357c478bd9Sstevel@tonic-gate #ifdef _LP64
39367c478bd9Sstevel@tonic-gate 		if (data_model == PR_MODEL_LP64)
39377c478bd9Sstevel@tonic-gate 			show_portargs(pri, (long)pri->sys_args[2]);
39387c478bd9Sstevel@tonic-gate 		else
39397c478bd9Sstevel@tonic-gate 			show_portargs32(pri, (long)pri->sys_args[2]);
39407c478bd9Sstevel@tonic-gate #else
39417c478bd9Sstevel@tonic-gate 		show_portargs(pri, (long)pri->sys_args[2]);
39427c478bd9Sstevel@tonic-gate #endif
39437c478bd9Sstevel@tonic-gate 		break;
39447c478bd9Sstevel@tonic-gate 	}
39457c478bd9Sstevel@tonic-gate }
39467c478bd9Sstevel@tonic-gate 
39477c478bd9Sstevel@tonic-gate #define	MAX_SNDFL_PRD 16
39487c478bd9Sstevel@tonic-gate 
39497c478bd9Sstevel@tonic-gate #ifdef _LP64
39507c478bd9Sstevel@tonic-gate 
39517c478bd9Sstevel@tonic-gate static void
39527c478bd9Sstevel@tonic-gate show_ksendfilevec32(private_t *pri, int fd,
39537c478bd9Sstevel@tonic-gate     ksendfilevec32_t *sndvec, int sfvcnt)
39547c478bd9Sstevel@tonic-gate {
39557c478bd9Sstevel@tonic-gate 	ksendfilevec32_t *snd_ptr, snd[MAX_SNDFL_PRD];
39567c478bd9Sstevel@tonic-gate 	size_t cpy_rqst;
39577c478bd9Sstevel@tonic-gate 
39587c478bd9Sstevel@tonic-gate 	Eserialize();
39597c478bd9Sstevel@tonic-gate 	while (sfvcnt > 0) {
39607c478bd9Sstevel@tonic-gate 		cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
39617c478bd9Sstevel@tonic-gate 		sfvcnt -= cpy_rqst;
39627c478bd9Sstevel@tonic-gate 		cpy_rqst *= sizeof (snd[0]);
39637c478bd9Sstevel@tonic-gate 
39647c478bd9Sstevel@tonic-gate 		if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
39657c478bd9Sstevel@tonic-gate 			break;
39667c478bd9Sstevel@tonic-gate 
39677c478bd9Sstevel@tonic-gate 		snd_ptr = &snd[0];
39687c478bd9Sstevel@tonic-gate 
39697c478bd9Sstevel@tonic-gate 		while (cpy_rqst) {
39707c478bd9Sstevel@tonic-gate 			(void) printf(
39717c478bd9Sstevel@tonic-gate 			    "sfv_fd=%d\tsfv_flag=0x%x\t"
39727c478bd9Sstevel@tonic-gate 			    "sfv_off=%d\tsfv_len=%u\n",
39737c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_fd,
39747c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_flag,
39757c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_off,
39767c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_len);
39777c478bd9Sstevel@tonic-gate 
39787c478bd9Sstevel@tonic-gate 			if (snd_ptr->sfv_fd == SFV_FD_SELF &&
39797c478bd9Sstevel@tonic-gate 			    prismember(&writefd, fd)) {
39807c478bd9Sstevel@tonic-gate 				showbuffer(pri,
39817c478bd9Sstevel@tonic-gate 				    (long)snd_ptr->sfv_off & 0xffffffff,
39827c478bd9Sstevel@tonic-gate 				    (long)snd_ptr->sfv_len);
39837c478bd9Sstevel@tonic-gate 			}
39847c478bd9Sstevel@tonic-gate 
39857c478bd9Sstevel@tonic-gate 			cpy_rqst -= sizeof (snd[0]);
39867c478bd9Sstevel@tonic-gate 			snd_ptr++;
39877c478bd9Sstevel@tonic-gate 		}
39887c478bd9Sstevel@tonic-gate 
39897c478bd9Sstevel@tonic-gate 		sndvec += MAX_SNDFL_PRD;
39907c478bd9Sstevel@tonic-gate 	}
39917c478bd9Sstevel@tonic-gate 	Xserialize();
39927c478bd9Sstevel@tonic-gate }
39937c478bd9Sstevel@tonic-gate 
39947c478bd9Sstevel@tonic-gate static void
39957c478bd9Sstevel@tonic-gate show_ksendfilevec64(private_t *pri, int fd,
39967c478bd9Sstevel@tonic-gate     ksendfilevec64_t *sndvec, int sfvcnt)
39977c478bd9Sstevel@tonic-gate {
39987c478bd9Sstevel@tonic-gate 	ksendfilevec64_t *snd_ptr, snd[MAX_SNDFL_PRD];
39997c478bd9Sstevel@tonic-gate 	size_t cpy_rqst;
40007c478bd9Sstevel@tonic-gate 
40017c478bd9Sstevel@tonic-gate 	Eserialize();
40027c478bd9Sstevel@tonic-gate 	while (sfvcnt > 0) {
40037c478bd9Sstevel@tonic-gate 		cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
40047c478bd9Sstevel@tonic-gate 		sfvcnt -= cpy_rqst;
40057c478bd9Sstevel@tonic-gate 		cpy_rqst *= sizeof (snd[0]);
40067c478bd9Sstevel@tonic-gate 
40077c478bd9Sstevel@tonic-gate 		if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
40087c478bd9Sstevel@tonic-gate 			break;
40097c478bd9Sstevel@tonic-gate 
40107c478bd9Sstevel@tonic-gate 		snd_ptr = &snd[0];
40117c478bd9Sstevel@tonic-gate 
40127c478bd9Sstevel@tonic-gate 		while (cpy_rqst) {
40137c478bd9Sstevel@tonic-gate 			(void) printf(
40147c478bd9Sstevel@tonic-gate 			    "sfv_fd=%d\tsfv_flag=0x%x\t"
40157c478bd9Sstevel@tonic-gate 			    "sfv_off=%ld\tsfv_len=%u\n",
40167c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_fd,
40177c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_flag,
40187c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_off,
40197c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_len);
40207c478bd9Sstevel@tonic-gate 
40217c478bd9Sstevel@tonic-gate 			if (snd_ptr->sfv_fd == SFV_FD_SELF &&
40227c478bd9Sstevel@tonic-gate 			    prismember(&writefd, fd)) {
40237c478bd9Sstevel@tonic-gate 				showbuffer(pri,
40247c478bd9Sstevel@tonic-gate 				    (long)snd_ptr->sfv_off & 0xffffffff,
40257c478bd9Sstevel@tonic-gate 				    (long)snd_ptr->sfv_len);
40267c478bd9Sstevel@tonic-gate 			}
40277c478bd9Sstevel@tonic-gate 
40287c478bd9Sstevel@tonic-gate 			cpy_rqst -= sizeof (snd[0]);
40297c478bd9Sstevel@tonic-gate 			snd_ptr++;
40307c478bd9Sstevel@tonic-gate 		}
40317c478bd9Sstevel@tonic-gate 
40327c478bd9Sstevel@tonic-gate 		sndvec += MAX_SNDFL_PRD;
40337c478bd9Sstevel@tonic-gate 	}
40347c478bd9Sstevel@tonic-gate 	Xserialize();
40357c478bd9Sstevel@tonic-gate }
40367c478bd9Sstevel@tonic-gate 
40377c478bd9Sstevel@tonic-gate #endif /* _LP64 */
40387c478bd9Sstevel@tonic-gate 
40397c478bd9Sstevel@tonic-gate /*ARGSUSED*/
40407c478bd9Sstevel@tonic-gate static void
40417c478bd9Sstevel@tonic-gate show_sendfilevec(private_t *pri, int fd, sendfilevec_t *sndvec, int sfvcnt)
40427c478bd9Sstevel@tonic-gate {
40437c478bd9Sstevel@tonic-gate 	sendfilevec_t *snd_ptr, snd[MAX_SNDFL_PRD];
40447c478bd9Sstevel@tonic-gate 	size_t cpy_rqst;
40457c478bd9Sstevel@tonic-gate 
40467c478bd9Sstevel@tonic-gate #ifdef _LP64
40477c478bd9Sstevel@tonic-gate 	if (data_model != PR_MODEL_LP64) {
40487c478bd9Sstevel@tonic-gate 		show_ksendfilevec32(pri, fd,
40497c478bd9Sstevel@tonic-gate 		    (ksendfilevec32_t *)sndvec, sfvcnt);
40507c478bd9Sstevel@tonic-gate 		return;
40517c478bd9Sstevel@tonic-gate 	}
40527c478bd9Sstevel@tonic-gate #endif
40537c478bd9Sstevel@tonic-gate 	Eserialize();
40547c478bd9Sstevel@tonic-gate 	while (sfvcnt > 0) {
40557c478bd9Sstevel@tonic-gate 		cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
40567c478bd9Sstevel@tonic-gate 		sfvcnt -= cpy_rqst;
40577c478bd9Sstevel@tonic-gate 		cpy_rqst *= sizeof (snd[0]);
40587c478bd9Sstevel@tonic-gate 
40597c478bd9Sstevel@tonic-gate 		if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
40607c478bd9Sstevel@tonic-gate 			break;
40617c478bd9Sstevel@tonic-gate 
40627c478bd9Sstevel@tonic-gate 		snd_ptr = &snd[0];
40637c478bd9Sstevel@tonic-gate 
40647c478bd9Sstevel@tonic-gate 		while (cpy_rqst) {
40657c478bd9Sstevel@tonic-gate 			(void) printf(
40667c478bd9Sstevel@tonic-gate 			    "sfv_fd=%d\tsfv_flag=0x%x\t"
40677c478bd9Sstevel@tonic-gate 			    "sfv_off=%ld\tsfv_len=%lu\n",
40687c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_fd,
40697c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_flag,
40707c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_off,
40717c478bd9Sstevel@tonic-gate 			    (ulong_t)snd_ptr->sfv_len);
40727c478bd9Sstevel@tonic-gate 
40737c478bd9Sstevel@tonic-gate 			if (snd_ptr->sfv_fd == SFV_FD_SELF &&
40747c478bd9Sstevel@tonic-gate 			    prismember(&writefd, fd)) {
40757c478bd9Sstevel@tonic-gate 				showbuffer(pri, (long)snd_ptr->sfv_off,
4076019c3c43Sraf 				    (long)snd_ptr->sfv_len);
40777c478bd9Sstevel@tonic-gate 			}
40787c478bd9Sstevel@tonic-gate 
40797c478bd9Sstevel@tonic-gate 			cpy_rqst -= sizeof (snd[0]);
40807c478bd9Sstevel@tonic-gate 			snd_ptr++;
40817c478bd9Sstevel@tonic-gate 		}
40827c478bd9Sstevel@tonic-gate 
40837c478bd9Sstevel@tonic-gate 		sndvec += MAX_SNDFL_PRD;
40847c478bd9Sstevel@tonic-gate 	}
40857c478bd9Sstevel@tonic-gate 	Xserialize();
40867c478bd9Sstevel@tonic-gate }
40877c478bd9Sstevel@tonic-gate 
40887c478bd9Sstevel@tonic-gate /*ARGSUSED*/
40897c478bd9Sstevel@tonic-gate static void
40907c478bd9Sstevel@tonic-gate show_sendfilevec64(private_t *pri, int fd, sendfilevec64_t *sndvec, int sfvcnt)
40917c478bd9Sstevel@tonic-gate {
40927c478bd9Sstevel@tonic-gate 	sendfilevec64_t *snd_ptr, snd[MAX_SNDFL_PRD];
40937c478bd9Sstevel@tonic-gate 	size_t cpy_rqst;
40947c478bd9Sstevel@tonic-gate 
40957c478bd9Sstevel@tonic-gate #ifdef _LP64
40967c478bd9Sstevel@tonic-gate 	if (data_model != PR_MODEL_LP64) {
40977c478bd9Sstevel@tonic-gate 		show_ksendfilevec64(pri, fd,
40987c478bd9Sstevel@tonic-gate 		    (ksendfilevec64_t *)sndvec, sfvcnt);
40997c478bd9Sstevel@tonic-gate 		return;
41007c478bd9Sstevel@tonic-gate 	}
41017c478bd9Sstevel@tonic-gate #endif
41027c478bd9Sstevel@tonic-gate 
41037c478bd9Sstevel@tonic-gate 	Eserialize();
41047c478bd9Sstevel@tonic-gate 	while (sfvcnt > 0) {
41057c478bd9Sstevel@tonic-gate 		cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
41067c478bd9Sstevel@tonic-gate 		sfvcnt -= cpy_rqst;
41077c478bd9Sstevel@tonic-gate 		cpy_rqst *= sizeof (snd[0]);
41087c478bd9Sstevel@tonic-gate 
41097c478bd9Sstevel@tonic-gate 		if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
41107c478bd9Sstevel@tonic-gate 			break;
41117c478bd9Sstevel@tonic-gate 
41127c478bd9Sstevel@tonic-gate 		snd_ptr = &snd[0];
41137c478bd9Sstevel@tonic-gate 
41147c478bd9Sstevel@tonic-gate 		while (cpy_rqst) {
41157c478bd9Sstevel@tonic-gate 			(void) printf(
41167c478bd9Sstevel@tonic-gate #ifdef _LP64
41177c478bd9Sstevel@tonic-gate 			    "sfv_fd=%d\tsfv_flag=0x%x\t"
41187c478bd9Sstevel@tonic-gate 			    "sfv_off=%ld\tsfv_len=%lu\n",
41197c478bd9Sstevel@tonic-gate #else
41207c478bd9Sstevel@tonic-gate 			    "sfv_fd=%d\tsfv_flag=0x%x\t"
41217c478bd9Sstevel@tonic-gate 			    "sfv_off=%lld\tsfv_len=%lu\n",
41227c478bd9Sstevel@tonic-gate #endif
41237c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_fd,
41247c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_flag,
41257c478bd9Sstevel@tonic-gate 			    snd_ptr->sfv_off,
41267c478bd9Sstevel@tonic-gate 			    (ulong_t)snd_ptr->sfv_len);
41277c478bd9Sstevel@tonic-gate 
41287c478bd9Sstevel@tonic-gate 			if (snd_ptr->sfv_fd == SFV_FD_SELF &&
41297c478bd9Sstevel@tonic-gate 			    prismember(&writefd, fd)) {
41307c478bd9Sstevel@tonic-gate 				showbuffer(pri, (long)snd_ptr->sfv_off,
4131019c3c43Sraf 				    (long)snd_ptr->sfv_len);
41327c478bd9Sstevel@tonic-gate 			}
41337c478bd9Sstevel@tonic-gate 
41347c478bd9Sstevel@tonic-gate 			cpy_rqst -= sizeof (snd[0]);
41357c478bd9Sstevel@tonic-gate 			snd_ptr++;
41367c478bd9Sstevel@tonic-gate 		}
41377c478bd9Sstevel@tonic-gate 
41387c478bd9Sstevel@tonic-gate 		sndvec += MAX_SNDFL_PRD;
41397c478bd9Sstevel@tonic-gate 	}
41407c478bd9Sstevel@tonic-gate 	Xserialize();
41417c478bd9Sstevel@tonic-gate }
41427c478bd9Sstevel@tonic-gate 
41437c478bd9Sstevel@tonic-gate static void
41447c478bd9Sstevel@tonic-gate show_memcntl_mha(private_t *pri, long offset)
41457c478bd9Sstevel@tonic-gate {
41467c478bd9Sstevel@tonic-gate 	struct memcntl_mha mha;
41477c478bd9Sstevel@tonic-gate 	const char *s = NULL;
41487c478bd9Sstevel@tonic-gate 
41497c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &mha, sizeof (mha), offset) == sizeof (mha)) {
41507c478bd9Sstevel@tonic-gate 		switch (mha.mha_cmd) {
41517c478bd9Sstevel@tonic-gate 		case MHA_MAPSIZE_VA:	    s = "MHA_MAPSIZE_VA";	break;
41527c478bd9Sstevel@tonic-gate 		case MHA_MAPSIZE_BSSBRK:    s = "MHA_MAPSIZE_BSSBRK";	break;
41537c478bd9Sstevel@tonic-gate 		case MHA_MAPSIZE_STACK:	    s = "MHA_MAPSIZE_STACK";	break;
41547c478bd9Sstevel@tonic-gate 		}
41557c478bd9Sstevel@tonic-gate 		if (s)
41567c478bd9Sstevel@tonic-gate 			(void) printf("%s\tmha_cmd=%s mha_flags=0x%x"
41577c478bd9Sstevel@tonic-gate 			    " mha_pagesize=%lu\n",
41587c478bd9Sstevel@tonic-gate 			    pri->pname, s, mha.mha_flags,
41597c478bd9Sstevel@tonic-gate 			    (ulong_t)mha.mha_pagesize);
41607c478bd9Sstevel@tonic-gate 		else
41617c478bd9Sstevel@tonic-gate 			(void) printf("%s\tmha_cmd=0x%.8x mha_flags=0x%x"
41627c478bd9Sstevel@tonic-gate 			    " mha_pagesize=%lu\n",
41637c478bd9Sstevel@tonic-gate 			    pri->pname, mha.mha_cmd, mha.mha_flags,
41647c478bd9Sstevel@tonic-gate 			    (ulong_t)mha.mha_pagesize);
41657c478bd9Sstevel@tonic-gate 	}
41667c478bd9Sstevel@tonic-gate }
41677c478bd9Sstevel@tonic-gate 
41687c478bd9Sstevel@tonic-gate #ifdef _LP64
41697c478bd9Sstevel@tonic-gate 
41707c478bd9Sstevel@tonic-gate static void
41717c478bd9Sstevel@tonic-gate show_memcntl_mha32(private_t *pri, long offset)
41727c478bd9Sstevel@tonic-gate {
41737c478bd9Sstevel@tonic-gate 	struct memcntl_mha32 mha32;
41747c478bd9Sstevel@tonic-gate 	const char *s = NULL;
41757c478bd9Sstevel@tonic-gate 
41767c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &mha32, sizeof (mha32), offset) ==
41777c478bd9Sstevel@tonic-gate 	    sizeof (mha32)) {
41787c478bd9Sstevel@tonic-gate 		switch (mha32.mha_cmd) {
41797c478bd9Sstevel@tonic-gate 		case MHA_MAPSIZE_VA:	    s = "MHA_MAPSIZE_VA";	break;
41807c478bd9Sstevel@tonic-gate 		case MHA_MAPSIZE_BSSBRK:    s = "MHA_MAPSIZE_BSSBRK";	break;
41817c478bd9Sstevel@tonic-gate 		case MHA_MAPSIZE_STACK:	    s = "MHA_MAPSIZE_STACK";	break;
41827c478bd9Sstevel@tonic-gate 		}
41837c478bd9Sstevel@tonic-gate 		if (s)
41847c478bd9Sstevel@tonic-gate 			(void) printf("%s\tmha_cmd=%s mha_flags=0x%x"
41857c478bd9Sstevel@tonic-gate 			    " mha_pagesize=%u\n",
41867c478bd9Sstevel@tonic-gate 			    pri->pname, s, mha32.mha_flags, mha32.mha_pagesize);
41877c478bd9Sstevel@tonic-gate 		else
41887c478bd9Sstevel@tonic-gate 			(void) printf("%s\tmha_cmd=0x%.8x mha_flags=0x%x"
41897c478bd9Sstevel@tonic-gate 			    " mha_pagesize=%u\n",
41907c478bd9Sstevel@tonic-gate 			    pri->pname, mha32.mha_cmd, mha32.mha_flags,
41917c478bd9Sstevel@tonic-gate 			    mha32.mha_pagesize);
41927c478bd9Sstevel@tonic-gate 	}
41937c478bd9Sstevel@tonic-gate }
41947c478bd9Sstevel@tonic-gate 
41957c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
41967c478bd9Sstevel@tonic-gate 
41977c478bd9Sstevel@tonic-gate static void
41987c478bd9Sstevel@tonic-gate show_memcntl(private_t *pri)
41997c478bd9Sstevel@tonic-gate {
42007c478bd9Sstevel@tonic-gate 
42017c478bd9Sstevel@tonic-gate 	if ((int)pri->sys_args[2] != MC_HAT_ADVISE)
42027c478bd9Sstevel@tonic-gate 		return;
42037c478bd9Sstevel@tonic-gate #ifdef _LP64
42047c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_LP64)
42057c478bd9Sstevel@tonic-gate 		show_memcntl_mha(pri, (long)pri->sys_args[3]);
42067c478bd9Sstevel@tonic-gate 	else
42077c478bd9Sstevel@tonic-gate 		show_memcntl_mha32(pri, (long)pri->sys_args[3]);
42087c478bd9Sstevel@tonic-gate #else
42097c478bd9Sstevel@tonic-gate 	show_memcntl_mha(pri, (long)pri->sys_args[3]);
42107c478bd9Sstevel@tonic-gate #endif
42117c478bd9Sstevel@tonic-gate }
42127c478bd9Sstevel@tonic-gate 
42137c478bd9Sstevel@tonic-gate void
42147c478bd9Sstevel@tonic-gate show_ids(private_t *pri, long offset, int count)
42157c478bd9Sstevel@tonic-gate {
42167c478bd9Sstevel@tonic-gate 	id_t buf[MYBUFSIZ / sizeof (id_t)];
42177c478bd9Sstevel@tonic-gate 	id_t *idp;
42187c478bd9Sstevel@tonic-gate 	int serial = (count > MYBUFSIZ / 48);
42197c478bd9Sstevel@tonic-gate 
42203b862e9aSRoger A. Faulkner 	if (offset == 0)
42217c478bd9Sstevel@tonic-gate 		return;
42227c478bd9Sstevel@tonic-gate 
42237c478bd9Sstevel@tonic-gate 	/* enter region of lengthy output */
42247c478bd9Sstevel@tonic-gate 	if (serial)
42257c478bd9Sstevel@tonic-gate 		Eserialize();
42267c478bd9Sstevel@tonic-gate 
42277c478bd9Sstevel@tonic-gate 	while (count > 0 && !interrupt) {
42287c478bd9Sstevel@tonic-gate 		ssize_t nb = (count * sizeof (id_t) < MYBUFSIZ)?
4229019c3c43Sraf 		    count * sizeof (id_t) : MYBUFSIZ;
42307c478bd9Sstevel@tonic-gate 
42317c478bd9Sstevel@tonic-gate 		if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) < 0 ||
42327c478bd9Sstevel@tonic-gate 		    nb < sizeof (id_t))
42337c478bd9Sstevel@tonic-gate 			break;
42347c478bd9Sstevel@tonic-gate 
42357c478bd9Sstevel@tonic-gate 		idp = buf;
42367c478bd9Sstevel@tonic-gate 		while (!interrupt && nb >= sizeof (id_t)) {
42377c478bd9Sstevel@tonic-gate 			(void) printf("%s\t%8d\n", pri->pname, (int)*idp);
42387c478bd9Sstevel@tonic-gate 			offset += sizeof (id_t);
42397c478bd9Sstevel@tonic-gate 			nb -= sizeof (id_t);
42407c478bd9Sstevel@tonic-gate 			idp++;
42417c478bd9Sstevel@tonic-gate 			count--;
42427c478bd9Sstevel@tonic-gate 		}
42437c478bd9Sstevel@tonic-gate 	}
42447c478bd9Sstevel@tonic-gate 
42457c478bd9Sstevel@tonic-gate 	/* exit region of lengthy output */
42467c478bd9Sstevel@tonic-gate 	if (serial)
42477c478bd9Sstevel@tonic-gate 		Xserialize();
42487c478bd9Sstevel@tonic-gate }
42497c478bd9Sstevel@tonic-gate 
42507c478bd9Sstevel@tonic-gate void
42517c478bd9Sstevel@tonic-gate show_ntp_gettime(private_t *pri)
42527c478bd9Sstevel@tonic-gate {
42537c478bd9Sstevel@tonic-gate 	struct ntptimeval ntv;
42547c478bd9Sstevel@tonic-gate 	long offset;
42557c478bd9Sstevel@tonic-gate 
42567c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
42577c478bd9Sstevel@tonic-gate 		return;
42587c478bd9Sstevel@tonic-gate 
42597c478bd9Sstevel@tonic-gate 	if (data_model == PR_MODEL_NATIVE) {
42607c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &ntv, sizeof (ntv), offset)
42617c478bd9Sstevel@tonic-gate 		    != sizeof (ntv))
42627c478bd9Sstevel@tonic-gate 			return;
42637c478bd9Sstevel@tonic-gate 	} else {
42647c478bd9Sstevel@tonic-gate 		struct ntptimeval32 ntv32;
42657c478bd9Sstevel@tonic-gate 
42667c478bd9Sstevel@tonic-gate 		if (Pread(Proc, &ntv32, sizeof (ntv32), offset)
42677c478bd9Sstevel@tonic-gate 		    != sizeof (ntv32))
42687c478bd9Sstevel@tonic-gate 			return;
42697c478bd9Sstevel@tonic-gate 
42707c478bd9Sstevel@tonic-gate 		TIMEVAL32_TO_TIMEVAL(&ntv.time, &ntv32.time);
42717c478bd9Sstevel@tonic-gate 		ntv.maxerror = ntv32.maxerror;
42727c478bd9Sstevel@tonic-gate 		ntv.esterror = ntv32.esterror;
42737c478bd9Sstevel@tonic-gate 	}
42747c478bd9Sstevel@tonic-gate 
42757c478bd9Sstevel@tonic-gate 	(void) printf("\ttime:     %ld.%6.6ld sec\n",
42767c478bd9Sstevel@tonic-gate 	    ntv.time.tv_sec, ntv.time.tv_usec);
42777c478bd9Sstevel@tonic-gate 	(void) printf("\tmaxerror: %11d usec\n", ntv.maxerror);
42787c478bd9Sstevel@tonic-gate 	(void) printf("\testerror: %11d usec\n", ntv.esterror);
42797c478bd9Sstevel@tonic-gate }
42807c478bd9Sstevel@tonic-gate 
42817c478bd9Sstevel@tonic-gate static char *
42827c478bd9Sstevel@tonic-gate get_timex_modes(private_t *pri, uint32_t val)
42837c478bd9Sstevel@tonic-gate {
42847c478bd9Sstevel@tonic-gate 	char *str = pri->code_buf;
42857c478bd9Sstevel@tonic-gate 	size_t used = 0;
42867c478bd9Sstevel@tonic-gate 
42877c478bd9Sstevel@tonic-gate 	*str = '\0';
42887c478bd9Sstevel@tonic-gate 	if (val & MOD_OFFSET)
42897c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_OFFSET", sizeof (pri->code_buf));
42907c478bd9Sstevel@tonic-gate 	if (val & MOD_FREQUENCY)
42917c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_FREQUENCY", sizeof (pri->code_buf));
42927c478bd9Sstevel@tonic-gate 	if (val & MOD_MAXERROR)
42937c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_MAXERROR", sizeof (pri->code_buf));
42947c478bd9Sstevel@tonic-gate 	if (val & MOD_ESTERROR)
42957c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_ESTERROR", sizeof (pri->code_buf));
42967c478bd9Sstevel@tonic-gate 	if (val & MOD_STATUS)
42977c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_STATUS", sizeof (pri->code_buf));
42987c478bd9Sstevel@tonic-gate 	if (val & MOD_TIMECONST)
42997c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_TIMECONST", sizeof (pri->code_buf));
43007c478bd9Sstevel@tonic-gate 	if (val & MOD_CLKB)
43017c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_CLKB", sizeof (pri->code_buf));
43027c478bd9Sstevel@tonic-gate 	if (val & MOD_CLKA)
43037c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|MOD_CLKA", sizeof (pri->code_buf));
43047c478bd9Sstevel@tonic-gate 
43057c478bd9Sstevel@tonic-gate 	if (used == 0 || used >= sizeof (pri->code_buf))
43067c478bd9Sstevel@tonic-gate 		(void) snprintf(str, sizeof (pri->code_buf), " 0x%.4x", val);
43077c478bd9Sstevel@tonic-gate 
43087c478bd9Sstevel@tonic-gate 	return (str + 1);
43097c478bd9Sstevel@tonic-gate }
43107c478bd9Sstevel@tonic-gate 
43117c478bd9Sstevel@tonic-gate static char *
43127c478bd9Sstevel@tonic-gate get_timex_status(private_t *pri, int32_t val)
43137c478bd9Sstevel@tonic-gate {
43147c478bd9Sstevel@tonic-gate 	char *str = pri->code_buf;
43157c478bd9Sstevel@tonic-gate 	size_t used = 0;
43167c478bd9Sstevel@tonic-gate 
43177c478bd9Sstevel@tonic-gate 	*str = '\0';
43187c478bd9Sstevel@tonic-gate 	if (val & STA_PLL)
43197c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PLL", sizeof (pri->code_buf));
43207c478bd9Sstevel@tonic-gate 	if (val & STA_PPSFREQ)
43217c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PPSFREQ", sizeof (pri->code_buf));
43227c478bd9Sstevel@tonic-gate 	if (val & STA_PPSTIME)
43237c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PPSTIME", sizeof (pri->code_buf));
43247c478bd9Sstevel@tonic-gate 	if (val & STA_FLL)
43257c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_FLL", sizeof (pri->code_buf));
43267c478bd9Sstevel@tonic-gate 
43277c478bd9Sstevel@tonic-gate 	if (val & STA_INS)
43287c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_INS", sizeof (pri->code_buf));
43297c478bd9Sstevel@tonic-gate 	if (val & STA_DEL)
43307c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_DEL", sizeof (pri->code_buf));
43317c478bd9Sstevel@tonic-gate 	if (val & STA_UNSYNC)
43327c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_UNSYNC", sizeof (pri->code_buf));
43337c478bd9Sstevel@tonic-gate 	if (val & STA_FREQHOLD)
43347c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_FREQHOLD", sizeof (pri->code_buf));
43357c478bd9Sstevel@tonic-gate 
43367c478bd9Sstevel@tonic-gate 	if (val & STA_PPSSIGNAL)
43377c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PPSSIGNAL", sizeof (pri->code_buf));
43387c478bd9Sstevel@tonic-gate 	if (val & STA_PPSJITTER)
43397c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PPSJITTER", sizeof (pri->code_buf));
43407c478bd9Sstevel@tonic-gate 	if (val & STA_PPSWANDER)
43417c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PPSWANDER", sizeof (pri->code_buf));
43427c478bd9Sstevel@tonic-gate 	if (val & STA_PPSERROR)
43437c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_PPSERROR", sizeof (pri->code_buf));
43447c478bd9Sstevel@tonic-gate 
43457c478bd9Sstevel@tonic-gate 	if (val & STA_CLOCKERR)
43467c478bd9Sstevel@tonic-gate 		used = strlcat(str, "|STA_CLOCKERR", sizeof (pri->code_buf));
43477c478bd9Sstevel@tonic-gate 
43487c478bd9Sstevel@tonic-gate 	if (used == 0 || used >= sizeof (pri->code_buf))
43497c478bd9Sstevel@tonic-gate 		(void) snprintf(str, sizeof (pri->code_buf), " 0x%.4x", val);
43507c478bd9Sstevel@tonic-gate 
43517c478bd9Sstevel@tonic-gate 	return (str + 1);
43527c478bd9Sstevel@tonic-gate }
43537c478bd9Sstevel@tonic-gate 
43547c478bd9Sstevel@tonic-gate void
43557c478bd9Sstevel@tonic-gate show_ntp_adjtime(private_t *pri)
43567c478bd9Sstevel@tonic-gate {
43577c478bd9Sstevel@tonic-gate 	struct timex timex;
43587c478bd9Sstevel@tonic-gate 	long offset;
43597c478bd9Sstevel@tonic-gate 
43607c478bd9Sstevel@tonic-gate 	if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
43617c478bd9Sstevel@tonic-gate 		return;
43627c478bd9Sstevel@tonic-gate 
43637c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &timex, sizeof (timex), offset) != sizeof (timex))
43647c478bd9Sstevel@tonic-gate 		return;
43657c478bd9Sstevel@tonic-gate 
43667c478bd9Sstevel@tonic-gate 	(void) printf("\tmodes:     %s\n", get_timex_modes(pri, timex.modes));
43677c478bd9Sstevel@tonic-gate 	(void) printf("\toffset:    %11d usec\n", timex.offset);
43687c478bd9Sstevel@tonic-gate 	(void) printf("\tfreq:      %11d scaled ppm\n", timex.freq);
43697c478bd9Sstevel@tonic-gate 	(void) printf("\tmaxerror:  %11d usec\n", timex.maxerror);
43707c478bd9Sstevel@tonic-gate 	(void) printf("\testerror:  %11d usec\n", timex.esterror);
43717c478bd9Sstevel@tonic-gate 	(void) printf("\tstatus:    %s\n", get_timex_status(pri, timex.status));
43727c478bd9Sstevel@tonic-gate 	(void) printf("\tconstant:  %11d\n", timex.constant);
43737c478bd9Sstevel@tonic-gate 	(void) printf("\tprecision: %11d usec\n", timex.precision);
43747c478bd9Sstevel@tonic-gate 	(void) printf("\ttolerance: %11d scaled ppm\n", timex.tolerance);
43757c478bd9Sstevel@tonic-gate 	(void) printf("\tppsfreq:   %11d scaled ppm\n", timex.ppsfreq);
43767c478bd9Sstevel@tonic-gate 	(void) printf("\tjitter:    %11d usec\n", timex.jitter);
43777c478bd9Sstevel@tonic-gate 	(void) printf("\tshift:     %11d sec\n", timex.shift);
43787c478bd9Sstevel@tonic-gate 	(void) printf("\tstabil:    %11d scaled ppm\n", timex.stabil);
43797c478bd9Sstevel@tonic-gate 	(void) printf("\tjitcnt:    %11d\n", timex.jitcnt);
43807c478bd9Sstevel@tonic-gate 	(void) printf("\tcalcnt:    %11d\n", timex.calcnt);
43817c478bd9Sstevel@tonic-gate 	(void) printf("\terrcnt:    %11d\n", timex.errcnt);
43827c478bd9Sstevel@tonic-gate 	(void) printf("\tstbcnt:    %11d\n", timex.stbcnt);
43837c478bd9Sstevel@tonic-gate }
43847c478bd9Sstevel@tonic-gate 
43857c478bd9Sstevel@tonic-gate void
43867c478bd9Sstevel@tonic-gate show_getrusage(long offset)
43877c478bd9Sstevel@tonic-gate {
43887c478bd9Sstevel@tonic-gate 	struct rusage r;
43897c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &r, sizeof (r), offset) != sizeof (r))
43907c478bd9Sstevel@tonic-gate 		return;
43917c478bd9Sstevel@tonic-gate 	(void) printf("\t       user time: %ld.%6.6ld sec\n",
43927c478bd9Sstevel@tonic-gate 	    r.ru_utime.tv_sec,
43937c478bd9Sstevel@tonic-gate 	    r.ru_utime.tv_usec);
43947c478bd9Sstevel@tonic-gate 	(void) printf("\t     system time: %ld.%6.6ld sec\n",
43957c478bd9Sstevel@tonic-gate 	    r.ru_stime.tv_sec,
43967c478bd9Sstevel@tonic-gate 	    r.ru_stime.tv_usec);
43977c478bd9Sstevel@tonic-gate 	(void) printf("\t         max rss: <unimpl> %ld\n",
43987c478bd9Sstevel@tonic-gate 	    r.ru_maxrss);
43997c478bd9Sstevel@tonic-gate 	(void) printf("\t     shared data: <unimpl> %ld\n",
44007c478bd9Sstevel@tonic-gate 	    r.ru_ixrss);
44017c478bd9Sstevel@tonic-gate 	(void) printf("\t   unshared data: <unimpl> %ld\n",
44027c478bd9Sstevel@tonic-gate 	    r.ru_idrss);
44037c478bd9Sstevel@tonic-gate 	(void) printf("\t  unshared stack: <unimpl> %ld\n",
44047c478bd9Sstevel@tonic-gate 	    r.ru_isrss);
44057c478bd9Sstevel@tonic-gate 	(void) printf("\t    minor faults: %ld\n",
44067c478bd9Sstevel@tonic-gate 	    r.ru_minflt);
44077c478bd9Sstevel@tonic-gate 	(void) printf("\t    major faults: %ld\n",
44087c478bd9Sstevel@tonic-gate 	    r.ru_majflt);
44097c478bd9Sstevel@tonic-gate 	(void) printf("\t      # of swaps: %ld\n",
44107c478bd9Sstevel@tonic-gate 	    r.ru_nswap);
44117c478bd9Sstevel@tonic-gate 	(void) printf("\t  blocked inputs: %ld\n",
44127c478bd9Sstevel@tonic-gate 	    r.ru_inblock);
44137c478bd9Sstevel@tonic-gate 	(void) printf("\t blocked outputs: %ld\n",
44147c478bd9Sstevel@tonic-gate 	    r.ru_oublock);
44157c478bd9Sstevel@tonic-gate 	(void) printf("\t       msgs sent: %ld\n",
44167c478bd9Sstevel@tonic-gate 	    r.ru_msgsnd);
44177c478bd9Sstevel@tonic-gate 	(void) printf("\t      msgs rcv'd: %ld\n",
44187c478bd9Sstevel@tonic-gate 	    r.ru_msgrcv);
44197c478bd9Sstevel@tonic-gate 	(void) printf("\t   signals rcv'd: %ld\n",
44207c478bd9Sstevel@tonic-gate 	    r.ru_nsignals);
44217c478bd9Sstevel@tonic-gate 	(void) printf("\tvol cntxt swtchs: %ld\n",
44227c478bd9Sstevel@tonic-gate 	    r.ru_nvcsw);
44237c478bd9Sstevel@tonic-gate 	(void) printf("\tinv cntxt swtchs: %ld\n",
44247c478bd9Sstevel@tonic-gate 	    r.ru_nivcsw);
44257c478bd9Sstevel@tonic-gate }
44267c478bd9Sstevel@tonic-gate 
44277c478bd9Sstevel@tonic-gate #ifdef _LP64
44287c478bd9Sstevel@tonic-gate void
44297c478bd9Sstevel@tonic-gate show_getrusage32(long offset)
44307c478bd9Sstevel@tonic-gate {
44317c478bd9Sstevel@tonic-gate 	struct rusage32 r;
44327c478bd9Sstevel@tonic-gate 	if (Pread(Proc, &r, sizeof (r), offset) != sizeof (r))
44337c478bd9Sstevel@tonic-gate 		return;
44347c478bd9Sstevel@tonic-gate 	(void) printf("\t       user time: %d.%6.6d sec\n",
44357c478bd9Sstevel@tonic-gate 	    r.ru_utime.tv_sec,
44367c478bd9Sstevel@tonic-gate 	    r.ru_utime.tv_usec);
44377c478bd9Sstevel@tonic-gate 	(void) printf("\t     system time: %d.%6.6d sec\n",
44387c478bd9Sstevel@tonic-gate 	    r.ru_stime.tv_sec,
44397c478bd9Sstevel@tonic-gate 	    r.ru_stime.tv_usec);
44407c478bd9Sstevel@tonic-gate 	(void) printf("\t         max rss: <unimpl> %d\n",
44417c478bd9Sstevel@tonic-gate 	    r.ru_maxrss);
44427c478bd9Sstevel@tonic-gate 	(void) printf("\t     shared data: <unimpl> %d\n",
44437c478bd9Sstevel@tonic-gate 	    r.ru_ixrss);
44447c478bd9Sstevel@tonic-gate 	(void) printf("\t   unshared data: <unimpl> %d\n",
44457c478bd9Sstevel@tonic-gate 	    r.ru_idrss);
44467c478bd9Sstevel@tonic-gate 	(void) printf("\t  unshared stack: <unimpl> %d\n",
44477c478bd9Sstevel@tonic-gate 	    r.ru_isrss);
44487c478bd9Sstevel@tonic-gate 	(void) printf("\t    minor faults: %d\n",
44497c478bd9Sstevel@tonic-gate 	    r.ru_minflt);
44507c478bd9Sstevel@tonic-gate 	(void) printf("\t    major faults: %d\n",
44517c478bd9Sstevel@tonic-gate 	    r.ru_majflt);
44527c478bd9Sstevel@tonic-gate 	(void) printf("\t      # of swaps: %d\n",
44537c478bd9Sstevel@tonic-gate 	    r.ru_nswap);
44547c478bd9Sstevel@tonic-gate 	(void) printf("\t  blocked inputs: %d\n",
44557c478bd9Sstevel@tonic-gate 	    r.ru_inblock);
44567c478bd9Sstevel@tonic-gate 	(void) printf("\t blocked outputs: %d\n",
44577c478bd9Sstevel@tonic-gate 	    r.ru_oublock);
44587c478bd9Sstevel@tonic-gate 	(void) printf("\t       msgs sent: %d\n",
44597c478bd9Sstevel@tonic-gate 	    r.ru_msgsnd);
44607c478bd9Sstevel@tonic-gate 	(void) printf("\t      msgs rcv'd: %d\n",
44617c478bd9Sstevel@tonic-gate 	    r.ru_msgrcv);
44627c478bd9Sstevel@tonic-gate 	(void) printf("\t   signals rcv'd: %d\n",
44637c478bd9Sstevel@tonic-gate 	    r.ru_nsignals);
44647c478bd9Sstevel@tonic-gate 	(void) printf("\tvol cntxt swtchs: %d\n",
44657c478bd9Sstevel@tonic-gate 	    r.ru_nvcsw);
44667c478bd9Sstevel@tonic-gate 	(void) printf("\tinv cntxt swtchs: %d\n",
44677c478bd9Sstevel@tonic-gate 	    r.ru_nivcsw);
44687c478bd9Sstevel@tonic-gate }
44697c478bd9Sstevel@tonic-gate #endif
44707c478bd9Sstevel@tonic-gate 
4471aa4a4f3bSnf /*
4472aa4a4f3bSnf  * Utility function to print a packed nvlist by unpacking
4473aa4a4f3bSnf  * and calling the libnvpair pretty printer.  Frees all
4474aa4a4f3bSnf  * allocated memory internally.
4475aa4a4f3bSnf  */
4476aa4a4f3bSnf static void
4477aa4a4f3bSnf show_packed_nvlist(private_t *pri, uintptr_t offset, size_t size)
4478aa4a4f3bSnf {
4479aa4a4f3bSnf 	nvlist_t *nvl = NULL;
4480aa4a4f3bSnf 	size_t readsize;
4481aa4a4f3bSnf 	char *buf;
4482aa4a4f3bSnf 
4483aa4a4f3bSnf 	if ((offset == 0) || (size == 0)) {
4484aa4a4f3bSnf 		return;
4485aa4a4f3bSnf 	}
4486aa4a4f3bSnf 
4487aa4a4f3bSnf 	buf = my_malloc(size, "nvlist decode buffer");
4488aa4a4f3bSnf 	readsize = Pread(Proc, buf, size, offset);
4489aa4a4f3bSnf 	if (readsize != size) {
4490aa4a4f3bSnf 		(void) printf("%s\t<?>", pri->pname);
4491aa4a4f3bSnf 	} else {
4492aa4a4f3bSnf 		int result;
4493aa4a4f3bSnf 
4494aa4a4f3bSnf 		result = nvlist_unpack(buf, size, &nvl, 0);
4495aa4a4f3bSnf 		if (result == 0) {
4496aa4a4f3bSnf 			nvlist_print(stdout, nvl);
4497aa4a4f3bSnf 			nvlist_free(nvl);
4498aa4a4f3bSnf 		} else {
4499aa4a4f3bSnf 			(void) printf("%s\tunpack of nvlist"
4500aa4a4f3bSnf 			    " failed: %d\n", pri->pname, result);
4501aa4a4f3bSnf 		}
4502aa4a4f3bSnf 	}
4503aa4a4f3bSnf 	free(buf);
4504aa4a4f3bSnf }
4505aa4a4f3bSnf 
4506821c4a97Sdp static void
4507821c4a97Sdp show_zone_create_args(private_t *pri, long offset)
4508821c4a97Sdp {
4509821c4a97Sdp 	zone_def args;
4510821c4a97Sdp 	char zone_name[ZONENAME_MAX];
4511821c4a97Sdp 	char zone_root[MAXPATHLEN];
4512821c4a97Sdp 	char *zone_zfs = NULL;
4513821c4a97Sdp 
4514821c4a97Sdp 	if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
4515821c4a97Sdp 
4516821c4a97Sdp 		if (Pread_string(Proc, zone_name, sizeof (zone_name),
4517821c4a97Sdp 		    (uintptr_t)args.zone_name) == -1)
4518821c4a97Sdp 			(void) strcpy(zone_name, "<?>");
4519821c4a97Sdp 
4520821c4a97Sdp 		if (Pread_string(Proc, zone_root, sizeof (zone_root),
4521821c4a97Sdp 		    (uintptr_t)args.zone_root) == -1)
4522821c4a97Sdp 			(void) strcpy(zone_root, "<?>");
4523821c4a97Sdp 
4524821c4a97Sdp 		if (args.zfsbufsz > 0) {
4525821c4a97Sdp 			zone_zfs = malloc(MIN(4, args.zfsbufsz));
4526821c4a97Sdp 			if (zone_zfs != NULL) {
4527821c4a97Sdp 				if (Pread(Proc, zone_zfs, args.zfsbufsz,
4528821c4a97Sdp 				    (uintptr_t)args.zfsbuf) == -1)
4529821c4a97Sdp 					(void) strcpy(zone_zfs, "<?>");
4530821c4a97Sdp 			}
4531821c4a97Sdp 		} else {
4532821c4a97Sdp 			zone_zfs = "";
4533821c4a97Sdp 		}
4534821c4a97Sdp 
4535821c4a97Sdp 		(void) printf("%s\t     zone_name: %s\n", pri->pname,
4536821c4a97Sdp 		    zone_name);
4537821c4a97Sdp 		(void) printf("%s\t     zone_root: %s\n", pri->pname,
4538821c4a97Sdp 		    zone_root);
4539821c4a97Sdp 
4540821c4a97Sdp 		show_privset(pri, (uintptr_t)args.zone_privs,
4541821c4a97Sdp 		    args.zone_privssz, "    zone_privs: ");
4542821c4a97Sdp 
4543821c4a97Sdp 		(void) printf("%s\t       rctlbuf: 0x%p\n", pri->pname,
4544821c4a97Sdp 		    (void *)args.rctlbuf);
4545821c4a97Sdp 		(void) printf("%s\t     rctlbufsz: %lu\n", pri->pname,
4546821c4a97Sdp 		    (ulong_t)args.rctlbufsz);
4547821c4a97Sdp 
4548aa4a4f3bSnf 		show_packed_nvlist(pri, (uintptr_t)args.rctlbuf,
4549aa4a4f3bSnf 		    args.rctlbufsz);
4550aa4a4f3bSnf 
4551821c4a97Sdp 		(void) printf("%s\t           zfs: %s\n", pri->pname, zone_zfs);
4552821c4a97Sdp 
4553821c4a97Sdp 		(void) printf("%s\textended_error: 0x%p\n", pri->pname,
4554821c4a97Sdp 		    (void *)args.extended_error);
4555821c4a97Sdp 
455645916cd2Sjpk 		if (is_system_labeled()) {
455745916cd2Sjpk 			char		*label_str = NULL;
455845916cd2Sjpk 			bslabel_t	zone_label;
455945916cd2Sjpk 
456045916cd2Sjpk 			(void) printf("%s\t         match: %d\n", pri->pname,
456145916cd2Sjpk 			    args.match);
456245916cd2Sjpk 			(void) printf("%s\t           doi: %d\n", pri->pname,
456345916cd2Sjpk 			    args.doi);
456445916cd2Sjpk 
456545916cd2Sjpk 			if (Pread_string(Proc, (char *)&zone_label,
456645916cd2Sjpk 			    sizeof (zone_label), (uintptr_t)args.label) != -1) {
456745916cd2Sjpk 				/* show the label as string */
456845916cd2Sjpk 				if (label_to_str(&zone_label, &label_str,
456945916cd2Sjpk 				    M_LABEL, SHORT_NAMES) != 0) {
457045916cd2Sjpk 					/* have to dump label as raw string */
457145916cd2Sjpk 					(void) label_to_str(&zone_label,
457245916cd2Sjpk 					    &label_str, M_INTERNAL,
457345916cd2Sjpk 					    SHORT_NAMES);
457445916cd2Sjpk 				}
457545916cd2Sjpk 			}
457645916cd2Sjpk 
457745916cd2Sjpk 			(void) printf("%s\t         label: %s\n",
457845916cd2Sjpk 			    pri->pname, label_str != NULL ? label_str : "<?>");
457945916cd2Sjpk 			if (label_str)
458045916cd2Sjpk 				free(label_str);
458145916cd2Sjpk 		}
458245916cd2Sjpk 
4583821c4a97Sdp 		if (args.zfsbufsz > 0)
4584821c4a97Sdp 			free(zone_zfs);
4585821c4a97Sdp 	}
4586821c4a97Sdp }
4587821c4a97Sdp 
4588821c4a97Sdp 
4589821c4a97Sdp #ifdef _LP64
4590821c4a97Sdp 
4591821c4a97Sdp static void
4592821c4a97Sdp show_zone_create_args32(private_t *pri, long offset)
4593821c4a97Sdp {
4594821c4a97Sdp 	zone_def32 args;
4595821c4a97Sdp 	char zone_name[ZONENAME_MAX];
4596821c4a97Sdp 	char zone_root[MAXPATHLEN];
4597821c4a97Sdp 	char *zone_zfs = NULL;
4598821c4a97Sdp 
4599821c4a97Sdp 	if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
4600821c4a97Sdp 
4601821c4a97Sdp 		if (Pread_string(Proc, zone_name, sizeof (zone_name),
4602821c4a97Sdp 		    (uintptr_t)args.zone_name) == -1)
4603821c4a97Sdp 			(void) strcpy(zone_name, "<?>");
4604821c4a97Sdp 
4605821c4a97Sdp 		if (Pread_string(Proc, zone_root, sizeof (zone_root),
4606821c4a97Sdp 		    (uintptr_t)args.zone_root) == -1)
4607821c4a97Sdp 			(void) strcpy(zone_root, "<?>");
4608821c4a97Sdp 
4609821c4a97Sdp 		if (args.zfsbufsz > 0) {
4610821c4a97Sdp 			zone_zfs = malloc(MIN(4, args.zfsbufsz));
4611821c4a97Sdp 			if (zone_zfs != NULL) {
4612821c4a97Sdp 				if (Pread(Proc, zone_zfs, args.zfsbufsz,
4613821c4a97Sdp 				    (uintptr_t)args.zfsbuf) == -1)
4614821c4a97Sdp 					(void) strcpy(zone_zfs, "<?>");
4615821c4a97Sdp 			}
4616821c4a97Sdp 		} else {
4617821c4a97Sdp 			zone_zfs = "";
4618821c4a97Sdp 		}
4619821c4a97Sdp 
4620821c4a97Sdp 		(void) printf("%s\t     zone_name: %s\n", pri->pname,
4621821c4a97Sdp 		    zone_name);
4622821c4a97Sdp 		(void) printf("%s\t     zone_root: %s\n", pri->pname,
4623821c4a97Sdp 		    zone_root);
4624821c4a97Sdp 
4625821c4a97Sdp 		show_privset(pri, (uintptr_t)args.zone_privs,
4626821c4a97Sdp 		    args.zone_privssz, "    zone_privs: ");
4627821c4a97Sdp 
46283246257cSdp 		(void) printf("%s\t       rctlbuf: 0x%x\n", pri->pname,
46293246257cSdp 		    (caddr32_t)args.rctlbuf);
4630821c4a97Sdp 		(void) printf("%s\t     rctlbufsz: %lu\n", pri->pname,
4631821c4a97Sdp 		    (ulong_t)args.rctlbufsz);
4632821c4a97Sdp 
4633aa4a4f3bSnf 		show_packed_nvlist(pri, (uintptr_t)args.rctlbuf,
4634aa4a4f3bSnf 		    args.rctlbufsz);
4635aa4a4f3bSnf 
4636821c4a97Sdp 		(void) printf("%s\t           zfs: %s\n", pri->pname, zone_zfs);
4637821c4a97Sdp 
46383246257cSdp 		(void) printf("%s\textended_error: 0x%x\n", pri->pname,
46393246257cSdp 		    (caddr32_t)args.extended_error);
4640821c4a97Sdp 
464145916cd2Sjpk 		if (is_system_labeled()) {
464245916cd2Sjpk 			char		*label_str = NULL;
464345916cd2Sjpk 			bslabel_t	zone_label;
464445916cd2Sjpk 
464545916cd2Sjpk 			(void) printf("%s\t         match: %d\n", pri->pname,
464645916cd2Sjpk 			    args.match);
464745916cd2Sjpk 			(void) printf("%s\t           doi: %d\n", pri->pname,
464845916cd2Sjpk 			    args.doi);
464945916cd2Sjpk 
465045916cd2Sjpk 			if (Pread_string(Proc, (char *)&zone_label,
465145916cd2Sjpk 			    sizeof (zone_label), (caddr32_t)args.label) != -1) {
465245916cd2Sjpk 				/* show the label as string */
465345916cd2Sjpk 				if (label_to_str(&zone_label, &label_str,
465445916cd2Sjpk 				    M_LABEL, SHORT_NAMES) != 0) {
465545916cd2Sjpk 					/* have to dump label as raw string */
465645916cd2Sjpk 					(void) label_to_str(&zone_label,
465745916cd2Sjpk 					    &label_str, M_INTERNAL,
465845916cd2Sjpk 					    SHORT_NAMES);
465945916cd2Sjpk 				}
466045916cd2Sjpk 			}
466145916cd2Sjpk 			(void) printf("%s\t         label: %s\n",
466245916cd2Sjpk 			    pri->pname, label_str != NULL ? label_str : "<?>");
466345916cd2Sjpk 			if (label_str)
466445916cd2Sjpk 				free(label_str);
466545916cd2Sjpk 		}
466645916cd2Sjpk 
4667821c4a97Sdp 		if (args.zfsbufsz > 0)
4668821c4a97Sdp 			free(zone_zfs);
4669821c4a97Sdp 	}
4670821c4a97Sdp }
4671821c4a97Sdp 
4672821c4a97Sdp #endif
4673821c4a97Sdp 
4674821c4a97Sdp static void
4675821c4a97Sdp show_zones(private_t *pri)
4676821c4a97Sdp {
4677821c4a97Sdp 	switch (pri->sys_args[0]) {
4678821c4a97Sdp 	case ZONE_CREATE:
4679821c4a97Sdp #ifdef _LP64
4680821c4a97Sdp 		if (data_model == PR_MODEL_LP64)
4681821c4a97Sdp 			show_zone_create_args(pri, (long)pri->sys_args[1]);
4682821c4a97Sdp 		else
4683821c4a97Sdp 			show_zone_create_args32(pri, (long)pri->sys_args[1]);
4684821c4a97Sdp #else
4685821c4a97Sdp 		show_zone_create_args(pri, (long)pri->sys_args[1]);
4686821c4a97Sdp #endif
4687821c4a97Sdp 		break;
4688821c4a97Sdp 	}
4689821c4a97Sdp }
4690821c4a97Sdp 
4691aa4a4f3bSnf static void
4692aa4a4f3bSnf show_rctlblk(private_t *pri, long _rctlblk)
4693aa4a4f3bSnf {
4694aa4a4f3bSnf 	rctlblk_t *blk;
4695aa4a4f3bSnf 	int size = rctlblk_size();
4696aa4a4f3bSnf 	size_t readsize;
4697aa4a4f3bSnf 	const char *s;
4698aa4a4f3bSnf 
4699aa4a4f3bSnf 	blk = my_malloc(size, "rctlblk decode buffer");
4700aa4a4f3bSnf 	readsize = Pread(Proc, blk, size, _rctlblk);
4701aa4a4f3bSnf 	if (readsize != size) {
4702aa4a4f3bSnf 		(void) printf("%s\t\t<?>", pri->pname);
4703aa4a4f3bSnf 	} else {
4704aa4a4f3bSnf 		(void) printf("%s\t\t     Privilege: 0x%x\n",
4705aa4a4f3bSnf 		    pri->pname,
4706aa4a4f3bSnf 		    rctlblk_get_privilege(blk));
4707aa4a4f3bSnf 		(void) printf("%s\t\t         Value: %lld\n",
4708aa4a4f3bSnf 		    pri->pname,
4709aa4a4f3bSnf 		    rctlblk_get_value(blk));
4710aa4a4f3bSnf 		(void) printf("%s\t\tEnforced Value: %lld\n",
4711aa4a4f3bSnf 		    pri->pname,
4712aa4a4f3bSnf 		    rctlblk_get_enforced_value(blk));
4713aa4a4f3bSnf 
4714aa4a4f3bSnf 		{
4715aa4a4f3bSnf 			int sig, act;
4716aa4a4f3bSnf 			act = rctlblk_get_local_action(blk, &sig);
4717aa4a4f3bSnf 
4718aa4a4f3bSnf 			s = rctl_local_action(pri, act);
4719aa4a4f3bSnf 			if (s == NULL) {
4720aa4a4f3bSnf 				(void) printf("%s\t\t  Local action: 0x%x\n",
4721aa4a4f3bSnf 				    pri->pname, act);
4722aa4a4f3bSnf 			} else {
4723aa4a4f3bSnf 				(void) printf("%s\t\t  Local action: %s\n",
4724aa4a4f3bSnf 				    pri->pname, s);
4725aa4a4f3bSnf 			}
4726aa4a4f3bSnf 
4727aa4a4f3bSnf 			if (act & RCTL_LOCAL_SIGNAL) {
4728aa4a4f3bSnf 				(void) printf("%s\t\t                "
4729aa4a4f3bSnf 				    "For signal %s\n",
4730aa4a4f3bSnf 				    pri->pname, signame(pri, sig));
4731aa4a4f3bSnf 			}
4732aa4a4f3bSnf 		}
4733aa4a4f3bSnf 
4734aa4a4f3bSnf 		s = rctl_local_flags(pri, rctlblk_get_local_flags(blk));
4735aa4a4f3bSnf 		if (s == NULL) {
4736aa4a4f3bSnf 			(void) printf("%s\t\t   Local flags: 0x%x\n",
4737aa4a4f3bSnf 			    pri->pname, rctlblk_get_local_flags(blk));
4738aa4a4f3bSnf 		} else {
4739aa4a4f3bSnf 			(void) printf("%s\t\t   Local flags: %s\n",
4740aa4a4f3bSnf 			    pri->pname, s);
4741aa4a4f3bSnf 		}
4742aa4a4f3bSnf 
4743aa4a4f3bSnf #ifdef _LP64
4744aa4a4f3bSnf 		(void) printf("%s\t\t Recipient PID: %d\n",
4745aa4a4f3bSnf 		    pri->pname,
4746aa4a4f3bSnf 		    rctlblk_get_recipient_pid(blk));
4747aa4a4f3bSnf #else
4748aa4a4f3bSnf 		(void) printf("%s\t\t Recipient PID: %ld\n",
4749aa4a4f3bSnf 		    pri->pname,
4750aa4a4f3bSnf 		    rctlblk_get_recipient_pid(blk));
4751aa4a4f3bSnf #endif
4752aa4a4f3bSnf 		(void) printf("%s\t\t   Firing Time: %lld\n",
4753aa4a4f3bSnf 		    pri->pname,
4754aa4a4f3bSnf 		    rctlblk_get_firing_time(blk));
4755aa4a4f3bSnf 	}
4756aa4a4f3bSnf 	free(blk);
4757aa4a4f3bSnf }
4758aa4a4f3bSnf 
4759aa4a4f3bSnf static void
4760aa4a4f3bSnf show_rctls(private_t *pri)
4761aa4a4f3bSnf {
4762532877c4Srd 	int entry;
4763532877c4Srd 
4764aa4a4f3bSnf 	switch (pri->sys_args[0]) {
4765aa4a4f3bSnf 	case 0:	/* getrctl */
4766aa4a4f3bSnf 	case 1: /* setrctl */
4767aa4a4f3bSnf 		/*
4768aa4a4f3bSnf 		 * If these offsets look a little odd, remember that they're
4769aa4a4f3bSnf 		 * into the _raw_ system call
4770aa4a4f3bSnf 		 */
4771aa4a4f3bSnf 		(void) printf("%s\tOld rctlblk: 0x%lx\n", pri->pname,
4772aa4a4f3bSnf 		    pri->sys_args[2]);
4773aa4a4f3bSnf 		if (pri->sys_args[2] != NULL) {
4774aa4a4f3bSnf 			show_rctlblk(pri, pri->sys_args[2]);
4775aa4a4f3bSnf 		}
4776aa4a4f3bSnf 		(void) printf("%s\tNew rctlblk: 0x%lx\n", pri->pname,
4777aa4a4f3bSnf 		    pri->sys_args[3]);
4778aa4a4f3bSnf 		if (pri->sys_args[3] != NULL) {
4779aa4a4f3bSnf 			show_rctlblk(pri, pri->sys_args[3]);
4780aa4a4f3bSnf 		}
4781aa4a4f3bSnf 		break;
4782532877c4Srd 	case 4: /* setprojrctl */
4783532877c4Srd 		for (entry = 0; entry < pri->sys_args[4]; entry++) {
4784532877c4Srd 			(void) printf("%s\tNew rctlblk[%d]: 0x%lx\n",
4785532877c4Srd 			    pri->pname, entry,
4786532877c4Srd 			    (long)RCTLBLK_INC(pri->sys_args[3], entry));
4787532877c4Srd 			if (RCTLBLK_INC(pri->sys_args[3], entry) != NULL) {
4788532877c4Srd 				show_rctlblk(pri,
4789532877c4Srd 				    (long)RCTLBLK_INC(pri->sys_args[3], entry));
4790532877c4Srd 			}
4791532877c4Srd 		}
4792aa4a4f3bSnf 	}
4793aa4a4f3bSnf }
4794821c4a97Sdp 
47953b862e9aSRoger A. Faulkner void
47963b862e9aSRoger A. Faulkner show_utimesys(private_t *pri)
47973b862e9aSRoger A. Faulkner {
47983b862e9aSRoger A. Faulkner 	switch (pri->sys_args[0]) {
47993b862e9aSRoger A. Faulkner 	case 0:			/* futimens() */
48003b862e9aSRoger A. Faulkner 		if (pri->sys_nargs > 2)
48013b862e9aSRoger A. Faulkner 			show_utimens(pri, (long)pri->sys_args[2]);
48023b862e9aSRoger A. Faulkner 		break;
48033b862e9aSRoger A. Faulkner 	case 1:			/* utimensat */
48043b862e9aSRoger A. Faulkner 		if (pri->sys_nargs > 3)
48053b862e9aSRoger A. Faulkner 			show_utimens(pri, (long)pri->sys_args[3]);
48063b862e9aSRoger A. Faulkner 		break;
48073b862e9aSRoger A. Faulkner 	default:		/* unexpected subcode */
48083b862e9aSRoger A. Faulkner 		break;
48093b862e9aSRoger A. Faulkner 	}
48103b862e9aSRoger A. Faulkner }
48113b862e9aSRoger A. Faulkner 
48127c478bd9Sstevel@tonic-gate /* expound verbosely upon syscall arguments */
48137c478bd9Sstevel@tonic-gate /*ARGSUSED*/
48147c478bd9Sstevel@tonic-gate void
48157c478bd9Sstevel@tonic-gate expound(private_t *pri, long r0, int raw)
48167c478bd9Sstevel@tonic-gate {
48177c478bd9Sstevel@tonic-gate 	const lwpstatus_t *Lsp = pri->lwpstat;
48187c478bd9Sstevel@tonic-gate 	int lp64 = (data_model == PR_MODEL_LP64);
48197c478bd9Sstevel@tonic-gate 	int what = Lsp->pr_what;
48207c478bd9Sstevel@tonic-gate 	int err = pri->Errno;		/* don't display output parameters */
48217c478bd9Sstevel@tonic-gate 					/* for a failed system call */
48227c478bd9Sstevel@tonic-gate #ifndef _LP64
48237c478bd9Sstevel@tonic-gate 	/* We are a 32-bit truss; we can't grok a 64-bit process */
48247c478bd9Sstevel@tonic-gate 	if (lp64)
48257c478bd9Sstevel@tonic-gate 		return;
48267c478bd9Sstevel@tonic-gate #endif
48277c478bd9Sstevel@tonic-gate 	/* for reporting sleeping system calls */
48287c478bd9Sstevel@tonic-gate 	if (what == 0 && (Lsp->pr_flags & (PR_ASLEEP|PR_VFORKP)))
48297c478bd9Sstevel@tonic-gate 		what = Lsp->pr_syscall;
48307c478bd9Sstevel@tonic-gate 
48317c478bd9Sstevel@tonic-gate 	switch (what) {
48327c478bd9Sstevel@tonic-gate 	case SYS_utime:
48337c478bd9Sstevel@tonic-gate 		show_utime(pri);
48347c478bd9Sstevel@tonic-gate 		break;
48357c478bd9Sstevel@tonic-gate 	case SYS_utimes:
48363b862e9aSRoger A. Faulkner 		show_utimes(pri, (long)pri->sys_args[1]);
48377c478bd9Sstevel@tonic-gate 		break;
48387c478bd9Sstevel@tonic-gate 	case SYS_gettimeofday:
48397c478bd9Sstevel@tonic-gate 		if (!err)
48407c478bd9Sstevel@tonic-gate 			show_timeofday(pri);
48417c478bd9Sstevel@tonic-gate 		break;
48427c478bd9Sstevel@tonic-gate 	case SYS_getitimer:
48437c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1)
48447c478bd9Sstevel@tonic-gate 			show_itimerval(pri, (long)pri->sys_args[1],
4845019c3c43Sraf 			    " value");
48467c478bd9Sstevel@tonic-gate 		break;
48477c478bd9Sstevel@tonic-gate 	case SYS_setitimer:
48487c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
48497c478bd9Sstevel@tonic-gate 			show_itimerval(pri, (long)pri->sys_args[1],
4850019c3c43Sraf 			    " value");
48517c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
48527c478bd9Sstevel@tonic-gate 			show_itimerval(pri, (long)pri->sys_args[2],
4853019c3c43Sraf 			    "ovalue");
48547c478bd9Sstevel@tonic-gate 		break;
48557c478bd9Sstevel@tonic-gate 	case SYS_stime:
48567c478bd9Sstevel@tonic-gate 		show_stime(pri);
48577c478bd9Sstevel@tonic-gate 		break;
48587c478bd9Sstevel@tonic-gate 	case SYS_times:
48597c478bd9Sstevel@tonic-gate 		if (!err)
48607c478bd9Sstevel@tonic-gate 			show_times(pri);
48617c478bd9Sstevel@tonic-gate 		break;
48627c478bd9Sstevel@tonic-gate 	case SYS_utssys:
48637c478bd9Sstevel@tonic-gate 		if (err)
48647c478bd9Sstevel@tonic-gate 			break;
48657c478bd9Sstevel@tonic-gate #ifdef _LP64
48667c478bd9Sstevel@tonic-gate 		if (lp64)
48677c478bd9Sstevel@tonic-gate 			show_utssys(pri, r0);
48687c478bd9Sstevel@tonic-gate 		else
48697c478bd9Sstevel@tonic-gate 			show_utssys32(pri, r0);
48707c478bd9Sstevel@tonic-gate #else
48717c478bd9Sstevel@tonic-gate 		show_utssys(pri, r0);
48727c478bd9Sstevel@tonic-gate #endif
48737c478bd9Sstevel@tonic-gate 		break;
48747c478bd9Sstevel@tonic-gate 	case SYS_ioctl:
48757c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs >= 3) /* each case must decide for itself */
48767c478bd9Sstevel@tonic-gate 			show_ioctl(pri, pri->sys_args[1],
4877019c3c43Sraf 			    (long)pri->sys_args[2]);
48787c478bd9Sstevel@tonic-gate 		break;
48797c478bd9Sstevel@tonic-gate 	case SYS_stat:
48807c478bd9Sstevel@tonic-gate 	case SYS_fstat:
48817c478bd9Sstevel@tonic-gate 	case SYS_lstat:
48827c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs >= 2)
48837c478bd9Sstevel@tonic-gate 			show_stat(pri, (long)pri->sys_args[1]);
48847c478bd9Sstevel@tonic-gate 		break;
48857c478bd9Sstevel@tonic-gate 	case SYS_stat64:
48867c478bd9Sstevel@tonic-gate 	case SYS_fstat64:
48877c478bd9Sstevel@tonic-gate 	case SYS_lstat64:
48887c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs >= 2)
48897c478bd9Sstevel@tonic-gate 			show_stat64_32(pri, (long)pri->sys_args[1]);
48907c478bd9Sstevel@tonic-gate 		break;
48917c478bd9Sstevel@tonic-gate 	case SYS_fsat:
48927c478bd9Sstevel@tonic-gate 		/*
48933b862e9aSRoger A. Faulkner 		 * subcodes for fstatat(), fstatat64(), futimesat().
48947c478bd9Sstevel@tonic-gate 		 */
48957c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs >= 4) {
48967c478bd9Sstevel@tonic-gate 			if (pri->sys_args[0] == 3)
48977c478bd9Sstevel@tonic-gate 				show_statat(pri, (long)pri->sys_args[3]);
48987c478bd9Sstevel@tonic-gate 			else if (pri->sys_args[0] == 2)
48997c478bd9Sstevel@tonic-gate 				show_stat64_32(pri, (long)pri->sys_args[3]);
49003b862e9aSRoger A. Faulkner 			else if (pri->sys_args[0] == 6)
49013b862e9aSRoger A. Faulkner 				show_utimes(pri, (long)pri->sys_args[3]);
49027c478bd9Sstevel@tonic-gate 		}
49037c478bd9Sstevel@tonic-gate 		break;
49047c478bd9Sstevel@tonic-gate 	case SYS_xstat:
49057c478bd9Sstevel@tonic-gate 	case SYS_fxstat:
49067c478bd9Sstevel@tonic-gate 	case SYS_lxstat:
49077c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs >= 3)
49087c478bd9Sstevel@tonic-gate 			show_xstat(pri, (int)pri->sys_args[0],
4909019c3c43Sraf 			    (long)pri->sys_args[2]);
49107c478bd9Sstevel@tonic-gate 		break;
49117c478bd9Sstevel@tonic-gate 	case SYS_statvfs:
49127c478bd9Sstevel@tonic-gate 	case SYS_fstatvfs:
49137c478bd9Sstevel@tonic-gate 		if (err)
49147c478bd9Sstevel@tonic-gate 			break;
49157c478bd9Sstevel@tonic-gate #ifdef _LP64
49167c478bd9Sstevel@tonic-gate 		if (!lp64) {
49177c478bd9Sstevel@tonic-gate 			show_statvfs32(pri);
49187c478bd9Sstevel@tonic-gate 			break;
49197c478bd9Sstevel@tonic-gate 		}
49207c478bd9Sstevel@tonic-gate #endif
49217c478bd9Sstevel@tonic-gate 		show_statvfs(pri);
49227c478bd9Sstevel@tonic-gate 		break;
49237c478bd9Sstevel@tonic-gate 	case SYS_statvfs64:
49247c478bd9Sstevel@tonic-gate 	case SYS_fstatvfs64:
49257c478bd9Sstevel@tonic-gate 		if (err)
49267c478bd9Sstevel@tonic-gate 			break;
49277c478bd9Sstevel@tonic-gate 		show_statvfs64(pri);
49287c478bd9Sstevel@tonic-gate 		break;
49297c478bd9Sstevel@tonic-gate 	case SYS_statfs:
49307c478bd9Sstevel@tonic-gate 	case SYS_fstatfs:
49317c478bd9Sstevel@tonic-gate 		if (err)
49327c478bd9Sstevel@tonic-gate 			break;
49337c478bd9Sstevel@tonic-gate #ifdef _LP64
49347c478bd9Sstevel@tonic-gate 		if (lp64)
49357c478bd9Sstevel@tonic-gate 			show_statfs(pri);
49367c478bd9Sstevel@tonic-gate 		else
49377c478bd9Sstevel@tonic-gate 			show_statfs32(pri);
49387c478bd9Sstevel@tonic-gate #else
49397c478bd9Sstevel@tonic-gate 		show_statfs(pri);
49407c478bd9Sstevel@tonic-gate #endif
49417c478bd9Sstevel@tonic-gate 		break;
49427c478bd9Sstevel@tonic-gate 	case SYS_fcntl:
49437c478bd9Sstevel@tonic-gate 		show_fcntl(pri);
49447c478bd9Sstevel@tonic-gate 		break;
49457c478bd9Sstevel@tonic-gate 	case SYS_msgsys:
49467c478bd9Sstevel@tonic-gate 		show_msgsys(pri, r0); /* each case must decide for itself */
49477c478bd9Sstevel@tonic-gate 		break;
49487c478bd9Sstevel@tonic-gate 	case SYS_semsys:
49497c478bd9Sstevel@tonic-gate 		show_semsys(pri);	/* each case must decide for itself */
49507c478bd9Sstevel@tonic-gate 		break;
49517c478bd9Sstevel@tonic-gate 	case SYS_shmsys:
49527c478bd9Sstevel@tonic-gate 		show_shmsys(pri);	/* each case must decide for itself */
49537c478bd9Sstevel@tonic-gate 		break;
49547c478bd9Sstevel@tonic-gate 	case SYS_getdents:
49557c478bd9Sstevel@tonic-gate 		if (err || pri->sys_nargs <= 1 || r0 <= 0)
49567c478bd9Sstevel@tonic-gate 			break;
49577c478bd9Sstevel@tonic-gate #ifdef _LP64
49587c478bd9Sstevel@tonic-gate 		if (!lp64) {
49597c478bd9Sstevel@tonic-gate 			show_dents32(pri, (long)pri->sys_args[1], r0);
49607c478bd9Sstevel@tonic-gate 			break;
49617c478bd9Sstevel@tonic-gate 		}
49627c478bd9Sstevel@tonic-gate 		/* FALLTHROUGH */
49637c478bd9Sstevel@tonic-gate #else
49647c478bd9Sstevel@tonic-gate 		show_dents32(pri, (long)pri->sys_args[1], r0);
49657c478bd9Sstevel@tonic-gate 		break;
49667c478bd9Sstevel@tonic-gate #endif
49677c478bd9Sstevel@tonic-gate 	case SYS_getdents64:
49687c478bd9Sstevel@tonic-gate 		if (err || pri->sys_nargs <= 1 || r0 <= 0)
49697c478bd9Sstevel@tonic-gate 			break;
49707c478bd9Sstevel@tonic-gate 		show_dents64(pri, (long)pri->sys_args[1], r0);
49717c478bd9Sstevel@tonic-gate 		break;
49727c478bd9Sstevel@tonic-gate 	case SYS_getmsg:
49737c478bd9Sstevel@tonic-gate 		show_gp_msg(pri, what);
49747c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3)
49757c478bd9Sstevel@tonic-gate 			show_hhex_int(pri, (long)pri->sys_args[3], "flags");
49767c478bd9Sstevel@tonic-gate 		break;
49777c478bd9Sstevel@tonic-gate 	case SYS_getpmsg:
49787c478bd9Sstevel@tonic-gate 		show_gp_msg(pri, what);
49797c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 3)
49807c478bd9Sstevel@tonic-gate 			show_hhex_int(pri, (long)pri->sys_args[3], "band");
49817c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 4)
49827c478bd9Sstevel@tonic-gate 			show_hhex_int(pri, (long)pri->sys_args[4], "flags");
49837c478bd9Sstevel@tonic-gate 		break;
49847c478bd9Sstevel@tonic-gate 	case SYS_putmsg:
49857c478bd9Sstevel@tonic-gate 	case SYS_putpmsg:
49867c478bd9Sstevel@tonic-gate 		show_gp_msg(pri, what);
49877c478bd9Sstevel@tonic-gate 		break;
49887c478bd9Sstevel@tonic-gate 	case SYS_poll:
49897c478bd9Sstevel@tonic-gate 		show_poll(pri);
49907c478bd9Sstevel@tonic-gate 		break;
49917c478bd9Sstevel@tonic-gate 	case SYS_pollsys:
49927c478bd9Sstevel@tonic-gate 		show_pollsys(pri);
49937c478bd9Sstevel@tonic-gate 		break;
49947c478bd9Sstevel@tonic-gate 	case SYS_setgroups:
49957c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1 && (r0 = pri->sys_args[0]) > 0)
49967c478bd9Sstevel@tonic-gate 			show_groups(pri, (long)pri->sys_args[1], r0);
49977c478bd9Sstevel@tonic-gate 		break;
49987c478bd9Sstevel@tonic-gate 	case SYS_getgroups:
49997c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1 && pri->sys_args[0] > 0)
50007c478bd9Sstevel@tonic-gate 			show_groups(pri, (long)pri->sys_args[1], r0);
50017c478bd9Sstevel@tonic-gate 		break;
50027c478bd9Sstevel@tonic-gate 	case SYS_sigprocmask:
50037c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
50047c478bd9Sstevel@tonic-gate 			show_sigset(pri, (long)pri->sys_args[1], " set");
50057c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
50067c478bd9Sstevel@tonic-gate 			show_sigset(pri, (long)pri->sys_args[2], "oset");
50077c478bd9Sstevel@tonic-gate 		break;
50087c478bd9Sstevel@tonic-gate 	case SYS_sigsuspend:
50097c478bd9Sstevel@tonic-gate 	case SYS_sigtimedwait:
50107c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
50117c478bd9Sstevel@tonic-gate 			show_sigset(pri, (long)pri->sys_args[0], "sigmask");
50127c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1)
50137c478bd9Sstevel@tonic-gate 			show_siginfo(pri, (long)pri->sys_args[1]);
50147c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 2)
50157c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[2], "timeout");
50167c478bd9Sstevel@tonic-gate 		break;
50177c478bd9Sstevel@tonic-gate 	case SYS_sigaltstack:
50187c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
50197c478bd9Sstevel@tonic-gate 			show_sigaltstack(pri, (long)pri->sys_args[0],
5020019c3c43Sraf 			    "new");
50217c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1)
50227c478bd9Sstevel@tonic-gate 			show_sigaltstack(pri, (long)pri->sys_args[1],
5023019c3c43Sraf 			    "old");
50247c478bd9Sstevel@tonic-gate 		break;
50257c478bd9Sstevel@tonic-gate 	case SYS_sigaction:
50267c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
50277c478bd9Sstevel@tonic-gate 			show_sigaction(pri, (long)pri->sys_args[1],
5028019c3c43Sraf 			    "new", NULL);
50297c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
50307c478bd9Sstevel@tonic-gate 			show_sigaction(pri, (long)pri->sys_args[2],
5031019c3c43Sraf 			    "old", r0);
50327c478bd9Sstevel@tonic-gate 		break;
5033f48068adSraf 	case SYS_signotify:
5034f48068adSraf 		if (pri->sys_nargs > 1)
5035f48068adSraf 			show_siginfo(pri, (long)pri->sys_args[1]);
5036f48068adSraf 		break;
5037f48068adSraf 	case SYS_sigresend:
5038f48068adSraf 		if (pri->sys_nargs > 1)
5039f48068adSraf 			show_siginfo(pri, (long)pri->sys_args[1]);
5040f48068adSraf 		if (pri->sys_nargs > 2)
5041f48068adSraf 			show_sigset(pri, (long)pri->sys_args[2], "sigmask");
5042f48068adSraf 		break;
50437c478bd9Sstevel@tonic-gate 	case SYS_sigpending:
50447c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1)
50457c478bd9Sstevel@tonic-gate 			show_sigset(pri, (long)pri->sys_args[1], "sigmask");
50467c478bd9Sstevel@tonic-gate 		break;
5047a574db85Sraf 	case SYS_waitid:
50487c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
50497c478bd9Sstevel@tonic-gate 			show_siginfo(pri, (long)pri->sys_args[2]);
50507c478bd9Sstevel@tonic-gate 		break;
50517c478bd9Sstevel@tonic-gate 	case SYS_sigsendsys:
50527c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
50537c478bd9Sstevel@tonic-gate 			show_procset(pri, (long)pri->sys_args[0]);
50547c478bd9Sstevel@tonic-gate 		break;
50557c478bd9Sstevel@tonic-gate 	case SYS_priocntlsys:
50567c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
50577c478bd9Sstevel@tonic-gate 			show_procset(pri, (long)pri->sys_args[1]);
50587c478bd9Sstevel@tonic-gate 		break;
50597c478bd9Sstevel@tonic-gate 	case SYS_mincore:
50607c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
50617c478bd9Sstevel@tonic-gate 			show_bool(pri, (long)pri->sys_args[2],
5062019c3c43Sraf 			    (pri->sys_args[1] + pagesize - 1) / pagesize);
50637c478bd9Sstevel@tonic-gate 		break;
50647c478bd9Sstevel@tonic-gate 	case SYS_readv:
50657c478bd9Sstevel@tonic-gate 	case SYS_writev:
50667c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 2) {
50677c478bd9Sstevel@tonic-gate 			int i = pri->sys_args[0]+1;
50687c478bd9Sstevel@tonic-gate 			int showbuf = FALSE;
50697c478bd9Sstevel@tonic-gate 			long nb = (what == SYS_readv)? r0 : 32*1024;
50707c478bd9Sstevel@tonic-gate 
50717c478bd9Sstevel@tonic-gate 			if ((what == SYS_readv && !err &&
50727c478bd9Sstevel@tonic-gate 			    prismember(&readfd, i)) ||
50737c478bd9Sstevel@tonic-gate 			    (what == SYS_writev &&
50747c478bd9Sstevel@tonic-gate 			    prismember(&writefd, i)))
50757c478bd9Sstevel@tonic-gate 				showbuf = TRUE;
50767c478bd9Sstevel@tonic-gate 			show_iovec(pri, (long)pri->sys_args[1],
5077019c3c43Sraf 			    pri->sys_args[2], showbuf, nb);
50787c478bd9Sstevel@tonic-gate 		}
50797c478bd9Sstevel@tonic-gate 		break;
50807c478bd9Sstevel@tonic-gate 	case SYS_getrlimit:
50817c478bd9Sstevel@tonic-gate 		if (err)
50827c478bd9Sstevel@tonic-gate 			break;
50837c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
50847c478bd9Sstevel@tonic-gate 	case SYS_setrlimit:
50857c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs <= 1)
50867c478bd9Sstevel@tonic-gate 			break;
50877c478bd9Sstevel@tonic-gate #ifdef _LP64
50887c478bd9Sstevel@tonic-gate 		if (lp64)
50897c478bd9Sstevel@tonic-gate 			show_rlimit64(pri, (long)pri->sys_args[1]);
50907c478bd9Sstevel@tonic-gate 		else
50917c478bd9Sstevel@tonic-gate 			show_rlimit32(pri, (long)pri->sys_args[1]);
50927c478bd9Sstevel@tonic-gate #else
50937c478bd9Sstevel@tonic-gate 		show_rlimit32(pri, (long)pri->sys_args[1]);
50947c478bd9Sstevel@tonic-gate #endif
50957c478bd9Sstevel@tonic-gate 		break;
50967c478bd9Sstevel@tonic-gate 	case SYS_getrlimit64:
50977c478bd9Sstevel@tonic-gate 		if (err)
50987c478bd9Sstevel@tonic-gate 			break;
50997c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
51007c478bd9Sstevel@tonic-gate 	case SYS_setrlimit64:
51017c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs <= 1)
51027c478bd9Sstevel@tonic-gate 			break;
51037c478bd9Sstevel@tonic-gate 		show_rlimit64(pri, (long)pri->sys_args[1]);
51047c478bd9Sstevel@tonic-gate 		break;
51057c478bd9Sstevel@tonic-gate 	case SYS_uname:
51067c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 0)
51077c478bd9Sstevel@tonic-gate 			show_nuname(pri, (long)pri->sys_args[0]);
51087c478bd9Sstevel@tonic-gate 		break;
51097c478bd9Sstevel@tonic-gate 	case SYS_adjtime:
51107c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1)
51117c478bd9Sstevel@tonic-gate 			show_adjtime(pri, (long)pri->sys_args[0],
5112019c3c43Sraf 			    (long)pri->sys_args[1]);
51137c478bd9Sstevel@tonic-gate 		break;
51147c478bd9Sstevel@tonic-gate 	case SYS_lwp_info:
51157c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 0)
51167c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[0], "cpu time");
51177c478bd9Sstevel@tonic-gate 		break;
51187c478bd9Sstevel@tonic-gate 	case SYS_lwp_wait:
51197c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 1)
51207c478bd9Sstevel@tonic-gate 			show_int(pri, (long)pri->sys_args[1], "lwpid");
51217c478bd9Sstevel@tonic-gate 		break;
51227c478bd9Sstevel@tonic-gate 	case SYS_lwp_mutex_wakeup:
51237c478bd9Sstevel@tonic-gate 	case SYS_lwp_mutex_lock:
51247c478bd9Sstevel@tonic-gate 	case SYS_lwp_mutex_unlock:
51257c478bd9Sstevel@tonic-gate 	case SYS_lwp_mutex_trylock:
5126883492d5Sraf 	case SYS_lwp_mutex_register:
51277c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51287c478bd9Sstevel@tonic-gate 			show_mutex(pri, (long)pri->sys_args[0]);
51297c478bd9Sstevel@tonic-gate 		break;
51307c478bd9Sstevel@tonic-gate 	case SYS_lwp_mutex_timedlock:
51317c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51327c478bd9Sstevel@tonic-gate 			show_mutex(pri, (long)pri->sys_args[0]);
51337c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
51347c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[1], "timeout");
51357c478bd9Sstevel@tonic-gate 		break;
51367c478bd9Sstevel@tonic-gate 	case SYS_lwp_cond_wait:
51377c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51387c478bd9Sstevel@tonic-gate 			show_condvar(pri, (long)pri->sys_args[0]);
51397c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
51407c478bd9Sstevel@tonic-gate 			show_mutex(pri, (long)pri->sys_args[1]);
51417c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 2)
51427c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[2], "timeout");
51437c478bd9Sstevel@tonic-gate 		break;
51447c478bd9Sstevel@tonic-gate 	case SYS_lwp_cond_signal:
51457c478bd9Sstevel@tonic-gate 	case SYS_lwp_cond_broadcast:
51467c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51477c478bd9Sstevel@tonic-gate 			show_condvar(pri, (long)pri->sys_args[0]);
51487c478bd9Sstevel@tonic-gate 		break;
51497c478bd9Sstevel@tonic-gate 	case SYS_lwp_sema_wait:
51507c478bd9Sstevel@tonic-gate 	case SYS_lwp_sema_trywait:
51517c478bd9Sstevel@tonic-gate 	case SYS_lwp_sema_post:
51527c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51537c478bd9Sstevel@tonic-gate 			show_sema(pri, (long)pri->sys_args[0]);
51547c478bd9Sstevel@tonic-gate 		break;
51557c478bd9Sstevel@tonic-gate 	case SYS_lwp_sema_timedwait:
51567c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51577c478bd9Sstevel@tonic-gate 			show_sema(pri, (long)pri->sys_args[0]);
51587c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
51597c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[1], "timeout");
51607c478bd9Sstevel@tonic-gate 		break;
51617c478bd9Sstevel@tonic-gate 	case SYS_lwp_rwlock_sys:
51627c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1)
51637c478bd9Sstevel@tonic-gate 			show_rwlock(pri, (long)pri->sys_args[1]);
51647c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 2 &&
51657c478bd9Sstevel@tonic-gate 		    (pri->sys_args[0] == 0 || pri->sys_args[0] == 1))
51667c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[2], "timeout");
51677c478bd9Sstevel@tonic-gate 		break;
51687c478bd9Sstevel@tonic-gate 	case SYS_lwp_create:
51697c478bd9Sstevel@tonic-gate 		/* XXX print some values in ucontext ??? */
51707c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
51717c478bd9Sstevel@tonic-gate 			show_int(pri, (long)pri->sys_args[2], "lwpid");
51727c478bd9Sstevel@tonic-gate 		break;
51737c478bd9Sstevel@tonic-gate 	case SYS_kaio:
51747c478bd9Sstevel@tonic-gate 		if (pri->sys_args[0] == AIOWAIT && !err && pri->sys_nargs > 1)
51757c478bd9Sstevel@tonic-gate 			show_timeval(pri, (long)pri->sys_args[1], "timeout");
51767c478bd9Sstevel@tonic-gate 		break;
51777c478bd9Sstevel@tonic-gate 	case SYS_nanosleep:
51787c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 0)
51797c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[0], "tmout");
51807c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 1 && (err == 0 || err == EINTR))
51817c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[1], "resid");
51827c478bd9Sstevel@tonic-gate 		break;
51837c478bd9Sstevel@tonic-gate 	case SYS_privsys:
51847c478bd9Sstevel@tonic-gate 		switch (pri->sys_args[0]) {
51857c478bd9Sstevel@tonic-gate 		case PRIVSYS_SETPPRIV:
51867c478bd9Sstevel@tonic-gate 		case PRIVSYS_GETPPRIV:
51877c478bd9Sstevel@tonic-gate 			if (!err)
51887c478bd9Sstevel@tonic-gate 				show_privset(pri, (long)pri->sys_args[3],
5189019c3c43Sraf 				    (size_t)pri->sys_args[4], "");
51907c478bd9Sstevel@tonic-gate 		}
51917c478bd9Sstevel@tonic-gate 		break;
51927c478bd9Sstevel@tonic-gate 	case SYS_ucredsys:
51937c478bd9Sstevel@tonic-gate 		switch (pri->sys_args[0]) {
51947c478bd9Sstevel@tonic-gate 		case UCREDSYS_UCREDGET:
51957c478bd9Sstevel@tonic-gate 		case UCREDSYS_GETPEERUCRED:
51967c478bd9Sstevel@tonic-gate 			if (err == 0)
51977c478bd9Sstevel@tonic-gate 				show_ucred(pri, (long)pri->sys_args[2]);
51987c478bd9Sstevel@tonic-gate 			break;
51997c478bd9Sstevel@tonic-gate 		}
52007c478bd9Sstevel@tonic-gate 		break;
52017c478bd9Sstevel@tonic-gate 	case SYS_bind:
52027c478bd9Sstevel@tonic-gate 	case SYS_connect:
52037c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 2)
52047c478bd9Sstevel@tonic-gate 			show_sockaddr(pri, "name", (long)pri->sys_args[1],
5205019c3c43Sraf 			    0, (long)pri->sys_args[2]);
52067c478bd9Sstevel@tonic-gate 		break;
52077c478bd9Sstevel@tonic-gate 	case SYS_sendto:
52087c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 5)
52097c478bd9Sstevel@tonic-gate 			show_sockaddr(pri, "to", (long)pri->sys_args[4], 0,
5210019c3c43Sraf 			    pri->sys_args[5]);
52117c478bd9Sstevel@tonic-gate 		break;
52127c478bd9Sstevel@tonic-gate 	case SYS_accept:
52137c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
52147c478bd9Sstevel@tonic-gate 			show_sockaddr(pri, "name", (long)pri->sys_args[1],
5215019c3c43Sraf 			    (long)pri->sys_args[2], 0);
52167c478bd9Sstevel@tonic-gate 		break;
52177c478bd9Sstevel@tonic-gate 	case SYS_getsockname:
52187c478bd9Sstevel@tonic-gate 	case SYS_getpeername:
52197c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
52207c478bd9Sstevel@tonic-gate 			show_sockaddr(pri, "name", (long)pri->sys_args[1],
5221019c3c43Sraf 			    (long)pri->sys_args[2], 0);
52227c478bd9Sstevel@tonic-gate 		break;
52237c478bd9Sstevel@tonic-gate 	case SYS_cladm:
52247c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 2)
52257c478bd9Sstevel@tonic-gate 			show_cladm(pri, pri->sys_args[0], pri->sys_args[1],
52267c478bd9Sstevel@tonic-gate 			    (long)pri->sys_args[2]);
52277c478bd9Sstevel@tonic-gate 		break;
52287c478bd9Sstevel@tonic-gate 	case SYS_recvfrom:
52297c478bd9Sstevel@tonic-gate 		if (!err && pri->sys_nargs > 5)
52307c478bd9Sstevel@tonic-gate 			show_sockaddr(pri, "from", (long)pri->sys_args[4],
5231019c3c43Sraf 			    (long)pri->sys_args[5], 0);
52327c478bd9Sstevel@tonic-gate 		break;
52337c478bd9Sstevel@tonic-gate 	case SYS_recvmsg:
52347c478bd9Sstevel@tonic-gate 		if (err)
52357c478bd9Sstevel@tonic-gate 			break;
52367c478bd9Sstevel@tonic-gate 		/* FALLTHROUGH */
52377c478bd9Sstevel@tonic-gate 	case SYS_sendmsg:
523881006e0fSja 		if (pri->sys_nargs <= 2)
52397c478bd9Sstevel@tonic-gate 			break;
52407c478bd9Sstevel@tonic-gate #ifdef _LP64
52417c478bd9Sstevel@tonic-gate 		if (lp64)
52427c478bd9Sstevel@tonic-gate 			show_msghdr(pri, pri->sys_args[1]);
52437c478bd9Sstevel@tonic-gate 		else
52447c478bd9Sstevel@tonic-gate 			show_msghdr32(pri, pri->sys_args[1]);
52457c478bd9Sstevel@tonic-gate #else
52467c478bd9Sstevel@tonic-gate 		show_msghdr(pri, pri->sys_args[1]);
52477c478bd9Sstevel@tonic-gate #endif
52487c478bd9Sstevel@tonic-gate 		break;
52497c478bd9Sstevel@tonic-gate 	case SYS_door:
52507c478bd9Sstevel@tonic-gate 		show_doors(pri);
52517c478bd9Sstevel@tonic-gate 		break;
52527c478bd9Sstevel@tonic-gate 	case SYS_sendfilev:
52537c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs != 5)
52547c478bd9Sstevel@tonic-gate 			break;
52557c478bd9Sstevel@tonic-gate 
52567c478bd9Sstevel@tonic-gate 		if (pri->sys_args[0] == SENDFILEV) {
52577c478bd9Sstevel@tonic-gate 			show_sendfilevec(pri, (int)pri->sys_args[1],
5258019c3c43Sraf 			    (sendfilevec_t *)pri->sys_args[2],
5259019c3c43Sraf 			    (int)pri->sys_args[3]);
52607c478bd9Sstevel@tonic-gate 		} else if (pri->sys_args[0] == SENDFILEV64) {
52617c478bd9Sstevel@tonic-gate 			show_sendfilevec64(pri, (int)pri->sys_args[1],
5262019c3c43Sraf 			    (sendfilevec64_t *)pri->sys_args[2],
5263019c3c43Sraf 			    (int)pri->sys_args[3]);
52647c478bd9Sstevel@tonic-gate 		}
52657c478bd9Sstevel@tonic-gate 		break;
52667c478bd9Sstevel@tonic-gate 	case SYS_memcntl:
52677c478bd9Sstevel@tonic-gate 		show_memcntl(pri);
52687c478bd9Sstevel@tonic-gate 		break;
52697c478bd9Sstevel@tonic-gate 	case SYS_lwp_park:
527047eb4d1eSsl 		/*
527147eb4d1eSsl 		 * subcode 0: lwp_park(timespec_t *, id_t)
527247eb4d1eSsl 		 * subcode 4: lwp_set_park(timespec_t *, id_t)
527347eb4d1eSsl 		 */
527447eb4d1eSsl 		if (pri->sys_nargs > 1 &&
527547eb4d1eSsl 		    (pri->sys_args[0] == 0 || pri->sys_args[0] == 4))
52767c478bd9Sstevel@tonic-gate 			show_timestruc(pri, (long)pri->sys_args[1], "timeout");
52777c478bd9Sstevel@tonic-gate 		/* subcode 2: lwp_unpark_all(id_t *, int) */
52787c478bd9Sstevel@tonic-gate 		if (pri->sys_nargs > 2 && pri->sys_args[0] == 2)
52797c478bd9Sstevel@tonic-gate 			show_ids(pri, (long)pri->sys_args[1],
528047eb4d1eSsl 			    (int)pri->sys_args[2]);
52817c478bd9Sstevel@tonic-gate 		break;
52827c478bd9Sstevel@tonic-gate 	case SYS_ntp_gettime:
52837c478bd9Sstevel@tonic-gate 		if (!err)
52847c478bd9Sstevel@tonic-gate 			show_ntp_gettime(pri);
52857c478bd9Sstevel@tonic-gate 		break;
52867c478bd9Sstevel@tonic-gate 	case SYS_ntp_adjtime:
52877c478bd9Sstevel@tonic-gate 		if (!err)
52887c478bd9Sstevel@tonic-gate 			show_ntp_adjtime(pri);
52897c478bd9Sstevel@tonic-gate 		break;
52907c478bd9Sstevel@tonic-gate 	case SYS_rusagesys:
52917c478bd9Sstevel@tonic-gate 		if (!err)
52927c478bd9Sstevel@tonic-gate 			if (pri->sys_args[0] == _RUSAGESYS_GETRUSAGE) {
52937c478bd9Sstevel@tonic-gate #ifdef _LP64
52947c478bd9Sstevel@tonic-gate 				if (!lp64)
5295019c3c43Sraf 					show_getrusage32(pri->sys_args[1]);
52967c478bd9Sstevel@tonic-gate 				else
52977c478bd9Sstevel@tonic-gate #endif
5298019c3c43Sraf 					show_getrusage(pri->sys_args[1]);
52997c478bd9Sstevel@tonic-gate 			}
53007c478bd9Sstevel@tonic-gate 		break;
53017c478bd9Sstevel@tonic-gate 	case SYS_port:
53027c478bd9Sstevel@tonic-gate 		show_ports(pri);
53037c478bd9Sstevel@tonic-gate 		break;
5304821c4a97Sdp 	case SYS_zone:
5305821c4a97Sdp 		show_zones(pri);
5306821c4a97Sdp 		break;
5307aa4a4f3bSnf 	case SYS_rctlsys:
5308aa4a4f3bSnf 		show_rctls(pri);
5309aa4a4f3bSnf 		break;
53103b862e9aSRoger A. Faulkner 	case SYS_utimesys:
53113b862e9aSRoger A. Faulkner 		show_utimesys(pri);
53123b862e9aSRoger A. Faulkner 		break;
53137c478bd9Sstevel@tonic-gate 	}
53147c478bd9Sstevel@tonic-gate }
5315