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