1 /*- 2 * Copyright (c) 1988, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #ifndef lint 31 static const char copyright[] = 32 "@(#) Copyright (c) 1988, 1993\n\ 33 The Regents of the University of California. All rights reserved.\n"; 34 #endif /* not lint */ 35 36 #ifndef lint 37 #if 0 38 static char sccsid[] = "@(#)kdump.c 8.1 (Berkeley) 6/6/93"; 39 #endif 40 #endif /* not lint */ 41 #include <sys/cdefs.h> 42 __FBSDID("$FreeBSD$"); 43 44 #define _KERNEL 45 extern int errno; 46 #include <sys/errno.h> 47 #undef _KERNEL 48 #include <sys/param.h> 49 #include <sys/capability.h> 50 #include <sys/errno.h> 51 #define _KERNEL 52 #include <sys/time.h> 53 #undef _KERNEL 54 #include <sys/uio.h> 55 #include <sys/ktrace.h> 56 #include <sys/ioctl.h> 57 #include <sys/socket.h> 58 #include <sys/stat.h> 59 #include <sys/sysent.h> 60 #include <sys/un.h> 61 #include <sys/queue.h> 62 #ifdef IPX 63 #include <sys/types.h> 64 #include <netipx/ipx.h> 65 #endif 66 #ifdef NETATALK 67 #include <netatalk/at.h> 68 #endif 69 #include <arpa/inet.h> 70 #include <netinet/in.h> 71 #include <ctype.h> 72 #include <dlfcn.h> 73 #include <err.h> 74 #include <grp.h> 75 #include <inttypes.h> 76 #include <locale.h> 77 #include <netdb.h> 78 #include <nl_types.h> 79 #include <pwd.h> 80 #include <stdio.h> 81 #include <stdlib.h> 82 #include <string.h> 83 #include <termios.h> 84 #include <time.h> 85 #include <unistd.h> 86 #include <vis.h> 87 #include "ktrace.h" 88 #include "kdump_subr.h" 89 90 u_int abidump(struct ktr_header *); 91 int fetchprocinfo(struct ktr_header *, u_int *); 92 int fread_tail(void *, int, int); 93 void dumpheader(struct ktr_header *); 94 void ktrsyscall(struct ktr_syscall *, u_int); 95 void ktrsysret(struct ktr_sysret *, u_int); 96 void ktrnamei(char *, int); 97 void hexdump(char *, int, int); 98 void visdump(char *, int, int); 99 void ktrgenio(struct ktr_genio *, int); 100 void ktrpsig(struct ktr_psig *); 101 void ktrcsw(struct ktr_csw *); 102 void ktrcsw_old(struct ktr_csw_old *); 103 void ktruser_malloc(unsigned char *); 104 void ktruser_rtld(int, unsigned char *); 105 void ktruser(int, unsigned char *); 106 void ktrsockaddr(struct sockaddr *); 107 void ktrstat(struct stat *); 108 void ktrstruct(char *, size_t); 109 void ktrcapfail(struct ktr_cap_fail *); 110 void ktrfault(struct ktr_fault *); 111 void ktrfaultend(struct ktr_faultend *); 112 void limitfd(int fd); 113 void usage(void); 114 void ioctlname(unsigned long, int); 115 116 int timestamp, decimal, fancy = 1, suppressdata, tail, threads, maxdata, 117 resolv = 0, abiflag = 0; 118 const char *tracefile = DEF_TRACEFILE; 119 struct ktr_header ktr_header; 120 121 #define TIME_FORMAT "%b %e %T %Y" 122 #define eqs(s1, s2) (strcmp((s1), (s2)) == 0) 123 124 #define print_number(i,n,c) do { \ 125 if (decimal) \ 126 printf("%c%jd", c, (intmax_t)*i); \ 127 else \ 128 printf("%c%#jx", c, (uintmax_t)(u_register_t)*i); \ 129 i++; \ 130 n--; \ 131 c = ','; \ 132 } while (0) 133 134 #if defined(__amd64__) || defined(__i386__) 135 136 void linux_ktrsyscall(struct ktr_syscall *); 137 void linux_ktrsysret(struct ktr_sysret *); 138 extern char *linux_syscallnames[]; 139 extern int nlinux_syscalls; 140 141 /* 142 * from linux.h 143 * Linux syscalls return negative errno's, we do positive and map them 144 */ 145 static int bsd_to_linux_errno[ELAST + 1] = { 146 -0, -1, -2, -3, -4, -5, -6, -7, -8, -9, 147 -10, -35, -12, -13, -14, -15, -16, -17, -18, -19, 148 -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, 149 -30, -31, -32, -33, -34, -11,-115,-114, -88, -89, 150 -90, -91, -92, -93, -94, -95, -96, -97, -98, -99, 151 -100,-101,-102,-103,-104,-105,-106,-107,-108,-109, 152 -110,-111, -40, -36,-112,-113, -39, -11, -87,-122, 153 -116, -66, -6, -6, -6, -6, -6, -37, -38, -9, 154 -6, -6, -43, -42, -75,-125, -84, -95, -16, -74, 155 -72, -67, -71 156 }; 157 #endif 158 159 struct proc_info 160 { 161 TAILQ_ENTRY(proc_info) info; 162 u_int sv_flags; 163 pid_t pid; 164 }; 165 166 TAILQ_HEAD(trace_procs, proc_info) trace_procs; 167 168 static void 169 strerror_init(void) 170 { 171 172 /* 173 * Cache NLS data before entering capability mode. 174 * XXXPJD: There should be strerror_init() and strsignal_init() in libc. 175 */ 176 (void)catopen("libc", NL_CAT_LOCALE); 177 } 178 179 static void 180 localtime_init(void) 181 { 182 time_t ltime; 183 184 /* 185 * Allow localtime(3) to cache /etc/localtime content before entering 186 * capability mode. 187 * XXXPJD: There should be localtime_init() in libc. 188 */ 189 (void)time(<ime); 190 (void)localtime(<ime); 191 } 192 193 int 194 main(int argc, char *argv[]) 195 { 196 int ch, ktrlen, size; 197 void *m; 198 int trpoints = ALL_POINTS; 199 int drop_logged; 200 pid_t pid = 0; 201 u_int sv_flags; 202 203 setlocale(LC_CTYPE, ""); 204 205 while ((ch = getopt(argc,argv,"f:dElm:np:AHRrsTt:")) != -1) 206 switch (ch) { 207 case 'A': 208 abiflag = 1; 209 break; 210 case 'f': 211 tracefile = optarg; 212 break; 213 case 'd': 214 decimal = 1; 215 break; 216 case 'l': 217 tail = 1; 218 break; 219 case 'm': 220 maxdata = atoi(optarg); 221 break; 222 case 'n': 223 fancy = 0; 224 break; 225 case 'p': 226 pid = atoi(optarg); 227 break; 228 case 'r': 229 resolv = 1; 230 break; 231 case 's': 232 suppressdata = 1; 233 break; 234 case 'E': 235 timestamp = 3; /* elapsed timestamp */ 236 break; 237 case 'H': 238 threads = 1; 239 break; 240 case 'R': 241 timestamp = 2; /* relative timestamp */ 242 break; 243 case 'T': 244 timestamp = 1; 245 break; 246 case 't': 247 trpoints = getpoints(optarg); 248 if (trpoints < 0) 249 errx(1, "unknown trace point in %s", optarg); 250 break; 251 default: 252 usage(); 253 } 254 255 if (argc > optind) 256 usage(); 257 258 m = malloc(size = 1025); 259 if (m == NULL) 260 errx(1, "%s", strerror(ENOMEM)); 261 if (!freopen(tracefile, "r", stdin)) 262 err(1, "%s", tracefile); 263 264 strerror_init(); 265 localtime_init(); 266 267 if (resolv == 0) { 268 if (cap_enter() < 0 && errno != ENOSYS) 269 err(1, "unable to enter capability mode"); 270 } 271 limitfd(STDIN_FILENO); 272 limitfd(STDOUT_FILENO); 273 limitfd(STDERR_FILENO); 274 275 TAILQ_INIT(&trace_procs); 276 drop_logged = 0; 277 while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) { 278 if (ktr_header.ktr_type & KTR_DROP) { 279 ktr_header.ktr_type &= ~KTR_DROP; 280 if (!drop_logged && threads) { 281 printf( 282 "%6jd %6jd %-8.*s Events dropped.\n", 283 (intmax_t)ktr_header.ktr_pid, 284 ktr_header.ktr_tid > 0 ? 285 (intmax_t)ktr_header.ktr_tid : 0, 286 MAXCOMLEN, ktr_header.ktr_comm); 287 drop_logged = 1; 288 } else if (!drop_logged) { 289 printf("%6jd %-8.*s Events dropped.\n", 290 (intmax_t)ktr_header.ktr_pid, MAXCOMLEN, 291 ktr_header.ktr_comm); 292 drop_logged = 1; 293 } 294 } 295 if (trpoints & (1<<ktr_header.ktr_type)) 296 if (pid == 0 || ktr_header.ktr_pid == pid || 297 ktr_header.ktr_tid == pid) 298 dumpheader(&ktr_header); 299 if ((ktrlen = ktr_header.ktr_len) < 0) 300 errx(1, "bogus length 0x%x", ktrlen); 301 if (ktrlen > size) { 302 m = realloc(m, ktrlen+1); 303 if (m == NULL) 304 errx(1, "%s", strerror(ENOMEM)); 305 size = ktrlen; 306 } 307 if (ktrlen && fread_tail(m, ktrlen, 1) == 0) 308 errx(1, "data too short"); 309 if (fetchprocinfo(&ktr_header, (u_int *)m) != 0) 310 continue; 311 sv_flags = abidump(&ktr_header); 312 if (pid && ktr_header.ktr_pid != pid && 313 ktr_header.ktr_tid != pid) 314 continue; 315 if ((trpoints & (1<<ktr_header.ktr_type)) == 0) 316 continue; 317 drop_logged = 0; 318 switch (ktr_header.ktr_type) { 319 case KTR_SYSCALL: 320 #if defined(__amd64__) || defined(__i386__) 321 if ((sv_flags & SV_ABI_MASK) == SV_ABI_LINUX) 322 linux_ktrsyscall((struct ktr_syscall *)m); 323 else 324 #endif 325 ktrsyscall((struct ktr_syscall *)m, sv_flags); 326 break; 327 case KTR_SYSRET: 328 #if defined(__amd64__) || defined(__i386__) 329 if ((sv_flags & SV_ABI_MASK) == SV_ABI_LINUX) 330 linux_ktrsysret((struct ktr_sysret *)m); 331 else 332 #endif 333 ktrsysret((struct ktr_sysret *)m, sv_flags); 334 break; 335 case KTR_NAMEI: 336 case KTR_SYSCTL: 337 ktrnamei(m, ktrlen); 338 break; 339 case KTR_GENIO: 340 ktrgenio((struct ktr_genio *)m, ktrlen); 341 break; 342 case KTR_PSIG: 343 ktrpsig((struct ktr_psig *)m); 344 break; 345 case KTR_CSW: 346 if (ktrlen == sizeof(struct ktr_csw_old)) 347 ktrcsw_old((struct ktr_csw_old *)m); 348 else 349 ktrcsw((struct ktr_csw *)m); 350 break; 351 case KTR_USER: 352 ktruser(ktrlen, m); 353 break; 354 case KTR_STRUCT: 355 ktrstruct(m, ktrlen); 356 break; 357 case KTR_CAPFAIL: 358 ktrcapfail((struct ktr_cap_fail *)m); 359 break; 360 case KTR_FAULT: 361 ktrfault((struct ktr_fault *)m); 362 break; 363 case KTR_FAULTEND: 364 ktrfaultend((struct ktr_faultend *)m); 365 break; 366 default: 367 printf("\n"); 368 break; 369 } 370 if (tail) 371 fflush(stdout); 372 } 373 return 0; 374 } 375 376 void 377 limitfd(int fd) 378 { 379 cap_rights_t rights; 380 unsigned long cmd; 381 382 rights = CAP_FSTAT; 383 cmd = -1; 384 385 switch (fd) { 386 case STDIN_FILENO: 387 rights |= CAP_READ; 388 break; 389 case STDOUT_FILENO: 390 rights |= CAP_IOCTL | CAP_WRITE; 391 cmd = TIOCGETA; /* required by isatty(3) in printf(3) */ 392 break; 393 case STDERR_FILENO: 394 rights |= CAP_WRITE; 395 if (!suppressdata) { 396 rights |= CAP_IOCTL; 397 cmd = TIOCGWINSZ; 398 } 399 break; 400 default: 401 abort(); 402 } 403 404 if (cap_rights_limit(fd, rights) < 0 && errno != ENOSYS) 405 err(1, "unable to limit rights for descriptor %d", fd); 406 if (cmd != -1 && cap_ioctls_limit(fd, &cmd, 1) < 0 && errno != ENOSYS) 407 err(1, "unable to limit ioctls for descriptor %d", fd); 408 } 409 410 int 411 fread_tail(void *buf, int size, int num) 412 { 413 int i; 414 415 while ((i = fread(buf, size, num, stdin)) == 0 && tail) { 416 sleep(1); 417 clearerr(stdin); 418 } 419 return (i); 420 } 421 422 int 423 fetchprocinfo(struct ktr_header *kth, u_int *flags) 424 { 425 struct proc_info *pi; 426 427 switch (kth->ktr_type) { 428 case KTR_PROCCTOR: 429 TAILQ_FOREACH(pi, &trace_procs, info) { 430 if (pi->pid == kth->ktr_pid) { 431 TAILQ_REMOVE(&trace_procs, pi, info); 432 break; 433 } 434 } 435 pi = malloc(sizeof(struct proc_info)); 436 if (pi == NULL) 437 errx(1, "%s", strerror(ENOMEM)); 438 pi->sv_flags = *flags; 439 pi->pid = kth->ktr_pid; 440 TAILQ_INSERT_TAIL(&trace_procs, pi, info); 441 return (1); 442 443 case KTR_PROCDTOR: 444 TAILQ_FOREACH(pi, &trace_procs, info) { 445 if (pi->pid == kth->ktr_pid) { 446 TAILQ_REMOVE(&trace_procs, pi, info); 447 free(pi); 448 break; 449 } 450 } 451 return (1); 452 } 453 454 return (0); 455 } 456 457 u_int 458 abidump(struct ktr_header *kth) 459 { 460 struct proc_info *pi; 461 const char *abi; 462 const char *arch; 463 u_int flags = 0; 464 465 TAILQ_FOREACH(pi, &trace_procs, info) { 466 if (pi->pid == kth->ktr_pid) { 467 flags = pi->sv_flags; 468 break; 469 } 470 } 471 472 if (abiflag == 0) 473 return (flags); 474 475 switch (flags & SV_ABI_MASK) { 476 case SV_ABI_LINUX: 477 abi = "L"; 478 break; 479 case SV_ABI_FREEBSD: 480 abi = "F"; 481 break; 482 default: 483 abi = "U"; 484 break; 485 } 486 487 if (flags != 0) { 488 if (flags & SV_LP64) 489 arch = "64"; 490 else 491 arch = "32"; 492 } else 493 arch = "00"; 494 495 printf("%s%s ", abi, arch); 496 497 return (flags); 498 } 499 500 void 501 dumpheader(struct ktr_header *kth) 502 { 503 static char unknown[64]; 504 static struct timeval prevtime, temp; 505 const char *type; 506 507 switch (kth->ktr_type) { 508 case KTR_SYSCALL: 509 type = "CALL"; 510 break; 511 case KTR_SYSRET: 512 type = "RET "; 513 break; 514 case KTR_NAMEI: 515 type = "NAMI"; 516 break; 517 case KTR_GENIO: 518 type = "GIO "; 519 break; 520 case KTR_PSIG: 521 type = "PSIG"; 522 break; 523 case KTR_CSW: 524 type = "CSW "; 525 break; 526 case KTR_USER: 527 type = "USER"; 528 break; 529 case KTR_STRUCT: 530 type = "STRU"; 531 break; 532 case KTR_SYSCTL: 533 type = "SCTL"; 534 break; 535 case KTR_PROCCTOR: 536 /* FALLTHROUGH */ 537 case KTR_PROCDTOR: 538 return; 539 case KTR_CAPFAIL: 540 type = "CAP "; 541 break; 542 case KTR_FAULT: 543 type = "PFLT"; 544 break; 545 case KTR_FAULTEND: 546 type = "PRET"; 547 break; 548 default: 549 sprintf(unknown, "UNKNOWN(%d)", kth->ktr_type); 550 type = unknown; 551 } 552 553 /* 554 * The ktr_tid field was previously the ktr_buffer field, which held 555 * the kernel pointer value for the buffer associated with data 556 * following the record header. It now holds a threadid, but only 557 * for trace files after the change. Older trace files still contain 558 * kernel pointers. Detect this and suppress the results by printing 559 * negative tid's as 0. 560 */ 561 if (threads) 562 printf("%6jd %6jd %-8.*s ", (intmax_t)kth->ktr_pid, 563 kth->ktr_tid > 0 ? (intmax_t)kth->ktr_tid : 0, 564 MAXCOMLEN, kth->ktr_comm); 565 else 566 printf("%6jd %-8.*s ", (intmax_t)kth->ktr_pid, MAXCOMLEN, 567 kth->ktr_comm); 568 if (timestamp) { 569 if (timestamp == 3) { 570 if (prevtime.tv_sec == 0) 571 prevtime = kth->ktr_time; 572 timevalsub(&kth->ktr_time, &prevtime); 573 } 574 if (timestamp == 2) { 575 temp = kth->ktr_time; 576 timevalsub(&kth->ktr_time, &prevtime); 577 prevtime = temp; 578 } 579 printf("%jd.%06ld ", (intmax_t)kth->ktr_time.tv_sec, 580 kth->ktr_time.tv_usec); 581 } 582 printf("%s ", type); 583 } 584 585 #include <sys/syscall.h> 586 #define KTRACE 587 #include <sys/kern/syscalls.c> 588 #undef KTRACE 589 int nsyscalls = sizeof (syscallnames) / sizeof (syscallnames[0]); 590 591 void 592 ktrsyscall(struct ktr_syscall *ktr, u_int flags) 593 { 594 int narg = ktr->ktr_narg; 595 register_t *ip; 596 intmax_t arg; 597 598 if ((flags != 0 && ((flags & SV_ABI_MASK) != SV_ABI_FREEBSD)) || 599 (ktr->ktr_code >= nsyscalls || ktr->ktr_code < 0)) 600 printf("[%d]", ktr->ktr_code); 601 else 602 printf("%s", syscallnames[ktr->ktr_code]); 603 ip = &ktr->ktr_args[0]; 604 if (narg) { 605 char c = '('; 606 if (fancy && 607 (flags == 0 || (flags & SV_ABI_MASK) == SV_ABI_FREEBSD)) { 608 switch (ktr->ktr_code) { 609 case SYS_ioctl: { 610 print_number(ip, narg, c); 611 putchar(c); 612 ioctlname(*ip, decimal); 613 c = ','; 614 ip++; 615 narg--; 616 break; 617 } 618 case SYS_ptrace: 619 putchar('('); 620 ptraceopname(*ip); 621 c = ','; 622 ip++; 623 narg--; 624 break; 625 case SYS_access: 626 case SYS_eaccess: 627 print_number(ip, narg, c); 628 putchar(','); 629 accessmodename(*ip); 630 ip++; 631 narg--; 632 break; 633 case SYS_open: 634 print_number(ip, narg, c); 635 putchar(','); 636 flagsandmodename(ip[0], ip[1], decimal); 637 ip += 2; 638 narg -= 2; 639 break; 640 case SYS_wait4: 641 print_number(ip, narg, c); 642 print_number(ip, narg, c); 643 putchar(','); 644 wait4optname(*ip); 645 ip++; 646 narg--; 647 break; 648 case SYS_chmod: 649 case SYS_fchmod: 650 case SYS_lchmod: 651 print_number(ip, narg, c); 652 putchar(','); 653 modename(*ip); 654 ip++; 655 narg--; 656 break; 657 case SYS_mknod: 658 print_number(ip, narg, c); 659 putchar(','); 660 modename(*ip); 661 ip++; 662 narg--; 663 break; 664 case SYS_getfsstat: 665 print_number(ip, narg, c); 666 print_number(ip, narg, c); 667 putchar(','); 668 getfsstatflagsname(*ip); 669 ip++; 670 narg--; 671 break; 672 case SYS_mount: 673 print_number(ip, narg, c); 674 print_number(ip, narg, c); 675 putchar(','); 676 mountflagsname(*ip); 677 ip++; 678 narg--; 679 break; 680 case SYS_unmount: 681 print_number(ip, narg, c); 682 putchar(','); 683 mountflagsname(*ip); 684 ip++; 685 narg--; 686 break; 687 case SYS_recvmsg: 688 case SYS_sendmsg: 689 print_number(ip, narg, c); 690 print_number(ip, narg, c); 691 putchar(','); 692 sendrecvflagsname(*ip); 693 ip++; 694 narg--; 695 break; 696 case SYS_recvfrom: 697 case SYS_sendto: 698 print_number(ip, narg, c); 699 print_number(ip, narg, c); 700 print_number(ip, narg, c); 701 putchar(','); 702 sendrecvflagsname(*ip); 703 ip++; 704 narg--; 705 break; 706 case SYS_chflags: 707 case SYS_fchflags: 708 case SYS_lchflags: 709 print_number(ip, narg, c); 710 putchar(','); 711 modename(*ip); 712 ip++; 713 narg--; 714 break; 715 case SYS_kill: 716 print_number(ip, narg, c); 717 putchar(','); 718 signame(*ip); 719 ip++; 720 narg--; 721 break; 722 case SYS_reboot: 723 putchar('('); 724 rebootoptname(*ip); 725 ip++; 726 narg--; 727 break; 728 case SYS_umask: 729 putchar('('); 730 modename(*ip); 731 ip++; 732 narg--; 733 break; 734 case SYS_msync: 735 print_number(ip, narg, c); 736 print_number(ip, narg, c); 737 putchar(','); 738 msyncflagsname(*ip); 739 ip++; 740 narg--; 741 break; 742 #ifdef SYS_freebsd6_mmap 743 case SYS_freebsd6_mmap: 744 print_number(ip, narg, c); 745 print_number(ip, narg, c); 746 putchar(','); 747 mmapprotname(*ip); 748 putchar(','); 749 ip++; 750 narg--; 751 mmapflagsname(*ip); 752 ip++; 753 narg--; 754 break; 755 #endif 756 case SYS_mmap: 757 print_number(ip, narg, c); 758 print_number(ip, narg, c); 759 putchar(','); 760 mmapprotname(*ip); 761 putchar(','); 762 ip++; 763 narg--; 764 mmapflagsname(*ip); 765 ip++; 766 narg--; 767 break; 768 case SYS_mprotect: 769 print_number(ip, narg, c); 770 print_number(ip, narg, c); 771 putchar(','); 772 mmapprotname(*ip); 773 ip++; 774 narg--; 775 break; 776 case SYS_madvise: 777 print_number(ip, narg, c); 778 print_number(ip, narg, c); 779 putchar(','); 780 madvisebehavname(*ip); 781 ip++; 782 narg--; 783 break; 784 case SYS_setpriority: 785 print_number(ip, narg, c); 786 print_number(ip, narg, c); 787 putchar(','); 788 prioname(*ip); 789 ip++; 790 narg--; 791 break; 792 case SYS_fcntl: 793 print_number(ip, narg, c); 794 putchar(','); 795 fcntlcmdname(ip[0], ip[1], decimal); 796 ip += 2; 797 narg -= 2; 798 break; 799 case SYS_socket: { 800 int sockdomain; 801 putchar('('); 802 sockdomain = *ip; 803 sockdomainname(sockdomain); 804 ip++; 805 narg--; 806 putchar(','); 807 socktypename(*ip); 808 ip++; 809 narg--; 810 if (sockdomain == PF_INET || 811 sockdomain == PF_INET6) { 812 putchar(','); 813 sockipprotoname(*ip); 814 ip++; 815 narg--; 816 } 817 c = ','; 818 break; 819 } 820 case SYS_setsockopt: 821 case SYS_getsockopt: 822 print_number(ip, narg, c); 823 putchar(','); 824 sockoptlevelname(*ip, decimal); 825 if (*ip == SOL_SOCKET) { 826 ip++; 827 narg--; 828 putchar(','); 829 sockoptname(*ip); 830 } 831 ip++; 832 narg--; 833 break; 834 #ifdef SYS_freebsd6_lseek 835 case SYS_freebsd6_lseek: 836 print_number(ip, narg, c); 837 /* Hidden 'pad' argument, not in lseek(2) */ 838 print_number(ip, narg, c); 839 print_number(ip, narg, c); 840 putchar(','); 841 whencename(*ip); 842 ip++; 843 narg--; 844 break; 845 #endif 846 case SYS_lseek: 847 print_number(ip, narg, c); 848 /* Hidden 'pad' argument, not in lseek(2) */ 849 print_number(ip, narg, c); 850 putchar(','); 851 whencename(*ip); 852 ip++; 853 narg--; 854 break; 855 case SYS_flock: 856 print_number(ip, narg, c); 857 putchar(','); 858 flockname(*ip); 859 ip++; 860 narg--; 861 break; 862 case SYS_mkfifo: 863 case SYS_mkdir: 864 print_number(ip, narg, c); 865 putchar(','); 866 modename(*ip); 867 ip++; 868 narg--; 869 break; 870 case SYS_shutdown: 871 print_number(ip, narg, c); 872 putchar(','); 873 shutdownhowname(*ip); 874 ip++; 875 narg--; 876 break; 877 case SYS_socketpair: 878 putchar('('); 879 sockdomainname(*ip); 880 ip++; 881 narg--; 882 putchar(','); 883 socktypename(*ip); 884 ip++; 885 narg--; 886 c = ','; 887 break; 888 case SYS_getrlimit: 889 case SYS_setrlimit: 890 putchar('('); 891 rlimitname(*ip); 892 ip++; 893 narg--; 894 c = ','; 895 break; 896 case SYS_quotactl: 897 print_number(ip, narg, c); 898 putchar(','); 899 quotactlname(*ip); 900 ip++; 901 narg--; 902 c = ','; 903 break; 904 case SYS_nfssvc: 905 putchar('('); 906 nfssvcname(*ip); 907 ip++; 908 narg--; 909 c = ','; 910 break; 911 case SYS_rtprio: 912 putchar('('); 913 rtprioname(*ip); 914 ip++; 915 narg--; 916 c = ','; 917 break; 918 case SYS___semctl: 919 print_number(ip, narg, c); 920 print_number(ip, narg, c); 921 putchar(','); 922 semctlname(*ip); 923 ip++; 924 narg--; 925 break; 926 case SYS_semget: 927 print_number(ip, narg, c); 928 print_number(ip, narg, c); 929 putchar(','); 930 semgetname(*ip); 931 ip++; 932 narg--; 933 break; 934 case SYS_msgctl: 935 print_number(ip, narg, c); 936 putchar(','); 937 shmctlname(*ip); 938 ip++; 939 narg--; 940 break; 941 case SYS_shmat: 942 print_number(ip, narg, c); 943 print_number(ip, narg, c); 944 putchar(','); 945 shmatname(*ip); 946 ip++; 947 narg--; 948 break; 949 case SYS_shmctl: 950 print_number(ip, narg, c); 951 putchar(','); 952 shmctlname(*ip); 953 ip++; 954 narg--; 955 break; 956 case SYS_minherit: 957 print_number(ip, narg, c); 958 print_number(ip, narg, c); 959 putchar(','); 960 minheritname(*ip); 961 ip++; 962 narg--; 963 break; 964 case SYS_rfork: 965 putchar('('); 966 rforkname(*ip); 967 ip++; 968 narg--; 969 c = ','; 970 break; 971 case SYS_lio_listio: 972 putchar('('); 973 lio_listioname(*ip); 974 ip++; 975 narg--; 976 c = ','; 977 break; 978 case SYS_mlockall: 979 putchar('('); 980 mlockallname(*ip); 981 ip++; 982 narg--; 983 break; 984 case SYS_sched_setscheduler: 985 print_number(ip, narg, c); 986 putchar(','); 987 schedpolicyname(*ip); 988 ip++; 989 narg--; 990 break; 991 case SYS_sched_get_priority_max: 992 case SYS_sched_get_priority_min: 993 putchar('('); 994 schedpolicyname(*ip); 995 ip++; 996 narg--; 997 break; 998 case SYS_sendfile: 999 print_number(ip, narg, c); 1000 print_number(ip, narg, c); 1001 print_number(ip, narg, c); 1002 print_number(ip, narg, c); 1003 print_number(ip, narg, c); 1004 print_number(ip, narg, c); 1005 putchar(','); 1006 sendfileflagsname(*ip); 1007 ip++; 1008 narg--; 1009 break; 1010 case SYS_kldsym: 1011 print_number(ip, narg, c); 1012 putchar(','); 1013 kldsymcmdname(*ip); 1014 ip++; 1015 narg--; 1016 break; 1017 case SYS_sigprocmask: 1018 putchar('('); 1019 sigprocmaskhowname(*ip); 1020 ip++; 1021 narg--; 1022 c = ','; 1023 break; 1024 case SYS___acl_get_file: 1025 case SYS___acl_set_file: 1026 case SYS___acl_get_fd: 1027 case SYS___acl_set_fd: 1028 case SYS___acl_delete_file: 1029 case SYS___acl_delete_fd: 1030 case SYS___acl_aclcheck_file: 1031 case SYS___acl_aclcheck_fd: 1032 case SYS___acl_get_link: 1033 case SYS___acl_set_link: 1034 case SYS___acl_delete_link: 1035 case SYS___acl_aclcheck_link: 1036 print_number(ip, narg, c); 1037 putchar(','); 1038 acltypename(*ip); 1039 ip++; 1040 narg--; 1041 break; 1042 case SYS_sigaction: 1043 putchar('('); 1044 signame(*ip); 1045 ip++; 1046 narg--; 1047 c = ','; 1048 break; 1049 case SYS_extattrctl: 1050 print_number(ip, narg, c); 1051 putchar(','); 1052 extattrctlname(*ip); 1053 ip++; 1054 narg--; 1055 break; 1056 case SYS_nmount: 1057 print_number(ip, narg, c); 1058 print_number(ip, narg, c); 1059 putchar(','); 1060 mountflagsname(*ip); 1061 ip++; 1062 narg--; 1063 break; 1064 case SYS_thr_create: 1065 print_number(ip, narg, c); 1066 print_number(ip, narg, c); 1067 putchar(','); 1068 thrcreateflagsname(*ip); 1069 ip++; 1070 narg--; 1071 break; 1072 case SYS_thr_kill: 1073 print_number(ip, narg, c); 1074 putchar(','); 1075 signame(*ip); 1076 ip++; 1077 narg--; 1078 break; 1079 case SYS_kldunloadf: 1080 print_number(ip, narg, c); 1081 putchar(','); 1082 kldunloadfflagsname(*ip); 1083 ip++; 1084 narg--; 1085 break; 1086 case SYS_cap_new: 1087 case SYS_cap_rights_limit: 1088 print_number(ip, narg, c); 1089 putchar(','); 1090 arg = *ip; 1091 ip++; 1092 narg--; 1093 /* 1094 * Hack: the second argument is a 1095 * cap_rights_t, which 64 bits wide, so on 1096 * 32-bit systems, it is split between two 1097 * registers. 1098 * 1099 * Since sizeof() is not evaluated by the 1100 * preprocessor, we can't use an #ifdef, 1101 * but the compiler will probably optimize 1102 * the code out anyway. 1103 */ 1104 if (sizeof(cap_rights_t) > sizeof(register_t)) { 1105 #if _BYTE_ORDER == _LITTLE_ENDIAN 1106 arg = ((intmax_t)*ip << 32) + arg; 1107 #else 1108 arg = (arg << 32) + *ip; 1109 #endif 1110 ip++; 1111 narg--; 1112 } 1113 capname(arg); 1114 break; 1115 case SYS_cap_fcntls_limit: 1116 print_number(ip, narg, c); 1117 putchar(','); 1118 arg = *ip; 1119 ip++; 1120 narg--; 1121 capfcntlname(arg); 1122 break; 1123 case SYS_posix_fadvise: 1124 print_number(ip, narg, c); 1125 print_number(ip, narg, c); 1126 print_number(ip, narg, c); 1127 (void)putchar(','); 1128 fadvisebehavname((int)*ip); 1129 ip++; 1130 narg--; 1131 break; 1132 } 1133 } 1134 while (narg > 0) { 1135 print_number(ip, narg, c); 1136 } 1137 putchar(')'); 1138 } 1139 putchar('\n'); 1140 } 1141 1142 void 1143 ktrsysret(struct ktr_sysret *ktr, u_int flags) 1144 { 1145 register_t ret = ktr->ktr_retval; 1146 int error = ktr->ktr_error; 1147 int code = ktr->ktr_code; 1148 1149 if ((flags != 0 && ((flags & SV_ABI_MASK) != SV_ABI_FREEBSD)) || 1150 (code >= nsyscalls || code < 0)) 1151 printf("[%d] ", code); 1152 else 1153 printf("%s ", syscallnames[code]); 1154 1155 if (error == 0) { 1156 if (fancy) { 1157 printf("%ld", (long)ret); 1158 if (ret < 0 || ret > 9) 1159 printf("/%#lx", (unsigned long)ret); 1160 } else { 1161 if (decimal) 1162 printf("%ld", (long)ret); 1163 else 1164 printf("%#lx", (unsigned long)ret); 1165 } 1166 } else if (error == ERESTART) 1167 printf("RESTART"); 1168 else if (error == EJUSTRETURN) 1169 printf("JUSTRETURN"); 1170 else { 1171 printf("-1 errno %d", ktr->ktr_error); 1172 if (fancy) 1173 printf(" %s", strerror(ktr->ktr_error)); 1174 } 1175 putchar('\n'); 1176 } 1177 1178 void 1179 ktrnamei(char *cp, int len) 1180 { 1181 printf("\"%.*s\"\n", len, cp); 1182 } 1183 1184 void 1185 hexdump(char *p, int len, int screenwidth) 1186 { 1187 int n, i; 1188 int width; 1189 1190 width = 0; 1191 do { 1192 width += 2; 1193 i = 13; /* base offset */ 1194 i += (width / 2) + 1; /* spaces every second byte */ 1195 i += (width * 2); /* width of bytes */ 1196 i += 3; /* " |" */ 1197 i += width; /* each byte */ 1198 i += 1; /* "|" */ 1199 } while (i < screenwidth); 1200 width -= 2; 1201 1202 for (n = 0; n < len; n += width) { 1203 for (i = n; i < n + width; i++) { 1204 if ((i % width) == 0) { /* beginning of line */ 1205 printf(" 0x%04x", i); 1206 } 1207 if ((i % 2) == 0) { 1208 printf(" "); 1209 } 1210 if (i < len) 1211 printf("%02x", p[i] & 0xff); 1212 else 1213 printf(" "); 1214 } 1215 printf(" |"); 1216 for (i = n; i < n + width; i++) { 1217 if (i >= len) 1218 break; 1219 if (p[i] >= ' ' && p[i] <= '~') 1220 printf("%c", p[i]); 1221 else 1222 printf("."); 1223 } 1224 printf("|\n"); 1225 } 1226 if ((i % width) != 0) 1227 printf("\n"); 1228 } 1229 1230 void 1231 visdump(char *dp, int datalen, int screenwidth) 1232 { 1233 int col = 0; 1234 char *cp; 1235 int width; 1236 char visbuf[5]; 1237 1238 printf(" \""); 1239 col = 8; 1240 for (;datalen > 0; datalen--, dp++) { 1241 vis(visbuf, *dp, VIS_CSTYLE, *(dp+1)); 1242 cp = visbuf; 1243 /* 1244 * Keep track of printables and 1245 * space chars (like fold(1)). 1246 */ 1247 if (col == 0) { 1248 putchar('\t'); 1249 col = 8; 1250 } 1251 switch(*cp) { 1252 case '\n': 1253 col = 0; 1254 putchar('\n'); 1255 continue; 1256 case '\t': 1257 width = 8 - (col&07); 1258 break; 1259 default: 1260 width = strlen(cp); 1261 } 1262 if (col + width > (screenwidth-2)) { 1263 printf("\\\n\t"); 1264 col = 8; 1265 } 1266 col += width; 1267 do { 1268 putchar(*cp++); 1269 } while (*cp); 1270 } 1271 if (col == 0) 1272 printf(" "); 1273 printf("\"\n"); 1274 } 1275 1276 void 1277 ktrgenio(struct ktr_genio *ktr, int len) 1278 { 1279 int datalen = len - sizeof (struct ktr_genio); 1280 char *dp = (char *)ktr + sizeof (struct ktr_genio); 1281 static int screenwidth = 0; 1282 int i, binary; 1283 1284 printf("fd %d %s %d byte%s\n", ktr->ktr_fd, 1285 ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen, 1286 datalen == 1 ? "" : "s"); 1287 if (suppressdata) 1288 return; 1289 if (screenwidth == 0) { 1290 struct winsize ws; 1291 1292 if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 && 1293 ws.ws_col > 8) 1294 screenwidth = ws.ws_col; 1295 else 1296 screenwidth = 80; 1297 } 1298 if (maxdata && datalen > maxdata) 1299 datalen = maxdata; 1300 1301 for (i = 0, binary = 0; i < datalen && binary == 0; i++) { 1302 if (dp[i] >= 32 && dp[i] < 127) 1303 continue; 1304 if (dp[i] == 10 || dp[i] == 13 || dp[i] == 0 || dp[i] == 9) 1305 continue; 1306 binary = 1; 1307 } 1308 if (binary) 1309 hexdump(dp, datalen, screenwidth); 1310 else 1311 visdump(dp, datalen, screenwidth); 1312 } 1313 1314 const char *signames[] = { 1315 "NULL", "HUP", "INT", "QUIT", "ILL", "TRAP", "IOT", /* 1 - 6 */ 1316 "EMT", "FPE", "KILL", "BUS", "SEGV", "SYS", /* 7 - 12 */ 1317 "PIPE", "ALRM", "TERM", "URG", "STOP", "TSTP", /* 13 - 18 */ 1318 "CONT", "CHLD", "TTIN", "TTOU", "IO", "XCPU", /* 19 - 24 */ 1319 "XFSZ", "VTALRM", "PROF", "WINCH", "29", "USR1", /* 25 - 30 */ 1320 "USR2", NULL, /* 31 - 32 */ 1321 }; 1322 1323 void 1324 ktrpsig(struct ktr_psig *psig) 1325 { 1326 if (psig->signo > 0 && psig->signo < NSIG) 1327 printf("SIG%s ", signames[psig->signo]); 1328 else 1329 printf("SIG %d ", psig->signo); 1330 if (psig->action == SIG_DFL) { 1331 printf("SIG_DFL code="); 1332 sigcodename(psig->signo, psig->code); 1333 putchar('\n'); 1334 } else { 1335 printf("caught handler=0x%lx mask=0x%x code=", 1336 (u_long)psig->action, psig->mask.__bits[0]); 1337 sigcodename(psig->signo, psig->code); 1338 putchar('\n'); 1339 } 1340 } 1341 1342 void 1343 ktrcsw_old(struct ktr_csw_old *cs) 1344 { 1345 printf("%s %s\n", cs->out ? "stop" : "resume", 1346 cs->user ? "user" : "kernel"); 1347 } 1348 1349 void 1350 ktrcsw(struct ktr_csw *cs) 1351 { 1352 printf("%s %s \"%s\"\n", cs->out ? "stop" : "resume", 1353 cs->user ? "user" : "kernel", cs->wmesg); 1354 } 1355 1356 #define UTRACE_DLOPEN_START 1 1357 #define UTRACE_DLOPEN_STOP 2 1358 #define UTRACE_DLCLOSE_START 3 1359 #define UTRACE_DLCLOSE_STOP 4 1360 #define UTRACE_LOAD_OBJECT 5 1361 #define UTRACE_UNLOAD_OBJECT 6 1362 #define UTRACE_ADD_RUNDEP 7 1363 #define UTRACE_PRELOAD_FINISHED 8 1364 #define UTRACE_INIT_CALL 9 1365 #define UTRACE_FINI_CALL 10 1366 1367 struct utrace_rtld { 1368 char sig[4]; /* 'RTLD' */ 1369 int event; 1370 void *handle; 1371 void *mapbase; 1372 size_t mapsize; 1373 int refcnt; 1374 char name[MAXPATHLEN]; 1375 }; 1376 1377 void 1378 ktruser_rtld(int len, unsigned char *p) 1379 { 1380 struct utrace_rtld *ut = (struct utrace_rtld *)p; 1381 void *parent; 1382 int mode; 1383 1384 switch (ut->event) { 1385 case UTRACE_DLOPEN_START: 1386 mode = ut->refcnt; 1387 printf("dlopen(%s, ", ut->name); 1388 switch (mode & RTLD_MODEMASK) { 1389 case RTLD_NOW: 1390 printf("RTLD_NOW"); 1391 break; 1392 case RTLD_LAZY: 1393 printf("RTLD_LAZY"); 1394 break; 1395 default: 1396 printf("%#x", mode & RTLD_MODEMASK); 1397 } 1398 if (mode & RTLD_GLOBAL) 1399 printf(" | RTLD_GLOBAL"); 1400 if (mode & RTLD_TRACE) 1401 printf(" | RTLD_TRACE"); 1402 if (mode & ~(RTLD_MODEMASK | RTLD_GLOBAL | RTLD_TRACE)) 1403 printf(" | %#x", mode & 1404 ~(RTLD_MODEMASK | RTLD_GLOBAL | RTLD_TRACE)); 1405 printf(")\n"); 1406 break; 1407 case UTRACE_DLOPEN_STOP: 1408 printf("%p = dlopen(%s) ref %d\n", ut->handle, ut->name, 1409 ut->refcnt); 1410 break; 1411 case UTRACE_DLCLOSE_START: 1412 printf("dlclose(%p) (%s, %d)\n", ut->handle, ut->name, 1413 ut->refcnt); 1414 break; 1415 case UTRACE_DLCLOSE_STOP: 1416 printf("dlclose(%p) finished\n", ut->handle); 1417 break; 1418 case UTRACE_LOAD_OBJECT: 1419 printf("RTLD: loaded %p @ %p - %p (%s)\n", ut->handle, 1420 ut->mapbase, (char *)ut->mapbase + ut->mapsize - 1, 1421 ut->name); 1422 break; 1423 case UTRACE_UNLOAD_OBJECT: 1424 printf("RTLD: unloaded %p @ %p - %p (%s)\n", ut->handle, 1425 ut->mapbase, (char *)ut->mapbase + ut->mapsize - 1, 1426 ut->name); 1427 break; 1428 case UTRACE_ADD_RUNDEP: 1429 parent = ut->mapbase; 1430 printf("RTLD: %p now depends on %p (%s, %d)\n", parent, 1431 ut->handle, ut->name, ut->refcnt); 1432 break; 1433 case UTRACE_PRELOAD_FINISHED: 1434 printf("RTLD: LD_PRELOAD finished\n"); 1435 break; 1436 case UTRACE_INIT_CALL: 1437 printf("RTLD: init %p for %p (%s)\n", ut->mapbase, ut->handle, 1438 ut->name); 1439 break; 1440 case UTRACE_FINI_CALL: 1441 printf("RTLD: fini %p for %p (%s)\n", ut->mapbase, ut->handle, 1442 ut->name); 1443 break; 1444 default: 1445 p += 4; 1446 len -= 4; 1447 printf("RTLD: %d ", len); 1448 while (len--) 1449 if (decimal) 1450 printf(" %d", *p++); 1451 else 1452 printf(" %02x", *p++); 1453 printf("\n"); 1454 } 1455 } 1456 1457 struct utrace_malloc { 1458 void *p; 1459 size_t s; 1460 void *r; 1461 }; 1462 1463 void 1464 ktruser_malloc(unsigned char *p) 1465 { 1466 struct utrace_malloc *ut = (struct utrace_malloc *)p; 1467 1468 if (ut->p == (void *)(intptr_t)(-1)) 1469 printf("malloc_init()\n"); 1470 else if (ut->s == 0) 1471 printf("free(%p)\n", ut->p); 1472 else if (ut->p == NULL) 1473 printf("%p = malloc(%zu)\n", ut->r, ut->s); 1474 else 1475 printf("%p = realloc(%p, %zu)\n", ut->r, ut->p, ut->s); 1476 } 1477 1478 void 1479 ktruser(int len, unsigned char *p) 1480 { 1481 1482 if (len >= 8 && bcmp(p, "RTLD", 4) == 0) { 1483 ktruser_rtld(len, p); 1484 return; 1485 } 1486 1487 if (len == sizeof(struct utrace_malloc)) { 1488 ktruser_malloc(p); 1489 return; 1490 } 1491 1492 printf("%d ", len); 1493 while (len--) 1494 if (decimal) 1495 printf(" %d", *p++); 1496 else 1497 printf(" %02x", *p++); 1498 printf("\n"); 1499 } 1500 1501 void 1502 ktrsockaddr(struct sockaddr *sa) 1503 { 1504 /* 1505 TODO: Support additional address families 1506 #include <netnatm/natm.h> 1507 struct sockaddr_natm *natm; 1508 #include <netsmb/netbios.h> 1509 struct sockaddr_nb *nb; 1510 */ 1511 char addr[64]; 1512 1513 /* 1514 * note: ktrstruct() has already verified that sa points to a 1515 * buffer at least sizeof(struct sockaddr) bytes long and exactly 1516 * sa->sa_len bytes long. 1517 */ 1518 printf("struct sockaddr { "); 1519 sockfamilyname(sa->sa_family); 1520 printf(", "); 1521 1522 #define check_sockaddr_len(n) \ 1523 if (sa_##n.s##n##_len < sizeof(struct sockaddr_##n)) { \ 1524 printf("invalid"); \ 1525 break; \ 1526 } 1527 1528 switch(sa->sa_family) { 1529 case AF_INET: { 1530 struct sockaddr_in sa_in; 1531 1532 memset(&sa_in, 0, sizeof(sa_in)); 1533 memcpy(&sa_in, sa, sa->sa_len); 1534 check_sockaddr_len(in); 1535 inet_ntop(AF_INET, &sa_in.sin_addr, addr, sizeof addr); 1536 printf("%s:%u", addr, ntohs(sa_in.sin_port)); 1537 break; 1538 } 1539 #ifdef NETATALK 1540 case AF_APPLETALK: { 1541 struct sockaddr_at sa_at; 1542 struct netrange *nr; 1543 1544 memset(&sa_at, 0, sizeof(sa_at)); 1545 memcpy(&sa_at, sa, sa->sa_len); 1546 check_sockaddr_len(at); 1547 nr = &sa_at.sat_range.r_netrange; 1548 printf("%d.%d, %d-%d, %d", ntohs(sa_at.sat_addr.s_net), 1549 sa_at.sat_addr.s_node, ntohs(nr->nr_firstnet), 1550 ntohs(nr->nr_lastnet), nr->nr_phase); 1551 break; 1552 } 1553 #endif 1554 case AF_INET6: { 1555 struct sockaddr_in6 sa_in6; 1556 1557 memset(&sa_in6, 0, sizeof(sa_in6)); 1558 memcpy(&sa_in6, sa, sa->sa_len); 1559 check_sockaddr_len(in6); 1560 getnameinfo((struct sockaddr *)&sa_in6, sizeof(sa_in6), 1561 addr, sizeof(addr), NULL, 0, NI_NUMERICHOST); 1562 printf("[%s]:%u", addr, htons(sa_in6.sin6_port)); 1563 break; 1564 } 1565 #ifdef IPX 1566 case AF_IPX: { 1567 struct sockaddr_ipx sa_ipx; 1568 1569 memset(&sa_ipx, 0, sizeof(sa_ipx)); 1570 memcpy(&sa_ipx, sa, sa->sa_len); 1571 check_sockaddr_len(ipx); 1572 /* XXX wish we had ipx_ntop */ 1573 printf("%s", ipx_ntoa(sa_ipx.sipx_addr)); 1574 free(sa_ipx); 1575 break; 1576 } 1577 #endif 1578 case AF_UNIX: { 1579 struct sockaddr_un sa_un; 1580 1581 memset(&sa_un, 0, sizeof(sa_un)); 1582 memcpy(&sa_un, sa, sa->sa_len); 1583 printf("%.*s", (int)sizeof(sa_un.sun_path), sa_un.sun_path); 1584 break; 1585 } 1586 default: 1587 printf("unknown address family"); 1588 } 1589 printf(" }\n"); 1590 } 1591 1592 void 1593 ktrstat(struct stat *statp) 1594 { 1595 char mode[12], timestr[PATH_MAX + 4]; 1596 struct passwd *pwd; 1597 struct group *grp; 1598 struct tm *tm; 1599 1600 /* 1601 * note: ktrstruct() has already verified that statp points to a 1602 * buffer exactly sizeof(struct stat) bytes long. 1603 */ 1604 printf("struct stat {"); 1605 strmode(statp->st_mode, mode); 1606 printf("dev=%ju, ino=%ju, mode=%s, nlink=%ju, ", 1607 (uintmax_t)statp->st_dev, (uintmax_t)statp->st_ino, mode, 1608 (uintmax_t)statp->st_nlink); 1609 if (resolv == 0 || (pwd = getpwuid(statp->st_uid)) == NULL) 1610 printf("uid=%ju, ", (uintmax_t)statp->st_uid); 1611 else 1612 printf("uid=\"%s\", ", pwd->pw_name); 1613 if (resolv == 0 || (grp = getgrgid(statp->st_gid)) == NULL) 1614 printf("gid=%ju, ", (uintmax_t)statp->st_gid); 1615 else 1616 printf("gid=\"%s\", ", grp->gr_name); 1617 printf("rdev=%ju, ", (uintmax_t)statp->st_rdev); 1618 printf("atime="); 1619 if (resolv == 0) 1620 printf("%jd", (intmax_t)statp->st_atim.tv_sec); 1621 else { 1622 tm = localtime(&statp->st_atim.tv_sec); 1623 strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1624 printf("\"%s\"", timestr); 1625 } 1626 if (statp->st_atim.tv_nsec != 0) 1627 printf(".%09ld, ", statp->st_atim.tv_nsec); 1628 else 1629 printf(", "); 1630 printf("stime="); 1631 if (resolv == 0) 1632 printf("%jd", (intmax_t)statp->st_mtim.tv_sec); 1633 else { 1634 tm = localtime(&statp->st_mtim.tv_sec); 1635 strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1636 printf("\"%s\"", timestr); 1637 } 1638 if (statp->st_mtim.tv_nsec != 0) 1639 printf(".%09ld, ", statp->st_mtim.tv_nsec); 1640 else 1641 printf(", "); 1642 printf("ctime="); 1643 if (resolv == 0) 1644 printf("%jd", (intmax_t)statp->st_ctim.tv_sec); 1645 else { 1646 tm = localtime(&statp->st_ctim.tv_sec); 1647 strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1648 printf("\"%s\"", timestr); 1649 } 1650 if (statp->st_ctim.tv_nsec != 0) 1651 printf(".%09ld, ", statp->st_ctim.tv_nsec); 1652 else 1653 printf(", "); 1654 printf("birthtime="); 1655 if (resolv == 0) 1656 printf("%jd", (intmax_t)statp->st_birthtim.tv_sec); 1657 else { 1658 tm = localtime(&statp->st_birthtim.tv_sec); 1659 strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1660 printf("\"%s\"", timestr); 1661 } 1662 if (statp->st_birthtim.tv_nsec != 0) 1663 printf(".%09ld, ", statp->st_birthtim.tv_nsec); 1664 else 1665 printf(", "); 1666 printf("size=%jd, blksize=%ju, blocks=%jd, flags=0x%x", 1667 (uintmax_t)statp->st_size, (uintmax_t)statp->st_blksize, 1668 (intmax_t)statp->st_blocks, statp->st_flags); 1669 printf(" }\n"); 1670 } 1671 1672 void 1673 ktrstruct(char *buf, size_t buflen) 1674 { 1675 char *name, *data; 1676 size_t namelen, datalen; 1677 int i; 1678 struct stat sb; 1679 struct sockaddr_storage ss; 1680 1681 for (name = buf, namelen = 0; 1682 namelen < buflen && name[namelen] != '\0'; 1683 ++namelen) 1684 /* nothing */; 1685 if (namelen == buflen) 1686 goto invalid; 1687 if (name[namelen] != '\0') 1688 goto invalid; 1689 data = buf + namelen + 1; 1690 datalen = buflen - namelen - 1; 1691 if (datalen == 0) 1692 goto invalid; 1693 /* sanity check */ 1694 for (i = 0; i < (int)namelen; ++i) 1695 if (!isalpha(name[i])) 1696 goto invalid; 1697 if (strcmp(name, "stat") == 0) { 1698 if (datalen != sizeof(struct stat)) 1699 goto invalid; 1700 memcpy(&sb, data, datalen); 1701 ktrstat(&sb); 1702 } else if (strcmp(name, "sockaddr") == 0) { 1703 if (datalen > sizeof(ss)) 1704 goto invalid; 1705 memcpy(&ss, data, datalen); 1706 if (datalen != ss.ss_len) 1707 goto invalid; 1708 ktrsockaddr((struct sockaddr *)&ss); 1709 } else { 1710 printf("unknown structure\n"); 1711 } 1712 return; 1713 invalid: 1714 printf("invalid record\n"); 1715 } 1716 1717 void 1718 ktrcapfail(struct ktr_cap_fail *ktr) 1719 { 1720 switch (ktr->cap_type) { 1721 case CAPFAIL_NOTCAPABLE: 1722 /* operation on fd with insufficient capabilities */ 1723 printf("operation requires "); 1724 capname((intmax_t)ktr->cap_needed); 1725 printf(", process holds "); 1726 capname((intmax_t)ktr->cap_held); 1727 break; 1728 case CAPFAIL_INCREASE: 1729 /* requested more capabilities than fd already has */ 1730 printf("attempt to increase capabilities from "); 1731 capname((intmax_t)ktr->cap_held); 1732 printf(" to "); 1733 capname((intmax_t)ktr->cap_needed); 1734 break; 1735 case CAPFAIL_SYSCALL: 1736 /* called restricted syscall */ 1737 printf("disallowed system call"); 1738 break; 1739 case CAPFAIL_LOOKUP: 1740 /* used ".." in strict-relative mode */ 1741 printf("restricted VFS lookup"); 1742 break; 1743 default: 1744 printf("unknown capability failure: "); 1745 capname((intmax_t)ktr->cap_needed); 1746 printf(" "); 1747 capname((intmax_t)ktr->cap_held); 1748 break; 1749 } 1750 printf("\n"); 1751 } 1752 1753 void 1754 ktrfault(struct ktr_fault *ktr) 1755 { 1756 1757 printf("0x%jx ", ktr->vaddr); 1758 vmprotname(ktr->type); 1759 printf("\n"); 1760 } 1761 1762 void 1763 ktrfaultend(struct ktr_faultend *ktr) 1764 { 1765 1766 vmresultname(ktr->result); 1767 printf("\n"); 1768 } 1769 1770 #if defined(__amd64__) || defined(__i386__) 1771 void 1772 linux_ktrsyscall(struct ktr_syscall *ktr) 1773 { 1774 int narg = ktr->ktr_narg; 1775 register_t *ip; 1776 1777 if (ktr->ktr_code >= nlinux_syscalls || ktr->ktr_code < 0) 1778 printf("[%d]", ktr->ktr_code); 1779 else 1780 printf("%s", linux_syscallnames[ktr->ktr_code]); 1781 ip = &ktr->ktr_args[0]; 1782 if (narg) { 1783 char c = '('; 1784 while (narg > 0) 1785 print_number(ip, narg, c); 1786 putchar(')'); 1787 } 1788 putchar('\n'); 1789 } 1790 1791 void 1792 linux_ktrsysret(struct ktr_sysret *ktr) 1793 { 1794 register_t ret = ktr->ktr_retval; 1795 int error = ktr->ktr_error; 1796 int code = ktr->ktr_code; 1797 1798 if (code >= nlinux_syscalls || code < 0) 1799 printf("[%d] ", code); 1800 else 1801 printf("%s ", linux_syscallnames[code]); 1802 1803 if (error == 0) { 1804 if (fancy) { 1805 printf("%ld", (long)ret); 1806 if (ret < 0 || ret > 9) 1807 printf("/%#lx", (unsigned long)ret); 1808 } else { 1809 if (decimal) 1810 printf("%ld", (long)ret); 1811 else 1812 printf("%#lx", (unsigned long)ret); 1813 } 1814 } else if (error == ERESTART) 1815 printf("RESTART"); 1816 else if (error == EJUSTRETURN) 1817 printf("JUSTRETURN"); 1818 else { 1819 if (ktr->ktr_error <= ELAST + 1) 1820 error = abs(bsd_to_linux_errno[ktr->ktr_error]); 1821 else 1822 error = 999; 1823 printf("-1 errno %d", error); 1824 if (fancy) 1825 printf(" %s", strerror(ktr->ktr_error)); 1826 } 1827 putchar('\n'); 1828 } 1829 #endif 1830 1831 void 1832 usage(void) 1833 { 1834 fprintf(stderr, "usage: kdump [-dEnlHRrsTA] [-f trfile] " 1835 "[-m maxdata] [-p pid] [-t trstr]\n"); 1836 exit(1); 1837 } 1838