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