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