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