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