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, ×truc, sizeof (timestruc), offset) 297 != sizeof (timestruc)) 298 return; 299 } else { 300 timestruc32_t timestruc32; 301 302 if (Pread(Proc, ×truc32, sizeof (timestruc32), offset) 303 != sizeof (timestruc32)) 304 return; 305 306 TIMESPEC32_TO_TIMESPEC(×truc, ×truc32); 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, <chars, sizeof (ltchars), offset) 734 == sizeof (ltchars)) { 735 (void) printf("%s\t cc: ", pri->pname); 736 for (p = (char *)<chars, 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 #else 5272 show_dents32(pri, (long)pri->sys_args[1], r0); 5273 break; 5274 #endif 5275 /* FALLTHROUGH */ 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 } 5622