kdump.c revision 1.82
1 /* $NetBSD: kdump.c,v 1.82 2005/10/18 01:49:18 christos 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/cdefs.h> 33 #ifndef lint 34 __COPYRIGHT("@(#) Copyright (c) 1988, 1993\n\ 35 The Regents of the University of California. All rights reserved.\n"); 36 #endif /* not lint */ 37 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "@(#)kdump.c 8.4 (Berkeley) 4/28/95"; 41 #else 42 __RCSID("$NetBSD: kdump.c,v 1.82 2005/10/18 01:49:18 christos Exp $"); 43 #endif 44 #endif /* not lint */ 45 46 #include <sys/param.h> 47 #define _KERNEL 48 #include <sys/errno.h> 49 #undef _KERNEL 50 #include <sys/time.h> 51 #include <sys/uio.h> 52 #include <sys/ktrace.h> 53 #include <sys/ioctl.h> 54 #include <sys/ptrace.h> 55 56 #include <ctype.h> 57 #include <err.h> 58 #include <signal.h> 59 #include <stddef.h> 60 #include <stdio.h> 61 #include <stdlib.h> 62 #include <string.h> 63 #include <unistd.h> 64 #include <vis.h> 65 66 #include "ktrace.h" 67 #include "setemul.h" 68 69 #include <sys/syscall.h> 70 71 static int timestamp, decimal, plain, tail, maxdata = -1, numeric; 72 static int word_size = 0; 73 static pid_t do_pid = -1; 74 static const char *tracefile = NULL; 75 static struct ktr_header ktr_header; 76 static int emul_changed = 0; 77 78 #define eqs(s1, s2) (strcmp((s1), (s2)) == 0) 79 #define small(v) (((long)(v) >= 0) && ((long)(v) < 10)) 80 81 static const char * const ptrace_ops[] = { 82 "PT_TRACE_ME", "PT_READ_I", "PT_READ_D", "PT_READ_U", 83 "PT_WRITE_I", "PT_WRITE_D", "PT_WRITE_U", "PT_CONTINUE", 84 "PT_KILL", "PT_ATTACH", "PT_DETACH", "PT_IO", 85 "PT_DUMPCORE", "PT_LWPINFO" 86 }; 87 88 #ifdef PT_MACHDEP_STRINGS 89 static const char * const ptrace_machdep_ops[] = { PT_MACHDEP_STRINGS }; 90 #endif 91 92 static const char * const linux_ptrace_ops[] = { 93 "PTRACE_TRACEME", 94 "PTRACE_PEEKTEXT", "PTRACE_PEEKDATA", "PTRACE_PEEKUSER", 95 "PTRACE_POKETEXT", "PTRACE_POKEDATA", "PTRACE_POKEUSER", 96 "PTRACE_CONT", "PTRACE_KILL", "PTRACE_SINGLESTEP", 97 NULL, NULL, 98 "PTRACE_GETREGS", "PTRACE_SETREGS", "PTRACE_GETFPREGS", 99 "PTRACE_SETFPREGS", "PTRACE_ATTACH", "PTRACE_DETACH", 100 "PTRACE_SYSCALL", 101 }; 102 103 int main(int, char **); 104 static int fread_tail(void *, size_t, size_t); 105 static int dumpheader(struct ktr_header *); 106 static void output_long(u_long, int); 107 static void ioctldecode(u_long); 108 static void ktrsyscall(struct ktr_syscall *); 109 static void ktrsysret(struct ktr_sysret *, int); 110 static void ktrnamei(char *, int); 111 static void ktremul(char *, int, int); 112 static void ktrgenio(struct ktr_genio *, int); 113 static void ktrpsig(void *, int); 114 static void ktrcsw(struct ktr_csw *); 115 static void ktruser(struct ktr_user *, int); 116 static void ktrmmsg(struct ktr_mmsg *, int); 117 static void ktrmool(struct ktr_mool *, int); 118 static void usage(void) __attribute__((__noreturn__)); 119 static void eprint(int); 120 static void rprint(register_t); 121 static const char *signame(long, int); 122 static void hexdump_buf(const void *, int, int); 123 static void visdump_buf(const void *, int, int); 124 125 int 126 main(int argc, char **argv) 127 { 128 int ch, ktrlen, size; 129 void *m; 130 int trpoints = 0; 131 int trset = 0; 132 const char *emul_name = "netbsd"; 133 int col; 134 char *cp; 135 136 setprogname(argv[0]); 137 while ((ch = getopt(argc, argv, "e:f:dlm:Nnp:RTt:xX:")) != -1) { 138 switch (ch) { 139 case 'e': 140 emul_name = strdup(optarg); /* it's safer to copy it */ 141 break; 142 case 'f': 143 tracefile = optarg; 144 break; 145 case 'd': 146 decimal = 1; 147 break; 148 case 'l': 149 tail = 1; 150 break; 151 case 'p': 152 do_pid = strtoul(optarg, &cp, 0); 153 if (*cp != 0) 154 errx(1,"invalid number %s", optarg); 155 break; 156 case 'm': 157 maxdata = strtoul(optarg, &cp, 0); 158 if (*cp != 0) 159 errx(1,"invalid number %s", optarg); 160 break; 161 case 'N': 162 numeric++; 163 break; 164 case 'n': 165 plain++; 166 break; 167 case 'R': 168 timestamp = 2; /* relative timestamp */ 169 break; 170 case 'T': 171 timestamp = 1; 172 break; 173 case 't': 174 trset = 1; 175 trpoints = getpoints(trpoints, optarg); 176 if (trpoints < 0) 177 errx(1, "unknown trace point in %s", optarg); 178 break; 179 case 'x': 180 word_size = 1; 181 break; 182 case 'X': 183 word_size = strtoul(optarg, &cp, 0); 184 if (*cp != 0 || word_size & (word_size - 1) || 185 word_size > 16 || word_size <= 0) 186 errx(1, "argument to -X must be " 187 "1, 2, 4, 8 or 16"); 188 break; 189 default: 190 usage(); 191 } 192 } 193 argv += optind; 194 argc -= optind; 195 196 if (!trset) 197 trpoints = ALL_POINTS; 198 199 if (tracefile == NULL) { 200 if (argc == 1) { 201 tracefile = argv[0]; 202 argv++; 203 argc--; 204 } else 205 tracefile = DEF_TRACEFILE; 206 } 207 208 if (argc > 0) 209 usage(); 210 211 setemul(emul_name, 0, 0); 212 mach_lookup_emul(); 213 214 m = malloc(size = 1024); 215 if (m == NULL) 216 errx(1, "malloc: %s", strerror(ENOMEM)); 217 if (!freopen(tracefile, "r", stdin)) 218 err(1, "%s", tracefile); 219 while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) { 220 if (trpoints & (1 << ktr_header.ktr_type) && 221 (do_pid == -1 || ktr_header.ktr_pid == do_pid)) 222 col = dumpheader(&ktr_header); 223 else 224 col = -1; 225 if ((ktrlen = ktr_header.ktr_len) < 0) 226 errx(1, "bogus length 0x%x", ktrlen); 227 if (ktrlen > size) { 228 while (ktrlen > size) 229 size *= 2; 230 m = realloc(m, size); 231 if (m == NULL) 232 errx(1, "realloc: %s", strerror(ENOMEM)); 233 } 234 if (ktrlen && fread_tail(m, ktrlen, 1) == 0) 235 errx(1, "data too short"); 236 if (col == -1) 237 continue; 238 239 /* update context to match currently processed record */ 240 ectx_sanify(ktr_header.ktr_pid); 241 242 switch (ktr_header.ktr_type) { 243 case KTR_SYSCALL: 244 ktrsyscall(m); 245 break; 246 case KTR_SYSRET: 247 ktrsysret(m, ktrlen); 248 break; 249 case KTR_NAMEI: 250 ktrnamei(m, ktrlen); 251 break; 252 case KTR_GENIO: 253 ktrgenio(m, ktrlen); 254 break; 255 case KTR_PSIG: 256 ktrpsig(m, ktrlen); 257 break; 258 case KTR_CSW: 259 ktrcsw(m); 260 break; 261 case KTR_EMUL: 262 ktremul(m, ktrlen, size); 263 break; 264 case KTR_USER: 265 ktruser(m, ktrlen); 266 break; 267 case KTR_MMSG: 268 ktrmmsg(m, ktrlen); 269 break; 270 case KTR_MOOL: 271 ktrmool(m, ktrlen); 272 break; 273 case KTR_EXEC_ARG: 274 case KTR_EXEC_ENV: 275 visdump_buf(m, ktrlen, col); 276 break; 277 default: 278 putchar('\n'); 279 hexdump_buf(m, ktrlen, word_size ? word_size : 1); 280 } 281 if (tail) 282 (void)fflush(stdout); 283 } 284 return (0); 285 } 286 287 static int 288 fread_tail(void *buf, size_t num, size_t size) 289 { 290 int i; 291 292 while ((i = fread(buf, size, num, stdin)) == 0 && tail) { 293 (void)sleep(1); 294 clearerr(stdin); 295 } 296 return (i); 297 } 298 299 static int 300 dumpheader(struct ktr_header *kth) 301 { 302 char unknown[64]; 303 const char *type; 304 static struct timeval prevtime; 305 struct timeval temp; 306 int col; 307 308 switch (kth->ktr_type) { 309 case KTR_SYSCALL: 310 type = "CALL"; 311 break; 312 case KTR_SYSRET: 313 type = "RET "; 314 break; 315 case KTR_NAMEI: 316 type = "NAMI"; 317 break; 318 case KTR_GENIO: 319 type = "GIO "; 320 break; 321 case KTR_PSIG: 322 type = "PSIG"; 323 break; 324 case KTR_CSW: 325 type = "CSW "; 326 break; 327 case KTR_EMUL: 328 type = "EMUL"; 329 break; 330 case KTR_USER: 331 type = "USER"; 332 break; 333 case KTR_MMSG: 334 type = "MMSG"; 335 break; 336 case KTR_MOOL: 337 type = "MOOL"; 338 break; 339 case KTR_EXEC_ENV: 340 type = "ENV"; 341 break; 342 case KTR_EXEC_ARG: 343 type = "ARG"; 344 break; 345 default: 346 (void)snprintf(unknown, sizeof(unknown), "UNKNOWN(%d)", 347 kth->ktr_type); 348 type = unknown; 349 } 350 351 col = printf("%6d %-8.*s ", kth->ktr_pid, MAXCOMLEN, kth->ktr_comm); 352 if (timestamp) { 353 if (timestamp == 2) { 354 if (prevtime.tv_sec == 0) 355 temp.tv_sec = temp.tv_usec = 0; 356 else 357 timersub(&kth->ktr_time, &prevtime, &temp); 358 prevtime = kth->ktr_time; 359 } else 360 temp = kth->ktr_time; 361 col += printf("%ld.%06ld ", 362 (long int)temp.tv_sec, (long int)temp.tv_usec); 363 } 364 col += printf("%-4s ", type); 365 return col; 366 } 367 368 static void 369 output_long(u_long it, int as_x) 370 { 371 if (cur_emul->flags & EMUL_FLAG_NETBSD32) 372 printf(as_x ? "%#x" : "%d", (u_int)it); 373 else 374 printf(as_x ? "%#lx" : "%ld", it); 375 } 376 377 static void 378 ioctldecode(u_long cmd) 379 { 380 char dirbuf[4], *dir = dirbuf; 381 382 if (cmd & IOC_IN) 383 *dir++ = 'W'; 384 if (cmd & IOC_OUT) 385 *dir++ = 'R'; 386 *dir = '\0'; 387 388 printf(",_IO%s('%c',", dirbuf, (int) ((cmd >> 8) & 0xff)); 389 output_long(cmd & 0xff, decimal == 0); 390 if ((cmd & IOC_VOID) == 0) { 391 putchar(','); 392 output_long((cmd >> 16) & 0xff, decimal == 0); 393 } 394 putchar(')'); 395 } 396 397 static void 398 ktrsyscall(struct ktr_syscall *ktr) 399 { 400 int argcount; 401 const struct emulation *emul = cur_emul; 402 register_t *ap; 403 char c; 404 const char *cp; 405 const char *sys_name; 406 407 argcount = ktr->ktr_argsize / sizeof (*ap); 408 409 emul_changed = 0; 410 411 if (numeric || 412 ((ktr->ktr_code >= emul->nsysnames || ktr->ktr_code < 0) && 413 mach_traps_dispatch(&ktr->ktr_code, &emul) == 0)) { 414 sys_name = "?"; 415 (void)printf("[%d]", ktr->ktr_code); 416 } else { 417 sys_name = emul->sysnames[ktr->ktr_code]; 418 (void)printf("%s", sys_name); 419 } 420 #ifdef _LP64 421 #define NETBSD32_ "netbsd32_" 422 if (cur_emul->flags & EMUL_FLAG_NETBSD32) { 423 size_t len = strlen(NETBSD32_); 424 if (strncmp(sys_name, NETBSD32_, len) == 0) 425 sys_name += len; 426 } 427 #undef NETBSD32_ 428 #endif 429 430 ap = (register_t *)((char *)ktr + sizeof(struct ktr_syscall)); 431 if (argcount) { 432 c = '('; 433 if (plain) { 434 ; 435 436 } else if (strcmp(sys_name, "exit") == 0) { 437 ectx_delete(); 438 439 } else if (strcmp(sys_name, "ioctl") == 0 && argcount >= 2) { 440 (void)putchar('('); 441 output_long((long)*ap, !(decimal || small(*ap))); 442 ap++; 443 argcount--; 444 if ((cp = ioctlname(*ap)) != NULL) 445 (void)printf(",%s", cp); 446 else 447 ioctldecode(*ap); 448 ap++; 449 argcount--; 450 c = ','; 451 452 } else if ((strstr(sys_name, "sigaction") != NULL || 453 strstr(sys_name, "sigvec") != NULL) && argcount >= 1) { 454 (void)printf("(SIG%s", signame(ap[0], 1)); 455 ap += 1; 456 argcount -= 1; 457 c = ','; 458 459 } else if ((strcmp(sys_name, "kill") == 0 || 460 strcmp(sys_name, "killpg") == 0) && argcount >= 2) { 461 putchar('('); 462 output_long((long)ap[0], !(decimal || small(*ap))); 463 (void)printf(", SIG%s", signame(ap[1], 1)); 464 ap += 2; 465 argcount -= 2; 466 c = ','; 467 468 } else if (strcmp(sys_name, "ptrace") == 0 && argcount >= 1) { 469 putchar('('); 470 if (strcmp(emul->name, "linux") == 0) { 471 if (*ap >= 0 && *ap < 472 sizeof(linux_ptrace_ops) / 473 sizeof(linux_ptrace_ops[0])) 474 (void)printf("%s", 475 linux_ptrace_ops[*ap]); 476 else 477 output_long((long)*ap, 1); 478 } else { 479 if (*ap >= 0 && *ap < 480 sizeof(ptrace_ops) / sizeof(ptrace_ops[0])) 481 (void)printf("%s", ptrace_ops[*ap]); 482 #ifdef PT_MACHDEP_STRINGS 483 else if (*ap >= PT_FIRSTMACH && 484 *ap - PT_FIRSTMACH < 485 sizeof(ptrace_machdep_ops) / 486 sizeof(ptrace_machdep_ops[0])) 487 (void)printf("%s", ptrace_machdep_ops[*ap - PT_FIRSTMACH]); 488 #endif 489 else 490 output_long((long)*ap, 1); 491 } 492 ap++; 493 argcount--; 494 c = ','; 495 496 } 497 while (argcount > 0) { 498 putchar(c); 499 output_long((long)*ap, !(decimal || small(*ap))); 500 ap++; 501 argcount--; 502 c = ','; 503 } 504 (void)putchar(')'); 505 } 506 (void)putchar('\n'); 507 } 508 509 static void 510 ktrsysret(struct ktr_sysret *ktr, int len) 511 { 512 const struct emulation *emul; 513 int error = ktr->ktr_error; 514 int code = ktr->ktr_code; 515 516 if (emul_changed) { 517 /* In order to get system call name right in execve return */ 518 emul = prev_emul; 519 emul_changed = 0; 520 } else 521 emul = cur_emul; 522 523 if ((code >= emul->nsysnames || code < 0 || plain > 1) && 524 (mach_traps_dispatch(&code, &emul) == 0)) 525 (void)printf("[%d] ", code); 526 else 527 (void)printf("%s ", emul->sysnames[code]); 528 529 switch (error) { 530 case 0: 531 rprint(ktr->ktr_retval); 532 if (len > offsetof(struct ktr_sysret, ktr_retval_1) && 533 ktr->ktr_retval_1 != 0) { 534 (void)printf(", "); 535 rprint(ktr->ktr_retval_1); 536 } 537 break; 538 539 default: 540 eprint(error); 541 break; 542 } 543 (void)putchar('\n'); 544 } 545 546 static void 547 rprint(register_t ret) 548 { 549 550 if (!plain) { 551 (void)printf("%ld", (long)ret); 552 if (!small(ret)) 553 (void)printf("/%#lx", (long)ret); 554 } else { 555 if (decimal || small(ret)) 556 (void)printf("%ld", (long)ret); 557 else 558 (void)printf("%#lx", (long)ret); 559 } 560 } 561 562 /* 563 * We print the original emulation's error numerically, but we 564 * translate it to netbsd to print it symbolically. 565 */ 566 static void 567 eprint(int e) 568 { 569 int i = e; 570 571 if (cur_emul->errnomap) { 572 573 /* No remapping for ERESTART and EJUSTRETURN */ 574 /* Kludge for linux that has negative error numbers */ 575 if (cur_emul->errnomap[2] > 0 && e < 0) 576 goto normal; 577 578 for (i = 0; i < cur_emul->nerrnomap; i++) 579 if (e == cur_emul->errnomap[i]) 580 break; 581 582 if (i == cur_emul->nerrnomap) { 583 printf("-1 unknown errno %d", e); 584 return; 585 } 586 } 587 588 normal: 589 switch (i) { 590 case ERESTART: 591 (void)printf("RESTART"); 592 break; 593 594 case EJUSTRETURN: 595 (void)printf("JUSTRETURN"); 596 break; 597 598 default: 599 (void)printf("-1 errno %d", e); 600 if (!plain) 601 (void)printf(" %s", strerror(i)); 602 } 603 } 604 605 static void 606 ktrnamei(char *cp, int len) 607 { 608 609 (void)printf("\"%.*s\"\n", len, cp); 610 } 611 612 static void 613 ktremul(char *name, int len, int bufsize) 614 { 615 616 if (len >= bufsize) 617 len = bufsize - 1; 618 619 name[len] = '\0'; 620 setemul(name, ktr_header.ktr_pid, 1); 621 emul_changed = 1; 622 623 (void)printf("\"%s\"\n", name); 624 } 625 626 static void 627 hexdump_buf(const void *vdp, int datalen, int word_sz) 628 { 629 const char hex[] = "0123456789abcdef"; 630 char chars[16], prev[16]; 631 char bytes[16 * 3 + 4]; 632 const unsigned char *dp = vdp; 633 const unsigned char *datalim = dp + datalen; 634 const unsigned char *line_end; 635 int off, l = 0, c; 636 char *cp, *bp; 637 int divmask = word_sz - 1; /* block size in bytes */ 638 int gdelim = 3; /* gap between blocks */ 639 int bsize = 2; /* increment for each byte */ 640 int width; 641 int dupl = 0; 642 #if _BYTE_ORDER == _LITTLE_ENDIAN 643 int bswap = word_sz - 1; 644 #else 645 #define bswap 0 646 #endif 647 648 switch (word_sz) { 649 case 2: 650 gdelim = 2; 651 break; 652 case 1: 653 divmask = 7; 654 bsize = 3; 655 gdelim = 1; 656 break; 657 default: 658 break; 659 } 660 width = 16 * bsize + (16 / (divmask + 1)) * gdelim; 661 if (word_sz != 1) 662 width += 2; 663 664 for (off = 0; dp < datalim; off += l) { 665 memset(bytes, ' ', sizeof bytes); 666 line_end = dp + 16; 667 if (line_end >= datalim) { 668 line_end = datalim; 669 dupl |= 1; /* need to print */ 670 } else { 671 if (dupl == 0 || memcmp(dp, prev, sizeof chars)) 672 dupl |= 1; 673 } 674 675 if (!(dupl & 1)) { 676 /* This is a duplicate of the line above, count 'em */ 677 dupl += 2; 678 dp = line_end; 679 continue; 680 } 681 682 if (dupl > 3) { 683 /* previous line as a duplicate */ 684 if (dupl == 5) 685 /* Only one duplicate, print line */ 686 printf("\t%-5.3x%.*s%.*s\n", 687 off - l, width, bytes, l, chars); 688 else 689 printf("\t%.*s\n", 690 snprintf(NULL, 0, "%3x", off), "*****"); 691 } 692 693 for (l = 0, bp = bytes, cp = chars; dp < line_end; l++) { 694 c = *dp++; 695 prev[l] = c; 696 if ((l & divmask) == 0) 697 bp += gdelim; 698 bp[(l ^ bswap) * bsize] = hex[c >> 4]; 699 bp[(l ^ bswap) * bsize + 1] = hex[c & 0xf]; 700 *cp++ = isgraph(c) ? c : '.'; 701 } 702 703 printf("\t%-5.3x%.*s%.*s\n", off, width, bytes, l, chars); 704 dupl = 2; 705 } 706 } 707 708 static void 709 visdump_buf(const void *vdp, int datalen, int col) 710 { 711 const unsigned char *dp = vdp; 712 char *cp; 713 int width; 714 char visbuf[5]; 715 static int screenwidth = 0; 716 717 if (screenwidth == 0) { 718 struct winsize ws; 719 720 if (!plain && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 && 721 ws.ws_col > 8) 722 screenwidth = ws.ws_col; 723 else 724 screenwidth = 80; 725 } 726 727 (void)printf("\""); 728 col++; 729 for (; datalen > 0; datalen--, dp++) { 730 (void)svis(visbuf, *dp, VIS_CSTYLE, 731 datalen > 1 ? *(dp + 1) : 0, "\""); 732 cp = visbuf; 733 /* 734 * Keep track of printables and 735 * space chars (like fold(1)). 736 */ 737 if (col == 0) { 738 (void)putchar('\t'); 739 col = 8; 740 } 741 switch (*cp) { 742 case '\n': 743 col = 0; 744 (void)putchar('\n'); 745 continue; 746 case '\t': 747 width = 8 - (col & 07); 748 break; 749 default: 750 width = strlen(cp); 751 } 752 if (col + width > (screenwidth - 2)) { 753 (void)printf("\\\n\t"); 754 col = 8; 755 if (*cp == '\t') 756 width = 8; 757 } 758 col += width; 759 do { 760 (void)putchar(*cp++); 761 } while (*cp); 762 } 763 if (col == 0) 764 (void)printf(" "); 765 (void)printf("\"\n"); 766 } 767 768 static void 769 ktrgenio(struct ktr_genio *ktr, int len) 770 { 771 int datalen = len - sizeof (struct ktr_genio); 772 char *dp = (char *)ktr + sizeof (struct ktr_genio); 773 774 printf("fd %d %s %d bytes\n", ktr->ktr_fd, 775 ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen); 776 if (maxdata == 0) 777 return; 778 if (maxdata > 0 && datalen > maxdata) 779 datalen = maxdata; 780 if (word_size) { 781 hexdump_buf(dp, datalen, word_size); 782 return; 783 } 784 (void)printf(" "); 785 visdump_buf(dp, datalen, 7); 786 } 787 788 static void 789 ktrpsig(void *v, int len) 790 { 791 int signo, first; 792 struct { 793 struct ktr_psig ps; 794 siginfo_t si; 795 } *psig = v; 796 siginfo_t *si = &psig->si; 797 const char *code; 798 799 (void)printf("SIG%s ", signame(psig->ps.signo, 0)); 800 if (psig->ps.action == SIG_DFL) 801 (void)printf("SIG_DFL"); 802 else { 803 (void)printf("caught handler=%p mask=(", psig->ps.action); 804 first = 1; 805 for (signo = 1; signo < NSIG; signo++) { 806 if (sigismember(&psig->ps.mask, signo)) { 807 if (first) 808 first = 0; 809 else 810 (void)printf(","); 811 (void)printf("%d", signo); 812 } 813 } 814 (void)printf(")"); 815 } 816 switch (len) { 817 case sizeof(struct ktr_psig): 818 if (psig->ps.code) 819 printf(" code=0x%x", psig->ps.code); 820 printf(psig->ps.action == SIG_DFL ? "\n" : ")\n"); 821 return; 822 case sizeof(*psig): 823 if (si->si_code == 0) { 824 printf(": code=SI_USER sent by pid=%d, uid=%d)\n", 825 si->si_pid, si->si_uid); 826 return; 827 } 828 829 if (si->si_code < 0) { 830 switch (si->si_code) { 831 case SI_TIMER: 832 printf(": code=SI_TIMER sigval %p)\n", 833 si->si_sigval.sival_ptr); 834 return; 835 case SI_QUEUE: 836 code = "SI_QUEUE"; 837 break; 838 case SI_ASYNCIO: 839 code = "SI_ASYNCIO"; 840 break; 841 case SI_MESGQ: 842 code = "SI_MESGQ"; 843 break; 844 default: 845 code = NULL; 846 break; 847 } 848 if (code) 849 printf(": code=%s unimplemented)\n", code); 850 else 851 printf(": code=%d unimplemented)\n", 852 si->si_code); 853 return; 854 } 855 856 code = siginfocodename(si->si_signo, si->si_code); 857 switch (si->si_signo) { 858 case SIGCHLD: 859 printf(": code=%s child pid=%d, uid=%d, " 860 " status=%u, utime=%lu, stime=%lu)\n", 861 code, si->si_pid, 862 si->si_uid, si->si_status, 863 (unsigned long) si->si_utime, 864 (unsigned long) si->si_stime); 865 return; 866 case SIGILL: 867 case SIGFPE: 868 case SIGSEGV: 869 case SIGBUS: 870 case SIGTRAP: 871 printf(": code=%s, addr=%p, trap=%d)\n", 872 code, si->si_addr, si->si_trap); 873 return; 874 case SIGIO: 875 printf(": code=%s, fd=%d, band=%lx)\n", 876 code, si->si_fd, si->si_band); 877 return; 878 default: 879 printf(": code=%s, errno=%d)\n", 880 code, si->si_errno); 881 return; 882 } 883 /*NOTREACHED*/ 884 default: 885 warnx("Unhandled size %d for ktrpsig\n", len); 886 break; 887 } 888 } 889 890 static void 891 ktrcsw(struct ktr_csw *cs) 892 { 893 894 (void)printf("%s %s\n", cs->out ? "stop" : "resume", 895 cs->user ? "user" : "kernel"); 896 } 897 898 static void 899 ktruser(struct ktr_user *usr, int len) 900 { 901 int i; 902 unsigned char *dta; 903 904 printf("\"%.*s: %d, ", KTR_USER_MAXIDLEN, usr->ktr_id, len); 905 dta = (unsigned char *)usr; 906 for (i = sizeof(struct ktr_user); i < len; i++) 907 printf("%02x", (unsigned int) dta[i]); 908 printf("\"\n"); 909 } 910 911 static void 912 ktrmmsg(struct ktr_mmsg *mmsg, int len) 913 { 914 const char *service_name; 915 const char *reply; 916 int id; 917 918 id = mmsg->ktr_id; 919 if ((id / 100) % 2) { /* Message reply */ 920 reply = " reply"; 921 id -= 100; 922 } else { 923 reply = ""; 924 } 925 926 if ((service_name = mach_service_name(id)) != NULL) 927 printf("%s%s [%d]\n", service_name, reply, mmsg->ktr_id); 928 else 929 printf("unknown service%s [%d]\n", reply, mmsg->ktr_id); 930 931 hexdump_buf(mmsg, len, word_size ? word_size : 4); 932 } 933 934 static void 935 ktrmool(struct ktr_mool *mool, int len) 936 { 937 size_t size = mool->size; 938 939 printf("%ld/0x%lx bytes at %p\n", 940 (u_long)size, (u_long)size, mool->uaddr); 941 mool++; 942 hexdump_buf(mool, size, word_size ? word_size : 4); 943 } 944 945 static const char * 946 signame(long sig, int xlat) 947 { 948 static char buf[64]; 949 950 if (sig == 0) 951 return " 0"; 952 else if (sig < 0 || sig >= NSIG) { 953 (void)snprintf(buf, sizeof(buf), "*unknown %ld*", sig); 954 return buf; 955 } else 956 return sys_signame[(xlat && cur_emul->signalmap != NULL) ? 957 cur_emul->signalmap[sig] : sig]; 958 } 959 960 static void 961 usage(void) 962 { 963 964 (void)fprintf(stderr, "Usage: %s [-dlNnRT] [-e emulation] " 965 "[-f file] [-m maxdata] [-p pid]\n [-t trstr] " 966 "[-x | -X size] [file]\n", getprogname()); 967 exit(1); 968 } 969
Indexes created Tue Sep 23 13:09:54 GMT 2025