1 /* $OpenBSD: kdump.c,v 1.159 2023/11/09 15:43:28 kn Exp $ */ 2 3 /*- 4 * Copyright (c) 1988, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/time.h> 33 #include <sys/signal.h> 34 #include <sys/uio.h> 35 #include <sys/ktrace.h> 36 #include <sys/ioctl.h> 37 #include <sys/malloc.h> 38 #include <sys/namei.h> 39 #include <sys/ptrace.h> 40 #include <sys/sem.h> 41 #include <sys/shm.h> 42 #include <sys/socket.h> 43 #include <sys/sysctl.h> 44 #include <sys/siginfo.h> 45 #include <sys/vmmeter.h> 46 #include <sys/tty.h> 47 #include <sys/wait.h> 48 #define PLEDGENAMES 49 #include <sys/pledge.h> 50 #undef PLEDGENAMES 51 #define _KERNEL 52 #include <errno.h> 53 #undef _KERNEL 54 #include <ddb/db_var.h> 55 #include <machine/cpu.h> 56 57 #include <ctype.h> 58 #include <err.h> 59 #include <fcntl.h> 60 #include <limits.h> 61 #include <netdb.h> 62 #include <poll.h> 63 #include <signal.h> 64 #include <stddef.h> 65 #include <stdint.h> 66 #include <stdio.h> 67 #include <stdlib.h> 68 #include <string.h> 69 #include <unistd.h> 70 #include <vis.h> 71 72 #include "ktrace.h" 73 #include "kdump.h" 74 #include "kdump_subr.h" 75 #include "extern.h" 76 77 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 78 79 enum { 80 TIMESTAMP_NONE, 81 TIMESTAMP_ABSOLUTE, 82 TIMESTAMP_RELATIVE, 83 TIMESTAMP_ELAPSED 84 } timestamp = TIMESTAMP_NONE; 85 86 int decimal, iohex, fancy = 1, maxdata = INT_MAX; 87 int needtid, tail, basecol; 88 char *tracefile = DEF_TRACEFILE; 89 struct ktr_header ktr_header; 90 pid_t pid_opt = -1; 91 const char *program; 92 char* utracefilter; 93 94 #define eqs(s1, s2) (strcmp((s1), (s2)) == 0) 95 96 #include <sys/syscall.h> 97 98 #define KTRACE 99 #define PTRACE 100 #define NFSCLIENT 101 #define NFSSERVER 102 #define SYSVSEM 103 #define SYSVMSG 104 #define SYSVSHM 105 #define ACCOUNTING 106 #include <kern/syscalls.c> 107 #undef KTRACE 108 #undef PTRACE 109 #undef NFSCLIENT 110 #undef NFSSERVER 111 #undef SYSVSEM 112 #undef SYSVMSG 113 #undef SYSVSHM 114 #undef ACCOUNTING 115 116 117 static char *ptrace_ops[] = { 118 "PT_TRACE_ME", "PT_READ_I", "PT_READ_D", "PT_READ_U", 119 "PT_WRITE_I", "PT_WRITE_D", "PT_WRITE_U", "PT_CONTINUE", 120 "PT_KILL", "PT_ATTACH", "PT_DETACH", "PT_IO", 121 "PT_SET_EVENT_MASK", "PT_GET_EVENT_MASK", "PT_GET_PROCESS_STATE", 122 "PT_GET_THREAD_FIRST", "PT_GET_THREAD_NEXT", 123 }; 124 125 static int fread_tail(void *, size_t, size_t); 126 static void dumpheader(struct ktr_header *); 127 static void ktrgenio(struct ktr_genio *, size_t); 128 static void ktrnamei(const char *, size_t); 129 static void ktrpsig(struct ktr_psig *); 130 static void ktrsyscall(struct ktr_syscall *, size_t); 131 static const char *kresolvsysctl(int, const int *); 132 static void ktrsysret(struct ktr_sysret *, size_t); 133 static void ktruser(struct ktr_user *, size_t); 134 static void ktrexec(const char*, size_t); 135 static void ktrpledge(struct ktr_pledge *, size_t); 136 static void usage(void); 137 static void ioctldecode(int); 138 static void ptracedecode(int); 139 static void atfd(int); 140 static void polltimeout(int); 141 static void wait4pid(int); 142 static void signame(int); 143 static void semctlname(int); 144 static void shmctlname(int); 145 static void semgetname(int); 146 static void flagsandmodename(int); 147 static void clockname(int); 148 static void sockoptlevelname(int); 149 static void ktraceopname(int); 150 static void idtypeandid(int); 151 152 static int screenwidth; 153 154 int 155 main(int argc, char *argv[]) 156 { 157 int ch, silent; 158 size_t ktrlen, size; 159 int trpoints = ALL_POINTS; 160 const char *errstr; 161 void *m; 162 163 if (screenwidth == 0) { 164 struct winsize ws; 165 166 if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 && 167 ws.ws_col > 8) 168 screenwidth = ws.ws_col; 169 else 170 screenwidth = 80; 171 } 172 173 while ((ch = getopt(argc, argv, "f:dHlm:nP:p:RTt:u:xX")) != -1) 174 switch (ch) { 175 case 'f': 176 tracefile = optarg; 177 break; 178 case 'd': 179 decimal = 1; 180 break; 181 case 'H': 182 needtid = 1; 183 break; 184 case 'l': 185 tail = 1; 186 break; 187 case 'm': 188 maxdata = strtonum(optarg, 0, INT_MAX, &errstr); 189 if (errstr) 190 errx(1, "-m %s: %s", optarg, errstr); 191 break; 192 case 'n': 193 fancy = 0; 194 break; 195 case 'P': 196 program = optarg; 197 break; 198 case 'p': 199 pid_opt = strtonum(optarg, 1, INT_MAX, &errstr); 200 if (errstr) 201 errx(1, "-p %s: %s", optarg, errstr); 202 break; 203 case 'R': /* relative timestamp */ 204 if (timestamp == TIMESTAMP_ABSOLUTE) 205 timestamp = TIMESTAMP_ELAPSED; 206 else 207 timestamp = TIMESTAMP_RELATIVE; 208 break; 209 case 'T': 210 if (timestamp == TIMESTAMP_RELATIVE) 211 timestamp = TIMESTAMP_ELAPSED; 212 else 213 timestamp = TIMESTAMP_ABSOLUTE; 214 break; 215 case 't': 216 trpoints = getpoints(optarg, DEF_POINTS); 217 if (trpoints < 0) 218 errx(1, "unknown trace point in %s", optarg); 219 utracefilter = NULL; 220 break; 221 case 'u': 222 utracefilter = optarg; 223 trpoints = KTRFAC_USER; 224 break; 225 case 'x': 226 iohex = 1; 227 break; 228 case 'X': 229 iohex = 2; 230 break; 231 default: 232 usage(); 233 } 234 if (argc > optind) 235 usage(); 236 237 if (strcmp(tracefile, "-") != 0) 238 if (unveil(tracefile, "r") == -1) 239 err(1, "unveil %s", tracefile); 240 if (unveil(_PATH_PROTOCOLS, "r") == -1) 241 err(1, "unveil %s", _PATH_PROTOCOLS); 242 if (pledge("stdio rpath getpw", NULL) == -1) 243 err(1, "pledge"); 244 245 m = malloc(size = 1025); 246 if (m == NULL) 247 err(1, NULL); 248 if (strcmp(tracefile, "-") != 0) 249 if (!freopen(tracefile, "r", stdin)) 250 err(1, "%s", tracefile); 251 252 if (fread_tail(&ktr_header, sizeof(struct ktr_header), 1) == 0 || 253 ktr_header.ktr_type != htobe32(KTR_START)) 254 errx(1, "%s: not a dump", tracefile); 255 while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) { 256 silent = 0; 257 if (pid_opt != -1 && pid_opt != ktr_header.ktr_pid) 258 silent = 1; 259 if (program != NULL && 260 strcmp(ktr_header.ktr_comm, program) != 0) 261 silent = 1; 262 if (utracefilter == NULL && silent == 0 && 263 trpoints & (1<<ktr_header.ktr_type)) 264 dumpheader(&ktr_header); 265 ktrlen = ktr_header.ktr_len; 266 if (ktrlen > size) { 267 void *newm; 268 269 if (ktrlen == SIZE_MAX) 270 errx(1, "data too long"); 271 newm = realloc(m, ktrlen+1); 272 if (newm == NULL) 273 err(1, "realloc"); 274 m = newm; 275 size = ktrlen; 276 } 277 if (ktrlen && fread_tail(m, ktrlen, 1) == 0) 278 errx(1, "data too short"); 279 if (silent) 280 continue; 281 if ((trpoints & (1<<ktr_header.ktr_type)) == 0) 282 continue; 283 switch (ktr_header.ktr_type) { 284 case KTR_SYSCALL: 285 ktrsyscall(m, ktrlen); 286 break; 287 case KTR_SYSRET: 288 ktrsysret(m, ktrlen); 289 break; 290 case KTR_NAMEI: 291 ktrnamei(m, ktrlen); 292 break; 293 case KTR_GENIO: 294 ktrgenio(m, ktrlen); 295 break; 296 case KTR_PSIG: 297 ktrpsig(m); 298 break; 299 case KTR_STRUCT: 300 ktrstruct(m, ktrlen); 301 break; 302 case KTR_USER: 303 ktruser(m, ktrlen); 304 break; 305 case KTR_EXECARGS: 306 case KTR_EXECENV: 307 ktrexec(m, ktrlen); 308 break; 309 case KTR_PLEDGE: 310 ktrpledge(m, ktrlen); 311 break; 312 default: 313 printf("\n"); 314 break; 315 } 316 if (tail) 317 (void)fflush(stdout); 318 } 319 exit(0); 320 } 321 322 static int 323 fread_tail(void *buf, size_t size, size_t num) 324 { 325 int i; 326 327 while ((i = fread(buf, size, num, stdin)) == 0 && tail) { 328 (void)sleep(1); 329 clearerr(stdin); 330 } 331 return (i); 332 } 333 334 static void 335 dumpheader(struct ktr_header *kth) 336 { 337 static struct timespec prevtime; 338 char unknown[64], *type; 339 struct timespec temp; 340 341 switch (kth->ktr_type) { 342 case KTR_SYSCALL: 343 type = "CALL"; 344 break; 345 case KTR_SYSRET: 346 type = "RET "; 347 break; 348 case KTR_NAMEI: 349 type = "NAMI"; 350 break; 351 case KTR_GENIO: 352 type = "GIO "; 353 break; 354 case KTR_PSIG: 355 type = "PSIG"; 356 break; 357 case KTR_STRUCT: 358 type = "STRU"; 359 break; 360 case KTR_USER: 361 type = "USER"; 362 break; 363 case KTR_EXECARGS: 364 type = "ARGS"; 365 break; 366 case KTR_EXECENV: 367 type = "ENV "; 368 break; 369 case KTR_PLEDGE: 370 type = "PLDG"; 371 break; 372 default: 373 /* htobe32() not guaranteed to work as case label */ 374 if (kth->ktr_type == htobe32(KTR_START)) { 375 type = "STRT"; 376 break; 377 } 378 (void)snprintf(unknown, sizeof unknown, "UNKNOWN(%u)", 379 kth->ktr_type); 380 type = unknown; 381 } 382 383 basecol = printf("%6ld", (long)kth->ktr_pid); 384 if (needtid) 385 basecol += printf("/%-7ld", (long)kth->ktr_tid); 386 basecol += printf(" %-8s ", kth->ktr_comm); 387 if (timestamp != TIMESTAMP_NONE) { 388 if (timestamp == TIMESTAMP_ELAPSED) { 389 if (prevtime.tv_sec == 0) 390 prevtime = kth->ktr_time; 391 timespecsub(&kth->ktr_time, &prevtime, &temp); 392 } else if (timestamp == TIMESTAMP_RELATIVE) { 393 timespecsub(&kth->ktr_time, &prevtime, &temp); 394 prevtime = kth->ktr_time; 395 } else 396 temp = kth->ktr_time; 397 basecol += printf("%lld.%06ld ", (long long)temp.tv_sec, 398 temp.tv_nsec / 1000); 399 } 400 basecol += printf("%s ", type); 401 } 402 403 /* 404 * Base Formatters 405 */ 406 407 /* some syscalls have padding that shouldn't be shown */ 408 static int 409 pad(long arg) 410 { 411 /* nothing printed */ 412 return (1); 413 } 414 415 /* a formatter that just saves the argument for the next formatter */ 416 int arg1; 417 static int 418 pass_two(long arg) 419 { 420 arg1 = (int)arg; 421 422 /* nothing printed */ 423 return (1); 424 } 425 426 static int 427 pdeclong(long arg) 428 { 429 (void)printf("%ld", arg); 430 return (0); 431 } 432 433 static int 434 pdeculong(long arg) 435 { 436 (void)printf("%lu", arg); 437 return (0); 438 } 439 440 static int 441 phexlong(long arg) 442 { 443 (void)printf("%#lx", arg); 444 return (0); 445 } 446 447 static int 448 pnonfancy(long arg) 449 { 450 if (decimal) 451 (void)printf("%ld", arg); 452 else 453 (void)printf("%#lx", arg); 454 return (0); 455 } 456 457 static void 458 pdecint(int arg) 459 { 460 (void)printf("%d", arg); 461 } 462 463 static void 464 pdecuint(int arg) 465 { 466 (void)printf("%u", arg); 467 } 468 469 static void 470 phexint(int arg) 471 { 472 (void)printf("%#x", arg); 473 } 474 475 static void 476 poctint(int arg) 477 { 478 (void)printf("%#o", arg); 479 } 480 481 482 #ifdef __LP64__ 483 484 /* on LP64, long long arguments are the same as long arguments */ 485 #define Phexlonglong Phexlong 486 #define phexll NULL /* not actually used on LP64 */ 487 488 /* no padding before long long arguments, nor at end */ 489 #define PAD64 0 490 #define END64 end_of_args 491 492 #else /* __LP64__ */ 493 494 /* on ILP32, long long arguments are passed as two 32bit args */ 495 #define Phexlonglong PASS_LONGLONG, Phexll 496 497 static int 498 phexll(long arg2) 499 { 500 long long val; 501 502 #if _BYTE_ORDER == _LITTLE_ENDIAN 503 val = ((long long)arg2 << 32) | ((long long)arg1 & 0xffffffff); 504 #else 505 val = ((long long)arg1 << 32) | ((long long)arg2 & 0xffffffff); 506 #endif 507 508 if (fancy || !decimal) 509 (void)printf("%#llx", val); 510 else 511 (void)printf("%lld", val); 512 return (0); 513 } 514 515 /* 516 * Some ILP32 archs naturally align off_t arguments to 8byte boundaries 517 * Get the compiler to tell if this arch is one of them. 518 */ 519 struct padding_test { 520 int padtest_one; 521 off_t padtest_two; 522 }; 523 #define PAD64 (offsetof(struct padding_test,padtest_two) == 8) 524 #define END64 (PAD64 ? PASS_LONGLONG : end_of_args) 525 526 #endif /* __LP64__ */ 527 528 static int (*long_formatters[])(long) = { 529 NULL, 530 pdeclong, 531 pdeculong, 532 phexlong, 533 pass_two, 534 pass_two, 535 phexll, 536 pad, 537 pnonfancy, 538 }; 539 540 static void (*formatters[])(int) = { 541 NULL, 542 pdecint, 543 phexint, 544 poctint, 545 pdecuint, 546 ioctldecode, 547 ptracedecode, 548 atfd, 549 polltimeout, 550 wait4pid, 551 signame, 552 semctlname, 553 shmctlname, 554 semgetname, 555 flagsandmodename, 556 clockname, 557 sockoptlevelname, 558 ktraceopname, 559 fcntlcmdname, 560 modename, 561 flagsname, 562 openflagsname, 563 atflagsname, 564 accessmodename, 565 mmapprotname, 566 mmapflagsname, 567 wait4optname, 568 sendrecvflagsname, 569 mountflagsname, 570 rebootoptname, 571 flockname, 572 sockoptname, 573 sockipprotoname, 574 socktypename, 575 sockflagsname, 576 sockfamilyname, 577 mlockallname, 578 shmatname, 579 whencename, 580 pathconfname, 581 rlimitname, 582 shutdownhowname, 583 prioname, 584 madvisebehavname, 585 msyncflagsname, 586 clocktypename, 587 rusagewho, 588 sigactionflagname, 589 sigprocmaskhowname, 590 minheritname, 591 quotactlname, 592 sigill_name, 593 sigtrap_name, 594 sigemt_name, 595 sigfpe_name, 596 sigbus_name, 597 sigsegv_name, 598 sigchld_name, 599 ktracefacname, 600 itimername, 601 sigset, 602 uidname, 603 gidname, 604 syslogflagname, 605 futexflagname, 606 waitidoptname, 607 idtypeandid, 608 }; 609 610 enum { 611 /* the end of the (known) arguments is recognized by the zero fill */ 612 end_of_args = 0, 613 614 /* negative are the negative of the index into long_formatters[] */ 615 Pdeclong = -1, 616 Pdeculong = -2, 617 Phexlong = -3, 618 PASS_TWO = -4, 619 620 /* the remaining long formatters still get called when non-fancy (-n option) */ 621 #define FMT_IS_NONFANCY(x) ((x) <= PASS_LONGLONG) 622 PASS_LONGLONG = -5, 623 Phexll = -6, 624 PAD = -7, 625 Pnonfancy = -8, 626 627 /* positive values are the index into formatters[] */ 628 Pdecint = 1, 629 Phexint, 630 Poctint, 631 Pdecuint, 632 Ioctldecode, 633 Ptracedecode, 634 Atfd, 635 Polltimeout, 636 Wait4pid, 637 Signame, 638 Semctlname, 639 Shmctlname, 640 Semgetname, 641 Flagsandmodename, 642 Clockname, 643 Sockoptlevelname, 644 Ktraceopname, 645 Fcntlcmdname, 646 Modename, 647 Flagsname, 648 Openflagsname, 649 Atflagsname, 650 Accessmodename, 651 Mmapprotname, 652 Mmapflagsname, 653 Wait4optname, 654 Sendrecvflagsname, 655 Mountflagsname, 656 Rebootoptname, 657 Flockname, 658 Sockoptname, 659 Sockipprotoname, 660 Socktypename, 661 Sockflagsname, 662 Sockfamilyname, 663 Mlockallname, 664 Shmatname, 665 Whencename, 666 Pathconfname, 667 Rlimitname, 668 Shutdownhowname, 669 Prioname, 670 Madvisebehavname, 671 Msyncflagsname, 672 Clocktypename, 673 Rusagewho, 674 Sigactionflagname, 675 Sigprocmaskhowname, 676 Minheritname, 677 Quotactlname, 678 Sigill_name, 679 Sigtrap_name, 680 Sigemt_name, 681 Sigfpe_name, 682 Sigbus_name, 683 Sigsegv_name, 684 Sigchld_name, 685 Ktracefacname, 686 Itimername, 687 Sigset, 688 Uidname, 689 Gidname, 690 Syslogflagname, 691 Futexflagname, 692 Waitidoptname, 693 Idtypeandid, 694 }; 695 696 #define Pptr Phexlong 697 #define Psize Pdeculong /* size_t for small buffers */ 698 #define Pbigsize Phexlong /* size_t for I/O buffers */ 699 #define Pcount Pdecint /* int for a count of something */ 700 #define Pfd Pdecint 701 #define Ppath Phexlong 702 #define Pdev_t Pdecint 703 #define Ppid_t Pdecint 704 #define Ppgid Pdecint /* pid or negative pgid */ 705 #define Poff_t Phexlonglong 706 #define Pmsqid Pdecint 707 #define Pshmid Pdecint 708 #define Psemid Pdecint 709 #define Pkey_t Pdecint 710 #define Pucount Pdecuint 711 #define Chflagsname Phexlong /* to be added */ 712 #define Sockprotoname Phexlong /* to be added */ 713 #define Swapctlname Phexlong /* to be added */ 714 #define Msgflgname Phexlong /* to be added */ 715 716 717 /* includes relevant entries as of syscalls.master rev 1.238 */ 718 typedef signed char formatter; 719 static const formatter scargs[][8] = { 720 [SYS_exit] = { Pdecint }, 721 [SYS_read] = { Pfd, Pptr, Pbigsize }, 722 [SYS_write] = { Pfd, Pptr, Pbigsize }, 723 [SYS_open] = { Ppath, PASS_TWO, Flagsandmodename }, 724 [SYS_close] = { Pfd }, 725 [SYS_getentropy] = { Pptr, Psize }, 726 [SYS___tfork] = { Pptr, Psize }, 727 [SYS_link] = { Ppath, Ppath }, 728 [SYS_unlink] = { Ppath }, 729 [SYS_wait4] = { Wait4pid, Pptr, Wait4optname }, 730 [SYS_chdir] = { Ppath }, 731 [SYS_fchdir] = { Pfd }, 732 [SYS_mknod] = { Ppath, Modename, Pdev_t }, 733 [SYS_chmod] = { Ppath, Modename }, 734 [SYS_chown] = { Ppath, Uidname, Gidname }, 735 [SYS_break] = { Pptr }, 736 [SYS_getrusage] = { Rusagewho, Pptr }, 737 [SYS_mount] = { Pptr, Ppath, Mountflagsname, Pptr }, 738 [SYS_unmount] = { Ppath, Mountflagsname }, 739 [SYS_setuid] = { Uidname }, 740 [SYS_ptrace] = { Ptracedecode, Ppid_t, Pptr, Pdecint }, 741 [SYS_recvmsg] = { Pfd, Pptr, Sendrecvflagsname }, 742 [SYS_sendmsg] = { Pfd, Pptr, Sendrecvflagsname }, 743 [SYS_recvfrom] = { Pfd, Pptr, Pbigsize, Sendrecvflagsname }, 744 [SYS_accept] = { Pfd, Pptr, Pptr }, 745 [SYS_getpeername] = { Pfd, Pptr, Pptr }, 746 [SYS_getsockname] = { Pfd, Pptr, Pptr }, 747 [SYS_access] = { Ppath, Accessmodename }, 748 [SYS_chflags] = { Ppath, Chflagsname }, 749 [SYS_fchflags] = { Pfd, Chflagsname }, 750 [SYS_msyscall] = { Pptr, Pbigsize }, 751 [SYS_stat] = { Ppath, Pptr }, 752 [SYS_lstat] = { Ppath, Pptr }, 753 [SYS_dup] = { Pfd }, 754 [SYS_fstatat] = { Atfd, Ppath, Pptr, Atflagsname }, 755 [SYS_profil] = { Pptr, Pbigsize, Pbigsize, Pdecuint }, 756 [SYS_ktrace] = { Ppath, Ktraceopname, Ktracefacname, Ppgid }, 757 [SYS_sigaction] = { Signame, Pptr, Pptr }, 758 [SYS_sigprocmask] = { Sigprocmaskhowname, Sigset }, 759 [SYS_mmap] = { Pptr, Pbigsize, Mmapprotname, Mmapflagsname, Pfd, Poff_t, END64 }, 760 [SYS_setlogin] = { Pptr }, 761 [SYS_acct] = { Ppath }, 762 [SYS_fstat] = { Pfd, Pptr }, 763 [SYS_ioctl] = { Pfd, Ioctldecode, Pptr }, 764 [SYS_reboot] = { Rebootoptname }, 765 [SYS_revoke] = { Ppath }, 766 [SYS_symlink] = { Ppath, Ppath }, 767 [SYS_readlink] = { Ppath, Pptr, Psize }, 768 [SYS_execve] = { Ppath, Pptr, Pptr }, 769 [SYS_umask] = { Modename }, 770 [SYS_chroot] = { Ppath }, 771 [SYS_getfsstat] = { Pptr, Pbigsize, Mountflagsname }, 772 [SYS_statfs] = { Ppath, Pptr }, 773 [SYS_fstatfs] = { Pfd, Pptr }, 774 [SYS_fhstatfs] = { Pptr, Pptr }, 775 [SYS_gettimeofday] = { Pptr, Pptr }, 776 [SYS_settimeofday] = { Pptr, Pptr }, 777 [SYS_setitimer] = { Itimername, Pptr, Pptr }, 778 [SYS_getitimer] = { Itimername, Pptr }, 779 [SYS_select] = { Pcount, Pptr, Pptr, Pptr, Pptr }, 780 [SYS_kevent] = { Pfd, Pptr, Pcount, Pptr, Pcount, Pptr }, 781 [SYS_munmap] = { Pptr, Pbigsize }, 782 [SYS_mprotect] = { Pptr, Pbigsize, Mmapprotname }, 783 [SYS_madvise] = { Pptr, Pbigsize, Madvisebehavname }, 784 [SYS_utimes] = { Ppath, Pptr }, 785 [SYS_futimes] = { Pfd, Pptr }, 786 [SYS_mquery] = { Pptr, Pbigsize, Mmapprotname, Mmapflagsname, Pfd, Poff_t, END64 }, 787 [SYS_getgroups] = { Pcount, Pptr }, 788 [SYS_setgroups] = { Pcount, Pptr }, 789 [SYS_setpgid] = { Ppid_t, Ppid_t }, 790 [SYS_futex] = { Pptr, Futexflagname, Pcount, Pptr, Pptr }, 791 [SYS_utimensat] = { Atfd, Ppath, Pptr, Atflagsname }, 792 [SYS_futimens] = { Pfd, Pptr }, 793 [SYS_kbind] = { Pptr, Psize, Phexlonglong }, 794 [SYS_clock_gettime] = { Clockname, Pptr }, 795 [SYS_clock_settime] = { Clockname, Pptr }, 796 [SYS_clock_getres] = { Clockname, Pptr }, 797 [SYS_dup2] = { Pfd, Pfd }, 798 [SYS_nanosleep] = { Pptr, Pptr }, 799 [SYS_fcntl] = { Pfd, PASS_TWO, Fcntlcmdname }, 800 [SYS_accept4] = { Pfd, Pptr, Pptr, Sockflagsname }, 801 [SYS___thrsleep] = { Pptr, Clockname, Pptr, Pptr, Pptr }, 802 [SYS_fsync] = { Pfd }, 803 [SYS_setpriority] = { Prioname, Ppid_t, Pdecint }, 804 [SYS_socket] = { Sockfamilyname, Socktypename, Sockprotoname }, 805 [SYS_connect] = { Pfd, Pptr, Pucount }, 806 [SYS_getdents] = { Pfd, Pptr, Pbigsize }, 807 [SYS_getpriority] = { Prioname, Ppid_t }, 808 [SYS_pipe2] = { Pptr, Flagsname }, 809 [SYS_dup3] = { Pfd, Pfd, Flagsname }, 810 [SYS_sigreturn] = { Pptr }, 811 [SYS_bind] = { Pfd, Pptr, Pucount }, 812 [SYS_setsockopt] = { Pfd, PASS_TWO, Sockoptlevelname, Pptr, Pdecint }, 813 [SYS_listen] = { Pfd, Pdecint }, 814 [SYS_chflagsat] = { Atfd, Ppath, Chflagsname, Atflagsname }, 815 [SYS_pledge] = { Pptr, Pptr }, 816 [SYS_ppoll] = { Pptr, Pucount, Pptr, Pptr }, 817 [SYS_pselect] = { Pcount, Pptr, Pptr, Pptr, Pptr, Pptr }, 818 [SYS_sigsuspend] = { Sigset }, 819 [SYS_sendsyslog] = { Pptr, Psize, Syslogflagname }, 820 [SYS_unveil] = { Ppath, Pptr }, 821 [SYS___realpath] = { Ppath, Pptr }, 822 [SYS_recvmmsg] = { Pfd, Pptr, Pucount, Sendrecvflagsname, Pptr }, 823 [SYS_sendmmsg] = { Pfd, Pptr, Pucount, Sendrecvflagsname }, 824 [SYS_getsockopt] = { Pfd, PASS_TWO, Sockoptlevelname, Pptr, Pptr }, 825 [SYS_thrkill] = { Ppid_t, Signame, Pptr }, 826 [SYS_readv] = { Pfd, Pptr, Pcount }, 827 [SYS_writev] = { Pfd, Pptr, Pcount }, 828 [SYS_kill] = { Ppgid, Signame }, 829 [SYS_fchown] = { Pfd, Uidname, Gidname }, 830 [SYS_fchmod] = { Pfd, Modename }, 831 [SYS_setreuid] = { Uidname, Uidname }, 832 [SYS_setregid] = { Gidname, Gidname }, 833 [SYS_rename] = { Ppath, Ppath }, 834 [SYS_flock] = { Pfd, Flockname }, 835 [SYS_mkfifo] = { Ppath, Modename }, 836 [SYS_sendto] = { Pfd, Pptr, Pbigsize, Sendrecvflagsname }, 837 [SYS_shutdown] = { Pfd, Shutdownhowname }, 838 [SYS_socketpair] = { Sockfamilyname, Socktypename, Sockprotoname, Pptr }, 839 [SYS_mkdir] = { Ppath, Modename }, 840 [SYS_rmdir] = { Ppath }, 841 [SYS_adjtime] = { Pptr, Pptr }, 842 [SYS_getlogin_r] = { Pptr, Psize }, 843 [SYS_getthrname] = { Ppid_t, Pptr, Psize }, 844 [SYS_setthrname] = { Ppid_t, Pptr }, 845 [SYS_quotactl] = { Ppath, Quotactlname, Uidname, Pptr }, 846 [SYS_ypconnect] = { Socktypename }, 847 [SYS_nfssvc] = { Phexint, Pptr }, 848 [SYS_mimmutable] = { Pptr, Pbigsize }, 849 [SYS_waitid] = { PASS_TWO, Idtypeandid, Pptr, Waitidoptname }, 850 [SYS_getfh] = { Ppath, Pptr }, 851 [SYS___tmpfd] = { Openflagsname }, 852 [SYS_sysarch] = { Pdecint, Pptr }, 853 [SYS_lseek] = { Pfd, Poff_t, Whencename, END64 }, 854 [SYS_truncate] = { Ppath, Poff_t, END64 }, 855 [SYS_ftruncate] = { Pfd, Poff_t, END64 }, 856 [SYS_pread] = { Pfd, Pptr, Pbigsize, Poff_t, END64 }, 857 [SYS_pwrite] = { Pfd, Pptr, Pbigsize, Poff_t, END64 }, 858 [SYS_preadv] = { Pfd, Pptr, Pcount, Poff_t, END64 }, 859 [SYS_pwritev] = { Pfd, Pptr, Pcount, Poff_t, END64 }, 860 [SYS_setgid] = { Gidname }, 861 [SYS_setegid] = { Gidname }, 862 [SYS_seteuid] = { Uidname }, 863 [SYS_pathconf] = { Ppath, Pathconfname }, 864 [SYS_fpathconf] = { Pfd, Pathconfname }, 865 [SYS_swapctl] = { Swapctlname, Pptr, Pdecint }, 866 [SYS_getrlimit] = { Rlimitname, Pptr }, 867 [SYS_setrlimit] = { Rlimitname, Pptr }, 868 [SYS_sysctl] = { Pptr, Pcount, Pptr, Pptr, Pptr, Psize }, 869 [SYS_mlock] = { Pptr, Pbigsize }, 870 [SYS_munlock] = { Pptr, Pbigsize }, 871 [SYS_getpgid] = { Ppid_t }, 872 [SYS_utrace] = { Pptr, Pptr, Psize }, 873 [SYS_semget] = { Pkey_t, Pcount, Semgetname }, 874 [SYS_msgget] = { Pkey_t, Msgflgname }, 875 [SYS_msgsnd] = { Pmsqid, Pptr, Psize, Msgflgname }, 876 [SYS_msgrcv] = { Pmsqid, Pptr, Psize, Pdeclong, Msgflgname }, 877 [SYS_shmat] = { Pshmid, Pptr, Shmatname }, 878 [SYS_shmdt] = { Pptr }, 879 [SYS_minherit] = { Pptr, Pbigsize, Minheritname }, 880 [SYS_poll] = { Pptr, Pucount, Polltimeout }, 881 [SYS_lchown] = { Ppath, Uidname, Gidname }, 882 [SYS_getsid] = { Ppid_t }, 883 [SYS_msync] = { Pptr, Pbigsize, Msyncflagsname }, 884 [SYS_pipe] = { Pptr }, 885 [SYS_fhopen] = { Pptr, Openflagsname }, 886 [SYS_kqueue1] = { Flagsname }, 887 [SYS_mlockall] = { Mlockallname }, 888 [SYS_getresuid] = { Pptr, Pptr, Pptr }, 889 [SYS_setresuid] = { Uidname, Uidname, Uidname }, 890 [SYS_getresgid] = { Pptr, Pptr, Pptr }, 891 [SYS_setresgid] = { Gidname, Gidname, Gidname }, 892 [SYS_closefrom] = { Pfd }, 893 [SYS_sigaltstack] = { Pptr, Pptr }, 894 [SYS_shmget] = { Pkey_t, Pbigsize, Semgetname }, 895 [SYS_semop] = { Psemid, Pptr, Psize }, 896 [SYS_fhstat] = { Pptr, Pptr }, 897 [SYS___semctl] = { Psemid, Pcount, Semctlname, Pptr }, 898 [SYS_shmctl] = { Pshmid, Shmctlname, Pptr }, 899 [SYS_msgctl] = { Pmsqid, Shmctlname, Pptr }, 900 [SYS___thrwakeup] = { Pptr, Pcount }, 901 [SYS___threxit] = { Pptr }, 902 [SYS___thrsigdivert] = { Sigset, Pptr, Pptr }, 903 [SYS___getcwd] = { Pptr, Psize }, 904 [SYS_adjfreq] = { Pptr, Pptr }, 905 [SYS_setrtable] = { Pdecint }, 906 [SYS_faccessat] = { Atfd, Ppath, Accessmodename, Atflagsname }, 907 [SYS_fchmodat] = { Atfd, Ppath, Modename, Atflagsname }, 908 [SYS_fchownat] = { Atfd, Ppath, Uidname, Gidname, Atflagsname }, 909 [SYS_linkat] = { Atfd, Ppath, Atfd, Ppath, Atflagsname }, 910 [SYS_mkdirat] = { Atfd, Ppath, Modename }, 911 [SYS_mkfifoat] = { Atfd, Ppath, Modename }, 912 [SYS_mknodat] = { Atfd, Ppath, Modename, Pdev_t }, 913 [SYS_openat] = { Atfd, Ppath, PASS_TWO, Flagsandmodename }, 914 [SYS_readlinkat] = { Atfd, Ppath, Pptr, Psize }, 915 [SYS_renameat] = { Atfd, Ppath, Atfd, Ppath }, 916 [SYS_symlinkat] = { Ppath, Atfd, Ppath }, 917 [SYS_unlinkat] = { Atfd, Ppath, Atflagsname }, 918 [SYS___set_tcb] = { Pptr }, 919 }; 920 921 922 static void 923 ktrsyscall(struct ktr_syscall *ktr, size_t ktrlen) 924 { 925 register_t *ap; 926 int narg, code; 927 char sep; 928 929 if (ktr->ktr_argsize > ktrlen) 930 errx(1, "syscall argument length %d > ktr header length %zu", 931 ktr->ktr_argsize, ktrlen); 932 933 narg = ktr->ktr_argsize / sizeof(register_t); 934 sep = '\0'; 935 936 if (ktr->ktr_code & KTRC_CODE_SYSCALL) 937 (void)printf("(via syscall) "); 938 code = ktr->ktr_code & KTRC_CODE_MASK; 939 if (code >= SYS_MAXSYSCALL || code < 0) 940 (void)printf("[%d]", code); 941 else 942 (void)printf("%s", syscallnames[code]); 943 ap = (register_t *)((char *)ktr + sizeof(struct ktr_syscall)); 944 (void)putchar('('); 945 946 if (code == SYS_sysctl && fancy) { 947 const char *s; 948 int n, i, *top; 949 950 n = ap[1]; 951 if (n > CTL_MAXNAME) 952 n = CTL_MAXNAME; 953 if (n < 0) 954 errx(1, "invalid sysctl length %d", n); 955 if (n > 0) { 956 top = (int *)(ap + 6); 957 printf("%d", top[0]); 958 for (i = 1; i < n; i++) 959 printf(".%d", top[i]); 960 if ((s = kresolvsysctl(0, top)) != NULL) { 961 printf("<%s", s); 962 for (i = 1; i < n; i++) { 963 if ((s = kresolvsysctl(i, top)) != NULL) 964 printf(".%s", s); 965 else 966 printf(".%d", top[i]); 967 } 968 putchar('>'); 969 } 970 } 971 972 sep = ','; 973 ap += 2; 974 narg -= 2; 975 } else if (code < nitems(scargs)) { 976 const formatter *fmts = scargs[code]; 977 int fmt; 978 int arg = 0; 979 980 while (arg < narg && (fmt = *fmts) != 0) { 981 if (PAD64 && fmt == PASS_LONGLONG && (arg & 1)) 982 goto skip; 983 if (sep) 984 putchar(sep); 985 sep = ','; 986 if (!fancy && !FMT_IS_NONFANCY(fmt)) 987 fmt = Pnonfancy; 988 if (fmt > 0) 989 formatters[fmt]((int)*ap); 990 else if (long_formatters[-fmt](*ap)) 991 sep = '\0'; 992 fmts++; 993 skip: 994 ap++; 995 arg++; 996 } 997 narg -= arg; 998 } 999 1000 while (narg > 0) { 1001 if (sep) 1002 putchar(sep); 1003 if (decimal) 1004 (void)printf("%ld", (long)*ap); 1005 else 1006 (void)printf("%#lx", (long)*ap); 1007 sep = ','; 1008 ap++; 1009 narg--; 1010 } 1011 (void)printf(")\n"); 1012 } 1013 1014 static struct ctlname topname[] = CTL_NAMES; 1015 static struct ctlname kernname[] = CTL_KERN_NAMES; 1016 static struct ctlname vmname[] = CTL_VM_NAMES; 1017 static struct ctlname fsname[] = CTL_FS_NAMES; 1018 static struct ctlname netname[] = CTL_NET_NAMES; 1019 static struct ctlname hwname[] = CTL_HW_NAMES; 1020 static struct ctlname debugname[CTL_DEBUG_MAXID]; 1021 static struct ctlname kernmallocname[] = CTL_KERN_MALLOC_NAMES; 1022 static struct ctlname forkstatname[] = CTL_KERN_FORKSTAT_NAMES; 1023 static struct ctlname nchstatsname[] = CTL_KERN_NCHSTATS_NAMES; 1024 static struct ctlname kernprocname[] = { 1025 { NULL }, 1026 { "all" }, 1027 { "pid" }, 1028 { "pgrp" }, 1029 { "session" }, 1030 { "tty" }, 1031 { "uid" }, 1032 { "ruid" }, 1033 { "kthread" }, 1034 }; 1035 static struct ctlname ttysname[] = CTL_KERN_TTY_NAMES; 1036 static struct ctlname semname[] = CTL_KERN_SEMINFO_NAMES; 1037 static struct ctlname shmname[] = CTL_KERN_SHMINFO_NAMES; 1038 static struct ctlname watchdogname[] = CTL_KERN_WATCHDOG_NAMES; 1039 static struct ctlname tcname[] = CTL_KERN_TIMECOUNTER_NAMES; 1040 #ifdef CTL_MACHDEP_NAMES 1041 static struct ctlname machdepname[] = CTL_MACHDEP_NAMES; 1042 #endif 1043 static struct ctlname ddbname[] = CTL_DDB_NAMES; 1044 1045 #ifndef nitems 1046 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0])) 1047 #endif 1048 1049 #define SETNAME(name) do { names = (name); limit = nitems(name); } while (0) 1050 1051 static const char * 1052 kresolvsysctl(int depth, const int *top) 1053 { 1054 struct ctlname *names; 1055 size_t limit; 1056 int idx = top[depth]; 1057 1058 names = NULL; 1059 1060 switch (depth) { 1061 case 0: 1062 SETNAME(topname); 1063 break; 1064 case 1: 1065 switch (top[0]) { 1066 case CTL_KERN: 1067 SETNAME(kernname); 1068 break; 1069 case CTL_VM: 1070 SETNAME(vmname); 1071 break; 1072 case CTL_FS: 1073 SETNAME(fsname); 1074 break; 1075 case CTL_NET: 1076 SETNAME(netname); 1077 break; 1078 case CTL_DEBUG: 1079 SETNAME(debugname); 1080 break; 1081 case CTL_HW: 1082 SETNAME(hwname); 1083 break; 1084 #ifdef CTL_MACHDEP_NAMES 1085 case CTL_MACHDEP: 1086 SETNAME(machdepname); 1087 break; 1088 #endif 1089 case CTL_DDB: 1090 SETNAME(ddbname); 1091 break; 1092 } 1093 break; 1094 case 2: 1095 switch (top[0]) { 1096 case CTL_KERN: 1097 switch (top[1]) { 1098 case KERN_MALLOCSTATS: 1099 SETNAME(kernmallocname); 1100 break; 1101 case KERN_FORKSTAT: 1102 SETNAME(forkstatname); 1103 break; 1104 case KERN_NCHSTATS: 1105 SETNAME(nchstatsname); 1106 break; 1107 case KERN_TTY: 1108 SETNAME(ttysname); 1109 break; 1110 case KERN_SEMINFO: 1111 SETNAME(semname); 1112 break; 1113 case KERN_SHMINFO: 1114 SETNAME(shmname); 1115 break; 1116 case KERN_WATCHDOG: 1117 SETNAME(watchdogname); 1118 break; 1119 case KERN_PROC: 1120 idx++; /* zero is valid at this level */ 1121 SETNAME(kernprocname); 1122 break; 1123 case KERN_TIMECOUNTER: 1124 SETNAME(tcname); 1125 break; 1126 } 1127 } 1128 break; 1129 } 1130 if (names != NULL && idx > 0 && idx < limit) 1131 return (names[idx].ctl_name); 1132 return (NULL); 1133 } 1134 1135 static void 1136 ktrsysret(struct ktr_sysret *ktr, size_t ktrlen) 1137 { 1138 register_t ret = 0; 1139 long long retll; 1140 int error = ktr->ktr_error; 1141 int code = ktr->ktr_code; 1142 1143 if (ktrlen < sizeof(*ktr)) 1144 errx(1, "sysret length %zu < ktr header length %zu", 1145 ktrlen, sizeof(*ktr)); 1146 ktrlen -= sizeof(*ktr); 1147 if (error == 0) { 1148 if (ktrlen == sizeof(ret)) { 1149 memcpy(&ret, ktr+1, sizeof(ret)); 1150 retll = ret; 1151 } else if (ktrlen == sizeof(retll)) 1152 memcpy(&retll, ktr+1, sizeof(retll)); 1153 else 1154 errx(1, "sysret bogus length %zu", ktrlen); 1155 } 1156 1157 if (code >= SYS_MAXSYSCALL || code < 0) 1158 (void)printf("[%d] ", code); 1159 else 1160 (void)printf("%s ", syscallnames[code]); 1161 1162 doerr: 1163 if (error == 0) { 1164 if (fancy) { 1165 switch (code) { 1166 case SYS_lseek: 1167 (void)printf("%lld", retll); 1168 if (retll < 0 || retll > 9) 1169 (void)printf("/%#llx", retll); 1170 break; 1171 case SYS_sigprocmask: 1172 case SYS_sigpending: 1173 sigset(ret); 1174 break; 1175 case SYS___thrsigdivert: 1176 signame(ret); 1177 break; 1178 case SYS_getuid: 1179 case SYS_geteuid: 1180 uidname(ret); 1181 break; 1182 case SYS_getgid: 1183 case SYS_getegid: 1184 gidname(ret); 1185 break; 1186 /* syscalls that return errno values */ 1187 case SYS_getlogin_r: 1188 case SYS___thrsleep: 1189 case SYS_getthrname: 1190 case SYS_setthrname: 1191 if ((error = ret) != 0) 1192 goto doerr; 1193 /* FALLTHROUGH */ 1194 default: 1195 (void)printf("%ld", (long)ret); 1196 if (ret < 0 || ret > 9) 1197 (void)printf("/%#lx", (long)ret); 1198 } 1199 } else { 1200 if (decimal) 1201 (void)printf("%lld", retll); 1202 else 1203 (void)printf("%#llx", retll); 1204 } 1205 } else if (error == ERESTART) 1206 (void)printf("RESTART"); 1207 else if (error == EJUSTRETURN) 1208 (void)printf("JUSTRETURN"); 1209 else { 1210 (void)printf("-1 errno %d", error); 1211 if (fancy) 1212 (void)printf(" %s", strerror(error)); 1213 } 1214 (void)putchar('\n'); 1215 } 1216 1217 static void 1218 ktrnamei(const char *cp, size_t len) 1219 { 1220 showbufc(basecol, (unsigned char *)cp, len, VIS_DQ | VIS_TAB | VIS_NL); 1221 } 1222 1223 void 1224 showbufc(int col, unsigned char *dp, size_t datalen, int flags) 1225 { 1226 int width; 1227 unsigned char visbuf[5], *cp; 1228 1229 flags |= VIS_CSTYLE; 1230 putchar('"'); 1231 col++; 1232 for (; datalen > 0; datalen--, dp++) { 1233 (void)vis(visbuf, *dp, flags, *(dp+1)); 1234 cp = visbuf; 1235 1236 /* 1237 * Keep track of printables and 1238 * space chars (like fold(1)). 1239 */ 1240 if (col == 0) { 1241 (void)putchar('\t'); 1242 col = 8; 1243 } 1244 switch (*cp) { 1245 case '\n': 1246 col = 0; 1247 (void)putchar('\n'); 1248 continue; 1249 case '\t': 1250 width = 8 - (col&07); 1251 break; 1252 default: 1253 width = strlen(cp); 1254 } 1255 if (col + width > (screenwidth-2)) { 1256 (void)printf("\\\n\t"); 1257 col = 8; 1258 } 1259 col += width; 1260 do { 1261 (void)putchar(*cp++); 1262 } while (*cp); 1263 } 1264 if (col == 0) 1265 (void)printf(" "); 1266 (void)printf("\"\n"); 1267 } 1268 1269 static void 1270 showbuf(unsigned char *dp, size_t datalen) 1271 { 1272 size_t i, j; 1273 int col = 0, bpl; 1274 unsigned char c; 1275 char visbuf[4 * KTR_USER_MAXLEN + 1]; 1276 1277 if (utracefilter != NULL) { 1278 strvisx(visbuf, dp, datalen, VIS_SAFE | VIS_OCTAL); 1279 printf("%s", visbuf); 1280 return; 1281 } 1282 if (iohex == 1) { 1283 putchar('\t'); 1284 col = 8; 1285 for (i = 0; i < datalen; i++) { 1286 printf("%02x", dp[i]); 1287 col += 3; 1288 if (i < datalen - 1) { 1289 if (col + 3 > screenwidth) { 1290 printf("\n\t"); 1291 col = 8; 1292 } else 1293 putchar(' '); 1294 } 1295 } 1296 putchar('\n'); 1297 return; 1298 } 1299 if (iohex == 2) { 1300 bpl = (screenwidth - 13)/4; 1301 if (bpl <= 0) 1302 bpl = 1; 1303 for (i = 0; i < datalen; i += bpl) { 1304 printf(" %04zx: ", i); 1305 for (j = 0; j < bpl; j++) { 1306 if (i+j >= datalen) 1307 printf(" "); 1308 else 1309 printf("%02x ", dp[i+j]); 1310 } 1311 putchar(' '); 1312 for (j = 0; j < bpl; j++) { 1313 if (i+j >= datalen) 1314 break; 1315 c = dp[i+j]; 1316 if (!isprint(c)) 1317 c = '.'; 1318 putchar(c); 1319 } 1320 putchar('\n'); 1321 } 1322 return; 1323 } 1324 1325 (void)printf(" "); 1326 showbufc(7, dp, datalen, 0); 1327 } 1328 1329 static void 1330 ktrgenio(struct ktr_genio *ktr, size_t len) 1331 { 1332 unsigned char *dp = (unsigned char *)ktr + sizeof(struct ktr_genio); 1333 size_t datalen; 1334 1335 if (len < sizeof(struct ktr_genio)) 1336 errx(1, "invalid ktr genio length %zu", len); 1337 1338 datalen = len - sizeof(struct ktr_genio); 1339 1340 printf("fd %d %s %zu bytes\n", ktr->ktr_fd, 1341 ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen); 1342 if (maxdata == 0) 1343 return; 1344 if (datalen > maxdata) 1345 datalen = maxdata; 1346 if (iohex && !datalen) 1347 return; 1348 showbuf(dp, datalen); 1349 } 1350 1351 void 1352 siginfo(const siginfo_t *si, int show_signo) 1353 { 1354 if (show_signo) { 1355 printf("signo="); 1356 signame(si->si_signo); 1357 } 1358 if (si->si_code) { 1359 printf(" code="); 1360 if (!fancy) 1361 printf("<%d>", si->si_code); 1362 else { 1363 switch (si->si_signo) { 1364 case SIGILL: 1365 sigill_name(si->si_code); 1366 break; 1367 case SIGTRAP: 1368 sigtrap_name(si->si_code); 1369 break; 1370 case SIGEMT: 1371 sigemt_name(si->si_code); 1372 break; 1373 case SIGFPE: 1374 sigfpe_name(si->si_code); 1375 break; 1376 case SIGBUS: 1377 sigbus_name(si->si_code); 1378 break; 1379 case SIGSEGV: 1380 sigsegv_name(si->si_code); 1381 break; 1382 case SIGCHLD: 1383 sigchld_name(si->si_code); 1384 break; 1385 default: 1386 printf("<%d>", si->si_code); 1387 break; 1388 } 1389 } 1390 } 1391 1392 switch (si->si_signo) { 1393 case SIGSEGV: 1394 case SIGILL: 1395 case SIGBUS: 1396 case SIGFPE: 1397 printf(" addr=%p trapno=%d", si->si_addr, si->si_trapno); 1398 break; 1399 case SIGCHLD: 1400 if (si->si_code == CLD_EXITED) { 1401 printf(" status=%d", si->si_status); 1402 if (si->si_status < 0 || si->si_status > 9) 1403 (void)printf("/%#x", si->si_status); 1404 } else { 1405 printf(" status="); 1406 signame(si->si_status); 1407 } 1408 printf(" pid=%d uid=", si->si_pid); 1409 uidname(si->si_uid); 1410 break; 1411 default: 1412 break; 1413 } 1414 } 1415 1416 static void 1417 ktrpsig(struct ktr_psig *psig) 1418 { 1419 signame(psig->signo); 1420 printf(" "); 1421 if (psig->action == SIG_DFL) 1422 printf("SIG_DFL"); 1423 else { 1424 printf("caught handler=0x%lx mask=", (u_long)psig->action); 1425 sigset(psig->mask); 1426 } 1427 siginfo(&psig->si, 0); 1428 putchar('\n'); 1429 } 1430 1431 static void 1432 ktruser(struct ktr_user *usr, size_t len) 1433 { 1434 if (len < sizeof(struct ktr_user)) 1435 errx(1, "invalid ktr user length %zu", len); 1436 len -= sizeof(struct ktr_user); 1437 if (utracefilter == NULL) { 1438 printf("%.*s:", KTR_USER_MAXIDLEN, usr->ktr_id); 1439 printf(" %zu bytes\n", len); 1440 showbuf((unsigned char *)(usr + 1), len); 1441 } else if (strncmp(usr->ktr_id, utracefilter, KTR_USER_MAXIDLEN) == 0) 1442 showbuf((unsigned char *)(usr + 1), len); 1443 } 1444 1445 static void 1446 ktrexec(const char *ptr, size_t len) 1447 { 1448 int i, col; 1449 size_t l; 1450 1451 putchar('\n'); 1452 i = 0; 1453 while (len > 0) { 1454 l = strnlen(ptr, len); 1455 col = printf("\t[%d] = ", i++); 1456 col += 7; /* tab expands from 1 to 8 columns */ 1457 showbufc(col, (unsigned char *)ptr, l, VIS_DQ|VIS_TAB|VIS_NL); 1458 if (l == len) { 1459 printf("\tunterminated argument\n"); 1460 break; 1461 } 1462 len -= l + 1; 1463 ptr += l + 1; 1464 } 1465 } 1466 1467 static void 1468 ktrpledge(struct ktr_pledge *pledge, size_t len) 1469 { 1470 const char *name = ""; 1471 int i; 1472 1473 if (len < sizeof(struct ktr_pledge)) 1474 errx(1, "invalid ktr pledge length %zu", len); 1475 1476 if (pledge->syscall >= SYS_MAXSYSCALL || pledge->syscall < 0) 1477 (void)printf("[%d]", pledge->syscall); 1478 else 1479 (void)printf("%s", syscallnames[pledge->syscall]); 1480 printf(", "); 1481 for (i = 0; pledge->code && pledgenames[i].bits != 0; i++) { 1482 if (pledgenames[i].bits & pledge->code) { 1483 name = pledgenames[i].name; 1484 break; 1485 } 1486 } 1487 printf("\"%s\"", name); 1488 (void)printf(", errno %d", pledge->error); 1489 if (fancy) 1490 (void)printf(" %s", strerror(pledge->error)); 1491 printf("\n"); 1492 } 1493 1494 static void 1495 usage(void) 1496 { 1497 1498 extern char *__progname; 1499 fprintf(stderr, "usage: %s " 1500 "[-dHlnRTXx] [-f file] [-m maxdata] [-P program] [-p pid] " 1501 "[-t trstr]\n\t[-u label]\n", __progname); 1502 exit(1); 1503 } 1504 1505 1506 /* 1507 * FORMATTERS 1508 */ 1509 1510 static void 1511 ioctldecode(int cmd) 1512 { 1513 char dirbuf[4], *dir = dirbuf; 1514 const char *cp; 1515 1516 if ((cp = ioctlname((unsigned)cmd)) != NULL) { 1517 (void)printf("%s", cp); 1518 return; 1519 } 1520 1521 if (cmd & IOC_IN) 1522 *dir++ = 'W'; 1523 if (cmd & IOC_OUT) 1524 *dir++ = 'R'; 1525 *dir = '\0'; 1526 1527 printf("_IO%s('%c',%d", 1528 dirbuf, (int)((cmd >> 8) & 0xff), cmd & 0xff); 1529 if ((cmd & IOC_VOID) == 0) 1530 printf(decimal ? ",%u)" : ",%#x)", (cmd >> 16) & 0xff); 1531 else 1532 printf(")"); 1533 } 1534 1535 static void 1536 ptracedecode(int request) 1537 { 1538 if (request >= 0 && request < nitems(ptrace_ops)) 1539 (void)printf("%s", ptrace_ops[request]); 1540 else switch(request) { 1541 #ifdef PT_GETFPREGS 1542 case PT_GETFPREGS: 1543 (void)printf("PT_GETFPREGS"); 1544 break; 1545 #endif 1546 case PT_GETREGS: 1547 (void)printf("PT_GETREGS"); 1548 break; 1549 #ifdef PT_GETXMMREGS 1550 case PT_GETXMMREGS: 1551 (void)printf("PT_GETXMMREGS"); 1552 break; 1553 #endif 1554 #ifdef PT_SETFPREGS 1555 case PT_SETFPREGS: 1556 (void)printf("PT_SETFPREGS"); 1557 break; 1558 #endif 1559 case PT_SETREGS: 1560 (void)printf("PT_SETREGS"); 1561 break; 1562 #ifdef PT_SETXMMREGS 1563 case PT_SETXMMREGS: 1564 (void)printf("PT_SETXMMREGS"); 1565 break; 1566 #endif 1567 #ifdef PT_STEP 1568 case PT_STEP: 1569 (void)printf("PT_STEP"); 1570 break; 1571 #endif 1572 #ifdef PT_WCOOKIE 1573 case PT_WCOOKIE: 1574 (void)printf("PT_WCOOKIE"); 1575 break; 1576 #endif 1577 default: 1578 pdecint(request); 1579 } 1580 } 1581 1582 1583 static void 1584 atfd(int fd) 1585 { 1586 if (fd == AT_FDCWD) 1587 (void)printf("AT_FDCWD"); 1588 else 1589 pdecint(fd); 1590 } 1591 1592 static void 1593 polltimeout(int timeout) 1594 { 1595 if (timeout == INFTIM) 1596 (void)printf("INFTIM"); 1597 else 1598 pdecint(timeout); 1599 } 1600 1601 static void 1602 wait4pid(int pid) 1603 { 1604 if (pid == WAIT_ANY) 1605 (void)printf("WAIT_ANY"); 1606 else if (pid == WAIT_MYPGRP) 1607 (void)printf("WAIT_MYPGRP"); 1608 else 1609 pdecint(pid); /* ppgid */ 1610 } 1611 1612 static void 1613 signame(int sig) 1614 { 1615 if (sig > 0 && sig < NSIG) 1616 (void)printf("SIG%s", sys_signame[sig]); 1617 else 1618 (void)printf("SIG %d", sig); 1619 } 1620 1621 void 1622 sigset(int ss) 1623 { 1624 int or = 0; 1625 int cnt = 0; 1626 int i; 1627 1628 for (i = 1; i < NSIG; i++) 1629 if (sigismember(&ss, i)) 1630 cnt++; 1631 if (cnt > (NSIG-1)/2) { 1632 ss = ~ss; 1633 putchar('~'); 1634 } 1635 1636 if (ss == 0) { 1637 (void)printf("0<>"); 1638 return; 1639 } 1640 1641 printf("%#x<", ss); 1642 for (i = 1; i < NSIG; i++) 1643 if (sigismember(&ss, i)) { 1644 if (or) putchar('|'); else or=1; 1645 signame(i); 1646 } 1647 printf(">"); 1648 } 1649 1650 static void 1651 semctlname(int cmd) 1652 { 1653 switch (cmd) { 1654 case GETNCNT: 1655 (void)printf("GETNCNT"); 1656 break; 1657 case GETPID: 1658 (void)printf("GETPID"); 1659 break; 1660 case GETVAL: 1661 (void)printf("GETVAL"); 1662 break; 1663 case GETALL: 1664 (void)printf("GETALL"); 1665 break; 1666 case GETZCNT: 1667 (void)printf("GETZCNT"); 1668 break; 1669 case SETVAL: 1670 (void)printf("SETVAL"); 1671 break; 1672 case SETALL: 1673 (void)printf("SETALL"); 1674 break; 1675 case IPC_RMID: 1676 (void)printf("IPC_RMID"); 1677 break; 1678 case IPC_SET: 1679 (void)printf("IPC_SET"); 1680 break; 1681 case IPC_STAT: 1682 (void)printf("IPC_STAT"); 1683 break; 1684 default: /* Should not reach */ 1685 (void)printf("<invalid=%d>", cmd); 1686 } 1687 } 1688 1689 static void 1690 shmctlname(int cmd) 1691 { 1692 switch (cmd) { 1693 case IPC_RMID: 1694 (void)printf("IPC_RMID"); 1695 break; 1696 case IPC_SET: 1697 (void)printf("IPC_SET"); 1698 break; 1699 case IPC_STAT: 1700 (void)printf("IPC_STAT"); 1701 break; 1702 default: /* Should not reach */ 1703 (void)printf("<invalid=%d>", cmd); 1704 } 1705 } 1706 1707 1708 static void 1709 semgetname(int flag) 1710 { 1711 int or = 0; 1712 if_print_or(flag, IPC_CREAT, or); 1713 if_print_or(flag, IPC_EXCL, or); 1714 if_print_or(flag, SEM_R, or); 1715 if_print_or(flag, SEM_A, or); 1716 if_print_or(flag, (SEM_R>>3), or); 1717 if_print_or(flag, (SEM_A>>3), or); 1718 if_print_or(flag, (SEM_R>>6), or); 1719 if_print_or(flag, (SEM_A>>6), or); 1720 1721 if (flag & ~(IPC_CREAT|IPC_EXCL|SEM_R|SEM_A|((SEM_R|SEM_A)>>3)| 1722 ((SEM_R|SEM_A)>>6))) 1723 printf("<invalid=%#x>", flag); 1724 } 1725 1726 1727 /* 1728 * Only used by SYS_open and SYS_openat. Unless O_CREAT is set in flags, the 1729 * mode argument is unused (and often bogus and misleading). 1730 */ 1731 static void 1732 flagsandmodename(int mode) 1733 { 1734 openflagsname(arg1); 1735 if ((arg1 & O_CREAT) == O_CREAT) { 1736 (void)putchar(','); 1737 modename(mode); 1738 } else if (!fancy) 1739 (void)printf(",<unused>%#o", mode); 1740 } 1741 1742 static void 1743 clockname(int clockid) 1744 { 1745 clocktypename(__CLOCK_TYPE(clockid)); 1746 if (__CLOCK_PTID(clockid) != 0) 1747 printf("(%d)", __CLOCK_PTID(clockid)); 1748 } 1749 1750 /* 1751 * [g|s]etsockopt's level argument can either be SOL_SOCKET or a value 1752 * referring to a line in /etc/protocols. 1753 */ 1754 static void 1755 sockoptlevelname(int optname) 1756 { 1757 struct protoent *pe; 1758 1759 if (arg1 == SOL_SOCKET) { 1760 (void)printf("SOL_SOCKET,"); 1761 sockoptname(optname); 1762 } else { 1763 pe = getprotobynumber(arg1); 1764 (void)printf("%u<%s>,%d", arg1, 1765 pe != NULL ? pe->p_name : "unknown", optname); 1766 } 1767 } 1768 1769 static void 1770 ktraceopname(int ops) 1771 { 1772 int invalid = 0; 1773 1774 printf("%#x<", ops); 1775 switch (KTROP(ops)) { 1776 case KTROP_SET: 1777 printf("KTROP_SET"); 1778 break; 1779 case KTROP_CLEAR: 1780 printf("KTROP_CLEAR"); 1781 break; 1782 case KTROP_CLEARFILE: 1783 printf("KTROP_CLEARFILE"); 1784 break; 1785 default: 1786 printf("KTROP(%d)", KTROP(ops)); 1787 invalid = 1; 1788 break; 1789 } 1790 if (ops & KTRFLAG_DESCEND) printf("|KTRFLAG_DESCEND"); 1791 printf(">"); 1792 if (invalid || (ops & ~(KTROP((unsigned)-1) | KTRFLAG_DESCEND))) 1793 (void)printf("<invalid>%d", ops); 1794 } 1795 1796 static void 1797 idtypeandid(int id) 1798 { 1799 switch (arg1) { 1800 case P_PID: 1801 printf("P_PID,%d", id); 1802 break; 1803 case P_PGID: 1804 printf("P_PGID,%d", id); 1805 break; 1806 case P_ALL: 1807 printf("P_ALL,<unused>%d", id); 1808 break; 1809 default: /* Should not reach */ 1810 printf("<invalid=%d>, <unused>%d", arg1, id); 1811 } 1812 } 1813