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