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
cappwdgrp_setup(cap_channel_t ** cappwdp,cap_channel_t ** capgrpp)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
print_integer_arg(const char * (* decoder)(int),int value)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
print_integer_arg_valid(const char * (* decoder)(int),int value)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
print_mask_arg_part(bool (* decoder)(FILE *,int,int *),int value,int * rem)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
print_mask_arg(bool (* decoder)(FILE *,int,int *),int value)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
print_mask_arg0(bool (* decoder)(FILE *,int,int *),int value)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
decode_fileflags(fflags_t value)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
decode_filemode(int value)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
print_mask_arg32(bool (* decoder)(FILE *,uint32_t,uint32_t *),uint32_t value)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
print_mask_argul(bool (* decoder)(FILE *,u_long,u_long *),u_long value)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
main(int argc,char * argv[])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
fread_tail(void * buf,int size,int num)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
fetchprocinfo(struct ktr_header * kth,u_int * flags)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
findabi(struct ktr_header * kth)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
dumptimeval(struct ktr_header_v0 * kth)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
dumptimespec(struct ktr_header * kth)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
dumpheader(struct ktr_header * kth,u_int sv_flags)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
ioctlname(unsigned long val)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
syscallabi(u_int sv_flags)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
syscallname(u_int code,u_int sv_flags)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
print_signal(int signo)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
ktrsyscall(struct ktr_syscall * ktr,u_int sv_flags)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
ktrsyscall_freebsd(struct ktr_syscall * ktr,register_t ** resip,int * resnarg,char * resc,u_int sv_flags)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
ktrsysret(struct ktr_sysret * ktr,u_int sv_flags)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
ktrnamei(char * cp,int len)1656 ktrnamei(char *cp, int len)
1657 {
1658 printf("\"%.*s\"\n", len, cp);
1659 }
1660
1661 void
hexdump(char * p,int len,int screenwidth)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
visdump(char * dp,int datalen,int screenwidth)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
ktrgenio(struct ktr_genio * ktr,int len)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
ktrpsig(struct ktr_psig * psig)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
ktrcsw_old(struct ktr_csw_old * cs)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
ktrcsw(struct ktr_csw * cs)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
ktruser(int len,void * p)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
ktrcaprights(cap_rights_t * rightsp)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
ktrtimeval(struct timeval * tv)1856 ktrtimeval(struct timeval *tv)
1857 {
1858
1859 printf("{%ld, %ld}", (long)tv->tv_sec, tv->tv_usec);
1860 }
1861
1862 void
ktritimerval(struct itimerval * it)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
ktrsockaddr(struct sockaddr * sa)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
ktrsplice(struct splice * sp)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
ktrstat(struct stat * statp)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
ktrbitset(char * name,struct bitset * set,size_t setlen)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
ktrstruct(char * buf,size_t buflen)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
ktrcapfail(struct ktr_cap_fail * ktr)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
ktrfault(struct ktr_fault * ktr)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
ktrfaultend(struct ktr_faultend * ktr)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
ktrkevent(struct kevent * kev)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
ktrpollfd(struct pollfd * pfd)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
ktrstructarray(struct ktr_struct_array * ksa,size_t buflen)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
usage(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