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