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