?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / truss / expound.c
blobce98740cfa2db245c64ae90012ae2cb05132ddb8
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
24 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
25 * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
26 * Copyright 2015 Joyent, Inc.
27 */
28
29 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
30 /* All Rights Reserved */
31
32 #define _SYSCALL32
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <ctype.h>
38 #include <sys/types.h>
39 #include <sys/mman.h>
40 #include <libproc.h>
41 #include <string.h>
42 #include <limits.h>
43 #include <sys/statfs.h>
44 #include <sys/times.h>
45 #include <sys/timex.h>
46 #include <sys/utssys.h>
47 #include <sys/utsname.h>
48 #include <sys/ipc.h>
49 #include <sys/ipc_impl.h>
50 #include <sys/msg.h>
51 #include <sys/msg_impl.h>
52 #include <sys/sem.h>
53 #include <sys/sem_impl.h>
54 #include <sys/shm.h>
55 #include <sys/shm_impl.h>
56 #include <sys/dirent.h>
57 #include <ustat.h>
58 #include <fcntl.h>
59 #include <time.h>
60 #include <sys/termios.h>
61 #include <sys/termiox.h>
62 #include <sys/termio.h>
63 #include <sys/ttold.h>
64 #include <sys/jioctl.h>
65 #include <sys/filio.h>
66 #include <stropts.h>
67 #include <poll.h>
68 #include <sys/uio.h>
69 #include <sys/resource.h>
70 #include <sys/statvfs.h>
71 #include <sys/time.h>
72 #include <sys/aio.h>
73 #include <sys/socket.h>
74 #include <netinet/in.h>
75 #include <sys/un.h>
76 #include <sys/byteorder.h>
77 #include <arpa/inet.h>
78 #include <sys/audioio.h>
79 #include <sys/cladm.h>
80 #include <sys/synch.h>
81 #include <sys/synch32.h>
82 #include <sys/sysmacros.h>
83 #include <sys/sendfile.h>
84 #include <priv.h>
85 #include <ucred.h>
86 #include <sys/ucred.h>
87 #include <sys/port_impl.h>
88 #include <sys/zone.h>
89 #include <sys/priv_impl.h>
90 #include <sys/priv.h>
91 #include <tsol/label.h>
92 #include <sys/nvpair.h>
93 #include <libnvpair.h>
94 #include <sys/rctl_impl.h>
95 #include <sys/socketvar.h>
96 #include <sys/fs/zfs.h>
97 #include <sys/zfs_ioctl.h>
98
99 #include "ramdata.h"
100 #include "systable.h"
101 #include "proto.h"
102
103 void show_sigset(private_t *, long, const char *);
104 void show_ioctl(private_t *, int, long);
105 void show_zfs_ioc(private_t *, long);
106
107 static void
108 mk_ctime(char *str, size_t maxsize, time_t value)
109 {
110 (void) strftime(str, maxsize, "%b %e %H:%M:%S %Z %Y",
111 localtime(&value));
112 }
113
114 void
115 prtime(private_t *pri, const char *name, time_t value)
116 {
117 char str[80];
118
119 mk_ctime(str, sizeof (str), value);
120 (void) printf("%s\t%s%s [ %lu ]\n",
121 pri->pname,
122 name,
123 str,
124 value);
125 }
126
127 void
128 prtimeval(private_t *pri, const char *name, struct timeval *value)
129 {
130 char str[80];
131
132 mk_ctime(str, sizeof (str), value->tv_sec);
133 (void) printf("%s\t%s%s [ %lu.%6.6lu ]\n",
134 pri->pname,
135 name,
136 str,
137 value->tv_sec,
138 value->tv_usec);
139 }
140
141 void
142 prtimestruc(private_t *pri, const char *name, timestruc_t *value)
143 {
144 char str[80];
145
146 mk_ctime(str, sizeof (str), value->tv_sec);
147 (void) printf("%s\t%s%s [ %lu.%9.9lu ]\n",
148 pri->pname,
149 name,
150 str,
151 value->tv_sec,
152 value->tv_nsec);
153 }
154
155 static void
156 show_utimens(private_t *pri, long offset)
157 {
158 struct {
159 timespec_t atime;
160 timespec_t mtime;
161 } utimbuf;
162
163 if (offset == 0)
164 return;
165
166 if (data_model == PR_MODEL_NATIVE) {
167 if (Pread(Proc, &utimbuf, sizeof (utimbuf), offset)
168 != sizeof (utimbuf))
169 return;
170 } else {
171 struct {
172 timespec32_t atime;
173 timespec32_t mtime;
174 } utimbuf32;
175
176 if (Pread(Proc, &utimbuf32, sizeof (utimbuf32), offset)
177 != sizeof (utimbuf32))
178 return;
179
180 TIMESPEC32_TO_TIMESPEC(&utimbuf.atime, &utimbuf32.atime);
181 TIMESPEC32_TO_TIMESPEC(&utimbuf.mtime, &utimbuf32.mtime);
182 }
183
184 /* print access and modification times */
185 if (utimbuf.atime.tv_nsec == UTIME_OMIT)
186 (void) printf("%s\tat = UTIME_OMIT\n", pri->pname);
187 else if (utimbuf.atime.tv_nsec == UTIME_NOW)
188 (void) printf("%s\tat = UTIME_NOW\n", pri->pname);
189 else
190 prtimestruc(pri, "at = ", &utimbuf.atime);
191 if (utimbuf.mtime.tv_nsec == UTIME_OMIT)
192 (void) printf("%s\tmt = UTIME_OMIT\n", pri->pname);
193 else if (utimbuf.mtime.tv_nsec == UTIME_NOW)
194 (void) printf("%s\tmt = UTIME_NOW\n", pri->pname);
195 else
196 prtimestruc(pri, "mt = ", &utimbuf.mtime);
197 }
198
199 void
200 show_timeofday(private_t *pri)
201 {
202 struct timeval tod;
203 long offset;
204
205 if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
206 return;
207
208 if (data_model == PR_MODEL_NATIVE) {
209 if (Pread(Proc, &tod, sizeof (tod), offset)
210 != sizeof (tod))
211 return;
212 } else {
213 struct timeval32 tod32;
214
215 if (Pread(Proc, &tod32, sizeof (tod32), offset)
216 != sizeof (tod32))
217 return;
218
219 TIMEVAL32_TO_TIMEVAL(&tod, &tod32);
220 }
221
222 prtimeval(pri, "time: ", &tod);
223 }
224
225 void
226 show_itimerval(private_t *pri, long offset, const char *name)
227 {
228 struct itimerval itimerval;
229
230 if (offset == 0)
231 return;
232
233 if (data_model == PR_MODEL_NATIVE) {
234 if (Pread(Proc, &itimerval, sizeof (itimerval), offset)
235 != sizeof (itimerval))
236 return;
237 } else {
238 struct itimerval32 itimerval32;
239
240 if (Pread(Proc, &itimerval32, sizeof (itimerval32), offset)
241 != sizeof (itimerval32))
242 return;
243
244 ITIMERVAL32_TO_ITIMERVAL(&itimerval, &itimerval32);
245 }
246
247 (void) printf(
248 "%s\t%s: interval: %4ld.%6.6ld sec value: %4ld.%6.6ld sec\n",
249 pri->pname,
250 name,
251 itimerval.it_interval.tv_sec,
252 itimerval.it_interval.tv_usec,
253 itimerval.it_value.tv_sec,
254 itimerval.it_value.tv_usec);
255 }
256
257 void
258 show_timeval(private_t *pri, long offset, const char *name)
259 {
260 struct timeval timeval;
261
262 if (offset == 0)
263 return;
264
265 if (data_model == PR_MODEL_NATIVE) {
266 if (Pread(Proc, &timeval, sizeof (timeval), offset)
267 != sizeof (timeval))
268 return;
269 } else {
270 struct timeval32 timeval32;
271
272 if (Pread(Proc, &timeval32, sizeof (timeval32), offset)
273 != sizeof (timeval32))
274 return;
275
276 TIMEVAL32_TO_TIMEVAL(&timeval, &timeval32);
277 }
278
279 (void) printf(
280 "%s\t%s: %ld.%6.6ld sec\n",
281 pri->pname,
282 name,
283 timeval.tv_sec,
284 timeval.tv_usec);
285 }
286
287 void
288 show_timestruc(private_t *pri, long offset, const char *name)
289 {
290 timestruc_t timestruc;
291
292 if (offset == 0)
293 return;
294
295 if (data_model == PR_MODEL_NATIVE) {
296 if (Pread(Proc, &timestruc, sizeof (timestruc), offset)
297 != sizeof (timestruc))
298 return;
299 } else {
300 timestruc32_t timestruc32;
301
302 if (Pread(Proc, &timestruc32, sizeof (timestruc32), offset)
303 != sizeof (timestruc32))
304 return;
305
306 TIMESPEC32_TO_TIMESPEC(&timestruc, &timestruc32);
307 }
308
309 (void) printf(
310 "%s\t%s: %ld.%9.9ld sec\n",
311 pri->pname,
312 name,
313 timestruc.tv_sec,
314 timestruc.tv_nsec);
315 }
316
317 void
318 show_stime(private_t *pri)
319 {
320 if (pri->sys_nargs >= 1) {
321 /* print new system time */
322 prtime(pri, "systime = ", (time_t)pri->sys_args[0]);
323 }
324 }
325
326 void
327 show_times(private_t *pri)
328 {
329 long hz = sysconf(_SC_CLK_TCK);
330 long offset;
331 struct tms tms;
332
333 if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
334 return;
335
336 if (data_model == PR_MODEL_NATIVE) {
337 if (Pread(Proc, &tms, sizeof (tms), offset)
338 != sizeof (tms))
339 return;
340 } else {
341 struct tms32 tms32;
342
343 if (Pread(Proc, &tms32, sizeof (tms32), offset)
344 != sizeof (tms32))
345 return;
346
347 /*
348 * This looks a bit odd (since the values are actually
349 * signed), but we need to suppress sign extension to
350 * preserve compatibility (we've always printed these
351 * numbers as unsigned quantities).
352 */
353 tms.tms_utime = (unsigned)tms32.tms_utime;
354 tms.tms_stime = (unsigned)tms32.tms_stime;
355 tms.tms_cutime = (unsigned)tms32.tms_cutime;
356 tms.tms_cstime = (unsigned)tms32.tms_cstime;
357 }
358
359 (void) printf(
360 "%s\tutim=%-6lu stim=%-6lu cutim=%-6lu cstim=%-6lu (HZ=%ld)\n",
361 pri->pname,
362 tms.tms_utime,
363 tms.tms_stime,
364 tms.tms_cutime,
365 tms.tms_cstime,
366 hz);
367 }
368
369 void
370 show_uname(private_t *pri, long offset)
371 {
372 /*
373 * Old utsname buffer (no longer accessible in <sys/utsname.h>).
374 */
375 struct {
376 char sysname[9];
377 char nodename[9];
378 char release[9];
379 char version[9];
380 char machine[9];
381 } ubuf;
382
383 if (offset != NULL &&
384 Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
385 (void) printf(
386 "%s\tsys=%-9.9snod=%-9.9srel=%-9.9sver=%-9.9smch=%.9s\n",
387 pri->pname,
388 ubuf.sysname,
389 ubuf.nodename,
390 ubuf.release,
391 ubuf.version,
392 ubuf.machine);
393 }
394 }
395
396 /* XX64 -- definition of 'struct ustat' is strange -- check out the defn */
397 void
398 show_ustat(private_t *pri, long offset)
399 {
400 struct ustat ubuf;
401
402 if (offset != NULL &&
403 Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
404 (void) printf(
405 "%s\ttfree=%-6ld tinode=%-5lu fname=%-6.6s fpack=%-.6s\n",
406 pri->pname,
407 ubuf.f_tfree,
408 ubuf.f_tinode,
409 ubuf.f_fname,
410 ubuf.f_fpack);
411 }
412 }
413
414 #ifdef _LP64
415 void
416 show_ustat32(private_t *pri, long offset)
417 {
418 struct ustat32 ubuf;
419
420 if (offset != NULL &&
421 Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
422 (void) printf(
423 "%s\ttfree=%-6d tinode=%-5u fname=%-6.6s fpack=%-.6s\n",
424 pri->pname,
425 ubuf.f_tfree,
426 ubuf.f_tinode,
427 ubuf.f_fname,
428 ubuf.f_fpack);
429 }
430 }
431 #endif /* _LP64 */
432
433 void
434 show_fusers(private_t *pri, long offset, long nproc)
435 {
436 f_user_t fubuf;
437 int serial = (nproc > 4);
438
439 if (offset == 0)
440 return;
441
442 /* enter region of lengthy output */
443 if (serial)
444 Eserialize();
445
446 while (nproc > 0 &&
447 Pread(Proc, &fubuf, sizeof (fubuf), offset) == sizeof (fubuf)) {
448 (void) printf("%s\tpid=%-5d uid=%-5u flags=%s\n",
449 pri->pname,
450 (int)fubuf.fu_pid,
451 fubuf.fu_uid,
452 fuflags(pri, fubuf.fu_flags));
453 nproc--;
454 offset += sizeof (fubuf);
455 }
456
457 /* exit region of lengthy output */
458 if (serial)
459 Xserialize();
460 }
461
462 void
463 show_utssys(private_t *pri, long r0)
464 {
465 if (pri->sys_nargs >= 3) {
466 switch (pri->sys_args[2]) {
467 case UTS_UNAME:
468 show_uname(pri, (long)pri->sys_args[0]);
469 break;
470 case UTS_USTAT:
471 show_ustat(pri, (long)pri->sys_args[0]);
472 break;
473 case UTS_FUSERS:
474 show_fusers(pri, (long)pri->sys_args[3], r0);
475 break;
476 }
477 }
478 }
479
480 #ifdef _LP64
481 void
482 show_utssys32(private_t *pri, long r0)
483 {
484 if (pri->sys_nargs >= 3) {
485 switch (pri->sys_args[2]) {
486 case UTS_UNAME:
487 show_uname(pri, (long)pri->sys_args[0]);
488 break;
489 case UTS_USTAT:
490 show_ustat32(pri, (long)pri->sys_args[0]);
491 break;
492 case UTS_FUSERS:
493 show_fusers(pri, (long)pri->sys_args[3], r0);
494 break;
495 }
496 }
497 }
498 #endif /* _LP64 */
499
500 void
501 show_cladm(private_t *pri, int code, int function, long offset)
502 {
503 int arg;
504
505 switch (code) {
506 case CL_INITIALIZE:
507 switch (function) {
508 case CL_GET_BOOTFLAG:
509 if (Pread(Proc, &arg, sizeof (arg), offset)
510 == sizeof (arg)) {
511 if (arg & CLUSTER_CONFIGURED)
512 (void) printf("%s\tbootflags="
513 "CLUSTER_CONFIGURED", pri->pname);
514 if (arg & CLUSTER_BOOTED)
515 (void) printf("|CLUSTER_BOOTED\n");
516 }
517 break;
518 }
519 break;
520 case CL_CONFIG:
521 switch (function) {
522 case CL_NODEID:
523 case CL_HIGHEST_NODEID:
524 if (Pread(Proc, &arg, sizeof (arg), offset)
525 == sizeof (arg))
526 (void) printf("%s\tnodeid=%d\n",
527 pri->pname, arg);
528 }
529 break;
530 }
531 }
532
533 #define ALL_LOCK_TYPES \
534 (USYNC_PROCESS | LOCK_ERRORCHECK | LOCK_RECURSIVE | \
535 LOCK_PRIO_INHERIT | LOCK_PRIO_PROTECT | LOCK_ROBUST | \
536 USYNC_PROCESS_ROBUST)
537
538 /* return cv and mutex types */
539 const char *
540 synch_type(private_t *pri, uint_t type)
541 {
542 char *str = pri->code_buf;
543
544 if (type & USYNC_PROCESS)
545 (void) strcpy(str, "USYNC_PROCESS");
546 else
547 (void) strcpy(str, "USYNC_THREAD");
548
549 if (type & LOCK_ERRORCHECK)
550 (void) strcat(str, "|LOCK_ERRORCHECK");
551 if (type & LOCK_RECURSIVE)
552 (void) strcat(str, "|LOCK_RECURSIVE");
553 if (type & LOCK_PRIO_INHERIT)
554 (void) strcat(str, "|LOCK_PRIO_INHERIT");
555 if (type & LOCK_PRIO_PROTECT)
556 (void) strcat(str, "|LOCK_PRIO_PROTECT");
557 if (type & LOCK_ROBUST)
558 (void) strcat(str, "|LOCK_ROBUST");
559 if (type & USYNC_PROCESS_ROBUST)
560 (void) strcat(str, "|USYNC_PROCESS_ROBUST");
561
562 if ((type &= ~ALL_LOCK_TYPES) != 0)
563 (void) sprintf(str + strlen(str), "|0x%.4X", type);
564
565 return ((const char *)str);
566 }
567
568 void
569 show_mutex(private_t *pri, long offset)
570 {
571 lwp_mutex_t mutex;
572
573 if (Pread(Proc, &mutex, sizeof (mutex), offset) == sizeof (mutex)) {
574 (void) printf("%s\tmutex type: %s\n",
575 pri->pname,
576 synch_type(pri, mutex.mutex_type));
577 }
578 }
579
580 void
581 show_condvar(private_t *pri, long offset)
582 {
583 lwp_cond_t condvar;
584
585 if (Pread(Proc, &condvar, sizeof (condvar), offset)
586 == sizeof (condvar)) {
587 (void) printf("%s\tcondvar type: %s\n",
588 pri->pname,
589 synch_type(pri, condvar.cond_type));
590 }
591 }
592
593 void
594 show_sema(private_t *pri, long offset)
595 {
596 lwp_sema_t sema;
597
598 if (Pread(Proc, &sema, sizeof (sema), offset) == sizeof (sema)) {
599 (void) printf("%s\tsema type: %s count = %u\n",
600 pri->pname,
601 synch_type(pri, sema.sema_type),
602 sema.sema_count);
603 }
604 }
605
606 void
607 show_rwlock(private_t *pri, long offset)
608 {
609 lwp_rwlock_t rwlock;
610
611 if (Pread(Proc, &rwlock, sizeof (rwlock), offset) == sizeof (rwlock)) {
612 (void) printf("%s\trwlock type: %s readers = %d\n",
613 pri->pname,
614 synch_type(pri, rwlock.rwlock_type),
615 rwlock.rwlock_readers);
616 }
617 }
618
619 /* represent character as itself ('c') or octal (012) */
620 char *
621 show_char(char *buf, int c)
622 {
623 const char *fmt;
624
625 if (c >= ' ' && c < 0177)
626 fmt = "'%c'";
627 else
628 fmt = "%.3o";
629
630 (void) sprintf(buf, fmt, c&0xff);
631 return (buf);
632 }
633
634 void
635 show_termio(private_t *pri, long offset)
636 {
637 struct termio termio;
638 char cbuf[8];
639 int i;
640
641 if (Pread(Proc, &termio, sizeof (termio), offset) == sizeof (termio)) {
642 (void) printf(
643 "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o line=%d\n",
644 pri->pname,
645 termio.c_iflag,
646 termio.c_oflag,
647 termio.c_cflag,
648 termio.c_lflag,
649 termio.c_line);
650 (void) printf("%s\t cc: ", pri->pname);
651 for (i = 0; i < NCC; i++)
652 (void) printf(" %s",
653 show_char(cbuf, (int)termio.c_cc[i]));
654 (void) fputc('\n', stdout);
655 }
656 }
657
658 void
659 show_termios(private_t *pri, long offset)
660 {
661 struct termios termios;
662 char cbuf[8];
663 int i;
664
665 if (Pread(Proc, &termios, sizeof (termios), offset)
666 == sizeof (termios)) {
667 (void) printf(
668 "%s\tiflag=0%.6o oflag=0%.6o cflag=0%.6o lflag=0%.6o\n",
669 pri->pname,
670 termios.c_iflag,
671 termios.c_oflag,
672 termios.c_cflag,
673 termios.c_lflag);
674 (void) printf("%s\t cc: ", pri->pname);
675 for (i = 0; i < NCCS; i++) {
676 if (i == NCC) /* show new chars on new line */
677 (void) printf("\n%s\t\t", pri->pname);
678 (void) printf(" %s",
679 show_char(cbuf, (int)termios.c_cc[i]));
680 }
681 (void) fputc('\n', stdout);
682 }
683 }
684
685 void
686 show_termiox(private_t *pri, long offset)
687 {
688 struct termiox termiox;
689 int i;
690
691 if (Pread(Proc, &termiox, sizeof (termiox), offset)
692 == sizeof (termiox)) {
693 (void) printf("%s\thflag=0%.3o cflag=0%.3o rflag=0%.3o",
694 pri->pname,
695 termiox.x_hflag,
696 termiox.x_cflag,
697 termiox.x_rflag[0]);
698 for (i = 1; i < NFF; i++)
699 (void) printf(",0%.3o", termiox.x_rflag[i]);
700 (void) printf(" sflag=0%.3o\n",
701 termiox.x_sflag);
702 }
703 }
704
705 void
706 show_sgttyb(private_t *pri, long offset)
707 {
708 struct sgttyb sgttyb;
709
710 if (Pread(Proc, &sgttyb, sizeof (sgttyb), offset) == sizeof (sgttyb)) {
711 char erase[8];
712 char kill[8];
713
714 (void) printf(
715 "%s\tispeed=%-2d ospeed=%-2d erase=%s kill=%s flags=0x%.8x\n",
716 pri->pname,
717 sgttyb.sg_ispeed&0xff,
718 sgttyb.sg_ospeed&0xff,
719 show_char(erase, sgttyb.sg_erase),
720 show_char(kill, sgttyb.sg_kill),
721 sgttyb.sg_flags);
722 }
723 }
724
725 void
726 show_ltchars(private_t *pri, long offset)
727 {
728 struct ltchars ltchars;
729 char *p;
730 char cbuf[8];
731 int i;
732
733 if (Pread(Proc, &ltchars, sizeof (ltchars), offset)
734 == sizeof (ltchars)) {
735 (void) printf("%s\t cc: ", pri->pname);
736 for (p = (char *)&ltchars, i = 0; i < sizeof (ltchars); i++)
737 (void) printf(" %s", show_char(cbuf, (int)*p++));
738 (void) fputc('\n', stdout);
739 }
740 }
741
742 void
743 show_tchars(private_t *pri, long offset)
744 {
745 struct tchars tchars;
746 char *p;
747 char cbuf[8];
748 int i;
749
750 if (Pread(Proc, &tchars, sizeof (tchars), offset) == sizeof (tchars)) {
751 (void) printf("%s\t cc: ", pri->pname);
752 for (p = (char *)&tchars, i = 0; i < sizeof (tchars); i++)
753 (void) printf(" %s", show_char(cbuf, (int)*p++));
754 (void) fputc('\n', stdout);
755 }
756 }
757
758 void
759 show_termcb(private_t *pri, long offset)
760 {
761 struct termcb termcb;
762
763 if (Pread(Proc, &termcb, sizeof (termcb), offset) == sizeof (termcb)) {
764 (void) printf(
765 "%s\tflgs=0%.2o termt=%d crow=%d ccol=%d vrow=%d lrow=%d\n",
766 pri->pname,
767 termcb.st_flgs&0xff,
768 termcb.st_termt&0xff,
769 termcb.st_crow&0xff,
770 termcb.st_ccol&0xff,
771 termcb.st_vrow&0xff,
772 termcb.st_lrow&0xff);
773 }
774 }
775
776 /* integer value pointed to by ioctl() arg */
777 void
778 show_strint(private_t *pri, int code, long offset)
779 {
780 int val;
781
782 if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) {
783 const char *s = NULL;
784
785 switch (code) { /* interpret these symbolically */
786 case I_GRDOPT:
787 s = strrdopt(val);
788 break;
789 case I_GETSIG:
790 s = strevents(pri, val);
791 break;
792 case TIOCFLUSH:
793 s = tiocflush(pri, val);
794 break;
795 }
796
797 if (s == NULL)
798 (void) printf("%s\t0x%.8lX: %d\n",
799 pri->pname, offset, val);
800 else
801 (void) printf("%s\t0x%.8lX: %s\n",
802 pri->pname, offset, s);
803 }
804 }
805
806 void
807 show_strioctl(private_t *pri, long offset)
808 {
809 struct strioctl strioctl;
810
811 if (Pread(Proc, &strioctl, sizeof (strioctl), offset) ==
812 sizeof (strioctl)) {
813 (void) printf(
814 "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n",
815 pri->pname,
816 ioctlname(pri, strioctl.ic_cmd),
817 strioctl.ic_timout,
818 strioctl.ic_len,
819 (long)strioctl.ic_dp);
820
821 if (pri->recur++ == 0) /* avoid indefinite recursion */
822 show_ioctl(pri, strioctl.ic_cmd,
823 (long)strioctl.ic_dp);
824 --pri->recur;
825 }
826 }
827
828 #ifdef _LP64
829 void
830 show_strioctl32(private_t *pri, long offset)
831 {
832 struct strioctl32 strioctl;
833
834 if (Pread(Proc, &strioctl, sizeof (strioctl), offset) ==
835 sizeof (strioctl)) {
836 (void) printf(
837 "%s\tcmd=%s timout=%d len=%d dp=0x%.8lX\n",
838 pri->pname,
839 ioctlname(pri, strioctl.ic_cmd),
840 strioctl.ic_timout,
841 strioctl.ic_len,
842 (long)strioctl.ic_dp);
843
844 if (pri->recur++ == 0) /* avoid indefinite recursion */
845 show_ioctl(pri, strioctl.ic_cmd,
846 (long)strioctl.ic_dp);
847 --pri->recur;
848 }
849 }
850 #endif /* _LP64 */
851
852 void
853 print_strbuf(private_t *pri, struct strbuf *sp, const char *name, int dump)
854 {
855 (void) printf(
856 "%s\t%s: maxlen=%-4d len=%-4d buf=0x%.8lX",
857 pri->pname,
858 name,
859 sp->maxlen,
860 sp->len,
861 (long)sp->buf);
862 /*
863 * Should we show the buffer contents?
864 * Keyed to the '-r fds' and '-w fds' options?
865 */
866 if (sp->buf == NULL || sp->len <= 0)
867 (void) fputc('\n', stdout);
868 else {
869 int nb = (sp->len > 8)? 8 : sp->len;
870 char buffer[8];
871 char obuf[40];
872
873 if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) {
874 (void) strcpy(obuf, ": \"");
875 showbytes(buffer, nb, obuf+3);
876 (void) strcat(obuf,
877 (nb == sp->len)?
878 (const char *)"\"" : (const char *)"\"..");
879 (void) fputs(obuf, stdout);
880 }
881 (void) fputc('\n', stdout);
882 if (dump && sp->len > 8)
883 showbuffer(pri, (long)sp->buf, (long)sp->len);
884 }
885 }
886
887 #ifdef _LP64
888 void
889 print_strbuf32(private_t *pri, struct strbuf32 *sp, const char *name, int dump)
890 {
891 (void) printf(
892 "%s\t%s: maxlen=%-4d len=%-4d buf=0x%.8lX",
893 pri->pname,
894 name,
895 sp->maxlen,
896 sp->len,
897 (long)sp->buf);
898 /*
899 * Should we show the buffer contents?
900 * Keyed to the '-r fds' and '-w fds' options?
901 */
902 if (sp->buf == NULL || sp->len <= 0)
903 (void) fputc('\n', stdout);
904 else {
905 int nb = (sp->len > 8)? 8 : sp->len;
906 char buffer[8];
907 char obuf[40];
908
909 if (Pread(Proc, buffer, (size_t)nb, (long)sp->buf) == nb) {
910 (void) strcpy(obuf, ": \"");
911 showbytes(buffer, nb, obuf+3);
912 (void) strcat(obuf,
913 (nb == sp->len)?
914 (const char *)"\"" : (const char *)"\"..");
915 (void) fputs(obuf, stdout);
916 }
917 (void) fputc('\n', stdout);
918 if (dump && sp->len > 8)
919 showbuffer(pri, (long)sp->buf, (long)sp->len);
920 }
921 }
922 #endif /* _LP64 */
923
924 /* strpeek and strfdinsert flags word */
925 const char *
926 strflags(private_t *pri, int flags)
927 {
928 const char *s;
929
930 switch (flags) {
931 case 0:
932 s = "0";
933 break;
934 case RS_HIPRI:
935 s = "RS_HIPRI";
936 break;
937 default:
938 (void) sprintf(pri->code_buf, "0x%.4X", flags);
939 s = pri->code_buf;
940 }
941
942 return (s);
943 }
944
945 void
946 show_strpeek(private_t *pri, long offset)
947 {
948 struct strpeek strpeek;
949
950 if (Pread(Proc, &strpeek, sizeof (strpeek), offset)
951 == sizeof (strpeek)) {
952
953 print_strbuf(pri, &strpeek.ctlbuf, "ctl", FALSE);
954 print_strbuf(pri, &strpeek.databuf, "dat", FALSE);
955
956 (void) printf("%s\tflags=%s\n",
957 pri->pname,
958 strflags(pri, strpeek.flags));
959 }
960 }
961
962 #ifdef _LP64
963 void
964 show_strpeek32(private_t *pri, long offset)
965 {
966 struct strpeek32 strpeek;
967
968 if (Pread(Proc, &strpeek, sizeof (strpeek), offset)
969 == sizeof (strpeek)) {
970
971 print_strbuf32(pri, &strpeek.ctlbuf, "ctl", FALSE);
972 print_strbuf32(pri, &strpeek.databuf, "dat", FALSE);
973
974 (void) printf("%s\tflags=%s\n",
975 pri->pname,
976 strflags(pri, strpeek.flags));
977 }
978 }
979 #endif /* _LP64 */
980
981 void
982 show_strfdinsert(private_t *pri, long offset)
983 {
984 struct strfdinsert strfdinsert;
985
986 if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) ==
987 sizeof (strfdinsert)) {
988
989 print_strbuf(pri, &strfdinsert.ctlbuf, "ctl", FALSE);
990 print_strbuf(pri, &strfdinsert.databuf, "dat", FALSE);
991
992 (void) printf("%s\tflags=%s fildes=%d offset=%d\n",
993 pri->pname,
994 strflags(pri, strfdinsert.flags),
995 strfdinsert.fildes,
996 strfdinsert.offset);
997 }
998 }
999
1000 #ifdef _LP64
1001 void
1002 show_strfdinsert32(private_t *pri, long offset)
1003 {
1004 struct strfdinsert32 strfdinsert;
1005
1006 if (Pread(Proc, &strfdinsert, sizeof (strfdinsert), offset) ==
1007 sizeof (strfdinsert)) {
1008
1009 print_strbuf32(pri, &strfdinsert.ctlbuf, "ctl", FALSE);
1010 print_strbuf32(pri, &strfdinsert.databuf, "dat", FALSE);
1011
1012 (void) printf("%s\tflags=%s fildes=%d offset=%d\n",
1013 pri->pname,
1014 strflags(pri, strfdinsert.flags),
1015 strfdinsert.fildes,
1016 strfdinsert.offset);
1017 }
1018 }
1019 #endif /* _LP64 */
1020
1021 void
1022 show_strrecvfd(private_t *pri, long offset)
1023 {
1024 struct strrecvfd strrecvfd;
1025
1026 if (Pread(Proc, &strrecvfd, sizeof (strrecvfd), offset) ==
1027 sizeof (strrecvfd)) {
1028 (void) printf(
1029 "%s\tfd=%-5d uid=%-5u gid=%u\n",
1030 pri->pname,
1031 strrecvfd.fd,
1032 strrecvfd.uid,
1033 strrecvfd.gid);
1034 }
1035 }
1036
1037 void
1038 show_strlist(private_t *pri, long offset)
1039 {
1040 struct str_list strlist;
1041 struct str_mlist list;
1042 int count;
1043
1044 if (Pread(Proc, &strlist, sizeof (strlist), offset) ==
1045 sizeof (strlist)) {
1046 (void) printf("%s\tnmods=%d modlist=0x%.8lX\n",
1047 pri->pname,
1048 strlist.sl_nmods,
1049 (long)strlist.sl_modlist);
1050
1051 count = strlist.sl_nmods;
1052 offset = (long)strlist.sl_modlist;
1053 while (!interrupt && --count >= 0) {
1054 if (Pread(Proc, &list, sizeof (list), offset) !=
1055 sizeof (list))
1056 break;
1057 (void) printf("%s\t\t\"%.*s\"\n",
1058 pri->pname,
1059 (int)sizeof (list.l_name),
1060 list.l_name);
1061 offset += sizeof (struct str_mlist);
1062 }
1063 }
1064 }
1065
1066 #ifdef _LP64
1067 void
1068 show_strlist32(private_t *pri, long offset)
1069 {
1070 struct str_list32 strlist;
1071 struct str_mlist list;
1072 int count;
1073
1074 if (Pread(Proc, &strlist, sizeof (strlist), offset) ==
1075 sizeof (strlist)) {
1076 (void) printf("%s\tnmods=%d modlist=0x%.8lX\n",
1077 pri->pname,
1078 strlist.sl_nmods,
1079 (long)strlist.sl_modlist);
1080
1081 count = strlist.sl_nmods;
1082 offset = (long)strlist.sl_modlist;
1083 while (!interrupt && --count >= 0) {
1084 if (Pread(Proc, &list, sizeof (list), offset) !=
1085 sizeof (list))
1086 break;
1087 (void) printf("%s\t\t\"%.*s\"\n",
1088 pri->pname,
1089 (int)sizeof (list.l_name),
1090 list.l_name);
1091 offset += sizeof (struct str_mlist);
1092 }
1093 }
1094 }
1095 #endif /* _LP64 */
1096
1097 void
1098 show_jwinsize(private_t *pri, long offset)
1099 {
1100 struct jwinsize jwinsize;
1101
1102 if (Pread(Proc, &jwinsize, sizeof (jwinsize), offset) ==
1103 sizeof (jwinsize)) {
1104 (void) printf(
1105 "%s\tbytesx=%-3u bytesy=%-3u bitsx=%-3u bitsy=%-3u\n",
1106 pri->pname,
1107 (unsigned)jwinsize.bytesx,
1108 (unsigned)jwinsize.bytesy,
1109 (unsigned)jwinsize.bitsx,
1110 (unsigned)jwinsize.bitsy);
1111 }
1112 }
1113
1114 void
1115 show_winsize(private_t *pri, long offset)
1116 {
1117 struct winsize winsize;
1118
1119 if (Pread(Proc, &winsize, sizeof (winsize), offset)
1120 == sizeof (winsize)) {
1121 (void) printf(
1122 "%s\trow=%-3d col=%-3d xpixel=%-3d ypixel=%-3d\n",
1123 pri->pname,
1124 winsize.ws_row,
1125 winsize.ws_col,
1126 winsize.ws_xpixel,
1127 winsize.ws_ypixel);
1128 }
1129 }
1130
1131 struct audio_stuff {
1132 uint_t bit;
1133 const char *str;
1134 };
1135
1136 const struct audio_stuff audio_output_ports[] = {
1137 { AUDIO_SPEAKER, "SPEAKER" },
1138 { AUDIO_HEADPHONE, "HEADPHONE" },
1139 { AUDIO_LINE_OUT, "LINE_OUT" },
1140 { AUDIO_SPDIF_OUT, "SPDIF_OUT" },
1141 { AUDIO_AUX1_OUT, "AUX1_OUT" },
1142 { AUDIO_AUX2_OUT, "AUX2_OUT" },
1143 { 0, NULL }
1144 };
1145
1146 const struct audio_stuff audio_input_ports[] = {
1147 { AUDIO_MICROPHONE, "MICROPHONE" },
1148 { AUDIO_LINE_IN, "LINE_IN" },
1149 { AUDIO_CD, "CD" },
1150 { AUDIO_SPDIF_IN, "SPDIF_IN" },
1151 { AUDIO_AUX1_IN, "AUX1_IN" },
1152 { AUDIO_AUX2_IN, "AUX2_IN" },
1153 { AUDIO_CODEC_LOOPB_IN, "CODEC_LOOPB_IN" },
1154 { AUDIO_SUNVTS, "SUNVTS" },
1155 { 0, NULL }
1156 };
1157
1158 static const struct audio_stuff audio_hw_features[] = {
1159 { AUDIO_HWFEATURE_DUPLEX, "DUPLEX" },
1160 { AUDIO_HWFEATURE_MSCODEC, "MSCODEC" },
1161 { AUDIO_HWFEATURE_IN2OUT, "IN2OUT" },
1162 { AUDIO_HWFEATURE_PLAY, "PLAY" },
1163 { AUDIO_HWFEATURE_RECORD, "RECORD" },
1164 { 0, NULL }
1165 };
1166
1167 static const struct audio_stuff audio_sw_features[] = {
1168 { AUDIO_SWFEATURE_MIXER, "MIXER" },
1169 { 0, NULL }
1170 };
1171
1172 void
1173 show_audio_features(const private_t *pri,
1174 const struct audio_stuff *audio_porttab, uint_t features,
1175 const char *name)
1176 {
1177 (void) printf("%s\t%s=", pri->pname, name);
1178 if (features == 0) {
1179 (void) printf("0\n");
1180 return;
1181 }
1182
1183 for (; audio_porttab->bit != 0; ++audio_porttab) {
1184 if (features & audio_porttab->bit) {
1185 (void) printf(audio_porttab->str);
1186 features &= ~audio_porttab->bit;
1187 if (features)
1188 (void) putchar('|');
1189 }
1190 }
1191 if (features)
1192 (void) printf("0x%x", features);
1193 (void) putchar('\n');
1194 }
1195
1196 void
1197 show_audio_ports(private_t *pri, const char *mode,
1198 const char *field, uint_t ports)
1199 {
1200 const struct audio_stuff *audio_porttab;
1201
1202 (void) printf("%s\t%s\t%s=", pri->pname, mode, field);
1203 if (ports == 0) {
1204 (void) printf("0\n");
1205 return;
1206 }
1207 if (*mode == 'p')
1208 audio_porttab = audio_output_ports;
1209 else
1210 audio_porttab = audio_input_ports;
1211 for (; audio_porttab->bit != 0; ++audio_porttab) {
1212 if (ports & audio_porttab->bit) {
1213 (void) printf(audio_porttab->str);
1214 ports &= ~audio_porttab->bit;
1215 if (ports)
1216 (void) putchar('|');
1217 }
1218 }
1219 if (ports)
1220 (void) printf("0x%x", ports);
1221 (void) putchar('\n');
1222 }
1223
1224 void
1225 show_audio_prinfo(private_t *pri, const char *mode, struct audio_prinfo *au_pr)
1226 {
1227 const char *s;
1228
1229 /*
1230 * The following values describe the audio data encoding.
1231 */
1232
1233 (void) printf("%s\t%s\tsample_rate=%u channels=%u precision=%u\n",
1234 pri->pname, mode,
1235 au_pr->sample_rate,
1236 au_pr->channels,
1237 au_pr->precision);
1238
1239 s = NULL;
1240 switch (au_pr->encoding) {
1241 case AUDIO_ENCODING_NONE: s = "NONE"; break;
1242 case AUDIO_ENCODING_ULAW: s = "ULAW"; break;
1243 case AUDIO_ENCODING_ALAW: s = "ALAW"; break;
1244 case AUDIO_ENCODING_LINEAR: s = "LINEAR"; break;
1245 case AUDIO_ENCODING_DVI: s = "DVI"; break;
1246 case AUDIO_ENCODING_LINEAR8: s = "LINEAR8"; break;
1247 }
1248 if (s)
1249 (void) printf("%s\t%s\tencoding=%s\n", pri->pname, mode, s);
1250 else {
1251 (void) printf("%s\t%s\tencoding=%u\n",
1252 pri->pname, mode, au_pr->encoding);
1253 }
1254
1255 /*
1256 * The following values control audio device configuration
1257 */
1258
1259 (void) printf(
1260 "%s\t%s\tgain=%u buffer_size=%u\n",
1261 pri->pname, mode,
1262 au_pr->gain,
1263 au_pr->buffer_size);
1264 show_audio_ports(pri, mode, "port", au_pr->port);
1265 show_audio_ports(pri, mode, "avail_ports", au_pr->avail_ports);
1266 show_audio_ports(pri, mode, "mod_ports", au_pr->mod_ports);
1267
1268 /*
1269 * The following values describe driver state
1270 */
1271
1272 (void) printf("%s\t%s\tsamples=%u eof=%u pause=%u error=%u\n",
1273 pri->pname, mode,
1274 au_pr->samples,
1275 au_pr->eof,
1276 au_pr->pause,
1277 au_pr->error);
1278 (void) printf("%s\t%s\twaiting=%u balance=%u minordev=%u\n",
1279 pri->pname, mode,
1280 au_pr->waiting,
1281 au_pr->balance,
1282 au_pr->minordev);
1283
1284 /*
1285 * The following values are read-only state flags
1286 */
1287 (void) printf("%s\t%s\topen=%u active=%u\n",
1288 pri->pname, mode,
1289 au_pr->open,
1290 au_pr->active);
1291 }
1292
1293 void
1294 show_audio_info(private_t *pri, long offset)
1295 {
1296 struct audio_info au;
1297
1298 if (Pread(Proc, &au, sizeof (au), offset) == sizeof (au)) {
1299 show_audio_prinfo(pri, "play", &au.play);
1300 show_audio_prinfo(pri, "record", &au.record);
1301 (void) printf("%s\tmonitor_gain=%u output_muted=%u\n",
1302 pri->pname, au.monitor_gain, au.output_muted);
1303 show_audio_features(pri, audio_hw_features, au.hw_features,
1304 "hw_features");
1305 show_audio_features(pri, audio_sw_features, au.sw_features,
1306 "sw_features");
1307 show_audio_features(pri, audio_sw_features,
1308 au.sw_features_enabled, "sw_features_enabled");
1309 }
1310 }
1311
1312 void
1313 show_ioctl(private_t *pri, int code, long offset)
1314 {
1315 int lp64 = (data_model == PR_MODEL_LP64);
1316 int err = pri->Errno; /* don't display output parameters */
1317 /* for a failed system call */
1318 #ifndef _LP64
1319 if (lp64)
1320 return;
1321 #endif
1322 if (offset == 0)
1323 return;
1324
1325 switch (code) {
1326 case TCGETA:
1327 if (err)
1328 break;
1329 /*FALLTHROUGH*/
1330 case TCSETA:
1331 case TCSETAW:
1332 case TCSETAF:
1333 show_termio(pri, offset);
1334 break;
1335 case TCGETS:
1336 if (err)
1337 break;
1338 /*FALLTHROUGH*/
1339 case TCSETS:
1340 case TCSETSW:
1341 case TCSETSF:
1342 show_termios(pri, offset);
1343 break;
1344 case TCGETX:
1345 if (err)
1346 break;
1347 /*FALLTHROUGH*/
1348 case TCSETX:
1349 case TCSETXW:
1350 case TCSETXF:
1351 show_termiox(pri, offset);
1352 break;
1353 case TIOCGETP:
1354 if (err)
1355 break;
1356 /*FALLTHROUGH*/
1357 case TIOCSETN:
1358 case TIOCSETP:
1359 show_sgttyb(pri, offset);
1360 break;
1361 case TIOCGLTC:
1362 if (err)
1363 break;
1364 /*FALLTHROUGH*/
1365 case TIOCSLTC:
1366 show_ltchars(pri, offset);
1367 break;
1368 case TIOCGETC:
1369 if (err)
1370 break;
1371 /*FALLTHROUGH*/
1372 case TIOCSETC:
1373 show_tchars(pri, offset);
1374 break;
1375 case LDGETT:
1376 if (err)
1377 break;
1378 /*FALLTHROUGH*/
1379 case LDSETT:
1380 show_termcb(pri, offset);
1381 break;
1382 /* streams ioctl()s */
1383 #if 0
1384 /* these are displayed as strings in the arg list */
1385 /* by prt_ioa(). don't display them again here */
1386 case I_PUSH:
1387 case I_LOOK:
1388 case I_FIND:
1389 /* these are displayed as decimal in the arg list */
1390 /* by prt_ioa(). don't display them again here */
1391 case I_LINK:
1392 case I_UNLINK:
1393 case I_SENDFD:
1394 /* these are displayed symbolically in the arg list */
1395 /* by prt_ioa(). don't display them again here */
1396 case I_SRDOPT:
1397 case I_SETSIG:
1398 case I_FLUSH:
1399 break;
1400 /* this one just ignores the argument */
1401 case I_POP:
1402 break;
1403 #endif
1404 /* these return something in an int pointed to by arg */
1405 case I_NREAD:
1406 case I_GRDOPT:
1407 case I_GETSIG:
1408 case TIOCGSID:
1409 case TIOCGPGRP:
1410 case TIOCLGET:
1411 case FIONREAD:
1412 case FIORDCHK:
1413 if (err)
1414 break;
1415 /*FALLTHROUGH*/
1416 /* these pass something in an int pointed to by arg */
1417 case TIOCSPGRP:
1418 case TIOCFLUSH:
1419 case TIOCLBIS:
1420 case TIOCLBIC:
1421 case TIOCLSET:
1422 show_strint(pri, code, offset);
1423 break;
1424 /* these all point to structures */
1425 case I_STR:
1426 #ifdef _LP64
1427 if (lp64)
1428 show_strioctl(pri, offset);
1429 else
1430 show_strioctl32(pri, offset);
1431 #else
1432 show_strioctl(pri, offset);
1433 #endif
1434 break;
1435 case I_PEEK:
1436 #ifdef _LP64
1437 if (lp64)
1438 show_strpeek(pri, offset);
1439 else
1440 show_strpeek32(pri, offset);
1441 #else
1442 show_strpeek(pri, offset);
1443 #endif
1444 break;
1445 case I_FDINSERT:
1446 #ifdef _LP64
1447 if (lp64)
1448 show_strfdinsert(pri, offset);
1449 else
1450 show_strfdinsert32(pri, offset);
1451 #else
1452 show_strfdinsert(pri, offset);
1453 #endif
1454 break;
1455 case I_RECVFD:
1456 if (err)
1457 break;
1458 show_strrecvfd(pri, offset);
1459 break;
1460 case I_LIST:
1461 if (err)
1462 break;
1463 #ifdef _LP64
1464 if (lp64)
1465 show_strlist(pri, offset);
1466 else
1467 show_strlist32(pri, offset);
1468 #else
1469 show_strlist(pri, offset);
1470 #endif
1471 break;
1472 case JWINSIZE:
1473 if (err)
1474 break;
1475 show_jwinsize(pri, offset);
1476 break;
1477 case TIOCGWINSZ:
1478 if (err)
1479 break;
1480 /*FALLTHROUGH*/
1481 case TIOCSWINSZ:
1482 show_winsize(pri, offset);
1483 break;
1484 case AUDIO_GETINFO:
1485 case (int)AUDIO_SETINFO:
1486 show_audio_info(pri, offset);
1487 break;
1488
1489 default:
1490 if ((code & ~0xff) == ZFS_IOC) {
1491 show_zfs_ioc(pri, offset);
1492 break;
1493 }
1494
1495 if (code & IOC_INOUT) {
1496 const char *str = ioctldatastruct(code);
1497
1498 (void) printf("\t\t%s",
1499 (code & IOC_INOUT) == IOC_INOUT ? "write/read" :
1500 code & IOC_IN ? "write" : "read");
1501 if (str != NULL) {
1502 (void) printf(" (struct %s)\n", str);
1503 } else {
1504 (void) printf(" %d bytes\n",
1505 (code >> 16) & IOCPARM_MASK);
1506 }
1507 }
1508 }
1509 }
1510
1511 void
1512 show_statvfs(private_t *pri)
1513 {
1514 long offset;
1515 struct statvfs statvfs;
1516 char *cp;
1517
1518 if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL &&
1519 Pread(Proc, &statvfs, sizeof (statvfs), offset)
1520 == sizeof (statvfs)) {
1521 (void) printf(
1522 "%s\tbsize=%-10lu frsize=%-9lu blocks=%-8llu bfree=%-9llu\n",
1523 pri->pname,
1524 statvfs.f_bsize,
1525 statvfs.f_frsize,
1526 (u_longlong_t)statvfs.f_blocks,
1527 (u_longlong_t)statvfs.f_bfree);
1528 (void) printf(
1529 "%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n",
1530 pri->pname,
1531 (u_longlong_t)statvfs.f_bavail,
1532 (u_longlong_t)statvfs.f_files,
1533 (u_longlong_t)statvfs.f_ffree,
1534 (u_longlong_t)statvfs.f_favail);
1535 (void) printf(
1536 "%s\tfsid=0x%-9.4lX basetype=%-7.16s namemax=%ld\n",
1537 pri->pname,
1538 statvfs.f_fsid,
1539 statvfs.f_basetype,
1540 (long)statvfs.f_namemax);
1541 (void) printf(
1542 "%s\tflag=%s\n",
1543 pri->pname,
1544 svfsflags(pri, (ulong_t)statvfs.f_flag));
1545 cp = statvfs.f_fstr + strlen(statvfs.f_fstr);
1546 if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 &&
1547 *(cp+1) != '\0')
1548 *cp = ' ';
1549 (void) printf("%s\tfstr=\"%.*s\"\n",
1550 pri->pname,
1551 (int)sizeof (statvfs.f_fstr),
1552 statvfs.f_fstr);
1553 }
1554 }
1555
1556 #ifdef _LP64
1557 void
1558 show_statvfs32(private_t *pri)
1559 {
1560 long offset;
1561 struct statvfs32 statvfs;
1562 char *cp;
1563
1564 if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL &&
1565 Pread(Proc, &statvfs, sizeof (statvfs), offset)
1566 == sizeof (statvfs)) {
1567 (void) printf(
1568 "%s\tbsize=%-10u frsize=%-9u blocks=%-8u bfree=%-9u\n",
1569 pri->pname,
1570 statvfs.f_bsize,
1571 statvfs.f_frsize,
1572 statvfs.f_blocks,
1573 statvfs.f_bfree);
1574 (void) printf(
1575 "%s\tbavail=%-9u files=%-10u ffree=%-9u favail=%-9u\n",
1576 pri->pname,
1577 statvfs.f_bavail,
1578 statvfs.f_files,
1579 statvfs.f_ffree,
1580 statvfs.f_favail);
1581 (void) printf(
1582 "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n",
1583 pri->pname,
1584 statvfs.f_fsid,
1585 statvfs.f_basetype,
1586 (int)statvfs.f_namemax);
1587 (void) printf(
1588 "%s\tflag=%s\n",
1589 pri->pname,
1590 svfsflags(pri, (ulong_t)statvfs.f_flag));
1591 cp = statvfs.f_fstr + strlen(statvfs.f_fstr);
1592 if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 &&
1593 *(cp+1) != '\0')
1594 *cp = ' ';
1595 (void) printf("%s\tfstr=\"%.*s\"\n",
1596 pri->pname,
1597 (int)sizeof (statvfs.f_fstr),
1598 statvfs.f_fstr);
1599 }
1600 }
1601 #endif /* _LP64 */
1602
1603 void
1604 show_statvfs64(private_t *pri)
1605 {
1606 long offset;
1607 struct statvfs64_32 statvfs;
1608 char *cp;
1609
1610 if (pri->sys_nargs > 1 && (offset = pri->sys_args[1]) != NULL &&
1611 Pread(Proc, &statvfs, sizeof (statvfs), offset)
1612 == sizeof (statvfs)) {
1613 (void) printf(
1614 "%s\tbsize=%-10u frsize=%-9u blocks=%-8llu bfree=%-9llu\n",
1615 pri->pname,
1616 statvfs.f_bsize,
1617 statvfs.f_frsize,
1618 (u_longlong_t)statvfs.f_blocks,
1619 (u_longlong_t)statvfs.f_bfree);
1620 (void) printf(
1621 "%s\tbavail=%-9llu files=%-10llu ffree=%-9llu favail=%-9llu\n",
1622 pri->pname,
1623 (u_longlong_t)statvfs.f_bavail,
1624 (u_longlong_t)statvfs.f_files,
1625 (u_longlong_t)statvfs.f_ffree,
1626 (u_longlong_t)statvfs.f_favail);
1627 (void) printf(
1628 "%s\tfsid=0x%-9.4X basetype=%-7.16s namemax=%d\n",
1629 pri->pname,
1630 statvfs.f_fsid,
1631 statvfs.f_basetype,
1632 (int)statvfs.f_namemax);
1633 (void) printf(
1634 "%s\tflag=%s\n",
1635 pri->pname,
1636 svfsflags(pri, (ulong_t)statvfs.f_flag));
1637 cp = statvfs.f_fstr + strlen(statvfs.f_fstr);
1638 if (cp < statvfs.f_fstr + sizeof (statvfs.f_fstr) - 1 &&
1639 *(cp+1) != '\0')
1640 *cp = ' ';
1641 (void) printf("%s\tfstr=\"%.*s\"\n",
1642 pri->pname,
1643 (int)sizeof (statvfs.f_fstr),
1644 statvfs.f_fstr);
1645 }
1646 }
1647
1648 void
1649 show_statfs(private_t *pri)
1650 {
1651 long offset;
1652 struct statfs statfs;
1653
1654 if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL &&
1655 Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) {
1656 (void) printf(
1657 "%s\tfty=%d bsz=%ld fsz=%ld blk=%ld bfr=%ld fil=%lu ffr=%lu\n",
1658 pri->pname,
1659 statfs.f_fstyp,
1660 statfs.f_bsize,
1661 statfs.f_frsize,
1662 statfs.f_blocks,
1663 statfs.f_bfree,
1664 statfs.f_files,
1665 statfs.f_ffree);
1666 (void) printf("%s\t fname=%.6s fpack=%.6s\n",
1667 pri->pname,
1668 statfs.f_fname,
1669 statfs.f_fpack);
1670 }
1671 }
1672
1673 #ifdef _LP64
1674 void
1675 show_statfs32(private_t *pri)
1676 {
1677 long offset;
1678 struct statfs32 statfs;
1679
1680 if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL &&
1681 Pread(Proc, &statfs, sizeof (statfs), offset) == sizeof (statfs)) {
1682 (void) printf(
1683 "%s\tfty=%d bsz=%d fsz=%d blk=%d bfr=%d fil=%u ffr=%u\n",
1684 pri->pname,
1685 statfs.f_fstyp,
1686 statfs.f_bsize,
1687 statfs.f_frsize,
1688 statfs.f_blocks,
1689 statfs.f_bfree,
1690 statfs.f_files,
1691 statfs.f_ffree);
1692 (void) printf("%s\t fname=%.6s fpack=%.6s\n",
1693 pri->pname,
1694 statfs.f_fname,
1695 statfs.f_fpack);
1696 }
1697 }
1698 #endif /* _LP64 */
1699
1700 void
1701 show_flock32(private_t *pri, long offset)
1702 {
1703 struct flock32 flock;
1704
1705 if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) {
1706 const char *str = NULL;
1707
1708 (void) printf("%s\ttyp=", pri->pname);
1709
1710 switch (flock.l_type) {
1711 case F_RDLCK:
1712 str = "F_RDLCK";
1713 break;
1714 case F_WRLCK:
1715 str = "F_WRLCK";
1716 break;
1717 case F_UNLCK:
1718 str = "F_UNLCK";
1719 break;
1720 }
1721 if (str != NULL)
1722 (void) printf("%s", str);
1723 else
1724 (void) printf("%-7d", flock.l_type);
1725
1726 str = whencearg(flock.l_whence);
1727 if (str != NULL)
1728 (void) printf(" whence=%s", str);
1729 else
1730 (void) printf(" whence=%-8u", flock.l_whence);
1731
1732 (void) printf(
1733 " start=%-5d len=%-5d sys=%-2u pid=%d\n",
1734 flock.l_start,
1735 flock.l_len,
1736 flock.l_sysid,
1737 flock.l_pid);
1738 }
1739 }
1740
1741 void
1742 show_flock64(private_t *pri, long offset)
1743 {
1744 struct flock64 flock;
1745
1746 if (Pread(Proc, &flock, sizeof (flock), offset) == sizeof (flock)) {
1747 const char *str = NULL;
1748
1749 (void) printf("%s\ttyp=", pri->pname);
1750
1751 switch (flock.l_type) {
1752 case F_RDLCK:
1753 str = "F_RDLCK";
1754 break;
1755 case F_WRLCK:
1756 str = "F_WRLCK";
1757 break;
1758 case F_UNLCK:
1759 str = "F_UNLCK";
1760 break;
1761 }
1762 if (str != NULL)
1763 (void) printf("%s", str);
1764 else
1765 (void) printf("%-7d", flock.l_type);
1766
1767 str = whencearg(flock.l_whence);
1768 if (str != NULL)
1769 (void) printf(" whence=%s", str);
1770 else
1771 (void) printf(" whence=%-8u", flock.l_whence);
1772
1773 (void) printf(
1774 " start=%-5lld len=%-5lld sys=%-2u pid=%d\n",
1775 (long long)flock.l_start,
1776 (long long)flock.l_len,
1777 flock.l_sysid,
1778 (int)flock.l_pid);
1779 }
1780 }
1781
1782 void
1783 show_share(private_t *pri, long offset)
1784 {
1785 struct fshare fshare;
1786
1787 if (Pread(Proc, &fshare, sizeof (fshare), offset) == sizeof (fshare)) {
1788 const char *str = NULL;
1789 int manddny = 0;
1790
1791 (void) printf("%s\taccess=", pri->pname);
1792
1793 switch (fshare.f_access) {
1794 case F_RDACC:
1795 str = "F_RDACC";
1796 break;
1797 case F_WRACC:
1798 str = "F_WRACC";
1799 break;
1800 case F_RWACC:
1801 str = "F_RWACC";
1802 break;
1803 }
1804 if (str != NULL)
1805 (void) printf("%s", str);
1806 else
1807 (void) printf("%-7d", fshare.f_access);
1808
1809 str = NULL;
1810 if (fshare.f_deny & F_MANDDNY) {
1811 fshare.f_deny &= ~F_MANDDNY;
1812 manddny = 1;
1813 }
1814 switch (fshare.f_deny) {
1815 case F_NODNY:
1816 str = "F_NODNY";
1817 break;
1818 case F_RDDNY:
1819 str = "F_RDDNY";
1820 break;
1821 case F_WRDNY:
1822 str = "F_WRDNY";
1823 break;
1824 case F_RWDNY:
1825 str = "F_RWDNY";
1826 break;
1827 case F_COMPAT:
1828 str = "F_COMPAT";
1829 break;
1830 }
1831 if (str != NULL) {
1832 if (manddny)
1833 (void) printf(" deny=F_MANDDNY|%s", str);
1834 else
1835 (void) printf(" deny=%s", str);
1836 } else {
1837 (void) printf(" deny=0x%x", manddny?
1838 fshare.f_deny | F_MANDDNY : fshare.f_deny);
1839 }
1840
1841 (void) printf(" id=%x\n", fshare.f_id);
1842 }
1843 }
1844
1845 void
1846 show_ffg(private_t *pri)
1847 {
1848 (void) putchar('\t');
1849 (void) putchar('\t');
1850 prt_ffg(pri, 0, pri->Rval1);
1851 (void) puts(pri->sys_string);
1852 }
1853
1854 /* print values in fcntl() pointed-to structure */
1855 void
1856 show_fcntl(private_t *pri)
1857 {
1858 long offset;
1859
1860 if (pri->sys_nargs >= 2 && pri->sys_args[1] == F_GETFL) {
1861 show_ffg(pri);
1862 return;
1863 }
1864
1865 if (pri->sys_nargs < 3 || (offset = pri->sys_args[2]) == NULL)
1866 return;
1867
1868 switch (pri->sys_args[1]) {
1869 #ifdef _LP64
1870 case F_GETLK:
1871 case F_SETLK:
1872 case F_SETLKW:
1873 case F_FREESP:
1874 case F_ALLOCSP:
1875 case F_SETLK_NBMAND:
1876 case F_OFD_GETLK:
1877 case F_OFD_SETLK:
1878 case F_OFD_SETLKW:
1879 case F_FLOCK:
1880 case F_FLOCKW:
1881 if (data_model == PR_MODEL_LP64)
1882 show_flock64(pri, offset);
1883 else
1884 show_flock32(pri, offset);
1885 break;
1886 case 33: /* F_GETLK64 */
1887 case 34: /* F_SETLK64 */
1888 case 35: /* F_SETLKW64 */
1889 case 27: /* F_FREESP64 */
1890 case 28: /* F_ALLOCSP64 */
1891 case 44: /* F_SETLK64_NBMAND */
1892 case 50: /* F_OFD_GETLK64 */
1893 case 51: /* F_OFD_SETLK64 */
1894 case 52: /* F_OFD_SETLKW64 */
1895 case 55: /* F_FLOCK64 */
1896 case 56: /* F_FLOCKW64 */
1897 show_flock64(pri, offset);
1898 break;
1899 #else /* _LP64 */
1900 case F_GETLK:
1901 case F_SETLK:
1902 case F_SETLKW:
1903 case F_FREESP:
1904 case F_ALLOCSP:
1905 case F_SETLK_NBMAND:
1906 show_flock32(pri, offset);
1907 break;
1908 case F_GETLK64:
1909 case F_SETLK64:
1910 case F_SETLKW64:
1911 case F_FREESP64:
1912 case F_ALLOCSP64:
1913 case F_SETLK64_NBMAND:
1914 case F_OFD_GETLK64:
1915 case F_OFD_SETLK64:
1916 case F_OFD_SETLKW64:
1917 case F_FLOCK64:
1918 case F_FLOCKW64:
1919 show_flock64(pri, offset);
1920 break;
1921 #endif /* _LP64 */
1922 case F_SHARE:
1923 case F_UNSHARE:
1924 show_share(pri, offset);
1925 break;
1926 }
1927 }
1928
1929 void
1930 show_strbuf(private_t *pri, long offset, const char *name, int dump)
1931 {
1932 struct strbuf strbuf;
1933
1934 if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf))
1935 print_strbuf(pri, &strbuf, name, dump);
1936 }
1937
1938 #ifdef _LP64
1939 void
1940 show_strbuf32(private_t *pri, long offset, const char *name, int dump)
1941 {
1942 struct strbuf32 strbuf;
1943
1944 if (Pread(Proc, &strbuf, sizeof (strbuf), offset) == sizeof (strbuf))
1945 print_strbuf32(pri, &strbuf, name, dump);
1946 }
1947 #endif /* _LP64 */
1948
1949 void
1950 show_gp_msg(private_t *pri, int what)
1951 {
1952 long offset;
1953 int dump = FALSE;
1954 int fdp1 = pri->sys_args[0] + 1;
1955
1956 switch (what) {
1957 case SYS_getmsg:
1958 case SYS_getpmsg:
1959 if (pri->Errno == 0 && prismember(&readfd, fdp1))
1960 dump = TRUE;
1961 break;
1962 case SYS_putmsg:
1963 case SYS_putpmsg:
1964 if (prismember(&writefd, fdp1))
1965 dump = TRUE;
1966 break;
1967 }
1968
1969 /* enter region of lengthy output */
1970 if (dump)
1971 Eserialize();
1972
1973 #ifdef _LP64
1974 if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL) {
1975 if (data_model == PR_MODEL_LP64)
1976 show_strbuf(pri, offset, "ctl", dump);
1977 else
1978 show_strbuf32(pri, offset, "ctl", dump);
1979 }
1980 if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL) {
1981 if (data_model == PR_MODEL_LP64)
1982 show_strbuf(pri, offset, "dat", dump);
1983 else
1984 show_strbuf32(pri, offset, "dat", dump);
1985 }
1986 #else /* _LP64 */
1987 if (pri->sys_nargs >= 2 && (offset = pri->sys_args[1]) != NULL)
1988 show_strbuf(pri, offset, "ctl", dump);
1989 if (pri->sys_nargs >= 3 && (offset = pri->sys_args[2]) != NULL)
1990 show_strbuf(pri, offset, "dat", dump);
1991 #endif /* _LP64 */
1992
1993 /* exit region of lengthy output */
1994 if (dump)
1995 Xserialize();
1996 }
1997
1998 void
1999 show_int(private_t *pri, long offset, const char *name)
2000 {
2001 int value;
2002
2003 if (offset != 0 &&
2004 Pread(Proc, &value, sizeof (value), offset) == sizeof (value))
2005 (void) printf("%s\t%s:\t%d\n",
2006 pri->pname,
2007 name,
2008 value);
2009 }
2010
2011 void
2012 show_hhex_int(private_t *pri, long offset, const char *name)
2013 {
2014 int value;
2015
2016 if (Pread(Proc, &value, sizeof (value), offset) == sizeof (value))
2017 (void) printf("%s\t%s:\t0x%.4X\n",
2018 pri->pname,
2019 name,
2020 value);
2021 }
2022
2023 #define ALL_POLL_FLAGS (POLLIN|POLLPRI|POLLOUT| \
2024 POLLRDNORM|POLLRDBAND|POLLWRBAND|POLLERR|POLLHUP|POLLNVAL)
2025
2026 const char *
2027 pollevent(private_t *pri, int arg)
2028 {
2029 char *str = pri->code_buf;
2030
2031 if (arg == 0)
2032 return ("0");
2033 if (arg & ~ALL_POLL_FLAGS) {
2034 (void) sprintf(str, "0x%-5X", arg);
2035 return ((const char *)str);
2036 }
2037
2038 *str = '\0';
2039 if (arg & POLLIN)
2040 (void) strcat(str, "|POLLIN");
2041 if (arg & POLLPRI)
2042 (void) strcat(str, "|POLLPRI");
2043 if (arg & POLLOUT)
2044 (void) strcat(str, "|POLLOUT");
2045 if (arg & POLLRDNORM)
2046 (void) strcat(str, "|POLLRDNORM");
2047 if (arg & POLLRDBAND)
2048 (void) strcat(str, "|POLLRDBAND");
2049 if (arg & POLLWRBAND)
2050 (void) strcat(str, "|POLLWRBAND");
2051 if (arg & POLLERR)
2052 (void) strcat(str, "|POLLERR");
2053 if (arg & POLLHUP)
2054 (void) strcat(str, "|POLLHUP");
2055 if (arg & POLLNVAL)
2056 (void) strcat(str, "|POLLNVAL");
2057
2058 return ((const char *)(str+1));
2059 }
2060
2061 static void
2062 show_one_pollfd(private_t *pri, struct pollfd *ppollfd)
2063 {
2064 /*
2065 * can't print both events and revents in same printf.
2066 * pollevent() returns a pointer to a TSD location.
2067 */
2068 (void) printf("%s\tfd=%-2d ev=%s",
2069 pri->pname, ppollfd->fd, pollevent(pri, ppollfd->events));
2070 (void) printf(" rev=%s\n", pollevent(pri, ppollfd->revents));
2071 }
2072
2073 static void
2074 show_all_pollfds(private_t *pri, long offset, int nfds)
2075 {
2076 struct pollfd pollfd[2];
2077 int skip = -1;
2078
2079 for (; nfds && !interrupt; nfds--, offset += sizeof (struct pollfd)) {
2080 if (Pread(Proc, &pollfd[0], sizeof (struct pollfd), offset) !=
2081 sizeof (struct pollfd))
2082 continue;
2083
2084 if (skip >= 0 && pollfd[0].fd == pollfd[1].fd &&
2085 pollfd[0].events == pollfd[1].events &&
2086 pollfd[0].revents == pollfd[1].revents) {
2087 skip++;
2088 continue;
2089 }
2090
2091 if (skip > 0)
2092 (void) printf("%s\t...last pollfd structure"
2093 " repeated %d time%s...\n",
2094 pri->pname, skip, (skip == 1 ? "" : "s"));
2095
2096 skip = 0;
2097 show_one_pollfd(pri, &pollfd[0]);
2098 pollfd[1] = pollfd[0];
2099 }
2100
2101 if (skip > 0)
2102 (void) printf(
2103 "%s\t...last pollfd structure repeated %d time%s...\n",
2104 pri->pname, skip, (skip == 1 ? "" : "s"));
2105 }
2106
2107 void
2108 show_pollsys(private_t *pri)
2109 {
2110 long offset;
2111 int nfds;
2112 int serial = 0;
2113
2114 if (pri->sys_nargs < 2)
2115 return;
2116
2117 offset = pri->sys_args[0];
2118 nfds = pri->sys_args[1];
2119
2120 /* enter region of lengthy output */
2121 if (offset != NULL && nfds > 32) {
2122 Eserialize();
2123 serial = 1;
2124 }
2125
2126 if (offset != NULL && nfds > 0)
2127 show_all_pollfds(pri, offset, nfds);
2128
2129 if (pri->sys_nargs > 2)
2130 show_timestruc(pri, (long)pri->sys_args[2], "timeout");
2131
2132 if (pri->sys_nargs > 3)
2133 show_sigset(pri, (long)pri->sys_args[3], "sigmask");
2134
2135 /* exit region of lengthy output */
2136 if (serial)
2137 Xserialize();
2138 }
2139
2140 static void
2141 show_perm64(private_t *pri, struct ipc_perm64 *ip)
2142 {
2143 (void) printf("%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u z=%-5d "
2144 "m=0%.6o key=%d projid=%-5d\n",
2145 pri->pname,
2146 ip->ipcx_uid,
2147 ip->ipcx_gid,
2148 ip->ipcx_cuid,
2149 ip->ipcx_cgid,
2150 (int)ip->ipcx_zoneid,
2151 (unsigned int)ip->ipcx_mode,
2152 ip->ipcx_key,
2153 (int)ip->ipcx_projid);
2154 }
2155
2156 void
2157 show_perm(private_t *pri, struct ipc_perm *ip)
2158 {
2159 (void) printf(
2160 "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n",
2161 pri->pname,
2162 ip->uid,
2163 ip->gid,
2164 ip->cuid,
2165 ip->cgid,
2166 (int)ip->mode,
2167 ip->seq,
2168 ip->key);
2169 }
2170
2171 #ifdef _LP64
2172 void
2173 show_perm32(private_t *pri, struct ipc_perm32 *ip)
2174 {
2175 (void) printf(
2176 "%s\tu=%-5u g=%-5u cu=%-5u cg=%-5u m=0%.6o seq=%u key=%d\n",
2177 pri->pname,
2178 ip->uid,
2179 ip->gid,
2180 ip->cuid,
2181 ip->cgid,
2182 ip->mode,
2183 ip->seq,
2184 ip->key);
2185 }
2186 #endif /* _LP64 */
2187
2188 static void
2189 show_msgctl64(private_t *pri, long offset)
2190 {
2191 struct msqid_ds64 msgq;
2192
2193 if (offset != NULL &&
2194 Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) {
2195 show_perm64(pri, &msgq.msgx_perm);
2196
2197 (void) printf("%s\tbytes=%-5llu msgs=%-5llu maxby=%-5llu "
2198 "lspid=%-5d lrpid=%-5d\n", pri->pname,
2199 (unsigned long long)msgq.msgx_cbytes,
2200 (unsigned long long)msgq.msgx_qnum,
2201 (unsigned long long)msgq.msgx_qbytes,
2202 (int)msgq.msgx_lspid,
2203 (int)msgq.msgx_lrpid);
2204
2205 prtime(pri, " st = ", (time_t)msgq.msgx_stime);
2206 prtime(pri, " rt = ", (time_t)msgq.msgx_rtime);
2207 prtime(pri, " ct = ", (time_t)msgq.msgx_ctime);
2208 }
2209 }
2210
2211 void
2212 show_msgctl(private_t *pri, long offset)
2213 {
2214 struct msqid_ds msgq;
2215
2216 if (offset != NULL &&
2217 Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) {
2218 show_perm(pri, &msgq.msg_perm);
2219
2220 (void) printf(
2221 "%s\tbytes=%-5lu msgs=%-5lu maxby=%-5lu lspid=%-5u lrpid=%-5u\n",
2222 pri->pname,
2223 msgq.msg_cbytes,
2224 msgq.msg_qnum,
2225 msgq.msg_qbytes,
2226 (int)msgq.msg_lspid,
2227 (int)msgq.msg_lrpid);
2228
2229 prtime(pri, " st = ", msgq.msg_stime);
2230 prtime(pri, " rt = ", msgq.msg_rtime);
2231 prtime(pri, " ct = ", msgq.msg_ctime);
2232 }
2233 }
2234
2235 #ifdef _LP64
2236 void
2237 show_msgctl32(private_t *pri, long offset)
2238 {
2239 struct msqid_ds32 msgq;
2240
2241 if (offset != NULL &&
2242 Pread(Proc, &msgq, sizeof (msgq), offset) == sizeof (msgq)) {
2243 show_perm32(pri, &msgq.msg_perm);
2244
2245 (void) printf(
2246 "%s\tbytes=%-5u msgs=%-5u maxby=%-5u lspid=%-5u lrpid=%-5u\n",
2247 pri->pname,
2248 msgq.msg_cbytes,
2249 msgq.msg_qnum,
2250 msgq.msg_qbytes,
2251 msgq.msg_lspid,
2252 msgq.msg_lrpid);
2253
2254 prtime(pri, " st = ", msgq.msg_stime);
2255 prtime(pri, " rt = ", msgq.msg_rtime);
2256 prtime(pri, " ct = ", msgq.msg_ctime);
2257 }
2258 }
2259 #endif /* _LP64 */
2260
2261 void
2262 show_msgbuf(private_t *pri, long offset, long msgsz)
2263 {
2264 struct msgbuf msgb;
2265
2266 if (offset != NULL &&
2267 Pread(Proc, &msgb, sizeof (msgb.mtype), offset) ==
2268 sizeof (msgb.mtype)) {
2269 /* enter region of lengthy output */
2270 if (msgsz > MYBUFSIZ / 4)
2271 Eserialize();
2272
2273 (void) printf("%s\tmtype=%lu mtext[]=\n",
2274 pri->pname,
2275 msgb.mtype);
2276 showbuffer(pri,
2277 (long)(offset + sizeof (msgb.mtype)), msgsz);
2278
2279 /* exit region of lengthy output */
2280 if (msgsz > MYBUFSIZ / 4)
2281 Xserialize();
2282 }
2283 }
2284
2285 #ifdef _LP64
2286 void
2287 show_msgbuf32(private_t *pri, long offset, long msgsz)
2288 {
2289 struct ipcmsgbuf32 msgb;
2290
2291 if (offset != NULL &&
2292 Pread(Proc, &msgb, sizeof (msgb.mtype), offset) ==
2293 sizeof (msgb.mtype)) {
2294 /* enter region of lengthy output */
2295 if (msgsz > MYBUFSIZ / 4)
2296 Eserialize();
2297
2298 (void) printf("%s\tmtype=%u mtext[]=\n",
2299 pri->pname,
2300 msgb.mtype);
2301 showbuffer(pri,
2302 (long)(offset + sizeof (msgb.mtype)), msgsz);
2303
2304 /* exit region of lengthy output */
2305 if (msgsz > MYBUFSIZ / 4)
2306 Xserialize();
2307 }
2308 }
2309 #endif /* _LP64 */
2310
2311 #ifdef _LP64
2312 void
2313 show_msgsys(private_t *pri, long msgsz)
2314 {
2315 switch (pri->sys_args[0]) {
2316 case 0: /* msgget() */
2317 break;
2318 case 1: /* msgctl() */
2319 if (pri->sys_nargs > 3) {
2320 switch (pri->sys_args[2]) {
2321 case IPC_STAT:
2322 if (pri->Errno)
2323 break;
2324 /*FALLTHROUGH*/
2325 case IPC_SET:
2326 if (data_model == PR_MODEL_LP64)
2327 show_msgctl(pri,
2328 (long)pri->sys_args[3]);
2329 else
2330 show_msgctl32(pri,
2331 (long)pri->sys_args[3]);
2332 break;
2333 case IPC_STAT64:
2334 if (pri->Errno)
2335 break;
2336 /*FALLTHROUGH*/
2337 case IPC_SET64:
2338 show_msgctl64(pri, (long)pri->sys_args[3]);
2339 break;
2340 }
2341 }
2342 break;
2343 case 2: /* msgrcv() */
2344 if (!pri->Errno && pri->sys_nargs > 2) {
2345 if (data_model == PR_MODEL_LP64)
2346 show_msgbuf(pri, pri->sys_args[2], msgsz);
2347 else
2348 show_msgbuf32(pri, pri->sys_args[2], msgsz);
2349 }
2350 break;
2351 case 3: /* msgsnd() */
2352 if (pri->sys_nargs > 3) {
2353 if (data_model == PR_MODEL_LP64)
2354 show_msgbuf(pri, pri->sys_args[2],
2355 pri->sys_args[3]);
2356 else
2357 show_msgbuf32(pri, pri->sys_args[2],
2358 pri->sys_args[3]);
2359 }
2360 break;
2361 case 4: /* msgids() */
2362 case 5: /* msgsnap() */
2363 default: /* unexpected subcode */
2364 break;
2365 }
2366 }
2367 #else /* _LP64 */
2368 void
2369 show_msgsys(private_t *pri, long msgsz)
2370 {
2371 switch (pri->sys_args[0]) {
2372 case 0: /* msgget() */
2373 break;
2374 case 1: /* msgctl() */
2375 if (pri->sys_nargs > 3) {
2376 switch (pri->sys_args[2]) {
2377 case IPC_STAT:
2378 if (pri->Errno)
2379 break;
2380 /*FALLTHROUGH*/
2381 case IPC_SET:
2382 show_msgctl(pri, (long)pri->sys_args[3]);
2383 break;
2384 case IPC_STAT64:
2385 if (pri->Errno)
2386 break;
2387 /*FALLTHROUGH*/
2388 case IPC_SET64:
2389 show_msgctl64(pri, (long)pri->sys_args[3]);
2390 break;
2391 }
2392 }
2393 break;
2394 case 2: /* msgrcv() */
2395 if (!pri->Errno && pri->sys_nargs > 2)
2396 show_msgbuf(pri, pri->sys_args[2], msgsz);
2397 break;
2398 case 3: /* msgsnd() */
2399 if (pri->sys_nargs > 3)
2400 show_msgbuf(pri, pri->sys_args[2],
2401 pri->sys_args[3]);
2402 break;
2403 case 4: /* msgids() */
2404 case 5: /* msgsnap() */
2405 default: /* unexpected subcode */
2406 break;
2407 }
2408 }
2409 #endif /* _LP64 */
2410
2411 static void
2412 show_semctl64(private_t *pri, long offset)
2413 {
2414 struct semid_ds64 semds;
2415
2416 if (offset != NULL &&
2417 Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) {
2418 show_perm64(pri, &semds.semx_perm);
2419
2420 (void) printf("%s\tnsems=%u\n", pri->pname, semds.semx_nsems);
2421
2422 prtime(pri, " ot = ", (time_t)semds.semx_otime);
2423 prtime(pri, " ct = ", (time_t)semds.semx_ctime);
2424 }
2425 }
2426
2427 void
2428 show_semctl(private_t *pri, long offset)
2429 {
2430 struct semid_ds semds;
2431
2432 if (offset != NULL &&
2433 Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) {
2434 show_perm(pri, &semds.sem_perm);
2435
2436 (void) printf("%s\tnsems=%u\n",
2437 pri->pname,
2438 semds.sem_nsems);
2439
2440 prtime(pri, " ot = ", semds.sem_otime);
2441 prtime(pri, " ct = ", semds.sem_ctime);
2442 }
2443 }
2444
2445 #ifdef _LP64
2446 void
2447 show_semctl32(private_t *pri, long offset)
2448 {
2449 struct semid_ds32 semds;
2450
2451 if (offset != NULL &&
2452 Pread(Proc, &semds, sizeof (semds), offset) == sizeof (semds)) {
2453 show_perm32(pri, &semds.sem_perm);
2454
2455 (void) printf("%s\tnsems=%u\n",
2456 pri->pname,
2457 semds.sem_nsems);
2458
2459 prtime(pri, " ot = ", semds.sem_otime);
2460 prtime(pri, " ct = ", semds.sem_ctime);
2461 }
2462 }
2463 #endif /* _LP64 */
2464
2465 void
2466 show_semop(private_t *pri, long offset, long nsops, long timeout)
2467 {
2468 struct sembuf sembuf;
2469 const char *str;
2470
2471 if (offset == 0)
2472 return;
2473
2474 if (nsops > 40) /* let's not be ridiculous */
2475 nsops = 40;
2476
2477 for (; nsops > 0 && !interrupt; --nsops, offset += sizeof (sembuf)) {
2478 if (Pread(Proc, &sembuf, sizeof (sembuf), offset) !=
2479 sizeof (sembuf))
2480 break;
2481
2482 (void) printf("%s\tsemnum=%-5u semop=%-5d semflg=",
2483 pri->pname,
2484 sembuf.sem_num,
2485 sembuf.sem_op);
2486
2487 if (sembuf.sem_flg == 0)
2488 (void) printf("0\n");
2489 else if ((str = semflags(pri, sembuf.sem_flg)) != NULL)
2490 (void) printf("%s\n", str);
2491 else
2492 (void) printf("0%.6o\n", sembuf.sem_flg);
2493 }
2494 if (timeout)
2495 show_timestruc(pri, timeout, "timeout");
2496 }
2497
2498 void
2499 show_semsys(private_t *pri)
2500 {
2501 switch (pri->sys_args[0]) {
2502 case 0: /* semctl() */
2503 if (pri->sys_nargs > 4) {
2504 switch (pri->sys_args[3]) {
2505 case IPC_STAT:
2506 if (pri->Errno)
2507 break;
2508 /*FALLTHROUGH*/
2509 case IPC_SET:
2510 #ifdef _LP64
2511 if (data_model == PR_MODEL_LP64)
2512 show_semctl(pri,
2513 (long)pri->sys_args[4]);
2514 else
2515 show_semctl32(pri,
2516 (long)pri->sys_args[4]);
2517 #else
2518 show_semctl(pri, (long)pri->sys_args[4]);
2519 #endif
2520 break;
2521 case IPC_STAT64:
2522 if (pri->Errno)
2523 break;
2524 /*FALLTHROUGH*/
2525 case IPC_SET64:
2526 show_semctl64(pri, (long)pri->sys_args[4]);
2527 break;
2528 }
2529 }
2530 break;
2531 case 1: /* semget() */
2532 break;
2533 case 2: /* semop() */
2534 if (pri->sys_nargs > 3)
2535 show_semop(pri, (long)pri->sys_args[2],
2536 pri->sys_args[3], 0);
2537 break;
2538 case 3: /* semids() */
2539 break;
2540 case 4: /* semtimedop() */
2541 if (pri->sys_nargs > 4)
2542 show_semop(pri, (long)pri->sys_args[2],
2543 pri->sys_args[3], pri->sys_args[4]);
2544 break;
2545 default: /* unexpected subcode */
2546 break;
2547 }
2548 }
2549
2550 static void
2551 show_shmctl64(private_t *pri, long offset)
2552 {
2553 struct shmid_ds64 shmds;
2554
2555 if (offset != NULL &&
2556 Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) {
2557 show_perm64(pri, &shmds.shmx_perm);
2558
2559 (void) printf(
2560 "%s\tsize=%-6llu lpid=%-5d cpid=%-5d na=%-5llu cna=%llu\n",
2561 pri->pname,
2562 (unsigned long long)shmds.shmx_segsz,
2563 (int)shmds.shmx_lpid,
2564 (int)shmds.shmx_cpid,
2565 (unsigned long long)shmds.shmx_nattch,
2566 (unsigned long long)shmds.shmx_cnattch);
2567
2568 prtime(pri, " at = ", (time_t)shmds.shmx_atime);
2569 prtime(pri, " dt = ", (time_t)shmds.shmx_dtime);
2570 prtime(pri, " ct = ", (time_t)shmds.shmx_ctime);
2571 }
2572 }
2573
2574 void
2575 show_shmctl(private_t *pri, long offset)
2576 {
2577 struct shmid_ds shmds;
2578
2579 if (offset != NULL &&
2580 Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) {
2581 show_perm(pri, &shmds.shm_perm);
2582
2583 (void) printf(
2584 "%s\tsize=%-6lu lpid=%-5u cpid=%-5u na=%-5lu cna=%lu\n",
2585 pri->pname,
2586 (ulong_t)shmds.shm_segsz,
2587 (int)shmds.shm_lpid,
2588 (int)shmds.shm_cpid,
2589 shmds.shm_nattch,
2590 shmds.shm_cnattch);
2591
2592 prtime(pri, " at = ", shmds.shm_atime);
2593 prtime(pri, " dt = ", shmds.shm_dtime);
2594 prtime(pri, " ct = ", shmds.shm_ctime);
2595 }
2596 }
2597
2598 #ifdef _LP64
2599 void
2600 show_shmctl32(private_t *pri, long offset)
2601 {
2602 struct shmid_ds32 shmds;
2603
2604 if (offset != NULL &&
2605 Pread(Proc, &shmds, sizeof (shmds), offset) == sizeof (shmds)) {
2606 show_perm32(pri, &shmds.shm_perm);
2607
2608 (void) printf(
2609 "%s\tsize=%-6u lpid=%-5u cpid=%-5u na=%-5u cna=%u\n",
2610 pri->pname,
2611 shmds.shm_segsz,
2612 shmds.shm_lpid,
2613 shmds.shm_cpid,
2614 shmds.shm_nattch,
2615 shmds.shm_cnattch);
2616
2617 prtime(pri, " at = ", shmds.shm_atime);
2618 prtime(pri, " dt = ", shmds.shm_dtime);
2619 prtime(pri, " ct = ", shmds.shm_ctime);
2620 }
2621 }
2622 #endif /* _LP64 */
2623
2624 void
2625 show_shmsys(private_t *pri)
2626 {
2627 switch (pri->sys_args[0]) {
2628 case 0: /* shmat() */
2629 break;
2630 case 1: /* shmctl() */
2631 if (pri->sys_nargs > 3) {
2632 switch (pri->sys_args[2]) {
2633 case IPC_STAT:
2634 if (pri->Errno)
2635 break;
2636 /*FALLTHROUGH*/
2637 case IPC_SET:
2638 #ifdef _LP64
2639 if (data_model == PR_MODEL_LP64)
2640 show_shmctl(pri,
2641 (long)pri->sys_args[3]);
2642 else
2643 show_shmctl32(pri,
2644 (long)pri->sys_args[3]);
2645 #else
2646 show_shmctl(pri, (long)pri->sys_args[3]);
2647 #endif
2648 break;
2649 case IPC_STAT64:
2650 if (pri->Errno)
2651 break;
2652 /*FALLTHROUGH*/
2653 case IPC_SET64:
2654 show_shmctl64(pri, (long)pri->sys_args[3]);
2655 break;
2656 }
2657 }
2658 break;
2659 case 2: /* shmdt() */
2660 case 3: /* shmget() */
2661 case 4: /* shmids() */
2662 default: /* unexpected subcode */
2663 break;
2664 }
2665 }
2666
2667 void
2668 show_groups(private_t *pri, long offset, long count)
2669 {
2670 int groups[100];
2671
2672 if (count > 100)
2673 count = 100;
2674
2675 if (count > 0 && offset != NULL &&
2676 Pread(Proc, &groups[0], count*sizeof (int), offset) ==
2677 count*sizeof (int)) {
2678 int n;
2679
2680 (void) printf("%s\t", pri->pname);
2681 for (n = 0; !interrupt && n < count; n++) {
2682 if (n != 0 && n%10 == 0)
2683 (void) printf("\n%s\t", pri->pname);
2684 (void) printf(" %5d", groups[n]);
2685 }
2686 (void) fputc('\n', stdout);
2687 }
2688 }
2689
2690 /*
2691 * This assumes that a sigset_t is simply an array of ints.
2692 */
2693 char *
2694 sigset_string(private_t *pri, sigset_t *sp)
2695 {
2696 char *s = pri->code_buf;
2697 int n = sizeof (*sp) / sizeof (int32_t);
2698 int32_t *lp = (int32_t *)sp;
2699
2700 while (--n >= 0) {
2701 int32_t val = *lp++;
2702
2703 if (val == 0)
2704 s += sprintf(s, " 0");
2705 else
2706 s += sprintf(s, " 0x%.8X", val);
2707 }
2708
2709 return (pri->code_buf);
2710 }
2711
2712 void
2713 show_sigset(private_t *pri, long offset, const char *name)
2714 {
2715 sigset_t sigset;
2716
2717 if (offset != NULL &&
2718 Pread(Proc, &sigset, sizeof (sigset), offset) == sizeof (sigset)) {
2719 (void) printf("%s\t%s =%s\n",
2720 pri->pname, name, sigset_string(pri, &sigset));
2721 }
2722 }
2723
2724 #ifdef _LP64
2725 void
2726 show_sigaltstack32(private_t *pri, long offset, const char *name)
2727 {
2728 struct sigaltstack32 altstack;
2729
2730 if (offset != NULL &&
2731 Pread(Proc, &altstack, sizeof (altstack), offset) ==
2732 sizeof (altstack)) {
2733 (void) printf("%s\t%s: sp=0x%.8X size=%u flags=0x%.4X\n",
2734 pri->pname,
2735 name,
2736 altstack.ss_sp,
2737 altstack.ss_size,
2738 altstack.ss_flags);
2739 }
2740 }
2741 #endif /* _LP64 */
2742
2743 void
2744 show_sigaltstack(private_t *pri, long offset, const char *name)
2745 {
2746 struct sigaltstack altstack;
2747
2748 #ifdef _LP64
2749 if (data_model != PR_MODEL_LP64) {
2750 show_sigaltstack32(pri, offset, name);
2751 return;
2752 }
2753 #endif
2754 if (offset != NULL &&
2755 Pread(Proc, &altstack, sizeof (altstack), offset) ==
2756 sizeof (altstack)) {
2757 (void) printf("%s\t%s: sp=0x%.8lX size=%lu flags=0x%.4X\n",
2758 pri->pname,
2759 name,
2760 (ulong_t)altstack.ss_sp,
2761 (ulong_t)altstack.ss_size,
2762 altstack.ss_flags);
2763 }
2764 }
2765
2766 #ifdef _LP64
2767 void
2768 show_sigaction32(private_t *pri, long offset, const char *name, long odisp)
2769 {
2770 struct sigaction32 sigaction;
2771
2772 if (offset != NULL &&
2773 Pread(Proc, &sigaction, sizeof (sigaction), offset) ==
2774 sizeof (sigaction)) {
2775 /* This is stupid, we shouldn't have to do this */
2776 if (odisp != NULL)
2777 sigaction.sa_handler = (caddr32_t)odisp;
2778 (void) printf(
2779 "%s %s: hand = 0x%.8X mask =%s flags = 0x%.4X\n",
2780 pri->pname,
2781 name,
2782 sigaction.sa_handler,
2783 sigset_string(pri, (sigset_t *)&sigaction.sa_mask),
2784 sigaction.sa_flags);
2785 }
2786 }
2787 #endif /* _LP64 */
2788
2789 void
2790 show_sigaction(private_t *pri, long offset, const char *name, long odisp)
2791 {
2792 struct sigaction sigaction;
2793
2794 #ifdef _LP64
2795 if (data_model != PR_MODEL_LP64) {
2796 show_sigaction32(pri, offset, name, odisp);
2797 return;
2798 }
2799 #endif
2800 if (offset != NULL &&
2801 Pread(Proc, &sigaction, sizeof (sigaction), offset) ==
2802 sizeof (sigaction)) {
2803 /* This is stupid, we shouldn't have to do this */
2804 if (odisp != NULL)
2805 sigaction.sa_handler = (void (*)())odisp;
2806 (void) printf(
2807 "%s %s: hand = 0x%.8lX mask =%s flags = 0x%.4X\n",
2808 pri->pname,
2809 name,
2810 (long)sigaction.sa_handler,
2811 sigset_string(pri, &sigaction.sa_mask),
2812 sigaction.sa_flags);
2813 }
2814 }
2815
2816 #ifdef _LP64
2817 void
2818 print_siginfo32(private_t *pri, const siginfo32_t *sip)
2819 {
2820 const char *code = NULL;
2821
2822 (void) printf("%s siginfo: %s", pri->pname,
2823 signame(pri, sip->si_signo));
2824
2825 if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) {
2826 (void) printf(" pid=%d uid=%d", sip->si_pid, sip->si_uid);
2827 if (sip->si_code != 0)
2828 (void) printf(" code=%d", sip->si_code);
2829 (void) fputc('\n', stdout);
2830 return;
2831 }
2832
2833 switch (sip->si_signo) {
2834 default:
2835 (void) fputc('\n', stdout);
2836 return;
2837 case SIGILL:
2838 case SIGTRAP:
2839 case SIGFPE:
2840 case SIGSEGV:
2841 case SIGBUS:
2842 case SIGEMT:
2843 case SIGCLD:
2844 case SIGPOLL:
2845 case SIGXFSZ:
2846 break;
2847 }
2848
2849 switch (sip->si_signo) {
2850 case SIGILL:
2851 switch (sip->si_code) {
2852 case ILL_ILLOPC: code = "ILL_ILLOPC"; break;
2853 case ILL_ILLOPN: code = "ILL_ILLOPN"; break;
2854 case ILL_ILLADR: code = "ILL_ILLADR"; break;
2855 case ILL_ILLTRP: code = "ILL_ILLTRP"; break;
2856 case ILL_PRVOPC: code = "ILL_PRVOPC"; break;
2857 case ILL_PRVREG: code = "ILL_PRVREG"; break;
2858 case ILL_COPROC: code = "ILL_COPROC"; break;
2859 case ILL_BADSTK: code = "ILL_BADSTK"; break;
2860 }
2861 break;
2862 case SIGTRAP:
2863 switch (sip->si_code) {
2864 case TRAP_BRKPT: code = "TRAP_BRKPT"; break;
2865 case TRAP_TRACE: code = "TRAP_TRACE"; break;
2866 case TRAP_RWATCH: code = "TRAP_RWATCH"; break;
2867 case TRAP_WWATCH: code = "TRAP_WWATCH"; break;
2868 case TRAP_XWATCH: code = "TRAP_XWATCH"; break;
2869 case TRAP_DTRACE: code = "TRAP_DTRACE"; break;
2870 }
2871 break;
2872 case SIGFPE:
2873 switch (sip->si_code) {
2874 case FPE_INTDIV: code = "FPE_INTDIV"; break;
2875 case FPE_INTOVF: code = "FPE_INTOVF"; break;
2876 case FPE_FLTDIV: code = "FPE_FLTDIV"; break;
2877 case FPE_FLTOVF: code = "FPE_FLTOVF"; break;
2878 case FPE_FLTUND: code = "FPE_FLTUND"; break;
2879 case FPE_FLTRES: code = "FPE_FLTRES"; break;
2880 case FPE_FLTINV: code = "FPE_FLTINV"; break;
2881 case FPE_FLTSUB: code = "FPE_FLTSUB"; break;
2882 #if defined(FPE_FLTDEN)
2883 case FPE_FLTDEN: code = "FPE_FLTDEN"; break;
2884 #endif
2885 }
2886 break;
2887 case SIGSEGV:
2888 switch (sip->si_code) {
2889 case SEGV_MAPERR: code = "SEGV_MAPERR"; break;
2890 case SEGV_ACCERR: code = "SEGV_ACCERR"; break;
2891 }
2892 break;
2893 case SIGEMT:
2894 switch (sip->si_code) {
2895 #ifdef EMT_TAGOVF
2896 case EMT_TAGOVF: code = "EMT_TAGOVF"; break;
2897 #endif
2898 case EMT_CPCOVF: code = "EMT_CPCOVF"; break;
2899 }
2900 break;
2901 case SIGBUS:
2902 switch (sip->si_code) {
2903 case BUS_ADRALN: code = "BUS_ADRALN"; break;
2904 case BUS_ADRERR: code = "BUS_ADRERR"; break;
2905 case BUS_OBJERR: code = "BUS_OBJERR"; break;
2906 }
2907 break;
2908 case SIGCLD:
2909 switch (sip->si_code) {
2910 case CLD_EXITED: code = "CLD_EXITED"; break;
2911 case CLD_KILLED: code = "CLD_KILLED"; break;
2912 case CLD_DUMPED: code = "CLD_DUMPED"; break;
2913 case CLD_TRAPPED: code = "CLD_TRAPPED"; break;
2914 case CLD_STOPPED: code = "CLD_STOPPED"; break;
2915 case CLD_CONTINUED: code = "CLD_CONTINUED"; break;
2916 }
2917 break;
2918 case SIGPOLL:
2919 switch (sip->si_code) {
2920 case POLL_IN: code = "POLL_IN"; break;
2921 case POLL_OUT: code = "POLL_OUT"; break;
2922 case POLL_MSG: code = "POLL_MSG"; break;
2923 case POLL_ERR: code = "POLL_ERR"; break;
2924 case POLL_PRI: code = "POLL_PRI"; break;
2925 case POLL_HUP: code = "POLL_HUP"; break;
2926 }
2927 break;
2928 }
2929
2930 if (code == NULL) {
2931 (void) sprintf(pri->code_buf, "code=%d", sip->si_code);
2932 code = (const char *)pri->code_buf;
2933 }
2934
2935 switch (sip->si_signo) {
2936 case SIGILL:
2937 case SIGTRAP:
2938 case SIGFPE:
2939 case SIGSEGV:
2940 case SIGBUS:
2941 case SIGEMT:
2942 (void) printf(" %s addr=0x%.8X",
2943 code,
2944 sip->si_addr);
2945 break;
2946 case SIGCLD:
2947 (void) printf(" %s pid=%d status=0x%.4X",
2948 code,
2949 sip->si_pid,
2950 sip->si_status);
2951 break;
2952 case SIGPOLL:
2953 case SIGXFSZ:
2954 (void) printf(" %s fd=%d band=%d",
2955 code,
2956 sip->si_fd,
2957 sip->si_band);
2958 break;
2959 }
2960
2961 if (sip->si_errno != 0) {
2962 const char *ename = errname(sip->si_errno);
2963
2964 (void) printf(" errno=%d", sip->si_errno);
2965 if (ename != NULL)
2966 (void) printf("(%s)", ename);
2967 }
2968
2969 (void) fputc('\n', stdout);
2970 }
2971 #endif /* _LP64 */
2972
2973 void
2974 print_siginfo(private_t *pri, const siginfo_t *sip)
2975 {
2976 const char *code = NULL;
2977
2978 (void) printf("%s siginfo: %s", pri->pname,
2979 signame(pri, sip->si_signo));
2980
2981 if (sip->si_signo != 0 && SI_FROMUSER(sip) && sip->si_pid != 0) {
2982 (void) printf(" pid=%d uid=%u",
2983 (int)sip->si_pid,
2984 sip->si_uid);
2985 if (sip->si_code != 0)
2986 (void) printf(" code=%d", sip->si_code);
2987 (void) fputc('\n', stdout);
2988 return;
2989 }
2990
2991 switch (sip->si_signo) {
2992 default:
2993 (void) fputc('\n', stdout);
2994 return;
2995 case SIGILL:
2996 case SIGTRAP:
2997 case SIGFPE:
2998 case SIGSEGV:
2999 case SIGBUS:
3000 case SIGEMT:
3001 case SIGCLD:
3002 case SIGPOLL:
3003 case SIGXFSZ:
3004 break;
3005 }
3006
3007 switch (sip->si_signo) {
3008 case SIGILL:
3009 switch (sip->si_code) {
3010 case ILL_ILLOPC: code = "ILL_ILLOPC"; break;
3011 case ILL_ILLOPN: code = "ILL_ILLOPN"; break;
3012 case ILL_ILLADR: code = "ILL_ILLADR"; break;
3013 case ILL_ILLTRP: code = "ILL_ILLTRP"; break;
3014 case ILL_PRVOPC: code = "ILL_PRVOPC"; break;
3015 case ILL_PRVREG: code = "ILL_PRVREG"; break;
3016 case ILL_COPROC: code = "ILL_COPROC"; break;
3017 case ILL_BADSTK: code = "ILL_BADSTK"; break;
3018 }
3019 break;
3020 case SIGTRAP:
3021 switch (sip->si_code) {
3022 case TRAP_BRKPT: code = "TRAP_BRKPT"; break;
3023 case TRAP_TRACE: code = "TRAP_TRACE"; break;
3024 case TRAP_RWATCH: code = "TRAP_RWATCH"; break;
3025 case TRAP_WWATCH: code = "TRAP_WWATCH"; break;
3026 case TRAP_XWATCH: code = "TRAP_XWATCH"; break;
3027 case TRAP_DTRACE: code = "TRAP_DTRACE"; break;
3028 }
3029 break;
3030 case SIGFPE:
3031 switch (sip->si_code) {
3032 case FPE_INTDIV: code = "FPE_INTDIV"; break;
3033 case FPE_INTOVF: code = "FPE_INTOVF"; break;
3034 case FPE_FLTDIV: code = "FPE_FLTDIV"; break;
3035 case FPE_FLTOVF: code = "FPE_FLTOVF"; break;
3036 case FPE_FLTUND: code = "FPE_FLTUND"; break;
3037 case FPE_FLTRES: code = "FPE_FLTRES"; break;
3038 case FPE_FLTINV: code = "FPE_FLTINV"; break;
3039 case FPE_FLTSUB: code = "FPE_FLTSUB"; break;
3040 #if defined(FPE_FLTDEN)
3041 case FPE_FLTDEN: code = "FPE_FLTDEN"; break;
3042 #endif
3043 }
3044 break;
3045 case SIGSEGV:
3046 switch (sip->si_code) {
3047 case SEGV_MAPERR: code = "SEGV_MAPERR"; break;
3048 case SEGV_ACCERR: code = "SEGV_ACCERR"; break;
3049 }
3050 break;
3051 case SIGEMT:
3052 switch (sip->si_code) {
3053 #ifdef EMT_TAGOVF
3054 case EMT_TAGOVF: code = "EMT_TAGOVF"; break;
3055 #endif
3056 case EMT_CPCOVF: code = "EMT_CPCOVF"; break;
3057 }
3058 break;
3059 case SIGBUS:
3060 switch (sip->si_code) {
3061 case BUS_ADRALN: code = "BUS_ADRALN"; break;
3062 case BUS_ADRERR: code = "BUS_ADRERR"; break;
3063 case BUS_OBJERR: code = "BUS_OBJERR"; break;
3064 }
3065 break;
3066 case SIGCLD:
3067 switch (sip->si_code) {
3068 case CLD_EXITED: code = "CLD_EXITED"; break;
3069 case CLD_KILLED: code = "CLD_KILLED"; break;
3070 case CLD_DUMPED: code = "CLD_DUMPED"; break;
3071 case CLD_TRAPPED: code = "CLD_TRAPPED"; break;
3072 case CLD_STOPPED: code = "CLD_STOPPED"; break;
3073 case CLD_CONTINUED: code = "CLD_CONTINUED"; break;
3074 }
3075 break;
3076 case SIGPOLL:
3077 switch (sip->si_code) {
3078 case POLL_IN: code = "POLL_IN"; break;
3079 case POLL_OUT: code = "POLL_OUT"; break;
3080 case POLL_MSG: code = "POLL_MSG"; break;
3081 case POLL_ERR: code = "POLL_ERR"; break;
3082 case POLL_PRI: code = "POLL_PRI"; break;
3083 case POLL_HUP: code = "POLL_HUP"; break;
3084 }
3085 break;
3086 }
3087
3088 if (code == NULL) {
3089 (void) sprintf(pri->code_buf, "code=%d", sip->si_code);
3090 code = (const char *)pri->code_buf;
3091 }
3092
3093 switch (sip->si_signo) {
3094 case SIGILL:
3095 case SIGTRAP:
3096 case SIGFPE:
3097 case SIGSEGV:
3098 case SIGBUS:
3099 case SIGEMT:
3100 (void) printf(" %s addr=0x%.8lX",
3101 code,
3102 (long)sip->si_addr);
3103 break;
3104 case SIGCLD:
3105 (void) printf(" %s pid=%d status=0x%.4X",
3106 code,
3107 (int)sip->si_pid,
3108 sip->si_status);
3109 break;
3110 case SIGPOLL:
3111 case SIGXFSZ:
3112 (void) printf(" %s fd=%d band=%ld",
3113 code,
3114 sip->si_fd,
3115 sip->si_band);
3116 break;
3117 }
3118
3119 if (sip->si_errno != 0) {
3120 const char *ename = errname(sip->si_errno);
3121
3122 (void) printf(" errno=%d", sip->si_errno);
3123 if (ename != NULL)
3124 (void) printf("(%s)", ename);
3125 }
3126
3127 (void) fputc('\n', stdout);
3128 }
3129
3130 #ifdef _LP64
3131 void
3132 show_siginfo32(private_t *pri, long offset)
3133 {
3134 struct siginfo32 siginfo;
3135
3136 if (offset != NULL &&
3137 Pread(Proc, &siginfo, sizeof (siginfo), offset) == sizeof (siginfo))
3138 print_siginfo32(pri, &siginfo);
3139 }
3140 #endif /* _LP64 */
3141
3142 void
3143 show_siginfo(private_t *pri, long offset)
3144 {
3145 struct siginfo siginfo;
3146
3147 #ifdef _LP64
3148 if (data_model != PR_MODEL_LP64) {
3149 show_siginfo32(pri, offset);
3150 return;
3151 }
3152 #endif
3153 if (offset != NULL &&
3154 Pread(Proc, &siginfo, sizeof (siginfo), offset) == sizeof (siginfo))
3155 print_siginfo(pri, &siginfo);
3156 }
3157
3158 void
3159 show_bool(private_t *pri, long offset, int count)
3160 {
3161 int serial = (count > MYBUFSIZ / 4);
3162
3163 /* enter region of lengthy output */
3164 if (serial)
3165 Eserialize();
3166
3167 while (count > 0) {
3168 char buf[32];
3169 int nb = (count < 32)? count : 32;
3170 int i;
3171
3172 if (Pread(Proc, buf, (size_t)nb, offset) != nb)
3173 break;
3174
3175 (void) printf("%s ", pri->pname);
3176 for (i = 0; i < nb; i++)
3177 (void) printf(" %d", buf[i]);
3178 (void) fputc('\n', stdout);
3179
3180 count -= nb;
3181 offset += nb;
3182 }
3183
3184 /* exit region of lengthy output */
3185 if (serial)
3186 Xserialize();
3187 }
3188
3189 #ifdef _LP64
3190 void
3191 show_iovec32(private_t *pri, long offset, int niov, int showbuf, long count)
3192 {
3193 iovec32_t iovec[16];
3194 iovec32_t *ip;
3195 long nb;
3196 int serial = (count > MYBUFSIZ / 4 && showbuf);
3197
3198 if (niov > 16) /* is this the real limit? */
3199 niov = 16;
3200
3201 if (offset != NULL && niov > 0 &&
3202 Pread(Proc, &iovec[0], niov*sizeof (iovec32_t), offset)
3203 == niov*sizeof (iovec32_t)) {
3204 /* enter region of lengthy output */
3205 if (serial)
3206 Eserialize();
3207
3208 for (ip = &iovec[0]; niov-- && !interrupt; ip++) {
3209 (void) printf("%s\tiov_base = 0x%.8X iov_len = %d\n",
3210 pri->pname,
3211 ip->iov_base,
3212 ip->iov_len);
3213 if ((nb = count) > 0) {
3214 if (nb > ip->iov_len)
3215 nb = ip->iov_len;
3216 if (nb > 0)
3217 count -= nb;
3218 }
3219 if (showbuf && nb > 0)
3220 showbuffer(pri, (long)ip->iov_base, nb);
3221 }
3222
3223 /* exit region of lengthy output */
3224 if (serial)
3225 Xserialize();
3226 }
3227 }
3228 #endif /* _LP64 */
3229
3230 void
3231 show_iovec(private_t *pri, long offset, long niov, int showbuf, long count)
3232 {
3233 iovec_t iovec[16];
3234 iovec_t *ip;
3235 long nb;
3236 int serial = (count > MYBUFSIZ / 4 && showbuf);
3237
3238 #ifdef _LP64
3239 if (data_model != PR_MODEL_LP64) {
3240 show_iovec32(pri, offset, niov, showbuf, count);
3241 return;
3242 }
3243 #endif
3244 if (niov > 16) /* is this the real limit? */
3245 niov = 16;
3246
3247 if (offset != NULL && niov > 0 &&
3248 Pread(Proc, &iovec[0], niov*sizeof (iovec_t), offset)
3249 == niov*sizeof (iovec_t)) {
3250 /* enter region of lengthy output */
3251 if (serial)
3252 Eserialize();
3253
3254 for (ip = &iovec[0]; niov-- && !interrupt; ip++) {
3255 (void) printf("%s\tiov_base = 0x%.8lX iov_len = %lu\n",
3256 pri->pname,
3257 (long)ip->iov_base,
3258 ip->iov_len);
3259 if ((nb = count) > 0) {
3260 if (nb > ip->iov_len)
3261 nb = ip->iov_len;
3262 if (nb > 0)
3263 count -= nb;
3264 }
3265 if (showbuf && nb > 0)
3266 showbuffer(pri, (long)ip->iov_base, nb);
3267 }
3268
3269 /* exit region of lengthy output */
3270 if (serial)
3271 Xserialize();
3272 }
3273 }
3274
3275 void
3276 show_dents32(private_t *pri, long offset, long count)
3277 {
3278 long buf[MYBUFSIZ / sizeof (long)];
3279 struct dirent32 *dp;
3280 int serial = (count > 100);
3281
3282 if (offset == 0)
3283 return;
3284
3285 /* enter region of lengthy output */
3286 if (serial)
3287 Eserialize();
3288
3289 while (count > 0 && !interrupt) {
3290 int nb = count < MYBUFSIZ? (int)count : MYBUFSIZ;
3291
3292 if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) <= 0)
3293 break;
3294
3295 dp = (struct dirent32 *)&buf[0];
3296 if (nb < (int)(dp->d_name - (char *)dp))
3297 break;
3298 if ((unsigned)nb < dp->d_reclen) {
3299 /* getdents() error? */
3300 (void) printf(
3301 "%s ino=%-5u off=%-4d rlen=%-3d\n",
3302 pri->pname,
3303 dp->d_ino,
3304 dp->d_off,
3305 dp->d_reclen);
3306 break;
3307 }
3308
3309 while (!interrupt &&
3310 nb >= (int)(dp->d_name - (char *)dp) &&
3311 (unsigned)nb >= dp->d_reclen) {
3312 (void) printf(
3313 "%s ino=%-5u off=%-4d rlen=%-3d \"%.*s\"\n",
3314 pri->pname,
3315 dp->d_ino,
3316 dp->d_off,
3317 dp->d_reclen,
3318 dp->d_reclen - (int)(dp->d_name - (char *)dp),
3319 dp->d_name);
3320 nb -= dp->d_reclen;
3321 count -= dp->d_reclen;
3322 offset += dp->d_reclen;
3323 /* LINTED improper alignment */
3324 dp = (struct dirent32 *)((char *)dp + dp->d_reclen);
3325 }
3326 }
3327
3328 /* exit region of lengthy output */
3329 if (serial)
3330 Xserialize();
3331 }
3332
3333 void
3334 show_dents64(private_t *pri, long offset, long count)
3335 {
3336 long long buf[MYBUFSIZ / sizeof (long long)];
3337 struct dirent64 *dp;
3338 int serial = (count > 100);
3339
3340 if (offset == 0)
3341 return;
3342
3343 /* enter region of lengthy output */
3344 if (serial)
3345 Eserialize();
3346
3347 while (count > 0 && !interrupt) {
3348 int nb = count < MYBUFSIZ? (int)count : MYBUFSIZ;
3349
3350 if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) <= 0)
3351 break;
3352
3353 dp = (struct dirent64 *)&buf[0];
3354 if (nb < (int)(dp->d_name - (char *)dp))
3355 break;
3356 if ((unsigned)nb < dp->d_reclen) {
3357 /* getdents() error? */
3358 (void) printf(
3359 "%s ino=%-5llu off=%-4lld rlen=%-3d\n",
3360 pri->pname,
3361 (long long)dp->d_ino,
3362 (long long)dp->d_off,
3363 dp->d_reclen);
3364 break;
3365 }
3366
3367 while (!interrupt &&
3368 nb >= (int)(dp->d_name - (char *)dp) &&
3369 (unsigned)nb >= dp->d_reclen) {
3370 (void) printf(
3371 "%s ino=%-5llu off=%-4lld rlen=%-3d \"%.*s\"\n",
3372 pri->pname,
3373 (long long)dp->d_ino,
3374 (long long)dp->d_off,
3375 dp->d_reclen,
3376 dp->d_reclen - (int)(dp->d_name - (char *)dp),
3377 dp->d_name);
3378 nb -= dp->d_reclen;
3379 count -= dp->d_reclen;
3380 offset += dp->d_reclen;
3381 /* LINTED improper alignment */
3382 dp = (struct dirent64 *)((char *)dp + dp->d_reclen);
3383 }
3384 }
3385
3386 /* exit region of lengthy output */
3387 if (serial)
3388 Xserialize();
3389 }
3390
3391 void
3392 show_rlimit32(private_t *pri, long offset)
3393 {
3394 struct rlimit32 rlimit;
3395
3396 if (offset != NULL &&
3397 Pread(Proc, &rlimit, sizeof (rlimit), offset) == sizeof (rlimit)) {
3398 (void) printf("%s\t", pri->pname);
3399 switch (rlimit.rlim_cur) {
3400 case RLIM32_INFINITY:
3401 (void) fputs("cur = RLIM_INFINITY", stdout);
3402 break;
3403 case RLIM32_SAVED_MAX:
3404 (void) fputs("cur = RLIM_SAVED_MAX", stdout);
3405 break;
3406 case RLIM32_SAVED_CUR:
3407 (void) fputs("cur = RLIM_SAVED_CUR", stdout);
3408 break;
3409 default:
3410 (void) printf("cur = %lu", (long)rlimit.rlim_cur);
3411 break;
3412 }
3413 switch (rlimit.rlim_max) {
3414 case RLIM32_INFINITY:
3415 (void) fputs(" max = RLIM_INFINITY\n", stdout);
3416 break;
3417 case RLIM32_SAVED_MAX:
3418 (void) fputs(" max = RLIM_SAVED_MAX\n", stdout);
3419 break;
3420 case RLIM32_SAVED_CUR:
3421 (void) fputs(" max = RLIM_SAVED_CUR\n", stdout);
3422 break;
3423 default:
3424 (void) printf(" max = %lu\n", (long)rlimit.rlim_max);
3425 break;
3426 }
3427 }
3428 }
3429
3430 void
3431 show_rlimit64(private_t *pri, long offset)
3432 {
3433 struct rlimit64 rlimit;
3434
3435 if (offset != NULL &&
3436 Pread(Proc, &rlimit, sizeof (rlimit), offset) == sizeof (rlimit)) {
3437 (void) printf("%s\t", pri->pname);
3438 switch (rlimit.rlim_cur) {
3439 case RLIM64_INFINITY:
3440 (void) fputs("cur = RLIM64_INFINITY", stdout);
3441 break;
3442 case RLIM64_SAVED_MAX:
3443 (void) fputs("cur = RLIM64_SAVED_MAX", stdout);
3444 break;
3445 case RLIM64_SAVED_CUR:
3446 (void) fputs("cur = RLIM64_SAVED_CUR", stdout);
3447 break;
3448 default:
3449 (void) printf("cur = %llu",
3450 (unsigned long long)rlimit.rlim_cur);
3451 break;
3452 }
3453 switch (rlimit.rlim_max) {
3454 case RLIM64_INFINITY:
3455 (void) fputs(" max = RLIM64_INFINITY\n", stdout);
3456 break;
3457 case RLIM64_SAVED_MAX:
3458 (void) fputs(" max = RLIM64_SAVED_MAX\n", stdout);
3459 break;
3460 case RLIM64_SAVED_CUR:
3461 (void) fputs(" max = RLIM64_SAVED_CUR\n", stdout);
3462 break;
3463 default:
3464 (void) printf(" max = %llu\n",
3465 (unsigned long long)rlimit.rlim_max);
3466 break;
3467 }
3468 }
3469 }
3470
3471 void
3472 show_nuname(private_t *pri, long offset)
3473 {
3474 struct utsname ubuf;
3475
3476 if (offset != NULL &&
3477 Pread(Proc, &ubuf, sizeof (ubuf), offset) == sizeof (ubuf)) {
3478 (void) printf(
3479 "%s\tsys=%s nod=%s rel=%s ver=%s mch=%s\n",
3480 pri->pname,
3481 ubuf.sysname,
3482 ubuf.nodename,
3483 ubuf.release,
3484 ubuf.version,
3485 ubuf.machine);
3486 }
3487 }
3488
3489 void
3490 show_adjtime(private_t *pri, long off1, long off2)
3491 {
3492 show_timeval(pri, off1, " delta");
3493 show_timeval(pri, off2, "olddelta");
3494 }
3495
3496 void
3497 show_sockaddr(private_t *pri,
3498 const char *str, long addroff, long lenoff, long len)
3499 {
3500 /*
3501 * A buffer large enough for PATH_MAX size AF_UNIX address, which is
3502 * also large enough to store a sockaddr_in or a sockaddr_in6.
3503 */
3504 long buf[(sizeof (short) + PATH_MAX + sizeof (long) - 1)
3505 / sizeof (long)];
3506 struct sockaddr *sa = (struct sockaddr *)buf;
3507 struct sockaddr_in *sin = (struct sockaddr_in *)buf;
3508 struct sockaddr_un *soun = (struct sockaddr_un *)buf;
3509 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)buf;
3510 char addrbuf[INET6_ADDRSTRLEN];
3511
3512 if (lenoff != 0) {
3513 uint_t ilen;
3514 if (Pread(Proc, &ilen, sizeof (ilen), lenoff) != sizeof (ilen))
3515 return;
3516 len = ilen;
3517 }
3518
3519 if (len >= sizeof (buf)) /* protect against ridiculous length */
3520 len = sizeof (buf) - 1;
3521 if (Pread(Proc, buf, len, addroff) != len)
3522 return;
3523
3524 switch (sa->sa_family) {
3525 case AF_INET6:
3526 (void) printf("%s\tAF_INET6 %s = %s port = %u\n",
3527 pri->pname, str,
3528 inet_ntop(AF_INET6, &sin6->sin6_addr, addrbuf,
3529 sizeof (addrbuf)),
3530 ntohs(sin6->sin6_port));
3531 (void) printf("%s\tscope id = %u source id = 0x%x\n"
3532 "%s\tflow class = 0x%02x flow label = 0x%05x\n",
3533 pri->pname, ntohl(sin6->sin6_scope_id),
3534 ntohl(sin6->__sin6_src_id),
3535 pri->pname,
3536 ntohl((sin6->sin6_flowinfo & IPV6_FLOWINFO_TCLASS) >> 20),
3537 ntohl(sin6->sin6_flowinfo & IPV6_FLOWINFO_FLOWLABEL));
3538 break;
3539 case AF_INET:
3540 (void) printf("%s\tAF_%s %s = %s port = %u\n",
3541 pri->pname, "INET",
3542 str, inet_ntop(AF_INET, &sin->sin_addr, addrbuf,
3543 sizeof (addrbuf)), ntohs(sin->sin_port));
3544 break;
3545 case AF_UNIX:
3546 len -= sizeof (soun->sun_family);
3547 if (len >= 0) {
3548 /* Null terminate */
3549 soun->sun_path[len] = NULL;
3550 (void) printf("%s\tAF_UNIX %s = %s\n", pri->pname,
3551 str, soun->sun_path);
3552 }
3553 break;
3554 }
3555 }
3556
3557 void
3558 show_msghdr(private_t *pri, long offset)
3559 {
3560 const lwpstatus_t *Lsp = pri->lwpstat;
3561 int what = Lsp->pr_what;
3562 int err = pri->Errno;
3563 struct msghdr msg;
3564 int showbuf = FALSE;
3565 int i = pri->sys_args[0]+1;
3566 long nb = (what == SYS_recvmsg)? pri->Rval1 : 32*1024;
3567
3568 if (Pread(Proc, &msg, sizeof (msg), offset) != sizeof (msg))
3569 return;
3570
3571 if (msg.msg_name != NULL && msg.msg_namelen != 0)
3572 show_sockaddr(pri, "msg_name",
3573 (long)msg.msg_name, 0, (long)msg.msg_namelen);
3574
3575 /*
3576 * Print the iovec if the syscall was successful and the fd is
3577 * part of the set being traced.
3578 */
3579 if ((what == SYS_recvmsg && !err &&
3580 prismember(&readfd, i)) ||
3581 (what == SYS_sendmsg &&
3582 prismember(&writefd, i)))
3583 showbuf = TRUE;
3584
3585 show_iovec(pri, (long)msg.msg_iov, msg.msg_iovlen, showbuf, nb);
3586
3587 }
3588
3589 #ifdef _LP64
3590 void
3591 show_msghdr32(private_t *pri, long offset)
3592 {
3593 struct msghdr32 {
3594 caddr32_t msg_name;
3595 uint32_t msg_namelen;
3596 caddr32_t msg_iov;
3597 int32_t msg_iovlen;
3598 } msg;
3599 const lwpstatus_t *Lsp = pri->lwpstat;
3600 int what = Lsp->pr_what;
3601 int err = pri->Errno;
3602 int showbuf = FALSE;
3603 int i = pri->sys_args[0]+1;
3604 long nb = (what == SYS_recvmsg)? pri->Rval1 : 32*1024;
3605
3606 if (Pread(Proc, &msg, sizeof (msg), offset) != sizeof (msg))
3607 return;
3608
3609 if (msg.msg_name != NULL && msg.msg_namelen != 0)
3610 show_sockaddr(pri, "msg_name",
3611 (long)msg.msg_name, 0, (long)msg.msg_namelen);
3612 /*
3613 * Print the iovec if the syscall was successful and the fd is
3614 * part of the set being traced.
3615 */
3616 if ((what == SYS_recvmsg && !err &&
3617 prismember(&readfd, i)) ||
3618 (what == SYS_sendmsg &&
3619 prismember(&writefd, i)))
3620 showbuf = TRUE;
3621
3622 show_iovec32(pri, (long)msg.msg_iov, msg.msg_iovlen, showbuf, nb);
3623
3624 }
3625 #endif /* _LP64 */
3626
3627 static void
3628 show_doorargs(private_t *pri, long offset)
3629 {
3630 door_arg_t args;
3631
3632 if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
3633 (void) printf("%s\tdata_ptr=0x%lX data_size=%lu\n",
3634 pri->pname,
3635 (ulong_t)args.data_ptr,
3636 (ulong_t)args.data_size);
3637 (void) printf("%s\tdesc_ptr=0x%lX desc_num=%u\n",
3638 pri->pname,
3639 (ulong_t)args.desc_ptr,
3640 args.desc_num);
3641 (void) printf("%s\trbuf=0x%lX rsize=%lu\n",
3642 pri->pname,
3643 (ulong_t)args.rbuf,
3644 (ulong_t)args.rsize);
3645 }
3646 }
3647
3648 static void
3649 show_ucred_privsets(private_t *pri, ucred_t *uc)
3650 {
3651 int i = 0;
3652 const priv_set_t *s;
3653 priv_ptype_t sn;
3654 char *str;
3655
3656 while ((sn = priv_getsetbynum(i++)) != NULL) {
3657 s = ucred_getprivset(uc, sn);
3658
3659 if (s == NULL)
3660 continue;
3661
3662 (void) printf("%s\t%c: %s\n",
3663 pri->pname,
3664 *sn,
3665 str = priv_set_to_str(s, ',', PRIV_STR_SHORT));
3666
3667 free(str);
3668 }
3669 }
3670
3671 static void
3672 show_ucred(private_t *pri, long offset)
3673 {
3674 ucred_t *uc = _ucred_alloc();
3675 size_t sz;
3676
3677 if (uc == NULL)
3678 return;
3679
3680 sz = Pread(Proc, uc, uc->uc_size, offset);
3681
3682 /*
3683 * A new uc_size is read, it could be smaller than the previously
3684 * value. We accept short reads that fill the whole header.
3685 */
3686 if (sz >= sizeof (ucred_t) && sz >= uc->uc_size) {
3687 (void) printf("%s\teuid=%u egid=%u\n",
3688 pri->pname,
3689 ucred_geteuid(uc),
3690 ucred_getegid(uc));
3691 (void) printf("%s\truid=%u rgid=%u\n",
3692 pri->pname,
3693 ucred_getruid(uc),
3694 ucred_getrgid(uc));
3695 (void) printf("%s\tpid=%d zoneid=%d\n",
3696 pri->pname,
3697 (int)ucred_getpid(uc),
3698 (int)ucred_getzoneid(uc));
3699 show_ucred_privsets(pri, uc);
3700 }
3701 ucred_free(uc);
3702 }
3703
3704 static void
3705 show_privset(private_t *pri, long offset, size_t size, char *label)
3706 {
3707 priv_set_t *tmp = priv_allocset();
3708 size_t sz;
3709
3710 if (tmp == NULL)
3711 return;
3712
3713 sz = Pread(Proc, tmp, size, offset);
3714
3715 if (sz == size) {
3716 char *str = priv_set_to_str(tmp, ',', PRIV_STR_SHORT);
3717 if (str != NULL) {
3718 (void) printf("%s\t%s%s\n", pri->pname, label, str);
3719 free(str);
3720 }
3721 }
3722 priv_freeset(tmp);
3723 }
3724
3725 static void
3726 show_doorinfo(private_t *pri, long offset)
3727 {
3728 door_info_t info;
3729 door_attr_t attr;
3730
3731 if (Pread(Proc, &info, sizeof (info), offset) != sizeof (info))
3732 return;
3733 (void) printf("%s\ttarget=%d proc=0x%llX data=0x%llX\n",
3734 pri->pname,
3735 (int)info.di_target,
3736 info.di_proc,
3737 info.di_data);
3738 attr = info.di_attributes;
3739 (void) printf("%s\tattributes=%s\n", pri->pname, door_flags(pri, attr));
3740 (void) printf("%s\tuniquifier=%llu\n", pri->pname, info.di_uniquifier);
3741 }
3742
3743 static void
3744 show_doorparam(private_t *pri, long offset)
3745 {
3746 ulong_t val;
3747
3748 if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) {
3749 (void) printf("%s\tvalue=%lu\n",
3750 pri->pname,
3751 val);
3752 }
3753 }
3754
3755 #ifdef _LP64
3756
3757 static void
3758 show_doorargs32(private_t *pri, long offset)
3759 {
3760 struct door_arg32 args;
3761
3762 if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
3763 (void) printf("%s\tdata_ptr=%X data_size=%u\n",
3764 pri->pname,
3765 args.data_ptr,
3766 args.data_size);
3767 (void) printf("%s\tdesc_ptr=0x%X desc_num=%u\n",
3768 pri->pname,
3769 args.desc_ptr,
3770 args.desc_num);
3771 (void) printf("%s\trbuf=0x%X rsize=%u\n",
3772 pri->pname,
3773 args.rbuf,
3774 args.rsize);
3775 }
3776 }
3777
3778 static void
3779 show_doorparam32(private_t *pri, long offset)
3780 {
3781 uint_t val;
3782
3783 if (Pread(Proc, &val, sizeof (val), offset) == sizeof (val)) {
3784 (void) printf("%s\tvalue=%u\n",
3785 pri->pname,
3786 val);
3787 }
3788 }
3789
3790 #endif /* _LP64 */
3791
3792 static void
3793 show_doors(private_t *pri)
3794 {
3795 switch (pri->sys_args[5]) {
3796 case DOOR_CALL:
3797 #ifdef _LP64
3798 if (data_model == PR_MODEL_LP64)
3799 show_doorargs(pri, (long)pri->sys_args[1]);
3800 else
3801 show_doorargs32(pri, (long)pri->sys_args[1]);
3802 #else
3803 show_doorargs(pri, (long)pri->sys_args[1]);
3804 #endif
3805 break;
3806 case DOOR_UCRED:
3807 if (!pri->Errno)
3808 show_ucred(pri, (long)pri->sys_args[0]);
3809 break;
3810 case DOOR_INFO:
3811 if (!pri->Errno)
3812 show_doorinfo(pri, (long)pri->sys_args[1]);
3813 break;
3814 case DOOR_GETPARAM:
3815 if (!pri->Errno) {
3816 #ifdef _LP64
3817 if (data_model == PR_MODEL_LP64)
3818 show_doorparam(pri, (long)pri->sys_args[2]);
3819 else
3820 show_doorparam32(pri, (long)pri->sys_args[2]);
3821 #else
3822 show_doorparam(pri, (long)pri->sys_args[2]);
3823 #endif
3824 }
3825 break;
3826 }
3827 }
3828
3829 static void
3830 show_portargs(private_t *pri, long offset)
3831 {
3832 port_event_t args;
3833
3834 if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
3835 (void) printf("%s\tevents=0x%x source=%u\n",
3836 pri->pname,
3837 args.portev_events,
3838 args.portev_source);
3839 (void) printf("%s\tobject=0x%p user=0x%p\n",
3840 pri->pname,
3841 (void *)args.portev_object,
3842 (void *)args.portev_user);
3843 }
3844 }
3845
3846
3847 #ifdef _LP64
3848
3849 static void
3850 show_portargs32(private_t *pri, long offset)
3851 {
3852 port_event32_t args;
3853
3854 if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
3855 (void) printf("%s\tevents=0x%x source=%u\n",
3856 pri->pname,
3857 args.portev_events,
3858 args.portev_source);
3859 (void) printf("%s\tobject=0x%x user=0x%x\n",
3860 pri->pname,
3861 args.portev_object,
3862 args.portev_user);
3863 }
3864 }
3865
3866 #endif /* _LP64 */
3867
3868 static void
3869 show_ports(private_t *pri)
3870 {
3871 switch (pri->sys_args[0]) {
3872 case PORT_GET:
3873 #ifdef _LP64
3874 if (data_model == PR_MODEL_LP64)
3875 show_portargs(pri, (long)pri->sys_args[2]);
3876 else
3877 show_portargs32(pri, (long)pri->sys_args[2]);
3878 #else
3879 show_portargs(pri, (long)pri->sys_args[2]);
3880 #endif
3881 break;
3882 }
3883 }
3884
3885 #define MAX_SNDFL_PRD 16
3886
3887 #ifdef _LP64
3888
3889 static void
3890 show_ksendfilevec32(private_t *pri, int fd,
3891 ksendfilevec32_t *sndvec, int sfvcnt)
3892 {
3893 ksendfilevec32_t *snd_ptr, snd[MAX_SNDFL_PRD];
3894 size_t cpy_rqst;
3895
3896 Eserialize();
3897 while (sfvcnt > 0) {
3898 cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
3899 sfvcnt -= cpy_rqst;
3900 cpy_rqst *= sizeof (snd[0]);
3901
3902 if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
3903 break;
3904
3905 snd_ptr = &snd[0];
3906
3907 while (cpy_rqst) {
3908 (void) printf(
3909 "sfv_fd=%d\tsfv_flag=0x%x\t"
3910 "sfv_off=%d\tsfv_len=%u\n",
3911 snd_ptr->sfv_fd,
3912 snd_ptr->sfv_flag,
3913 snd_ptr->sfv_off,
3914 snd_ptr->sfv_len);
3915
3916 if (snd_ptr->sfv_fd == SFV_FD_SELF &&
3917 prismember(&writefd, fd)) {
3918 showbuffer(pri,
3919 (long)snd_ptr->sfv_off & 0xffffffff,
3920 (long)snd_ptr->sfv_len);
3921 }
3922
3923 cpy_rqst -= sizeof (snd[0]);
3924 snd_ptr++;
3925 }
3926
3927 sndvec += MAX_SNDFL_PRD;
3928 }
3929 Xserialize();
3930 }
3931
3932 static void
3933 show_ksendfilevec64(private_t *pri, int fd,
3934 ksendfilevec64_t *sndvec, int sfvcnt)
3935 {
3936 ksendfilevec64_t *snd_ptr, snd[MAX_SNDFL_PRD];
3937 size_t cpy_rqst;
3938
3939 Eserialize();
3940 while (sfvcnt > 0) {
3941 cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
3942 sfvcnt -= cpy_rqst;
3943 cpy_rqst *= sizeof (snd[0]);
3944
3945 if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
3946 break;
3947
3948 snd_ptr = &snd[0];
3949
3950 while (cpy_rqst) {
3951 (void) printf(
3952 "sfv_fd=%d\tsfv_flag=0x%x\t"
3953 "sfv_off=%ld\tsfv_len=%u\n",
3954 snd_ptr->sfv_fd,
3955 snd_ptr->sfv_flag,
3956 snd_ptr->sfv_off,
3957 snd_ptr->sfv_len);
3958
3959 if (snd_ptr->sfv_fd == SFV_FD_SELF &&
3960 prismember(&writefd, fd)) {
3961 showbuffer(pri,
3962 (long)snd_ptr->sfv_off & 0xffffffff,
3963 (long)snd_ptr->sfv_len);
3964 }
3965
3966 cpy_rqst -= sizeof (snd[0]);
3967 snd_ptr++;
3968 }
3969
3970 sndvec += MAX_SNDFL_PRD;
3971 }
3972 Xserialize();
3973 }
3974
3975 #endif /* _LP64 */
3976
3977 /*ARGSUSED*/
3978 static void
3979 show_sendfilevec(private_t *pri, int fd, sendfilevec_t *sndvec, int sfvcnt)
3980 {
3981 sendfilevec_t *snd_ptr, snd[MAX_SNDFL_PRD];
3982 size_t cpy_rqst;
3983
3984 #ifdef _LP64
3985 if (data_model != PR_MODEL_LP64) {
3986 show_ksendfilevec32(pri, fd,
3987 (ksendfilevec32_t *)sndvec, sfvcnt);
3988 return;
3989 }
3990 #endif
3991 Eserialize();
3992 while (sfvcnt > 0) {
3993 cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
3994 sfvcnt -= cpy_rqst;
3995 cpy_rqst *= sizeof (snd[0]);
3996
3997 if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
3998 break;
3999
4000 snd_ptr = &snd[0];
4001
4002 while (cpy_rqst) {
4003 (void) printf(
4004 "sfv_fd=%d\tsfv_flag=0x%x\t"
4005 "sfv_off=%ld\tsfv_len=%lu\n",
4006 snd_ptr->sfv_fd,
4007 snd_ptr->sfv_flag,
4008 snd_ptr->sfv_off,
4009 (ulong_t)snd_ptr->sfv_len);
4010
4011 if (snd_ptr->sfv_fd == SFV_FD_SELF &&
4012 prismember(&writefd, fd)) {
4013 showbuffer(pri, (long)snd_ptr->sfv_off,
4014 (long)snd_ptr->sfv_len);
4015 }
4016
4017 cpy_rqst -= sizeof (snd[0]);
4018 snd_ptr++;
4019 }
4020
4021 sndvec += MAX_SNDFL_PRD;
4022 }
4023 Xserialize();
4024 }
4025
4026 /*ARGSUSED*/
4027 static void
4028 show_sendfilevec64(private_t *pri, int fd, sendfilevec64_t *sndvec, int sfvcnt)
4029 {
4030 sendfilevec64_t *snd_ptr, snd[MAX_SNDFL_PRD];
4031 size_t cpy_rqst;
4032
4033 #ifdef _LP64
4034 if (data_model != PR_MODEL_LP64) {
4035 show_ksendfilevec64(pri, fd,
4036 (ksendfilevec64_t *)sndvec, sfvcnt);
4037 return;
4038 }
4039 #endif
4040
4041 Eserialize();
4042 while (sfvcnt > 0) {
4043 cpy_rqst = MIN(sfvcnt, MAX_SNDFL_PRD);
4044 sfvcnt -= cpy_rqst;
4045 cpy_rqst *= sizeof (snd[0]);
4046
4047 if (Pread(Proc, snd, cpy_rqst, (uintptr_t)sndvec) != cpy_rqst)
4048 break;
4049
4050 snd_ptr = &snd[0];
4051
4052 while (cpy_rqst) {
4053 (void) printf(
4054 #ifdef _LP64
4055 "sfv_fd=%d\tsfv_flag=0x%x\t"
4056 "sfv_off=%ld\tsfv_len=%lu\n",
4057 #else
4058 "sfv_fd=%d\tsfv_flag=0x%x\t"
4059 "sfv_off=%lld\tsfv_len=%lu\n",
4060 #endif
4061 snd_ptr->sfv_fd,
4062 snd_ptr->sfv_flag,
4063 snd_ptr->sfv_off,
4064 (ulong_t)snd_ptr->sfv_len);
4065
4066 if (snd_ptr->sfv_fd == SFV_FD_SELF &&
4067 prismember(&writefd, fd)) {
4068 showbuffer(pri, (long)snd_ptr->sfv_off,
4069 (long)snd_ptr->sfv_len);
4070 }
4071
4072 cpy_rqst -= sizeof (snd[0]);
4073 snd_ptr++;
4074 }
4075
4076 sndvec += MAX_SNDFL_PRD;
4077 }
4078 Xserialize();
4079 }
4080
4081 static void
4082 show_memcntl_mha(private_t *pri, long offset)
4083 {
4084 struct memcntl_mha mha;
4085 const char *s = NULL;
4086
4087 if (Pread(Proc, &mha, sizeof (mha), offset) == sizeof (mha)) {
4088 switch (mha.mha_cmd) {
4089 case MHA_MAPSIZE_VA: s = "MHA_MAPSIZE_VA"; break;
4090 case MHA_MAPSIZE_BSSBRK: s = "MHA_MAPSIZE_BSSBRK"; break;
4091 case MHA_MAPSIZE_STACK: s = "MHA_MAPSIZE_STACK"; break;
4092 }
4093 if (s)
4094 (void) printf("%s\tmha_cmd=%s mha_flags=0x%x"
4095 " mha_pagesize=%lu\n",
4096 pri->pname, s, mha.mha_flags,
4097 (ulong_t)mha.mha_pagesize);
4098 else
4099 (void) printf("%s\tmha_cmd=0x%.8x mha_flags=0x%x"
4100 " mha_pagesize=%lu\n",
4101 pri->pname, mha.mha_cmd, mha.mha_flags,
4102 (ulong_t)mha.mha_pagesize);
4103 }
4104 }
4105
4106 #ifdef _LP64
4107
4108 static void
4109 show_memcntl_mha32(private_t *pri, long offset)
4110 {
4111 struct memcntl_mha32 mha32;
4112 const char *s = NULL;
4113
4114 if (Pread(Proc, &mha32, sizeof (mha32), offset) ==
4115 sizeof (mha32)) {
4116 switch (mha32.mha_cmd) {
4117 case MHA_MAPSIZE_VA: s = "MHA_MAPSIZE_VA"; break;
4118 case MHA_MAPSIZE_BSSBRK: s = "MHA_MAPSIZE_BSSBRK"; break;
4119 case MHA_MAPSIZE_STACK: s = "MHA_MAPSIZE_STACK"; break;
4120 }
4121 if (s)
4122 (void) printf("%s\tmha_cmd=%s mha_flags=0x%x"
4123 " mha_pagesize=%u\n",
4124 pri->pname, s, mha32.mha_flags, mha32.mha_pagesize);
4125 else
4126 (void) printf("%s\tmha_cmd=0x%.8x mha_flags=0x%x"
4127 " mha_pagesize=%u\n",
4128 pri->pname, mha32.mha_cmd, mha32.mha_flags,
4129 mha32.mha_pagesize);
4130 }
4131 }
4132
4133 #endif /* _LP64 */
4134
4135 static void
4136 show_memcntl(private_t *pri)
4137 {
4138
4139 if ((int)pri->sys_args[2] != MC_HAT_ADVISE)
4140 return;
4141 #ifdef _LP64
4142 if (data_model == PR_MODEL_LP64)
4143 show_memcntl_mha(pri, (long)pri->sys_args[3]);
4144 else
4145 show_memcntl_mha32(pri, (long)pri->sys_args[3]);
4146 #else
4147 show_memcntl_mha(pri, (long)pri->sys_args[3]);
4148 #endif
4149 }
4150
4151 void
4152 show_ids(private_t *pri, long offset, int count)
4153 {
4154 id_t buf[MYBUFSIZ / sizeof (id_t)];
4155 id_t *idp;
4156 int serial = (count > MYBUFSIZ / 48);
4157
4158 if (offset == 0)
4159 return;
4160
4161 /* enter region of lengthy output */
4162 if (serial)
4163 Eserialize();
4164
4165 while (count > 0 && !interrupt) {
4166 ssize_t nb = (count * sizeof (id_t) < MYBUFSIZ)?
4167 count * sizeof (id_t) : MYBUFSIZ;
4168
4169 if ((nb = Pread(Proc, &buf[0], (size_t)nb, offset)) < 0 ||
4170 nb < sizeof (id_t))
4171 break;
4172
4173 idp = buf;
4174 while (!interrupt && nb >= sizeof (id_t)) {
4175 (void) printf("%s\t%8d\n", pri->pname, (int)*idp);
4176 offset += sizeof (id_t);
4177 nb -= sizeof (id_t);
4178 idp++;
4179 count--;
4180 }
4181 }
4182
4183 /* exit region of lengthy output */
4184 if (serial)
4185 Xserialize();
4186 }
4187
4188 void
4189 show_ntp_gettime(private_t *pri)
4190 {
4191 struct ntptimeval ntv;
4192 long offset;
4193
4194 if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
4195 return;
4196
4197 if (data_model == PR_MODEL_NATIVE) {
4198 if (Pread(Proc, &ntv, sizeof (ntv), offset)
4199 != sizeof (ntv))
4200 return;
4201 } else {
4202 struct ntptimeval32 ntv32;
4203
4204 if (Pread(Proc, &ntv32, sizeof (ntv32), offset)
4205 != sizeof (ntv32))
4206 return;
4207
4208 TIMEVAL32_TO_TIMEVAL(&ntv.time, &ntv32.time);
4209 ntv.maxerror = ntv32.maxerror;
4210 ntv.esterror = ntv32.esterror;
4211 }
4212
4213 (void) printf("\ttime: %ld.%6.6ld sec\n",
4214 ntv.time.tv_sec, ntv.time.tv_usec);
4215 (void) printf("\tmaxerror: %11d usec\n", ntv.maxerror);
4216 (void) printf("\testerror: %11d usec\n", ntv.esterror);
4217 }
4218
4219 static char *
4220 get_timex_modes(private_t *pri, uint32_t val)
4221 {
4222 char *str = pri->code_buf;
4223 size_t used = 0;
4224
4225 *str = '\0';
4226 if (val & MOD_OFFSET)
4227 used = strlcat(str, "|MOD_OFFSET", sizeof (pri->code_buf));
4228 if (val & MOD_FREQUENCY)
4229 used = strlcat(str, "|MOD_FREQUENCY", sizeof (pri->code_buf));
4230 if (val & MOD_MAXERROR)
4231 used = strlcat(str, "|MOD_MAXERROR", sizeof (pri->code_buf));
4232 if (val & MOD_ESTERROR)
4233 used = strlcat(str, "|MOD_ESTERROR", sizeof (pri->code_buf));
4234 if (val & MOD_STATUS)
4235 used = strlcat(str, "|MOD_STATUS", sizeof (pri->code_buf));
4236 if (val & MOD_TIMECONST)
4237 used = strlcat(str, "|MOD_TIMECONST", sizeof (pri->code_buf));
4238 if (val & MOD_CLKB)
4239 used = strlcat(str, "|MOD_CLKB", sizeof (pri->code_buf));
4240 if (val & MOD_CLKA)
4241 used = strlcat(str, "|MOD_CLKA", sizeof (pri->code_buf));
4242
4243 if (used == 0 || used >= sizeof (pri->code_buf))
4244 (void) snprintf(str, sizeof (pri->code_buf), " 0x%.4x", val);
4245
4246 return (str + 1);
4247 }
4248
4249 static char *
4250 get_timex_status(private_t *pri, int32_t val)
4251 {
4252 char *str = pri->code_buf;
4253 size_t used = 0;
4254
4255 *str = '\0';
4256 if (val & STA_PLL)
4257 used = strlcat(str, "|STA_PLL", sizeof (pri->code_buf));
4258 if (val & STA_PPSFREQ)
4259 used = strlcat(str, "|STA_PPSFREQ", sizeof (pri->code_buf));
4260 if (val & STA_PPSTIME)
4261 used = strlcat(str, "|STA_PPSTIME", sizeof (pri->code_buf));
4262 if (val & STA_FLL)
4263 used = strlcat(str, "|STA_FLL", sizeof (pri->code_buf));
4264
4265 if (val & STA_INS)
4266 used = strlcat(str, "|STA_INS", sizeof (pri->code_buf));
4267 if (val & STA_DEL)
4268 used = strlcat(str, "|STA_DEL", sizeof (pri->code_buf));
4269 if (val & STA_UNSYNC)
4270 used = strlcat(str, "|STA_UNSYNC", sizeof (pri->code_buf));
4271 if (val & STA_FREQHOLD)
4272 used = strlcat(str, "|STA_FREQHOLD", sizeof (pri->code_buf));
4273
4274 if (val & STA_PPSSIGNAL)
4275 used = strlcat(str, "|STA_PPSSIGNAL", sizeof (pri->code_buf));
4276 if (val & STA_PPSJITTER)
4277 used = strlcat(str, "|STA_PPSJITTER", sizeof (pri->code_buf));
4278 if (val & STA_PPSWANDER)
4279 used = strlcat(str, "|STA_PPSWANDER", sizeof (pri->code_buf));
4280 if (val & STA_PPSERROR)
4281 used = strlcat(str, "|STA_PPSERROR", sizeof (pri->code_buf));
4282
4283 if (val & STA_CLOCKERR)
4284 used = strlcat(str, "|STA_CLOCKERR", sizeof (pri->code_buf));
4285
4286 if (used == 0 || used >= sizeof (pri->code_buf))
4287 (void) snprintf(str, sizeof (pri->code_buf), " 0x%.4x", val);
4288
4289 return (str + 1);
4290 }
4291
4292 void
4293 show_ntp_adjtime(private_t *pri)
4294 {
4295 struct timex timex;
4296 long offset;
4297
4298 if (pri->sys_nargs < 1 || (offset = pri->sys_args[0]) == NULL)
4299 return;
4300
4301 if (Pread(Proc, &timex, sizeof (timex), offset) != sizeof (timex))
4302 return;
4303
4304 (void) printf("\tmodes: %s\n", get_timex_modes(pri, timex.modes));
4305 (void) printf("\toffset: %11d usec\n", timex.offset);
4306 (void) printf("\tfreq: %11d scaled ppm\n", timex.freq);
4307 (void) printf("\tmaxerror: %11d usec\n", timex.maxerror);
4308 (void) printf("\testerror: %11d usec\n", timex.esterror);
4309 (void) printf("\tstatus: %s\n", get_timex_status(pri, timex.status));
4310 (void) printf("\tconstant: %11d\n", timex.constant);
4311 (void) printf("\tprecision: %11d usec\n", timex.precision);
4312 (void) printf("\ttolerance: %11d scaled ppm\n", timex.tolerance);
4313 (void) printf("\tppsfreq: %11d scaled ppm\n", timex.ppsfreq);
4314 (void) printf("\tjitter: %11d usec\n", timex.jitter);
4315 (void) printf("\tshift: %11d sec\n", timex.shift);
4316 (void) printf("\tstabil: %11d scaled ppm\n", timex.stabil);
4317 (void) printf("\tjitcnt: %11d\n", timex.jitcnt);
4318 (void) printf("\tcalcnt: %11d\n", timex.calcnt);
4319 (void) printf("\terrcnt: %11d\n", timex.errcnt);
4320 (void) printf("\tstbcnt: %11d\n", timex.stbcnt);
4321 }
4322
4323 void
4324 show_getrusage(long offset)
4325 {
4326 struct rusage r;
4327 if (Pread(Proc, &r, sizeof (r), offset) != sizeof (r))
4328 return;
4329 (void) printf("\t user time: %ld.%6.6ld sec\n",
4330 r.ru_utime.tv_sec,
4331 r.ru_utime.tv_usec);
4332 (void) printf("\t system time: %ld.%6.6ld sec\n",
4333 r.ru_stime.tv_sec,
4334 r.ru_stime.tv_usec);
4335 (void) printf("\t max rss: <unimpl> %ld\n",
4336 r.ru_maxrss);
4337 (void) printf("\t shared data: <unimpl> %ld\n",
4338 r.ru_ixrss);
4339 (void) printf("\t unshared data: <unimpl> %ld\n",
4340 r.ru_idrss);
4341 (void) printf("\t unshared stack: <unimpl> %ld\n",
4342 r.ru_isrss);
4343 (void) printf("\t minor faults: %ld\n",
4344 r.ru_minflt);
4345 (void) printf("\t major faults: %ld\n",
4346 r.ru_majflt);
4347 (void) printf("\t # of swaps: %ld\n",
4348 r.ru_nswap);
4349 (void) printf("\t blocked inputs: %ld\n",
4350 r.ru_inblock);
4351 (void) printf("\t blocked outputs: %ld\n",
4352 r.ru_oublock);
4353 (void) printf("\t msgs sent: %ld\n",
4354 r.ru_msgsnd);
4355 (void) printf("\t msgs rcv'd: %ld\n",
4356 r.ru_msgrcv);
4357 (void) printf("\t signals rcv'd: %ld\n",
4358 r.ru_nsignals);
4359 (void) printf("\tvol cntxt swtchs: %ld\n",
4360 r.ru_nvcsw);
4361 (void) printf("\tinv cntxt swtchs: %ld\n",
4362 r.ru_nivcsw);
4363 }
4364
4365 #ifdef _LP64
4366 void
4367 show_getrusage32(long offset)
4368 {
4369 struct rusage32 r;
4370 if (Pread(Proc, &r, sizeof (r), offset) != sizeof (r))
4371 return;
4372 (void) printf("\t user time: %d.%6.6d sec\n",
4373 r.ru_utime.tv_sec,
4374 r.ru_utime.tv_usec);
4375 (void) printf("\t system time: %d.%6.6d sec\n",
4376 r.ru_stime.tv_sec,
4377 r.ru_stime.tv_usec);
4378 (void) printf("\t max rss: <unimpl> %d\n",
4379 r.ru_maxrss);
4380 (void) printf("\t shared data: <unimpl> %d\n",
4381 r.ru_ixrss);
4382 (void) printf("\t unshared data: <unimpl> %d\n",
4383 r.ru_idrss);
4384 (void) printf("\t unshared stack: <unimpl> %d\n",
4385 r.ru_isrss);
4386 (void) printf("\t minor faults: %d\n",
4387 r.ru_minflt);
4388 (void) printf("\t major faults: %d\n",
4389 r.ru_majflt);
4390 (void) printf("\t # of swaps: %d\n",
4391 r.ru_nswap);
4392 (void) printf("\t blocked inputs: %d\n",
4393 r.ru_inblock);
4394 (void) printf("\t blocked outputs: %d\n",
4395 r.ru_oublock);
4396 (void) printf("\t msgs sent: %d\n",
4397 r.ru_msgsnd);
4398 (void) printf("\t msgs rcv'd: %d\n",
4399 r.ru_msgrcv);
4400 (void) printf("\t signals rcv'd: %d\n",
4401 r.ru_nsignals);
4402 (void) printf("\tvol cntxt swtchs: %d\n",
4403 r.ru_nvcsw);
4404 (void) printf("\tinv cntxt swtchs: %d\n",
4405 r.ru_nivcsw);
4406 }
4407 #endif
4408
4409 /*
4410 * Utility function to print a packed nvlist by unpacking
4411 * and calling the libnvpair pretty printer. Frees all
4412 * allocated memory internally.
4413 */
4414 static void
4415 show_packed_nvlist(private_t *pri, uintptr_t offset, size_t size)
4416 {
4417 nvlist_t *nvl = NULL;
4418 size_t readsize;
4419 char *buf;
4420
4421 if ((offset == 0) || (size == 0)) {
4422 return;
4423 }
4424
4425 buf = my_malloc(size, "nvlist decode buffer");
4426 readsize = Pread(Proc, buf, size, offset);
4427 if (readsize != size) {
4428 (void) printf("%s\t<?>", pri->pname);
4429 } else {
4430 int result;
4431
4432 result = nvlist_unpack(buf, size, &nvl, 0);
4433 if (result == 0) {
4434 dump_nvlist(nvl, 8);
4435 nvlist_free(nvl);
4436 } else {
4437 (void) printf("%s\tunpack of nvlist"
4438 " failed: %d\n", pri->pname, result);
4439 }
4440 }
4441 free(buf);
4442 }
4443
4444 static void
4445 show_zone_create_args(private_t *pri, long offset)
4446 {
4447 zone_def args;
4448 char zone_name[ZONENAME_MAX];
4449 char zone_root[MAXPATHLEN];
4450 char *zone_zfs = NULL;
4451
4452 if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
4453
4454 if (Pread_string(Proc, zone_name, sizeof (zone_name),
4455 (uintptr_t)args.zone_name) == -1)
4456 (void) strcpy(zone_name, "<?>");
4457
4458 if (Pread_string(Proc, zone_root, sizeof (zone_root),
4459 (uintptr_t)args.zone_root) == -1)
4460 (void) strcpy(zone_root, "<?>");
4461
4462 if (args.zfsbufsz > 0) {
4463 zone_zfs = malloc(MIN(4, args.zfsbufsz));
4464 if (zone_zfs != NULL) {
4465 if (Pread(Proc, zone_zfs, args.zfsbufsz,
4466 (uintptr_t)args.zfsbuf) == -1)
4467 (void) strcpy(zone_zfs, "<?>");
4468 }
4469 } else {
4470 zone_zfs = "";
4471 }
4472
4473 (void) printf("%s\t zone_name: %s\n", pri->pname,
4474 zone_name);
4475 (void) printf("%s\t zone_root: %s\n", pri->pname,
4476 zone_root);
4477
4478 show_privset(pri, (uintptr_t)args.zone_privs,
4479 args.zone_privssz, " zone_privs: ");
4480
4481 (void) printf("%s\t rctlbuf: 0x%p\n", pri->pname,
4482 (void *)args.rctlbuf);
4483 (void) printf("%s\t rctlbufsz: %lu\n", pri->pname,
4484 (ulong_t)args.rctlbufsz);
4485
4486 show_packed_nvlist(pri, (uintptr_t)args.rctlbuf,
4487 args.rctlbufsz);
4488
4489 (void) printf("%s\t zfs: %s\n", pri->pname, zone_zfs);
4490
4491 (void) printf("%s\textended_error: 0x%p\n", pri->pname,
4492 (void *)args.extended_error);
4493
4494 if (is_system_labeled()) {
4495 char *label_str = NULL;
4496 bslabel_t zone_label;
4497
4498 (void) printf("%s\t match: %d\n", pri->pname,
4499 args.match);
4500 (void) printf("%s\t doi: %d\n", pri->pname,
4501 args.doi);
4502
4503 if (Pread_string(Proc, (char *)&zone_label,
4504 sizeof (zone_label), (uintptr_t)args.label) != -1) {
4505 /* show the label as string */
4506 if (label_to_str(&zone_label, &label_str,
4507 M_LABEL, SHORT_NAMES) != 0) {
4508 /* have to dump label as raw string */
4509 (void) label_to_str(&zone_label,
4510 &label_str, M_INTERNAL,
4511 SHORT_NAMES);
4512 }
4513 }
4514
4515 (void) printf("%s\t label: %s\n",
4516 pri->pname, label_str != NULL ? label_str : "<?>");
4517 if (label_str)
4518 free(label_str);
4519 }
4520
4521 if (args.zfsbufsz > 0)
4522 free(zone_zfs);
4523 }
4524 }
4525
4526
4527 #ifdef _LP64
4528
4529 static void
4530 show_zone_create_args32(private_t *pri, long offset)
4531 {
4532 zone_def32 args;
4533 char zone_name[ZONENAME_MAX];
4534 char zone_root[MAXPATHLEN];
4535 char *zone_zfs = NULL;
4536
4537 if (Pread(Proc, &args, sizeof (args), offset) == sizeof (args)) {
4538
4539 if (Pread_string(Proc, zone_name, sizeof (zone_name),
4540 (uintptr_t)args.zone_name) == -1)
4541 (void) strcpy(zone_name, "<?>");
4542
4543 if (Pread_string(Proc, zone_root, sizeof (zone_root),
4544 (uintptr_t)args.zone_root) == -1)
4545 (void) strcpy(zone_root, "<?>");
4546
4547 if (args.zfsbufsz > 0) {
4548 zone_zfs = malloc(MIN(4, args.zfsbufsz));
4549 if (zone_zfs != NULL) {
4550 if (Pread(Proc, zone_zfs, args.zfsbufsz,
4551 (uintptr_t)args.zfsbuf) == -1)
4552 (void) strcpy(zone_zfs, "<?>");
4553 }
4554 } else {
4555 zone_zfs = "";
4556 }
4557
4558 (void) printf("%s\t zone_name: %s\n", pri->pname,
4559 zone_name);
4560 (void) printf("%s\t zone_root: %s\n", pri->pname,
4561 zone_root);
4562
4563 show_privset(pri, (uintptr_t)args.zone_privs,
4564 args.zone_privssz, " zone_privs: ");
4565
4566 (void) printf("%s\t rctlbuf: 0x%x\n", pri->pname,
4567 (caddr32_t)args.rctlbuf);
4568 (void) printf("%s\t rctlbufsz: %lu\n", pri->pname,
4569 (ulong_t)args.rctlbufsz);
4570
4571 show_packed_nvlist(pri, (uintptr_t)args.rctlbuf,
4572 args.rctlbufsz);
4573
4574 (void) printf("%s\t zfs: %s\n", pri->pname, zone_zfs);
4575
4576 (void) printf("%s\textended_error: 0x%x\n", pri->pname,
4577 (caddr32_t)args.extended_error);
4578
4579 if (is_system_labeled()) {
4580 char *label_str = NULL;
4581 bslabel_t zone_label;
4582
4583 (void) printf("%s\t match: %d\n", pri->pname,
4584 args.match);
4585 (void) printf("%s\t doi: %d\n", pri->pname,
4586 args.doi);
4587
4588 if (Pread_string(Proc, (char *)&zone_label,
4589 sizeof (zone_label), (caddr32_t)args.label) != -1) {
4590 /* show the label as string */
4591 if (label_to_str(&zone_label, &label_str,
4592 M_LABEL, SHORT_NAMES) != 0) {
4593 /* have to dump label as raw string */
4594 (void) label_to_str(&zone_label,
4595 &label_str, M_INTERNAL,
4596 SHORT_NAMES);
4597 }
4598 }
4599 (void) printf("%s\t label: %s\n",
4600 pri->pname, label_str != NULL ? label_str : "<?>");
4601 if (label_str)
4602 free(label_str);
4603 }
4604
4605 if (args.zfsbufsz > 0)
4606 free(zone_zfs);
4607 }
4608 }
4609
4610 #endif
4611
4612 static void
4613 show_zones(private_t *pri)
4614 {
4615 switch (pri->sys_args[0]) {
4616 case ZONE_CREATE:
4617 #ifdef _LP64
4618 if (data_model == PR_MODEL_LP64)
4619 show_zone_create_args(pri, (long)pri->sys_args[1]);
4620 else
4621 show_zone_create_args32(pri, (long)pri->sys_args[1]);
4622 #else
4623 show_zone_create_args(pri, (long)pri->sys_args[1]);
4624 #endif
4625 break;
4626 }
4627 }
4628
4629 static void
4630 show_rctlblk(private_t *pri, long _rctlblk)
4631 {
4632 rctlblk_t *blk;
4633 int size = rctlblk_size();
4634 size_t readsize;
4635 const char *s;
4636
4637 blk = my_malloc(size, "rctlblk decode buffer");
4638 readsize = Pread(Proc, blk, size, _rctlblk);
4639 if (readsize != size) {
4640 (void) printf("%s\t\t<?>", pri->pname);
4641 } else {
4642 (void) printf("%s\t\t Privilege: 0x%x\n",
4643 pri->pname,
4644 rctlblk_get_privilege(blk));
4645 (void) printf("%s\t\t Value: %lld\n",
4646 pri->pname,
4647 rctlblk_get_value(blk));
4648 (void) printf("%s\t\tEnforced Value: %lld\n",
4649 pri->pname,
4650 rctlblk_get_enforced_value(blk));
4651
4652 {
4653 int sig, act;
4654 act = rctlblk_get_local_action(blk, &sig);
4655
4656 s = rctl_local_action(pri, act);
4657 if (s == NULL) {
4658 (void) printf("%s\t\t Local action: 0x%x\n",
4659 pri->pname, act);
4660 } else {
4661 (void) printf("%s\t\t Local action: %s\n",
4662 pri->pname, s);
4663 }
4664
4665 if (act & RCTL_LOCAL_SIGNAL) {
4666 (void) printf("%s\t\t "
4667 "For signal %s\n",
4668 pri->pname, signame(pri, sig));
4669 }
4670 }
4671
4672 s = rctl_local_flags(pri, rctlblk_get_local_flags(blk));
4673 if (s == NULL) {
4674 (void) printf("%s\t\t Local flags: 0x%x\n",
4675 pri->pname, rctlblk_get_local_flags(blk));
4676 } else {
4677 (void) printf("%s\t\t Local flags: %s\n",
4678 pri->pname, s);
4679 }
4680
4681 #ifdef _LP64
4682 (void) printf("%s\t\t Recipient PID: %d\n",
4683 pri->pname,
4684 rctlblk_get_recipient_pid(blk));
4685 #else
4686 (void) printf("%s\t\t Recipient PID: %ld\n",
4687 pri->pname,
4688 rctlblk_get_recipient_pid(blk));
4689 #endif
4690 (void) printf("%s\t\t Firing Time: %lld\n",
4691 pri->pname,
4692 rctlblk_get_firing_time(blk));
4693 }
4694 free(blk);
4695 }
4696
4697 static void
4698 show_rctls(private_t *pri)
4699 {
4700 int entry;
4701
4702 switch (pri->sys_args[0]) {
4703 case 0: /* getrctl */
4704 case 1: /* setrctl */
4705 /*
4706 * If these offsets look a little odd, remember that they're
4707 * into the _raw_ system call
4708 */
4709 (void) printf("%s\tOld rctlblk: 0x%lx\n", pri->pname,
4710 pri->sys_args[2]);
4711 if (pri->sys_args[2] != NULL) {
4712 show_rctlblk(pri, pri->sys_args[2]);
4713 }
4714 (void) printf("%s\tNew rctlblk: 0x%lx\n", pri->pname,
4715 pri->sys_args[3]);
4716 if (pri->sys_args[3] != NULL) {
4717 show_rctlblk(pri, pri->sys_args[3]);
4718 }
4719 break;
4720 case 4: /* setprojrctl */
4721 for (entry = 0; entry < pri->sys_args[4]; entry++) {
4722 (void) printf("%s\tNew rctlblk[%d]: 0x%lx\n",
4723 pri->pname, entry,
4724 (long)RCTLBLK_INC(pri->sys_args[3], entry));
4725 if (RCTLBLK_INC(pri->sys_args[3], entry) != NULL) {
4726 show_rctlblk(pri,
4727 (long)RCTLBLK_INC(pri->sys_args[3], entry));
4728 }
4729 }
4730 }
4731 }
4732
4733 void
4734 show_utimesys(private_t *pri)
4735 {
4736 switch (pri->sys_args[0]) {
4737 case 0: /* futimens() */
4738 if (pri->sys_nargs > 2)
4739 show_utimens(pri, (long)pri->sys_args[2]);
4740 break;
4741 case 1: /* utimensat */
4742 if (pri->sys_nargs > 3)
4743 show_utimens(pri, (long)pri->sys_args[3]);
4744 break;
4745 default: /* unexpected subcode */
4746 break;
4747 }
4748 }
4749
4750 #ifdef _LP64
4751 static void
4752 show_sockconfig_filter_prop32(private_t *pri, long addr)
4753 {
4754 struct sockconfig_filter_props32 props;
4755 const char *s = NULL;
4756 char buf[MAX(FILNAME_MAX, MODMAXNAMELEN)];
4757 sof_socktuple32_t *tup;
4758 size_t sz;
4759 int i;
4760
4761 if (Pread(Proc, &props, sizeof (props), addr) == sizeof (props)) {
4762 if (Pread_string(Proc, buf, sizeof (buf),
4763 (uintptr_t)props.sfp_modname) == -1)
4764 (void) strcpy(buf, "<?>");
4765 (void) printf("%s\tmodule name: %s\n", pri->pname, buf);
4766 (void) printf("%s\tattach semantics: %s", pri->pname,
4767 props.sfp_autoattach ? "automatic" : "progammatic");
4768 if (props.sfp_autoattach) {
4769 buf[0] = '\0';
4770 switch (props.sfp_hint) {
4771 case SOF_HINT_TOP: s = "top"; break;
4772 case SOF_HINT_BOTTOM: s = "bottom"; break;
4773 case SOF_HINT_BEFORE:
4774 case SOF_HINT_AFTER:
4775 s = (props.sfp_hint == SOF_HINT_BEFORE) ?
4776 "before" : "after";
4777 if (Pread_string(Proc, buf, sizeof (buf),
4778 (uintptr_t)props.sfp_hintarg) == -1)
4779 (void) strcpy(buf, "<?>");
4780 }
4781 if (s != NULL) {
4782 (void) printf(", placement: %s %s", s, buf);
4783 }
4784 }
4785 (void) printf("\n");
4786 (void) printf("%s\tsocket tuples:\n", pri->pname);
4787 if (props.sfp_socktuple_cnt == 0) {
4788 (void) printf("\t\t<empty>\n");
4789 return;
4790 }
4791 sz = props.sfp_socktuple_cnt * sizeof (*tup);
4792 tup = my_malloc(sz, "socket tuple buffer");
4793 if (Pread(Proc, tup, sz, (uintptr_t)props.sfp_socktuple) == sz)
4794 for (i = 0; i < props.sfp_socktuple_cnt; i++) {
4795 (void) printf(
4796 "\t\tfamily: %d, type: %d, proto: %d\n",
4797 tup[i].sofst_family, tup[i].sofst_type,
4798 tup[i].sofst_protocol);
4799 }
4800 }
4801 }
4802 #endif /* _LP64 */
4803 static void
4804 show_sockconfig_filter_prop(private_t *pri, long addr)
4805 {
4806 struct sockconfig_filter_props props;
4807 const char *s = NULL;
4808 char buf[MAX(FILNAME_MAX, MODMAXNAMELEN)];
4809 sof_socktuple_t *tup;
4810 size_t sz;
4811 int i;
4812
4813 if (Pread(Proc, &props, sizeof (props), addr) == sizeof (props)) {
4814 if (Pread_string(Proc, buf, sizeof (buf),
4815 (uintptr_t)props.sfp_modname) == -1)
4816 (void) strcpy(buf, "<?>");
4817 (void) printf("%s\tmodule name: %s\n", pri->pname, buf);
4818 (void) printf("%s\tattach semantics: %s", pri->pname,
4819 props.sfp_autoattach ? "automatic" : "progammatic");
4820 if (props.sfp_autoattach) {
4821 buf[0] = '\0';
4822 switch (props.sfp_hint) {
4823 case SOF_HINT_TOP: s = "top"; break;
4824 case SOF_HINT_BOTTOM: s = "bottom"; break;
4825 case SOF_HINT_BEFORE:
4826 case SOF_HINT_AFTER:
4827 s = (props.sfp_hint == SOF_HINT_BEFORE) ?
4828 "before" : "after";
4829 if (Pread_string(Proc, buf, sizeof (buf),
4830 (uintptr_t)props.sfp_hintarg) == -1)
4831 (void) strcpy(buf, "<?>");
4832 }
4833 if (s != NULL) {
4834 (void) printf(", placement: %s", s);
4835 }
4836 }
4837 (void) printf("\n");
4838 (void) printf("%s\tsocket tuples:\n", pri->pname);
4839 if (props.sfp_socktuple_cnt == 0) {
4840 (void) printf("\t\t<empty>\n");
4841 return;
4842 }
4843 sz = props.sfp_socktuple_cnt * sizeof (*tup);
4844 tup = my_malloc(sz, "socket tuple buffer");
4845 if (Pread(Proc, tup, sz, (uintptr_t)props.sfp_socktuple) == sz)
4846 for (i = 0; i < props.sfp_socktuple_cnt; i++) {
4847 (void) printf(
4848 "\t\tfamily: %d, type: %d, proto: %d\n",
4849 tup[i].sofst_family, tup[i].sofst_type,
4850 tup[i].sofst_protocol);
4851 }
4852 }
4853 }
4854
4855 void
4856 show_sockconfig(private_t *pri)
4857 {
4858 switch (pri->sys_args[0]) {
4859 case SOCKCONFIG_ADD_FILTER:
4860 #ifdef _LP64
4861 if (data_model == PR_MODEL_LP64)
4862 show_sockconfig_filter_prop(pri,
4863 (long)pri->sys_args[2]);
4864 else
4865 show_sockconfig_filter_prop32(pri,
4866 (long)pri->sys_args[2]);
4867 #else
4868 show_sockconfig_filter_prop(pri, (long)pri->sys_args[2]);
4869 #endif
4870 break;
4871 default:
4872 break;
4873 }
4874 }
4875
4876 void
4877 show_zfs_ioc(private_t *pri, long addr)
4878 {
4879 static const zfs_share_t zero_share = {0};
4880 static const dmu_objset_stats_t zero_objstats = {0};
4881 static const struct drr_begin zero_drrbegin = {0};
4882 static const zinject_record_t zero_injectrec = {0};
4883 static const zfs_stat_t zero_zstat = {0};
4884 zfs_cmd_t zc;
4885
4886 if (Pread(Proc, &zc, sizeof (zc), addr) != sizeof (zc)) {
4887 (void) printf(" zfs_ioctl read failed\n");
4888 return;
4889 }
4890
4891 if (zc.zc_name[0])
4892 (void) printf(" zc_name=%s\n", zc.zc_name);
4893 if (zc.zc_value[0])
4894 (void) printf(" zc_value=%s\n", zc.zc_value);
4895 if (zc.zc_string[0])
4896 (void) printf(" zc_string=%s\n", zc.zc_string);
4897 if (zc.zc_guid != 0) {
4898 (void) printf(" zc_guid=%llu\n",
4899 (u_longlong_t)zc.zc_guid);
4900 }
4901 if (zc.zc_nvlist_conf_size) {
4902 (void) printf(" nvlist_conf:\n");
4903 show_packed_nvlist(pri, zc.zc_nvlist_conf,
4904 zc.zc_nvlist_conf_size);
4905 }
4906 if (zc.zc_nvlist_src_size) {
4907 (void) printf(" nvlist_src:\n");
4908 show_packed_nvlist(pri, zc.zc_nvlist_src,
4909 zc.zc_nvlist_src_size);
4910 }
4911 if (zc.zc_nvlist_dst_size) {
4912 (void) printf(" nvlist_dst:\n");
4913 show_packed_nvlist(pri, zc.zc_nvlist_dst,
4914 zc.zc_nvlist_dst_size);
4915 }
4916 if (zc.zc_cookie != 0) {
4917 (void) printf(" zc_cookie=%llu\n",
4918 (u_longlong_t)zc.zc_cookie);
4919 }
4920 if (zc.zc_objset_type != 0) {
4921 (void) printf(" zc_objset_type=%llu\n",
4922 (u_longlong_t)zc.zc_objset_type);
4923 }
4924 if (zc.zc_perm_action != 0) {
4925 (void) printf(" zc_perm_action=%llu\n",
4926 (u_longlong_t)zc.zc_perm_action);
4927 }
4928 if (zc.zc_history != 0) {
4929 (void) printf(" zc_history=%llu\n",
4930 (u_longlong_t)zc.zc_history);
4931 }
4932 if (zc.zc_obj != 0) {
4933 (void) printf(" zc_obj=%llu\n",
4934 (u_longlong_t)zc.zc_obj);
4935 }
4936 if (zc.zc_iflags != 0) {
4937 (void) printf(" zc_obj=0x%llx\n",
4938 (u_longlong_t)zc.zc_iflags);
4939 }
4940
4941 if (memcmp(&zc.zc_share, &zero_share, sizeof (zc.zc_share))) {
4942 zfs_share_t *z = &zc.zc_share;
4943 (void) printf(" zc_share:\n");
4944 if (z->z_exportdata) {
4945 (void) printf("\tz_exportdata=0x%llx\n",
4946 (u_longlong_t)z->z_exportdata);
4947 }
4948 if (z->z_sharedata) {
4949 (void) printf("\tz_sharedata=0x%llx\n",
4950 (u_longlong_t)z->z_sharedata);
4951 }
4952 if (z->z_sharetype) {
4953 (void) printf("\tz_sharetype=%llu\n",
4954 (u_longlong_t)z->z_sharetype);
4955 }
4956 if (z->z_sharemax) {
4957 (void) printf("\tz_sharemax=%llu\n",
4958 (u_longlong_t)z->z_sharemax);
4959 }
4960 }
4961
4962 if (memcmp(&zc.zc_objset_stats, &zero_objstats,
4963 sizeof (zc.zc_objset_stats))) {
4964 dmu_objset_stats_t *dds = &zc.zc_objset_stats;
4965 (void) printf(" zc_objset_stats:\n");
4966 if (dds->dds_num_clones) {
4967 (void) printf("\tdds_num_clones=%llu\n",
4968 (u_longlong_t)dds->dds_num_clones);
4969 }
4970 if (dds->dds_creation_txg) {
4971 (void) printf("\tdds_creation_txg=%llu\n",
4972 (u_longlong_t)dds->dds_creation_txg);
4973 }
4974 if (dds->dds_guid) {
4975 (void) printf("\tdds_guid=%llu\n",
4976 (u_longlong_t)dds->dds_guid);
4977 }
4978 if (dds->dds_type)
4979 (void) printf("\tdds_type=%u\n", dds->dds_type);
4980 if (dds->dds_is_snapshot) {
4981 (void) printf("\tdds_is_snapshot=%u\n",
4982 dds->dds_is_snapshot);
4983 }
4984 if (dds->dds_inconsistent) {
4985 (void) printf("\tdds_inconsitent=%u\n",
4986 dds->dds_inconsistent);
4987 }
4988 if (dds->dds_origin[0]) {
4989 (void) printf("\tdds_origin=%s\n", dds->dds_origin);
4990 }
4991 }
4992
4993 if (memcmp(&zc.zc_begin_record, &zero_drrbegin,
4994 sizeof (zc.zc_begin_record))) {
4995 struct drr_begin *drr = &zc.zc_begin_record.drr_u.drr_begin;
4996 (void) printf(" zc_begin_record:\n");
4997 if (drr->drr_magic) {
4998 (void) printf("\tdrr_magic=%llu\n",
4999 (u_longlong_t)drr->drr_magic);
5000 }
5001 if (drr->drr_versioninfo) {
5002 (void) printf("\tdrr_versioninfo=%llu\n",
5003 (u_longlong_t)drr->drr_versioninfo);
5004 }
5005 if (drr->drr_creation_time) {
5006 (void) printf("\tdrr_creation_time=%llu\n",
5007 (u_longlong_t)drr->drr_creation_time);
5008 }
5009 if (drr->drr_type)
5010 (void) printf("\tdrr_type=%u\n", drr->drr_type);
5011 if (drr->drr_flags)
5012 (void) printf("\tdrr_flags=0x%x\n", drr->drr_flags);
5013 if (drr->drr_toguid) {
5014 (void) printf("\tdrr_toguid=%llu\n",
5015 (u_longlong_t)drr->drr_toguid);
5016 }
5017 if (drr->drr_fromguid) {
5018 (void) printf("\tdrr_fromguid=%llu\n",
5019 (u_longlong_t)drr->drr_fromguid);
5020 }
5021 if (drr->drr_toname[0]) {
5022 (void) printf("\tdrr_toname=%s\n", drr->drr_toname);
5023 }
5024 }
5025
5026 if (memcmp(&zc.zc_inject_record, &zero_injectrec,
5027 sizeof (zc.zc_inject_record))) {
5028 zinject_record_t *zi = &zc.zc_inject_record;
5029 (void) printf(" zc_inject_record:\n");
5030 if (zi->zi_objset) {
5031 (void) printf("\tzi_objset=%llu\n",
5032 (u_longlong_t)zi->zi_objset);
5033 }
5034 if (zi->zi_object) {
5035 (void) printf("\tzi_object=%llu\n",
5036 (u_longlong_t)zi->zi_object);
5037 }
5038 if (zi->zi_start) {
5039 (void) printf("\tzi_start=%llu\n",
5040 (u_longlong_t)zi->zi_start);
5041 }
5042 if (zi->zi_end) {
5043 (void) printf("\tzi_end=%llu\n",
5044 (u_longlong_t)zi->zi_end);
5045 }
5046 if (zi->zi_guid) {
5047 (void) printf("\tzi_guid=%llu\n",
5048 (u_longlong_t)zi->zi_guid);
5049 }
5050 if (zi->zi_level) {
5051 (void) printf("\tzi_level=%lu\n",
5052 (ulong_t)zi->zi_level);
5053 }
5054 if (zi->zi_error) {
5055 (void) printf("\tzi_error=%lu\n",
5056 (ulong_t)zi->zi_error);
5057 }
5058 if (zi->zi_type) {
5059 (void) printf("\tzi_type=%llu\n",
5060 (u_longlong_t)zi->zi_type);
5061 }
5062 if (zi->zi_freq) {
5063 (void) printf("\tzi_freq=%lu\n",
5064 (ulong_t)zi->zi_freq);
5065 }
5066 if (zi->zi_failfast) {
5067 (void) printf("\tzi_failfast=%lu\n",
5068 (ulong_t)zi->zi_failfast);
5069 }
5070 if (zi->zi_func[0])
5071 (void) printf("\tzi_func=%s\n", zi->zi_func);
5072 if (zi->zi_iotype) {
5073 (void) printf("\tzi_iotype=%lu\n",
5074 (ulong_t)zi->zi_iotype);
5075 }
5076 if (zi->zi_duration) {
5077 (void) printf("\tzi_duration=%ld\n",
5078 (long)zi->zi_duration);
5079 }
5080 if (zi->zi_timer) {
5081 (void) printf("\tzi_timer=%llu\n",
5082 (u_longlong_t)zi->zi_timer);
5083 }
5084 }
5085
5086 if (zc.zc_defer_destroy) {
5087 (void) printf(" zc_defer_destroy=%d\n",
5088 (int)zc.zc_defer_destroy);
5089 }
5090 if (zc.zc_flags) {
5091 (void) printf(" zc_flags=0x%x\n",
5092 zc.zc_flags);
5093 }
5094 if (zc.zc_action_handle) {
5095 (void) printf(" zc_action_handle=%llu\n",
5096 (u_longlong_t)zc.zc_action_handle);
5097 }
5098 if (zc.zc_cleanup_fd >= 0)
5099 (void) printf(" zc_cleanup_fd=%d\n", zc.zc_cleanup_fd);
5100 if (zc.zc_sendobj) {
5101 (void) printf(" zc_sendobj=%llu\n",
5102 (u_longlong_t)zc.zc_sendobj);
5103 }
5104 if (zc.zc_fromobj) {
5105 (void) printf(" zc_fromobj=%llu\n",
5106 (u_longlong_t)zc.zc_fromobj);
5107 }
5108 if (zc.zc_createtxg) {
5109 (void) printf(" zc_createtxg=%llu\n",
5110 (u_longlong_t)zc.zc_createtxg);
5111 }
5112
5113 if (memcmp(&zc.zc_stat, &zero_zstat, sizeof (zc.zc_stat))) {
5114 zfs_stat_t *zs = &zc.zc_stat;
5115 (void) printf(" zc_stat:\n");
5116 if (zs->zs_gen) {
5117 (void) printf("\tzs_gen=%llu\n",
5118 (u_longlong_t)zs->zs_gen);
5119 }
5120 if (zs->zs_mode) {
5121 (void) printf("\tzs_mode=%llu\n",
5122 (u_longlong_t)zs->zs_mode);
5123 }
5124 if (zs->zs_links) {
5125 (void) printf("\tzs_links=%llu\n",
5126 (u_longlong_t)zs->zs_links);
5127 }
5128 if (zs->zs_ctime[0]) {
5129 (void) printf("\tzs_ctime[0]=%llu\n",
5130 (u_longlong_t)zs->zs_ctime[0]);
5131 }
5132 if (zs->zs_ctime[1]) {
5133 (void) printf("\tzs_ctime[1]=%llu\n",
5134 (u_longlong_t)zs->zs_ctime[1]);
5135 }
5136 }
5137 }
5138
5139 /* expound verbosely upon syscall arguments */
5140 /*ARGSUSED*/
5141 void
5142 expound(private_t *pri, long r0, int raw)
5143 {
5144 const lwpstatus_t *Lsp = pri->lwpstat;
5145 int lp64 = (data_model == PR_MODEL_LP64);
5146 int what = Lsp->pr_what;
5147 int err = pri->Errno; /* don't display output parameters */
5148 /* for a failed system call */
5149 #ifndef _LP64
5150 /* We are a 32-bit truss; we can't grok a 64-bit process */
5151 if (lp64)
5152 return;
5153 #endif
5154 /* for reporting sleeping system calls */
5155 if (what == 0 && (Lsp->pr_flags & (PR_ASLEEP|PR_VFORKP)))
5156 what = Lsp->pr_syscall;
5157
5158 switch (what) {
5159 case SYS_gettimeofday:
5160 if (!err)
5161 show_timeofday(pri);
5162 break;
5163 case SYS_getitimer:
5164 if (!err && pri->sys_nargs > 1)
5165 show_itimerval(pri, (long)pri->sys_args[1],
5166 " value");
5167 break;
5168 case SYS_setitimer:
5169 if (pri->sys_nargs > 1)
5170 show_itimerval(pri, (long)pri->sys_args[1],
5171 " value");
5172 if (!err && pri->sys_nargs > 2)
5173 show_itimerval(pri, (long)pri->sys_args[2],
5174 "ovalue");
5175 break;
5176 case SYS_stime:
5177 show_stime(pri);
5178 break;
5179 case SYS_times:
5180 if (!err)
5181 show_times(pri);
5182 break;
5183 case SYS_utssys:
5184 if (err)
5185 break;
5186 #ifdef _LP64
5187 if (lp64)
5188 show_utssys(pri, r0);
5189 else
5190 show_utssys32(pri, r0);
5191 #else
5192 show_utssys(pri, r0);
5193 #endif
5194 break;
5195 case SYS_ioctl:
5196 if (pri->sys_nargs >= 3) /* each case must decide for itself */
5197 show_ioctl(pri, pri->sys_args[1],
5198 (long)pri->sys_args[2]);
5199 break;
5200 case SYS_fstatat:
5201 if (!err && pri->sys_nargs >= 3)
5202 show_stat(pri, (long)pri->sys_args[2]);
5203 break;
5204 case SYS_fstatat64:
5205 if (!err && pri->sys_nargs >= 3)
5206 show_stat64_32(pri, (long)pri->sys_args[2]);
5207 break;
5208 case SYS_stat:
5209 case SYS_fstat:
5210 case SYS_lstat:
5211 if (!err && pri->sys_nargs >= 2)
5212 show_stat(pri, (long)pri->sys_args[1]);
5213 break;
5214 case SYS_stat64:
5215 case SYS_fstat64:
5216 case SYS_lstat64:
5217 if (!err && pri->sys_nargs >= 2)
5218 show_stat64_32(pri, (long)pri->sys_args[1]);
5219 break;
5220 case SYS_statvfs:
5221 case SYS_fstatvfs:
5222 if (err)
5223 break;
5224 #ifdef _LP64
5225 if (!lp64) {
5226 show_statvfs32(pri);
5227 break;
5228 }
5229 #endif
5230 show_statvfs(pri);
5231 break;
5232 case SYS_statvfs64:
5233 case SYS_fstatvfs64:
5234 if (err)
5235 break;
5236 show_statvfs64(pri);
5237 break;
5238 case SYS_statfs:
5239 case SYS_fstatfs:
5240 if (err)
5241 break;
5242 #ifdef _LP64
5243 if (lp64)
5244 show_statfs(pri);
5245 else
5246 show_statfs32(pri);
5247 #else
5248 show_statfs(pri);
5249 #endif
5250 break;
5251 case SYS_fcntl:
5252 show_fcntl(pri);
5253 break;
5254 case SYS_msgsys:
5255 show_msgsys(pri, r0); /* each case must decide for itself */
5256 break;
5257 case SYS_semsys:
5258 show_semsys(pri); /* each case must decide for itself */
5259 break;
5260 case SYS_shmsys:
5261 show_shmsys(pri); /* each case must decide for itself */
5262 break;
5263 case SYS_getdents:
5264 if (err || pri->sys_nargs <= 1 || r0 <= 0)
5265 break;
5266 #ifdef _LP64
5267 if (!lp64) {
5268 show_dents32(pri, (long)pri->sys_args[1], r0);
5269 break;
5270 }
5271 /* FALLTHROUGH */
5272 #else
5273 show_dents32(pri, (long)pri->sys_args[1], r0);
5274 break;
5275 #endif
5276 case SYS_getdents64:
5277 if (err || pri->sys_nargs <= 1 || r0 <= 0)
5278 break;
5279 show_dents64(pri, (long)pri->sys_args[1], r0);
5280 break;
5281 case SYS_getmsg:
5282 show_gp_msg(pri, what);
5283 if (pri->sys_nargs > 3)
5284 show_hhex_int(pri, (long)pri->sys_args[3], "flags");
5285 break;
5286 case SYS_getpmsg:
5287 show_gp_msg(pri, what);
5288 if (pri->sys_nargs > 3)
5289 show_hhex_int(pri, (long)pri->sys_args[3], "band");
5290 if (pri->sys_nargs > 4)
5291 show_hhex_int(pri, (long)pri->sys_args[4], "flags");
5292 break;
5293 case SYS_putmsg:
5294 case SYS_putpmsg:
5295 show_gp_msg(pri, what);
5296 break;
5297 case SYS_pollsys:
5298 show_pollsys(pri);
5299 break;
5300 case SYS_setgroups:
5301 if (pri->sys_nargs > 1 && (r0 = pri->sys_args[0]) > 0)
5302 show_groups(pri, (long)pri->sys_args[1], r0);
5303 break;
5304 case SYS_getgroups:
5305 if (!err && pri->sys_nargs > 1 && pri->sys_args[0] > 0)
5306 show_groups(pri, (long)pri->sys_args[1], r0);
5307 break;
5308 case SYS_sigprocmask:
5309 if (pri->sys_nargs > 1)
5310 show_sigset(pri, (long)pri->sys_args[1], " set");
5311 if (!err && pri->sys_nargs > 2)
5312 show_sigset(pri, (long)pri->sys_args[2], "oset");
5313 break;
5314 case SYS_sigsuspend:
5315 case SYS_sigtimedwait:
5316 if (pri->sys_nargs > 0)
5317 show_sigset(pri, (long)pri->sys_args[0], "sigmask");
5318 if (!err && pri->sys_nargs > 1)
5319 show_siginfo(pri, (long)pri->sys_args[1]);
5320 if (pri->sys_nargs > 2)
5321 show_timestruc(pri, (long)pri->sys_args[2], "timeout");
5322 break;
5323 case SYS_sigaltstack:
5324 if (pri->sys_nargs > 0)
5325 show_sigaltstack(pri, (long)pri->sys_args[0],
5326 "new");
5327 if (!err && pri->sys_nargs > 1)
5328 show_sigaltstack(pri, (long)pri->sys_args[1],
5329 "old");
5330 break;
5331 case SYS_sigaction:
5332 if (pri->sys_nargs > 1)
5333 show_sigaction(pri, (long)pri->sys_args[1],
5334 "new", NULL);
5335 if (!err && pri->sys_nargs > 2)
5336 show_sigaction(pri, (long)pri->sys_args[2],
5337 "old", r0);
5338 break;
5339 case SYS_signotify:
5340 if (pri->sys_nargs > 1)
5341 show_siginfo(pri, (long)pri->sys_args[1]);
5342 break;
5343 case SYS_sigresend:
5344 if (pri->sys_nargs > 1)
5345 show_siginfo(pri, (long)pri->sys_args[1]);
5346 if (pri->sys_nargs > 2)
5347 show_sigset(pri, (long)pri->sys_args[2], "sigmask");
5348 break;
5349 case SYS_sigpending:
5350 if (!err && pri->sys_nargs > 1)
5351 show_sigset(pri, (long)pri->sys_args[1], "sigmask");
5352 break;
5353 case SYS_waitid:
5354 if (!err && pri->sys_nargs > 2)
5355 show_siginfo(pri, (long)pri->sys_args[2]);
5356 break;
5357 case SYS_sigsendsys:
5358 if (pri->sys_nargs > 0)
5359 show_procset(pri, (long)pri->sys_args[0]);
5360 break;
5361 case SYS_priocntlsys:
5362 if (pri->sys_nargs > 1)
5363 show_procset(pri, (long)pri->sys_args[1]);
5364 break;
5365 case SYS_mincore:
5366 if (!err && pri->sys_nargs > 2)
5367 show_bool(pri, (long)pri->sys_args[2],
5368 (pri->sys_args[1] + pagesize - 1) / pagesize);
5369 break;
5370 case SYS_readv:
5371 case SYS_writev:
5372 if (pri->sys_nargs > 2) {
5373 int i = pri->sys_args[0]+1;
5374 int showbuf = FALSE;
5375 long nb = (what == SYS_readv)? r0 : 32*1024;
5376
5377 if ((what == SYS_readv && !err &&
5378 prismember(&readfd, i)) ||
5379 (what == SYS_writev &&
5380 prismember(&writefd, i)))
5381 showbuf = TRUE;
5382 show_iovec(pri, (long)pri->sys_args[1],
5383 pri->sys_args[2], showbuf, nb);
5384 }
5385 break;
5386 case SYS_getrlimit:
5387 if (err)
5388 break;
5389 /*FALLTHROUGH*/
5390 case SYS_setrlimit:
5391 if (pri->sys_nargs <= 1)
5392 break;
5393 #ifdef _LP64
5394 if (lp64)
5395 show_rlimit64(pri, (long)pri->sys_args[1]);
5396 else
5397 show_rlimit32(pri, (long)pri->sys_args[1]);
5398 #else
5399 show_rlimit32(pri, (long)pri->sys_args[1]);
5400 #endif
5401 break;
5402 case SYS_getrlimit64:
5403 if (err)
5404 break;
5405 /*FALLTHROUGH*/
5406 case SYS_setrlimit64:
5407 if (pri->sys_nargs <= 1)
5408 break;
5409 show_rlimit64(pri, (long)pri->sys_args[1]);
5410 break;
5411 case SYS_uname:
5412 if (!err && pri->sys_nargs > 0)
5413 show_nuname(pri, (long)pri->sys_args[0]);
5414 break;
5415 case SYS_adjtime:
5416 if (!err && pri->sys_nargs > 1)
5417 show_adjtime(pri, (long)pri->sys_args[0],
5418 (long)pri->sys_args[1]);
5419 break;
5420 case SYS_lwp_info:
5421 if (!err && pri->sys_nargs > 0)
5422 show_timestruc(pri, (long)pri->sys_args[0], "cpu time");
5423 break;
5424 case SYS_lwp_wait:
5425 if (!err && pri->sys_nargs > 1)
5426 show_int(pri, (long)pri->sys_args[1], "lwpid");
5427 break;
5428 case SYS_lwp_mutex_wakeup:
5429 case SYS_lwp_mutex_unlock:
5430 case SYS_lwp_mutex_trylock:
5431 case SYS_lwp_mutex_register:
5432 if (pri->sys_nargs > 0)
5433 show_mutex(pri, (long)pri->sys_args[0]);
5434 break;
5435 case SYS_lwp_mutex_timedlock:
5436 if (pri->sys_nargs > 0)
5437 show_mutex(pri, (long)pri->sys_args[0]);
5438 if (pri->sys_nargs > 1)
5439 show_timestruc(pri, (long)pri->sys_args[1], "timeout");
5440 break;
5441 case SYS_lwp_cond_wait:
5442 if (pri->sys_nargs > 0)
5443 show_condvar(pri, (long)pri->sys_args[0]);
5444 if (pri->sys_nargs > 1)
5445 show_mutex(pri, (long)pri->sys_args[1]);
5446 if (pri->sys_nargs > 2)
5447 show_timestruc(pri, (long)pri->sys_args[2], "timeout");
5448 break;
5449 case SYS_lwp_cond_signal:
5450 case SYS_lwp_cond_broadcast:
5451 if (pri->sys_nargs > 0)
5452 show_condvar(pri, (long)pri->sys_args[0]);
5453 break;
5454 case SYS_lwp_sema_trywait:
5455 case SYS_lwp_sema_post:
5456 if (pri->sys_nargs > 0)
5457 show_sema(pri, (long)pri->sys_args[0]);
5458 break;
5459 case SYS_lwp_sema_timedwait:
5460 if (pri->sys_nargs > 0)
5461 show_sema(pri, (long)pri->sys_args[0]);
5462 if (pri->sys_nargs > 1)
5463 show_timestruc(pri, (long)pri->sys_args[1], "timeout");
5464 break;
5465 case SYS_lwp_rwlock_sys:
5466 if (pri->sys_nargs > 1)
5467 show_rwlock(pri, (long)pri->sys_args[1]);
5468 if (pri->sys_nargs > 2 &&
5469 (pri->sys_args[0] == 0 || pri->sys_args[0] == 1))
5470 show_timestruc(pri, (long)pri->sys_args[2], "timeout");
5471 break;
5472 case SYS_lwp_create:
5473 /* XXX print some values in ucontext ??? */
5474 if (!err && pri->sys_nargs > 2)
5475 show_int(pri, (long)pri->sys_args[2], "lwpid");
5476 break;
5477 case SYS_kaio:
5478 if (pri->sys_args[0] == AIOWAIT && !err && pri->sys_nargs > 1)
5479 show_timeval(pri, (long)pri->sys_args[1], "timeout");
5480 break;
5481 case SYS_nanosleep:
5482 if (pri->sys_nargs > 0)
5483 show_timestruc(pri, (long)pri->sys_args[0], "tmout");
5484 if (pri->sys_nargs > 1 && (err == 0 || err == EINTR))
5485 show_timestruc(pri, (long)pri->sys_args[1], "resid");
5486 break;
5487 case SYS_privsys:
5488 switch (pri->sys_args[0]) {
5489 case PRIVSYS_SETPPRIV:
5490 case PRIVSYS_GETPPRIV:
5491 if (!err)
5492 show_privset(pri, (long)pri->sys_args[3],
5493 (size_t)pri->sys_args[4], "");
5494 }
5495 break;
5496 case SYS_ucredsys:
5497 switch (pri->sys_args[0]) {
5498 case UCREDSYS_UCREDGET:
5499 case UCREDSYS_GETPEERUCRED:
5500 if (err == 0)
5501 show_ucred(pri, (long)pri->sys_args[2]);
5502 break;
5503 }
5504 break;
5505 case SYS_bind:
5506 case SYS_connect:
5507 if (pri->sys_nargs > 2)
5508 show_sockaddr(pri, "name", (long)pri->sys_args[1],
5509 0, (long)pri->sys_args[2]);
5510 break;
5511 case SYS_sendto:
5512 if (pri->sys_nargs > 5)
5513 show_sockaddr(pri, "to", (long)pri->sys_args[4], 0,
5514 pri->sys_args[5]);
5515 break;
5516 case SYS_accept:
5517 if (!err && pri->sys_nargs > 2)
5518 show_sockaddr(pri, "name", (long)pri->sys_args[1],
5519 (long)pri->sys_args[2], 0);
5520 break;
5521 case SYS_getsockname:
5522 case SYS_getpeername:
5523 if (!err && pri->sys_nargs > 2)
5524 show_sockaddr(pri, "name", (long)pri->sys_args[1],
5525 (long)pri->sys_args[2], 0);
5526 break;
5527 case SYS_cladm:
5528 if (!err && pri->sys_nargs > 2)
5529 show_cladm(pri, pri->sys_args[0], pri->sys_args[1],
5530 (long)pri->sys_args[2]);
5531 break;
5532 case SYS_recvfrom:
5533 if (!err && pri->sys_nargs > 5)
5534 show_sockaddr(pri, "from", (long)pri->sys_args[4],
5535 (long)pri->sys_args[5], 0);
5536 break;
5537 case SYS_recvmsg:
5538 if (err)
5539 break;
5540 /* FALLTHROUGH */
5541 case SYS_sendmsg:
5542 if (pri->sys_nargs <= 2)
5543 break;
5544 #ifdef _LP64
5545 if (lp64)
5546 show_msghdr(pri, pri->sys_args[1]);
5547 else
5548 show_msghdr32(pri, pri->sys_args[1]);
5549 #else
5550 show_msghdr(pri, pri->sys_args[1]);
5551 #endif
5552 break;
5553 case SYS_door:
5554 show_doors(pri);
5555 break;
5556 case SYS_sendfilev:
5557 if (pri->sys_nargs != 5)
5558 break;
5559
5560 if (pri->sys_args[0] == SENDFILEV) {
5561 show_sendfilevec(pri, (int)pri->sys_args[1],
5562 (sendfilevec_t *)pri->sys_args[2],
5563 (int)pri->sys_args[3]);
5564 } else if (pri->sys_args[0] == SENDFILEV64) {
5565 show_sendfilevec64(pri, (int)pri->sys_args[1],
5566 (sendfilevec64_t *)pri->sys_args[2],
5567 (int)pri->sys_args[3]);
5568 }
5569 break;
5570 case SYS_memcntl:
5571 show_memcntl(pri);
5572 break;
5573 case SYS_lwp_park:
5574 /*
5575 * subcode 0: lwp_park(timespec_t *, id_t)
5576 * subcode 4: lwp_set_park(timespec_t *, id_t)
5577 */
5578 if (pri->sys_nargs > 1 &&
5579 (pri->sys_args[0] == 0 || pri->sys_args[0] == 4))
5580 show_timestruc(pri, (long)pri->sys_args[1], "timeout");
5581 /* subcode 2: lwp_unpark_all(id_t *, int) */
5582 if (pri->sys_nargs > 2 && pri->sys_args[0] == 2)
5583 show_ids(pri, (long)pri->sys_args[1],
5584 (int)pri->sys_args[2]);
5585 break;
5586 case SYS_ntp_gettime:
5587 if (!err)
5588 show_ntp_gettime(pri);
5589 break;
5590 case SYS_ntp_adjtime:
5591 if (!err)
5592 show_ntp_adjtime(pri);
5593 break;
5594 case SYS_rusagesys:
5595 if (!err)
5596 if (pri->sys_args[0] == _RUSAGESYS_GETRUSAGE) {
5597 #ifdef _LP64
5598 if (!lp64)
5599 show_getrusage32(pri->sys_args[1]);
5600 else
5601 #endif
5602 show_getrusage(pri->sys_args[1]);
5603 }
5604 break;
5605 case SYS_port:
5606 show_ports(pri);
5607 break;
5608 case SYS_zone:
5609 show_zones(pri);
5610 break;
5611 case SYS_rctlsys:
5612 show_rctls(pri);
5613 break;
5614 case SYS_utimesys:
5615 show_utimesys(pri);
5616 break;
5617 case SYS_sockconfig:
5618 show_sockconfig(pri);
5619 break;
5620 }
5621 }
unleashed repo fork