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