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