1 /* $OpenBSD: kdump.c,v 1.137 2019/01/11 18:46:30 deraadt 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]\n" 1394 "%*s[-t [cinpstuxX+]]\n", 1395 __progname, (int)(sizeof("usage: ") + strlen(__progname)), ""); 1396 exit(1); 1397 } 1398 1399 1400 /* 1401 * FORMATTERS 1402 */ 1403 1404 static void 1405 ioctldecode(int cmd) 1406 { 1407 char dirbuf[4], *dir = dirbuf; 1408 const char *cp; 1409 1410 if ((cp = ioctlname((unsigned)cmd)) != NULL) { 1411 (void)printf("%s", cp); 1412 return; 1413 } 1414 1415 if (cmd & IOC_IN) 1416 *dir++ = 'W'; 1417 if (cmd & IOC_OUT) 1418 *dir++ = 'R'; 1419 *dir = '\0'; 1420 1421 printf("_IO%s('%c',%d", 1422 dirbuf, (int)((cmd >> 8) & 0xff), cmd & 0xff); 1423 if ((cmd & IOC_VOID) == 0) 1424 printf(decimal ? ",%u)" : ",%#x)", (cmd >> 16) & 0xff); 1425 else 1426 printf(")"); 1427 } 1428 1429 static void 1430 ptracedecode(int request) 1431 { 1432 if (request >= 0 && request < nitems(ptrace_ops)) 1433 (void)printf("%s", ptrace_ops[request]); 1434 else switch(request) { 1435 #ifdef PT_GETFPREGS 1436 case PT_GETFPREGS: 1437 (void)printf("PT_GETFPREGS"); 1438 break; 1439 #endif 1440 case PT_GETREGS: 1441 (void)printf("PT_GETREGS"); 1442 break; 1443 #ifdef PT_GETXMMREGS 1444 case PT_GETXMMREGS: 1445 (void)printf("PT_GETXMMREGS"); 1446 break; 1447 #endif 1448 #ifdef PT_SETFPREGS 1449 case PT_SETFPREGS: 1450 (void)printf("PT_SETFPREGS"); 1451 break; 1452 #endif 1453 case PT_SETREGS: 1454 (void)printf("PT_SETREGS"); 1455 break; 1456 #ifdef PT_SETXMMREGS 1457 case PT_SETXMMREGS: 1458 (void)printf("PT_SETXMMREGS"); 1459 break; 1460 #endif 1461 #ifdef PT_STEP 1462 case PT_STEP: 1463 (void)printf("PT_STEP"); 1464 break; 1465 #endif 1466 #ifdef PT_WCOOKIE 1467 case PT_WCOOKIE: 1468 (void)printf("PT_WCOOKIE"); 1469 break; 1470 #endif 1471 default: 1472 pdecint(request); 1473 } 1474 } 1475 1476 1477 static void 1478 atfd(int fd) 1479 { 1480 if (fd == AT_FDCWD) 1481 (void)printf("AT_FDCWD"); 1482 else 1483 pdecint(fd); 1484 } 1485 1486 static void 1487 polltimeout(int timeout) 1488 { 1489 if (timeout == INFTIM) 1490 (void)printf("INFTIM"); 1491 else 1492 pdecint(timeout); 1493 } 1494 1495 static void 1496 wait4pid(int pid) 1497 { 1498 if (pid == WAIT_ANY) 1499 (void)printf("WAIT_ANY"); 1500 else if (pid == WAIT_MYPGRP) 1501 (void)printf("WAIT_MYPGRP"); 1502 else 1503 pdecint(pid); /* ppgid */ 1504 } 1505 1506 static void 1507 signame(int sig) 1508 { 1509 if (sig > 0 && sig < NSIG) 1510 (void)printf("SIG%s", sys_signame[sig]); 1511 else 1512 (void)printf("SIG %d", sig); 1513 } 1514 1515 void 1516 sigset(int ss) 1517 { 1518 int or = 0; 1519 int cnt = 0; 1520 int i; 1521 1522 for (i = 1; i < NSIG; i++) 1523 if (sigismember(&ss, i)) 1524 cnt++; 1525 if (cnt > (NSIG-1)/2) { 1526 ss = ~ss; 1527 putchar('~'); 1528 } 1529 1530 if (ss == 0) { 1531 (void)printf("0<>"); 1532 return; 1533 } 1534 1535 printf("%#x<", ss); 1536 for (i = 1; i < NSIG; i++) 1537 if (sigismember(&ss, i)) { 1538 if (or) putchar('|'); else or=1; 1539 signame(i); 1540 } 1541 printf(">"); 1542 } 1543 1544 static void 1545 semctlname(int cmd) 1546 { 1547 switch (cmd) { 1548 case GETNCNT: 1549 (void)printf("GETNCNT"); 1550 break; 1551 case GETPID: 1552 (void)printf("GETPID"); 1553 break; 1554 case GETVAL: 1555 (void)printf("GETVAL"); 1556 break; 1557 case GETALL: 1558 (void)printf("GETALL"); 1559 break; 1560 case GETZCNT: 1561 (void)printf("GETZCNT"); 1562 break; 1563 case SETVAL: 1564 (void)printf("SETVAL"); 1565 break; 1566 case SETALL: 1567 (void)printf("SETALL"); 1568 break; 1569 case IPC_RMID: 1570 (void)printf("IPC_RMID"); 1571 break; 1572 case IPC_SET: 1573 (void)printf("IPC_SET"); 1574 break; 1575 case IPC_STAT: 1576 (void)printf("IPC_STAT"); 1577 break; 1578 default: /* Should not reach */ 1579 (void)printf("<invalid=%d>", cmd); 1580 } 1581 } 1582 1583 static void 1584 shmctlname(int cmd) 1585 { 1586 switch (cmd) { 1587 case IPC_RMID: 1588 (void)printf("IPC_RMID"); 1589 break; 1590 case IPC_SET: 1591 (void)printf("IPC_SET"); 1592 break; 1593 case IPC_STAT: 1594 (void)printf("IPC_STAT"); 1595 break; 1596 default: /* Should not reach */ 1597 (void)printf("<invalid=%d>", cmd); 1598 } 1599 } 1600 1601 1602 static void 1603 semgetname(int flag) 1604 { 1605 int or = 0; 1606 if_print_or(flag, IPC_CREAT, or); 1607 if_print_or(flag, IPC_EXCL, or); 1608 if_print_or(flag, SEM_R, or); 1609 if_print_or(flag, SEM_A, or); 1610 if_print_or(flag, (SEM_R>>3), or); 1611 if_print_or(flag, (SEM_A>>3), or); 1612 if_print_or(flag, (SEM_R>>6), or); 1613 if_print_or(flag, (SEM_A>>6), or); 1614 1615 if (flag & ~(IPC_CREAT|IPC_EXCL|SEM_R|SEM_A|((SEM_R|SEM_A)>>3)| 1616 ((SEM_R|SEM_A)>>6))) 1617 printf("<invalid=%#x>", flag); 1618 } 1619 1620 1621 /* 1622 * Only used by SYS_open and SYS_openat. Unless O_CREAT is set in flags, the 1623 * mode argument is unused (and often bogus and misleading). 1624 */ 1625 static void 1626 flagsandmodename(int mode) 1627 { 1628 openflagsname(arg1); 1629 if ((arg1 & O_CREAT) == O_CREAT) { 1630 (void)putchar(','); 1631 modename(mode); 1632 } else if (!fancy) 1633 (void)printf(",<unused>%#o", mode); 1634 } 1635 1636 static void 1637 clockname(int clockid) 1638 { 1639 clocktypename(__CLOCK_TYPE(clockid)); 1640 if (__CLOCK_PTID(clockid) != 0) 1641 printf("(%d)", __CLOCK_PTID(clockid)); 1642 } 1643 1644 /* 1645 * [g|s]etsockopt's level argument can either be SOL_SOCKET or a value 1646 * referring to a line in /etc/protocols. 1647 */ 1648 static void 1649 sockoptlevelname(int optname) 1650 { 1651 struct protoent *pe; 1652 1653 if (arg1 == SOL_SOCKET) { 1654 (void)printf("SOL_SOCKET,"); 1655 sockoptname(optname); 1656 } else { 1657 pe = getprotobynumber(arg1); 1658 (void)printf("%u<%s>,%d", arg1, 1659 pe != NULL ? pe->p_name : "unknown", optname); 1660 } 1661 } 1662 1663 static void 1664 ktraceopname(int ops) 1665 { 1666 int invalid = 0; 1667 1668 printf("%#x<", ops); 1669 switch (KTROP(ops)) { 1670 case KTROP_SET: 1671 printf("KTROP_SET"); 1672 break; 1673 case KTROP_CLEAR: 1674 printf("KTROP_CLEAR"); 1675 break; 1676 case KTROP_CLEARFILE: 1677 printf("KTROP_CLEARFILE"); 1678 break; 1679 default: 1680 printf("KTROP(%d)", KTROP(ops)); 1681 invalid = 1; 1682 break; 1683 } 1684 if (ops & KTRFLAG_DESCEND) printf("|KTRFLAG_DESCEND"); 1685 printf(">"); 1686 if (invalid || (ops & ~(KTROP((unsigned)-1) | KTRFLAG_DESCEND))) 1687 (void)printf("<invalid>%d", ops); 1688 } 1689