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