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