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 5*2caf0dcdSrshoaib * Common Development and Distribution License (the "License"). 6*2caf0dcdSrshoaib * 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 */ 21*2caf0dcdSrshoaib 227c478bd9Sstevel@tonic-gate /* 23*2caf0dcdSrshoaib * Copyright 2006 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 317c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate #define _SYSCALL32 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate #include <stdio.h> 367c478bd9Sstevel@tonic-gate #include <stdlib.h> 377c478bd9Sstevel@tonic-gate #include <unistd.h> 387c478bd9Sstevel@tonic-gate #include <ctype.h> 397c478bd9Sstevel@tonic-gate #include <sys/types.h> 407c478bd9Sstevel@tonic-gate #include <sys/mman.h> 417c478bd9Sstevel@tonic-gate #include <libproc.h> 427c478bd9Sstevel@tonic-gate #include <string.h> 437c478bd9Sstevel@tonic-gate #include <limits.h> 447c478bd9Sstevel@tonic-gate #include <sys/statfs.h> 457c478bd9Sstevel@tonic-gate #include <sys/times.h> 467c478bd9Sstevel@tonic-gate #include <sys/timex.h> 477c478bd9Sstevel@tonic-gate #include <sys/utssys.h> 487c478bd9Sstevel@tonic-gate #include <sys/utsname.h> 497c478bd9Sstevel@tonic-gate #include <sys/ipc.h> 507c478bd9Sstevel@tonic-gate #include <sys/ipc_impl.h> 517c478bd9Sstevel@tonic-gate #include <sys/msg.h> 527c478bd9Sstevel@tonic-gate #include <sys/msg_impl.h> 537c478bd9Sstevel@tonic-gate #include <sys/sem.h> 547c478bd9Sstevel@tonic-gate #include <sys/sem_impl.h> 557c478bd9Sstevel@tonic-gate #include <sys/shm.h> 567c478bd9Sstevel@tonic-gate #include <sys/shm_impl.h> 577c478bd9Sstevel@tonic-gate #include <sys/dirent.h> 587c478bd9Sstevel@tonic-gate #include <sys/utime.h> 597c478bd9Sstevel@tonic-gate #include <ustat.h> 607c478bd9Sstevel@tonic-gate #include <fcntl.h> 617c478bd9Sstevel@tonic-gate #include <time.h> 627c478bd9Sstevel@tonic-gate #include <sys/termios.h> 637c478bd9Sstevel@tonic-gate #include <sys/termiox.h> 647c478bd9Sstevel@tonic-gate #include <sys/termio.h> 657c478bd9Sstevel@tonic-gate #include <sys/ttold.h> 667c478bd9Sstevel@tonic-gate #include <sys/jioctl.h> 677c478bd9Sstevel@tonic-gate #include <sys/filio.h> 687c478bd9Sstevel@tonic-gate #include <stropts.h> 697c478bd9Sstevel@tonic-gate #include <poll.h> 707c478bd9Sstevel@tonic-gate #include <sys/uio.h> 717c478bd9Sstevel@tonic-gate #include <sys/resource.h> 727c478bd9Sstevel@tonic-gate #include <sys/statvfs.h> 737c478bd9Sstevel@tonic-gate #include <sys/time.h> 747c478bd9Sstevel@tonic-gate #include <sys/aio.h> 757c478bd9Sstevel@tonic-gate #include <sys/socket.h> 767c478bd9Sstevel@tonic-gate #include <netinet/in.h> 777c478bd9Sstevel@tonic-gate #include <sys/un.h> 787c478bd9Sstevel@tonic-gate #include <sys/byteorder.h> 797c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 807c478bd9Sstevel@tonic-gate #include <sys/audioio.h> 817c478bd9Sstevel@tonic-gate #include <sys/cladm.h> 827c478bd9Sstevel@tonic-gate #include <sys/synch.h> 837c478bd9Sstevel@tonic-gate #include <sys/synch32.h> 847c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 857c478bd9Sstevel@tonic-gate #include <sys/sendfile.h> 867c478bd9Sstevel@tonic-gate #include <priv.h> 877c478bd9Sstevel@tonic-gate #include <ucred.h> 887c478bd9Sstevel@tonic-gate #include <sys/ucred.h> 897c478bd9Sstevel@tonic-gate #include <sys/port_impl.h> 90821c4a97Sdp #include <sys/zone.h> 91821c4a97Sdp #include <sys/priv_impl.h> 92821c4a97Sdp #include <sys/priv.h> 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate #include "ramdata.h" 957c478bd9Sstevel@tonic-gate #include "systable.h" 967c478bd9Sstevel@tonic-gate #include "proto.h" 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate void show_sigset(private_t *, long, const char *); 997c478bd9Sstevel@tonic-gate void show_ioctl(private_t *, int, long); 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate void 1027c478bd9Sstevel@tonic-gate prtime(private_t *pri, const char *name, time_t value) 1037c478bd9Sstevel@tonic-gate { 1047c478bd9Sstevel@tonic-gate char str[80]; 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate (void) strftime(str, sizeof (str), "%b %e %H:%M:%S %Z %Y", 1077c478bd9Sstevel@tonic-gate localtime(&value)); 1087c478bd9Sstevel@tonic-gate (void) printf("%s\t%s%s [ %llu ]\n", 1097c478bd9Sstevel@tonic-gate pri->pname, 1107c478bd9Sstevel@tonic-gate name, 1117c478bd9Sstevel@tonic-gate str, 1127c478bd9Sstevel@tonic-gate (longlong_t)value); 1137c478bd9Sstevel@tonic-gate } 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate void 1167c478bd9Sstevel@tonic-gate prtimestruc(private_t *pri, const char *name, timestruc_t *value) 1177c478bd9Sstevel@tonic-gate { 1187c478bd9Sstevel@tonic-gate prtime(pri, name, value->tv_sec); 1197c478bd9Sstevel@tonic-gate } 1207c478bd9Sstevel@tonic-gate 1217c478bd9Sstevel@tonic-gate void 1227c478bd9Sstevel@tonic-gate show_utime(private_t *pri) 1237c478bd9Sstevel@tonic-gate { 1247c478bd9Sstevel@tonic-gate long offset; 1257c478bd9Sstevel@tonic-gate struct utimbuf utimbuf; 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 2 || (offset = pri->sys_args[1]) == NULL) 1287c478bd9Sstevel@tonic-gate return; 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 1317c478bd9Sstevel@tonic-gate if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset) 1327c478bd9Sstevel@tonic-gate != sizeof (utimbuf)) 1337c478bd9Sstevel@tonic-gate return; 1347c478bd9Sstevel@tonic-gate } else { 1357c478bd9Sstevel@tonic-gate struct utimbuf32 utimbuf32; 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset) 1387c478bd9Sstevel@tonic-gate != sizeof (utimbuf32)) 1397c478bd9Sstevel@tonic-gate return; 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate utimbuf.actime = (time_t)utimbuf32.actime; 1427c478bd9Sstevel@tonic-gate utimbuf.modtime = (time_t)utimbuf32.modtime; 1437c478bd9Sstevel@tonic-gate } 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate /* print access and modification times */ 1467c478bd9Sstevel@tonic-gate prtime(pri, "atime: ", utimbuf.actime); 1477c478bd9Sstevel@tonic-gate prtime(pri, "mtime: ", utimbuf.modtime); 1487c478bd9Sstevel@tonic-gate } 1497c478bd9Sstevel@tonic-gate 1507c478bd9Sstevel@tonic-gate void 1517c478bd9Sstevel@tonic-gate show_utimes(private_t *pri) 1527c478bd9Sstevel@tonic-gate { 1537c478bd9Sstevel@tonic-gate long offset; 1547c478bd9Sstevel@tonic-gate struct { 1557c478bd9Sstevel@tonic-gate struct timeval atime; 1567c478bd9Sstevel@tonic-gate struct timeval mtime; 1577c478bd9Sstevel@tonic-gate } utimbuf; 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 2 || (offset = pri->sys_args[1]) == NULL) 1607c478bd9Sstevel@tonic-gate return; 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 1637c478bd9Sstevel@tonic-gate if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset) 1647c478bd9Sstevel@tonic-gate != sizeof (utimbuf)) 1657c478bd9Sstevel@tonic-gate return; 1667c478bd9Sstevel@tonic-gate } else { 1677c478bd9Sstevel@tonic-gate struct { 1687c478bd9Sstevel@tonic-gate struct timeval32 atime; 1697c478bd9Sstevel@tonic-gate struct timeval32 mtime; 1707c478bd9Sstevel@tonic-gate } utimbuf32; 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset) 1737c478bd9Sstevel@tonic-gate != sizeof (utimbuf32)) 1747c478bd9Sstevel@tonic-gate return; 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate TIMEVAL32_TO_TIMEVAL(&utimbuf.atime, &utimbuf32.atime); 1777c478bd9Sstevel@tonic-gate TIMEVAL32_TO_TIMEVAL(&utimbuf.mtime, &utimbuf32.mtime); 1787c478bd9Sstevel@tonic-gate } 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate /* print access and modification times */ 1817c478bd9Sstevel@tonic-gate prtime(pri, "atime: ", utimbuf.atime.tv_sec); 1827c478bd9Sstevel@tonic-gate prtime(pri, "mtime: ", utimbuf.mtime.tv_sec); 1837c478bd9Sstevel@tonic-gate } 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate void 1867c478bd9Sstevel@tonic-gate show_timeofday(private_t *pri) 1877c478bd9Sstevel@tonic-gate { 1887c478bd9Sstevel@tonic-gate struct timeval tod; 1897c478bd9Sstevel@tonic-gate long offset; 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL) 1927c478bd9Sstevel@tonic-gate return; 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 1957c478bd9Sstevel@tonic-gate if (Pread(Proc, &tod, sizeof (tod), offset) 1967c478bd9Sstevel@tonic-gate != sizeof (tod)) 1977c478bd9Sstevel@tonic-gate return; 1987c478bd9Sstevel@tonic-gate } else { 1997c478bd9Sstevel@tonic-gate struct timeval32 tod32; 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate if (Pread(Proc, &tod32, sizeof (tod32), offset) 2027c478bd9Sstevel@tonic-gate != sizeof (tod32)) 2037c478bd9Sstevel@tonic-gate return; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate TIMEVAL32_TO_TIMEVAL(&tod, &tod32); 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate prtime(pri, "time: ", tod.tv_sec); 2097c478bd9Sstevel@tonic-gate } 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate void 2127c478bd9Sstevel@tonic-gate show_itimerval(private_t *pri, long offset, const char *name) 2137c478bd9Sstevel@tonic-gate { 2147c478bd9Sstevel@tonic-gate struct itimerval itimerval; 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate if (offset == NULL) 2177c478bd9Sstevel@tonic-gate return; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 2207c478bd9Sstevel@tonic-gate if (Pread(Proc, &itimerval, sizeof (itimerval), offset) 2217c478bd9Sstevel@tonic-gate != sizeof (itimerval)) 2227c478bd9Sstevel@tonic-gate return; 2237c478bd9Sstevel@tonic-gate } else { 2247c478bd9Sstevel@tonic-gate struct itimerval32 itimerval32; 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate if (Pread(Proc, &itimerval32, sizeof (itimerval32), offset) 2277c478bd9Sstevel@tonic-gate != sizeof (itimerval32)) 2287c478bd9Sstevel@tonic-gate return; 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate ITIMERVAL32_TO_ITIMERVAL(&itimerval, &itimerval32); 2317c478bd9Sstevel@tonic-gate } 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate (void) printf( 2347c478bd9Sstevel@tonic-gate "%s\t%s: interval: %4ld.%6.6ld sec value: %4ld.%6.6ld sec\n", 2357c478bd9Sstevel@tonic-gate pri->pname, 2367c478bd9Sstevel@tonic-gate name, 2377c478bd9Sstevel@tonic-gate itimerval.it_interval.tv_sec, 2387c478bd9Sstevel@tonic-gate itimerval.it_interval.tv_usec, 2397c478bd9Sstevel@tonic-gate itimerval.it_value.tv_sec, 2407c478bd9Sstevel@tonic-gate itimerval.it_value.tv_usec); 2417c478bd9Sstevel@tonic-gate } 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate void 2447c478bd9Sstevel@tonic-gate show_timeval(private_t *pri, long offset, const char *name) 2457c478bd9Sstevel@tonic-gate { 2467c478bd9Sstevel@tonic-gate struct timeval timeval; 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate if (offset == NULL) 2497c478bd9Sstevel@tonic-gate return; 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 2527c478bd9Sstevel@tonic-gate if (Pread(Proc, &timeval, sizeof (timeval), offset) 2537c478bd9Sstevel@tonic-gate != sizeof (timeval)) 2547c478bd9Sstevel@tonic-gate return; 2557c478bd9Sstevel@tonic-gate } else { 2567c478bd9Sstevel@tonic-gate struct timeval32 timeval32; 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate if (Pread(Proc, &timeval32, sizeof (timeval32), offset) 2597c478bd9Sstevel@tonic-gate != sizeof (timeval32)) 2607c478bd9Sstevel@tonic-gate return; 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate TIMEVAL32_TO_TIMEVAL(&timeval, &timeval32); 2637c478bd9Sstevel@tonic-gate } 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate (void) printf( 2667c478bd9Sstevel@tonic-gate "%s\t%s: %ld.%6.6ld sec\n", 2677c478bd9Sstevel@tonic-gate pri->pname, 2687c478bd9Sstevel@tonic-gate name, 2697c478bd9Sstevel@tonic-gate timeval.tv_sec, 2707c478bd9Sstevel@tonic-gate timeval.tv_usec); 2717c478bd9Sstevel@tonic-gate } 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate void 2747c478bd9Sstevel@tonic-gate show_timestruc(private_t *pri, long offset, const char *name) 2757c478bd9Sstevel@tonic-gate { 2767c478bd9Sstevel@tonic-gate timestruc_t timestruc; 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate if (offset == NULL) 2797c478bd9Sstevel@tonic-gate return; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 2827c478bd9Sstevel@tonic-gate if (Pread(Proc, ×truc, sizeof (timestruc), offset) 2837c478bd9Sstevel@tonic-gate != sizeof (timestruc)) 2847c478bd9Sstevel@tonic-gate return; 2857c478bd9Sstevel@tonic-gate } else { 2867c478bd9Sstevel@tonic-gate timestruc32_t timestruc32; 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate if (Pread(Proc, ×truc32, sizeof (timestruc32), offset) 2897c478bd9Sstevel@tonic-gate != sizeof (timestruc32)) 2907c478bd9Sstevel@tonic-gate return; 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate TIMESPEC32_TO_TIMESPEC(×truc, ×truc32); 2937c478bd9Sstevel@tonic-gate } 2947c478bd9Sstevel@tonic-gate 2957c478bd9Sstevel@tonic-gate (void) printf( 2967c478bd9Sstevel@tonic-gate "%s\t%s: %ld.%9.9ld sec\n", 2977c478bd9Sstevel@tonic-gate pri->pname, 2987c478bd9Sstevel@tonic-gate name, 2997c478bd9Sstevel@tonic-gate timestruc.tv_sec, 3007c478bd9Sstevel@tonic-gate timestruc.tv_nsec); 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate void 3047c478bd9Sstevel@tonic-gate show_stime(private_t *pri) 3057c478bd9Sstevel@tonic-gate { 3067c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 1) { 3077c478bd9Sstevel@tonic-gate /* print new system time */ 3087c478bd9Sstevel@tonic-gate prtime(pri, "systime = ", (time_t)pri->sys_args[0]); 3097c478bd9Sstevel@tonic-gate } 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate void 3137c478bd9Sstevel@tonic-gate show_times(private_t *pri) 3147c478bd9Sstevel@tonic-gate { 3157c478bd9Sstevel@tonic-gate long hz = sysconf(_SC_CLK_TCK); 3167c478bd9Sstevel@tonic-gate long offset; 3177c478bd9Sstevel@tonic-gate struct tms tms; 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL) 3207c478bd9Sstevel@tonic-gate return; 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 3237c478bd9Sstevel@tonic-gate if (Pread(Proc, &tms, sizeof (tms), offset) 3247c478bd9Sstevel@tonic-gate != sizeof (tms)) 3257c478bd9Sstevel@tonic-gate return; 3267c478bd9Sstevel@tonic-gate } else { 3277c478bd9Sstevel@tonic-gate struct tms32 tms32; 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate if (Pread(Proc, &tms32, sizeof (tms32), offset) 3307c478bd9Sstevel@tonic-gate != sizeof (tms32)) 3317c478bd9Sstevel@tonic-gate return; 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate /* 3347c478bd9Sstevel@tonic-gate * This looks a bit odd (since the values are actually 3357c478bd9Sstevel@tonic-gate * signed), but we need to suppress sign extension to 3367c478bd9Sstevel@tonic-gate * preserve compatibility (we've always printed these 3377c478bd9Sstevel@tonic-gate * numbers as unsigned quantities). 3387c478bd9Sstevel@tonic-gate */ 3397c478bd9Sstevel@tonic-gate tms.tms_utime = (unsigned)tms32.tms_utime; 3407c478bd9Sstevel@tonic-gate tms.tms_stime = (unsigned)tms32.tms_stime; 3417c478bd9Sstevel@tonic-gate tms.tms_cutime = (unsigned)tms32.tms_cutime; 3427c478bd9Sstevel@tonic-gate tms.tms_cstime = (unsigned)tms32.tms_cstime; 3437c478bd9Sstevel@tonic-gate } 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate (void) printf( 3467c478bd9Sstevel@tonic-gate "%s\tutim=%-6lu stim=%-6lu cutim=%-6lu cstim=%-6lu (HZ=%ld)\n", 3477c478bd9Sstevel@tonic-gate pri->pname, 3487c478bd9Sstevel@tonic-gate tms.tms_utime, 3497c478bd9Sstevel@tonic-gate tms.tms_stime, 3507c478bd9Sstevel@tonic-gate tms.tms_cutime, 3517c478bd9Sstevel@tonic-gate tms.tms_cstime, 3527c478bd9Sstevel@tonic-gate hz); 3537c478bd9Sstevel@tonic-gate } 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate void 3567c478bd9Sstevel@tonic-gate show_uname(private_t *pri, long offset) 3577c478bd9Sstevel@tonic-gate { 3587c478bd9Sstevel@tonic-gate /* 3597c478bd9Sstevel@tonic-gate * Old utsname buffer (no longer accessible in <sys/utsname.h>). 3607c478bd9Sstevel@tonic-gate */ 3617c478bd9Sstevel@tonic-gate struct { 3627c478bd9Sstevel@tonic-gate char sysname[9]; 3637c478bd9Sstevel@tonic-gate char nodename[9]; 3647c478bd9Sstevel@tonic-gate char release[9]; 3657c478bd9Sstevel@tonic-gate char version[9]; 3667c478bd9Sstevel@tonic-gate char machine[9]; 3677c478bd9Sstevel@tonic-gate } ubuf; 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate if (offset != NULL && 3707c478bd9Sstevel@tonic-gate Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 3717c478bd9Sstevel@tonic-gate (void) printf( 3727c478bd9Sstevel@tonic-gate "%s\tsys=%-9.9snod=%-9.9srel=%-9.9sver=%-9.9smch=%.9s\n", 3737c478bd9Sstevel@tonic-gate pri->pname, 3747c478bd9Sstevel@tonic-gate ubuf.sysname, 3757c478bd9Sstevel@tonic-gate ubuf.nodename, 3767c478bd9Sstevel@tonic-gate ubuf.release, 3777c478bd9Sstevel@tonic-gate ubuf.version, 3787c478bd9Sstevel@tonic-gate ubuf.machine); 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate } 3817c478bd9Sstevel@tonic-gate 3827c478bd9Sstevel@tonic-gate /* XX64 -- definition of 'struct ustat' is strange -- check out the defn */ 3837c478bd9Sstevel@tonic-gate void 3847c478bd9Sstevel@tonic-gate show_ustat(private_t *pri, long offset) 3857c478bd9Sstevel@tonic-gate { 3867c478bd9Sstevel@tonic-gate struct ustat ubuf; 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate if (offset != NULL && 3897c478bd9Sstevel@tonic-gate Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 3907c478bd9Sstevel@tonic-gate (void) printf( 3917c478bd9Sstevel@tonic-gate "%s\ttfree=%-6ld tinode=%-5lu fname=%-6.6s fpack=%-.6s\n", 3927c478bd9Sstevel@tonic-gate pri->pname, 3937c478bd9Sstevel@tonic-gate ubuf.f_tfree, 3947c478bd9Sstevel@tonic-gate ubuf.f_tinode, 3957c478bd9Sstevel@tonic-gate ubuf.f_fname, 3967c478bd9Sstevel@tonic-gate ubuf.f_fpack); 3977c478bd9Sstevel@tonic-gate } 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate 4007c478bd9Sstevel@tonic-gate #ifdef _LP64 4017c478bd9Sstevel@tonic-gate void 4027c478bd9Sstevel@tonic-gate show_ustat32(private_t *pri, long offset) 4037c478bd9Sstevel@tonic-gate { 4047c478bd9Sstevel@tonic-gate struct ustat32 ubuf; 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate if (offset != NULL && 4077c478bd9Sstevel@tonic-gate Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 4087c478bd9Sstevel@tonic-gate (void) printf( 4097c478bd9Sstevel@tonic-gate "%s\ttfree=%-6d tinode=%-5u fname=%-6.6s fpack=%-.6s\n", 4107c478bd9Sstevel@tonic-gate pri->pname, 4117c478bd9Sstevel@tonic-gate ubuf.f_tfree, 4127c478bd9Sstevel@tonic-gate ubuf.f_tinode, 4137c478bd9Sstevel@tonic-gate ubuf.f_fname, 4147c478bd9Sstevel@tonic-gate ubuf.f_fpack); 4157c478bd9Sstevel@tonic-gate } 4167c478bd9Sstevel@tonic-gate } 4177c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate void 4207c478bd9Sstevel@tonic-gate show_fusers(private_t *pri, long offset, long nproc) 4217c478bd9Sstevel@tonic-gate { 4227c478bd9Sstevel@tonic-gate f_user_t fubuf; 4237c478bd9Sstevel@tonic-gate int serial = (nproc > 4); 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate if (offset == NULL) 4267c478bd9Sstevel@tonic-gate return; 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 4297c478bd9Sstevel@tonic-gate if (serial) 4307c478bd9Sstevel@tonic-gate Eserialize(); 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate while (nproc > 0 && 4337c478bd9Sstevel@tonic-gate Pread(Proc, &fubuf, sizeof (fubuf), offset) == sizeof (fubuf)) { 4347c478bd9Sstevel@tonic-gate (void) printf("%s\tpid=%-5d uid=%-5d flags=%s\n", 4357c478bd9Sstevel@tonic-gate pri->pname, 4367c478bd9Sstevel@tonic-gate (int)fubuf.fu_pid, 4377c478bd9Sstevel@tonic-gate (int)fubuf.fu_uid, 4387c478bd9Sstevel@tonic-gate fuflags(pri, fubuf.fu_flags)); 4397c478bd9Sstevel@tonic-gate nproc--; 4407c478bd9Sstevel@tonic-gate offset += sizeof (fubuf); 4417c478bd9Sstevel@tonic-gate } 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 4447c478bd9Sstevel@tonic-gate if (serial) 4457c478bd9Sstevel@tonic-gate Xserialize(); 4467c478bd9Sstevel@tonic-gate } 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate void 4497c478bd9Sstevel@tonic-gate show_utssys(private_t *pri, long r0) 4507c478bd9Sstevel@tonic-gate { 4517c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 3) { 4527c478bd9Sstevel@tonic-gate switch (pri->sys_args[2]) { 4537c478bd9Sstevel@tonic-gate case UTS_UNAME: 4547c478bd9Sstevel@tonic-gate show_uname(pri, (long)pri->sys_args[0]); 4557c478bd9Sstevel@tonic-gate break; 4567c478bd9Sstevel@tonic-gate case UTS_USTAT: 4577c478bd9Sstevel@tonic-gate show_ustat(pri, (long)pri->sys_args[0]); 4587c478bd9Sstevel@tonic-gate break; 4597c478bd9Sstevel@tonic-gate case UTS_FUSERS: 4607c478bd9Sstevel@tonic-gate show_fusers(pri, (long)pri->sys_args[3], r0); 4617c478bd9Sstevel@tonic-gate break; 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate #ifdef _LP64 4677c478bd9Sstevel@tonic-gate void 4687c478bd9Sstevel@tonic-gate show_utssys32(private_t *pri, long r0) 4697c478bd9Sstevel@tonic-gate { 4707c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 3) { 4717c478bd9Sstevel@tonic-gate switch (pri->sys_args[2]) { 4727c478bd9Sstevel@tonic-gate case UTS_UNAME: 4737c478bd9Sstevel@tonic-gate show_uname(pri, (long)pri->sys_args[0]); 4747c478bd9Sstevel@tonic-gate break; 4757c478bd9Sstevel@tonic-gate case UTS_USTAT: 4767c478bd9Sstevel@tonic-gate show_ustat32(pri, (long)pri->sys_args[0]); 4777c478bd9Sstevel@tonic-gate break; 4787c478bd9Sstevel@tonic-gate case UTS_FUSERS: 4797c478bd9Sstevel@tonic-gate show_fusers(pri, (long)pri->sys_args[3], r0); 4807c478bd9Sstevel@tonic-gate break; 4817c478bd9Sstevel@tonic-gate } 4827c478bd9Sstevel@tonic-gate } 4837c478bd9Sstevel@tonic-gate } 4847c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate void 4877c478bd9Sstevel@tonic-gate show_cladm(private_t *pri, int code, int function, long offset) 4887c478bd9Sstevel@tonic-gate { 4897c478bd9Sstevel@tonic-gate int arg; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate switch (code) { 4927c478bd9Sstevel@tonic-gate case CL_INITIALIZE: 4937c478bd9Sstevel@tonic-gate switch (function) { 4947c478bd9Sstevel@tonic-gate case CL_GET_BOOTFLAG: 4957c478bd9Sstevel@tonic-gate if (Pread(Proc, &arg, sizeof (arg), offset) 4967c478bd9Sstevel@tonic-gate == sizeof (arg)) { 4977c478bd9Sstevel@tonic-gate if (arg & CLUSTER_CONFIGURED) 4987c478bd9Sstevel@tonic-gate (void) printf("%s\tbootflags=" 4997c478bd9Sstevel@tonic-gate "CLUSTER_CONFIGURED", pri->pname); 5007c478bd9Sstevel@tonic-gate if (arg & CLUSTER_BOOTED) 5017c478bd9Sstevel@tonic-gate (void) printf("|CLUSTER_BOOTED\n"); 5027c478bd9Sstevel@tonic-gate } 5037c478bd9Sstevel@tonic-gate break; 5047c478bd9Sstevel@tonic-gate } 5057c478bd9Sstevel@tonic-gate break; 5067c478bd9Sstevel@tonic-gate case CL_CONFIG: 5077c478bd9Sstevel@tonic-gate switch (function) { 5087c478bd9Sstevel@tonic-gate case CL_NODEID: 5097c478bd9Sstevel@tonic-gate case CL_HIGHEST_NODEID: 5107c478bd9Sstevel@tonic-gate if (Pread(Proc, &arg, sizeof (arg), offset) 5117c478bd9Sstevel@tonic-gate == sizeof (arg)) 5127c478bd9Sstevel@tonic-gate (void) printf("%s\tnodeid=%d\n", 5137c478bd9Sstevel@tonic-gate pri->pname, arg); 5147c478bd9Sstevel@tonic-gate } 5157c478bd9Sstevel@tonic-gate break; 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate #define ALL_LOCK_TYPES \ 5207c478bd9Sstevel@tonic-gate (USYNC_PROCESS|LOCK_ERRORCHECK|LOCK_RECURSIVE|USYNC_PROCESS_ROBUST|\ 5217c478bd9Sstevel@tonic-gate LOCK_PRIO_INHERIT|LOCK_PRIO_PROTECT|LOCK_ROBUST_NP) 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate /* return cv and mutex types */ 5247c478bd9Sstevel@tonic-gate const char * 5257c478bd9Sstevel@tonic-gate synch_type(private_t *pri, uint_t type) 5267c478bd9Sstevel@tonic-gate { 5277c478bd9Sstevel@tonic-gate char *str = pri->code_buf; 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate if (type & USYNC_PROCESS) 5307c478bd9Sstevel@tonic-gate (void) strcpy(str, "USYNC_PROCESS"); 5317c478bd9Sstevel@tonic-gate else 5327c478bd9Sstevel@tonic-gate (void) strcpy(str, "USYNC_THREAD"); 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate if (type & LOCK_ERRORCHECK) 5357c478bd9Sstevel@tonic-gate (void) strcat(str, "|LOCK_ERRORCHECK"); 5367c478bd9Sstevel@tonic-gate if (type & LOCK_RECURSIVE) 5377c478bd9Sstevel@tonic-gate (void) strcat(str, "|LOCK_RECURSIVE"); 5387c478bd9Sstevel@tonic-gate if (type & USYNC_PROCESS_ROBUST) 5397c478bd9Sstevel@tonic-gate (void) strcat(str, "|USYNC_PROCESS_ROBUST"); 5407c478bd9Sstevel@tonic-gate if (type & LOCK_PRIO_INHERIT) 5417c478bd9Sstevel@tonic-gate (void) strcat(str, "|LOCK_PRIO_INHERIT"); 5427c478bd9Sstevel@tonic-gate if (type & LOCK_PRIO_PROTECT) 5437c478bd9Sstevel@tonic-gate (void) strcat(str, "|LOCK_PRIO_PROTECT"); 5447c478bd9Sstevel@tonic-gate if (type & LOCK_ROBUST_NP) 5457c478bd9Sstevel@tonic-gate (void) strcat(str, "|LOCK_ROBUST_NP"); 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate if ((type &= ~ALL_LOCK_TYPES) != 0) 5487c478bd9Sstevel@tonic-gate (void) sprintf(str + strlen(str), "|0x%.4X", type); 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate return ((const char *)str); 5517c478bd9Sstevel@tonic-gate } 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate void 5547c478bd9Sstevel@tonic-gate show_mutex(private_t *pri, long offset) 5557c478bd9Sstevel@tonic-gate { 5567c478bd9Sstevel@tonic-gate lwp_mutex_t mutex; 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate if (Pread(Proc, &mutex, sizeof (mutex), offset) == sizeof (mutex)) { 5597c478bd9Sstevel@tonic-gate (void) printf("%s\tmutex type: %s\n", 5607c478bd9Sstevel@tonic-gate pri->pname, 5617c478bd9Sstevel@tonic-gate synch_type(pri, mutex.mutex_type)); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate } 5647c478bd9Sstevel@tonic-gate 5657c478bd9Sstevel@tonic-gate void 5667c478bd9Sstevel@tonic-gate show_condvar(private_t *pri, long offset) 5677c478bd9Sstevel@tonic-gate { 5687c478bd9Sstevel@tonic-gate lwp_cond_t condvar; 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate if (Pread(Proc, &condvar, sizeof (condvar), offset) 5717c478bd9Sstevel@tonic-gate == sizeof (condvar)) { 5727c478bd9Sstevel@tonic-gate (void) printf("%s\tcondvar type: %s\n", 5737c478bd9Sstevel@tonic-gate pri->pname, 5747c478bd9Sstevel@tonic-gate synch_type(pri, condvar.cond_type)); 5757c478bd9Sstevel@tonic-gate } 5767c478bd9Sstevel@tonic-gate } 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate void 5797c478bd9Sstevel@tonic-gate show_sema(private_t *pri, long offset) 5807c478bd9Sstevel@tonic-gate { 5817c478bd9Sstevel@tonic-gate lwp_sema_t sema; 5827c478bd9Sstevel@tonic-gate 5837c478bd9Sstevel@tonic-gate if (Pread(Proc, &sema, sizeof (sema), offset) == sizeof (sema)) { 5847c478bd9Sstevel@tonic-gate (void) printf("%s\tsema type: %s count = %u\n", 5857c478bd9Sstevel@tonic-gate pri->pname, 5867c478bd9Sstevel@tonic-gate synch_type(pri, sema.sema_type), 5877c478bd9Sstevel@tonic-gate sema.sema_count); 5887c478bd9Sstevel@tonic-gate } 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate void 5927c478bd9Sstevel@tonic-gate show_rwlock(private_t *pri, long offset) 5937c478bd9Sstevel@tonic-gate { 5947c478bd9Sstevel@tonic-gate lwp_rwlock_t rwlock; 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate if (Pread(Proc, &rwlock, sizeof (rwlock), offset) == sizeof (rwlock)) { 5977c478bd9Sstevel@tonic-gate (void) printf("%s\trwlock type: %s readers = %d\n", 5987c478bd9Sstevel@tonic-gate pri->pname, 5997c478bd9Sstevel@tonic-gate synch_type(pri, rwlock.rwlock_type), 6007c478bd9Sstevel@tonic-gate rwlock.rwlock_readers); 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate /* represent character as itself ('c') or octal (012) */ 6057c478bd9Sstevel@tonic-gate char * 6067c478bd9Sstevel@tonic-gate show_char(char *buf, int c) 6077c478bd9Sstevel@tonic-gate { 6087c478bd9Sstevel@tonic-gate const char *fmt; 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate if (c >= ' ' && c < 0177) 6117c478bd9Sstevel@tonic-gate fmt = "'%c'"; 6127c478bd9Sstevel@tonic-gate else 6137c478bd9Sstevel@tonic-gate fmt = "%.3o"; 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate (void) sprintf(buf, fmt, c&0xff); 6167c478bd9Sstevel@tonic-gate return (buf); 6177c478bd9Sstevel@tonic-gate } 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate void 6207c478bd9Sstevel@tonic-gate show_termio(private_t *pri, long offset) 6217c478bd9Sstevel@tonic-gate { 6227c478bd9Sstevel@tonic-gate struct termio termio; 6237c478bd9Sstevel@tonic-gate char cbuf[8]; 6247c478bd9Sstevel@tonic-gate int i; 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate if (Pread(Proc, &termio, sizeof (termio), offset) == sizeof (termio)) { 6277c478bd9Sstevel@tonic-gate (void) printf( 6287c478bd9Sstevel@tonic-gate "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o line=%d\n", 6297c478bd9Sstevel@tonic-gate pri->pname, 6307c478bd9Sstevel@tonic-gate termio.c_iflag, 6317c478bd9Sstevel@tonic-gate termio.c_oflag, 6327c478bd9Sstevel@tonic-gate termio.c_cflag, 6337c478bd9Sstevel@tonic-gate termio.c_lflag, 6347c478bd9Sstevel@tonic-gate termio.c_line); 6357c478bd9Sstevel@tonic-gate (void) printf("%s\t cc: ", pri->pname); 6367c478bd9Sstevel@tonic-gate for (i = 0; i < NCC; i++) 6377c478bd9Sstevel@tonic-gate (void) printf(" %s", 6387c478bd9Sstevel@tonic-gate show_char(cbuf, (int)termio.c_cc[i])); 6397c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 6407c478bd9Sstevel@tonic-gate } 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate void 6447c478bd9Sstevel@tonic-gate show_termios(private_t *pri, long offset) 6457c478bd9Sstevel@tonic-gate { 6467c478bd9Sstevel@tonic-gate struct termios termios; 6477c478bd9Sstevel@tonic-gate char cbuf[8]; 6487c478bd9Sstevel@tonic-gate int i; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate if (Pread(Proc, &termios, sizeof (termios), offset) 6517c478bd9Sstevel@tonic-gate == sizeof (termios)) { 6527c478bd9Sstevel@tonic-gate (void) printf( 6537c478bd9Sstevel@tonic-gate "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o\n", 6547c478bd9Sstevel@tonic-gate pri->pname, 6557c478bd9Sstevel@tonic-gate termios.c_iflag, 6567c478bd9Sstevel@tonic-gate termios.c_oflag, 6577c478bd9Sstevel@tonic-gate termios.c_cflag, 6587c478bd9Sstevel@tonic-gate termios.c_lflag); 6597c478bd9Sstevel@tonic-gate (void) printf("%s\t cc: ", pri->pname); 6607c478bd9Sstevel@tonic-gate for (i = 0; i < NCCS; i++) { 6617c478bd9Sstevel@tonic-gate if (i == NCC) /* show new chars on new line */ 6627c478bd9Sstevel@tonic-gate (void) printf("\n%s\t\t", pri->pname); 6637c478bd9Sstevel@tonic-gate (void) printf(" %s", 6647c478bd9Sstevel@tonic-gate show_char(cbuf, (int)termios.c_cc[i])); 6657c478bd9Sstevel@tonic-gate } 6667c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 6677c478bd9Sstevel@tonic-gate } 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate void 6717c478bd9Sstevel@tonic-gate show_termiox(private_t *pri, long offset) 6727c478bd9Sstevel@tonic-gate { 6737c478bd9Sstevel@tonic-gate struct termiox termiox; 6747c478bd9Sstevel@tonic-gate int i; 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate if (Pread(Proc, &termiox, sizeof (termiox), offset) 6777c478bd9Sstevel@tonic-gate == sizeof (termiox)) { 6787c478bd9Sstevel@tonic-gate (void) printf("%s\thflag=0%.3o cflag=0%.3o rflag=0%.3o", 6797c478bd9Sstevel@tonic-gate pri->pname, 6807c478bd9Sstevel@tonic-gate termiox.x_hflag, 6817c478bd9Sstevel@tonic-gate termiox.x_cflag, 6827c478bd9Sstevel@tonic-gate termiox.x_rflag[0]); 6837c478bd9Sstevel@tonic-gate for (i = 1; i < NFF; i++) 6847c478bd9Sstevel@tonic-gate (void) printf(",0%.3o", termiox.x_rflag[i]); 6857c478bd9Sstevel@tonic-gate (void) printf(" sflag=0%.3o\n", 6867c478bd9Sstevel@tonic-gate termiox.x_sflag); 6877c478bd9Sstevel@tonic-gate } 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate void 6917c478bd9Sstevel@tonic-gate show_sgttyb(private_t *pri, long offset) 6927c478bd9Sstevel@tonic-gate { 6937c478bd9Sstevel@tonic-gate struct sgttyb sgttyb; 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate if (Pread(Proc, &sgttyb, sizeof (sgttyb), offset) == sizeof (sgttyb)) { 6967c478bd9Sstevel@tonic-gate char erase[8]; 6977c478bd9Sstevel@tonic-gate char kill[8]; 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate (void) printf( 7007c478bd9Sstevel@tonic-gate "%s\tispeed=%-2d ospeed=%-2d erase=%s kill=%s flags=0x%.8x\n", 7017c478bd9Sstevel@tonic-gate pri->pname, 7027c478bd9Sstevel@tonic-gate sgttyb.sg_ispeed&0xff, 7037c478bd9Sstevel@tonic-gate sgttyb.sg_ospeed&0xff, 7047c478bd9Sstevel@tonic-gate show_char(erase, sgttyb.sg_erase), 7057c478bd9Sstevel@tonic-gate show_char(kill, sgttyb.sg_kill), 7067c478bd9Sstevel@tonic-gate sgttyb.sg_flags); 7077c478bd9Sstevel@tonic-gate } 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate 7107c478bd9Sstevel@tonic-gate void 7117c478bd9Sstevel@tonic-gate show_ltchars(private_t *pri, long offset) 7127c478bd9Sstevel@tonic-gate { 7137c478bd9Sstevel@tonic-gate struct ltchars ltchars; 7147c478bd9Sstevel@tonic-gate char *p; 7157c478bd9Sstevel@tonic-gate char cbuf[8]; 7167c478bd9Sstevel@tonic-gate int i; 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate if (Pread(Proc, <chars, sizeof (ltchars), offset) 7197c478bd9Sstevel@tonic-gate == sizeof (ltchars)) { 7207c478bd9Sstevel@tonic-gate (void) printf("%s\t cc: ", pri->pname); 7217c478bd9Sstevel@tonic-gate for (p = (char *)<chars, i = 0; i < sizeof (ltchars); i++) 7227c478bd9Sstevel@tonic-gate (void) printf(" %s", show_char(cbuf, (int)*p++)); 7237c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate 7277c478bd9Sstevel@tonic-gate void 7287c478bd9Sstevel@tonic-gate show_tchars(private_t *pri, long offset) 7297c478bd9Sstevel@tonic-gate { 7307c478bd9Sstevel@tonic-gate struct tchars tchars; 7317c478bd9Sstevel@tonic-gate char *p; 7327c478bd9Sstevel@tonic-gate char cbuf[8]; 7337c478bd9Sstevel@tonic-gate int i; 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate if (Pread(Proc, &tchars, sizeof (tchars), offset) == sizeof (tchars)) { 7367c478bd9Sstevel@tonic-gate (void) printf("%s\t cc: ", pri->pname); 7377c478bd9Sstevel@tonic-gate for (p = (char *)&tchars, i = 0; i < sizeof (tchars); i++) 7387c478bd9Sstevel@tonic-gate (void) printf(" %s", show_char(cbuf, (int)*p++)); 7397c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 7407c478bd9Sstevel@tonic-gate } 7417c478bd9Sstevel@tonic-gate } 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate void 7447c478bd9Sstevel@tonic-gate show_termcb(private_t *pri, long offset) 7457c478bd9Sstevel@tonic-gate { 7467c478bd9Sstevel@tonic-gate struct termcb termcb; 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate if (Pread(Proc, &termcb, sizeof (termcb), offset) == sizeof (termcb)) { 7497c478bd9Sstevel@tonic-gate (void) printf( 7507c478bd9Sstevel@tonic-gate "%s\tflgs=0%.2o termt=%d crow=%d ccol=%d vrow=%d lrow=%d\n", 7517c478bd9Sstevel@tonic-gate pri->pname, 7527c478bd9Sstevel@tonic-gate termcb.st_flgs&0xff, 7537c478bd9Sstevel@tonic-gate termcb.st_termt&0xff, 7547c478bd9Sstevel@tonic-gate termcb.st_crow&0xff, 7557c478bd9Sstevel@tonic-gate termcb.st_ccol&0xff, 7567c478bd9Sstevel@tonic-gate termcb.st_vrow&0xff, 7577c478bd9Sstevel@tonic-gate termcb.st_lrow&0xff); 7587c478bd9Sstevel@tonic-gate } 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate /* integer value pointed to by ioctl() arg */ 7627c478bd9Sstevel@tonic-gate void 7637c478bd9Sstevel@tonic-gate show_strint(private_t *pri, int code, long offset) 7647c478bd9Sstevel@tonic-gate { 7657c478bd9Sstevel@tonic-gate int val; 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) { 7687c478bd9Sstevel@tonic-gate const char *s = NULL; 7697c478bd9Sstevel@tonic-gate 7707c478bd9Sstevel@tonic-gate switch (code) { /* interpret these symbolically */ 7717c478bd9Sstevel@tonic-gate case I_GRDOPT: 7727c478bd9Sstevel@tonic-gate s = strrdopt(val); 7737c478bd9Sstevel@tonic-gate break; 7747c478bd9Sstevel@tonic-gate case I_GETSIG: 7757c478bd9Sstevel@tonic-gate s = strevents(pri, val); 7767c478bd9Sstevel@tonic-gate break; 7777c478bd9Sstevel@tonic-gate case TIOCFLUSH: 7787c478bd9Sstevel@tonic-gate s = tiocflush(pri, val); 7797c478bd9Sstevel@tonic-gate break; 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate if (s == NULL) 7837c478bd9Sstevel@tonic-gate (void) printf("%s\t0x%.8lX: %d\n", 7847c478bd9Sstevel@tonic-gate pri->pname, offset, val); 7857c478bd9Sstevel@tonic-gate else 7867c478bd9Sstevel@tonic-gate (void) printf("%s\t0x%.8lX: %s\n", 7877c478bd9Sstevel@tonic-gate pri->pname, offset, s); 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate } 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate void 7927c478bd9Sstevel@tonic-gate show_strioctl(private_t *pri, long offset) 7937c478bd9Sstevel@tonic-gate { 7947c478bd9Sstevel@tonic-gate struct strioctl strioctl; 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate if (Pread(Proc, &strioctl, sizeof (strioctl), offset) == 7977c478bd9Sstevel@tonic-gate sizeof (strioctl)) { 7987c478bd9Sstevel@tonic-gate (void) printf( 7997c478bd9Sstevel@tonic-gate "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n", 8007c478bd9Sstevel@tonic-gate pri->pname, 8017c478bd9Sstevel@tonic-gate ioctlname(pri, strioctl.ic_cmd), 8027c478bd9Sstevel@tonic-gate strioctl.ic_timout, 8037c478bd9Sstevel@tonic-gate strioctl.ic_len, 8047c478bd9Sstevel@tonic-gate (long)strioctl.ic_dp); 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate if (pri->recur++ == 0) /* avoid indefinite recursion */ 8077c478bd9Sstevel@tonic-gate show_ioctl(pri, strioctl.ic_cmd, 8087c478bd9Sstevel@tonic-gate (long)strioctl.ic_dp); 8097c478bd9Sstevel@tonic-gate --pri->recur; 8107c478bd9Sstevel@tonic-gate } 8117c478bd9Sstevel@tonic-gate } 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate #ifdef _LP64 8147c478bd9Sstevel@tonic-gate void 8157c478bd9Sstevel@tonic-gate show_strioctl32(private_t *pri, long offset) 8167c478bd9Sstevel@tonic-gate { 8177c478bd9Sstevel@tonic-gate struct strioctl32 strioctl; 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate if (Pread(Proc, &strioctl, sizeof (strioctl), offset) == 8207c478bd9Sstevel@tonic-gate sizeof (strioctl)) { 8217c478bd9Sstevel@tonic-gate (void) printf( 8227c478bd9Sstevel@tonic-gate "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n", 8237c478bd9Sstevel@tonic-gate pri->pname, 8247c478bd9Sstevel@tonic-gate ioctlname(pri, strioctl.ic_cmd), 8257c478bd9Sstevel@tonic-gate strioctl.ic_timout, 8267c478bd9Sstevel@tonic-gate strioctl.ic_len, 8277c478bd9Sstevel@tonic-gate (long)strioctl.ic_dp); 8287c478bd9Sstevel@tonic-gate 8297c478bd9Sstevel@tonic-gate if (pri->recur++ == 0) /* avoid indefinite recursion */ 8307c478bd9Sstevel@tonic-gate show_ioctl(pri, strioctl.ic_cmd, 8317c478bd9Sstevel@tonic-gate (long)strioctl.ic_dp); 8327c478bd9Sstevel@tonic-gate --pri->recur; 8337c478bd9Sstevel@tonic-gate } 8347c478bd9Sstevel@tonic-gate } 8357c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate void 8387c478bd9Sstevel@tonic-gate print_strbuf(private_t *pri, struct strbuf *sp, const char *name, int dump) 8397c478bd9Sstevel@tonic-gate { 8407c478bd9Sstevel@tonic-gate (void) printf( 8417c478bd9Sstevel@tonic-gate "%s\t%s: maxlen=%-4d len=%-4d buf=0x%.8lX", 8427c478bd9Sstevel@tonic-gate pri->pname, 8437c478bd9Sstevel@tonic-gate name, 8447c478bd9Sstevel@tonic-gate sp->maxlen, 8457c478bd9Sstevel@tonic-gate sp->len, 8467c478bd9Sstevel@tonic-gate (long)sp->buf); 8477c478bd9Sstevel@tonic-gate /* 8487c478bd9Sstevel@tonic-gate * Should we show the buffer contents? 8497c478bd9Sstevel@tonic-gate * Keyed to the '-r fds' and '-w fds' options? 8507c478bd9Sstevel@tonic-gate */ 8517c478bd9Sstevel@tonic-gate if (sp->buf == NULL || sp->len <= 0) 8527c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 8537c478bd9Sstevel@tonic-gate else { 8547c478bd9Sstevel@tonic-gate int nb = (sp->len > 8)? 8 : sp->len; 8557c478bd9Sstevel@tonic-gate char buffer[8]; 8567c478bd9Sstevel@tonic-gate char obuf[40]; 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) { 8597c478bd9Sstevel@tonic-gate (void) strcpy(obuf, ": \""); 8607c478bd9Sstevel@tonic-gate showbytes(buffer, nb, obuf+3); 8617c478bd9Sstevel@tonic-gate (void) strcat(obuf, 8627c478bd9Sstevel@tonic-gate (nb == sp->len)? 8637c478bd9Sstevel@tonic-gate (const char *)"\"" : (const char *)"\".."); 8647c478bd9Sstevel@tonic-gate (void) fputs(obuf, stdout); 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 8677c478bd9Sstevel@tonic-gate if (dump && sp->len > 8) 8687c478bd9Sstevel@tonic-gate showbuffer(pri, (long)sp->buf, (long)sp->len); 8697c478bd9Sstevel@tonic-gate } 8707c478bd9Sstevel@tonic-gate } 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate #ifdef _LP64 8737c478bd9Sstevel@tonic-gate void 8747c478bd9Sstevel@tonic-gate print_strbuf32(private_t *pri, struct strbuf32 *sp, const char *name, int dump) 8757c478bd9Sstevel@tonic-gate { 8767c478bd9Sstevel@tonic-gate (void) printf( 8777c478bd9Sstevel@tonic-gate "%s\t%s: maxlen=%-4d len=%-4d buf=0x%.8lX", 8787c478bd9Sstevel@tonic-gate pri->pname, 8797c478bd9Sstevel@tonic-gate name, 8807c478bd9Sstevel@tonic-gate sp->maxlen, 8817c478bd9Sstevel@tonic-gate sp->len, 8827c478bd9Sstevel@tonic-gate (long)sp->buf); 8837c478bd9Sstevel@tonic-gate /* 8847c478bd9Sstevel@tonic-gate * Should we show the buffer contents? 8857c478bd9Sstevel@tonic-gate * Keyed to the '-r fds' and '-w fds' options? 8867c478bd9Sstevel@tonic-gate */ 8877c478bd9Sstevel@tonic-gate if (sp->buf == NULL || sp->len <= 0) 8887c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 8897c478bd9Sstevel@tonic-gate else { 8907c478bd9Sstevel@tonic-gate int nb = (sp->len > 8)? 8 : sp->len; 8917c478bd9Sstevel@tonic-gate char buffer[8]; 8927c478bd9Sstevel@tonic-gate char obuf[40]; 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) { 8957c478bd9Sstevel@tonic-gate (void) strcpy(obuf, ": \""); 8967c478bd9Sstevel@tonic-gate showbytes(buffer, nb, obuf+3); 8977c478bd9Sstevel@tonic-gate (void) strcat(obuf, 8987c478bd9Sstevel@tonic-gate (nb == sp->len)? 8997c478bd9Sstevel@tonic-gate (const char *)"\"" : (const char *)"\".."); 9007c478bd9Sstevel@tonic-gate (void) fputs(obuf, stdout); 9017c478bd9Sstevel@tonic-gate } 9027c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 9037c478bd9Sstevel@tonic-gate if (dump && sp->len > 8) 9047c478bd9Sstevel@tonic-gate showbuffer(pri, (long)sp->buf, (long)sp->len); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate } 9077c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 9087c478bd9Sstevel@tonic-gate 9097c478bd9Sstevel@tonic-gate /* strpeek and strfdinsert flags word */ 9107c478bd9Sstevel@tonic-gate const char * 9117c478bd9Sstevel@tonic-gate strflags(private_t *pri, int flags) 9127c478bd9Sstevel@tonic-gate { 9137c478bd9Sstevel@tonic-gate const char *s; 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate switch (flags) { 9167c478bd9Sstevel@tonic-gate case 0: 9177c478bd9Sstevel@tonic-gate s = "0"; 9187c478bd9Sstevel@tonic-gate break; 9197c478bd9Sstevel@tonic-gate case RS_HIPRI: 9207c478bd9Sstevel@tonic-gate s = "RS_HIPRI"; 9217c478bd9Sstevel@tonic-gate break; 9227c478bd9Sstevel@tonic-gate default: 9237c478bd9Sstevel@tonic-gate (void) sprintf(pri->code_buf, "0x%.4X", flags); 9247c478bd9Sstevel@tonic-gate s = pri->code_buf; 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate 9277c478bd9Sstevel@tonic-gate return (s); 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate void 9317c478bd9Sstevel@tonic-gate show_strpeek(private_t *pri, long offset) 9327c478bd9Sstevel@tonic-gate { 9337c478bd9Sstevel@tonic-gate struct strpeek strpeek; 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate if (Pread(Proc, &strpeek, sizeof (strpeek), offset) 9367c478bd9Sstevel@tonic-gate == sizeof (strpeek)) { 9377c478bd9Sstevel@tonic-gate 9387c478bd9Sstevel@tonic-gate print_strbuf(pri, &strpeek.ctlbuf, "ctl", FALSE); 9397c478bd9Sstevel@tonic-gate print_strbuf(pri, &strpeek.databuf, "dat", FALSE); 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate (void) printf("%s\tflags=%s\n", 9427c478bd9Sstevel@tonic-gate pri->pname, 9437c478bd9Sstevel@tonic-gate strflags(pri, strpeek.flags)); 9447c478bd9Sstevel@tonic-gate } 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate #ifdef _LP64 9487c478bd9Sstevel@tonic-gate void 9497c478bd9Sstevel@tonic-gate show_strpeek32(private_t *pri, long offset) 9507c478bd9Sstevel@tonic-gate { 9517c478bd9Sstevel@tonic-gate struct strpeek32 strpeek; 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate if (Pread(Proc, &strpeek, sizeof (strpeek), offset) 9547c478bd9Sstevel@tonic-gate == sizeof (strpeek)) { 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate print_strbuf32(pri, &strpeek.ctlbuf, "ctl", FALSE); 9577c478bd9Sstevel@tonic-gate print_strbuf32(pri, &strpeek.databuf, "dat", FALSE); 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate (void) printf("%s\tflags=%s\n", 9607c478bd9Sstevel@tonic-gate pri->pname, 9617c478bd9Sstevel@tonic-gate strflags(pri, strpeek.flags)); 9627c478bd9Sstevel@tonic-gate } 9637c478bd9Sstevel@tonic-gate } 9647c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate void 9677c478bd9Sstevel@tonic-gate show_strfdinsert(private_t *pri, long offset) 9687c478bd9Sstevel@tonic-gate { 9697c478bd9Sstevel@tonic-gate struct strfdinsert strfdinsert; 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) == 9727c478bd9Sstevel@tonic-gate sizeof (strfdinsert)) { 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate print_strbuf(pri, &strfdinsert.ctlbuf, "ctl", FALSE); 9757c478bd9Sstevel@tonic-gate print_strbuf(pri, &strfdinsert.databuf, "dat", FALSE); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate (void) printf("%s\tflags=%s fildes=%d offset=%d\n", 9787c478bd9Sstevel@tonic-gate pri->pname, 9797c478bd9Sstevel@tonic-gate strflags(pri, strfdinsert.flags), 9807c478bd9Sstevel@tonic-gate strfdinsert.fildes, 9817c478bd9Sstevel@tonic-gate strfdinsert.offset); 9827c478bd9Sstevel@tonic-gate } 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate #ifdef _LP64 9867c478bd9Sstevel@tonic-gate void 9877c478bd9Sstevel@tonic-gate show_strfdinsert32(private_t *pri, long offset) 9887c478bd9Sstevel@tonic-gate { 9897c478bd9Sstevel@tonic-gate struct strfdinsert32 strfdinsert; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) == 9927c478bd9Sstevel@tonic-gate sizeof (strfdinsert)) { 9937c478bd9Sstevel@tonic-gate 9947c478bd9Sstevel@tonic-gate print_strbuf32(pri, &strfdinsert.ctlbuf, "ctl", FALSE); 9957c478bd9Sstevel@tonic-gate print_strbuf32(pri, &strfdinsert.databuf, "dat", FALSE); 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate (void) printf("%s\tflags=%s fildes=%d offset=%d\n", 9987c478bd9Sstevel@tonic-gate pri->pname, 9997c478bd9Sstevel@tonic-gate strflags(pri, strfdinsert.flags), 10007c478bd9Sstevel@tonic-gate strfdinsert.fildes, 10017c478bd9Sstevel@tonic-gate strfdinsert.offset); 10027c478bd9Sstevel@tonic-gate } 10037c478bd9Sstevel@tonic-gate } 10047c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate void 10077c478bd9Sstevel@tonic-gate show_strrecvfd(private_t *pri, long offset) 10087c478bd9Sstevel@tonic-gate { 10097c478bd9Sstevel@tonic-gate struct strrecvfd strrecvfd; 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate if (Pread(Proc, &strrecvfd, sizeof (strrecvfd), offset) == 10127c478bd9Sstevel@tonic-gate sizeof (strrecvfd)) { 10137c478bd9Sstevel@tonic-gate (void) printf( 10147c478bd9Sstevel@tonic-gate "%s\tfd=%-5d uid=%-5d gid=%d\n", 10157c478bd9Sstevel@tonic-gate pri->pname, 10167c478bd9Sstevel@tonic-gate strrecvfd.fd, 10177c478bd9Sstevel@tonic-gate (int)strrecvfd.uid, 10187c478bd9Sstevel@tonic-gate (int)strrecvfd.gid); 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate } 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate void 10237c478bd9Sstevel@tonic-gate show_strlist(private_t *pri, long offset) 10247c478bd9Sstevel@tonic-gate { 10257c478bd9Sstevel@tonic-gate struct str_list strlist; 10267c478bd9Sstevel@tonic-gate struct str_mlist list; 10277c478bd9Sstevel@tonic-gate int count; 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate if (Pread(Proc, &strlist, sizeof (strlist), offset) == 10307c478bd9Sstevel@tonic-gate sizeof (strlist)) { 10317c478bd9Sstevel@tonic-gate (void) printf("%s\tnmods=%d modlist=0x%.8lX\n", 10327c478bd9Sstevel@tonic-gate pri->pname, 10337c478bd9Sstevel@tonic-gate strlist.sl_nmods, 10347c478bd9Sstevel@tonic-gate (long)strlist.sl_modlist); 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate count = strlist.sl_nmods; 10377c478bd9Sstevel@tonic-gate offset = (long)strlist.sl_modlist; 10387c478bd9Sstevel@tonic-gate while (!interrupt && --count >= 0) { 10397c478bd9Sstevel@tonic-gate if (Pread(Proc, &list, sizeof (list), offset) != 10407c478bd9Sstevel@tonic-gate sizeof (list)) 10417c478bd9Sstevel@tonic-gate break; 10427c478bd9Sstevel@tonic-gate (void) printf("%s\t\t\"%.*s\"\n", 10437c478bd9Sstevel@tonic-gate pri->pname, 10447c478bd9Sstevel@tonic-gate (int)sizeof (list.l_name), 10457c478bd9Sstevel@tonic-gate list.l_name); 10467c478bd9Sstevel@tonic-gate offset += sizeof (struct str_mlist); 10477c478bd9Sstevel@tonic-gate } 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate } 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate #ifdef _LP64 10527c478bd9Sstevel@tonic-gate void 10537c478bd9Sstevel@tonic-gate show_strlist32(private_t *pri, long offset) 10547c478bd9Sstevel@tonic-gate { 10557c478bd9Sstevel@tonic-gate struct str_list32 strlist; 10567c478bd9Sstevel@tonic-gate struct str_mlist list; 10577c478bd9Sstevel@tonic-gate int count; 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate if (Pread(Proc, &strlist, sizeof (strlist), offset) == 10607c478bd9Sstevel@tonic-gate sizeof (strlist)) { 10617c478bd9Sstevel@tonic-gate (void) printf("%s\tnmods=%d modlist=0x%.8lX\n", 10627c478bd9Sstevel@tonic-gate pri->pname, 10637c478bd9Sstevel@tonic-gate strlist.sl_nmods, 10647c478bd9Sstevel@tonic-gate (long)strlist.sl_modlist); 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate count = strlist.sl_nmods; 10677c478bd9Sstevel@tonic-gate offset = (long)strlist.sl_modlist; 10687c478bd9Sstevel@tonic-gate while (!interrupt && --count >= 0) { 10697c478bd9Sstevel@tonic-gate if (Pread(Proc, &list, sizeof (list), offset) != 10707c478bd9Sstevel@tonic-gate sizeof (list)) 10717c478bd9Sstevel@tonic-gate break; 10727c478bd9Sstevel@tonic-gate (void) printf("%s\t\t\"%.*s\"\n", 10737c478bd9Sstevel@tonic-gate pri->pname, 10747c478bd9Sstevel@tonic-gate (int)sizeof (list.l_name), 10757c478bd9Sstevel@tonic-gate list.l_name); 10767c478bd9Sstevel@tonic-gate offset += sizeof (struct str_mlist); 10777c478bd9Sstevel@tonic-gate } 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate void 10837c478bd9Sstevel@tonic-gate show_jwinsize(private_t *pri, long offset) 10847c478bd9Sstevel@tonic-gate { 10857c478bd9Sstevel@tonic-gate struct jwinsize jwinsize; 10867c478bd9Sstevel@tonic-gate 10877c478bd9Sstevel@tonic-gate if (Pread(Proc, &jwinsize, sizeof (jwinsize), offset) == 10887c478bd9Sstevel@tonic-gate sizeof (jwinsize)) { 10897c478bd9Sstevel@tonic-gate (void) printf( 10907c478bd9Sstevel@tonic-gate "%s\tbytesx=%-3u bytesy=%-3u bitsx=%-3u bitsy=%-3u\n", 10917c478bd9Sstevel@tonic-gate pri->pname, 10927c478bd9Sstevel@tonic-gate (unsigned)jwinsize.bytesx, 10937c478bd9Sstevel@tonic-gate (unsigned)jwinsize.bytesy, 10947c478bd9Sstevel@tonic-gate (unsigned)jwinsize.bitsx, 10957c478bd9Sstevel@tonic-gate (unsigned)jwinsize.bitsy); 10967c478bd9Sstevel@tonic-gate } 10977c478bd9Sstevel@tonic-gate } 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate void 11007c478bd9Sstevel@tonic-gate show_winsize(private_t *pri, long offset) 11017c478bd9Sstevel@tonic-gate { 11027c478bd9Sstevel@tonic-gate struct winsize winsize; 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate if (Pread(Proc, &winsize, sizeof (winsize), offset) 11057c478bd9Sstevel@tonic-gate == sizeof (winsize)) { 11067c478bd9Sstevel@tonic-gate (void) printf( 11077c478bd9Sstevel@tonic-gate "%s\trow=%-3d col=%-3d xpixel=%-3d ypixel=%-3d\n", 11087c478bd9Sstevel@tonic-gate pri->pname, 11097c478bd9Sstevel@tonic-gate winsize.ws_row, 11107c478bd9Sstevel@tonic-gate winsize.ws_col, 11117c478bd9Sstevel@tonic-gate winsize.ws_xpixel, 11127c478bd9Sstevel@tonic-gate winsize.ws_ypixel); 11137c478bd9Sstevel@tonic-gate } 11147c478bd9Sstevel@tonic-gate } 11157c478bd9Sstevel@tonic-gate 11167c478bd9Sstevel@tonic-gate struct audio_stuff { 11177c478bd9Sstevel@tonic-gate uint_t bit; 11187c478bd9Sstevel@tonic-gate const char *str; 11197c478bd9Sstevel@tonic-gate }; 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate const struct audio_stuff audio_output_ports[] = { 11227c478bd9Sstevel@tonic-gate { AUDIO_SPEAKER, "SPEAKER" }, 11237c478bd9Sstevel@tonic-gate { AUDIO_HEADPHONE, "HEADPHONE" }, 11247c478bd9Sstevel@tonic-gate { AUDIO_LINE_OUT, "LINE_OUT" }, 11257c478bd9Sstevel@tonic-gate { AUDIO_SPDIF_OUT, "SPDIF_OUT" }, 11267c478bd9Sstevel@tonic-gate { AUDIO_AUX1_OUT, "AUX1_OUT" }, 11277c478bd9Sstevel@tonic-gate { AUDIO_AUX2_OUT, "AUX2_OUT" }, 11287c478bd9Sstevel@tonic-gate { 0, NULL } 11297c478bd9Sstevel@tonic-gate }; 11307c478bd9Sstevel@tonic-gate 11317c478bd9Sstevel@tonic-gate const struct audio_stuff audio_input_ports[] = { 11327c478bd9Sstevel@tonic-gate { AUDIO_MICROPHONE, "MICROPHONE" }, 11337c478bd9Sstevel@tonic-gate { AUDIO_LINE_IN, "LINE_IN" }, 11347c478bd9Sstevel@tonic-gate { AUDIO_CD, "CD" }, 11357c478bd9Sstevel@tonic-gate { AUDIO_SPDIF_IN, "SPDIF_IN" }, 11367c478bd9Sstevel@tonic-gate { AUDIO_AUX1_IN, "AUX1_IN" }, 11377c478bd9Sstevel@tonic-gate { AUDIO_AUX2_IN, "AUX2_IN" }, 11387c478bd9Sstevel@tonic-gate { AUDIO_CODEC_LOOPB_IN, "CODEC_LOOPB_IN" }, 11397c478bd9Sstevel@tonic-gate { AUDIO_SUNVTS, "SUNVTS" }, 11407c478bd9Sstevel@tonic-gate { 0, NULL } 11417c478bd9Sstevel@tonic-gate }; 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate static const struct audio_stuff audio_hw_features[] = { 11447c478bd9Sstevel@tonic-gate { AUDIO_HWFEATURE_DUPLEX, "DUPLEX" }, 11457c478bd9Sstevel@tonic-gate { AUDIO_HWFEATURE_MSCODEC, "MSCODEC" }, 11467c478bd9Sstevel@tonic-gate { AUDIO_HWFEATURE_IN2OUT, "IN2OUT" }, 11477c478bd9Sstevel@tonic-gate { AUDIO_HWFEATURE_PLAY, "PLAY" }, 11487c478bd9Sstevel@tonic-gate { AUDIO_HWFEATURE_RECORD, "RECORD" }, 11497c478bd9Sstevel@tonic-gate { 0, NULL } 11507c478bd9Sstevel@tonic-gate }; 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate static const struct audio_stuff audio_sw_features[] = { 11537c478bd9Sstevel@tonic-gate { AUDIO_SWFEATURE_MIXER, "MIXER" }, 11547c478bd9Sstevel@tonic-gate { 0, NULL } 11557c478bd9Sstevel@tonic-gate }; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate void 11587c478bd9Sstevel@tonic-gate show_audio_features(const private_t *pri, 11597c478bd9Sstevel@tonic-gate const struct audio_stuff *audio_porttab, uint_t features, 11607c478bd9Sstevel@tonic-gate const char *name) 11617c478bd9Sstevel@tonic-gate { 11627c478bd9Sstevel@tonic-gate (void) printf("%s\t%s=", pri->pname, name); 11637c478bd9Sstevel@tonic-gate if (features == 0) { 11647c478bd9Sstevel@tonic-gate (void) printf("0\n"); 11657c478bd9Sstevel@tonic-gate return; 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate for (; audio_porttab->bit != 0; ++audio_porttab) { 11697c478bd9Sstevel@tonic-gate if (features & audio_porttab->bit) { 11707c478bd9Sstevel@tonic-gate (void) printf(audio_porttab->str); 11717c478bd9Sstevel@tonic-gate features &= ~audio_porttab->bit; 11727c478bd9Sstevel@tonic-gate if (features) 11737c478bd9Sstevel@tonic-gate (void) putchar('|'); 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate } 11767c478bd9Sstevel@tonic-gate if (features) 11777c478bd9Sstevel@tonic-gate (void) printf("0x%x", features); 11787c478bd9Sstevel@tonic-gate (void) putchar('\n'); 11797c478bd9Sstevel@tonic-gate } 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate void 11827c478bd9Sstevel@tonic-gate show_audio_ports(private_t *pri, const char *mode, 11837c478bd9Sstevel@tonic-gate const char *field, uint_t ports) 11847c478bd9Sstevel@tonic-gate { 11857c478bd9Sstevel@tonic-gate const struct audio_stuff *audio_porttab; 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\t%s=", pri->pname, mode, field); 11887c478bd9Sstevel@tonic-gate if (ports == 0) { 11897c478bd9Sstevel@tonic-gate (void) printf("0\n"); 11907c478bd9Sstevel@tonic-gate return; 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate if (*mode == 'p') 11937c478bd9Sstevel@tonic-gate audio_porttab = audio_output_ports; 11947c478bd9Sstevel@tonic-gate else 11957c478bd9Sstevel@tonic-gate audio_porttab = audio_input_ports; 11967c478bd9Sstevel@tonic-gate for (; audio_porttab->bit != 0; ++audio_porttab) { 11977c478bd9Sstevel@tonic-gate if (ports & audio_porttab->bit) { 11987c478bd9Sstevel@tonic-gate (void) printf(audio_porttab->str); 11997c478bd9Sstevel@tonic-gate ports &= ~audio_porttab->bit; 12007c478bd9Sstevel@tonic-gate if (ports) 12017c478bd9Sstevel@tonic-gate (void) putchar('|'); 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate } 12047c478bd9Sstevel@tonic-gate if (ports) 12057c478bd9Sstevel@tonic-gate (void) printf("0x%x", ports); 12067c478bd9Sstevel@tonic-gate (void) putchar('\n'); 12077c478bd9Sstevel@tonic-gate } 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate void 12107c478bd9Sstevel@tonic-gate show_audio_prinfo(private_t *pri, const char *mode, struct audio_prinfo *au_pr) 12117c478bd9Sstevel@tonic-gate { 12127c478bd9Sstevel@tonic-gate const char *s; 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate /* 12157c478bd9Sstevel@tonic-gate * The following values describe the audio data encoding. 12167c478bd9Sstevel@tonic-gate */ 12177c478bd9Sstevel@tonic-gate 12187c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\tsample_rate=%u channels=%u precision=%u\n", 12197c478bd9Sstevel@tonic-gate pri->pname, mode, 12207c478bd9Sstevel@tonic-gate au_pr->sample_rate, 12217c478bd9Sstevel@tonic-gate au_pr->channels, 12227c478bd9Sstevel@tonic-gate au_pr->precision); 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate s = NULL; 12257c478bd9Sstevel@tonic-gate switch (au_pr->encoding) { 12267c478bd9Sstevel@tonic-gate case AUDIO_ENCODING_NONE: s = "NONE"; break; 12277c478bd9Sstevel@tonic-gate case AUDIO_ENCODING_ULAW: s = "ULAW"; break; 12287c478bd9Sstevel@tonic-gate case AUDIO_ENCODING_ALAW: s = "ALAW"; break; 12297c478bd9Sstevel@tonic-gate case AUDIO_ENCODING_LINEAR: s = "LINEAR"; break; 12307c478bd9Sstevel@tonic-gate case AUDIO_ENCODING_DVI: s = "DVI"; break; 12317c478bd9Sstevel@tonic-gate case AUDIO_ENCODING_LINEAR8: s = "LINEAR8"; break; 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate if (s) 12347c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\tencoding=%s\n", pri->pname, mode, s); 12357c478bd9Sstevel@tonic-gate else { 12367c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\tencoding=%u\n", 12377c478bd9Sstevel@tonic-gate pri->pname, mode, au_pr->encoding); 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate /* 12417c478bd9Sstevel@tonic-gate * The following values control audio device configuration 12427c478bd9Sstevel@tonic-gate */ 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate (void) printf( 12457c478bd9Sstevel@tonic-gate "%s\t%s\tgain=%u buffer_size=%u\n", 12467c478bd9Sstevel@tonic-gate pri->pname, mode, 12477c478bd9Sstevel@tonic-gate au_pr->gain, 12487c478bd9Sstevel@tonic-gate au_pr->buffer_size); 12497c478bd9Sstevel@tonic-gate show_audio_ports(pri, mode, "port", au_pr->port); 12507c478bd9Sstevel@tonic-gate show_audio_ports(pri, mode, "avail_ports", au_pr->avail_ports); 12517c478bd9Sstevel@tonic-gate show_audio_ports(pri, mode, "mod_ports", au_pr->mod_ports); 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate /* 12547c478bd9Sstevel@tonic-gate * The following values describe driver state 12557c478bd9Sstevel@tonic-gate */ 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\tsamples=%u eof=%u pause=%u error=%u\n", 12587c478bd9Sstevel@tonic-gate pri->pname, mode, 12597c478bd9Sstevel@tonic-gate au_pr->samples, 12607c478bd9Sstevel@tonic-gate au_pr->eof, 12617c478bd9Sstevel@tonic-gate au_pr->pause, 12627c478bd9Sstevel@tonic-gate au_pr->error); 12637c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\twaiting=%u balance=%u minordev=%u\n", 12647c478bd9Sstevel@tonic-gate pri->pname, mode, 12657c478bd9Sstevel@tonic-gate au_pr->waiting, 12667c478bd9Sstevel@tonic-gate au_pr->balance, 12677c478bd9Sstevel@tonic-gate au_pr->minordev); 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate /* 12707c478bd9Sstevel@tonic-gate * The following values are read-only state flags 12717c478bd9Sstevel@tonic-gate */ 12727c478bd9Sstevel@tonic-gate (void) printf("%s\t%s\topen=%u active=%u\n", 12737c478bd9Sstevel@tonic-gate pri->pname, mode, 12747c478bd9Sstevel@tonic-gate au_pr->open, 12757c478bd9Sstevel@tonic-gate au_pr->active); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate void 12797c478bd9Sstevel@tonic-gate show_audio_info(private_t *pri, long offset) 12807c478bd9Sstevel@tonic-gate { 12817c478bd9Sstevel@tonic-gate struct audio_info au; 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate if (Pread(Proc, &au, sizeof (au), offset) == sizeof (au)) { 12847c478bd9Sstevel@tonic-gate show_audio_prinfo(pri, "play", &au.play); 12857c478bd9Sstevel@tonic-gate show_audio_prinfo(pri, "record", &au.record); 12867c478bd9Sstevel@tonic-gate (void) printf("%s\tmonitor_gain=%u output_muted=%u\n", 12877c478bd9Sstevel@tonic-gate pri->pname, au.monitor_gain, au.output_muted); 12887c478bd9Sstevel@tonic-gate show_audio_features(pri, audio_hw_features, au.hw_features, 12897c478bd9Sstevel@tonic-gate "hw_features"); 12907c478bd9Sstevel@tonic-gate show_audio_features(pri, audio_sw_features, au.sw_features, 12917c478bd9Sstevel@tonic-gate "sw_features"); 12927c478bd9Sstevel@tonic-gate show_audio_features(pri, audio_sw_features, 12937c478bd9Sstevel@tonic-gate au.sw_features_enabled, "sw_features_enabled"); 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate 12977c478bd9Sstevel@tonic-gate void 12987c478bd9Sstevel@tonic-gate show_ioctl(private_t *pri, int code, long offset) 12997c478bd9Sstevel@tonic-gate { 13007c478bd9Sstevel@tonic-gate int lp64 = (data_model == PR_MODEL_LP64); 13017c478bd9Sstevel@tonic-gate int err = pri->Errno; /* don't display output parameters */ 13027c478bd9Sstevel@tonic-gate /* for a failed system call */ 13037c478bd9Sstevel@tonic-gate #ifndef _LP64 13047c478bd9Sstevel@tonic-gate if (lp64) 13057c478bd9Sstevel@tonic-gate return; 13067c478bd9Sstevel@tonic-gate #endif 13077c478bd9Sstevel@tonic-gate if (offset == NULL) 13087c478bd9Sstevel@tonic-gate return; 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate switch (code) { 13117c478bd9Sstevel@tonic-gate case TCGETA: 13127c478bd9Sstevel@tonic-gate if (err) 13137c478bd9Sstevel@tonic-gate break; 13147c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13157c478bd9Sstevel@tonic-gate case TCSETA: 13167c478bd9Sstevel@tonic-gate case TCSETAW: 13177c478bd9Sstevel@tonic-gate case TCSETAF: 13187c478bd9Sstevel@tonic-gate show_termio(pri, offset); 13197c478bd9Sstevel@tonic-gate break; 13207c478bd9Sstevel@tonic-gate case TCGETS: 13217c478bd9Sstevel@tonic-gate if (err) 13227c478bd9Sstevel@tonic-gate break; 13237c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13247c478bd9Sstevel@tonic-gate case TCSETS: 13257c478bd9Sstevel@tonic-gate case TCSETSW: 13267c478bd9Sstevel@tonic-gate case TCSETSF: 13277c478bd9Sstevel@tonic-gate show_termios(pri, offset); 13287c478bd9Sstevel@tonic-gate break; 13297c478bd9Sstevel@tonic-gate case TCGETX: 13307c478bd9Sstevel@tonic-gate if (err) 13317c478bd9Sstevel@tonic-gate break; 13327c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13337c478bd9Sstevel@tonic-gate case TCSETX: 13347c478bd9Sstevel@tonic-gate case TCSETXW: 13357c478bd9Sstevel@tonic-gate case TCSETXF: 13367c478bd9Sstevel@tonic-gate show_termiox(pri, offset); 13377c478bd9Sstevel@tonic-gate break; 13387c478bd9Sstevel@tonic-gate case TIOCGETP: 13397c478bd9Sstevel@tonic-gate if (err) 13407c478bd9Sstevel@tonic-gate break; 13417c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13427c478bd9Sstevel@tonic-gate case TIOCSETN: 13437c478bd9Sstevel@tonic-gate case TIOCSETP: 13447c478bd9Sstevel@tonic-gate show_sgttyb(pri, offset); 13457c478bd9Sstevel@tonic-gate break; 13467c478bd9Sstevel@tonic-gate case TIOCGLTC: 13477c478bd9Sstevel@tonic-gate if (err) 13487c478bd9Sstevel@tonic-gate break; 13497c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13507c478bd9Sstevel@tonic-gate case TIOCSLTC: 13517c478bd9Sstevel@tonic-gate show_ltchars(pri, offset); 13527c478bd9Sstevel@tonic-gate break; 13537c478bd9Sstevel@tonic-gate case TIOCGETC: 13547c478bd9Sstevel@tonic-gate if (err) 13557c478bd9Sstevel@tonic-gate break; 13567c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13577c478bd9Sstevel@tonic-gate case TIOCSETC: 13587c478bd9Sstevel@tonic-gate show_tchars(pri, offset); 13597c478bd9Sstevel@tonic-gate break; 13607c478bd9Sstevel@tonic-gate case LDGETT: 13617c478bd9Sstevel@tonic-gate if (err) 13627c478bd9Sstevel@tonic-gate break; 13637c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 13647c478bd9Sstevel@tonic-gate case LDSETT: 13657c478bd9Sstevel@tonic-gate show_termcb(pri, offset); 13667c478bd9Sstevel@tonic-gate break; 13677c478bd9Sstevel@tonic-gate /* streams ioctl()s */ 13687c478bd9Sstevel@tonic-gate #if 0 13697c478bd9Sstevel@tonic-gate /* these are displayed as strings in the arg list */ 13707c478bd9Sstevel@tonic-gate /* by prt_ioa(). don't display them again here */ 13717c478bd9Sstevel@tonic-gate case I_PUSH: 13727c478bd9Sstevel@tonic-gate case I_LOOK: 13737c478bd9Sstevel@tonic-gate case I_FIND: 13747c478bd9Sstevel@tonic-gate /* these are displayed as decimal in the arg list */ 13757c478bd9Sstevel@tonic-gate /* by prt_ioa(). don't display them again here */ 13767c478bd9Sstevel@tonic-gate case I_LINK: 13777c478bd9Sstevel@tonic-gate case I_UNLINK: 13787c478bd9Sstevel@tonic-gate case I_SENDFD: 13797c478bd9Sstevel@tonic-gate /* these are displayed symbolically in the arg list */ 13807c478bd9Sstevel@tonic-gate /* by prt_ioa(). don't display them again here */ 13817c478bd9Sstevel@tonic-gate case I_SRDOPT: 13827c478bd9Sstevel@tonic-gate case I_SETSIG: 13837c478bd9Sstevel@tonic-gate case I_FLUSH: 13847c478bd9Sstevel@tonic-gate break; 13857c478bd9Sstevel@tonic-gate /* this one just ignores the argument */ 13867c478bd9Sstevel@tonic-gate case I_POP: 13877c478bd9Sstevel@tonic-gate break; 13887c478bd9Sstevel@tonic-gate #endif 13897c478bd9Sstevel@tonic-gate /* these return something in an int pointed to by arg */ 13907c478bd9Sstevel@tonic-gate case I_NREAD: 13917c478bd9Sstevel@tonic-gate case I_GRDOPT: 13927c478bd9Sstevel@tonic-gate case I_GETSIG: 13937c478bd9Sstevel@tonic-gate case TIOCGSID: 13947c478bd9Sstevel@tonic-gate case TIOCGPGRP: 13957c478bd9Sstevel@tonic-gate case TIOCLGET: 13967c478bd9Sstevel@tonic-gate case FIONREAD: 13977c478bd9Sstevel@tonic-gate case FIORDCHK: 13987c478bd9Sstevel@tonic-gate if (err) 13997c478bd9Sstevel@tonic-gate break; 14007c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 14017c478bd9Sstevel@tonic-gate /* these pass something in an int pointed to by arg */ 14027c478bd9Sstevel@tonic-gate case TIOCSPGRP: 14037c478bd9Sstevel@tonic-gate case TIOCFLUSH: 14047c478bd9Sstevel@tonic-gate case TIOCLBIS: 14057c478bd9Sstevel@tonic-gate case TIOCLBIC: 14067c478bd9Sstevel@tonic-gate case TIOCLSET: 14077c478bd9Sstevel@tonic-gate show_strint(pri, code, offset); 14087c478bd9Sstevel@tonic-gate break; 14097c478bd9Sstevel@tonic-gate /* these all point to structures */ 14107c478bd9Sstevel@tonic-gate case I_STR: 14117c478bd9Sstevel@tonic-gate #ifdef _LP64 14127c478bd9Sstevel@tonic-gate if (lp64) 14137c478bd9Sstevel@tonic-gate show_strioctl(pri, offset); 14147c478bd9Sstevel@tonic-gate else 14157c478bd9Sstevel@tonic-gate show_strioctl32(pri, offset); 14167c478bd9Sstevel@tonic-gate #else 14177c478bd9Sstevel@tonic-gate show_strioctl(pri, offset); 14187c478bd9Sstevel@tonic-gate #endif 14197c478bd9Sstevel@tonic-gate break; 14207c478bd9Sstevel@tonic-gate case I_PEEK: 14217c478bd9Sstevel@tonic-gate #ifdef _LP64 14227c478bd9Sstevel@tonic-gate if (lp64) 14237c478bd9Sstevel@tonic-gate show_strpeek(pri, offset); 14247c478bd9Sstevel@tonic-gate else 14257c478bd9Sstevel@tonic-gate show_strpeek32(pri, offset); 14267c478bd9Sstevel@tonic-gate #else 14277c478bd9Sstevel@tonic-gate show_strpeek(pri, offset); 14287c478bd9Sstevel@tonic-gate #endif 14297c478bd9Sstevel@tonic-gate break; 14307c478bd9Sstevel@tonic-gate case I_FDINSERT: 14317c478bd9Sstevel@tonic-gate #ifdef _LP64 14327c478bd9Sstevel@tonic-gate if (lp64) 14337c478bd9Sstevel@tonic-gate show_strfdinsert(pri, offset); 14347c478bd9Sstevel@tonic-gate else 14357c478bd9Sstevel@tonic-gate show_strfdinsert32(pri, offset); 14367c478bd9Sstevel@tonic-gate #else 14377c478bd9Sstevel@tonic-gate show_strfdinsert(pri, offset); 14387c478bd9Sstevel@tonic-gate #endif 14397c478bd9Sstevel@tonic-gate break; 14407c478bd9Sstevel@tonic-gate case I_RECVFD: 14417c478bd9Sstevel@tonic-gate if (err) 14427c478bd9Sstevel@tonic-gate break; 14437c478bd9Sstevel@tonic-gate show_strrecvfd(pri, offset); 14447c478bd9Sstevel@tonic-gate break; 14457c478bd9Sstevel@tonic-gate case I_LIST: 14467c478bd9Sstevel@tonic-gate if (err) 14477c478bd9Sstevel@tonic-gate break; 14487c478bd9Sstevel@tonic-gate #ifdef _LP64 14497c478bd9Sstevel@tonic-gate if (lp64) 14507c478bd9Sstevel@tonic-gate show_strlist(pri, offset); 14517c478bd9Sstevel@tonic-gate else 14527c478bd9Sstevel@tonic-gate show_strlist32(pri, offset); 14537c478bd9Sstevel@tonic-gate #else 14547c478bd9Sstevel@tonic-gate show_strlist(pri, offset); 14557c478bd9Sstevel@tonic-gate #endif 14567c478bd9Sstevel@tonic-gate break; 14577c478bd9Sstevel@tonic-gate case JWINSIZE: 14587c478bd9Sstevel@tonic-gate if (err) 14597c478bd9Sstevel@tonic-gate break; 14607c478bd9Sstevel@tonic-gate show_jwinsize(pri, offset); 14617c478bd9Sstevel@tonic-gate break; 14627c478bd9Sstevel@tonic-gate case TIOCGWINSZ: 14637c478bd9Sstevel@tonic-gate if (err) 14647c478bd9Sstevel@tonic-gate break; 14657c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 14667c478bd9Sstevel@tonic-gate case TIOCSWINSZ: 14677c478bd9Sstevel@tonic-gate show_winsize(pri, offset); 14687c478bd9Sstevel@tonic-gate break; 14697c478bd9Sstevel@tonic-gate case AUDIO_GETINFO: 14707c478bd9Sstevel@tonic-gate case (int)AUDIO_SETINFO: 14717c478bd9Sstevel@tonic-gate show_audio_info(pri, offset); 14727c478bd9Sstevel@tonic-gate break; 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate default: 14757c478bd9Sstevel@tonic-gate if (code & IOC_INOUT) { 14767c478bd9Sstevel@tonic-gate const char *str = ioctldatastruct(code); 14777c478bd9Sstevel@tonic-gate 14787c478bd9Sstevel@tonic-gate (void) printf("\t\t%s", 14797c478bd9Sstevel@tonic-gate (code & IOC_INOUT) == IOC_INOUT ? "write/read" : 14807c478bd9Sstevel@tonic-gate code & IOC_IN ? "write" : "read"); 14817c478bd9Sstevel@tonic-gate if (str != NULL) { 14827c478bd9Sstevel@tonic-gate (void) printf(" (struct %s)\n", str); 14837c478bd9Sstevel@tonic-gate } else { 14847c478bd9Sstevel@tonic-gate (void) printf(" %d bytes\n", 14857c478bd9Sstevel@tonic-gate (code >> 16) & IOCPARM_MASK); 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate } 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate } 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate void 14927c478bd9Sstevel@tonic-gate show_statvfs(private_t *pri) 14937c478bd9Sstevel@tonic-gate { 14947c478bd9Sstevel@tonic-gate long offset; 14957c478bd9Sstevel@tonic-gate struct statvfs statvfs; 14967c478bd9Sstevel@tonic-gate char *cp; 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL && 14997c478bd9Sstevel@tonic-gate Pread(Proc, &statvfs, sizeof (statvfs), offset) 15007c478bd9Sstevel@tonic-gate == sizeof (statvfs)) { 15017c478bd9Sstevel@tonic-gate (void) printf( 15027c478bd9Sstevel@tonic-gate "%s\tbsize=%-10lu frsize=%-9lu blocks=%-8llu bfree=%-9llu\n", 15037c478bd9Sstevel@tonic-gate pri->pname, 15047c478bd9Sstevel@tonic-gate statvfs.f_bsize, 15057c478bd9Sstevel@tonic-gate statvfs.f_frsize, 15067c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_blocks, 15077c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_bfree); 15087c478bd9Sstevel@tonic-gate (void) printf( 15097c478bd9Sstevel@tonic-gate "%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n", 15107c478bd9Sstevel@tonic-gate pri->pname, 15117c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_bavail, 15127c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_files, 15137c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_ffree, 15147c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_favail); 15157c478bd9Sstevel@tonic-gate (void) printf( 15167c478bd9Sstevel@tonic-gate "%s\tfsid=0x%-9.4lX basetype=%-7.16s namemax=%ld\n", 15177c478bd9Sstevel@tonic-gate pri->pname, 15187c478bd9Sstevel@tonic-gate statvfs.f_fsid, 15197c478bd9Sstevel@tonic-gate statvfs.f_basetype, 15207c478bd9Sstevel@tonic-gate (long)statvfs.f_namemax); 15217c478bd9Sstevel@tonic-gate (void) printf( 15227c478bd9Sstevel@tonic-gate "%s\tflag=%s\n", 15237c478bd9Sstevel@tonic-gate pri->pname, 15247c478bd9Sstevel@tonic-gate svfsflags(pri, (ulong_t)statvfs.f_flag)); 15257c478bd9Sstevel@tonic-gate cp = statvfs.f_fstr + strlen(statvfs.f_fstr); 15267c478bd9Sstevel@tonic-gate if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 && 15277c478bd9Sstevel@tonic-gate *(cp+1) != '\0') 15287c478bd9Sstevel@tonic-gate *cp = ' '; 15297c478bd9Sstevel@tonic-gate (void) printf("%s\tfstr=\"%.*s\"\n", 15307c478bd9Sstevel@tonic-gate pri->pname, 15317c478bd9Sstevel@tonic-gate (int)sizeof (statvfs.f_fstr), 15327c478bd9Sstevel@tonic-gate statvfs.f_fstr); 15337c478bd9Sstevel@tonic-gate } 15347c478bd9Sstevel@tonic-gate } 15357c478bd9Sstevel@tonic-gate 15367c478bd9Sstevel@tonic-gate #ifdef _LP64 15377c478bd9Sstevel@tonic-gate void 15387c478bd9Sstevel@tonic-gate show_statvfs32(private_t *pri) 15397c478bd9Sstevel@tonic-gate { 15407c478bd9Sstevel@tonic-gate long offset; 15417c478bd9Sstevel@tonic-gate struct statvfs32 statvfs; 15427c478bd9Sstevel@tonic-gate char *cp; 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL && 15457c478bd9Sstevel@tonic-gate Pread(Proc, &statvfs, sizeof (statvfs), offset) 15467c478bd9Sstevel@tonic-gate == sizeof (statvfs)) { 15477c478bd9Sstevel@tonic-gate (void) printf( 15487c478bd9Sstevel@tonic-gate "%s\tbsize=%-10u frsize=%-9u blocks=%-8u bfree=%-9u\n", 15497c478bd9Sstevel@tonic-gate pri->pname, 15507c478bd9Sstevel@tonic-gate statvfs.f_bsize, 15517c478bd9Sstevel@tonic-gate statvfs.f_frsize, 15527c478bd9Sstevel@tonic-gate statvfs.f_blocks, 15537c478bd9Sstevel@tonic-gate statvfs.f_bfree); 15547c478bd9Sstevel@tonic-gate (void) printf( 15557c478bd9Sstevel@tonic-gate "%s\tbavail=%-9u files=%-10u ffree=%-9u favail=%-9u\n", 15567c478bd9Sstevel@tonic-gate pri->pname, 15577c478bd9Sstevel@tonic-gate statvfs.f_bavail, 15587c478bd9Sstevel@tonic-gate statvfs.f_files, 15597c478bd9Sstevel@tonic-gate statvfs.f_ffree, 15607c478bd9Sstevel@tonic-gate statvfs.f_favail); 15617c478bd9Sstevel@tonic-gate (void) printf( 15627c478bd9Sstevel@tonic-gate "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n", 15637c478bd9Sstevel@tonic-gate pri->pname, 15647c478bd9Sstevel@tonic-gate statvfs.f_fsid, 15657c478bd9Sstevel@tonic-gate statvfs.f_basetype, 15667c478bd9Sstevel@tonic-gate (int)statvfs.f_namemax); 15677c478bd9Sstevel@tonic-gate (void) printf( 15687c478bd9Sstevel@tonic-gate "%s\tflag=%s\n", 15697c478bd9Sstevel@tonic-gate pri->pname, 15707c478bd9Sstevel@tonic-gate svfsflags(pri, (ulong_t)statvfs.f_flag)); 15717c478bd9Sstevel@tonic-gate cp = statvfs.f_fstr + strlen(statvfs.f_fstr); 15727c478bd9Sstevel@tonic-gate if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 && 15737c478bd9Sstevel@tonic-gate *(cp+1) != '\0') 15747c478bd9Sstevel@tonic-gate *cp = ' '; 15757c478bd9Sstevel@tonic-gate (void) printf("%s\tfstr=\"%.*s\"\n", 15767c478bd9Sstevel@tonic-gate pri->pname, 15777c478bd9Sstevel@tonic-gate (int)sizeof (statvfs.f_fstr), 15787c478bd9Sstevel@tonic-gate statvfs.f_fstr); 15797c478bd9Sstevel@tonic-gate } 15807c478bd9Sstevel@tonic-gate } 15817c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate void 15847c478bd9Sstevel@tonic-gate show_statvfs64(private_t *pri) 15857c478bd9Sstevel@tonic-gate { 15867c478bd9Sstevel@tonic-gate long offset; 15877c478bd9Sstevel@tonic-gate struct statvfs64_32 statvfs; 15887c478bd9Sstevel@tonic-gate char *cp; 15897c478bd9Sstevel@tonic-gate 15907c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL && 15917c478bd9Sstevel@tonic-gate Pread(Proc, &statvfs, sizeof (statvfs), offset) 15927c478bd9Sstevel@tonic-gate == sizeof (statvfs)) { 15937c478bd9Sstevel@tonic-gate (void) printf( 15947c478bd9Sstevel@tonic-gate "%s\tbsize=%-10u frsize=%-9u blocks=%-8llu bfree=%-9llu\n", 15957c478bd9Sstevel@tonic-gate pri->pname, 15967c478bd9Sstevel@tonic-gate statvfs.f_bsize, 15977c478bd9Sstevel@tonic-gate statvfs.f_frsize, 15987c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_blocks, 15997c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_bfree); 16007c478bd9Sstevel@tonic-gate (void) printf( 16017c478bd9Sstevel@tonic-gate "%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n", 16027c478bd9Sstevel@tonic-gate pri->pname, 16037c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_bavail, 16047c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_files, 16057c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_ffree, 16067c478bd9Sstevel@tonic-gate (u_longlong_t)statvfs.f_favail); 16077c478bd9Sstevel@tonic-gate (void) printf( 16087c478bd9Sstevel@tonic-gate "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n", 16097c478bd9Sstevel@tonic-gate pri->pname, 16107c478bd9Sstevel@tonic-gate statvfs.f_fsid, 16117c478bd9Sstevel@tonic-gate statvfs.f_basetype, 16127c478bd9Sstevel@tonic-gate (int)statvfs.f_namemax); 16137c478bd9Sstevel@tonic-gate (void) printf( 16147c478bd9Sstevel@tonic-gate "%s\tflag=%s\n", 16157c478bd9Sstevel@tonic-gate pri->pname, 16167c478bd9Sstevel@tonic-gate svfsflags(pri, (ulong_t)statvfs.f_flag)); 16177c478bd9Sstevel@tonic-gate cp = statvfs.f_fstr + strlen(statvfs.f_fstr); 16187c478bd9Sstevel@tonic-gate if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 && 16197c478bd9Sstevel@tonic-gate *(cp+1) != '\0') 16207c478bd9Sstevel@tonic-gate *cp = ' '; 16217c478bd9Sstevel@tonic-gate (void) printf("%s\tfstr=\"%.*s\"\n", 16227c478bd9Sstevel@tonic-gate pri->pname, 16237c478bd9Sstevel@tonic-gate (int)sizeof (statvfs.f_fstr), 16247c478bd9Sstevel@tonic-gate statvfs.f_fstr); 16257c478bd9Sstevel@tonic-gate } 16267c478bd9Sstevel@tonic-gate } 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate void 16297c478bd9Sstevel@tonic-gate show_statfs(private_t *pri) 16307c478bd9Sstevel@tonic-gate { 16317c478bd9Sstevel@tonic-gate long offset; 16327c478bd9Sstevel@tonic-gate struct statfs statfs; 16337c478bd9Sstevel@tonic-gate 16347c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL && 16357c478bd9Sstevel@tonic-gate Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) { 16367c478bd9Sstevel@tonic-gate (void) printf( 16377c478bd9Sstevel@tonic-gate "%s\tfty=%d bsz=%ld fsz=%ld blk=%ld bfr=%ld fil=%lu ffr=%lu\n", 16387c478bd9Sstevel@tonic-gate pri->pname, 16397c478bd9Sstevel@tonic-gate statfs.f_fstyp, 16407c478bd9Sstevel@tonic-gate statfs.f_bsize, 16417c478bd9Sstevel@tonic-gate statfs.f_frsize, 16427c478bd9Sstevel@tonic-gate statfs.f_blocks, 16437c478bd9Sstevel@tonic-gate statfs.f_bfree, 16447c478bd9Sstevel@tonic-gate statfs.f_files, 16457c478bd9Sstevel@tonic-gate statfs.f_ffree); 16467c478bd9Sstevel@tonic-gate (void) printf("%s\t fname=%.6s fpack=%.6s\n", 16477c478bd9Sstevel@tonic-gate pri->pname, 16487c478bd9Sstevel@tonic-gate statfs.f_fname, 16497c478bd9Sstevel@tonic-gate statfs.f_fpack); 16507c478bd9Sstevel@tonic-gate } 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate #ifdef _LP64 16547c478bd9Sstevel@tonic-gate void 16557c478bd9Sstevel@tonic-gate show_statfs32(private_t *pri) 16567c478bd9Sstevel@tonic-gate { 16577c478bd9Sstevel@tonic-gate long offset; 16587c478bd9Sstevel@tonic-gate struct statfs32 statfs; 16597c478bd9Sstevel@tonic-gate 16607c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL && 16617c478bd9Sstevel@tonic-gate Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) { 16627c478bd9Sstevel@tonic-gate (void) printf( 16637c478bd9Sstevel@tonic-gate "%s\tfty=%d bsz=%d fsz=%d blk=%d bfr=%d fil=%u ffr=%u\n", 16647c478bd9Sstevel@tonic-gate pri->pname, 16657c478bd9Sstevel@tonic-gate statfs.f_fstyp, 16667c478bd9Sstevel@tonic-gate statfs.f_bsize, 16677c478bd9Sstevel@tonic-gate statfs.f_frsize, 16687c478bd9Sstevel@tonic-gate statfs.f_blocks, 16697c478bd9Sstevel@tonic-gate statfs.f_bfree, 16707c478bd9Sstevel@tonic-gate statfs.f_files, 16717c478bd9Sstevel@tonic-gate statfs.f_ffree); 16727c478bd9Sstevel@tonic-gate (void) printf("%s\t fname=%.6s fpack=%.6s\n", 16737c478bd9Sstevel@tonic-gate pri->pname, 16747c478bd9Sstevel@tonic-gate statfs.f_fname, 16757c478bd9Sstevel@tonic-gate statfs.f_fpack); 16767c478bd9Sstevel@tonic-gate } 16777c478bd9Sstevel@tonic-gate } 16787c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 16797c478bd9Sstevel@tonic-gate 16807c478bd9Sstevel@tonic-gate void 16817c478bd9Sstevel@tonic-gate show_flock32(private_t *pri, long offset) 16827c478bd9Sstevel@tonic-gate { 16837c478bd9Sstevel@tonic-gate struct flock32 flock; 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) { 16867c478bd9Sstevel@tonic-gate const char *str = NULL; 16877c478bd9Sstevel@tonic-gate 16887c478bd9Sstevel@tonic-gate (void) printf("%s\ttyp=", pri->pname); 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate switch (flock.l_type) { 16917c478bd9Sstevel@tonic-gate case F_RDLCK: 16927c478bd9Sstevel@tonic-gate str = "F_RDLCK"; 16937c478bd9Sstevel@tonic-gate break; 16947c478bd9Sstevel@tonic-gate case F_WRLCK: 16957c478bd9Sstevel@tonic-gate str = "F_WRLCK"; 16967c478bd9Sstevel@tonic-gate break; 16977c478bd9Sstevel@tonic-gate case F_UNLCK: 16987c478bd9Sstevel@tonic-gate str = "F_UNLCK"; 16997c478bd9Sstevel@tonic-gate break; 17007c478bd9Sstevel@tonic-gate } 17017c478bd9Sstevel@tonic-gate if (str != NULL) 17027c478bd9Sstevel@tonic-gate (void) printf("%s", str); 17037c478bd9Sstevel@tonic-gate else 17047c478bd9Sstevel@tonic-gate (void) printf("%-7d", flock.l_type); 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate str = whencearg(flock.l_whence); 17077c478bd9Sstevel@tonic-gate if (str != NULL) 17087c478bd9Sstevel@tonic-gate (void) printf(" whence=%s", str); 17097c478bd9Sstevel@tonic-gate else 17107c478bd9Sstevel@tonic-gate (void) printf(" whence=%-8u", flock.l_whence); 17117c478bd9Sstevel@tonic-gate 17127c478bd9Sstevel@tonic-gate (void) printf( 17137c478bd9Sstevel@tonic-gate " start=%-5d len=%-5d sys=%-2u pid=%d\n", 17147c478bd9Sstevel@tonic-gate flock.l_start, 17157c478bd9Sstevel@tonic-gate flock.l_len, 17167c478bd9Sstevel@tonic-gate flock.l_sysid, 17177c478bd9Sstevel@tonic-gate flock.l_pid); 17187c478bd9Sstevel@tonic-gate } 17197c478bd9Sstevel@tonic-gate } 17207c478bd9Sstevel@tonic-gate 17217c478bd9Sstevel@tonic-gate void 17227c478bd9Sstevel@tonic-gate show_flock64(private_t *pri, long offset) 17237c478bd9Sstevel@tonic-gate { 17247c478bd9Sstevel@tonic-gate struct flock64 flock; 17257c478bd9Sstevel@tonic-gate 17267c478bd9Sstevel@tonic-gate if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) { 17277c478bd9Sstevel@tonic-gate const char *str = NULL; 17287c478bd9Sstevel@tonic-gate 17297c478bd9Sstevel@tonic-gate (void) printf("%s\ttyp=", pri->pname); 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate switch (flock.l_type) { 17327c478bd9Sstevel@tonic-gate case F_RDLCK: 17337c478bd9Sstevel@tonic-gate str = "F_RDLCK"; 17347c478bd9Sstevel@tonic-gate break; 17357c478bd9Sstevel@tonic-gate case F_WRLCK: 17367c478bd9Sstevel@tonic-gate str = "F_WRLCK"; 17377c478bd9Sstevel@tonic-gate break; 17387c478bd9Sstevel@tonic-gate case F_UNLCK: 17397c478bd9Sstevel@tonic-gate str = "F_UNLCK"; 17407c478bd9Sstevel@tonic-gate break; 17417c478bd9Sstevel@tonic-gate } 17427c478bd9Sstevel@tonic-gate if (str != NULL) 17437c478bd9Sstevel@tonic-gate (void) printf("%s", str); 17447c478bd9Sstevel@tonic-gate else 17457c478bd9Sstevel@tonic-gate (void) printf("%-7d", flock.l_type); 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate str = whencearg(flock.l_whence); 17487c478bd9Sstevel@tonic-gate if (str != NULL) 17497c478bd9Sstevel@tonic-gate (void) printf(" whence=%s", str); 17507c478bd9Sstevel@tonic-gate else 17517c478bd9Sstevel@tonic-gate (void) printf(" whence=%-8u", flock.l_whence); 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate (void) printf( 17547c478bd9Sstevel@tonic-gate " start=%-5lld len=%-5lld sys=%-2u pid=%d\n", 17557c478bd9Sstevel@tonic-gate (long long)flock.l_start, 17567c478bd9Sstevel@tonic-gate (long long)flock.l_len, 17577c478bd9Sstevel@tonic-gate flock.l_sysid, 17587c478bd9Sstevel@tonic-gate (int)flock.l_pid); 17597c478bd9Sstevel@tonic-gate } 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate void 17637c478bd9Sstevel@tonic-gate show_share(private_t *pri, long offset) 17647c478bd9Sstevel@tonic-gate { 17657c478bd9Sstevel@tonic-gate struct fshare fshare; 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate if (Pread(Proc, &fshare, sizeof (fshare), offset) == sizeof (fshare)) { 17687c478bd9Sstevel@tonic-gate const char *str = NULL; 17697c478bd9Sstevel@tonic-gate int manddny = 0; 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate (void) printf("%s\taccess=", pri->pname); 17727c478bd9Sstevel@tonic-gate 17737c478bd9Sstevel@tonic-gate switch (fshare.f_access) { 17747c478bd9Sstevel@tonic-gate case F_RDACC: 17757c478bd9Sstevel@tonic-gate str = "F_RDACC"; 17767c478bd9Sstevel@tonic-gate break; 17777c478bd9Sstevel@tonic-gate case F_WRACC: 17787c478bd9Sstevel@tonic-gate str = "F_WRACC"; 17797c478bd9Sstevel@tonic-gate break; 17807c478bd9Sstevel@tonic-gate case F_RWACC: 17817c478bd9Sstevel@tonic-gate str = "F_RWACC"; 17827c478bd9Sstevel@tonic-gate break; 17837c478bd9Sstevel@tonic-gate } 17847c478bd9Sstevel@tonic-gate if (str != NULL) 17857c478bd9Sstevel@tonic-gate (void) printf("%s", str); 17867c478bd9Sstevel@tonic-gate else 17877c478bd9Sstevel@tonic-gate (void) printf("%-7d", fshare.f_access); 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate str = NULL; 17907c478bd9Sstevel@tonic-gate if (fshare.f_deny & F_MANDDNY) { 17917c478bd9Sstevel@tonic-gate fshare.f_deny &= ~F_MANDDNY; 17927c478bd9Sstevel@tonic-gate manddny = 1; 17937c478bd9Sstevel@tonic-gate } 17947c478bd9Sstevel@tonic-gate switch (fshare.f_deny) { 17957c478bd9Sstevel@tonic-gate case F_NODNY: 17967c478bd9Sstevel@tonic-gate str = "F_NODNY"; 17977c478bd9Sstevel@tonic-gate break; 17987c478bd9Sstevel@tonic-gate case F_RDDNY: 17997c478bd9Sstevel@tonic-gate str = "F_RDDNY"; 18007c478bd9Sstevel@tonic-gate break; 18017c478bd9Sstevel@tonic-gate case F_WRDNY: 18027c478bd9Sstevel@tonic-gate str = "F_WRDNY"; 18037c478bd9Sstevel@tonic-gate break; 18047c478bd9Sstevel@tonic-gate case F_RWDNY: 18057c478bd9Sstevel@tonic-gate str = "F_RWDNY"; 18067c478bd9Sstevel@tonic-gate break; 18077c478bd9Sstevel@tonic-gate case F_COMPAT: 18087c478bd9Sstevel@tonic-gate str = "F_COMPAT"; 18097c478bd9Sstevel@tonic-gate break; 18107c478bd9Sstevel@tonic-gate } 18117c478bd9Sstevel@tonic-gate if (str != NULL) { 18127c478bd9Sstevel@tonic-gate if (manddny) 18137c478bd9Sstevel@tonic-gate (void) printf(" deny=F_MANDDNY|%s", str); 18147c478bd9Sstevel@tonic-gate else 18157c478bd9Sstevel@tonic-gate (void) printf(" deny=%s", str); 18167c478bd9Sstevel@tonic-gate } else { 18177c478bd9Sstevel@tonic-gate (void) printf(" deny=0x%x", manddny? 18187c478bd9Sstevel@tonic-gate fshare.f_deny | F_MANDDNY : fshare.f_deny); 18197c478bd9Sstevel@tonic-gate } 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate (void) printf(" id=%x\n", fshare.f_id); 18227c478bd9Sstevel@tonic-gate } 18237c478bd9Sstevel@tonic-gate } 18247c478bd9Sstevel@tonic-gate 18257c478bd9Sstevel@tonic-gate void 18267c478bd9Sstevel@tonic-gate show_ffg(private_t *pri) 18277c478bd9Sstevel@tonic-gate { 18287c478bd9Sstevel@tonic-gate (void) putchar('\t'); 18297c478bd9Sstevel@tonic-gate (void) putchar('\t'); 18307c478bd9Sstevel@tonic-gate prt_ffg(pri, 0, pri->Rval1); 18317c478bd9Sstevel@tonic-gate (void) puts(pri->sys_string); 18327c478bd9Sstevel@tonic-gate } 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate /* print values in fcntl() pointed-to structure */ 18357c478bd9Sstevel@tonic-gate void 18367c478bd9Sstevel@tonic-gate show_fcntl(private_t *pri) 18377c478bd9Sstevel@tonic-gate { 18387c478bd9Sstevel@tonic-gate long offset; 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 2 && pri->sys_args[1] == F_GETFL) { 18417c478bd9Sstevel@tonic-gate show_ffg(pri); 18427c478bd9Sstevel@tonic-gate return; 18437c478bd9Sstevel@tonic-gate } 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 3 || (offset = pri->sys_args[2]) == NULL) 18467c478bd9Sstevel@tonic-gate return; 18477c478bd9Sstevel@tonic-gate 18487c478bd9Sstevel@tonic-gate switch (pri->sys_args[1]) { 18497c478bd9Sstevel@tonic-gate #ifdef _LP64 18507c478bd9Sstevel@tonic-gate case F_GETLK: 18517c478bd9Sstevel@tonic-gate case F_SETLK: 18527c478bd9Sstevel@tonic-gate case F_SETLKW: 18537c478bd9Sstevel@tonic-gate case F_FREESP: 18547c478bd9Sstevel@tonic-gate case F_ALLOCSP: 18557c478bd9Sstevel@tonic-gate case F_SETLK_NBMAND: 18567c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 18577c478bd9Sstevel@tonic-gate show_flock64(pri, offset); 18587c478bd9Sstevel@tonic-gate else 18597c478bd9Sstevel@tonic-gate show_flock32(pri, offset); 18607c478bd9Sstevel@tonic-gate break; 18617c478bd9Sstevel@tonic-gate case 33: /* F_GETLK64 */ 18627c478bd9Sstevel@tonic-gate case 34: /* F_SETLK64 */ 18637c478bd9Sstevel@tonic-gate case 35: /* F_SETLKW64 */ 18647c478bd9Sstevel@tonic-gate case 27: /* F_FREESP64 */ 18657c478bd9Sstevel@tonic-gate case 44: /* F_SETLK64_NBMAND */ 18667c478bd9Sstevel@tonic-gate show_flock64(pri, offset); 18677c478bd9Sstevel@tonic-gate break; 18687c478bd9Sstevel@tonic-gate #else /* _LP64 */ 18697c478bd9Sstevel@tonic-gate case F_GETLK: 18707c478bd9Sstevel@tonic-gate case F_SETLK: 18717c478bd9Sstevel@tonic-gate case F_SETLKW: 18727c478bd9Sstevel@tonic-gate case F_FREESP: 18737c478bd9Sstevel@tonic-gate case F_ALLOCSP: 18747c478bd9Sstevel@tonic-gate case F_SETLK_NBMAND: 18757c478bd9Sstevel@tonic-gate show_flock32(pri, offset); 18767c478bd9Sstevel@tonic-gate break; 18777c478bd9Sstevel@tonic-gate case F_GETLK64: 18787c478bd9Sstevel@tonic-gate case F_SETLK64: 18797c478bd9Sstevel@tonic-gate case F_SETLKW64: 18807c478bd9Sstevel@tonic-gate case F_FREESP64: 18817c478bd9Sstevel@tonic-gate case F_SETLK64_NBMAND: 18827c478bd9Sstevel@tonic-gate show_flock64(pri, offset); 18837c478bd9Sstevel@tonic-gate break; 18847c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 18857c478bd9Sstevel@tonic-gate case F_SHARE: 18867c478bd9Sstevel@tonic-gate case F_UNSHARE: 18877c478bd9Sstevel@tonic-gate show_share(pri, offset); 18887c478bd9Sstevel@tonic-gate break; 18897c478bd9Sstevel@tonic-gate } 18907c478bd9Sstevel@tonic-gate } 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate void 18937c478bd9Sstevel@tonic-gate show_strbuf(private_t *pri, long offset, const char *name, int dump) 18947c478bd9Sstevel@tonic-gate { 18957c478bd9Sstevel@tonic-gate struct strbuf strbuf; 18967c478bd9Sstevel@tonic-gate 18977c478bd9Sstevel@tonic-gate if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf)) 18987c478bd9Sstevel@tonic-gate print_strbuf(pri, &strbuf, name, dump); 18997c478bd9Sstevel@tonic-gate } 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate #ifdef _LP64 19027c478bd9Sstevel@tonic-gate void 19037c478bd9Sstevel@tonic-gate show_strbuf32(private_t *pri, long offset, const char *name, int dump) 19047c478bd9Sstevel@tonic-gate { 19057c478bd9Sstevel@tonic-gate struct strbuf32 strbuf; 19067c478bd9Sstevel@tonic-gate 19077c478bd9Sstevel@tonic-gate if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf)) 19087c478bd9Sstevel@tonic-gate print_strbuf32(pri, &strbuf, name, dump); 19097c478bd9Sstevel@tonic-gate } 19107c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate void 19137c478bd9Sstevel@tonic-gate show_gp_msg(private_t *pri, int what) 19147c478bd9Sstevel@tonic-gate { 19157c478bd9Sstevel@tonic-gate long offset; 19167c478bd9Sstevel@tonic-gate int dump = FALSE; 19177c478bd9Sstevel@tonic-gate int fdp1 = pri->sys_args[0] + 1; 19187c478bd9Sstevel@tonic-gate 19197c478bd9Sstevel@tonic-gate switch (what) { 19207c478bd9Sstevel@tonic-gate case SYS_getmsg: 19217c478bd9Sstevel@tonic-gate case SYS_getpmsg: 19227c478bd9Sstevel@tonic-gate if (pri->Errno == 0 && prismember(&readfd, fdp1)) 19237c478bd9Sstevel@tonic-gate dump = TRUE; 19247c478bd9Sstevel@tonic-gate break; 19257c478bd9Sstevel@tonic-gate case SYS_putmsg: 19267c478bd9Sstevel@tonic-gate case SYS_putpmsg: 19277c478bd9Sstevel@tonic-gate if (prismember(&writefd, fdp1)) 19287c478bd9Sstevel@tonic-gate dump = TRUE; 19297c478bd9Sstevel@tonic-gate break; 19307c478bd9Sstevel@tonic-gate } 19317c478bd9Sstevel@tonic-gate 19327c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 19337c478bd9Sstevel@tonic-gate if (dump) 19347c478bd9Sstevel@tonic-gate Eserialize(); 19357c478bd9Sstevel@tonic-gate 19367c478bd9Sstevel@tonic-gate #ifdef _LP64 19377c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL) { 19387c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 19397c478bd9Sstevel@tonic-gate show_strbuf(pri, offset, "ctl", dump); 19407c478bd9Sstevel@tonic-gate else 19417c478bd9Sstevel@tonic-gate show_strbuf32(pri, offset, "ctl", dump); 19427c478bd9Sstevel@tonic-gate } 19437c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL) { 19447c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 19457c478bd9Sstevel@tonic-gate show_strbuf(pri, offset, "dat", dump); 19467c478bd9Sstevel@tonic-gate else 19477c478bd9Sstevel@tonic-gate show_strbuf32(pri, offset, "dat", dump); 19487c478bd9Sstevel@tonic-gate } 19497c478bd9Sstevel@tonic-gate #else /* _LP64 */ 19507c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL) 19517c478bd9Sstevel@tonic-gate show_strbuf(pri, offset, "ctl", dump); 19527c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL) 19537c478bd9Sstevel@tonic-gate show_strbuf(pri, offset, "dat", dump); 19547c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 19557c478bd9Sstevel@tonic-gate 19567c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 19577c478bd9Sstevel@tonic-gate if (dump) 19587c478bd9Sstevel@tonic-gate Xserialize(); 19597c478bd9Sstevel@tonic-gate } 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate void 19627c478bd9Sstevel@tonic-gate show_int(private_t *pri, long offset, const char *name) 19637c478bd9Sstevel@tonic-gate { 19647c478bd9Sstevel@tonic-gate int value; 19657c478bd9Sstevel@tonic-gate 19667c478bd9Sstevel@tonic-gate if (offset != 0 && 19677c478bd9Sstevel@tonic-gate Pread(Proc, &value, sizeof (value), offset) == sizeof (value)) 19687c478bd9Sstevel@tonic-gate (void) printf("%s\t%s:\t%d\n", 19697c478bd9Sstevel@tonic-gate pri->pname, 19707c478bd9Sstevel@tonic-gate name, 19717c478bd9Sstevel@tonic-gate value); 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate 19747c478bd9Sstevel@tonic-gate void 19757c478bd9Sstevel@tonic-gate show_hhex_int(private_t *pri, long offset, const char *name) 19767c478bd9Sstevel@tonic-gate { 19777c478bd9Sstevel@tonic-gate int value; 19787c478bd9Sstevel@tonic-gate 19797c478bd9Sstevel@tonic-gate if (Pread(Proc, &value, sizeof (value), offset) == sizeof (value)) 19807c478bd9Sstevel@tonic-gate (void) printf("%s\t%s:\t0x%.4X\n", 19817c478bd9Sstevel@tonic-gate pri->pname, 19827c478bd9Sstevel@tonic-gate name, 19837c478bd9Sstevel@tonic-gate value); 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate 19867c478bd9Sstevel@tonic-gate #define ALL_POLL_FLAGS (POLLIN|POLLPRI|POLLOUT| \ 19877c478bd9Sstevel@tonic-gate POLLRDNORM|POLLRDBAND|POLLWRBAND|POLLERR|POLLHUP|POLLNVAL) 19887c478bd9Sstevel@tonic-gate 19897c478bd9Sstevel@tonic-gate const char * 19907c478bd9Sstevel@tonic-gate pollevent(private_t *pri, int arg) 19917c478bd9Sstevel@tonic-gate { 19927c478bd9Sstevel@tonic-gate char *str = pri->code_buf; 19937c478bd9Sstevel@tonic-gate 19947c478bd9Sstevel@tonic-gate if (arg == 0) 19957c478bd9Sstevel@tonic-gate return ("0"); 19967c478bd9Sstevel@tonic-gate if (arg & ~ALL_POLL_FLAGS) { 19977c478bd9Sstevel@tonic-gate (void) sprintf(str, "0x%-5X", arg); 19987c478bd9Sstevel@tonic-gate return ((const char *)str); 19997c478bd9Sstevel@tonic-gate } 20007c478bd9Sstevel@tonic-gate 20017c478bd9Sstevel@tonic-gate *str = '\0'; 20027c478bd9Sstevel@tonic-gate if (arg & POLLIN) 20037c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLIN"); 20047c478bd9Sstevel@tonic-gate if (arg & POLLPRI) 20057c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLPRI"); 20067c478bd9Sstevel@tonic-gate if (arg & POLLOUT) 20077c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLOUT"); 20087c478bd9Sstevel@tonic-gate if (arg & POLLRDNORM) 20097c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLRDNORM"); 20107c478bd9Sstevel@tonic-gate if (arg & POLLRDBAND) 20117c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLRDBAND"); 20127c478bd9Sstevel@tonic-gate if (arg & POLLWRBAND) 20137c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLWRBAND"); 20147c478bd9Sstevel@tonic-gate if (arg & POLLERR) 20157c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLERR"); 20167c478bd9Sstevel@tonic-gate if (arg & POLLHUP) 20177c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLHUP"); 20187c478bd9Sstevel@tonic-gate if (arg & POLLNVAL) 20197c478bd9Sstevel@tonic-gate (void) strcat(str, "|POLLNVAL"); 20207c478bd9Sstevel@tonic-gate 20217c478bd9Sstevel@tonic-gate return ((const char *)(str+1)); 20227c478bd9Sstevel@tonic-gate } 20237c478bd9Sstevel@tonic-gate 20247c478bd9Sstevel@tonic-gate static void 20257c478bd9Sstevel@tonic-gate show_one_pollfd(private_t *pri, struct pollfd *ppollfd) 20267c478bd9Sstevel@tonic-gate { 20277c478bd9Sstevel@tonic-gate /* 20287c478bd9Sstevel@tonic-gate * can't print both events and revents in same printf. 20297c478bd9Sstevel@tonic-gate * pollevent() returns a pointer to a TSD location. 20307c478bd9Sstevel@tonic-gate */ 20317c478bd9Sstevel@tonic-gate (void) printf("%s\tfd=%-2d ev=%s", 20327c478bd9Sstevel@tonic-gate pri->pname, ppollfd->fd, pollevent(pri, ppollfd->events)); 20337c478bd9Sstevel@tonic-gate (void) printf(" rev=%s\n", pollevent(pri, ppollfd->revents)); 20347c478bd9Sstevel@tonic-gate } 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate static void 20377c478bd9Sstevel@tonic-gate show_all_pollfds(private_t *pri, long offset, int nfds) 20387c478bd9Sstevel@tonic-gate { 20397c478bd9Sstevel@tonic-gate struct pollfd pollfd[2]; 20407c478bd9Sstevel@tonic-gate int skip = -1; 20417c478bd9Sstevel@tonic-gate 20427c478bd9Sstevel@tonic-gate for (; nfds && !interrupt; nfds--, offset += sizeof (struct pollfd)) { 20437c478bd9Sstevel@tonic-gate if (Pread(Proc, &pollfd[0], sizeof (struct pollfd), offset) != 20447c478bd9Sstevel@tonic-gate sizeof (struct pollfd)) 20457c478bd9Sstevel@tonic-gate continue; 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate if (skip >= 0 && pollfd[0].fd == pollfd[1].fd && 20487c478bd9Sstevel@tonic-gate pollfd[0].events == pollfd[1].events && 20497c478bd9Sstevel@tonic-gate pollfd[0].revents == pollfd[1].revents) { 20507c478bd9Sstevel@tonic-gate skip++; 20517c478bd9Sstevel@tonic-gate continue; 20527c478bd9Sstevel@tonic-gate } 20537c478bd9Sstevel@tonic-gate 20547c478bd9Sstevel@tonic-gate if (skip > 0) 20557c478bd9Sstevel@tonic-gate (void) printf("%s\t...last pollfd structure" 20567c478bd9Sstevel@tonic-gate " repeated %d time%s...\n", 20577c478bd9Sstevel@tonic-gate pri->pname, skip, (skip == 1 ? "" : "s")); 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate skip = 0; 20607c478bd9Sstevel@tonic-gate show_one_pollfd(pri, &pollfd[0]); 20617c478bd9Sstevel@tonic-gate pollfd[1] = pollfd[0]; 20627c478bd9Sstevel@tonic-gate } 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate if (skip > 0) 20657c478bd9Sstevel@tonic-gate (void) printf( 20667c478bd9Sstevel@tonic-gate "%s\t...last pollfd structure repeated %d time%s...\n", 20677c478bd9Sstevel@tonic-gate pri->pname, skip, (skip == 1 ? "" : "s")); 20687c478bd9Sstevel@tonic-gate } 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate void 20717c478bd9Sstevel@tonic-gate show_poll(private_t *pri) 20727c478bd9Sstevel@tonic-gate { 20737c478bd9Sstevel@tonic-gate long offset; 20747c478bd9Sstevel@tonic-gate int nfds; 20757c478bd9Sstevel@tonic-gate int serial = 0; 20767c478bd9Sstevel@tonic-gate 20777c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 2 || (offset = pri->sys_args[0]) == NULL || 20787c478bd9Sstevel@tonic-gate (nfds = pri->sys_args[1]) <= 0) 20797c478bd9Sstevel@tonic-gate return; 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 20827c478bd9Sstevel@tonic-gate if (nfds > 32) { 20837c478bd9Sstevel@tonic-gate Eserialize(); 20847c478bd9Sstevel@tonic-gate serial = 1; 20857c478bd9Sstevel@tonic-gate } 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate show_all_pollfds(pri, offset, nfds); 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 20907c478bd9Sstevel@tonic-gate if (serial) 20917c478bd9Sstevel@tonic-gate Xserialize(); 20927c478bd9Sstevel@tonic-gate } 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate void 20957c478bd9Sstevel@tonic-gate show_pollsys(private_t *pri) 20967c478bd9Sstevel@tonic-gate { 20977c478bd9Sstevel@tonic-gate long offset; 20987c478bd9Sstevel@tonic-gate int nfds; 20997c478bd9Sstevel@tonic-gate int serial = 0; 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 2) 21027c478bd9Sstevel@tonic-gate return; 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate offset = pri->sys_args[0]; 21057c478bd9Sstevel@tonic-gate nfds = pri->sys_args[1]; 21067c478bd9Sstevel@tonic-gate 21077c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 21087c478bd9Sstevel@tonic-gate if (offset != NULL && nfds > 32) { 21097c478bd9Sstevel@tonic-gate Eserialize(); 21107c478bd9Sstevel@tonic-gate serial = 1; 21117c478bd9Sstevel@tonic-gate } 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate if (offset != NULL && nfds > 0) 21147c478bd9Sstevel@tonic-gate show_all_pollfds(pri, offset, nfds); 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2) 21177c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[2], "timeout"); 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) 21207c478bd9Sstevel@tonic-gate show_sigset(pri, (long)pri->sys_args[3], "sigmask"); 21217c478bd9Sstevel@tonic-gate 21227c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 21237c478bd9Sstevel@tonic-gate if (serial) 21247c478bd9Sstevel@tonic-gate Xserialize(); 21257c478bd9Sstevel@tonic-gate } 21267c478bd9Sstevel@tonic-gate 21277c478bd9Sstevel@tonic-gate static void 21287c478bd9Sstevel@tonic-gate show_perm64(private_t *pri, struct ipc_perm64 *ip) 21297c478bd9Sstevel@tonic-gate { 21307c478bd9Sstevel@tonic-gate (void) printf("%s\tu=%-5d g=%-5d cu=%-5d cg=%-5d z=%-5d " 21317c478bd9Sstevel@tonic-gate "m=0%.6o key=%d projid=%-5d\n", 21327c478bd9Sstevel@tonic-gate pri->pname, 21337c478bd9Sstevel@tonic-gate (int)ip->ipcx_uid, 21347c478bd9Sstevel@tonic-gate (int)ip->ipcx_gid, 21357c478bd9Sstevel@tonic-gate (int)ip->ipcx_cuid, 21367c478bd9Sstevel@tonic-gate (int)ip->ipcx_cgid, 21377c478bd9Sstevel@tonic-gate (int)ip->ipcx_zoneid, 21387c478bd9Sstevel@tonic-gate (unsigned int)ip->ipcx_mode, 21397c478bd9Sstevel@tonic-gate ip->ipcx_key, 21407c478bd9Sstevel@tonic-gate (int)ip->ipcx_projid); 21417c478bd9Sstevel@tonic-gate } 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate void 21447c478bd9Sstevel@tonic-gate show_perm(private_t *pri, struct ipc_perm *ip) 21457c478bd9Sstevel@tonic-gate { 21467c478bd9Sstevel@tonic-gate (void) printf( 21477c478bd9Sstevel@tonic-gate "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n", 21487c478bd9Sstevel@tonic-gate pri->pname, 21497c478bd9Sstevel@tonic-gate (int)ip->uid, 21507c478bd9Sstevel@tonic-gate (int)ip->gid, 21517c478bd9Sstevel@tonic-gate (int)ip->cuid, 21527c478bd9Sstevel@tonic-gate (int)ip->cgid, 21537c478bd9Sstevel@tonic-gate (int)ip->mode, 21547c478bd9Sstevel@tonic-gate ip->seq, 21557c478bd9Sstevel@tonic-gate ip->key); 21567c478bd9Sstevel@tonic-gate } 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate #ifdef _LP64 21597c478bd9Sstevel@tonic-gate void 21607c478bd9Sstevel@tonic-gate show_perm32(private_t *pri, struct ipc_perm32 *ip) 21617c478bd9Sstevel@tonic-gate { 21627c478bd9Sstevel@tonic-gate (void) printf( 21637c478bd9Sstevel@tonic-gate "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n", 21647c478bd9Sstevel@tonic-gate pri->pname, 21657c478bd9Sstevel@tonic-gate ip->uid, 21667c478bd9Sstevel@tonic-gate ip->gid, 21677c478bd9Sstevel@tonic-gate ip->cuid, 21687c478bd9Sstevel@tonic-gate ip->cgid, 21697c478bd9Sstevel@tonic-gate ip->mode, 21707c478bd9Sstevel@tonic-gate ip->seq, 21717c478bd9Sstevel@tonic-gate ip->key); 21727c478bd9Sstevel@tonic-gate } 21737c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 21747c478bd9Sstevel@tonic-gate 21757c478bd9Sstevel@tonic-gate static void 21767c478bd9Sstevel@tonic-gate show_msgctl64(private_t *pri, long offset) 21777c478bd9Sstevel@tonic-gate { 21787c478bd9Sstevel@tonic-gate struct msqid_ds64 msgq; 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate if (offset != NULL && 21817c478bd9Sstevel@tonic-gate Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) { 21827c478bd9Sstevel@tonic-gate show_perm64(pri, &msgq.msgx_perm); 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate (void) printf("%s\tbytes=%-5llu msgs=%-5llu maxby=%-5llu " 21857c478bd9Sstevel@tonic-gate "lspid=%-5d lrpid=%-5d\n", pri->pname, 21867c478bd9Sstevel@tonic-gate (unsigned long long)msgq.msgx_cbytes, 21877c478bd9Sstevel@tonic-gate (unsigned long long)msgq.msgx_qnum, 21887c478bd9Sstevel@tonic-gate (unsigned long long)msgq.msgx_qbytes, 21897c478bd9Sstevel@tonic-gate (int)msgq.msgx_lspid, 21907c478bd9Sstevel@tonic-gate (int)msgq.msgx_lrpid); 21917c478bd9Sstevel@tonic-gate 21927c478bd9Sstevel@tonic-gate prtime(pri, " st = ", (time_t)msgq.msgx_stime); 21937c478bd9Sstevel@tonic-gate prtime(pri, " rt = ", (time_t)msgq.msgx_rtime); 21947c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", (time_t)msgq.msgx_ctime); 21957c478bd9Sstevel@tonic-gate } 21967c478bd9Sstevel@tonic-gate } 21977c478bd9Sstevel@tonic-gate 21987c478bd9Sstevel@tonic-gate void 21997c478bd9Sstevel@tonic-gate show_msgctl(private_t *pri, long offset) 22007c478bd9Sstevel@tonic-gate { 22017c478bd9Sstevel@tonic-gate struct msqid_ds msgq; 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate if (offset != NULL && 22047c478bd9Sstevel@tonic-gate Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) { 22057c478bd9Sstevel@tonic-gate show_perm(pri, &msgq.msg_perm); 22067c478bd9Sstevel@tonic-gate 22077c478bd9Sstevel@tonic-gate (void) printf( 22087c478bd9Sstevel@tonic-gate "%s\tbytes=%-5lu msgs=%-5lu maxby=%-5lu lspid=%-5u lrpid=%-5u\n", 22097c478bd9Sstevel@tonic-gate pri->pname, 22107c478bd9Sstevel@tonic-gate msgq.msg_cbytes, 22117c478bd9Sstevel@tonic-gate msgq.msg_qnum, 22127c478bd9Sstevel@tonic-gate msgq.msg_qbytes, 22137c478bd9Sstevel@tonic-gate (int)msgq.msg_lspid, 22147c478bd9Sstevel@tonic-gate (int)msgq.msg_lrpid); 22157c478bd9Sstevel@tonic-gate 22167c478bd9Sstevel@tonic-gate prtime(pri, " st = ", msgq.msg_stime); 22177c478bd9Sstevel@tonic-gate prtime(pri, " rt = ", msgq.msg_rtime); 22187c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", msgq.msg_ctime); 22197c478bd9Sstevel@tonic-gate } 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate 22227c478bd9Sstevel@tonic-gate #ifdef _LP64 22237c478bd9Sstevel@tonic-gate void 22247c478bd9Sstevel@tonic-gate show_msgctl32(private_t *pri, long offset) 22257c478bd9Sstevel@tonic-gate { 22267c478bd9Sstevel@tonic-gate struct msqid_ds32 msgq; 22277c478bd9Sstevel@tonic-gate 22287c478bd9Sstevel@tonic-gate if (offset != NULL && 22297c478bd9Sstevel@tonic-gate Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) { 22307c478bd9Sstevel@tonic-gate show_perm32(pri, &msgq.msg_perm); 22317c478bd9Sstevel@tonic-gate 22327c478bd9Sstevel@tonic-gate (void) printf( 22337c478bd9Sstevel@tonic-gate "%s\tbytes=%-5u msgs=%-5u maxby=%-5u lspid=%-5u lrpid=%-5u\n", 22347c478bd9Sstevel@tonic-gate pri->pname, 22357c478bd9Sstevel@tonic-gate msgq.msg_cbytes, 22367c478bd9Sstevel@tonic-gate msgq.msg_qnum, 22377c478bd9Sstevel@tonic-gate msgq.msg_qbytes, 22387c478bd9Sstevel@tonic-gate msgq.msg_lspid, 22397c478bd9Sstevel@tonic-gate msgq.msg_lrpid); 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate prtime(pri, " st = ", msgq.msg_stime); 22427c478bd9Sstevel@tonic-gate prtime(pri, " rt = ", msgq.msg_rtime); 22437c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", msgq.msg_ctime); 22447c478bd9Sstevel@tonic-gate } 22457c478bd9Sstevel@tonic-gate } 22467c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 22477c478bd9Sstevel@tonic-gate 22487c478bd9Sstevel@tonic-gate void 22497c478bd9Sstevel@tonic-gate show_msgbuf(private_t *pri, long offset, long msgsz) 22507c478bd9Sstevel@tonic-gate { 22517c478bd9Sstevel@tonic-gate struct msgbuf msgb; 22527c478bd9Sstevel@tonic-gate 22537c478bd9Sstevel@tonic-gate if (offset != NULL && 22547c478bd9Sstevel@tonic-gate Pread(Proc, &msgb, sizeof (msgb.mtype), offset) == 22557c478bd9Sstevel@tonic-gate sizeof (msgb.mtype)) { 22567c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 22577c478bd9Sstevel@tonic-gate if (msgsz > MYBUFSIZ / 4) 22587c478bd9Sstevel@tonic-gate Eserialize(); 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate (void) printf("%s\tmtype=%lu mtext[]=\n", 22617c478bd9Sstevel@tonic-gate pri->pname, 22627c478bd9Sstevel@tonic-gate msgb.mtype); 22637c478bd9Sstevel@tonic-gate showbuffer(pri, 22647c478bd9Sstevel@tonic-gate (long)(offset + sizeof (msgb.mtype)), msgsz); 22657c478bd9Sstevel@tonic-gate 22667c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 22677c478bd9Sstevel@tonic-gate if (msgsz > MYBUFSIZ / 4) 22687c478bd9Sstevel@tonic-gate Xserialize(); 22697c478bd9Sstevel@tonic-gate } 22707c478bd9Sstevel@tonic-gate } 22717c478bd9Sstevel@tonic-gate 22727c478bd9Sstevel@tonic-gate #ifdef _LP64 22737c478bd9Sstevel@tonic-gate void 22747c478bd9Sstevel@tonic-gate show_msgbuf32(private_t *pri, long offset, long msgsz) 22757c478bd9Sstevel@tonic-gate { 22767c478bd9Sstevel@tonic-gate struct ipcmsgbuf32 msgb; 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate if (offset != NULL && 22797c478bd9Sstevel@tonic-gate Pread(Proc, &msgb, sizeof (msgb.mtype), offset) == 22807c478bd9Sstevel@tonic-gate sizeof (msgb.mtype)) { 22817c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 22827c478bd9Sstevel@tonic-gate if (msgsz > MYBUFSIZ / 4) 22837c478bd9Sstevel@tonic-gate Eserialize(); 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate (void) printf("%s\tmtype=%u mtext[]=\n", 22867c478bd9Sstevel@tonic-gate pri->pname, 22877c478bd9Sstevel@tonic-gate msgb.mtype); 22887c478bd9Sstevel@tonic-gate showbuffer(pri, 22897c478bd9Sstevel@tonic-gate (long)(offset + sizeof (msgb.mtype)), msgsz); 22907c478bd9Sstevel@tonic-gate 22917c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 22927c478bd9Sstevel@tonic-gate if (msgsz > MYBUFSIZ / 4) 22937c478bd9Sstevel@tonic-gate Xserialize(); 22947c478bd9Sstevel@tonic-gate } 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 22977c478bd9Sstevel@tonic-gate 22987c478bd9Sstevel@tonic-gate #ifdef _LP64 22997c478bd9Sstevel@tonic-gate void 23007c478bd9Sstevel@tonic-gate show_msgsys(private_t *pri, long msgsz) 23017c478bd9Sstevel@tonic-gate { 23027c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 23037c478bd9Sstevel@tonic-gate case 0: /* msgget() */ 23047c478bd9Sstevel@tonic-gate break; 23057c478bd9Sstevel@tonic-gate case 1: /* msgctl() */ 23067c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) { 23077c478bd9Sstevel@tonic-gate switch (pri->sys_args[2]) { 23087c478bd9Sstevel@tonic-gate case IPC_STAT: 23097c478bd9Sstevel@tonic-gate if (pri->Errno) 23107c478bd9Sstevel@tonic-gate break; 23117c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 23127c478bd9Sstevel@tonic-gate case IPC_SET: 23137c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 23147c478bd9Sstevel@tonic-gate show_msgctl(pri, 23157c478bd9Sstevel@tonic-gate (long)pri->sys_args[3]); 23167c478bd9Sstevel@tonic-gate else 23177c478bd9Sstevel@tonic-gate show_msgctl32(pri, 23187c478bd9Sstevel@tonic-gate (long)pri->sys_args[3]); 23197c478bd9Sstevel@tonic-gate break; 23207c478bd9Sstevel@tonic-gate case IPC_STAT64: 23217c478bd9Sstevel@tonic-gate if (pri->Errno) 23227c478bd9Sstevel@tonic-gate break; 23237c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 23247c478bd9Sstevel@tonic-gate case IPC_SET64: 23257c478bd9Sstevel@tonic-gate show_msgctl64(pri, (long)pri->sys_args[3]); 23267c478bd9Sstevel@tonic-gate break; 23277c478bd9Sstevel@tonic-gate } 23287c478bd9Sstevel@tonic-gate } 23297c478bd9Sstevel@tonic-gate break; 23307c478bd9Sstevel@tonic-gate case 2: /* msgrcv() */ 23317c478bd9Sstevel@tonic-gate if (!pri->Errno && pri->sys_nargs > 2) { 23327c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 23337c478bd9Sstevel@tonic-gate show_msgbuf(pri, pri->sys_args[2], msgsz); 23347c478bd9Sstevel@tonic-gate else 23357c478bd9Sstevel@tonic-gate show_msgbuf32(pri, pri->sys_args[2], msgsz); 23367c478bd9Sstevel@tonic-gate } 23377c478bd9Sstevel@tonic-gate break; 23387c478bd9Sstevel@tonic-gate case 3: /* msgsnd() */ 23397c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) { 23407c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 23417c478bd9Sstevel@tonic-gate show_msgbuf(pri, pri->sys_args[2], 23427c478bd9Sstevel@tonic-gate pri->sys_args[3]); 23437c478bd9Sstevel@tonic-gate else 23447c478bd9Sstevel@tonic-gate show_msgbuf32(pri, pri->sys_args[2], 23457c478bd9Sstevel@tonic-gate pri->sys_args[3]); 23467c478bd9Sstevel@tonic-gate } 23477c478bd9Sstevel@tonic-gate break; 23487c478bd9Sstevel@tonic-gate case 4: /* msgids() */ 23497c478bd9Sstevel@tonic-gate case 5: /* msgsnap() */ 23507c478bd9Sstevel@tonic-gate default: /* unexpected subcode */ 23517c478bd9Sstevel@tonic-gate break; 23527c478bd9Sstevel@tonic-gate } 23537c478bd9Sstevel@tonic-gate } 23547c478bd9Sstevel@tonic-gate #else /* _LP64 */ 23557c478bd9Sstevel@tonic-gate void 23567c478bd9Sstevel@tonic-gate show_msgsys(private_t *pri, long msgsz) 23577c478bd9Sstevel@tonic-gate { 23587c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 23597c478bd9Sstevel@tonic-gate case 0: /* msgget() */ 23607c478bd9Sstevel@tonic-gate break; 23617c478bd9Sstevel@tonic-gate case 1: /* msgctl() */ 23627c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) { 23637c478bd9Sstevel@tonic-gate switch (pri->sys_args[2]) { 23647c478bd9Sstevel@tonic-gate case IPC_STAT: 23657c478bd9Sstevel@tonic-gate if (pri->Errno) 23667c478bd9Sstevel@tonic-gate break; 23677c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 23687c478bd9Sstevel@tonic-gate case IPC_SET: 23697c478bd9Sstevel@tonic-gate show_msgctl(pri, (long)pri->sys_args[3]); 23707c478bd9Sstevel@tonic-gate break; 23717c478bd9Sstevel@tonic-gate case IPC_STAT64: 23727c478bd9Sstevel@tonic-gate if (pri->Errno) 23737c478bd9Sstevel@tonic-gate break; 23747c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 23757c478bd9Sstevel@tonic-gate case IPC_SET64: 23767c478bd9Sstevel@tonic-gate show_msgctl64(pri, (long)pri->sys_args[3]); 23777c478bd9Sstevel@tonic-gate break; 23787c478bd9Sstevel@tonic-gate } 23797c478bd9Sstevel@tonic-gate } 23807c478bd9Sstevel@tonic-gate break; 23817c478bd9Sstevel@tonic-gate case 2: /* msgrcv() */ 23827c478bd9Sstevel@tonic-gate if (!pri->Errno && pri->sys_nargs > 2) 23837c478bd9Sstevel@tonic-gate show_msgbuf(pri, pri->sys_args[2], msgsz); 23847c478bd9Sstevel@tonic-gate break; 23857c478bd9Sstevel@tonic-gate case 3: /* msgsnd() */ 23867c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) 23877c478bd9Sstevel@tonic-gate show_msgbuf(pri, pri->sys_args[2], 23887c478bd9Sstevel@tonic-gate pri->sys_args[3]); 23897c478bd9Sstevel@tonic-gate break; 23907c478bd9Sstevel@tonic-gate case 4: /* msgids() */ 23917c478bd9Sstevel@tonic-gate case 5: /* msgsnap() */ 23927c478bd9Sstevel@tonic-gate default: /* unexpected subcode */ 23937c478bd9Sstevel@tonic-gate break; 23947c478bd9Sstevel@tonic-gate } 23957c478bd9Sstevel@tonic-gate } 23967c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 23977c478bd9Sstevel@tonic-gate 23987c478bd9Sstevel@tonic-gate static void 23997c478bd9Sstevel@tonic-gate show_semctl64(private_t *pri, long offset) 24007c478bd9Sstevel@tonic-gate { 24017c478bd9Sstevel@tonic-gate struct semid_ds64 semds; 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate if (offset != NULL && 24047c478bd9Sstevel@tonic-gate Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) { 24057c478bd9Sstevel@tonic-gate show_perm64(pri, &semds.semx_perm); 24067c478bd9Sstevel@tonic-gate 24077c478bd9Sstevel@tonic-gate (void) printf("%s\tnsems=%u\n", pri->pname, semds.semx_nsems); 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate prtime(pri, " ot = ", (time_t)semds.semx_otime); 24107c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", (time_t)semds.semx_ctime); 24117c478bd9Sstevel@tonic-gate } 24127c478bd9Sstevel@tonic-gate } 24137c478bd9Sstevel@tonic-gate 24147c478bd9Sstevel@tonic-gate void 24157c478bd9Sstevel@tonic-gate show_semctl(private_t *pri, long offset) 24167c478bd9Sstevel@tonic-gate { 24177c478bd9Sstevel@tonic-gate struct semid_ds semds; 24187c478bd9Sstevel@tonic-gate 24197c478bd9Sstevel@tonic-gate if (offset != NULL && 24207c478bd9Sstevel@tonic-gate Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) { 24217c478bd9Sstevel@tonic-gate show_perm(pri, &semds.sem_perm); 24227c478bd9Sstevel@tonic-gate 24237c478bd9Sstevel@tonic-gate (void) printf("%s\tnsems=%u\n", 24247c478bd9Sstevel@tonic-gate pri->pname, 24257c478bd9Sstevel@tonic-gate semds.sem_nsems); 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate prtime(pri, " ot = ", semds.sem_otime); 24287c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", semds.sem_ctime); 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate } 24317c478bd9Sstevel@tonic-gate 24327c478bd9Sstevel@tonic-gate #ifdef _LP64 24337c478bd9Sstevel@tonic-gate void 24347c478bd9Sstevel@tonic-gate show_semctl32(private_t *pri, long offset) 24357c478bd9Sstevel@tonic-gate { 24367c478bd9Sstevel@tonic-gate struct semid_ds32 semds; 24377c478bd9Sstevel@tonic-gate 24387c478bd9Sstevel@tonic-gate if (offset != NULL && 24397c478bd9Sstevel@tonic-gate Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) { 24407c478bd9Sstevel@tonic-gate show_perm32(pri, &semds.sem_perm); 24417c478bd9Sstevel@tonic-gate 24427c478bd9Sstevel@tonic-gate (void) printf("%s\tnsems=%u\n", 24437c478bd9Sstevel@tonic-gate pri->pname, 24447c478bd9Sstevel@tonic-gate semds.sem_nsems); 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate prtime(pri, " ot = ", semds.sem_otime); 24477c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", semds.sem_ctime); 24487c478bd9Sstevel@tonic-gate } 24497c478bd9Sstevel@tonic-gate } 24507c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 24517c478bd9Sstevel@tonic-gate 24527c478bd9Sstevel@tonic-gate void 24537c478bd9Sstevel@tonic-gate show_semop(private_t *pri, long offset, long nsops, long timeout) 24547c478bd9Sstevel@tonic-gate { 24557c478bd9Sstevel@tonic-gate struct sembuf sembuf; 24567c478bd9Sstevel@tonic-gate const char *str; 24577c478bd9Sstevel@tonic-gate 24587c478bd9Sstevel@tonic-gate if (offset == NULL) 24597c478bd9Sstevel@tonic-gate return; 24607c478bd9Sstevel@tonic-gate 24617c478bd9Sstevel@tonic-gate if (nsops > 40) /* let's not be ridiculous */ 24627c478bd9Sstevel@tonic-gate nsops = 40; 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate for (; nsops > 0 && !interrupt; --nsops, offset += sizeof (sembuf)) { 24657c478bd9Sstevel@tonic-gate if (Pread(Proc, &sembuf, sizeof (sembuf), offset) != 24667c478bd9Sstevel@tonic-gate sizeof (sembuf)) 24677c478bd9Sstevel@tonic-gate break; 24687c478bd9Sstevel@tonic-gate 24697c478bd9Sstevel@tonic-gate (void) printf("%s\tsemnum=%-5u semop=%-5d semflg=", 24707c478bd9Sstevel@tonic-gate pri->pname, 24717c478bd9Sstevel@tonic-gate sembuf.sem_num, 24727c478bd9Sstevel@tonic-gate sembuf.sem_op); 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate if (sembuf.sem_flg == 0) 24757c478bd9Sstevel@tonic-gate (void) printf("0\n"); 24767c478bd9Sstevel@tonic-gate else if ((str = semflags(pri, sembuf.sem_flg)) != NULL) 24777c478bd9Sstevel@tonic-gate (void) printf("%s\n", str); 24787c478bd9Sstevel@tonic-gate else 24797c478bd9Sstevel@tonic-gate (void) printf("0%.6o\n", sembuf.sem_flg); 24807c478bd9Sstevel@tonic-gate } 24817c478bd9Sstevel@tonic-gate if (timeout) 24827c478bd9Sstevel@tonic-gate show_timestruc(pri, timeout, "timeout"); 24837c478bd9Sstevel@tonic-gate } 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate void 24867c478bd9Sstevel@tonic-gate show_semsys(private_t *pri) 24877c478bd9Sstevel@tonic-gate { 24887c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 24897c478bd9Sstevel@tonic-gate case 0: /* semctl() */ 24907c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 4) { 24917c478bd9Sstevel@tonic-gate switch (pri->sys_args[3]) { 24927c478bd9Sstevel@tonic-gate case IPC_STAT: 24937c478bd9Sstevel@tonic-gate if (pri->Errno) 24947c478bd9Sstevel@tonic-gate break; 24957c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 24967c478bd9Sstevel@tonic-gate case IPC_SET: 24977c478bd9Sstevel@tonic-gate #ifdef _LP64 24987c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 24997c478bd9Sstevel@tonic-gate show_semctl(pri, 25007c478bd9Sstevel@tonic-gate (long)pri->sys_args[4]); 25017c478bd9Sstevel@tonic-gate else 25027c478bd9Sstevel@tonic-gate show_semctl32(pri, 25037c478bd9Sstevel@tonic-gate (long)pri->sys_args[4]); 25047c478bd9Sstevel@tonic-gate #else 25057c478bd9Sstevel@tonic-gate show_semctl(pri, (long)pri->sys_args[4]); 25067c478bd9Sstevel@tonic-gate #endif 25077c478bd9Sstevel@tonic-gate break; 25087c478bd9Sstevel@tonic-gate case IPC_STAT64: 25097c478bd9Sstevel@tonic-gate if (pri->Errno) 25107c478bd9Sstevel@tonic-gate break; 25117c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 25127c478bd9Sstevel@tonic-gate case IPC_SET64: 25137c478bd9Sstevel@tonic-gate show_semctl64(pri, (long)pri->sys_args[4]); 25147c478bd9Sstevel@tonic-gate break; 25157c478bd9Sstevel@tonic-gate } 25167c478bd9Sstevel@tonic-gate } 25177c478bd9Sstevel@tonic-gate break; 25187c478bd9Sstevel@tonic-gate case 1: /* semget() */ 25197c478bd9Sstevel@tonic-gate break; 25207c478bd9Sstevel@tonic-gate case 2: /* semop() */ 25217c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) 25227c478bd9Sstevel@tonic-gate show_semop(pri, (long)pri->sys_args[2], 25237c478bd9Sstevel@tonic-gate pri->sys_args[3], 0); 25247c478bd9Sstevel@tonic-gate break; 25257c478bd9Sstevel@tonic-gate case 3: /* semids() */ 25267c478bd9Sstevel@tonic-gate break; 25277c478bd9Sstevel@tonic-gate case 4: /* semtimedop() */ 25287c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 4) 25297c478bd9Sstevel@tonic-gate show_semop(pri, (long)pri->sys_args[2], 25307c478bd9Sstevel@tonic-gate pri->sys_args[3], pri->sys_args[4]); 25317c478bd9Sstevel@tonic-gate break; 25327c478bd9Sstevel@tonic-gate default: /* unexpected subcode */ 25337c478bd9Sstevel@tonic-gate break; 25347c478bd9Sstevel@tonic-gate } 25357c478bd9Sstevel@tonic-gate } 25367c478bd9Sstevel@tonic-gate 25377c478bd9Sstevel@tonic-gate static void 25387c478bd9Sstevel@tonic-gate show_shmctl64(private_t *pri, long offset) 25397c478bd9Sstevel@tonic-gate { 25407c478bd9Sstevel@tonic-gate struct shmid_ds64 shmds; 25417c478bd9Sstevel@tonic-gate 25427c478bd9Sstevel@tonic-gate if (offset != NULL && 25437c478bd9Sstevel@tonic-gate Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) { 25447c478bd9Sstevel@tonic-gate show_perm64(pri, &shmds.shmx_perm); 25457c478bd9Sstevel@tonic-gate 25467c478bd9Sstevel@tonic-gate (void) printf( 25477c478bd9Sstevel@tonic-gate "%s\tsize=%-6llu lpid=%-5d cpid=%-5d na=%-5llu cna=%llu\n", 25487c478bd9Sstevel@tonic-gate pri->pname, 25497c478bd9Sstevel@tonic-gate (unsigned long long)shmds.shmx_segsz, 25507c478bd9Sstevel@tonic-gate (int)shmds.shmx_lpid, 25517c478bd9Sstevel@tonic-gate (int)shmds.shmx_cpid, 25527c478bd9Sstevel@tonic-gate (unsigned long long)shmds.shmx_nattch, 25537c478bd9Sstevel@tonic-gate (unsigned long long)shmds.shmx_cnattch); 25547c478bd9Sstevel@tonic-gate 25557c478bd9Sstevel@tonic-gate prtime(pri, " at = ", (time_t)shmds.shmx_atime); 25567c478bd9Sstevel@tonic-gate prtime(pri, " dt = ", (time_t)shmds.shmx_dtime); 25577c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", (time_t)shmds.shmx_ctime); 25587c478bd9Sstevel@tonic-gate } 25597c478bd9Sstevel@tonic-gate } 25607c478bd9Sstevel@tonic-gate 25617c478bd9Sstevel@tonic-gate void 25627c478bd9Sstevel@tonic-gate show_shmctl(private_t *pri, long offset) 25637c478bd9Sstevel@tonic-gate { 25647c478bd9Sstevel@tonic-gate struct shmid_ds shmds; 25657c478bd9Sstevel@tonic-gate 25667c478bd9Sstevel@tonic-gate if (offset != NULL && 25677c478bd9Sstevel@tonic-gate Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) { 25687c478bd9Sstevel@tonic-gate show_perm(pri, &shmds.shm_perm); 25697c478bd9Sstevel@tonic-gate 25707c478bd9Sstevel@tonic-gate (void) printf( 25717c478bd9Sstevel@tonic-gate "%s\tsize=%-6lu lpid=%-5u cpid=%-5u na=%-5lu cna=%lu\n", 25727c478bd9Sstevel@tonic-gate pri->pname, 25737c478bd9Sstevel@tonic-gate (ulong_t)shmds.shm_segsz, 25747c478bd9Sstevel@tonic-gate (int)shmds.shm_lpid, 25757c478bd9Sstevel@tonic-gate (int)shmds.shm_cpid, 25767c478bd9Sstevel@tonic-gate shmds.shm_nattch, 25777c478bd9Sstevel@tonic-gate shmds.shm_cnattch); 25787c478bd9Sstevel@tonic-gate 25797c478bd9Sstevel@tonic-gate prtime(pri, " at = ", shmds.shm_atime); 25807c478bd9Sstevel@tonic-gate prtime(pri, " dt = ", shmds.shm_dtime); 25817c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", shmds.shm_ctime); 25827c478bd9Sstevel@tonic-gate } 25837c478bd9Sstevel@tonic-gate } 25847c478bd9Sstevel@tonic-gate 25857c478bd9Sstevel@tonic-gate #ifdef _LP64 25867c478bd9Sstevel@tonic-gate void 25877c478bd9Sstevel@tonic-gate show_shmctl32(private_t *pri, long offset) 25887c478bd9Sstevel@tonic-gate { 25897c478bd9Sstevel@tonic-gate struct shmid_ds32 shmds; 25907c478bd9Sstevel@tonic-gate 25917c478bd9Sstevel@tonic-gate if (offset != NULL && 25927c478bd9Sstevel@tonic-gate Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) { 25937c478bd9Sstevel@tonic-gate show_perm32(pri, &shmds.shm_perm); 25947c478bd9Sstevel@tonic-gate 25957c478bd9Sstevel@tonic-gate (void) printf( 25967c478bd9Sstevel@tonic-gate "%s\tsize=%-6u lpid=%-5u cpid=%-5u na=%-5u cna=%u\n", 25977c478bd9Sstevel@tonic-gate pri->pname, 25987c478bd9Sstevel@tonic-gate shmds.shm_segsz, 25997c478bd9Sstevel@tonic-gate shmds.shm_lpid, 26007c478bd9Sstevel@tonic-gate shmds.shm_cpid, 26017c478bd9Sstevel@tonic-gate shmds.shm_nattch, 26027c478bd9Sstevel@tonic-gate shmds.shm_cnattch); 26037c478bd9Sstevel@tonic-gate 26047c478bd9Sstevel@tonic-gate prtime(pri, " at = ", shmds.shm_atime); 26057c478bd9Sstevel@tonic-gate prtime(pri, " dt = ", shmds.shm_dtime); 26067c478bd9Sstevel@tonic-gate prtime(pri, " ct = ", shmds.shm_ctime); 26077c478bd9Sstevel@tonic-gate } 26087c478bd9Sstevel@tonic-gate } 26097c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 26107c478bd9Sstevel@tonic-gate 26117c478bd9Sstevel@tonic-gate void 26127c478bd9Sstevel@tonic-gate show_shmsys(private_t *pri) 26137c478bd9Sstevel@tonic-gate { 26147c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 26157c478bd9Sstevel@tonic-gate case 0: /* shmat() */ 26167c478bd9Sstevel@tonic-gate break; 26177c478bd9Sstevel@tonic-gate case 1: /* shmctl() */ 26187c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) { 26197c478bd9Sstevel@tonic-gate switch (pri->sys_args[2]) { 26207c478bd9Sstevel@tonic-gate case IPC_STAT: 26217c478bd9Sstevel@tonic-gate if (pri->Errno) 26227c478bd9Sstevel@tonic-gate break; 26237c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 26247c478bd9Sstevel@tonic-gate case IPC_SET: 26257c478bd9Sstevel@tonic-gate #ifdef _LP64 26267c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 26277c478bd9Sstevel@tonic-gate show_shmctl(pri, 26287c478bd9Sstevel@tonic-gate (long)pri->sys_args[3]); 26297c478bd9Sstevel@tonic-gate else 26307c478bd9Sstevel@tonic-gate show_shmctl32(pri, 26317c478bd9Sstevel@tonic-gate (long)pri->sys_args[3]); 26327c478bd9Sstevel@tonic-gate #else 26337c478bd9Sstevel@tonic-gate show_shmctl(pri, (long)pri->sys_args[3]); 26347c478bd9Sstevel@tonic-gate #endif 26357c478bd9Sstevel@tonic-gate break; 26367c478bd9Sstevel@tonic-gate case IPC_STAT64: 26377c478bd9Sstevel@tonic-gate if (pri->Errno) 26387c478bd9Sstevel@tonic-gate break; 26397c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 26407c478bd9Sstevel@tonic-gate case IPC_SET64: 26417c478bd9Sstevel@tonic-gate show_shmctl64(pri, (long)pri->sys_args[3]); 26427c478bd9Sstevel@tonic-gate break; 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate } 26457c478bd9Sstevel@tonic-gate break; 26467c478bd9Sstevel@tonic-gate case 2: /* shmdt() */ 26477c478bd9Sstevel@tonic-gate case 3: /* shmget() */ 26487c478bd9Sstevel@tonic-gate case 4: /* shmids() */ 26497c478bd9Sstevel@tonic-gate default: /* unexpected subcode */ 26507c478bd9Sstevel@tonic-gate break; 26517c478bd9Sstevel@tonic-gate } 26527c478bd9Sstevel@tonic-gate } 26537c478bd9Sstevel@tonic-gate 26547c478bd9Sstevel@tonic-gate void 26557c478bd9Sstevel@tonic-gate show_groups(private_t *pri, long offset, long count) 26567c478bd9Sstevel@tonic-gate { 26577c478bd9Sstevel@tonic-gate int groups[100]; 26587c478bd9Sstevel@tonic-gate 26597c478bd9Sstevel@tonic-gate if (count > 100) 26607c478bd9Sstevel@tonic-gate count = 100; 26617c478bd9Sstevel@tonic-gate 26627c478bd9Sstevel@tonic-gate if (count > 0 && offset != NULL && 26637c478bd9Sstevel@tonic-gate Pread(Proc, &groups[0], count*sizeof (int), offset) == 26647c478bd9Sstevel@tonic-gate count*sizeof (int)) { 26657c478bd9Sstevel@tonic-gate int n; 26667c478bd9Sstevel@tonic-gate 26677c478bd9Sstevel@tonic-gate (void) printf("%s\t", pri->pname); 26687c478bd9Sstevel@tonic-gate for (n = 0; !interrupt && n < count; n++) { 26697c478bd9Sstevel@tonic-gate if (n != 0 && n%10 == 0) 26707c478bd9Sstevel@tonic-gate (void) printf("\n%s\t", pri->pname); 26717c478bd9Sstevel@tonic-gate (void) printf(" %5d", groups[n]); 26727c478bd9Sstevel@tonic-gate } 26737c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 26747c478bd9Sstevel@tonic-gate } 26757c478bd9Sstevel@tonic-gate } 26767c478bd9Sstevel@tonic-gate 26777c478bd9Sstevel@tonic-gate /* 26787c478bd9Sstevel@tonic-gate * This assumes that a sigset_t is simply an array of ints. 26797c478bd9Sstevel@tonic-gate */ 26807c478bd9Sstevel@tonic-gate char * 26817c478bd9Sstevel@tonic-gate sigset_string(private_t *pri, sigset_t *sp) 26827c478bd9Sstevel@tonic-gate { 26837c478bd9Sstevel@tonic-gate char *s = pri->code_buf; 26847c478bd9Sstevel@tonic-gate int n = sizeof (*sp) / sizeof (int32_t); 26857c478bd9Sstevel@tonic-gate int32_t *lp = (int32_t *)sp; 26867c478bd9Sstevel@tonic-gate 26877c478bd9Sstevel@tonic-gate while (--n >= 0) { 26887c478bd9Sstevel@tonic-gate int32_t val = *lp++; 26897c478bd9Sstevel@tonic-gate 26907c478bd9Sstevel@tonic-gate if (val == 0) 26917c478bd9Sstevel@tonic-gate s += sprintf(s, " 0"); 26927c478bd9Sstevel@tonic-gate else 26937c478bd9Sstevel@tonic-gate s += sprintf(s, " 0x%.8X", val); 26947c478bd9Sstevel@tonic-gate } 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate return (pri->code_buf); 26977c478bd9Sstevel@tonic-gate } 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate void 27007c478bd9Sstevel@tonic-gate show_sigset(private_t *pri, long offset, const char *name) 27017c478bd9Sstevel@tonic-gate { 27027c478bd9Sstevel@tonic-gate sigset_t sigset; 27037c478bd9Sstevel@tonic-gate 27047c478bd9Sstevel@tonic-gate if (offset != NULL && 27057c478bd9Sstevel@tonic-gate Pread(Proc, &sigset, sizeof (sigset), offset) == sizeof (sigset)) { 27067c478bd9Sstevel@tonic-gate (void) printf("%s\t%s =%s\n", 27077c478bd9Sstevel@tonic-gate pri->pname, name, sigset_string(pri, &sigset)); 27087c478bd9Sstevel@tonic-gate } 27097c478bd9Sstevel@tonic-gate } 27107c478bd9Sstevel@tonic-gate 27117c478bd9Sstevel@tonic-gate #ifdef _LP64 27127c478bd9Sstevel@tonic-gate void 27137c478bd9Sstevel@tonic-gate show_sigaltstack32(private_t *pri, long offset, const char *name) 27147c478bd9Sstevel@tonic-gate { 27157c478bd9Sstevel@tonic-gate struct sigaltstack32 altstack; 27167c478bd9Sstevel@tonic-gate 27177c478bd9Sstevel@tonic-gate if (offset != NULL && 27187c478bd9Sstevel@tonic-gate Pread(Proc, &altstack, sizeof (altstack), offset) == 27197c478bd9Sstevel@tonic-gate sizeof (altstack)) { 27207c478bd9Sstevel@tonic-gate (void) printf("%s\t%s: sp=0x%.8X size=%u flags=0x%.4X\n", 27217c478bd9Sstevel@tonic-gate pri->pname, 27227c478bd9Sstevel@tonic-gate name, 27237c478bd9Sstevel@tonic-gate altstack.ss_sp, 27247c478bd9Sstevel@tonic-gate altstack.ss_size, 27257c478bd9Sstevel@tonic-gate altstack.ss_flags); 27267c478bd9Sstevel@tonic-gate } 27277c478bd9Sstevel@tonic-gate } 27287c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 27297c478bd9Sstevel@tonic-gate 27307c478bd9Sstevel@tonic-gate void 27317c478bd9Sstevel@tonic-gate show_sigaltstack(private_t *pri, long offset, const char *name) 27327c478bd9Sstevel@tonic-gate { 27337c478bd9Sstevel@tonic-gate struct sigaltstack altstack; 27347c478bd9Sstevel@tonic-gate 27357c478bd9Sstevel@tonic-gate #ifdef _LP64 27367c478bd9Sstevel@tonic-gate if (data_model != PR_MODEL_LP64) { 27377c478bd9Sstevel@tonic-gate show_sigaltstack32(pri, offset, name); 27387c478bd9Sstevel@tonic-gate return; 27397c478bd9Sstevel@tonic-gate } 27407c478bd9Sstevel@tonic-gate #endif 27417c478bd9Sstevel@tonic-gate if (offset != NULL && 27427c478bd9Sstevel@tonic-gate Pread(Proc, &altstack, sizeof (altstack), offset) == 27437c478bd9Sstevel@tonic-gate sizeof (altstack)) { 27447c478bd9Sstevel@tonic-gate (void) printf("%s\t%s: sp=0x%.8lX size=%lu flags=0x%.4X\n", 27457c478bd9Sstevel@tonic-gate pri->pname, 27467c478bd9Sstevel@tonic-gate name, 27477c478bd9Sstevel@tonic-gate (ulong_t)altstack.ss_sp, 27487c478bd9Sstevel@tonic-gate (ulong_t)altstack.ss_size, 27497c478bd9Sstevel@tonic-gate altstack.ss_flags); 27507c478bd9Sstevel@tonic-gate } 27517c478bd9Sstevel@tonic-gate } 27527c478bd9Sstevel@tonic-gate 27537c478bd9Sstevel@tonic-gate #ifdef _LP64 27547c478bd9Sstevel@tonic-gate void 27557c478bd9Sstevel@tonic-gate show_sigaction32(private_t *pri, long offset, const char *name, long odisp) 27567c478bd9Sstevel@tonic-gate { 27577c478bd9Sstevel@tonic-gate struct sigaction32 sigaction; 27587c478bd9Sstevel@tonic-gate 27597c478bd9Sstevel@tonic-gate if (offset != NULL && 27607c478bd9Sstevel@tonic-gate Pread(Proc, &sigaction, sizeof (sigaction), offset) == 27617c478bd9Sstevel@tonic-gate sizeof (sigaction)) { 27627c478bd9Sstevel@tonic-gate /* This is stupid, we shouldn't have to do this */ 27637c478bd9Sstevel@tonic-gate if (odisp != NULL) 27647c478bd9Sstevel@tonic-gate sigaction.sa_handler = (caddr32_t)odisp; 27657c478bd9Sstevel@tonic-gate (void) printf( 27667c478bd9Sstevel@tonic-gate "%s %s: hand = 0x%.8X mask =%s flags = 0x%.4X\n", 27677c478bd9Sstevel@tonic-gate pri->pname, 27687c478bd9Sstevel@tonic-gate name, 27697c478bd9Sstevel@tonic-gate sigaction.sa_handler, 27707c478bd9Sstevel@tonic-gate sigset_string(pri, (sigset_t *)&sigaction.sa_mask), 27717c478bd9Sstevel@tonic-gate sigaction.sa_flags); 27727c478bd9Sstevel@tonic-gate } 27737c478bd9Sstevel@tonic-gate } 27747c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 27757c478bd9Sstevel@tonic-gate 27767c478bd9Sstevel@tonic-gate void 27777c478bd9Sstevel@tonic-gate show_sigaction(private_t *pri, long offset, const char *name, long odisp) 27787c478bd9Sstevel@tonic-gate { 27797c478bd9Sstevel@tonic-gate struct sigaction sigaction; 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate #ifdef _LP64 27827c478bd9Sstevel@tonic-gate if (data_model != PR_MODEL_LP64) { 27837c478bd9Sstevel@tonic-gate show_sigaction32(pri, offset, name, odisp); 27847c478bd9Sstevel@tonic-gate return; 27857c478bd9Sstevel@tonic-gate } 27867c478bd9Sstevel@tonic-gate #endif 27877c478bd9Sstevel@tonic-gate if (offset != NULL && 27887c478bd9Sstevel@tonic-gate Pread(Proc, &sigaction, sizeof (sigaction), offset) == 27897c478bd9Sstevel@tonic-gate sizeof (sigaction)) { 27907c478bd9Sstevel@tonic-gate /* This is stupid, we shouldn't have to do this */ 27917c478bd9Sstevel@tonic-gate if (odisp != NULL) 27927c478bd9Sstevel@tonic-gate sigaction.sa_handler = (void (*)())odisp; 27937c478bd9Sstevel@tonic-gate (void) printf( 27947c478bd9Sstevel@tonic-gate "%s %s: hand = 0x%.8lX mask =%s flags = 0x%.4X\n", 27957c478bd9Sstevel@tonic-gate pri->pname, 27967c478bd9Sstevel@tonic-gate name, 27977c478bd9Sstevel@tonic-gate (long)sigaction.sa_handler, 27987c478bd9Sstevel@tonic-gate sigset_string(pri, &sigaction.sa_mask), 27997c478bd9Sstevel@tonic-gate sigaction.sa_flags); 28007c478bd9Sstevel@tonic-gate } 28017c478bd9Sstevel@tonic-gate } 28027c478bd9Sstevel@tonic-gate 28037c478bd9Sstevel@tonic-gate #ifdef _LP64 28047c478bd9Sstevel@tonic-gate void 28057c478bd9Sstevel@tonic-gate print_siginfo32(private_t *pri, const siginfo32_t *sip) 28067c478bd9Sstevel@tonic-gate { 28077c478bd9Sstevel@tonic-gate const char *code = NULL; 28087c478bd9Sstevel@tonic-gate 28097c478bd9Sstevel@tonic-gate (void) printf("%s siginfo: %s", pri->pname, 28107c478bd9Sstevel@tonic-gate signame(pri, sip->si_signo)); 28117c478bd9Sstevel@tonic-gate 28127c478bd9Sstevel@tonic-gate if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) { 28137c478bd9Sstevel@tonic-gate (void) printf(" pid=%d uid=%d", sip->si_pid, sip->si_uid); 28147c478bd9Sstevel@tonic-gate if (sip->si_code != 0) 28157c478bd9Sstevel@tonic-gate (void) printf(" code=%d", sip->si_code); 28167c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 28177c478bd9Sstevel@tonic-gate return; 28187c478bd9Sstevel@tonic-gate } 28197c478bd9Sstevel@tonic-gate 28207c478bd9Sstevel@tonic-gate switch (sip->si_signo) { 28217c478bd9Sstevel@tonic-gate default: 28227c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 28237c478bd9Sstevel@tonic-gate return; 28247c478bd9Sstevel@tonic-gate case SIGILL: 28257c478bd9Sstevel@tonic-gate case SIGTRAP: 28267c478bd9Sstevel@tonic-gate case SIGFPE: 28277c478bd9Sstevel@tonic-gate case SIGSEGV: 28287c478bd9Sstevel@tonic-gate case SIGBUS: 28297c478bd9Sstevel@tonic-gate case SIGEMT: 28307c478bd9Sstevel@tonic-gate case SIGCLD: 28317c478bd9Sstevel@tonic-gate case SIGPOLL: 28327c478bd9Sstevel@tonic-gate case SIGXFSZ: 28337c478bd9Sstevel@tonic-gate break; 28347c478bd9Sstevel@tonic-gate } 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate switch (sip->si_signo) { 28377c478bd9Sstevel@tonic-gate case SIGILL: 28387c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28397c478bd9Sstevel@tonic-gate case ILL_ILLOPC: code = "ILL_ILLOPC"; break; 28407c478bd9Sstevel@tonic-gate case ILL_ILLOPN: code = "ILL_ILLOPN"; break; 28417c478bd9Sstevel@tonic-gate case ILL_ILLADR: code = "ILL_ILLADR"; break; 28427c478bd9Sstevel@tonic-gate case ILL_ILLTRP: code = "ILL_ILLTRP"; break; 28437c478bd9Sstevel@tonic-gate case ILL_PRVOPC: code = "ILL_PRVOPC"; break; 28447c478bd9Sstevel@tonic-gate case ILL_PRVREG: code = "ILL_PRVREG"; break; 28457c478bd9Sstevel@tonic-gate case ILL_COPROC: code = "ILL_COPROC"; break; 28467c478bd9Sstevel@tonic-gate case ILL_BADSTK: code = "ILL_BADSTK"; break; 28477c478bd9Sstevel@tonic-gate } 28487c478bd9Sstevel@tonic-gate break; 28497c478bd9Sstevel@tonic-gate case SIGTRAP: 28507c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28517c478bd9Sstevel@tonic-gate case TRAP_BRKPT: code = "TRAP_BRKPT"; break; 28527c478bd9Sstevel@tonic-gate case TRAP_TRACE: code = "TRAP_TRACE"; break; 28537c478bd9Sstevel@tonic-gate case TRAP_RWATCH: code = "TRAP_RWATCH"; break; 28547c478bd9Sstevel@tonic-gate case TRAP_WWATCH: code = "TRAP_WWATCH"; break; 28557c478bd9Sstevel@tonic-gate case TRAP_XWATCH: code = "TRAP_XWATCH"; break; 28567c478bd9Sstevel@tonic-gate case TRAP_DTRACE: code = "TRAP_DTRACE"; break; 28577c478bd9Sstevel@tonic-gate } 28587c478bd9Sstevel@tonic-gate break; 28597c478bd9Sstevel@tonic-gate case SIGFPE: 28607c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28617c478bd9Sstevel@tonic-gate case FPE_INTDIV: code = "FPE_INTDIV"; break; 28627c478bd9Sstevel@tonic-gate case FPE_INTOVF: code = "FPE_INTOVF"; break; 28637c478bd9Sstevel@tonic-gate case FPE_FLTDIV: code = "FPE_FLTDIV"; break; 28647c478bd9Sstevel@tonic-gate case FPE_FLTOVF: code = "FPE_FLTOVF"; break; 28657c478bd9Sstevel@tonic-gate case FPE_FLTUND: code = "FPE_FLTUND"; break; 28667c478bd9Sstevel@tonic-gate case FPE_FLTRES: code = "FPE_FLTRES"; break; 28677c478bd9Sstevel@tonic-gate case FPE_FLTINV: code = "FPE_FLTINV"; break; 28687c478bd9Sstevel@tonic-gate case FPE_FLTSUB: code = "FPE_FLTSUB"; break; 28697c478bd9Sstevel@tonic-gate #if defined(FPE_FLTDEN) 28707c478bd9Sstevel@tonic-gate case FPE_FLTDEN: code = "FPE_FLTDEN"; break; 28717c478bd9Sstevel@tonic-gate #endif 28727c478bd9Sstevel@tonic-gate } 28737c478bd9Sstevel@tonic-gate break; 28747c478bd9Sstevel@tonic-gate case SIGSEGV: 28757c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28767c478bd9Sstevel@tonic-gate case SEGV_MAPERR: code = "SEGV_MAPERR"; break; 28777c478bd9Sstevel@tonic-gate case SEGV_ACCERR: code = "SEGV_ACCERR"; break; 28787c478bd9Sstevel@tonic-gate } 28797c478bd9Sstevel@tonic-gate break; 28807c478bd9Sstevel@tonic-gate case SIGEMT: 28817c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28827c478bd9Sstevel@tonic-gate #ifdef EMT_TAGOVF 28837c478bd9Sstevel@tonic-gate case EMT_TAGOVF: code = "EMT_TAGOVF"; break; 28847c478bd9Sstevel@tonic-gate #endif 28857c478bd9Sstevel@tonic-gate case EMT_CPCOVF: code = "EMT_CPCOVF"; break; 28867c478bd9Sstevel@tonic-gate } 28877c478bd9Sstevel@tonic-gate break; 28887c478bd9Sstevel@tonic-gate case SIGBUS: 28897c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28907c478bd9Sstevel@tonic-gate case BUS_ADRALN: code = "BUS_ADRALN"; break; 28917c478bd9Sstevel@tonic-gate case BUS_ADRERR: code = "BUS_ADRERR"; break; 28927c478bd9Sstevel@tonic-gate case BUS_OBJERR: code = "BUS_OBJERR"; break; 28937c478bd9Sstevel@tonic-gate } 28947c478bd9Sstevel@tonic-gate break; 28957c478bd9Sstevel@tonic-gate case SIGCLD: 28967c478bd9Sstevel@tonic-gate switch (sip->si_code) { 28977c478bd9Sstevel@tonic-gate case CLD_EXITED: code = "CLD_EXITED"; break; 28987c478bd9Sstevel@tonic-gate case CLD_KILLED: code = "CLD_KILLED"; break; 28997c478bd9Sstevel@tonic-gate case CLD_DUMPED: code = "CLD_DUMPED"; break; 29007c478bd9Sstevel@tonic-gate case CLD_TRAPPED: code = "CLD_TRAPPED"; break; 29017c478bd9Sstevel@tonic-gate case CLD_STOPPED: code = "CLD_STOPPED"; break; 29027c478bd9Sstevel@tonic-gate case CLD_CONTINUED: code = "CLD_CONTINUED"; break; 29037c478bd9Sstevel@tonic-gate } 29047c478bd9Sstevel@tonic-gate break; 29057c478bd9Sstevel@tonic-gate case SIGPOLL: 29067c478bd9Sstevel@tonic-gate switch (sip->si_code) { 29077c478bd9Sstevel@tonic-gate case POLL_IN: code = "POLL_IN"; break; 29087c478bd9Sstevel@tonic-gate case POLL_OUT: code = "POLL_OUT"; break; 29097c478bd9Sstevel@tonic-gate case POLL_MSG: code = "POLL_MSG"; break; 29107c478bd9Sstevel@tonic-gate case POLL_ERR: code = "POLL_ERR"; break; 29117c478bd9Sstevel@tonic-gate case POLL_PRI: code = "POLL_PRI"; break; 29127c478bd9Sstevel@tonic-gate case POLL_HUP: code = "POLL_HUP"; break; 29137c478bd9Sstevel@tonic-gate } 29147c478bd9Sstevel@tonic-gate break; 29157c478bd9Sstevel@tonic-gate } 29167c478bd9Sstevel@tonic-gate 29177c478bd9Sstevel@tonic-gate if (code == NULL) { 29187c478bd9Sstevel@tonic-gate (void) sprintf(pri->code_buf, "code=%d", sip->si_code); 29197c478bd9Sstevel@tonic-gate code = (const char *)pri->code_buf; 29207c478bd9Sstevel@tonic-gate } 29217c478bd9Sstevel@tonic-gate 29227c478bd9Sstevel@tonic-gate switch (sip->si_signo) { 29237c478bd9Sstevel@tonic-gate case SIGILL: 29247c478bd9Sstevel@tonic-gate case SIGTRAP: 29257c478bd9Sstevel@tonic-gate case SIGFPE: 29267c478bd9Sstevel@tonic-gate case SIGSEGV: 29277c478bd9Sstevel@tonic-gate case SIGBUS: 29287c478bd9Sstevel@tonic-gate case SIGEMT: 29297c478bd9Sstevel@tonic-gate (void) printf(" %s addr=0x%.8X", 29307c478bd9Sstevel@tonic-gate code, 29317c478bd9Sstevel@tonic-gate sip->si_addr); 29327c478bd9Sstevel@tonic-gate break; 29337c478bd9Sstevel@tonic-gate case SIGCLD: 29347c478bd9Sstevel@tonic-gate (void) printf(" %s pid=%d status=0x%.4X", 29357c478bd9Sstevel@tonic-gate code, 29367c478bd9Sstevel@tonic-gate sip->si_pid, 29377c478bd9Sstevel@tonic-gate sip->si_status); 29387c478bd9Sstevel@tonic-gate break; 29397c478bd9Sstevel@tonic-gate case SIGPOLL: 29407c478bd9Sstevel@tonic-gate case SIGXFSZ: 29417c478bd9Sstevel@tonic-gate (void) printf(" %s fd=%d band=%d", 29427c478bd9Sstevel@tonic-gate code, 29437c478bd9Sstevel@tonic-gate sip->si_fd, 29447c478bd9Sstevel@tonic-gate sip->si_band); 29457c478bd9Sstevel@tonic-gate break; 29467c478bd9Sstevel@tonic-gate } 29477c478bd9Sstevel@tonic-gate 29487c478bd9Sstevel@tonic-gate if (sip->si_errno != 0) { 29497c478bd9Sstevel@tonic-gate const char *ename = errname(sip->si_errno); 29507c478bd9Sstevel@tonic-gate 29517c478bd9Sstevel@tonic-gate (void) printf(" errno=%d", sip->si_errno); 29527c478bd9Sstevel@tonic-gate if (ename != NULL) 29537c478bd9Sstevel@tonic-gate (void) printf("(%s)", ename); 29547c478bd9Sstevel@tonic-gate } 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 29577c478bd9Sstevel@tonic-gate } 29587c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 29597c478bd9Sstevel@tonic-gate 29607c478bd9Sstevel@tonic-gate void 29617c478bd9Sstevel@tonic-gate print_siginfo(private_t *pri, const siginfo_t *sip) 29627c478bd9Sstevel@tonic-gate { 29637c478bd9Sstevel@tonic-gate const char *code = NULL; 29647c478bd9Sstevel@tonic-gate 29657c478bd9Sstevel@tonic-gate (void) printf("%s siginfo: %s", pri->pname, 29667c478bd9Sstevel@tonic-gate signame(pri, sip->si_signo)); 29677c478bd9Sstevel@tonic-gate 29687c478bd9Sstevel@tonic-gate if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) { 29697c478bd9Sstevel@tonic-gate (void) printf(" pid=%d uid=%d", 29707c478bd9Sstevel@tonic-gate (int)sip->si_pid, 29717c478bd9Sstevel@tonic-gate (int)sip->si_uid); 29727c478bd9Sstevel@tonic-gate if (sip->si_code != 0) 29737c478bd9Sstevel@tonic-gate (void) printf(" code=%d", sip->si_code); 29747c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 29757c478bd9Sstevel@tonic-gate return; 29767c478bd9Sstevel@tonic-gate } 29777c478bd9Sstevel@tonic-gate 29787c478bd9Sstevel@tonic-gate switch (sip->si_signo) { 29797c478bd9Sstevel@tonic-gate default: 29807c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 29817c478bd9Sstevel@tonic-gate return; 29827c478bd9Sstevel@tonic-gate case SIGILL: 29837c478bd9Sstevel@tonic-gate case SIGTRAP: 29847c478bd9Sstevel@tonic-gate case SIGFPE: 29857c478bd9Sstevel@tonic-gate case SIGSEGV: 29867c478bd9Sstevel@tonic-gate case SIGBUS: 29877c478bd9Sstevel@tonic-gate case SIGEMT: 29887c478bd9Sstevel@tonic-gate case SIGCLD: 29897c478bd9Sstevel@tonic-gate case SIGPOLL: 29907c478bd9Sstevel@tonic-gate case SIGXFSZ: 29917c478bd9Sstevel@tonic-gate break; 29927c478bd9Sstevel@tonic-gate } 29937c478bd9Sstevel@tonic-gate 29947c478bd9Sstevel@tonic-gate switch (sip->si_signo) { 29957c478bd9Sstevel@tonic-gate case SIGILL: 29967c478bd9Sstevel@tonic-gate switch (sip->si_code) { 29977c478bd9Sstevel@tonic-gate case ILL_ILLOPC: code = "ILL_ILLOPC"; break; 29987c478bd9Sstevel@tonic-gate case ILL_ILLOPN: code = "ILL_ILLOPN"; break; 29997c478bd9Sstevel@tonic-gate case ILL_ILLADR: code = "ILL_ILLADR"; break; 30007c478bd9Sstevel@tonic-gate case ILL_ILLTRP: code = "ILL_ILLTRP"; break; 30017c478bd9Sstevel@tonic-gate case ILL_PRVOPC: code = "ILL_PRVOPC"; break; 30027c478bd9Sstevel@tonic-gate case ILL_PRVREG: code = "ILL_PRVREG"; break; 30037c478bd9Sstevel@tonic-gate case ILL_COPROC: code = "ILL_COPROC"; break; 30047c478bd9Sstevel@tonic-gate case ILL_BADSTK: code = "ILL_BADSTK"; break; 30057c478bd9Sstevel@tonic-gate } 30067c478bd9Sstevel@tonic-gate break; 30077c478bd9Sstevel@tonic-gate case SIGTRAP: 30087c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30097c478bd9Sstevel@tonic-gate case TRAP_BRKPT: code = "TRAP_BRKPT"; break; 30107c478bd9Sstevel@tonic-gate case TRAP_TRACE: code = "TRAP_TRACE"; break; 30117c478bd9Sstevel@tonic-gate case TRAP_RWATCH: code = "TRAP_RWATCH"; break; 30127c478bd9Sstevel@tonic-gate case TRAP_WWATCH: code = "TRAP_WWATCH"; break; 30137c478bd9Sstevel@tonic-gate case TRAP_XWATCH: code = "TRAP_XWATCH"; break; 30147c478bd9Sstevel@tonic-gate case TRAP_DTRACE: code = "TRAP_DTRACE"; break; 30157c478bd9Sstevel@tonic-gate } 30167c478bd9Sstevel@tonic-gate break; 30177c478bd9Sstevel@tonic-gate case SIGFPE: 30187c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30197c478bd9Sstevel@tonic-gate case FPE_INTDIV: code = "FPE_INTDIV"; break; 30207c478bd9Sstevel@tonic-gate case FPE_INTOVF: code = "FPE_INTOVF"; break; 30217c478bd9Sstevel@tonic-gate case FPE_FLTDIV: code = "FPE_FLTDIV"; break; 30227c478bd9Sstevel@tonic-gate case FPE_FLTOVF: code = "FPE_FLTOVF"; break; 30237c478bd9Sstevel@tonic-gate case FPE_FLTUND: code = "FPE_FLTUND"; break; 30247c478bd9Sstevel@tonic-gate case FPE_FLTRES: code = "FPE_FLTRES"; break; 30257c478bd9Sstevel@tonic-gate case FPE_FLTINV: code = "FPE_FLTINV"; break; 30267c478bd9Sstevel@tonic-gate case FPE_FLTSUB: code = "FPE_FLTSUB"; break; 30277c478bd9Sstevel@tonic-gate #if defined(FPE_FLTDEN) 30287c478bd9Sstevel@tonic-gate case FPE_FLTDEN: code = "FPE_FLTDEN"; break; 30297c478bd9Sstevel@tonic-gate #endif 30307c478bd9Sstevel@tonic-gate } 30317c478bd9Sstevel@tonic-gate break; 30327c478bd9Sstevel@tonic-gate case SIGSEGV: 30337c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30347c478bd9Sstevel@tonic-gate case SEGV_MAPERR: code = "SEGV_MAPERR"; break; 30357c478bd9Sstevel@tonic-gate case SEGV_ACCERR: code = "SEGV_ACCERR"; break; 30367c478bd9Sstevel@tonic-gate } 30377c478bd9Sstevel@tonic-gate break; 30387c478bd9Sstevel@tonic-gate case SIGEMT: 30397c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30407c478bd9Sstevel@tonic-gate #ifdef EMT_TAGOVF 30417c478bd9Sstevel@tonic-gate case EMT_TAGOVF: code = "EMT_TAGOVF"; break; 30427c478bd9Sstevel@tonic-gate #endif 30437c478bd9Sstevel@tonic-gate case EMT_CPCOVF: code = "EMT_CPCOVF"; break; 30447c478bd9Sstevel@tonic-gate } 30457c478bd9Sstevel@tonic-gate break; 30467c478bd9Sstevel@tonic-gate case SIGBUS: 30477c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30487c478bd9Sstevel@tonic-gate case BUS_ADRALN: code = "BUS_ADRALN"; break; 30497c478bd9Sstevel@tonic-gate case BUS_ADRERR: code = "BUS_ADRERR"; break; 30507c478bd9Sstevel@tonic-gate case BUS_OBJERR: code = "BUS_OBJERR"; break; 30517c478bd9Sstevel@tonic-gate } 30527c478bd9Sstevel@tonic-gate break; 30537c478bd9Sstevel@tonic-gate case SIGCLD: 30547c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30557c478bd9Sstevel@tonic-gate case CLD_EXITED: code = "CLD_EXITED"; break; 30567c478bd9Sstevel@tonic-gate case CLD_KILLED: code = "CLD_KILLED"; break; 30577c478bd9Sstevel@tonic-gate case CLD_DUMPED: code = "CLD_DUMPED"; break; 30587c478bd9Sstevel@tonic-gate case CLD_TRAPPED: code = "CLD_TRAPPED"; break; 30597c478bd9Sstevel@tonic-gate case CLD_STOPPED: code = "CLD_STOPPED"; break; 30607c478bd9Sstevel@tonic-gate case CLD_CONTINUED: code = "CLD_CONTINUED"; break; 30617c478bd9Sstevel@tonic-gate } 30627c478bd9Sstevel@tonic-gate break; 30637c478bd9Sstevel@tonic-gate case SIGPOLL: 30647c478bd9Sstevel@tonic-gate switch (sip->si_code) { 30657c478bd9Sstevel@tonic-gate case POLL_IN: code = "POLL_IN"; break; 30667c478bd9Sstevel@tonic-gate case POLL_OUT: code = "POLL_OUT"; break; 30677c478bd9Sstevel@tonic-gate case POLL_MSG: code = "POLL_MSG"; break; 30687c478bd9Sstevel@tonic-gate case POLL_ERR: code = "POLL_ERR"; break; 30697c478bd9Sstevel@tonic-gate case POLL_PRI: code = "POLL_PRI"; break; 30707c478bd9Sstevel@tonic-gate case POLL_HUP: code = "POLL_HUP"; break; 30717c478bd9Sstevel@tonic-gate } 30727c478bd9Sstevel@tonic-gate break; 30737c478bd9Sstevel@tonic-gate } 30747c478bd9Sstevel@tonic-gate 30757c478bd9Sstevel@tonic-gate if (code == NULL) { 30767c478bd9Sstevel@tonic-gate (void) sprintf(pri->code_buf, "code=%d", sip->si_code); 30777c478bd9Sstevel@tonic-gate code = (const char *)pri->code_buf; 30787c478bd9Sstevel@tonic-gate } 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate switch (sip->si_signo) { 30817c478bd9Sstevel@tonic-gate case SIGILL: 30827c478bd9Sstevel@tonic-gate case SIGTRAP: 30837c478bd9Sstevel@tonic-gate case SIGFPE: 30847c478bd9Sstevel@tonic-gate case SIGSEGV: 30857c478bd9Sstevel@tonic-gate case SIGBUS: 30867c478bd9Sstevel@tonic-gate case SIGEMT: 30877c478bd9Sstevel@tonic-gate (void) printf(" %s addr=0x%.8lX", 30887c478bd9Sstevel@tonic-gate code, 30897c478bd9Sstevel@tonic-gate (long)sip->si_addr); 30907c478bd9Sstevel@tonic-gate break; 30917c478bd9Sstevel@tonic-gate case SIGCLD: 30927c478bd9Sstevel@tonic-gate (void) printf(" %s pid=%d status=0x%.4X", 30937c478bd9Sstevel@tonic-gate code, 30947c478bd9Sstevel@tonic-gate (int)sip->si_pid, 30957c478bd9Sstevel@tonic-gate sip->si_status); 30967c478bd9Sstevel@tonic-gate break; 30977c478bd9Sstevel@tonic-gate case SIGPOLL: 30987c478bd9Sstevel@tonic-gate case SIGXFSZ: 30997c478bd9Sstevel@tonic-gate (void) printf(" %s fd=%d band=%ld", 31007c478bd9Sstevel@tonic-gate code, 31017c478bd9Sstevel@tonic-gate sip->si_fd, 31027c478bd9Sstevel@tonic-gate sip->si_band); 31037c478bd9Sstevel@tonic-gate break; 31047c478bd9Sstevel@tonic-gate } 31057c478bd9Sstevel@tonic-gate 31067c478bd9Sstevel@tonic-gate if (sip->si_errno != 0) { 31077c478bd9Sstevel@tonic-gate const char *ename = errname(sip->si_errno); 31087c478bd9Sstevel@tonic-gate 31097c478bd9Sstevel@tonic-gate (void) printf(" errno=%d", sip->si_errno); 31107c478bd9Sstevel@tonic-gate if (ename != NULL) 31117c478bd9Sstevel@tonic-gate (void) printf("(%s)", ename); 31127c478bd9Sstevel@tonic-gate } 31137c478bd9Sstevel@tonic-gate 31147c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 31157c478bd9Sstevel@tonic-gate } 31167c478bd9Sstevel@tonic-gate 31177c478bd9Sstevel@tonic-gate #ifdef _LP64 31187c478bd9Sstevel@tonic-gate void 31197c478bd9Sstevel@tonic-gate show_siginfo32(private_t *pri, long offset) 31207c478bd9Sstevel@tonic-gate { 31217c478bd9Sstevel@tonic-gate struct siginfo32 siginfo; 31227c478bd9Sstevel@tonic-gate 31237c478bd9Sstevel@tonic-gate if (offset != NULL && 31247c478bd9Sstevel@tonic-gate Pread(Proc, &siginfo, sizeof (siginfo), offset) == sizeof (siginfo)) 31257c478bd9Sstevel@tonic-gate print_siginfo32(pri, &siginfo); 31267c478bd9Sstevel@tonic-gate } 31277c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 31287c478bd9Sstevel@tonic-gate 31297c478bd9Sstevel@tonic-gate void 31307c478bd9Sstevel@tonic-gate show_siginfo(private_t *pri, long offset) 31317c478bd9Sstevel@tonic-gate { 31327c478bd9Sstevel@tonic-gate struct siginfo siginfo; 31337c478bd9Sstevel@tonic-gate 31347c478bd9Sstevel@tonic-gate #ifdef _LP64 31357c478bd9Sstevel@tonic-gate if (data_model != PR_MODEL_LP64) { 31367c478bd9Sstevel@tonic-gate show_siginfo32(pri, offset); 31377c478bd9Sstevel@tonic-gate return; 31387c478bd9Sstevel@tonic-gate } 31397c478bd9Sstevel@tonic-gate #endif 31407c478bd9Sstevel@tonic-gate if (offset != NULL && 31417c478bd9Sstevel@tonic-gate Pread(Proc, &siginfo, sizeof (siginfo), offset) == sizeof (siginfo)) 31427c478bd9Sstevel@tonic-gate print_siginfo(pri, &siginfo); 31437c478bd9Sstevel@tonic-gate } 31447c478bd9Sstevel@tonic-gate 31457c478bd9Sstevel@tonic-gate void 31467c478bd9Sstevel@tonic-gate show_bool(private_t *pri, long offset, int count) 31477c478bd9Sstevel@tonic-gate { 31487c478bd9Sstevel@tonic-gate int serial = (count > MYBUFSIZ / 4); 31497c478bd9Sstevel@tonic-gate 31507c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 31517c478bd9Sstevel@tonic-gate if (serial) 31527c478bd9Sstevel@tonic-gate Eserialize(); 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate while (count > 0) { 31557c478bd9Sstevel@tonic-gate char buf[32]; 31567c478bd9Sstevel@tonic-gate int nb = (count < 32)? count : 32; 31577c478bd9Sstevel@tonic-gate int i; 31587c478bd9Sstevel@tonic-gate 31597c478bd9Sstevel@tonic-gate if (Pread(Proc, buf, (size_t)nb, offset) != nb) 31607c478bd9Sstevel@tonic-gate break; 31617c478bd9Sstevel@tonic-gate 31627c478bd9Sstevel@tonic-gate (void) printf("%s ", pri->pname); 31637c478bd9Sstevel@tonic-gate for (i = 0; i < nb; i++) 31647c478bd9Sstevel@tonic-gate (void) printf(" %d", buf[i]); 31657c478bd9Sstevel@tonic-gate (void) fputc('\n', stdout); 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate count -= nb; 31687c478bd9Sstevel@tonic-gate offset += nb; 31697c478bd9Sstevel@tonic-gate } 31707c478bd9Sstevel@tonic-gate 31717c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 31727c478bd9Sstevel@tonic-gate if (serial) 31737c478bd9Sstevel@tonic-gate Xserialize(); 31747c478bd9Sstevel@tonic-gate } 31757c478bd9Sstevel@tonic-gate 31767c478bd9Sstevel@tonic-gate #ifdef _LP64 31777c478bd9Sstevel@tonic-gate void 31787c478bd9Sstevel@tonic-gate show_iovec32(private_t *pri, long offset, int niov, int showbuf, long count) 31797c478bd9Sstevel@tonic-gate { 31807c478bd9Sstevel@tonic-gate iovec32_t iovec[16]; 31817c478bd9Sstevel@tonic-gate iovec32_t *ip; 31827c478bd9Sstevel@tonic-gate long nb; 31837c478bd9Sstevel@tonic-gate int serial = (count > MYBUFSIZ / 4 && showbuf); 31847c478bd9Sstevel@tonic-gate 31857c478bd9Sstevel@tonic-gate if (niov > 16) /* is this the real limit? */ 31867c478bd9Sstevel@tonic-gate niov = 16; 31877c478bd9Sstevel@tonic-gate 31887c478bd9Sstevel@tonic-gate if (offset != NULL && niov > 0 && 31897c478bd9Sstevel@tonic-gate Pread(Proc, &iovec[0], niov*sizeof (iovec32_t), offset) 31907c478bd9Sstevel@tonic-gate == niov*sizeof (iovec32_t)) { 31917c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 31927c478bd9Sstevel@tonic-gate if (serial) 31937c478bd9Sstevel@tonic-gate Eserialize(); 31947c478bd9Sstevel@tonic-gate 31957c478bd9Sstevel@tonic-gate for (ip = &iovec[0]; niov-- && !interrupt; ip++) { 31967c478bd9Sstevel@tonic-gate (void) printf("%s\tiov_base = 0x%.8X iov_len = %d\n", 31977c478bd9Sstevel@tonic-gate pri->pname, 31987c478bd9Sstevel@tonic-gate ip->iov_base, 31997c478bd9Sstevel@tonic-gate ip->iov_len); 32007c478bd9Sstevel@tonic-gate if ((nb = count) > 0) { 32017c478bd9Sstevel@tonic-gate if (nb > ip->iov_len) 32027c478bd9Sstevel@tonic-gate nb = ip->iov_len; 32037c478bd9Sstevel@tonic-gate if (nb > 0) 32047c478bd9Sstevel@tonic-gate count -= nb; 32057c478bd9Sstevel@tonic-gate } 32067c478bd9Sstevel@tonic-gate if (showbuf && nb > 0) 32077c478bd9Sstevel@tonic-gate showbuffer(pri, (long)ip->iov_base, nb); 32087c478bd9Sstevel@tonic-gate } 32097c478bd9Sstevel@tonic-gate 32107c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 32117c478bd9Sstevel@tonic-gate if (serial) 32127c478bd9Sstevel@tonic-gate Xserialize(); 32137c478bd9Sstevel@tonic-gate } 32147c478bd9Sstevel@tonic-gate } 32157c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate void 32187c478bd9Sstevel@tonic-gate show_iovec(private_t *pri, long offset, long niov, int showbuf, long count) 32197c478bd9Sstevel@tonic-gate { 32207c478bd9Sstevel@tonic-gate iovec_t iovec[16]; 32217c478bd9Sstevel@tonic-gate iovec_t *ip; 32227c478bd9Sstevel@tonic-gate long nb; 32237c478bd9Sstevel@tonic-gate int serial = (count > MYBUFSIZ / 4 && showbuf); 32247c478bd9Sstevel@tonic-gate 32257c478bd9Sstevel@tonic-gate #ifdef _LP64 32267c478bd9Sstevel@tonic-gate if (data_model != PR_MODEL_LP64) { 32277c478bd9Sstevel@tonic-gate show_iovec32(pri, offset, niov, showbuf, count); 32287c478bd9Sstevel@tonic-gate return; 32297c478bd9Sstevel@tonic-gate } 32307c478bd9Sstevel@tonic-gate #endif 32317c478bd9Sstevel@tonic-gate if (niov > 16) /* is this the real limit? */ 32327c478bd9Sstevel@tonic-gate niov = 16; 32337c478bd9Sstevel@tonic-gate 32347c478bd9Sstevel@tonic-gate if (offset != NULL && niov > 0 && 32357c478bd9Sstevel@tonic-gate Pread(Proc, &iovec[0], niov*sizeof (iovec_t), offset) 32367c478bd9Sstevel@tonic-gate == niov*sizeof (iovec_t)) { 32377c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 32387c478bd9Sstevel@tonic-gate if (serial) 32397c478bd9Sstevel@tonic-gate Eserialize(); 32407c478bd9Sstevel@tonic-gate 32417c478bd9Sstevel@tonic-gate for (ip = &iovec[0]; niov-- && !interrupt; ip++) { 32427c478bd9Sstevel@tonic-gate (void) printf("%s\tiov_base = 0x%.8lX iov_len = %lu\n", 32437c478bd9Sstevel@tonic-gate pri->pname, 32447c478bd9Sstevel@tonic-gate (long)ip->iov_base, 32457c478bd9Sstevel@tonic-gate ip->iov_len); 32467c478bd9Sstevel@tonic-gate if ((nb = count) > 0) { 32477c478bd9Sstevel@tonic-gate if (nb > ip->iov_len) 32487c478bd9Sstevel@tonic-gate nb = ip->iov_len; 32497c478bd9Sstevel@tonic-gate if (nb > 0) 32507c478bd9Sstevel@tonic-gate count -= nb; 32517c478bd9Sstevel@tonic-gate } 32527c478bd9Sstevel@tonic-gate if (showbuf && nb > 0) 32537c478bd9Sstevel@tonic-gate showbuffer(pri, (long)ip->iov_base, nb); 32547c478bd9Sstevel@tonic-gate } 32557c478bd9Sstevel@tonic-gate 32567c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 32577c478bd9Sstevel@tonic-gate if (serial) 32587c478bd9Sstevel@tonic-gate Xserialize(); 32597c478bd9Sstevel@tonic-gate } 32607c478bd9Sstevel@tonic-gate } 32617c478bd9Sstevel@tonic-gate 32627c478bd9Sstevel@tonic-gate void 32637c478bd9Sstevel@tonic-gate show_dents32(private_t *pri, long offset, long count) 32647c478bd9Sstevel@tonic-gate { 32657c478bd9Sstevel@tonic-gate long buf[MYBUFSIZ / sizeof (long)]; 32667c478bd9Sstevel@tonic-gate struct dirent32 *dp; 32677c478bd9Sstevel@tonic-gate int serial = (count > 100); 32687c478bd9Sstevel@tonic-gate 32697c478bd9Sstevel@tonic-gate if (offset == NULL) 32707c478bd9Sstevel@tonic-gate return; 32717c478bd9Sstevel@tonic-gate 32727c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 32737c478bd9Sstevel@tonic-gate if (serial) 32747c478bd9Sstevel@tonic-gate Eserialize(); 32757c478bd9Sstevel@tonic-gate 32767c478bd9Sstevel@tonic-gate while (count > 0 && !interrupt) { 32777c478bd9Sstevel@tonic-gate int nb = count < MYBUFSIZ? (int)count : MYBUFSIZ; 32787c478bd9Sstevel@tonic-gate 32797c478bd9Sstevel@tonic-gate if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) <= 0) 32807c478bd9Sstevel@tonic-gate break; 32817c478bd9Sstevel@tonic-gate 32827c478bd9Sstevel@tonic-gate dp = (struct dirent32 *)&buf[0]; 32837c478bd9Sstevel@tonic-gate if (nb < (int)(dp->d_name - (char *)dp)) 32847c478bd9Sstevel@tonic-gate break; 32857c478bd9Sstevel@tonic-gate if ((unsigned)nb < dp->d_reclen) { 32867c478bd9Sstevel@tonic-gate /* getdents() error? */ 32877c478bd9Sstevel@tonic-gate (void) printf( 32887c478bd9Sstevel@tonic-gate "%s ino=%-5u off=%-4d rlen=%-3d\n", 32897c478bd9Sstevel@tonic-gate pri->pname, 32907c478bd9Sstevel@tonic-gate dp->d_ino, 32917c478bd9Sstevel@tonic-gate dp->d_off, 32927c478bd9Sstevel@tonic-gate dp->d_reclen); 32937c478bd9Sstevel@tonic-gate break; 32947c478bd9Sstevel@tonic-gate } 32957c478bd9Sstevel@tonic-gate 32967c478bd9Sstevel@tonic-gate while (!interrupt && 32977c478bd9Sstevel@tonic-gate nb >= (int)(dp->d_name - (char *)dp) && 32987c478bd9Sstevel@tonic-gate (unsigned)nb >= dp->d_reclen) { 32997c478bd9Sstevel@tonic-gate (void) printf( 33007c478bd9Sstevel@tonic-gate "%s ino=%-5u off=%-4d rlen=%-3d \"%.*s\"\n", 33017c478bd9Sstevel@tonic-gate pri->pname, 33027c478bd9Sstevel@tonic-gate dp->d_ino, 33037c478bd9Sstevel@tonic-gate dp->d_off, 33047c478bd9Sstevel@tonic-gate dp->d_reclen, 33057c478bd9Sstevel@tonic-gate dp->d_reclen - (int)(dp->d_name - (char *)dp), 33067c478bd9Sstevel@tonic-gate dp->d_name); 33077c478bd9Sstevel@tonic-gate nb -= dp->d_reclen; 33087c478bd9Sstevel@tonic-gate count -= dp->d_reclen; 33097c478bd9Sstevel@tonic-gate offset += dp->d_reclen; 33107c478bd9Sstevel@tonic-gate /* LINTED improper alignment */ 33117c478bd9Sstevel@tonic-gate dp = (struct dirent32 *)((char *)dp + dp->d_reclen); 33127c478bd9Sstevel@tonic-gate } 33137c478bd9Sstevel@tonic-gate } 33147c478bd9Sstevel@tonic-gate 33157c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 33167c478bd9Sstevel@tonic-gate if (serial) 33177c478bd9Sstevel@tonic-gate Xserialize(); 33187c478bd9Sstevel@tonic-gate } 33197c478bd9Sstevel@tonic-gate 33207c478bd9Sstevel@tonic-gate void 33217c478bd9Sstevel@tonic-gate show_dents64(private_t *pri, long offset, long count) 33227c478bd9Sstevel@tonic-gate { 33237c478bd9Sstevel@tonic-gate long long buf[MYBUFSIZ / sizeof (long long)]; 33247c478bd9Sstevel@tonic-gate struct dirent64 *dp; 33257c478bd9Sstevel@tonic-gate int serial = (count > 100); 33267c478bd9Sstevel@tonic-gate 33277c478bd9Sstevel@tonic-gate if (offset == NULL) 33287c478bd9Sstevel@tonic-gate return; 33297c478bd9Sstevel@tonic-gate 33307c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 33317c478bd9Sstevel@tonic-gate if (serial) 33327c478bd9Sstevel@tonic-gate Eserialize(); 33337c478bd9Sstevel@tonic-gate 33347c478bd9Sstevel@tonic-gate while (count > 0 && !interrupt) { 33357c478bd9Sstevel@tonic-gate int nb = count < MYBUFSIZ? (int)count : MYBUFSIZ; 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) <= 0) 33387c478bd9Sstevel@tonic-gate break; 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate dp = (struct dirent64 *)&buf[0]; 33417c478bd9Sstevel@tonic-gate if (nb < (int)(dp->d_name - (char *)dp)) 33427c478bd9Sstevel@tonic-gate break; 33437c478bd9Sstevel@tonic-gate if ((unsigned)nb < dp->d_reclen) { 33447c478bd9Sstevel@tonic-gate /* getdents() error? */ 33457c478bd9Sstevel@tonic-gate (void) printf( 33467c478bd9Sstevel@tonic-gate "%s ino=%-5llu off=%-4lld rlen=%-3d\n", 33477c478bd9Sstevel@tonic-gate pri->pname, 33487c478bd9Sstevel@tonic-gate (long long)dp->d_ino, 33497c478bd9Sstevel@tonic-gate (long long)dp->d_off, 33507c478bd9Sstevel@tonic-gate dp->d_reclen); 33517c478bd9Sstevel@tonic-gate break; 33527c478bd9Sstevel@tonic-gate } 33537c478bd9Sstevel@tonic-gate 33547c478bd9Sstevel@tonic-gate while (!interrupt && 33557c478bd9Sstevel@tonic-gate nb >= (int)(dp->d_name - (char *)dp) && 33567c478bd9Sstevel@tonic-gate (unsigned)nb >= dp->d_reclen) { 33577c478bd9Sstevel@tonic-gate (void) printf( 33587c478bd9Sstevel@tonic-gate "%s ino=%-5llu off=%-4lld rlen=%-3d \"%.*s\"\n", 33597c478bd9Sstevel@tonic-gate pri->pname, 33607c478bd9Sstevel@tonic-gate (long long)dp->d_ino, 33617c478bd9Sstevel@tonic-gate (long long)dp->d_off, 33627c478bd9Sstevel@tonic-gate dp->d_reclen, 33637c478bd9Sstevel@tonic-gate dp->d_reclen - (int)(dp->d_name - (char *)dp), 33647c478bd9Sstevel@tonic-gate dp->d_name); 33657c478bd9Sstevel@tonic-gate nb -= dp->d_reclen; 33667c478bd9Sstevel@tonic-gate count -= dp->d_reclen; 33677c478bd9Sstevel@tonic-gate offset += dp->d_reclen; 33687c478bd9Sstevel@tonic-gate /* LINTED improper alignment */ 33697c478bd9Sstevel@tonic-gate dp = (struct dirent64 *)((char *)dp + dp->d_reclen); 33707c478bd9Sstevel@tonic-gate } 33717c478bd9Sstevel@tonic-gate } 33727c478bd9Sstevel@tonic-gate 33737c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 33747c478bd9Sstevel@tonic-gate if (serial) 33757c478bd9Sstevel@tonic-gate Xserialize(); 33767c478bd9Sstevel@tonic-gate } 33777c478bd9Sstevel@tonic-gate 33787c478bd9Sstevel@tonic-gate void 33797c478bd9Sstevel@tonic-gate show_rlimit32(private_t *pri, long offset) 33807c478bd9Sstevel@tonic-gate { 33817c478bd9Sstevel@tonic-gate struct rlimit32 rlimit; 33827c478bd9Sstevel@tonic-gate 33837c478bd9Sstevel@tonic-gate if (offset != NULL && 33847c478bd9Sstevel@tonic-gate Pread(Proc, &rlimit, sizeof (rlimit), offset) == sizeof (rlimit)) { 33857c478bd9Sstevel@tonic-gate (void) printf("%s\t", pri->pname); 33867c478bd9Sstevel@tonic-gate switch (rlimit.rlim_cur) { 33877c478bd9Sstevel@tonic-gate case RLIM32_INFINITY: 33887c478bd9Sstevel@tonic-gate (void) fputs("cur = RLIM_INFINITY", stdout); 33897c478bd9Sstevel@tonic-gate break; 33907c478bd9Sstevel@tonic-gate case RLIM32_SAVED_MAX: 33917c478bd9Sstevel@tonic-gate (void) fputs("cur = RLIM_SAVED_MAX", stdout); 33927c478bd9Sstevel@tonic-gate break; 33937c478bd9Sstevel@tonic-gate case RLIM32_SAVED_CUR: 33947c478bd9Sstevel@tonic-gate (void) fputs("cur = RLIM_SAVED_CUR", stdout); 33957c478bd9Sstevel@tonic-gate break; 33967c478bd9Sstevel@tonic-gate default: 33977c478bd9Sstevel@tonic-gate (void) printf("cur = %lu", (long)rlimit.rlim_cur); 33987c478bd9Sstevel@tonic-gate break; 33997c478bd9Sstevel@tonic-gate } 34007c478bd9Sstevel@tonic-gate switch (rlimit.rlim_max) { 34017c478bd9Sstevel@tonic-gate case RLIM32_INFINITY: 34027c478bd9Sstevel@tonic-gate (void) fputs(" max = RLIM_INFINITY\n", stdout); 34037c478bd9Sstevel@tonic-gate break; 34047c478bd9Sstevel@tonic-gate case RLIM32_SAVED_MAX: 34057c478bd9Sstevel@tonic-gate (void) fputs(" max = RLIM_SAVED_MAX\n", stdout); 34067c478bd9Sstevel@tonic-gate break; 34077c478bd9Sstevel@tonic-gate case RLIM32_SAVED_CUR: 34087c478bd9Sstevel@tonic-gate (void) fputs(" max = RLIM_SAVED_CUR\n", stdout); 34097c478bd9Sstevel@tonic-gate break; 34107c478bd9Sstevel@tonic-gate default: 34117c478bd9Sstevel@tonic-gate (void) printf(" max = %lu\n", (long)rlimit.rlim_max); 34127c478bd9Sstevel@tonic-gate break; 34137c478bd9Sstevel@tonic-gate } 34147c478bd9Sstevel@tonic-gate } 34157c478bd9Sstevel@tonic-gate } 34167c478bd9Sstevel@tonic-gate 34177c478bd9Sstevel@tonic-gate void 34187c478bd9Sstevel@tonic-gate show_rlimit64(private_t *pri, long offset) 34197c478bd9Sstevel@tonic-gate { 34207c478bd9Sstevel@tonic-gate struct rlimit64 rlimit; 34217c478bd9Sstevel@tonic-gate 34227c478bd9Sstevel@tonic-gate if (offset != NULL && 34237c478bd9Sstevel@tonic-gate Pread(Proc, &rlimit, sizeof (rlimit), offset) == sizeof (rlimit)) { 34247c478bd9Sstevel@tonic-gate (void) printf("%s\t", pri->pname); 34257c478bd9Sstevel@tonic-gate switch (rlimit.rlim_cur) { 34267c478bd9Sstevel@tonic-gate case RLIM64_INFINITY: 34277c478bd9Sstevel@tonic-gate (void) fputs("cur = RLIM64_INFINITY", stdout); 34287c478bd9Sstevel@tonic-gate break; 34297c478bd9Sstevel@tonic-gate case RLIM64_SAVED_MAX: 34307c478bd9Sstevel@tonic-gate (void) fputs("cur = RLIM64_SAVED_MAX", stdout); 34317c478bd9Sstevel@tonic-gate break; 34327c478bd9Sstevel@tonic-gate case RLIM64_SAVED_CUR: 34337c478bd9Sstevel@tonic-gate (void) fputs("cur = RLIM64_SAVED_CUR", stdout); 34347c478bd9Sstevel@tonic-gate break; 34357c478bd9Sstevel@tonic-gate default: 34367c478bd9Sstevel@tonic-gate (void) printf("cur = %llu", 34377c478bd9Sstevel@tonic-gate (unsigned long long)rlimit.rlim_cur); 34387c478bd9Sstevel@tonic-gate break; 34397c478bd9Sstevel@tonic-gate } 34407c478bd9Sstevel@tonic-gate switch (rlimit.rlim_max) { 34417c478bd9Sstevel@tonic-gate case RLIM64_INFINITY: 34427c478bd9Sstevel@tonic-gate (void) fputs(" max = RLIM64_INFINITY\n", stdout); 34437c478bd9Sstevel@tonic-gate break; 34447c478bd9Sstevel@tonic-gate case RLIM64_SAVED_MAX: 34457c478bd9Sstevel@tonic-gate (void) fputs(" max = RLIM64_SAVED_MAX\n", stdout); 34467c478bd9Sstevel@tonic-gate break; 34477c478bd9Sstevel@tonic-gate case RLIM64_SAVED_CUR: 34487c478bd9Sstevel@tonic-gate (void) fputs(" max = RLIM64_SAVED_CUR\n", stdout); 34497c478bd9Sstevel@tonic-gate break; 34507c478bd9Sstevel@tonic-gate default: 34517c478bd9Sstevel@tonic-gate (void) printf(" max = %llu\n", 34527c478bd9Sstevel@tonic-gate (unsigned long long)rlimit.rlim_max); 34537c478bd9Sstevel@tonic-gate break; 34547c478bd9Sstevel@tonic-gate } 34557c478bd9Sstevel@tonic-gate } 34567c478bd9Sstevel@tonic-gate } 34577c478bd9Sstevel@tonic-gate 34587c478bd9Sstevel@tonic-gate void 34597c478bd9Sstevel@tonic-gate show_nuname(private_t *pri, long offset) 34607c478bd9Sstevel@tonic-gate { 34617c478bd9Sstevel@tonic-gate struct utsname ubuf; 34627c478bd9Sstevel@tonic-gate 34637c478bd9Sstevel@tonic-gate if (offset != NULL && 34647c478bd9Sstevel@tonic-gate Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) { 34657c478bd9Sstevel@tonic-gate (void) printf( 34667c478bd9Sstevel@tonic-gate "%s\tsys=%s nod=%s rel=%s ver=%s mch=%s\n", 34677c478bd9Sstevel@tonic-gate pri->pname, 34687c478bd9Sstevel@tonic-gate ubuf.sysname, 34697c478bd9Sstevel@tonic-gate ubuf.nodename, 34707c478bd9Sstevel@tonic-gate ubuf.release, 34717c478bd9Sstevel@tonic-gate ubuf.version, 34727c478bd9Sstevel@tonic-gate ubuf.machine); 34737c478bd9Sstevel@tonic-gate } 34747c478bd9Sstevel@tonic-gate } 34757c478bd9Sstevel@tonic-gate 34767c478bd9Sstevel@tonic-gate void 34777c478bd9Sstevel@tonic-gate show_adjtime(private_t *pri, long off1, long off2) 34787c478bd9Sstevel@tonic-gate { 34797c478bd9Sstevel@tonic-gate show_timeval(pri, off1, " delta"); 34807c478bd9Sstevel@tonic-gate show_timeval(pri, off2, "olddelta"); 34817c478bd9Sstevel@tonic-gate } 34827c478bd9Sstevel@tonic-gate 34837c478bd9Sstevel@tonic-gate void 34847c478bd9Sstevel@tonic-gate show_sockaddr(private_t *pri, 34857c478bd9Sstevel@tonic-gate const char *str, long addroff, long lenoff, long len) 34867c478bd9Sstevel@tonic-gate { 34877c478bd9Sstevel@tonic-gate /* 34887c478bd9Sstevel@tonic-gate * A buffer large enough for PATH_MAX size AF_UNIX address, which is 34897c478bd9Sstevel@tonic-gate * also large enough to store a sockaddr_in or a sockaddr_in6. 34907c478bd9Sstevel@tonic-gate */ 34917c478bd9Sstevel@tonic-gate long buf[(sizeof (short) + PATH_MAX + sizeof (long) - 1) 34927c478bd9Sstevel@tonic-gate / sizeof (long)]; 34937c478bd9Sstevel@tonic-gate struct sockaddr *sa = (struct sockaddr *)buf; 34947c478bd9Sstevel@tonic-gate struct sockaddr_in *sin = (struct sockaddr_in *)buf; 34957c478bd9Sstevel@tonic-gate struct sockaddr_un *soun = (struct sockaddr_un *)buf; 34967c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf; 34977c478bd9Sstevel@tonic-gate char addrbuf[INET6_ADDRSTRLEN]; 34987c478bd9Sstevel@tonic-gate 34997c478bd9Sstevel@tonic-gate if (lenoff != 0) { 35007c478bd9Sstevel@tonic-gate uint_t ilen; 35017c478bd9Sstevel@tonic-gate if (Pread(Proc, &ilen, sizeof (ilen), lenoff) != sizeof (ilen)) 35027c478bd9Sstevel@tonic-gate return; 35037c478bd9Sstevel@tonic-gate len = ilen; 35047c478bd9Sstevel@tonic-gate } 35057c478bd9Sstevel@tonic-gate 35067c478bd9Sstevel@tonic-gate if (len >= sizeof (buf)) /* protect against ridiculous length */ 35077c478bd9Sstevel@tonic-gate len = sizeof (buf) - 1; 35087c478bd9Sstevel@tonic-gate if (Pread(Proc, buf, len, addroff) != len) 35097c478bd9Sstevel@tonic-gate return; 35107c478bd9Sstevel@tonic-gate 35117c478bd9Sstevel@tonic-gate switch (sa->sa_family) { 35127c478bd9Sstevel@tonic-gate case AF_INET6: 35137c478bd9Sstevel@tonic-gate (void) printf("%s\tAF_INET6 %s = %s port = %u\n", 35147c478bd9Sstevel@tonic-gate pri->pname, str, 35157c478bd9Sstevel@tonic-gate inet_ntop(AF_INET6, &sin6->sin6_addr, addrbuf, 35167c478bd9Sstevel@tonic-gate sizeof (addrbuf)), 35177c478bd9Sstevel@tonic-gate ntohs(sin6->sin6_port)); 35187c478bd9Sstevel@tonic-gate (void) printf("%s\tscope id = %u source id = 0x%x\n" 35197c478bd9Sstevel@tonic-gate "%s\tflow class = 0x%02x flow label = 0x%05x\n", 35207c478bd9Sstevel@tonic-gate pri->pname, ntohl(sin6->sin6_scope_id), 35217c478bd9Sstevel@tonic-gate ntohl(sin6->__sin6_src_id), 35227c478bd9Sstevel@tonic-gate pri->pname, 35237c478bd9Sstevel@tonic-gate ntohl((sin6->sin6_flowinfo & IPV6_FLOWINFO_TCLASS) >> 20), 35247c478bd9Sstevel@tonic-gate ntohl(sin6->sin6_flowinfo & IPV6_FLOWINFO_FLOWLABEL)); 35257c478bd9Sstevel@tonic-gate break; 35267c478bd9Sstevel@tonic-gate case AF_INET: 35277c478bd9Sstevel@tonic-gate (void) printf("%s\tAF_%s %s = %s port = %u\n", 3528*2caf0dcdSrshoaib pri->pname, "INET", 35297c478bd9Sstevel@tonic-gate str, inet_ntop(AF_INET, &sin->sin_addr, addrbuf, 35307c478bd9Sstevel@tonic-gate sizeof (addrbuf)), ntohs(sin->sin_port)); 35317c478bd9Sstevel@tonic-gate break; 35327c478bd9Sstevel@tonic-gate case AF_UNIX: 35337c478bd9Sstevel@tonic-gate len -= sizeof (soun->sun_family); 35347c478bd9Sstevel@tonic-gate if (len >= 0) { 35357c478bd9Sstevel@tonic-gate /* Null terminate */ 35367c478bd9Sstevel@tonic-gate soun->sun_path[len] = NULL; 35377c478bd9Sstevel@tonic-gate (void) printf("%s\tAF_UNIX %s = %s\n", pri->pname, 35387c478bd9Sstevel@tonic-gate str, soun->sun_path); 35397c478bd9Sstevel@tonic-gate } 35407c478bd9Sstevel@tonic-gate break; 35417c478bd9Sstevel@tonic-gate } 35427c478bd9Sstevel@tonic-gate } 35437c478bd9Sstevel@tonic-gate 35447c478bd9Sstevel@tonic-gate void 35457c478bd9Sstevel@tonic-gate show_msghdr(private_t *pri, long offset) 35467c478bd9Sstevel@tonic-gate { 354781006e0fSja97890 const lwpstatus_t *Lsp = pri->lwpstat; 354881006e0fSja97890 int what = Lsp->pr_what; 354981006e0fSja97890 int err = pri->Errno; 35507c478bd9Sstevel@tonic-gate struct msghdr msg; 355181006e0fSja97890 int showbuf = FALSE; 355281006e0fSja97890 int i = pri->sys_args[0]+1; 355381006e0fSja97890 long nb = (what == SYS_recvmsg)? pri->Rval1 : 32*1024; 35547c478bd9Sstevel@tonic-gate 35557c478bd9Sstevel@tonic-gate if (Pread(Proc, &msg, sizeof (msg), offset) != sizeof (msg)) 35567c478bd9Sstevel@tonic-gate return; 355781006e0fSja97890 35587c478bd9Sstevel@tonic-gate if (msg.msg_name != NULL && msg.msg_namelen != 0) 35597c478bd9Sstevel@tonic-gate show_sockaddr(pri, "msg_name", 35607c478bd9Sstevel@tonic-gate (long)msg.msg_name, 0, (long)msg.msg_namelen); 356181006e0fSja97890 356281006e0fSja97890 /* 356381006e0fSja97890 * Print the iovec if the syscall was successful and the fd is 356481006e0fSja97890 * part of the set being traced. 356581006e0fSja97890 */ 356681006e0fSja97890 if ((what == SYS_recvmsg && !err && 356781006e0fSja97890 prismember(&readfd, i)) || 356881006e0fSja97890 (what == SYS_sendmsg && 356981006e0fSja97890 prismember(&writefd, i))) 357081006e0fSja97890 showbuf = TRUE; 357181006e0fSja97890 357281006e0fSja97890 show_iovec(pri, (long)msg.msg_iov, msg.msg_iovlen, showbuf, nb); 357381006e0fSja97890 35747c478bd9Sstevel@tonic-gate } 35757c478bd9Sstevel@tonic-gate 35767c478bd9Sstevel@tonic-gate #ifdef _LP64 35777c478bd9Sstevel@tonic-gate void 35787c478bd9Sstevel@tonic-gate show_msghdr32(private_t *pri, long offset) 35797c478bd9Sstevel@tonic-gate { 35807c478bd9Sstevel@tonic-gate struct msghdr32 { 35817c478bd9Sstevel@tonic-gate caddr32_t msg_name; 358281006e0fSja97890 uint32_t msg_namelen; 358381006e0fSja97890 caddr32_t msg_iov; 358481006e0fSja97890 int32_t msg_iovlen; 35857c478bd9Sstevel@tonic-gate } msg; 358681006e0fSja97890 const lwpstatus_t *Lsp = pri->lwpstat; 358781006e0fSja97890 int what = Lsp->pr_what; 358881006e0fSja97890 int err = pri->Errno; 358981006e0fSja97890 int showbuf = FALSE; 359081006e0fSja97890 int i = pri->sys_args[0]+1; 359181006e0fSja97890 long nb = (what == SYS_recvmsg)? pri->Rval1 : 32*1024; 35927c478bd9Sstevel@tonic-gate 35937c478bd9Sstevel@tonic-gate if (Pread(Proc, &msg, sizeof (msg), offset) != sizeof (msg)) 35947c478bd9Sstevel@tonic-gate return; 359581006e0fSja97890 35967c478bd9Sstevel@tonic-gate if (msg.msg_name != NULL && msg.msg_namelen != 0) 35977c478bd9Sstevel@tonic-gate show_sockaddr(pri, "msg_name", 35987c478bd9Sstevel@tonic-gate (long)msg.msg_name, 0, (long)msg.msg_namelen); 359981006e0fSja97890 /* 360081006e0fSja97890 * Print the iovec if the syscall was successful and the fd is 360181006e0fSja97890 * part of the set being traced. 360281006e0fSja97890 */ 360381006e0fSja97890 if ((what == SYS_recvmsg && !err && 360481006e0fSja97890 prismember(&readfd, i)) || 360581006e0fSja97890 (what == SYS_sendmsg && 360681006e0fSja97890 prismember(&writefd, i))) 360781006e0fSja97890 showbuf = TRUE; 360881006e0fSja97890 360981006e0fSja97890 show_iovec32(pri, (long)msg.msg_iov, msg.msg_iovlen, showbuf, nb); 361081006e0fSja97890 36117c478bd9Sstevel@tonic-gate } 36127c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 36137c478bd9Sstevel@tonic-gate 36147c478bd9Sstevel@tonic-gate static void 36157c478bd9Sstevel@tonic-gate show_doorargs(private_t *pri, long offset) 36167c478bd9Sstevel@tonic-gate { 36177c478bd9Sstevel@tonic-gate door_arg_t args; 36187c478bd9Sstevel@tonic-gate 36197c478bd9Sstevel@tonic-gate if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) { 36207c478bd9Sstevel@tonic-gate (void) printf("%s\tdata_ptr=0x%lX data_size=%lu\n", 36217c478bd9Sstevel@tonic-gate pri->pname, 36227c478bd9Sstevel@tonic-gate (ulong_t)args.data_ptr, 36237c478bd9Sstevel@tonic-gate (ulong_t)args.data_size); 36247c478bd9Sstevel@tonic-gate (void) printf("%s\tdesc_ptr=0x%lX desc_num=%u\n", 36257c478bd9Sstevel@tonic-gate pri->pname, 36267c478bd9Sstevel@tonic-gate (ulong_t)args.desc_ptr, 36277c478bd9Sstevel@tonic-gate args.desc_num); 36287c478bd9Sstevel@tonic-gate (void) printf("%s\trbuf=0x%lX rsize=%lu\n", 36297c478bd9Sstevel@tonic-gate pri->pname, 36307c478bd9Sstevel@tonic-gate (ulong_t)args.rbuf, 36317c478bd9Sstevel@tonic-gate (ulong_t)args.rsize); 36327c478bd9Sstevel@tonic-gate } 36337c478bd9Sstevel@tonic-gate } 36347c478bd9Sstevel@tonic-gate 36357c478bd9Sstevel@tonic-gate static void 36367c478bd9Sstevel@tonic-gate show_ucred_privsets(private_t *pri, ucred_t *uc) 36377c478bd9Sstevel@tonic-gate { 36387c478bd9Sstevel@tonic-gate int i = 0; 36397c478bd9Sstevel@tonic-gate const priv_set_t *s; 36407c478bd9Sstevel@tonic-gate priv_ptype_t sn; 36417c478bd9Sstevel@tonic-gate char *str; 36427c478bd9Sstevel@tonic-gate 36437c478bd9Sstevel@tonic-gate while ((sn = priv_getsetbynum(i++)) != NULL) { 36447c478bd9Sstevel@tonic-gate s = ucred_getprivset(uc, sn); 36457c478bd9Sstevel@tonic-gate 36467c478bd9Sstevel@tonic-gate if (s == NULL) 36477c478bd9Sstevel@tonic-gate continue; 36487c478bd9Sstevel@tonic-gate 36497c478bd9Sstevel@tonic-gate (void) printf("%s\t%c: %s\n", 36507c478bd9Sstevel@tonic-gate pri->pname, 36517c478bd9Sstevel@tonic-gate *sn, 36527c478bd9Sstevel@tonic-gate str = priv_set_to_str(s, ',', PRIV_STR_SHORT)); 36537c478bd9Sstevel@tonic-gate 36547c478bd9Sstevel@tonic-gate free(str); 36557c478bd9Sstevel@tonic-gate } 36567c478bd9Sstevel@tonic-gate } 36577c478bd9Sstevel@tonic-gate 36587c478bd9Sstevel@tonic-gate static void 36597c478bd9Sstevel@tonic-gate show_ucred(private_t *pri, long offset) 36607c478bd9Sstevel@tonic-gate { 36617c478bd9Sstevel@tonic-gate ucred_t *uc = _ucred_alloc(); 36627c478bd9Sstevel@tonic-gate size_t sz; 36637c478bd9Sstevel@tonic-gate 36647c478bd9Sstevel@tonic-gate if (uc == NULL) 36657c478bd9Sstevel@tonic-gate return; 36667c478bd9Sstevel@tonic-gate 36677c478bd9Sstevel@tonic-gate sz = Pread(Proc, uc, uc->uc_size, offset); 36687c478bd9Sstevel@tonic-gate 36697c478bd9Sstevel@tonic-gate /* 36707c478bd9Sstevel@tonic-gate * A new uc_size is read, it could be smaller than the previously 36717c478bd9Sstevel@tonic-gate * value. We accept short reads that fill the whole header. 36727c478bd9Sstevel@tonic-gate */ 36737c478bd9Sstevel@tonic-gate if (sz >= sizeof (ucred_t) && sz >= uc->uc_size) { 36747c478bd9Sstevel@tonic-gate (void) printf("%s\teuid=%d egid=%d\n", 36757c478bd9Sstevel@tonic-gate pri->pname, 36767c478bd9Sstevel@tonic-gate (int)ucred_geteuid(uc), 36777c478bd9Sstevel@tonic-gate (int)ucred_getegid(uc)); 36787c478bd9Sstevel@tonic-gate (void) printf("%s\truid=%d rgid=%d\n", 36797c478bd9Sstevel@tonic-gate pri->pname, 36807c478bd9Sstevel@tonic-gate (int)ucred_getruid(uc), 36817c478bd9Sstevel@tonic-gate (int)ucred_getrgid(uc)); 36827c478bd9Sstevel@tonic-gate (void) printf("%s\tpid=%d zoneid=%d\n", 36837c478bd9Sstevel@tonic-gate pri->pname, 36847c478bd9Sstevel@tonic-gate (int)ucred_getpid(uc), 36857c478bd9Sstevel@tonic-gate (int)ucred_getzoneid(uc)); 36867c478bd9Sstevel@tonic-gate show_ucred_privsets(pri, uc); 36877c478bd9Sstevel@tonic-gate } 36887c478bd9Sstevel@tonic-gate ucred_free(uc); 36897c478bd9Sstevel@tonic-gate } 36907c478bd9Sstevel@tonic-gate 36917c478bd9Sstevel@tonic-gate static void 3692821c4a97Sdp show_privset(private_t *pri, long offset, size_t size, char *label) 36937c478bd9Sstevel@tonic-gate { 36947c478bd9Sstevel@tonic-gate priv_set_t *tmp = priv_allocset(); 36957c478bd9Sstevel@tonic-gate size_t sz; 36967c478bd9Sstevel@tonic-gate 36977c478bd9Sstevel@tonic-gate if (tmp == NULL) 36987c478bd9Sstevel@tonic-gate return; 36997c478bd9Sstevel@tonic-gate 37007c478bd9Sstevel@tonic-gate sz = Pread(Proc, tmp, size, offset); 37017c478bd9Sstevel@tonic-gate 37027c478bd9Sstevel@tonic-gate if (sz == size) { 37037c478bd9Sstevel@tonic-gate char *str = priv_set_to_str(tmp, ',', PRIV_STR_SHORT); 37047c478bd9Sstevel@tonic-gate if (str != NULL) { 3705821c4a97Sdp (void) printf("%s\t%s%s\n", pri->pname, label, str); 37067c478bd9Sstevel@tonic-gate free(str); 37077c478bd9Sstevel@tonic-gate } 37087c478bd9Sstevel@tonic-gate } 37097c478bd9Sstevel@tonic-gate priv_freeset(tmp); 37107c478bd9Sstevel@tonic-gate } 37117c478bd9Sstevel@tonic-gate 37127c478bd9Sstevel@tonic-gate static void 37137c478bd9Sstevel@tonic-gate show_doorinfo(private_t *pri, long offset) 37147c478bd9Sstevel@tonic-gate { 37157c478bd9Sstevel@tonic-gate door_info_t info; 37167c478bd9Sstevel@tonic-gate door_attr_t attr; 37177c478bd9Sstevel@tonic-gate 37187c478bd9Sstevel@tonic-gate if (Pread(Proc, &info, sizeof (info), offset) != sizeof (info)) 37197c478bd9Sstevel@tonic-gate return; 37207c478bd9Sstevel@tonic-gate (void) printf("%s\ttarget=%d proc=0x%llX data=0x%llX\n", 37217c478bd9Sstevel@tonic-gate pri->pname, 37227c478bd9Sstevel@tonic-gate (int)info.di_target, 37237c478bd9Sstevel@tonic-gate info.di_proc, 37247c478bd9Sstevel@tonic-gate info.di_data); 37257c478bd9Sstevel@tonic-gate attr = info.di_attributes; 37267c478bd9Sstevel@tonic-gate (void) printf("%s\tattributes=%s\n", pri->pname, door_flags(pri, attr)); 37277c478bd9Sstevel@tonic-gate (void) printf("%s\tuniquifier=%llu\n", pri->pname, info.di_uniquifier); 37287c478bd9Sstevel@tonic-gate } 37297c478bd9Sstevel@tonic-gate 37307c478bd9Sstevel@tonic-gate static void 37317c478bd9Sstevel@tonic-gate show_doorparam(private_t *pri, long offset) 37327c478bd9Sstevel@tonic-gate { 37337c478bd9Sstevel@tonic-gate ulong_t val; 37347c478bd9Sstevel@tonic-gate 37357c478bd9Sstevel@tonic-gate if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) { 37367c478bd9Sstevel@tonic-gate (void) printf("%s\tvalue=%lu\n", 37377c478bd9Sstevel@tonic-gate pri->pname, 37387c478bd9Sstevel@tonic-gate val); 37397c478bd9Sstevel@tonic-gate } 37407c478bd9Sstevel@tonic-gate } 37417c478bd9Sstevel@tonic-gate 37427c478bd9Sstevel@tonic-gate #ifdef _LP64 37437c478bd9Sstevel@tonic-gate 37447c478bd9Sstevel@tonic-gate static void 37457c478bd9Sstevel@tonic-gate show_doorargs32(private_t *pri, long offset) 37467c478bd9Sstevel@tonic-gate { 37477c478bd9Sstevel@tonic-gate struct door_arg32 args; 37487c478bd9Sstevel@tonic-gate 37497c478bd9Sstevel@tonic-gate if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) { 37507c478bd9Sstevel@tonic-gate (void) printf("%s\tdata_ptr=%X data_size=%u\n", 37517c478bd9Sstevel@tonic-gate pri->pname, 37527c478bd9Sstevel@tonic-gate args.data_ptr, 37537c478bd9Sstevel@tonic-gate args.data_size); 37547c478bd9Sstevel@tonic-gate (void) printf("%s\tdesc_ptr=0x%X desc_num=%u\n", 37557c478bd9Sstevel@tonic-gate pri->pname, 37567c478bd9Sstevel@tonic-gate args.desc_ptr, 37577c478bd9Sstevel@tonic-gate args.desc_num); 37587c478bd9Sstevel@tonic-gate (void) printf("%s\trbuf=0x%X rsize=%u\n", 37597c478bd9Sstevel@tonic-gate pri->pname, 37607c478bd9Sstevel@tonic-gate args.rbuf, 37617c478bd9Sstevel@tonic-gate args.rsize); 37627c478bd9Sstevel@tonic-gate } 37637c478bd9Sstevel@tonic-gate } 37647c478bd9Sstevel@tonic-gate 37657c478bd9Sstevel@tonic-gate static void 37667c478bd9Sstevel@tonic-gate show_doorparam32(private_t *pri, long offset) 37677c478bd9Sstevel@tonic-gate { 37687c478bd9Sstevel@tonic-gate uint_t val; 37697c478bd9Sstevel@tonic-gate 37707c478bd9Sstevel@tonic-gate if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) { 37717c478bd9Sstevel@tonic-gate (void) printf("%s\tvalue=%u\n", 37727c478bd9Sstevel@tonic-gate pri->pname, 37737c478bd9Sstevel@tonic-gate val); 37747c478bd9Sstevel@tonic-gate } 37757c478bd9Sstevel@tonic-gate } 37767c478bd9Sstevel@tonic-gate 37777c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 37787c478bd9Sstevel@tonic-gate 37797c478bd9Sstevel@tonic-gate static void 37807c478bd9Sstevel@tonic-gate show_doors(private_t *pri) 37817c478bd9Sstevel@tonic-gate { 37827c478bd9Sstevel@tonic-gate switch (pri->sys_args[5]) { 37837c478bd9Sstevel@tonic-gate case DOOR_CALL: 37847c478bd9Sstevel@tonic-gate #ifdef _LP64 37857c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 37867c478bd9Sstevel@tonic-gate show_doorargs(pri, (long)pri->sys_args[1]); 37877c478bd9Sstevel@tonic-gate else 37887c478bd9Sstevel@tonic-gate show_doorargs32(pri, (long)pri->sys_args[1]); 37897c478bd9Sstevel@tonic-gate #else 37907c478bd9Sstevel@tonic-gate show_doorargs(pri, (long)pri->sys_args[1]); 37917c478bd9Sstevel@tonic-gate #endif 37927c478bd9Sstevel@tonic-gate break; 37937c478bd9Sstevel@tonic-gate case DOOR_UCRED: 37947c478bd9Sstevel@tonic-gate if (!pri->Errno) 37957c478bd9Sstevel@tonic-gate show_ucred(pri, (long)pri->sys_args[0]); 37967c478bd9Sstevel@tonic-gate break; 37977c478bd9Sstevel@tonic-gate case DOOR_INFO: 37987c478bd9Sstevel@tonic-gate if (!pri->Errno) 37997c478bd9Sstevel@tonic-gate show_doorinfo(pri, (long)pri->sys_args[1]); 38007c478bd9Sstevel@tonic-gate break; 38017c478bd9Sstevel@tonic-gate case DOOR_GETPARAM: 38027c478bd9Sstevel@tonic-gate if (!pri->Errno) { 38037c478bd9Sstevel@tonic-gate #ifdef _LP64 38047c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 38057c478bd9Sstevel@tonic-gate show_doorparam(pri, (long)pri->sys_args[2]); 38067c478bd9Sstevel@tonic-gate else 38077c478bd9Sstevel@tonic-gate show_doorparam32(pri, (long)pri->sys_args[2]); 38087c478bd9Sstevel@tonic-gate #else 38097c478bd9Sstevel@tonic-gate show_doorparam(pri, (long)pri->sys_args[2]); 38107c478bd9Sstevel@tonic-gate #endif 38117c478bd9Sstevel@tonic-gate } 38127c478bd9Sstevel@tonic-gate break; 38137c478bd9Sstevel@tonic-gate } 38147c478bd9Sstevel@tonic-gate } 38157c478bd9Sstevel@tonic-gate 38167c478bd9Sstevel@tonic-gate static void 38177c478bd9Sstevel@tonic-gate show_portargs(private_t *pri, long offset) 38187c478bd9Sstevel@tonic-gate { 38197c478bd9Sstevel@tonic-gate port_event_t args; 38207c478bd9Sstevel@tonic-gate 38217c478bd9Sstevel@tonic-gate if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) { 38227c478bd9Sstevel@tonic-gate (void) printf("%s\tevents=0x%x source=%u\n", 38237c478bd9Sstevel@tonic-gate pri->pname, 38247c478bd9Sstevel@tonic-gate args.portev_events, 38257c478bd9Sstevel@tonic-gate args.portev_source); 38267c478bd9Sstevel@tonic-gate (void) printf("%s\tobject=0x%p user=0x%p\n", 38277c478bd9Sstevel@tonic-gate pri->pname, 38287c478bd9Sstevel@tonic-gate (void *)args.portev_object, 38297c478bd9Sstevel@tonic-gate (void *)args.portev_user); 38307c478bd9Sstevel@tonic-gate } 38317c478bd9Sstevel@tonic-gate } 38327c478bd9Sstevel@tonic-gate 38337c478bd9Sstevel@tonic-gate 38347c478bd9Sstevel@tonic-gate #ifdef _LP64 38357c478bd9Sstevel@tonic-gate 38367c478bd9Sstevel@tonic-gate static void 38377c478bd9Sstevel@tonic-gate show_portargs32(private_t *pri, long offset) 38387c478bd9Sstevel@tonic-gate { 38397c478bd9Sstevel@tonic-gate port_event32_t args; 38407c478bd9Sstevel@tonic-gate 38417c478bd9Sstevel@tonic-gate if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) { 38427c478bd9Sstevel@tonic-gate (void) printf("%s\tevents=0x%x source=%u\n", 38437c478bd9Sstevel@tonic-gate pri->pname, 38447c478bd9Sstevel@tonic-gate args.portev_events, 38457c478bd9Sstevel@tonic-gate args.portev_source); 38467c478bd9Sstevel@tonic-gate (void) printf("%s\tobject=0x%x user=0x%x\n", 38477c478bd9Sstevel@tonic-gate pri->pname, 38487c478bd9Sstevel@tonic-gate args.portev_object, 38497c478bd9Sstevel@tonic-gate args.portev_user); 38507c478bd9Sstevel@tonic-gate } 38517c478bd9Sstevel@tonic-gate } 38527c478bd9Sstevel@tonic-gate 38537c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 38547c478bd9Sstevel@tonic-gate 38557c478bd9Sstevel@tonic-gate static void 38567c478bd9Sstevel@tonic-gate show_ports(private_t *pri) 38577c478bd9Sstevel@tonic-gate { 38587c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 38597c478bd9Sstevel@tonic-gate case PORT_GET: 38607c478bd9Sstevel@tonic-gate #ifdef _LP64 38617c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 38627c478bd9Sstevel@tonic-gate show_portargs(pri, (long)pri->sys_args[2]); 38637c478bd9Sstevel@tonic-gate else 38647c478bd9Sstevel@tonic-gate show_portargs32(pri, (long)pri->sys_args[2]); 38657c478bd9Sstevel@tonic-gate #else 38667c478bd9Sstevel@tonic-gate show_portargs(pri, (long)pri->sys_args[2]); 38677c478bd9Sstevel@tonic-gate #endif 38687c478bd9Sstevel@tonic-gate break; 38697c478bd9Sstevel@tonic-gate } 38707c478bd9Sstevel@tonic-gate } 38717c478bd9Sstevel@tonic-gate 38727c478bd9Sstevel@tonic-gate #define MAX_SNDFL_PRD 16 38737c478bd9Sstevel@tonic-gate 38747c478bd9Sstevel@tonic-gate #ifdef _LP64 38757c478bd9Sstevel@tonic-gate 38767c478bd9Sstevel@tonic-gate static void 38777c478bd9Sstevel@tonic-gate show_ksendfilevec32(private_t *pri, int fd, 38787c478bd9Sstevel@tonic-gate ksendfilevec32_t *sndvec, int sfvcnt) 38797c478bd9Sstevel@tonic-gate { 38807c478bd9Sstevel@tonic-gate ksendfilevec32_t *snd_ptr, snd[MAX_SNDFL_PRD]; 38817c478bd9Sstevel@tonic-gate size_t cpy_rqst; 38827c478bd9Sstevel@tonic-gate 38837c478bd9Sstevel@tonic-gate Eserialize(); 38847c478bd9Sstevel@tonic-gate while (sfvcnt > 0) { 38857c478bd9Sstevel@tonic-gate cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD); 38867c478bd9Sstevel@tonic-gate sfvcnt -= cpy_rqst; 38877c478bd9Sstevel@tonic-gate cpy_rqst *= sizeof (snd[0]); 38887c478bd9Sstevel@tonic-gate 38897c478bd9Sstevel@tonic-gate if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst) 38907c478bd9Sstevel@tonic-gate break; 38917c478bd9Sstevel@tonic-gate 38927c478bd9Sstevel@tonic-gate snd_ptr = &snd[0]; 38937c478bd9Sstevel@tonic-gate 38947c478bd9Sstevel@tonic-gate while (cpy_rqst) { 38957c478bd9Sstevel@tonic-gate (void) printf( 38967c478bd9Sstevel@tonic-gate "sfv_fd=%d\tsfv_flag=0x%x\t" 38977c478bd9Sstevel@tonic-gate "sfv_off=%d\tsfv_len=%u\n", 38987c478bd9Sstevel@tonic-gate snd_ptr->sfv_fd, 38997c478bd9Sstevel@tonic-gate snd_ptr->sfv_flag, 39007c478bd9Sstevel@tonic-gate snd_ptr->sfv_off, 39017c478bd9Sstevel@tonic-gate snd_ptr->sfv_len); 39027c478bd9Sstevel@tonic-gate 39037c478bd9Sstevel@tonic-gate if (snd_ptr->sfv_fd == SFV_FD_SELF && 39047c478bd9Sstevel@tonic-gate prismember(&writefd, fd)) { 39057c478bd9Sstevel@tonic-gate showbuffer(pri, 39067c478bd9Sstevel@tonic-gate (long)snd_ptr->sfv_off & 0xffffffff, 39077c478bd9Sstevel@tonic-gate (long)snd_ptr->sfv_len); 39087c478bd9Sstevel@tonic-gate } 39097c478bd9Sstevel@tonic-gate 39107c478bd9Sstevel@tonic-gate cpy_rqst -= sizeof (snd[0]); 39117c478bd9Sstevel@tonic-gate snd_ptr++; 39127c478bd9Sstevel@tonic-gate } 39137c478bd9Sstevel@tonic-gate 39147c478bd9Sstevel@tonic-gate sndvec += MAX_SNDFL_PRD; 39157c478bd9Sstevel@tonic-gate } 39167c478bd9Sstevel@tonic-gate Xserialize(); 39177c478bd9Sstevel@tonic-gate } 39187c478bd9Sstevel@tonic-gate 39197c478bd9Sstevel@tonic-gate static void 39207c478bd9Sstevel@tonic-gate show_ksendfilevec64(private_t *pri, int fd, 39217c478bd9Sstevel@tonic-gate ksendfilevec64_t *sndvec, int sfvcnt) 39227c478bd9Sstevel@tonic-gate { 39237c478bd9Sstevel@tonic-gate ksendfilevec64_t *snd_ptr, snd[MAX_SNDFL_PRD]; 39247c478bd9Sstevel@tonic-gate size_t cpy_rqst; 39257c478bd9Sstevel@tonic-gate 39267c478bd9Sstevel@tonic-gate Eserialize(); 39277c478bd9Sstevel@tonic-gate while (sfvcnt > 0) { 39287c478bd9Sstevel@tonic-gate cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD); 39297c478bd9Sstevel@tonic-gate sfvcnt -= cpy_rqst; 39307c478bd9Sstevel@tonic-gate cpy_rqst *= sizeof (snd[0]); 39317c478bd9Sstevel@tonic-gate 39327c478bd9Sstevel@tonic-gate if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst) 39337c478bd9Sstevel@tonic-gate break; 39347c478bd9Sstevel@tonic-gate 39357c478bd9Sstevel@tonic-gate snd_ptr = &snd[0]; 39367c478bd9Sstevel@tonic-gate 39377c478bd9Sstevel@tonic-gate while (cpy_rqst) { 39387c478bd9Sstevel@tonic-gate (void) printf( 39397c478bd9Sstevel@tonic-gate "sfv_fd=%d\tsfv_flag=0x%x\t" 39407c478bd9Sstevel@tonic-gate "sfv_off=%ld\tsfv_len=%u\n", 39417c478bd9Sstevel@tonic-gate snd_ptr->sfv_fd, 39427c478bd9Sstevel@tonic-gate snd_ptr->sfv_flag, 39437c478bd9Sstevel@tonic-gate snd_ptr->sfv_off, 39447c478bd9Sstevel@tonic-gate snd_ptr->sfv_len); 39457c478bd9Sstevel@tonic-gate 39467c478bd9Sstevel@tonic-gate if (snd_ptr->sfv_fd == SFV_FD_SELF && 39477c478bd9Sstevel@tonic-gate prismember(&writefd, fd)) { 39487c478bd9Sstevel@tonic-gate showbuffer(pri, 39497c478bd9Sstevel@tonic-gate (long)snd_ptr->sfv_off & 0xffffffff, 39507c478bd9Sstevel@tonic-gate (long)snd_ptr->sfv_len); 39517c478bd9Sstevel@tonic-gate } 39527c478bd9Sstevel@tonic-gate 39537c478bd9Sstevel@tonic-gate cpy_rqst -= sizeof (snd[0]); 39547c478bd9Sstevel@tonic-gate snd_ptr++; 39557c478bd9Sstevel@tonic-gate } 39567c478bd9Sstevel@tonic-gate 39577c478bd9Sstevel@tonic-gate sndvec += MAX_SNDFL_PRD; 39587c478bd9Sstevel@tonic-gate } 39597c478bd9Sstevel@tonic-gate Xserialize(); 39607c478bd9Sstevel@tonic-gate } 39617c478bd9Sstevel@tonic-gate 39627c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 39637c478bd9Sstevel@tonic-gate 39647c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 39657c478bd9Sstevel@tonic-gate static void 39667c478bd9Sstevel@tonic-gate show_sendfilevec(private_t *pri, int fd, sendfilevec_t *sndvec, int sfvcnt) 39677c478bd9Sstevel@tonic-gate { 39687c478bd9Sstevel@tonic-gate sendfilevec_t *snd_ptr, snd[MAX_SNDFL_PRD]; 39697c478bd9Sstevel@tonic-gate size_t cpy_rqst; 39707c478bd9Sstevel@tonic-gate 39717c478bd9Sstevel@tonic-gate #ifdef _LP64 39727c478bd9Sstevel@tonic-gate if (data_model != PR_MODEL_LP64) { 39737c478bd9Sstevel@tonic-gate show_ksendfilevec32(pri, fd, 39747c478bd9Sstevel@tonic-gate (ksendfilevec32_t *)sndvec, sfvcnt); 39757c478bd9Sstevel@tonic-gate return; 39767c478bd9Sstevel@tonic-gate } 39777c478bd9Sstevel@tonic-gate #endif 39787c478bd9Sstevel@tonic-gate Eserialize(); 39797c478bd9Sstevel@tonic-gate while (sfvcnt > 0) { 39807c478bd9Sstevel@tonic-gate cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD); 39817c478bd9Sstevel@tonic-gate sfvcnt -= cpy_rqst; 39827c478bd9Sstevel@tonic-gate cpy_rqst *= sizeof (snd[0]); 39837c478bd9Sstevel@tonic-gate 39847c478bd9Sstevel@tonic-gate if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst) 39857c478bd9Sstevel@tonic-gate break; 39867c478bd9Sstevel@tonic-gate 39877c478bd9Sstevel@tonic-gate snd_ptr = &snd[0]; 39887c478bd9Sstevel@tonic-gate 39897c478bd9Sstevel@tonic-gate while (cpy_rqst) { 39907c478bd9Sstevel@tonic-gate (void) printf( 39917c478bd9Sstevel@tonic-gate "sfv_fd=%d\tsfv_flag=0x%x\t" 39927c478bd9Sstevel@tonic-gate "sfv_off=%ld\tsfv_len=%lu\n", 39937c478bd9Sstevel@tonic-gate snd_ptr->sfv_fd, 39947c478bd9Sstevel@tonic-gate snd_ptr->sfv_flag, 39957c478bd9Sstevel@tonic-gate snd_ptr->sfv_off, 39967c478bd9Sstevel@tonic-gate (ulong_t)snd_ptr->sfv_len); 39977c478bd9Sstevel@tonic-gate 39987c478bd9Sstevel@tonic-gate if (snd_ptr->sfv_fd == SFV_FD_SELF && 39997c478bd9Sstevel@tonic-gate prismember(&writefd, fd)) { 40007c478bd9Sstevel@tonic-gate showbuffer(pri, (long)snd_ptr->sfv_off, 40017c478bd9Sstevel@tonic-gate (long)snd_ptr->sfv_len); 40027c478bd9Sstevel@tonic-gate } 40037c478bd9Sstevel@tonic-gate 40047c478bd9Sstevel@tonic-gate cpy_rqst -= sizeof (snd[0]); 40057c478bd9Sstevel@tonic-gate snd_ptr++; 40067c478bd9Sstevel@tonic-gate } 40077c478bd9Sstevel@tonic-gate 40087c478bd9Sstevel@tonic-gate sndvec += MAX_SNDFL_PRD; 40097c478bd9Sstevel@tonic-gate } 40107c478bd9Sstevel@tonic-gate Xserialize(); 40117c478bd9Sstevel@tonic-gate } 40127c478bd9Sstevel@tonic-gate 40137c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 40147c478bd9Sstevel@tonic-gate static void 40157c478bd9Sstevel@tonic-gate show_sendfilevec64(private_t *pri, int fd, sendfilevec64_t *sndvec, int sfvcnt) 40167c478bd9Sstevel@tonic-gate { 40177c478bd9Sstevel@tonic-gate sendfilevec64_t *snd_ptr, snd[MAX_SNDFL_PRD]; 40187c478bd9Sstevel@tonic-gate size_t cpy_rqst; 40197c478bd9Sstevel@tonic-gate 40207c478bd9Sstevel@tonic-gate #ifdef _LP64 40217c478bd9Sstevel@tonic-gate if (data_model != PR_MODEL_LP64) { 40227c478bd9Sstevel@tonic-gate show_ksendfilevec64(pri, fd, 40237c478bd9Sstevel@tonic-gate (ksendfilevec64_t *)sndvec, sfvcnt); 40247c478bd9Sstevel@tonic-gate return; 40257c478bd9Sstevel@tonic-gate } 40267c478bd9Sstevel@tonic-gate #endif 40277c478bd9Sstevel@tonic-gate 40287c478bd9Sstevel@tonic-gate Eserialize(); 40297c478bd9Sstevel@tonic-gate while (sfvcnt > 0) { 40307c478bd9Sstevel@tonic-gate cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD); 40317c478bd9Sstevel@tonic-gate sfvcnt -= cpy_rqst; 40327c478bd9Sstevel@tonic-gate cpy_rqst *= sizeof (snd[0]); 40337c478bd9Sstevel@tonic-gate 40347c478bd9Sstevel@tonic-gate if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst) 40357c478bd9Sstevel@tonic-gate break; 40367c478bd9Sstevel@tonic-gate 40377c478bd9Sstevel@tonic-gate snd_ptr = &snd[0]; 40387c478bd9Sstevel@tonic-gate 40397c478bd9Sstevel@tonic-gate while (cpy_rqst) { 40407c478bd9Sstevel@tonic-gate (void) printf( 40417c478bd9Sstevel@tonic-gate #ifdef _LP64 40427c478bd9Sstevel@tonic-gate "sfv_fd=%d\tsfv_flag=0x%x\t" 40437c478bd9Sstevel@tonic-gate "sfv_off=%ld\tsfv_len=%lu\n", 40447c478bd9Sstevel@tonic-gate #else 40457c478bd9Sstevel@tonic-gate "sfv_fd=%d\tsfv_flag=0x%x\t" 40467c478bd9Sstevel@tonic-gate "sfv_off=%lld\tsfv_len=%lu\n", 40477c478bd9Sstevel@tonic-gate #endif 40487c478bd9Sstevel@tonic-gate snd_ptr->sfv_fd, 40497c478bd9Sstevel@tonic-gate snd_ptr->sfv_flag, 40507c478bd9Sstevel@tonic-gate snd_ptr->sfv_off, 40517c478bd9Sstevel@tonic-gate (ulong_t)snd_ptr->sfv_len); 40527c478bd9Sstevel@tonic-gate 40537c478bd9Sstevel@tonic-gate if (snd_ptr->sfv_fd == SFV_FD_SELF && 40547c478bd9Sstevel@tonic-gate prismember(&writefd, fd)) { 40557c478bd9Sstevel@tonic-gate showbuffer(pri, (long)snd_ptr->sfv_off, 40567c478bd9Sstevel@tonic-gate (long)snd_ptr->sfv_len); 40577c478bd9Sstevel@tonic-gate } 40587c478bd9Sstevel@tonic-gate 40597c478bd9Sstevel@tonic-gate cpy_rqst -= sizeof (snd[0]); 40607c478bd9Sstevel@tonic-gate snd_ptr++; 40617c478bd9Sstevel@tonic-gate } 40627c478bd9Sstevel@tonic-gate 40637c478bd9Sstevel@tonic-gate sndvec += MAX_SNDFL_PRD; 40647c478bd9Sstevel@tonic-gate } 40657c478bd9Sstevel@tonic-gate Xserialize(); 40667c478bd9Sstevel@tonic-gate } 40677c478bd9Sstevel@tonic-gate 40687c478bd9Sstevel@tonic-gate static void 40697c478bd9Sstevel@tonic-gate show_memcntl_mha(private_t *pri, long offset) 40707c478bd9Sstevel@tonic-gate { 40717c478bd9Sstevel@tonic-gate struct memcntl_mha mha; 40727c478bd9Sstevel@tonic-gate const char *s = NULL; 40737c478bd9Sstevel@tonic-gate 40747c478bd9Sstevel@tonic-gate if (Pread(Proc, &mha, sizeof (mha), offset) == sizeof (mha)) { 40757c478bd9Sstevel@tonic-gate switch (mha.mha_cmd) { 40767c478bd9Sstevel@tonic-gate case MHA_MAPSIZE_VA: s = "MHA_MAPSIZE_VA"; break; 40777c478bd9Sstevel@tonic-gate case MHA_MAPSIZE_BSSBRK: s = "MHA_MAPSIZE_BSSBRK"; break; 40787c478bd9Sstevel@tonic-gate case MHA_MAPSIZE_STACK: s = "MHA_MAPSIZE_STACK"; break; 40797c478bd9Sstevel@tonic-gate } 40807c478bd9Sstevel@tonic-gate if (s) 40817c478bd9Sstevel@tonic-gate (void) printf("%s\tmha_cmd=%s mha_flags=0x%x" 40827c478bd9Sstevel@tonic-gate " mha_pagesize=%lu\n", 40837c478bd9Sstevel@tonic-gate pri->pname, s, mha.mha_flags, 40847c478bd9Sstevel@tonic-gate (ulong_t)mha.mha_pagesize); 40857c478bd9Sstevel@tonic-gate else 40867c478bd9Sstevel@tonic-gate (void) printf("%s\tmha_cmd=0x%.8x mha_flags=0x%x" 40877c478bd9Sstevel@tonic-gate " mha_pagesize=%lu\n", 40887c478bd9Sstevel@tonic-gate pri->pname, mha.mha_cmd, mha.mha_flags, 40897c478bd9Sstevel@tonic-gate (ulong_t)mha.mha_pagesize); 40907c478bd9Sstevel@tonic-gate } 40917c478bd9Sstevel@tonic-gate } 40927c478bd9Sstevel@tonic-gate 40937c478bd9Sstevel@tonic-gate #ifdef _LP64 40947c478bd9Sstevel@tonic-gate 40957c478bd9Sstevel@tonic-gate static void 40967c478bd9Sstevel@tonic-gate show_memcntl_mha32(private_t *pri, long offset) 40977c478bd9Sstevel@tonic-gate { 40987c478bd9Sstevel@tonic-gate struct memcntl_mha32 mha32; 40997c478bd9Sstevel@tonic-gate const char *s = NULL; 41007c478bd9Sstevel@tonic-gate 41017c478bd9Sstevel@tonic-gate if (Pread(Proc, &mha32, sizeof (mha32), offset) == 41027c478bd9Sstevel@tonic-gate sizeof (mha32)) { 41037c478bd9Sstevel@tonic-gate switch (mha32.mha_cmd) { 41047c478bd9Sstevel@tonic-gate case MHA_MAPSIZE_VA: s = "MHA_MAPSIZE_VA"; break; 41057c478bd9Sstevel@tonic-gate case MHA_MAPSIZE_BSSBRK: s = "MHA_MAPSIZE_BSSBRK"; break; 41067c478bd9Sstevel@tonic-gate case MHA_MAPSIZE_STACK: s = "MHA_MAPSIZE_STACK"; break; 41077c478bd9Sstevel@tonic-gate } 41087c478bd9Sstevel@tonic-gate if (s) 41097c478bd9Sstevel@tonic-gate (void) printf("%s\tmha_cmd=%s mha_flags=0x%x" 41107c478bd9Sstevel@tonic-gate " mha_pagesize=%u\n", 41117c478bd9Sstevel@tonic-gate pri->pname, s, mha32.mha_flags, mha32.mha_pagesize); 41127c478bd9Sstevel@tonic-gate else 41137c478bd9Sstevel@tonic-gate (void) printf("%s\tmha_cmd=0x%.8x mha_flags=0x%x" 41147c478bd9Sstevel@tonic-gate " mha_pagesize=%u\n", 41157c478bd9Sstevel@tonic-gate pri->pname, mha32.mha_cmd, mha32.mha_flags, 41167c478bd9Sstevel@tonic-gate mha32.mha_pagesize); 41177c478bd9Sstevel@tonic-gate } 41187c478bd9Sstevel@tonic-gate } 41197c478bd9Sstevel@tonic-gate 41207c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 41217c478bd9Sstevel@tonic-gate 41227c478bd9Sstevel@tonic-gate static void 41237c478bd9Sstevel@tonic-gate show_memcntl(private_t *pri) 41247c478bd9Sstevel@tonic-gate { 41257c478bd9Sstevel@tonic-gate 41267c478bd9Sstevel@tonic-gate if ((int)pri->sys_args[2] != MC_HAT_ADVISE) 41277c478bd9Sstevel@tonic-gate return; 41287c478bd9Sstevel@tonic-gate #ifdef _LP64 41297c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_LP64) 41307c478bd9Sstevel@tonic-gate show_memcntl_mha(pri, (long)pri->sys_args[3]); 41317c478bd9Sstevel@tonic-gate else 41327c478bd9Sstevel@tonic-gate show_memcntl_mha32(pri, (long)pri->sys_args[3]); 41337c478bd9Sstevel@tonic-gate #else 41347c478bd9Sstevel@tonic-gate show_memcntl_mha(pri, (long)pri->sys_args[3]); 41357c478bd9Sstevel@tonic-gate #endif 41367c478bd9Sstevel@tonic-gate } 41377c478bd9Sstevel@tonic-gate 41387c478bd9Sstevel@tonic-gate void 41397c478bd9Sstevel@tonic-gate show_ids(private_t *pri, long offset, int count) 41407c478bd9Sstevel@tonic-gate { 41417c478bd9Sstevel@tonic-gate id_t buf[MYBUFSIZ / sizeof (id_t)]; 41427c478bd9Sstevel@tonic-gate id_t *idp; 41437c478bd9Sstevel@tonic-gate int serial = (count > MYBUFSIZ / 48); 41447c478bd9Sstevel@tonic-gate 41457c478bd9Sstevel@tonic-gate if (offset == NULL) 41467c478bd9Sstevel@tonic-gate return; 41477c478bd9Sstevel@tonic-gate 41487c478bd9Sstevel@tonic-gate /* enter region of lengthy output */ 41497c478bd9Sstevel@tonic-gate if (serial) 41507c478bd9Sstevel@tonic-gate Eserialize(); 41517c478bd9Sstevel@tonic-gate 41527c478bd9Sstevel@tonic-gate while (count > 0 && !interrupt) { 41537c478bd9Sstevel@tonic-gate ssize_t nb = (count * sizeof (id_t) < MYBUFSIZ)? 41547c478bd9Sstevel@tonic-gate count * sizeof (id_t) : MYBUFSIZ; 41557c478bd9Sstevel@tonic-gate 41567c478bd9Sstevel@tonic-gate if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) < 0 || 41577c478bd9Sstevel@tonic-gate nb < sizeof (id_t)) 41587c478bd9Sstevel@tonic-gate break; 41597c478bd9Sstevel@tonic-gate 41607c478bd9Sstevel@tonic-gate idp = buf; 41617c478bd9Sstevel@tonic-gate while (!interrupt && nb >= sizeof (id_t)) { 41627c478bd9Sstevel@tonic-gate (void) printf("%s\t%8d\n", pri->pname, (int)*idp); 41637c478bd9Sstevel@tonic-gate offset += sizeof (id_t); 41647c478bd9Sstevel@tonic-gate nb -= sizeof (id_t); 41657c478bd9Sstevel@tonic-gate idp++; 41667c478bd9Sstevel@tonic-gate count--; 41677c478bd9Sstevel@tonic-gate } 41687c478bd9Sstevel@tonic-gate } 41697c478bd9Sstevel@tonic-gate 41707c478bd9Sstevel@tonic-gate /* exit region of lengthy output */ 41717c478bd9Sstevel@tonic-gate if (serial) 41727c478bd9Sstevel@tonic-gate Xserialize(); 41737c478bd9Sstevel@tonic-gate } 41747c478bd9Sstevel@tonic-gate 41757c478bd9Sstevel@tonic-gate void 41767c478bd9Sstevel@tonic-gate show_ntp_gettime(private_t *pri) 41777c478bd9Sstevel@tonic-gate { 41787c478bd9Sstevel@tonic-gate struct ntptimeval ntv; 41797c478bd9Sstevel@tonic-gate long offset; 41807c478bd9Sstevel@tonic-gate 41817c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL) 41827c478bd9Sstevel@tonic-gate return; 41837c478bd9Sstevel@tonic-gate 41847c478bd9Sstevel@tonic-gate if (data_model == PR_MODEL_NATIVE) { 41857c478bd9Sstevel@tonic-gate if (Pread(Proc, &ntv, sizeof (ntv), offset) 41867c478bd9Sstevel@tonic-gate != sizeof (ntv)) 41877c478bd9Sstevel@tonic-gate return; 41887c478bd9Sstevel@tonic-gate } else { 41897c478bd9Sstevel@tonic-gate struct ntptimeval32 ntv32; 41907c478bd9Sstevel@tonic-gate 41917c478bd9Sstevel@tonic-gate if (Pread(Proc, &ntv32, sizeof (ntv32), offset) 41927c478bd9Sstevel@tonic-gate != sizeof (ntv32)) 41937c478bd9Sstevel@tonic-gate return; 41947c478bd9Sstevel@tonic-gate 41957c478bd9Sstevel@tonic-gate TIMEVAL32_TO_TIMEVAL(&ntv.time, &ntv32.time); 41967c478bd9Sstevel@tonic-gate ntv.maxerror = ntv32.maxerror; 41977c478bd9Sstevel@tonic-gate ntv.esterror = ntv32.esterror; 41987c478bd9Sstevel@tonic-gate } 41997c478bd9Sstevel@tonic-gate 42007c478bd9Sstevel@tonic-gate (void) printf("\ttime: %ld.%6.6ld sec\n", 42017c478bd9Sstevel@tonic-gate ntv.time.tv_sec, ntv.time.tv_usec); 42027c478bd9Sstevel@tonic-gate (void) printf("\tmaxerror: %11d usec\n", ntv.maxerror); 42037c478bd9Sstevel@tonic-gate (void) printf("\testerror: %11d usec\n", ntv.esterror); 42047c478bd9Sstevel@tonic-gate } 42057c478bd9Sstevel@tonic-gate 42067c478bd9Sstevel@tonic-gate static char * 42077c478bd9Sstevel@tonic-gate get_timex_modes(private_t *pri, uint32_t val) 42087c478bd9Sstevel@tonic-gate { 42097c478bd9Sstevel@tonic-gate char *str = pri->code_buf; 42107c478bd9Sstevel@tonic-gate size_t used = 0; 42117c478bd9Sstevel@tonic-gate 42127c478bd9Sstevel@tonic-gate *str = '\0'; 42137c478bd9Sstevel@tonic-gate if (val & MOD_OFFSET) 42147c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_OFFSET", sizeof (pri->code_buf)); 42157c478bd9Sstevel@tonic-gate if (val & MOD_FREQUENCY) 42167c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_FREQUENCY", sizeof (pri->code_buf)); 42177c478bd9Sstevel@tonic-gate if (val & MOD_MAXERROR) 42187c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_MAXERROR", sizeof (pri->code_buf)); 42197c478bd9Sstevel@tonic-gate if (val & MOD_ESTERROR) 42207c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_ESTERROR", sizeof (pri->code_buf)); 42217c478bd9Sstevel@tonic-gate if (val & MOD_STATUS) 42227c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_STATUS", sizeof (pri->code_buf)); 42237c478bd9Sstevel@tonic-gate if (val & MOD_TIMECONST) 42247c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_TIMECONST", sizeof (pri->code_buf)); 42257c478bd9Sstevel@tonic-gate if (val & MOD_CLKB) 42267c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_CLKB", sizeof (pri->code_buf)); 42277c478bd9Sstevel@tonic-gate if (val & MOD_CLKA) 42287c478bd9Sstevel@tonic-gate used = strlcat(str, "|MOD_CLKA", sizeof (pri->code_buf)); 42297c478bd9Sstevel@tonic-gate 42307c478bd9Sstevel@tonic-gate if (used == 0 || used >= sizeof (pri->code_buf)) 42317c478bd9Sstevel@tonic-gate (void) snprintf(str, sizeof (pri->code_buf), " 0x%.4x", val); 42327c478bd9Sstevel@tonic-gate 42337c478bd9Sstevel@tonic-gate return (str + 1); 42347c478bd9Sstevel@tonic-gate } 42357c478bd9Sstevel@tonic-gate 42367c478bd9Sstevel@tonic-gate static char * 42377c478bd9Sstevel@tonic-gate get_timex_status(private_t *pri, int32_t val) 42387c478bd9Sstevel@tonic-gate { 42397c478bd9Sstevel@tonic-gate char *str = pri->code_buf; 42407c478bd9Sstevel@tonic-gate size_t used = 0; 42417c478bd9Sstevel@tonic-gate 42427c478bd9Sstevel@tonic-gate *str = '\0'; 42437c478bd9Sstevel@tonic-gate if (val & STA_PLL) 42447c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PLL", sizeof (pri->code_buf)); 42457c478bd9Sstevel@tonic-gate if (val & STA_PPSFREQ) 42467c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PPSFREQ", sizeof (pri->code_buf)); 42477c478bd9Sstevel@tonic-gate if (val & STA_PPSTIME) 42487c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PPSTIME", sizeof (pri->code_buf)); 42497c478bd9Sstevel@tonic-gate if (val & STA_FLL) 42507c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_FLL", sizeof (pri->code_buf)); 42517c478bd9Sstevel@tonic-gate 42527c478bd9Sstevel@tonic-gate if (val & STA_INS) 42537c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_INS", sizeof (pri->code_buf)); 42547c478bd9Sstevel@tonic-gate if (val & STA_DEL) 42557c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_DEL", sizeof (pri->code_buf)); 42567c478bd9Sstevel@tonic-gate if (val & STA_UNSYNC) 42577c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_UNSYNC", sizeof (pri->code_buf)); 42587c478bd9Sstevel@tonic-gate if (val & STA_FREQHOLD) 42597c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_FREQHOLD", sizeof (pri->code_buf)); 42607c478bd9Sstevel@tonic-gate 42617c478bd9Sstevel@tonic-gate if (val & STA_PPSSIGNAL) 42627c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PPSSIGNAL", sizeof (pri->code_buf)); 42637c478bd9Sstevel@tonic-gate if (val & STA_PPSJITTER) 42647c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PPSJITTER", sizeof (pri->code_buf)); 42657c478bd9Sstevel@tonic-gate if (val & STA_PPSWANDER) 42667c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PPSWANDER", sizeof (pri->code_buf)); 42677c478bd9Sstevel@tonic-gate if (val & STA_PPSERROR) 42687c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_PPSERROR", sizeof (pri->code_buf)); 42697c478bd9Sstevel@tonic-gate 42707c478bd9Sstevel@tonic-gate if (val & STA_CLOCKERR) 42717c478bd9Sstevel@tonic-gate used = strlcat(str, "|STA_CLOCKERR", sizeof (pri->code_buf)); 42727c478bd9Sstevel@tonic-gate 42737c478bd9Sstevel@tonic-gate if (used == 0 || used >= sizeof (pri->code_buf)) 42747c478bd9Sstevel@tonic-gate (void) snprintf(str, sizeof (pri->code_buf), " 0x%.4x", val); 42757c478bd9Sstevel@tonic-gate 42767c478bd9Sstevel@tonic-gate return (str + 1); 42777c478bd9Sstevel@tonic-gate } 42787c478bd9Sstevel@tonic-gate 42797c478bd9Sstevel@tonic-gate void 42807c478bd9Sstevel@tonic-gate show_ntp_adjtime(private_t *pri) 42817c478bd9Sstevel@tonic-gate { 42827c478bd9Sstevel@tonic-gate struct timex timex; 42837c478bd9Sstevel@tonic-gate long offset; 42847c478bd9Sstevel@tonic-gate 42857c478bd9Sstevel@tonic-gate if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL) 42867c478bd9Sstevel@tonic-gate return; 42877c478bd9Sstevel@tonic-gate 42887c478bd9Sstevel@tonic-gate if (Pread(Proc, &timex, sizeof (timex), offset) != sizeof (timex)) 42897c478bd9Sstevel@tonic-gate return; 42907c478bd9Sstevel@tonic-gate 42917c478bd9Sstevel@tonic-gate (void) printf("\tmodes: %s\n", get_timex_modes(pri, timex.modes)); 42927c478bd9Sstevel@tonic-gate (void) printf("\toffset: %11d usec\n", timex.offset); 42937c478bd9Sstevel@tonic-gate (void) printf("\tfreq: %11d scaled ppm\n", timex.freq); 42947c478bd9Sstevel@tonic-gate (void) printf("\tmaxerror: %11d usec\n", timex.maxerror); 42957c478bd9Sstevel@tonic-gate (void) printf("\testerror: %11d usec\n", timex.esterror); 42967c478bd9Sstevel@tonic-gate (void) printf("\tstatus: %s\n", get_timex_status(pri, timex.status)); 42977c478bd9Sstevel@tonic-gate (void) printf("\tconstant: %11d\n", timex.constant); 42987c478bd9Sstevel@tonic-gate (void) printf("\tprecision: %11d usec\n", timex.precision); 42997c478bd9Sstevel@tonic-gate (void) printf("\ttolerance: %11d scaled ppm\n", timex.tolerance); 43007c478bd9Sstevel@tonic-gate (void) printf("\tppsfreq: %11d scaled ppm\n", timex.ppsfreq); 43017c478bd9Sstevel@tonic-gate (void) printf("\tjitter: %11d usec\n", timex.jitter); 43027c478bd9Sstevel@tonic-gate (void) printf("\tshift: %11d sec\n", timex.shift); 43037c478bd9Sstevel@tonic-gate (void) printf("\tstabil: %11d scaled ppm\n", timex.stabil); 43047c478bd9Sstevel@tonic-gate (void) printf("\tjitcnt: %11d\n", timex.jitcnt); 43057c478bd9Sstevel@tonic-gate (void) printf("\tcalcnt: %11d\n", timex.calcnt); 43067c478bd9Sstevel@tonic-gate (void) printf("\terrcnt: %11d\n", timex.errcnt); 43077c478bd9Sstevel@tonic-gate (void) printf("\tstbcnt: %11d\n", timex.stbcnt); 43087c478bd9Sstevel@tonic-gate } 43097c478bd9Sstevel@tonic-gate 43107c478bd9Sstevel@tonic-gate void 43117c478bd9Sstevel@tonic-gate show_getrusage(long offset) 43127c478bd9Sstevel@tonic-gate { 43137c478bd9Sstevel@tonic-gate struct rusage r; 43147c478bd9Sstevel@tonic-gate if (Pread(Proc, &r, sizeof (r), offset) != sizeof (r)) 43157c478bd9Sstevel@tonic-gate return; 43167c478bd9Sstevel@tonic-gate (void) printf("\t user time: %ld.%6.6ld sec\n", 43177c478bd9Sstevel@tonic-gate r.ru_utime.tv_sec, 43187c478bd9Sstevel@tonic-gate r.ru_utime.tv_usec); 43197c478bd9Sstevel@tonic-gate (void) printf("\t system time: %ld.%6.6ld sec\n", 43207c478bd9Sstevel@tonic-gate r.ru_stime.tv_sec, 43217c478bd9Sstevel@tonic-gate r.ru_stime.tv_usec); 43227c478bd9Sstevel@tonic-gate (void) printf("\t max rss: <unimpl> %ld\n", 43237c478bd9Sstevel@tonic-gate r.ru_maxrss); 43247c478bd9Sstevel@tonic-gate (void) printf("\t shared data: <unimpl> %ld\n", 43257c478bd9Sstevel@tonic-gate r.ru_ixrss); 43267c478bd9Sstevel@tonic-gate (void) printf("\t unshared data: <unimpl> %ld\n", 43277c478bd9Sstevel@tonic-gate r.ru_idrss); 43287c478bd9Sstevel@tonic-gate (void) printf("\t unshared stack: <unimpl> %ld\n", 43297c478bd9Sstevel@tonic-gate r.ru_isrss); 43307c478bd9Sstevel@tonic-gate (void) printf("\t minor faults: %ld\n", 43317c478bd9Sstevel@tonic-gate r.ru_minflt); 43327c478bd9Sstevel@tonic-gate (void) printf("\t major faults: %ld\n", 43337c478bd9Sstevel@tonic-gate r.ru_majflt); 43347c478bd9Sstevel@tonic-gate (void) printf("\t # of swaps: %ld\n", 43357c478bd9Sstevel@tonic-gate r.ru_nswap); 43367c478bd9Sstevel@tonic-gate (void) printf("\t blocked inputs: %ld\n", 43377c478bd9Sstevel@tonic-gate r.ru_inblock); 43387c478bd9Sstevel@tonic-gate (void) printf("\t blocked outputs: %ld\n", 43397c478bd9Sstevel@tonic-gate r.ru_oublock); 43407c478bd9Sstevel@tonic-gate (void) printf("\t msgs sent: %ld\n", 43417c478bd9Sstevel@tonic-gate r.ru_msgsnd); 43427c478bd9Sstevel@tonic-gate (void) printf("\t msgs rcv'd: %ld\n", 43437c478bd9Sstevel@tonic-gate r.ru_msgrcv); 43447c478bd9Sstevel@tonic-gate (void) printf("\t signals rcv'd: %ld\n", 43457c478bd9Sstevel@tonic-gate r.ru_nsignals); 43467c478bd9Sstevel@tonic-gate (void) printf("\tvol cntxt swtchs: %ld\n", 43477c478bd9Sstevel@tonic-gate r.ru_nvcsw); 43487c478bd9Sstevel@tonic-gate (void) printf("\tinv cntxt swtchs: %ld\n", 43497c478bd9Sstevel@tonic-gate r.ru_nivcsw); 43507c478bd9Sstevel@tonic-gate } 43517c478bd9Sstevel@tonic-gate 43527c478bd9Sstevel@tonic-gate #ifdef _LP64 43537c478bd9Sstevel@tonic-gate void 43547c478bd9Sstevel@tonic-gate show_getrusage32(long offset) 43557c478bd9Sstevel@tonic-gate { 43567c478bd9Sstevel@tonic-gate struct rusage32 r; 43577c478bd9Sstevel@tonic-gate if (Pread(Proc, &r, sizeof (r), offset) != sizeof (r)) 43587c478bd9Sstevel@tonic-gate return; 43597c478bd9Sstevel@tonic-gate (void) printf("\t user time: %d.%6.6d sec\n", 43607c478bd9Sstevel@tonic-gate r.ru_utime.tv_sec, 43617c478bd9Sstevel@tonic-gate r.ru_utime.tv_usec); 43627c478bd9Sstevel@tonic-gate (void) printf("\t system time: %d.%6.6d sec\n", 43637c478bd9Sstevel@tonic-gate r.ru_stime.tv_sec, 43647c478bd9Sstevel@tonic-gate r.ru_stime.tv_usec); 43657c478bd9Sstevel@tonic-gate (void) printf("\t max rss: <unimpl> %d\n", 43667c478bd9Sstevel@tonic-gate r.ru_maxrss); 43677c478bd9Sstevel@tonic-gate (void) printf("\t shared data: <unimpl> %d\n", 43687c478bd9Sstevel@tonic-gate r.ru_ixrss); 43697c478bd9Sstevel@tonic-gate (void) printf("\t unshared data: <unimpl> %d\n", 43707c478bd9Sstevel@tonic-gate r.ru_idrss); 43717c478bd9Sstevel@tonic-gate (void) printf("\t unshared stack: <unimpl> %d\n", 43727c478bd9Sstevel@tonic-gate r.ru_isrss); 43737c478bd9Sstevel@tonic-gate (void) printf("\t minor faults: %d\n", 43747c478bd9Sstevel@tonic-gate r.ru_minflt); 43757c478bd9Sstevel@tonic-gate (void) printf("\t major faults: %d\n", 43767c478bd9Sstevel@tonic-gate r.ru_majflt); 43777c478bd9Sstevel@tonic-gate (void) printf("\t # of swaps: %d\n", 43787c478bd9Sstevel@tonic-gate r.ru_nswap); 43797c478bd9Sstevel@tonic-gate (void) printf("\t blocked inputs: %d\n", 43807c478bd9Sstevel@tonic-gate r.ru_inblock); 43817c478bd9Sstevel@tonic-gate (void) printf("\t blocked outputs: %d\n", 43827c478bd9Sstevel@tonic-gate r.ru_oublock); 43837c478bd9Sstevel@tonic-gate (void) printf("\t msgs sent: %d\n", 43847c478bd9Sstevel@tonic-gate r.ru_msgsnd); 43857c478bd9Sstevel@tonic-gate (void) printf("\t msgs rcv'd: %d\n", 43867c478bd9Sstevel@tonic-gate r.ru_msgrcv); 43877c478bd9Sstevel@tonic-gate (void) printf("\t signals rcv'd: %d\n", 43887c478bd9Sstevel@tonic-gate r.ru_nsignals); 43897c478bd9Sstevel@tonic-gate (void) printf("\tvol cntxt swtchs: %d\n", 43907c478bd9Sstevel@tonic-gate r.ru_nvcsw); 43917c478bd9Sstevel@tonic-gate (void) printf("\tinv cntxt swtchs: %d\n", 43927c478bd9Sstevel@tonic-gate r.ru_nivcsw); 43937c478bd9Sstevel@tonic-gate } 43947c478bd9Sstevel@tonic-gate #endif 43957c478bd9Sstevel@tonic-gate 4396821c4a97Sdp static void 4397821c4a97Sdp show_zone_create_args(private_t *pri, long offset) 4398821c4a97Sdp { 4399821c4a97Sdp zone_def args; 4400821c4a97Sdp char zone_name[ZONENAME_MAX]; 4401821c4a97Sdp char zone_root[MAXPATHLEN]; 4402821c4a97Sdp char *zone_zfs = NULL; 4403821c4a97Sdp 4404821c4a97Sdp if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) { 4405821c4a97Sdp 4406821c4a97Sdp if (Pread_string(Proc, zone_name, sizeof (zone_name), 4407821c4a97Sdp (uintptr_t)args.zone_name) == -1) 4408821c4a97Sdp (void) strcpy(zone_name, "<?>"); 4409821c4a97Sdp 4410821c4a97Sdp if (Pread_string(Proc, zone_root, sizeof (zone_root), 4411821c4a97Sdp (uintptr_t)args.zone_root) == -1) 4412821c4a97Sdp (void) strcpy(zone_root, "<?>"); 4413821c4a97Sdp 4414821c4a97Sdp if (args.zfsbufsz > 0) { 4415821c4a97Sdp zone_zfs = malloc(MIN(4, args.zfsbufsz)); 4416821c4a97Sdp if (zone_zfs != NULL) { 4417821c4a97Sdp if (Pread(Proc, zone_zfs, args.zfsbufsz, 4418821c4a97Sdp (uintptr_t)args.zfsbuf) == -1) 4419821c4a97Sdp (void) strcpy(zone_zfs, "<?>"); 4420821c4a97Sdp } 4421821c4a97Sdp } else { 4422821c4a97Sdp zone_zfs = ""; 4423821c4a97Sdp } 4424821c4a97Sdp 4425821c4a97Sdp (void) printf("%s\t zone_name: %s\n", pri->pname, 4426821c4a97Sdp zone_name); 4427821c4a97Sdp (void) printf("%s\t zone_root: %s\n", pri->pname, 4428821c4a97Sdp zone_root); 4429821c4a97Sdp 4430821c4a97Sdp show_privset(pri, (uintptr_t)args.zone_privs, 4431821c4a97Sdp args.zone_privssz, " zone_privs: "); 4432821c4a97Sdp 4433821c4a97Sdp (void) printf("%s\t rctlbuf: 0x%p\n", pri->pname, 4434821c4a97Sdp (void *)args.rctlbuf); 4435821c4a97Sdp (void) printf("%s\t rctlbufsz: %lu\n", pri->pname, 4436821c4a97Sdp (ulong_t)args.rctlbufsz); 4437821c4a97Sdp 4438821c4a97Sdp (void) printf("%s\t zfs: %s\n", pri->pname, zone_zfs); 4439821c4a97Sdp 4440821c4a97Sdp (void) printf("%s\textended_error: 0x%p\n", pri->pname, 4441821c4a97Sdp (void *)args.extended_error); 4442821c4a97Sdp 4443821c4a97Sdp if (args.zfsbufsz > 0) 4444821c4a97Sdp free(zone_zfs); 4445821c4a97Sdp } 4446821c4a97Sdp } 4447821c4a97Sdp 4448821c4a97Sdp 4449821c4a97Sdp #ifdef _LP64 4450821c4a97Sdp 4451821c4a97Sdp static void 4452821c4a97Sdp show_zone_create_args32(private_t *pri, long offset) 4453821c4a97Sdp { 4454821c4a97Sdp zone_def32 args; 4455821c4a97Sdp char zone_name[ZONENAME_MAX]; 4456821c4a97Sdp char zone_root[MAXPATHLEN]; 4457821c4a97Sdp char *zone_zfs = NULL; 4458821c4a97Sdp 4459821c4a97Sdp if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) { 4460821c4a97Sdp 4461821c4a97Sdp if (Pread_string(Proc, zone_name, sizeof (zone_name), 4462821c4a97Sdp (uintptr_t)args.zone_name) == -1) 4463821c4a97Sdp (void) strcpy(zone_name, "<?>"); 4464821c4a97Sdp 4465821c4a97Sdp if (Pread_string(Proc, zone_root, sizeof (zone_root), 4466821c4a97Sdp (uintptr_t)args.zone_root) == -1) 4467821c4a97Sdp (void) strcpy(zone_root, "<?>"); 4468821c4a97Sdp 4469821c4a97Sdp if (args.zfsbufsz > 0) { 4470821c4a97Sdp zone_zfs = malloc(MIN(4, args.zfsbufsz)); 4471821c4a97Sdp if (zone_zfs != NULL) { 4472821c4a97Sdp if (Pread(Proc, zone_zfs, args.zfsbufsz, 4473821c4a97Sdp (uintptr_t)args.zfsbuf) == -1) 4474821c4a97Sdp (void) strcpy(zone_zfs, "<?>"); 4475821c4a97Sdp } 4476821c4a97Sdp } else { 4477821c4a97Sdp zone_zfs = ""; 4478821c4a97Sdp } 4479821c4a97Sdp 4480821c4a97Sdp (void) printf("%s\t zone_name: %s\n", pri->pname, 4481821c4a97Sdp zone_name); 4482821c4a97Sdp (void) printf("%s\t zone_root: %s\n", pri->pname, 4483821c4a97Sdp zone_root); 4484821c4a97Sdp 4485821c4a97Sdp show_privset(pri, (uintptr_t)args.zone_privs, 4486821c4a97Sdp args.zone_privssz, " zone_privs: "); 4487821c4a97Sdp 44883246257cSdp (void) printf("%s\t rctlbuf: 0x%x\n", pri->pname, 44893246257cSdp (caddr32_t)args.rctlbuf); 4490821c4a97Sdp (void) printf("%s\t rctlbufsz: %lu\n", pri->pname, 4491821c4a97Sdp (ulong_t)args.rctlbufsz); 4492821c4a97Sdp 4493821c4a97Sdp (void) printf("%s\t zfs: %s\n", pri->pname, zone_zfs); 4494821c4a97Sdp 44953246257cSdp (void) printf("%s\textended_error: 0x%x\n", pri->pname, 44963246257cSdp (caddr32_t)args.extended_error); 4497821c4a97Sdp 4498821c4a97Sdp if (args.zfsbufsz > 0) 4499821c4a97Sdp free(zone_zfs); 4500821c4a97Sdp } 4501821c4a97Sdp } 4502821c4a97Sdp 4503821c4a97Sdp #endif 4504821c4a97Sdp 4505821c4a97Sdp static void 4506821c4a97Sdp show_zones(private_t *pri) 4507821c4a97Sdp { 4508821c4a97Sdp switch (pri->sys_args[0]) { 4509821c4a97Sdp case ZONE_CREATE: 4510821c4a97Sdp #ifdef _LP64 4511821c4a97Sdp if (data_model == PR_MODEL_LP64) 4512821c4a97Sdp show_zone_create_args(pri, (long)pri->sys_args[1]); 4513821c4a97Sdp else 4514821c4a97Sdp show_zone_create_args32(pri, (long)pri->sys_args[1]); 4515821c4a97Sdp #else 4516821c4a97Sdp show_zone_create_args(pri, (long)pri->sys_args[1]); 4517821c4a97Sdp #endif 4518821c4a97Sdp break; 4519821c4a97Sdp } 4520821c4a97Sdp } 4521821c4a97Sdp 4522821c4a97Sdp 45237c478bd9Sstevel@tonic-gate /* expound verbosely upon syscall arguments */ 45247c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 45257c478bd9Sstevel@tonic-gate void 45267c478bd9Sstevel@tonic-gate expound(private_t *pri, long r0, int raw) 45277c478bd9Sstevel@tonic-gate { 45287c478bd9Sstevel@tonic-gate const lwpstatus_t *Lsp = pri->lwpstat; 45297c478bd9Sstevel@tonic-gate int lp64 = (data_model == PR_MODEL_LP64); 45307c478bd9Sstevel@tonic-gate int what = Lsp->pr_what; 45317c478bd9Sstevel@tonic-gate int err = pri->Errno; /* don't display output parameters */ 45327c478bd9Sstevel@tonic-gate /* for a failed system call */ 45337c478bd9Sstevel@tonic-gate #ifndef _LP64 45347c478bd9Sstevel@tonic-gate /* We are a 32-bit truss; we can't grok a 64-bit process */ 45357c478bd9Sstevel@tonic-gate if (lp64) 45367c478bd9Sstevel@tonic-gate return; 45377c478bd9Sstevel@tonic-gate #endif 45387c478bd9Sstevel@tonic-gate /* for reporting sleeping system calls */ 45397c478bd9Sstevel@tonic-gate if (what == 0 && (Lsp->pr_flags & (PR_ASLEEP|PR_VFORKP))) 45407c478bd9Sstevel@tonic-gate what = Lsp->pr_syscall; 45417c478bd9Sstevel@tonic-gate 45427c478bd9Sstevel@tonic-gate switch (what) { 45437c478bd9Sstevel@tonic-gate case SYS_utime: 45447c478bd9Sstevel@tonic-gate show_utime(pri); 45457c478bd9Sstevel@tonic-gate break; 45467c478bd9Sstevel@tonic-gate case SYS_utimes: 45477c478bd9Sstevel@tonic-gate show_utimes(pri); 45487c478bd9Sstevel@tonic-gate break; 45497c478bd9Sstevel@tonic-gate case SYS_gettimeofday: 45507c478bd9Sstevel@tonic-gate if (!err) 45517c478bd9Sstevel@tonic-gate show_timeofday(pri); 45527c478bd9Sstevel@tonic-gate break; 45537c478bd9Sstevel@tonic-gate case SYS_getitimer: 45547c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1) 45557c478bd9Sstevel@tonic-gate show_itimerval(pri, (long)pri->sys_args[1], 45567c478bd9Sstevel@tonic-gate " value"); 45577c478bd9Sstevel@tonic-gate break; 45587c478bd9Sstevel@tonic-gate case SYS_setitimer: 45597c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 45607c478bd9Sstevel@tonic-gate show_itimerval(pri, (long)pri->sys_args[1], 45617c478bd9Sstevel@tonic-gate " value"); 45627c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 45637c478bd9Sstevel@tonic-gate show_itimerval(pri, (long)pri->sys_args[2], 45647c478bd9Sstevel@tonic-gate "ovalue"); 45657c478bd9Sstevel@tonic-gate break; 45667c478bd9Sstevel@tonic-gate case SYS_stime: 45677c478bd9Sstevel@tonic-gate show_stime(pri); 45687c478bd9Sstevel@tonic-gate break; 45697c478bd9Sstevel@tonic-gate case SYS_times: 45707c478bd9Sstevel@tonic-gate if (!err) 45717c478bd9Sstevel@tonic-gate show_times(pri); 45727c478bd9Sstevel@tonic-gate break; 45737c478bd9Sstevel@tonic-gate case SYS_utssys: 45747c478bd9Sstevel@tonic-gate if (err) 45757c478bd9Sstevel@tonic-gate break; 45767c478bd9Sstevel@tonic-gate #ifdef _LP64 45777c478bd9Sstevel@tonic-gate if (lp64) 45787c478bd9Sstevel@tonic-gate show_utssys(pri, r0); 45797c478bd9Sstevel@tonic-gate else 45807c478bd9Sstevel@tonic-gate show_utssys32(pri, r0); 45817c478bd9Sstevel@tonic-gate #else 45827c478bd9Sstevel@tonic-gate show_utssys(pri, r0); 45837c478bd9Sstevel@tonic-gate #endif 45847c478bd9Sstevel@tonic-gate break; 45857c478bd9Sstevel@tonic-gate case SYS_ioctl: 45867c478bd9Sstevel@tonic-gate if (pri->sys_nargs >= 3) /* each case must decide for itself */ 45877c478bd9Sstevel@tonic-gate show_ioctl(pri, pri->sys_args[1], 45887c478bd9Sstevel@tonic-gate (long)pri->sys_args[2]); 45897c478bd9Sstevel@tonic-gate break; 45907c478bd9Sstevel@tonic-gate case SYS_stat: 45917c478bd9Sstevel@tonic-gate case SYS_fstat: 45927c478bd9Sstevel@tonic-gate case SYS_lstat: 45937c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs >= 2) 45947c478bd9Sstevel@tonic-gate show_stat(pri, (long)pri->sys_args[1]); 45957c478bd9Sstevel@tonic-gate break; 45967c478bd9Sstevel@tonic-gate case SYS_stat64: 45977c478bd9Sstevel@tonic-gate case SYS_fstat64: 45987c478bd9Sstevel@tonic-gate case SYS_lstat64: 45997c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs >= 2) 46007c478bd9Sstevel@tonic-gate show_stat64_32(pri, (long)pri->sys_args[1]); 46017c478bd9Sstevel@tonic-gate break; 46027c478bd9Sstevel@tonic-gate case SYS_fsat: 46037c478bd9Sstevel@tonic-gate /* 46047c478bd9Sstevel@tonic-gate * subcodes for fstatat() and fstatat64(). 46057c478bd9Sstevel@tonic-gate */ 46067c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs >= 4) { 46077c478bd9Sstevel@tonic-gate if (pri->sys_args[0] == 3) 46087c478bd9Sstevel@tonic-gate show_statat(pri, (long)pri->sys_args[3]); 46097c478bd9Sstevel@tonic-gate else if (pri->sys_args[0] == 2) 46107c478bd9Sstevel@tonic-gate show_stat64_32(pri, (long)pri->sys_args[3]); 46117c478bd9Sstevel@tonic-gate } 46127c478bd9Sstevel@tonic-gate break; 46137c478bd9Sstevel@tonic-gate case SYS_xstat: 46147c478bd9Sstevel@tonic-gate case SYS_fxstat: 46157c478bd9Sstevel@tonic-gate case SYS_lxstat: 46167c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs >= 3) 46177c478bd9Sstevel@tonic-gate show_xstat(pri, (int)pri->sys_args[0], 46187c478bd9Sstevel@tonic-gate (long)pri->sys_args[2]); 46197c478bd9Sstevel@tonic-gate break; 46207c478bd9Sstevel@tonic-gate case SYS_statvfs: 46217c478bd9Sstevel@tonic-gate case SYS_fstatvfs: 46227c478bd9Sstevel@tonic-gate if (err) 46237c478bd9Sstevel@tonic-gate break; 46247c478bd9Sstevel@tonic-gate #ifdef _LP64 46257c478bd9Sstevel@tonic-gate if (!lp64) { 46267c478bd9Sstevel@tonic-gate show_statvfs32(pri); 46277c478bd9Sstevel@tonic-gate break; 46287c478bd9Sstevel@tonic-gate } 46297c478bd9Sstevel@tonic-gate #endif 46307c478bd9Sstevel@tonic-gate show_statvfs(pri); 46317c478bd9Sstevel@tonic-gate break; 46327c478bd9Sstevel@tonic-gate case SYS_statvfs64: 46337c478bd9Sstevel@tonic-gate case SYS_fstatvfs64: 46347c478bd9Sstevel@tonic-gate if (err) 46357c478bd9Sstevel@tonic-gate break; 46367c478bd9Sstevel@tonic-gate show_statvfs64(pri); 46377c478bd9Sstevel@tonic-gate break; 46387c478bd9Sstevel@tonic-gate case SYS_statfs: 46397c478bd9Sstevel@tonic-gate case SYS_fstatfs: 46407c478bd9Sstevel@tonic-gate if (err) 46417c478bd9Sstevel@tonic-gate break; 46427c478bd9Sstevel@tonic-gate #ifdef _LP64 46437c478bd9Sstevel@tonic-gate if (lp64) 46447c478bd9Sstevel@tonic-gate show_statfs(pri); 46457c478bd9Sstevel@tonic-gate else 46467c478bd9Sstevel@tonic-gate show_statfs32(pri); 46477c478bd9Sstevel@tonic-gate #else 46487c478bd9Sstevel@tonic-gate show_statfs(pri); 46497c478bd9Sstevel@tonic-gate #endif 46507c478bd9Sstevel@tonic-gate break; 46517c478bd9Sstevel@tonic-gate case SYS_fcntl: 46527c478bd9Sstevel@tonic-gate show_fcntl(pri); 46537c478bd9Sstevel@tonic-gate break; 46547c478bd9Sstevel@tonic-gate case SYS_msgsys: 46557c478bd9Sstevel@tonic-gate show_msgsys(pri, r0); /* each case must decide for itself */ 46567c478bd9Sstevel@tonic-gate break; 46577c478bd9Sstevel@tonic-gate case SYS_semsys: 46587c478bd9Sstevel@tonic-gate show_semsys(pri); /* each case must decide for itself */ 46597c478bd9Sstevel@tonic-gate break; 46607c478bd9Sstevel@tonic-gate case SYS_shmsys: 46617c478bd9Sstevel@tonic-gate show_shmsys(pri); /* each case must decide for itself */ 46627c478bd9Sstevel@tonic-gate break; 46637c478bd9Sstevel@tonic-gate case SYS_getdents: 46647c478bd9Sstevel@tonic-gate if (err || pri->sys_nargs <= 1 || r0 <= 0) 46657c478bd9Sstevel@tonic-gate break; 46667c478bd9Sstevel@tonic-gate #ifdef _LP64 46677c478bd9Sstevel@tonic-gate if (!lp64) { 46687c478bd9Sstevel@tonic-gate show_dents32(pri, (long)pri->sys_args[1], r0); 46697c478bd9Sstevel@tonic-gate break; 46707c478bd9Sstevel@tonic-gate } 46717c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 46727c478bd9Sstevel@tonic-gate #else 46737c478bd9Sstevel@tonic-gate show_dents32(pri, (long)pri->sys_args[1], r0); 46747c478bd9Sstevel@tonic-gate break; 46757c478bd9Sstevel@tonic-gate #endif 46767c478bd9Sstevel@tonic-gate case SYS_getdents64: 46777c478bd9Sstevel@tonic-gate if (err || pri->sys_nargs <= 1 || r0 <= 0) 46787c478bd9Sstevel@tonic-gate break; 46797c478bd9Sstevel@tonic-gate show_dents64(pri, (long)pri->sys_args[1], r0); 46807c478bd9Sstevel@tonic-gate break; 46817c478bd9Sstevel@tonic-gate case SYS_getmsg: 46827c478bd9Sstevel@tonic-gate show_gp_msg(pri, what); 46837c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) 46847c478bd9Sstevel@tonic-gate show_hhex_int(pri, (long)pri->sys_args[3], "flags"); 46857c478bd9Sstevel@tonic-gate break; 46867c478bd9Sstevel@tonic-gate case SYS_getpmsg: 46877c478bd9Sstevel@tonic-gate show_gp_msg(pri, what); 46887c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 3) 46897c478bd9Sstevel@tonic-gate show_hhex_int(pri, (long)pri->sys_args[3], "band"); 46907c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 4) 46917c478bd9Sstevel@tonic-gate show_hhex_int(pri, (long)pri->sys_args[4], "flags"); 46927c478bd9Sstevel@tonic-gate break; 46937c478bd9Sstevel@tonic-gate case SYS_putmsg: 46947c478bd9Sstevel@tonic-gate case SYS_putpmsg: 46957c478bd9Sstevel@tonic-gate show_gp_msg(pri, what); 46967c478bd9Sstevel@tonic-gate break; 46977c478bd9Sstevel@tonic-gate case SYS_poll: 46987c478bd9Sstevel@tonic-gate show_poll(pri); 46997c478bd9Sstevel@tonic-gate break; 47007c478bd9Sstevel@tonic-gate case SYS_pollsys: 47017c478bd9Sstevel@tonic-gate show_pollsys(pri); 47027c478bd9Sstevel@tonic-gate break; 47037c478bd9Sstevel@tonic-gate case SYS_setgroups: 47047c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1 && (r0 = pri->sys_args[0]) > 0) 47057c478bd9Sstevel@tonic-gate show_groups(pri, (long)pri->sys_args[1], r0); 47067c478bd9Sstevel@tonic-gate break; 47077c478bd9Sstevel@tonic-gate case SYS_getgroups: 47087c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1 && pri->sys_args[0] > 0) 47097c478bd9Sstevel@tonic-gate show_groups(pri, (long)pri->sys_args[1], r0); 47107c478bd9Sstevel@tonic-gate break; 47117c478bd9Sstevel@tonic-gate case SYS_sigprocmask: 47127c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 47137c478bd9Sstevel@tonic-gate show_sigset(pri, (long)pri->sys_args[1], " set"); 47147c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 47157c478bd9Sstevel@tonic-gate show_sigset(pri, (long)pri->sys_args[2], "oset"); 47167c478bd9Sstevel@tonic-gate break; 47177c478bd9Sstevel@tonic-gate case SYS_sigsuspend: 47187c478bd9Sstevel@tonic-gate case SYS_sigtimedwait: 47197c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 47207c478bd9Sstevel@tonic-gate show_sigset(pri, (long)pri->sys_args[0], "sigmask"); 47217c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1) 47227c478bd9Sstevel@tonic-gate show_siginfo(pri, (long)pri->sys_args[1]); 47237c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2) 47247c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[2], "timeout"); 47257c478bd9Sstevel@tonic-gate break; 47267c478bd9Sstevel@tonic-gate case SYS_sigaltstack: 47277c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 47287c478bd9Sstevel@tonic-gate show_sigaltstack(pri, (long)pri->sys_args[0], 47297c478bd9Sstevel@tonic-gate "new"); 47307c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1) 47317c478bd9Sstevel@tonic-gate show_sigaltstack(pri, (long)pri->sys_args[1], 47327c478bd9Sstevel@tonic-gate "old"); 47337c478bd9Sstevel@tonic-gate break; 47347c478bd9Sstevel@tonic-gate case SYS_sigaction: 47357c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 47367c478bd9Sstevel@tonic-gate show_sigaction(pri, (long)pri->sys_args[1], 47377c478bd9Sstevel@tonic-gate "new", NULL); 47387c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 47397c478bd9Sstevel@tonic-gate show_sigaction(pri, (long)pri->sys_args[2], 47407c478bd9Sstevel@tonic-gate "old", r0); 47417c478bd9Sstevel@tonic-gate break; 47427c478bd9Sstevel@tonic-gate case SYS_sigpending: 47437c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1) 47447c478bd9Sstevel@tonic-gate show_sigset(pri, (long)pri->sys_args[1], "sigmask"); 47457c478bd9Sstevel@tonic-gate break; 47467c478bd9Sstevel@tonic-gate case SYS_waitsys: 47477c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 47487c478bd9Sstevel@tonic-gate show_siginfo(pri, (long)pri->sys_args[2]); 47497c478bd9Sstevel@tonic-gate break; 47507c478bd9Sstevel@tonic-gate case SYS_sigsendsys: 47517c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 47527c478bd9Sstevel@tonic-gate show_procset(pri, (long)pri->sys_args[0]); 47537c478bd9Sstevel@tonic-gate break; 47547c478bd9Sstevel@tonic-gate case SYS_priocntlsys: 47557c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 47567c478bd9Sstevel@tonic-gate show_procset(pri, (long)pri->sys_args[1]); 47577c478bd9Sstevel@tonic-gate break; 47587c478bd9Sstevel@tonic-gate case SYS_mincore: 47597c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 47607c478bd9Sstevel@tonic-gate show_bool(pri, (long)pri->sys_args[2], 47617c478bd9Sstevel@tonic-gate (pri->sys_args[1] + pagesize - 1) / pagesize); 47627c478bd9Sstevel@tonic-gate break; 47637c478bd9Sstevel@tonic-gate case SYS_readv: 47647c478bd9Sstevel@tonic-gate case SYS_writev: 47657c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2) { 47667c478bd9Sstevel@tonic-gate int i = pri->sys_args[0]+1; 47677c478bd9Sstevel@tonic-gate int showbuf = FALSE; 47687c478bd9Sstevel@tonic-gate long nb = (what == SYS_readv)? r0 : 32*1024; 47697c478bd9Sstevel@tonic-gate 47707c478bd9Sstevel@tonic-gate if ((what == SYS_readv && !err && 47717c478bd9Sstevel@tonic-gate prismember(&readfd, i)) || 47727c478bd9Sstevel@tonic-gate (what == SYS_writev && 47737c478bd9Sstevel@tonic-gate prismember(&writefd, i))) 47747c478bd9Sstevel@tonic-gate showbuf = TRUE; 47757c478bd9Sstevel@tonic-gate show_iovec(pri, (long)pri->sys_args[1], 47767c478bd9Sstevel@tonic-gate pri->sys_args[2], showbuf, nb); 47777c478bd9Sstevel@tonic-gate } 47787c478bd9Sstevel@tonic-gate break; 47797c478bd9Sstevel@tonic-gate case SYS_getrlimit: 47807c478bd9Sstevel@tonic-gate if (err) 47817c478bd9Sstevel@tonic-gate break; 47827c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 47837c478bd9Sstevel@tonic-gate case SYS_setrlimit: 47847c478bd9Sstevel@tonic-gate if (pri->sys_nargs <= 1) 47857c478bd9Sstevel@tonic-gate break; 47867c478bd9Sstevel@tonic-gate #ifdef _LP64 47877c478bd9Sstevel@tonic-gate if (lp64) 47887c478bd9Sstevel@tonic-gate show_rlimit64(pri, (long)pri->sys_args[1]); 47897c478bd9Sstevel@tonic-gate else 47907c478bd9Sstevel@tonic-gate show_rlimit32(pri, (long)pri->sys_args[1]); 47917c478bd9Sstevel@tonic-gate #else 47927c478bd9Sstevel@tonic-gate show_rlimit32(pri, (long)pri->sys_args[1]); 47937c478bd9Sstevel@tonic-gate #endif 47947c478bd9Sstevel@tonic-gate break; 47957c478bd9Sstevel@tonic-gate case SYS_getrlimit64: 47967c478bd9Sstevel@tonic-gate if (err) 47977c478bd9Sstevel@tonic-gate break; 47987c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 47997c478bd9Sstevel@tonic-gate case SYS_setrlimit64: 48007c478bd9Sstevel@tonic-gate if (pri->sys_nargs <= 1) 48017c478bd9Sstevel@tonic-gate break; 48027c478bd9Sstevel@tonic-gate show_rlimit64(pri, (long)pri->sys_args[1]); 48037c478bd9Sstevel@tonic-gate break; 48047c478bd9Sstevel@tonic-gate case SYS_uname: 48057c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 0) 48067c478bd9Sstevel@tonic-gate show_nuname(pri, (long)pri->sys_args[0]); 48077c478bd9Sstevel@tonic-gate break; 48087c478bd9Sstevel@tonic-gate case SYS_adjtime: 48097c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1) 48107c478bd9Sstevel@tonic-gate show_adjtime(pri, (long)pri->sys_args[0], 48117c478bd9Sstevel@tonic-gate (long)pri->sys_args[1]); 48127c478bd9Sstevel@tonic-gate break; 48137c478bd9Sstevel@tonic-gate case SYS_lwp_info: 48147c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 0) 48157c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[0], "cpu time"); 48167c478bd9Sstevel@tonic-gate break; 48177c478bd9Sstevel@tonic-gate case SYS_lwp_wait: 48187c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 1) 48197c478bd9Sstevel@tonic-gate show_int(pri, (long)pri->sys_args[1], "lwpid"); 48207c478bd9Sstevel@tonic-gate break; 48217c478bd9Sstevel@tonic-gate case SYS_lwp_mutex_wakeup: 48227c478bd9Sstevel@tonic-gate case SYS_lwp_mutex_lock: 48237c478bd9Sstevel@tonic-gate case SYS_lwp_mutex_unlock: 48247c478bd9Sstevel@tonic-gate case SYS_lwp_mutex_trylock: 48257c478bd9Sstevel@tonic-gate case SYS_lwp_mutex_init: 48267c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48277c478bd9Sstevel@tonic-gate show_mutex(pri, (long)pri->sys_args[0]); 48287c478bd9Sstevel@tonic-gate break; 48297c478bd9Sstevel@tonic-gate case SYS_lwp_mutex_timedlock: 48307c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48317c478bd9Sstevel@tonic-gate show_mutex(pri, (long)pri->sys_args[0]); 48327c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 48337c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[1], "timeout"); 48347c478bd9Sstevel@tonic-gate break; 48357c478bd9Sstevel@tonic-gate case SYS_lwp_cond_wait: 48367c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48377c478bd9Sstevel@tonic-gate show_condvar(pri, (long)pri->sys_args[0]); 48387c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 48397c478bd9Sstevel@tonic-gate show_mutex(pri, (long)pri->sys_args[1]); 48407c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2) 48417c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[2], "timeout"); 48427c478bd9Sstevel@tonic-gate break; 48437c478bd9Sstevel@tonic-gate case SYS_lwp_cond_signal: 48447c478bd9Sstevel@tonic-gate case SYS_lwp_cond_broadcast: 48457c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48467c478bd9Sstevel@tonic-gate show_condvar(pri, (long)pri->sys_args[0]); 48477c478bd9Sstevel@tonic-gate break; 48487c478bd9Sstevel@tonic-gate case SYS_lwp_sema_wait: 48497c478bd9Sstevel@tonic-gate case SYS_lwp_sema_trywait: 48507c478bd9Sstevel@tonic-gate case SYS_lwp_sema_post: 48517c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48527c478bd9Sstevel@tonic-gate show_sema(pri, (long)pri->sys_args[0]); 48537c478bd9Sstevel@tonic-gate break; 48547c478bd9Sstevel@tonic-gate case SYS_lwp_sema_timedwait: 48557c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48567c478bd9Sstevel@tonic-gate show_sema(pri, (long)pri->sys_args[0]); 48577c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 48587c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[1], "timeout"); 48597c478bd9Sstevel@tonic-gate break; 48607c478bd9Sstevel@tonic-gate case SYS_lwp_rwlock_sys: 48617c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1) 48627c478bd9Sstevel@tonic-gate show_rwlock(pri, (long)pri->sys_args[1]); 48637c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2 && 48647c478bd9Sstevel@tonic-gate (pri->sys_args[0] == 0 || pri->sys_args[0] == 1)) 48657c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[2], "timeout"); 48667c478bd9Sstevel@tonic-gate break; 48677c478bd9Sstevel@tonic-gate case SYS_lwp_create: 48687c478bd9Sstevel@tonic-gate /* XXX print some values in ucontext ??? */ 48697c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 48707c478bd9Sstevel@tonic-gate show_int(pri, (long)pri->sys_args[2], "lwpid"); 48717c478bd9Sstevel@tonic-gate break; 48727c478bd9Sstevel@tonic-gate case SYS_kaio: 48737c478bd9Sstevel@tonic-gate if (pri->sys_args[0] == AIOWAIT && !err && pri->sys_nargs > 1) 48747c478bd9Sstevel@tonic-gate show_timeval(pri, (long)pri->sys_args[1], "timeout"); 48757c478bd9Sstevel@tonic-gate break; 48767c478bd9Sstevel@tonic-gate case SYS_nanosleep: 48777c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 0) 48787c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[0], "tmout"); 48797c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1 && (err == 0 || err == EINTR)) 48807c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[1], "resid"); 48817c478bd9Sstevel@tonic-gate break; 48827c478bd9Sstevel@tonic-gate case SYS_privsys: 48837c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 48847c478bd9Sstevel@tonic-gate case PRIVSYS_SETPPRIV: 48857c478bd9Sstevel@tonic-gate case PRIVSYS_GETPPRIV: 48867c478bd9Sstevel@tonic-gate if (!err) 48877c478bd9Sstevel@tonic-gate show_privset(pri, (long)pri->sys_args[3], 4888821c4a97Sdp (size_t)pri->sys_args[4], ""); 48897c478bd9Sstevel@tonic-gate } 48907c478bd9Sstevel@tonic-gate break; 48917c478bd9Sstevel@tonic-gate case SYS_ucredsys: 48927c478bd9Sstevel@tonic-gate switch (pri->sys_args[0]) { 48937c478bd9Sstevel@tonic-gate case UCREDSYS_UCREDGET: 48947c478bd9Sstevel@tonic-gate case UCREDSYS_GETPEERUCRED: 48957c478bd9Sstevel@tonic-gate if (err == 0) 48967c478bd9Sstevel@tonic-gate show_ucred(pri, (long)pri->sys_args[2]); 48977c478bd9Sstevel@tonic-gate break; 48987c478bd9Sstevel@tonic-gate } 48997c478bd9Sstevel@tonic-gate break; 49007c478bd9Sstevel@tonic-gate case SYS_bind: 49017c478bd9Sstevel@tonic-gate case SYS_connect: 49027c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2) 49037c478bd9Sstevel@tonic-gate show_sockaddr(pri, "name", (long)pri->sys_args[1], 49047c478bd9Sstevel@tonic-gate 0, (long)pri->sys_args[2]); 49057c478bd9Sstevel@tonic-gate break; 49067c478bd9Sstevel@tonic-gate case SYS_sendto: 49077c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 5) 49087c478bd9Sstevel@tonic-gate show_sockaddr(pri, "to", (long)pri->sys_args[4], 0, 49097c478bd9Sstevel@tonic-gate pri->sys_args[5]); 49107c478bd9Sstevel@tonic-gate break; 49117c478bd9Sstevel@tonic-gate case SYS_accept: 49127c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 49137c478bd9Sstevel@tonic-gate show_sockaddr(pri, "name", (long)pri->sys_args[1], 49147c478bd9Sstevel@tonic-gate (long)pri->sys_args[2], 0); 49157c478bd9Sstevel@tonic-gate break; 49167c478bd9Sstevel@tonic-gate case SYS_getsockname: 49177c478bd9Sstevel@tonic-gate case SYS_getpeername: 49187c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 49197c478bd9Sstevel@tonic-gate show_sockaddr(pri, "name", (long)pri->sys_args[1], 49207c478bd9Sstevel@tonic-gate (long)pri->sys_args[2], 0); 49217c478bd9Sstevel@tonic-gate break; 49227c478bd9Sstevel@tonic-gate case SYS_cladm: 49237c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 2) 49247c478bd9Sstevel@tonic-gate show_cladm(pri, pri->sys_args[0], pri->sys_args[1], 49257c478bd9Sstevel@tonic-gate (long)pri->sys_args[2]); 49267c478bd9Sstevel@tonic-gate break; 49277c478bd9Sstevel@tonic-gate case SYS_recvfrom: 49287c478bd9Sstevel@tonic-gate if (!err && pri->sys_nargs > 5) 49297c478bd9Sstevel@tonic-gate show_sockaddr(pri, "from", (long)pri->sys_args[4], 49307c478bd9Sstevel@tonic-gate (long)pri->sys_args[5], 0); 49317c478bd9Sstevel@tonic-gate break; 49327c478bd9Sstevel@tonic-gate case SYS_recvmsg: 49337c478bd9Sstevel@tonic-gate if (err) 49347c478bd9Sstevel@tonic-gate break; 49357c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 49367c478bd9Sstevel@tonic-gate case SYS_sendmsg: 493781006e0fSja97890 if (pri->sys_nargs <= 2) 49387c478bd9Sstevel@tonic-gate break; 49397c478bd9Sstevel@tonic-gate #ifdef _LP64 49407c478bd9Sstevel@tonic-gate if (lp64) 49417c478bd9Sstevel@tonic-gate show_msghdr(pri, pri->sys_args[1]); 49427c478bd9Sstevel@tonic-gate else 49437c478bd9Sstevel@tonic-gate show_msghdr32(pri, pri->sys_args[1]); 49447c478bd9Sstevel@tonic-gate #else 49457c478bd9Sstevel@tonic-gate show_msghdr(pri, pri->sys_args[1]); 49467c478bd9Sstevel@tonic-gate #endif 49477c478bd9Sstevel@tonic-gate break; 49487c478bd9Sstevel@tonic-gate case SYS_door: 49497c478bd9Sstevel@tonic-gate show_doors(pri); 49507c478bd9Sstevel@tonic-gate break; 49517c478bd9Sstevel@tonic-gate case SYS_sendfilev: 49527c478bd9Sstevel@tonic-gate if (pri->sys_nargs != 5) 49537c478bd9Sstevel@tonic-gate break; 49547c478bd9Sstevel@tonic-gate 49557c478bd9Sstevel@tonic-gate if (pri->sys_args[0] == SENDFILEV) { 49567c478bd9Sstevel@tonic-gate show_sendfilevec(pri, (int)pri->sys_args[1], 49577c478bd9Sstevel@tonic-gate (sendfilevec_t *)pri->sys_args[2], 49587c478bd9Sstevel@tonic-gate (int)pri->sys_args[3]); 49597c478bd9Sstevel@tonic-gate } else if (pri->sys_args[0] == SENDFILEV64) { 49607c478bd9Sstevel@tonic-gate show_sendfilevec64(pri, (int)pri->sys_args[1], 49617c478bd9Sstevel@tonic-gate (sendfilevec64_t *)pri->sys_args[2], 49627c478bd9Sstevel@tonic-gate (int)pri->sys_args[3]); 49637c478bd9Sstevel@tonic-gate } 49647c478bd9Sstevel@tonic-gate break; 49657c478bd9Sstevel@tonic-gate case SYS_memcntl: 49667c478bd9Sstevel@tonic-gate show_memcntl(pri); 49677c478bd9Sstevel@tonic-gate break; 49687c478bd9Sstevel@tonic-gate case SYS_lwp_park: 49697c478bd9Sstevel@tonic-gate /* subcode 0: lwp_park(timespec_t *, id_t) */ 49707c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 1 && pri->sys_args[0] == 0) 49717c478bd9Sstevel@tonic-gate show_timestruc(pri, (long)pri->sys_args[1], "timeout"); 49727c478bd9Sstevel@tonic-gate /* subcode 2: lwp_unpark_all(id_t *, int) */ 49737c478bd9Sstevel@tonic-gate if (pri->sys_nargs > 2 && pri->sys_args[0] == 2) 49747c478bd9Sstevel@tonic-gate show_ids(pri, (long)pri->sys_args[1], 49757c478bd9Sstevel@tonic-gate (int)pri->sys_args[2]); 49767c478bd9Sstevel@tonic-gate break; 49777c478bd9Sstevel@tonic-gate case SYS_ntp_gettime: 49787c478bd9Sstevel@tonic-gate if (!err) 49797c478bd9Sstevel@tonic-gate show_ntp_gettime(pri); 49807c478bd9Sstevel@tonic-gate break; 49817c478bd9Sstevel@tonic-gate case SYS_ntp_adjtime: 49827c478bd9Sstevel@tonic-gate if (!err) 49837c478bd9Sstevel@tonic-gate show_ntp_adjtime(pri); 49847c478bd9Sstevel@tonic-gate break; 49857c478bd9Sstevel@tonic-gate case SYS_rusagesys: 49867c478bd9Sstevel@tonic-gate if (!err) 49877c478bd9Sstevel@tonic-gate if (pri->sys_args[0] == _RUSAGESYS_GETRUSAGE) { 49887c478bd9Sstevel@tonic-gate #ifdef _LP64 49897c478bd9Sstevel@tonic-gate if (!lp64) 49907c478bd9Sstevel@tonic-gate show_getrusage32(pri->sys_args[1]); 49917c478bd9Sstevel@tonic-gate else 49927c478bd9Sstevel@tonic-gate #endif 49937c478bd9Sstevel@tonic-gate show_getrusage(pri->sys_args[1]); 49947c478bd9Sstevel@tonic-gate } 49957c478bd9Sstevel@tonic-gate break; 49967c478bd9Sstevel@tonic-gate case SYS_port: 49977c478bd9Sstevel@tonic-gate show_ports(pri); 49987c478bd9Sstevel@tonic-gate break; 4999821c4a97Sdp 5000821c4a97Sdp case SYS_zone: 5001821c4a97Sdp show_zones(pri); 5002821c4a97Sdp break; 50037c478bd9Sstevel@tonic-gate } 50047c478bd9Sstevel@tonic-gate } 5005