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