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