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