Annotation of src/usr.bin/kdump/kdump.c, Revision 1.156
1.156 ! deraadt 1: /* $OpenBSD: kdump.c,v 1.155 2023/01/16 05:32:05 deraadt Exp $ */
1.4 deraadt 2:
1.1 deraadt 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.
1.21 millert 15: * 3. Neither the name of the University nor the names of its contributors
1.1 deraadt 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: #include <sys/time.h>
1.97 deraadt 33: #include <sys/signal.h>
1.1 deraadt 34: #include <sys/uio.h>
35: #include <sys/ktrace.h>
36: #include <sys/ioctl.h>
1.62 otto 37: #include <sys/malloc.h>
38: #include <sys/namei.h>
1.1 deraadt 39: #include <sys/ptrace.h>
1.62 otto 40: #include <sys/sem.h>
41: #include <sys/shm.h>
1.51 otto 42: #include <sys/socket.h>
1.28 deraadt 43: #include <sys/sysctl.h>
1.63 deraadt 44: #include <sys/siginfo.h>
1.62 otto 45: #include <sys/vmmeter.h>
46: #include <sys/tty.h>
1.82 guenther 47: #include <sys/wait.h>
1.117 deraadt 48: #define PLEDGENAMES
49: #include <sys/pledge.h>
50: #undef PLEDGENAMES
1.1 deraadt 51: #define _KERNEL
1.84 guenther 52: #include <errno.h>
1.1 deraadt 53: #undef _KERNEL
1.62 otto 54: #include <ddb/db_var.h>
55: #include <machine/cpu.h>
1.1 deraadt 56:
1.33 tedu 57: #include <ctype.h>
1.1 deraadt 58: #include <err.h>
1.61 matthew 59: #include <fcntl.h>
1.64 guenther 60: #include <limits.h>
1.100 guenther 61: #include <netdb.h>
1.77 guenther 62: #include <poll.h>
1.1 deraadt 63: #include <signal.h>
1.145 guenther 64: #include <stddef.h>
65: #include <stdint.h>
1.1 deraadt 66: #include <stdio.h>
67: #include <stdlib.h>
68: #include <string.h>
69: #include <unistd.h>
70: #include <vis.h>
71:
72: #include "ktrace.h"
1.22 deraadt 73: #include "kdump.h"
1.51 otto 74: #include "kdump_subr.h"
1.12 espie 75: #include "extern.h"
1.146 deraadt 76:
77: #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
1.1 deraadt 78:
1.141 cheloha 79: enum {
80: TIMESTAMP_NONE,
81: TIMESTAMP_ABSOLUTE,
82: TIMESTAMP_RELATIVE,
83: TIMESTAMP_ELAPSED
84: } timestamp = TIMESTAMP_NONE;
85:
86: int decimal, iohex, fancy = 1, maxdata = INT_MAX;
1.111 guenther 87: int needtid, tail, basecol;
1.1 deraadt 88: char *tracefile = DEF_TRACEFILE;
89: struct ktr_header ktr_header;
1.85 guenther 90: pid_t pid_opt = -1;
1.1 deraadt 91:
92: #define eqs(s1, s2) (strcmp((s1), (s2)) == 0)
93:
94: #include <sys/syscall.h>
95:
96: #define KTRACE
1.19 mickey 97: #define PTRACE
1.7 deraadt 98: #define NFSCLIENT
99: #define NFSSERVER
100: #define SYSVSEM
101: #define SYSVMSG
102: #define SYSVSHM
1.110 guenther 103: #define ACCOUNTING
1.25 mickey 104: #include <kern/syscalls.c>
1.1 deraadt 105: #undef KTRACE
1.19 mickey 106: #undef PTRACE
1.7 deraadt 107: #undef NFSCLIENT
108: #undef NFSSERVER
109: #undef SYSVSEM
110: #undef SYSVMSG
111: #undef SYSVSHM
1.110 guenther 112: #undef ACCOUNTING
1.1 deraadt 113:
114:
115: static char *ptrace_ops[] = {
116: "PT_TRACE_ME", "PT_READ_I", "PT_READ_D", "PT_READ_U",
117: "PT_WRITE_I", "PT_WRITE_D", "PT_WRITE_U", "PT_CONTINUE",
1.15 art 118: "PT_KILL", "PT_ATTACH", "PT_DETACH", "PT_IO",
1.64 guenther 119: "PT_SET_EVENT_MASK", "PT_GET_EVENT_MASK", "PT_GET_PROCESS_STATE",
1.71 guenther 120: "PT_GET_THREAD_FIRST", "PT_GET_THREAD_NEXT",
1.1 deraadt 121: };
122:
1.37 tedu 123: static int fread_tail(void *, size_t, size_t);
1.13 millert 124: static void dumpheader(struct ktr_header *);
1.37 tedu 125: static void ktrgenio(struct ktr_genio *, size_t);
126: static void ktrnamei(const char *, size_t);
1.13 millert 127: static void ktrpsig(struct ktr_psig *);
1.93 jsg 128: static void ktrsyscall(struct ktr_syscall *, size_t);
1.94 guenther 129: static const char *kresolvsysctl(int, const int *);
1.103 guenther 130: static void ktrsysret(struct ktr_sysret *, size_t);
1.81 miod 131: static void ktruser(struct ktr_user *, size_t);
1.106 guenther 132: static void ktrexec(const char*, size_t);
1.117 deraadt 133: static void ktrpledge(struct ktr_pledge *, size_t);
1.13 millert 134: static void usage(void);
1.92 guenther 135: static void ioctldecode(int);
136: static void ptracedecode(int);
1.61 matthew 137: static void atfd(int);
1.77 guenther 138: static void polltimeout(int);
1.82 guenther 139: static void wait4pid(int);
1.83 guenther 140: static void signame(int);
141: static void semctlname(int);
142: static void shmctlname(int);
143: static void semgetname(int);
1.92 guenther 144: static void flagsandmodename(int);
1.83 guenther 145: static void clockname(int);
146: static void sockoptlevelname(int);
1.88 guenther 147: static void ktraceopname(int);
1.151 guenther 148: static void idtypeandid(int);
1.12 espie 149:
1.102 deraadt 150: static int screenwidth;
151:
1.1 deraadt 152: int
1.17 deraadt 153: main(int argc, char *argv[])
1.1 deraadt 154: {
1.37 tedu 155: int ch, silent;
156: size_t ktrlen, size;
1.17 deraadt 157: int trpoints = ALL_POINTS;
1.101 deraadt 158: const char *errstr;
1.12 espie 159: void *m;
1.1 deraadt 160:
1.102 deraadt 161: if (screenwidth == 0) {
162: struct winsize ws;
163:
164: if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 &&
165: ws.ws_col > 8)
166: screenwidth = ws.ws_col;
167: else
168: screenwidth = 80;
169: }
170:
1.122 guenther 171: while ((ch = getopt(argc, argv, "f:dHlm:np:RTt:xX")) != -1)
1.1 deraadt 172: switch (ch) {
173: case 'f':
174: tracefile = optarg;
175: break;
176: case 'd':
177: decimal = 1;
178: break;
1.67 mikeb 179: case 'H':
180: needtid = 1;
181: break;
1.1 deraadt 182: case 'l':
183: tail = 1;
184: break;
185: case 'm':
1.101 deraadt 186: maxdata = strtonum(optarg, 0, INT_MAX, &errstr);
187: if (errstr)
188: errx(1, "-m %s: %s", optarg, errstr);
1.1 deraadt 189: break;
190: case 'n':
191: fancy = 0;
192: break;
1.17 deraadt 193: case 'p':
1.101 deraadt 194: pid_opt = strtonum(optarg, 1, INT_MAX, &errstr);
195: if (errstr)
196: errx(1, "-p %s: %s", optarg, errstr);
1.17 deraadt 197: break;
1.128 tedu 198: case 'R': /* relative timestamp */
1.141 cheloha 199: if (timestamp == TIMESTAMP_ABSOLUTE)
200: timestamp = TIMESTAMP_ELAPSED;
201: else
202: timestamp = TIMESTAMP_RELATIVE;
1.1 deraadt 203: break;
204: case 'T':
1.141 cheloha 205: if (timestamp == TIMESTAMP_RELATIVE)
206: timestamp = TIMESTAMP_ELAPSED;
207: else
208: timestamp = TIMESTAMP_ABSOLUTE;
1.1 deraadt 209: break;
210: case 't':
1.129 guenther 211: trpoints = getpoints(optarg, DEF_POINTS);
1.1 deraadt 212: if (trpoints < 0)
213: errx(1, "unknown trace point in %s", optarg);
214: break;
1.31 tedu 215: case 'x':
216: iohex = 1;
217: break;
218: case 'X':
219: iohex = 2;
220: break;
1.1 deraadt 221: default:
222: usage();
223: }
1.5 deraadt 224: if (argc > optind)
1.1 deraadt 225: usage();
1.108 deraadt 226:
1.136 tedu 227: if (strcmp(tracefile, "-") != 0)
228: if (unveil(tracefile, "r") == -1)
1.144 beck 229: err(1, "unveil %s", tracefile);
1.140 deraadt 230: if (unveil(_PATH_PROTOCOLS, "r") == -1)
1.144 beck 231: err(1, "unveil %s", _PATH_PROTOCOLS);
1.115 deraadt 232: if (pledge("stdio rpath getpw", NULL) == -1)
1.113 deraadt 233: err(1, "pledge");
1.1 deraadt 234:
1.37 tedu 235: m = malloc(size = 1025);
1.1 deraadt 236: if (m == NULL)
1.37 tedu 237: err(1, NULL);
1.136 tedu 238: if (strcmp(tracefile, "-") != 0)
239: if (!freopen(tracefile, "r", stdin))
240: err(1, "%s", tracefile);
1.112 deraadt 241:
1.67 mikeb 242: if (fread_tail(&ktr_header, sizeof(struct ktr_header), 1) == 0 ||
243: ktr_header.ktr_type != htobe32(KTR_START))
244: errx(1, "%s: not a dump", tracefile);
1.1 deraadt 245: while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) {
1.17 deraadt 246: silent = 0;
1.85 guenther 247: if (pid_opt != -1 && pid_opt != ktr_header.ktr_pid)
1.17 deraadt 248: silent = 1;
249: if (silent == 0 && trpoints & (1<<ktr_header.ktr_type))
1.1 deraadt 250: dumpheader(&ktr_header);
1.37 tedu 251: ktrlen = ktr_header.ktr_len;
1.1 deraadt 252: if (ktrlen > size) {
1.23 tedu 253: void *newm;
254:
1.64 guenther 255: if (ktrlen == SIZE_MAX)
256: errx(1, "data too long");
1.23 tedu 257: newm = realloc(m, ktrlen+1);
258: if (newm == NULL)
1.66 deraadt 259: err(1, "realloc");
1.23 tedu 260: m = newm;
1.1 deraadt 261: size = ktrlen;
262: }
263: if (ktrlen && fread_tail(m, ktrlen, 1) == 0)
264: errx(1, "data too short");
1.17 deraadt 265: if (silent)
266: continue;
1.1 deraadt 267: if ((trpoints & (1<<ktr_header.ktr_type)) == 0)
268: continue;
269: switch (ktr_header.ktr_type) {
270: case KTR_SYSCALL:
1.131 guenther 271: ktrsyscall(m, ktrlen);
1.1 deraadt 272: break;
273: case KTR_SYSRET:
1.131 guenther 274: ktrsysret(m, ktrlen);
1.1 deraadt 275: break;
276: case KTR_NAMEI:
277: ktrnamei(m, ktrlen);
278: break;
279: case KTR_GENIO:
1.131 guenther 280: ktrgenio(m, ktrlen);
1.1 deraadt 281: break;
282: case KTR_PSIG:
1.131 guenther 283: ktrpsig(m);
1.1 deraadt 284: break;
1.55 otto 285: case KTR_STRUCT:
286: ktrstruct(m, ktrlen);
287: break;
1.81 miod 288: case KTR_USER:
289: ktruser(m, ktrlen);
290: break;
1.106 guenther 291: case KTR_EXECARGS:
292: case KTR_EXECENV:
293: ktrexec(m, ktrlen);
294: break;
1.117 deraadt 295: case KTR_PLEDGE:
1.131 guenther 296: ktrpledge(m, ktrlen);
1.117 deraadt 297: break;
1.123 guenther 298: default:
299: printf("\n");
300: break;
1.1 deraadt 301: }
302: if (tail)
303: (void)fflush(stdout);
304: }
1.12 espie 305: exit(0);
1.1 deraadt 306: }
307:
1.12 espie 308: static int
1.37 tedu 309: fread_tail(void *buf, size_t size, size_t num)
1.1 deraadt 310: {
311: int i;
312:
313: while ((i = fread(buf, size, num, stdin)) == 0 && tail) {
314: (void)sleep(1);
315: clearerr(stdin);
316: }
317: return (i);
318: }
319:
1.12 espie 320: static void
1.17 deraadt 321: dumpheader(struct ktr_header *kth)
1.1 deraadt 322: {
1.67 mikeb 323: static struct timespec prevtime;
1.1 deraadt 324: char unknown[64], *type;
1.67 mikeb 325: struct timespec temp;
1.1 deraadt 326:
327: switch (kth->ktr_type) {
328: case KTR_SYSCALL:
329: type = "CALL";
330: break;
331: case KTR_SYSRET:
332: type = "RET ";
333: break;
334: case KTR_NAMEI:
335: type = "NAMI";
336: break;
337: case KTR_GENIO:
338: type = "GIO ";
339: break;
340: case KTR_PSIG:
341: type = "PSIG";
342: break;
1.55 otto 343: case KTR_STRUCT:
344: type = "STRU";
345: break;
1.81 miod 346: case KTR_USER:
347: type = "USER";
348: break;
1.106 guenther 349: case KTR_EXECARGS:
350: type = "ARGS";
351: break;
352: case KTR_EXECENV:
353: type = "ENV ";
354: break;
1.117 deraadt 355: case KTR_PLEDGE:
356: type = "PLDG";
357: break;
1.1 deraadt 358: default:
1.123 guenther 359: /* htobe32() not guaranteed to work as case label */
360: if (kth->ktr_type == htobe32(KTR_START)) {
361: type = "STRT";
362: break;
363: }
1.122 guenther 364: (void)snprintf(unknown, sizeof unknown, "UNKNOWN(%u)",
1.17 deraadt 365: kth->ktr_type);
1.1 deraadt 366: type = unknown;
367: }
368:
1.111 guenther 369: basecol = printf("%6ld", (long)kth->ktr_pid);
1.67 mikeb 370: if (needtid)
1.111 guenther 371: basecol += printf("/%-7ld", (long)kth->ktr_tid);
1.148 deraadt 372: basecol += printf(" %-8s ", kth->ktr_comm);
1.141 cheloha 373: if (timestamp != TIMESTAMP_NONE) {
374: if (timestamp == TIMESTAMP_ELAPSED) {
1.128 tedu 375: if (prevtime.tv_sec == 0)
376: prevtime = kth->ktr_time;
377: timespecsub(&kth->ktr_time, &prevtime, &temp);
1.141 cheloha 378: } else if (timestamp == TIMESTAMP_RELATIVE) {
1.67 mikeb 379: timespecsub(&kth->ktr_time, &prevtime, &temp);
1.1 deraadt 380: prevtime = kth->ktr_time;
381: } else
382: temp = kth->ktr_time;
1.111 guenther 383: basecol += printf("%lld.%06ld ", (long long)temp.tv_sec,
1.79 deraadt 384: temp.tv_nsec / 1000);
1.1 deraadt 385: }
1.111 guenther 386: basecol += printf("%s ", type);
1.1 deraadt 387: }
388:
1.92 guenther 389: /*
390: * Base Formatters
391: */
392:
393: /* some syscalls have padding that shouldn't be shown */
394: static int
395: pad(long arg)
396: {
397: /* nothing printed */
398: return (1);
399: }
400:
401: /* a formatter that just saves the argument for the next formatter */
402: int arg1;
403: static int
404: pass_two(long arg)
405: {
406: arg1 = (int)arg;
407:
408: /* nothing printed */
409: return (1);
410: }
411:
412: static int
413: pdeclong(long arg)
414: {
415: (void)printf("%ld", arg);
416: return (0);
417: }
418:
419: static int
420: pdeculong(long arg)
1.2 deraadt 421: {
1.92 guenther 422: (void)printf("%lu", arg);
423: return (0);
424: }
1.2 deraadt 425:
1.92 guenther 426: static int
427: phexlong(long arg)
428: {
429: (void)printf("%#lx", arg);
430: return (0);
431: }
1.2 deraadt 432:
1.92 guenther 433: static int
434: pnonfancy(long arg)
435: {
436: if (decimal)
437: (void)printf("%ld", arg);
1.2 deraadt 438: else
1.92 guenther 439: (void)printf("%#lx", arg);
440: return (0);
1.2 deraadt 441: }
1.1 deraadt 442:
1.52 otto 443: static void
1.92 guenther 444: pdecint(int arg)
1.52 otto 445: {
1.92 guenther 446: (void)printf("%d", arg);
1.52 otto 447: }
448:
449: static void
1.92 guenther 450: pdecuint(int arg)
1.52 otto 451: {
1.92 guenther 452: (void)printf("%u", arg);
1.52 otto 453: }
454:
455: static void
1.92 guenther 456: phexint(int arg)
1.52 otto 457: {
1.92 guenther 458: (void)printf("%#x", arg);
1.52 otto 459: }
1.92 guenther 460:
1.52 otto 461: static void
1.92 guenther 462: poctint(int arg)
463: {
464: (void)printf("%#o", arg);
465: }
466:
467:
468: #ifdef __LP64__
469:
470: /* on LP64, long long arguments are the same as long arguments */
471: #define Phexlonglong Phexlong
472: #define phexll NULL /* not actually used on LP64 */
473:
1.145 guenther 474: /* no padding before long long arguments, nor at end */
475: #define PAD64 0
476: #define END64 end_of_args
477:
1.92 guenther 478: #else /* __LP64__ */
479:
480: /* on ILP32, long long arguments are passed as two 32bit args */
481: #define Phexlonglong PASS_LONGLONG, Phexll
482:
483: static int
484: phexll(long arg2)
1.52 otto 485: {
1.92 guenther 486: long long val;
487:
488: #if _BYTE_ORDER == _LITTLE_ENDIAN
489: val = ((long long)arg2 << 32) | ((long long)arg1 & 0xffffffff);
490: #else
491: val = ((long long)arg1 << 32) | ((long long)arg2 & 0xffffffff);
492: #endif
493:
494: if (fancy || !decimal)
495: (void)printf("%#llx", val);
496: else
1.52 otto 497: (void)printf("%lld", val);
1.92 guenther 498: return (0);
1.52 otto 499: }
1.92 guenther 500:
1.145 guenther 501: /*
502: * Some ILP32 archs naturally align off_t arguments to 8byte boundaries
503: * Get the compiler to tell if this arch is one of them.
504: */
505: struct padding_test {
506: int padtest_one;
507: off_t padtest_two;
508: };
509: #define PAD64 (offsetof(struct padding_test,padtest_two) == 8)
510: #define END64 (PAD64 ? PASS_LONGLONG : end_of_args)
511:
1.92 guenther 512: #endif /* __LP64__ */
513:
514: static int (*long_formatters[])(long) = {
515: NULL,
516: pdeclong,
517: pdeculong,
518: phexlong,
519: pass_two,
520: pass_two,
521: phexll,
522: pad,
523: pnonfancy,
524: };
525:
526: static void (*formatters[])(int) = {
527: NULL,
528: pdecint,
529: phexint,
530: poctint,
531: pdecuint,
532: ioctldecode,
533: ptracedecode,
534: atfd,
535: polltimeout,
536: wait4pid,
537: signame,
538: semctlname,
539: shmctlname,
540: semgetname,
541: flagsandmodename,
542: clockname,
543: sockoptlevelname,
544: ktraceopname,
545: fcntlcmdname,
546: modename,
547: flagsname,
548: openflagsname,
549: atflagsname,
550: accessmodename,
551: mmapprotname,
552: mmapflagsname,
553: wait4optname,
554: sendrecvflagsname,
555: mountflagsname,
556: rebootoptname,
557: flockname,
558: sockoptname,
559: sockipprotoname,
560: socktypename,
561: sockflagsname,
562: sockfamilyname,
563: mlockallname,
564: shmatname,
565: whencename,
566: pathconfname,
567: rlimitname,
568: shutdownhowname,
569: prioname,
570: madvisebehavname,
571: msyncflagsname,
572: clocktypename,
573: rusagewho,
574: sigactionflagname,
575: sigprocmaskhowname,
576: minheritname,
577: quotactlname,
578: sigill_name,
579: sigtrap_name,
580: sigemt_name,
581: sigfpe_name,
582: sigbus_name,
583: sigsegv_name,
584: sigchld_name,
585: ktracefacname,
586: itimername,
587: sigset,
1.94 guenther 588: uidname,
589: gidname,
1.125 guenther 590: syslogflagname,
1.130 mpi 591: futexflagname,
1.151 guenther 592: waitidoptname,
593: idtypeandid,
1.92 guenther 594: };
595:
596: enum {
597: /* the end of the (known) arguments is recognized by the zero fill */
598: end_of_args = 0,
599:
600: /* negative are the negative of the index into long_formatters[] */
601: Pdeclong = -1,
602: Pdeculong = -2,
603: Phexlong = -3,
604: PASS_TWO = -4,
605:
606: /* the remaining long formatters still get called when non-fancy (-n option) */
607: #define FMT_IS_NONFANCY(x) ((x) <= PASS_LONGLONG)
608: PASS_LONGLONG = -5,
609: Phexll = -6,
610: PAD = -7,
611: Pnonfancy = -8,
612:
613: /* positive values are the index into formatters[] */
614: Pdecint = 1,
615: Phexint,
616: Poctint,
617: Pdecuint,
618: Ioctldecode,
619: Ptracedecode,
620: Atfd,
621: Polltimeout,
622: Wait4pid,
623: Signame,
624: Semctlname,
625: Shmctlname,
626: Semgetname,
627: Flagsandmodename,
628: Clockname,
629: Sockoptlevelname,
630: Ktraceopname,
631: Fcntlcmdname,
632: Modename,
633: Flagsname,
634: Openflagsname,
635: Atflagsname,
636: Accessmodename,
637: Mmapprotname,
638: Mmapflagsname,
639: Wait4optname,
640: Sendrecvflagsname,
641: Mountflagsname,
642: Rebootoptname,
643: Flockname,
644: Sockoptname,
645: Sockipprotoname,
646: Socktypename,
647: Sockflagsname,
648: Sockfamilyname,
649: Mlockallname,
650: Shmatname,
651: Whencename,
652: Pathconfname,
653: Rlimitname,
654: Shutdownhowname,
655: Prioname,
656: Madvisebehavname,
657: Msyncflagsname,
658: Clocktypename,
659: Rusagewho,
660: Sigactionflagname,
661: Sigprocmaskhowname,
662: Minheritname,
663: Quotactlname,
664: Sigill_name,
665: Sigtrap_name,
666: Sigemt_name,
667: Sigfpe_name,
668: Sigbus_name,
669: Sigsegv_name,
670: Sigchld_name,
671: Ktracefacname,
672: Itimername,
673: Sigset,
1.94 guenther 674: Uidname,
675: Gidname,
1.125 guenther 676: Syslogflagname,
1.130 mpi 677: Futexflagname,
1.151 guenther 678: Waitidoptname,
679: Idtypeandid,
1.92 guenther 680: };
681:
682: #define Pptr Phexlong
683: #define Psize Pdeculong /* size_t for small buffers */
684: #define Pbigsize Phexlong /* size_t for I/O buffers */
685: #define Pcount Pdecint /* int for a count of something */
686: #define Pfd Pdecint
687: #define Ppath Phexlong
688: #define Pdev_t Pdecint
689: #define Ppid_t Pdecint
690: #define Ppgid Pdecint /* pid or negative pgid */
691: #define Poff_t Phexlonglong
692: #define Pmsqid Pdecint
693: #define Pshmid Pdecint
694: #define Psemid Pdecint
695: #define Pkey_t Pdecint
696: #define Pucount Pdecuint
697: #define Chflagsname Phexlong /* to be added */
698: #define Sockprotoname Phexlong /* to be added */
699: #define Swapctlname Phexlong /* to be added */
700: #define Msgflgname Phexlong /* to be added */
701:
702:
1.151 guenther 703: /* includes relevant entries as of syscalls.master rev 1.238 */
1.92 guenther 704: typedef signed char formatter;
705: static const formatter scargs[][8] = {
706: [SYS_exit] = { Pdecint },
707: [SYS_read] = { Pfd, Pptr, Pbigsize },
708: [SYS_write] = { Pfd, Pptr, Pbigsize },
709: [SYS_open] = { Ppath, PASS_TWO, Flagsandmodename },
710: [SYS_close] = { Pfd },
711: [SYS_getentropy] = { Pptr, Psize },
712: [SYS___tfork] = { Pptr, Psize },
713: [SYS_link] = { Ppath, Ppath },
714: [SYS_unlink] = { Ppath },
715: [SYS_wait4] = { Wait4pid, Pptr, Wait4optname },
716: [SYS_chdir] = { Ppath },
717: [SYS_fchdir] = { Pfd },
718: [SYS_mknod] = { Ppath, Modename, Pdev_t },
719: [SYS_chmod] = { Ppath, Modename },
1.94 guenther 720: [SYS_chown] = { Ppath, Uidname, Gidname },
1.92 guenther 721: [SYS_break] = { Pptr },
722: [SYS_getrusage] = { Rusagewho, Pptr },
723: [SYS_mount] = { Pptr, Ppath, Mountflagsname, Pptr },
724: [SYS_unmount] = { Ppath, Mountflagsname },
1.94 guenther 725: [SYS_setuid] = { Uidname },
1.92 guenther 726: [SYS_ptrace] = { Ptracedecode, Ppid_t, Pptr, Pdecint },
727: [SYS_recvmsg] = { Pfd, Pptr, Sendrecvflagsname },
728: [SYS_sendmsg] = { Pfd, Pptr, Sendrecvflagsname },
729: [SYS_recvfrom] = { Pfd, Pptr, Pbigsize, Sendrecvflagsname },
730: [SYS_accept] = { Pfd, Pptr, Pptr },
731: [SYS_getpeername] = { Pfd, Pptr, Pptr },
732: [SYS_getsockname] = { Pfd, Pptr, Pptr },
733: [SYS_access] = { Ppath, Accessmodename },
734: [SYS_chflags] = { Ppath, Chflagsname },
735: [SYS_fchflags] = { Pfd, Chflagsname },
1.152 guenther 736: [SYS_msyscall] = { Pptr, Pbigsize },
1.92 guenther 737: [SYS_stat] = { Ppath, Pptr },
738: [SYS_lstat] = { Ppath, Pptr },
739: [SYS_dup] = { Pfd },
740: [SYS_fstatat] = { Atfd, Ppath, Pptr, Atflagsname },
741: [SYS_profil] = { Pptr, Pbigsize, Pbigsize, Pdecuint },
742: [SYS_ktrace] = { Ppath, Ktraceopname, Ktracefacname, Ppgid },
743: [SYS_sigaction] = { Signame, Pptr, Pptr },
744: [SYS_sigprocmask] = { Sigprocmaskhowname, Sigset },
1.152 guenther 745: [SYS_mmap] = { Pptr, Pbigsize, Mmapprotname, Mmapflagsname, Pfd, Poff_t, END64 },
1.92 guenther 746: [SYS_setlogin] = { Pptr },
747: [SYS_acct] = { Ppath },
748: [SYS_fstat] = { Pfd, Pptr },
749: [SYS_ioctl] = { Pfd, Ioctldecode, Pptr },
750: [SYS_reboot] = { Rebootoptname },
751: [SYS_revoke] = { Ppath },
752: [SYS_symlink] = { Ppath, Ppath },
753: [SYS_readlink] = { Ppath, Pptr, Psize },
754: [SYS_execve] = { Ppath, Pptr, Pptr },
755: [SYS_umask] = { Modename },
756: [SYS_chroot] = { Ppath },
757: [SYS_getfsstat] = { Pptr, Pbigsize, Mountflagsname },
758: [SYS_statfs] = { Ppath, Pptr },
759: [SYS_fstatfs] = { Pfd, Pptr },
760: [SYS_fhstatfs] = { Pptr, Pptr },
761: [SYS_gettimeofday] = { Pptr, Pptr },
762: [SYS_settimeofday] = { Pptr, Pptr },
763: [SYS_setitimer] = { Itimername, Pptr, Pptr },
764: [SYS_getitimer] = { Itimername, Pptr },
765: [SYS_select] = { Pcount, Pptr, Pptr, Pptr, Pptr },
766: [SYS_kevent] = { Pfd, Pptr, Pcount, Pptr, Pcount, Pptr },
767: [SYS_munmap] = { Pptr, Pbigsize },
768: [SYS_mprotect] = { Pptr, Pbigsize, Mmapprotname },
769: [SYS_madvise] = { Pptr, Pbigsize, Madvisebehavname },
770: [SYS_utimes] = { Ppath, Pptr },
771: [SYS_futimes] = { Pfd, Pptr },
1.152 guenther 772: [SYS_mquery] = { Pptr, Pbigsize, Mmapprotname, Mmapflagsname, Pfd, Poff_t, END64 },
1.92 guenther 773: [SYS_getgroups] = { Pcount, Pptr },
774: [SYS_setgroups] = { Pcount, Pptr },
775: [SYS_setpgid] = { Ppid_t, Ppid_t },
1.130 mpi 776: [SYS_futex] = { Pptr, Futexflagname, Pcount, Pptr, Pptr },
1.92 guenther 777: [SYS_utimensat] = { Atfd, Ppath, Pptr, Atflagsname },
778: [SYS_futimens] = { Pfd, Pptr },
1.152 guenther 779: [SYS_kbind] = { Pptr, Psize, Phexlonglong },
1.92 guenther 780: [SYS_clock_gettime] = { Clockname, Pptr },
781: [SYS_clock_settime] = { Clockname, Pptr },
782: [SYS_clock_getres] = { Clockname, Pptr },
783: [SYS_dup2] = { Pfd, Pfd },
784: [SYS_nanosleep] = { Pptr, Pptr },
785: [SYS_fcntl] = { Pfd, PASS_TWO, Fcntlcmdname },
786: [SYS_accept4] = { Pfd, Pptr, Pptr, Sockflagsname },
787: [SYS___thrsleep] = { Pptr, Clockname, Pptr, Pptr, Pptr },
788: [SYS_fsync] = { Pfd },
789: [SYS_setpriority] = { Prioname, Ppid_t, Pdecint },
1.99 guenther 790: [SYS_socket] = { Sockfamilyname, Socktypename, Sockprotoname },
1.92 guenther 791: [SYS_connect] = { Pfd, Pptr, Pucount },
792: [SYS_getdents] = { Pfd, Pptr, Pbigsize },
793: [SYS_getpriority] = { Prioname, Ppid_t },
794: [SYS_pipe2] = { Pptr, Flagsname },
795: [SYS_dup3] = { Pfd, Pfd, Flagsname },
796: [SYS_sigreturn] = { Pptr },
797: [SYS_bind] = { Pfd, Pptr, Pucount },
798: [SYS_setsockopt] = { Pfd, PASS_TWO, Sockoptlevelname, Pptr, Pdecint },
799: [SYS_listen] = { Pfd, Pdecint },
800: [SYS_chflagsat] = { Atfd, Ppath, Chflagsname, Atflagsname },
1.152 guenther 801: [SYS_pledge] = { Pptr, Pptr },
1.92 guenther 802: [SYS_ppoll] = { Pptr, Pucount, Pptr, Pptr },
803: [SYS_pselect] = { Pcount, Pptr, Pptr, Pptr, Pptr, Pptr },
804: [SYS_sigsuspend] = { Sigset },
1.152 guenther 805: [SYS_sendsyslog] = { Pptr, Psize, Syslogflagname },
806: [SYS_unveil] = { Ppath, Pptr },
807: [SYS___realpath] = { Ppath, Pptr },
808: [SYS_recvmmsg] = { Pfd, Pptr, Pucount, Sendrecvflagsname, Pptr },
809: [SYS_sendmmsg] = { Pfd, Pptr, Pucount, Sendrecvflagsname },
1.92 guenther 810: [SYS_getsockopt] = { Pfd, PASS_TWO, Sockoptlevelname, Pptr, Pptr },
1.120 guenther 811: [SYS_thrkill] = { Ppid_t, Signame, Pptr },
1.92 guenther 812: [SYS_readv] = { Pfd, Pptr, Pcount },
813: [SYS_writev] = { Pfd, Pptr, Pcount },
1.152 guenther 814: [SYS_kill] = { Ppgid, Signame },
1.94 guenther 815: [SYS_fchown] = { Pfd, Uidname, Gidname },
1.92 guenther 816: [SYS_fchmod] = { Pfd, Modename },
1.94 guenther 817: [SYS_setreuid] = { Uidname, Uidname },
818: [SYS_setregid] = { Gidname, Gidname },
1.92 guenther 819: [SYS_rename] = { Ppath, Ppath },
820: [SYS_flock] = { Pfd, Flockname },
821: [SYS_mkfifo] = { Ppath, Modename },
822: [SYS_sendto] = { Pfd, Pptr, Pbigsize, Sendrecvflagsname },
823: [SYS_shutdown] = { Pfd, Shutdownhowname },
1.99 guenther 824: [SYS_socketpair] = { Sockfamilyname, Socktypename, Sockprotoname, Pptr },
1.92 guenther 825: [SYS_mkdir] = { Ppath, Modename },
826: [SYS_rmdir] = { Ppath },
827: [SYS_adjtime] = { Pptr, Pptr },
1.152 guenther 828: [SYS_getlogin_r] = { Pptr, Psize },
1.154 guenther 829: [SYS_getthrname] = { Ppid_t, Pptr, Psize },
830: [SYS_setthrname] = { Ppid_t, Pptr },
1.94 guenther 831: [SYS_quotactl] = { Ppath, Quotactlname, Uidname, Pptr },
1.152 guenther 832: [SYS_ypconnect] = { Socktypename },
1.92 guenther 833: [SYS_nfssvc] = { Phexint, Pptr },
1.151 guenther 834: [SYS_mimmutable] = { Pptr, Pbigsize },
835: [SYS_waitid] = { PASS_TWO, Idtypeandid, Pptr, Waitidoptname },
1.92 guenther 836: [SYS_getfh] = { Ppath, Pptr },
1.152 guenther 837: [SYS___tmpfd] = { Openflagsname },
1.92 guenther 838: [SYS_sysarch] = { Pdecint, Pptr },
1.152 guenther 839: [SYS_lseek] = { Pfd, Poff_t, Whencename, END64 },
840: [SYS_truncate] = { Ppath, Poff_t, END64 },
841: [SYS_ftruncate] = { Pfd, Poff_t, END64 },
1.145 guenther 842: [SYS_pread] = { Pfd, Pptr, Pbigsize, Poff_t, END64 },
843: [SYS_pwrite] = { Pfd, Pptr, Pbigsize, Poff_t, END64 },
1.152 guenther 844: [SYS_preadv] = { Pfd, Pptr, Pcount, Poff_t, END64 },
845: [SYS_pwritev] = { Pfd, Pptr, Pcount, Poff_t, END64 },
1.94 guenther 846: [SYS_setgid] = { Gidname },
847: [SYS_setegid] = { Gidname },
848: [SYS_seteuid] = { Uidname },
1.92 guenther 849: [SYS_pathconf] = { Ppath, Pathconfname },
850: [SYS_fpathconf] = { Pfd, Pathconfname },
851: [SYS_swapctl] = { Swapctlname, Pptr, Pdecint },
852: [SYS_getrlimit] = { Rlimitname, Pptr },
853: [SYS_setrlimit] = { Rlimitname, Pptr },
1.122 guenther 854: [SYS_sysctl] = { Pptr, Pcount, Pptr, Pptr, Pptr, Psize },
1.92 guenther 855: [SYS_mlock] = { Pptr, Pbigsize },
856: [SYS_munlock] = { Pptr, Pbigsize },
857: [SYS_getpgid] = { Ppid_t },
858: [SYS_utrace] = { Pptr, Pptr, Psize },
859: [SYS_semget] = { Pkey_t, Pcount, Semgetname },
860: [SYS_msgget] = { Pkey_t, Msgflgname },
861: [SYS_msgsnd] = { Pmsqid, Pptr, Psize, Msgflgname },
862: [SYS_msgrcv] = { Pmsqid, Pptr, Psize, Pdeclong, Msgflgname },
863: [SYS_shmat] = { Pshmid, Pptr, Shmatname },
864: [SYS_shmdt] = { Pptr },
865: [SYS_minherit] = { Pptr, Pbigsize, Minheritname },
866: [SYS_poll] = { Pptr, Pucount, Polltimeout },
1.94 guenther 867: [SYS_lchown] = { Ppath, Uidname, Gidname },
1.92 guenther 868: [SYS_getsid] = { Ppid_t },
869: [SYS_msync] = { Pptr, Pbigsize, Msyncflagsname },
870: [SYS_pipe] = { Pptr },
871: [SYS_fhopen] = { Pptr, Openflagsname },
872: [SYS_mlockall] = { Mlockallname },
873: [SYS_getresuid] = { Pptr, Pptr, Pptr },
1.94 guenther 874: [SYS_setresuid] = { Uidname, Uidname, Uidname },
1.92 guenther 875: [SYS_getresgid] = { Pptr, Pptr, Pptr },
1.94 guenther 876: [SYS_setresgid] = { Gidname, Gidname, Gidname },
1.92 guenther 877: [SYS_closefrom] = { Pfd },
878: [SYS_sigaltstack] = { Pptr, Pptr },
879: [SYS_shmget] = { Pkey_t, Pbigsize, Semgetname },
880: [SYS_semop] = { Psemid, Pptr, Psize },
881: [SYS_fhstat] = { Pptr, Pptr },
882: [SYS___semctl] = { Psemid, Pcount, Semctlname, Pptr },
883: [SYS_shmctl] = { Pshmid, Shmctlname, Pptr },
884: [SYS_msgctl] = { Pmsqid, Shmctlname, Pptr },
885: [SYS___thrwakeup] = { Pptr, Pcount },
886: [SYS___threxit] = { Pptr },
887: [SYS___thrsigdivert] = { Sigset, Pptr, Pptr },
888: [SYS___getcwd] = { Pptr, Psize },
889: [SYS_adjfreq] = { Pptr, Pptr },
890: [SYS_setrtable] = { Pdecint },
891: [SYS_faccessat] = { Atfd, Ppath, Accessmodename, Atflagsname },
892: [SYS_fchmodat] = { Atfd, Ppath, Modename, Atflagsname },
1.94 guenther 893: [SYS_fchownat] = { Atfd, Ppath, Uidname, Gidname, Atflagsname },
1.92 guenther 894: [SYS_linkat] = { Atfd, Ppath, Atfd, Ppath, Atflagsname },
895: [SYS_mkdirat] = { Atfd, Ppath, Modename },
896: [SYS_mkfifoat] = { Atfd, Ppath, Modename },
897: [SYS_mknodat] = { Atfd, Ppath, Modename, Pdev_t },
898: [SYS_openat] = { Atfd, Ppath, PASS_TWO, Flagsandmodename },
899: [SYS_readlinkat] = { Atfd, Ppath, Pptr, Psize },
900: [SYS_renameat] = { Atfd, Ppath, Atfd, Ppath },
1.98 guenther 901: [SYS_symlinkat] = { Ppath, Atfd, Ppath },
1.92 guenther 902: [SYS_unlinkat] = { Atfd, Ppath, Atflagsname },
903: [SYS___set_tcb] = { Pptr },
904: };
905:
1.51 otto 906:
1.12 espie 907: static void
1.93 jsg 908: ktrsyscall(struct ktr_syscall *ktr, size_t ktrlen)
1.1 deraadt 909: {
1.92 guenther 910: register_t *ap;
1.155 deraadt 911: int narg, code;
1.92 guenther 912: char sep;
913:
1.93 jsg 914: if (ktr->ktr_argsize > ktrlen)
915: errx(1, "syscall argument length %d > ktr header length %zu",
916: ktr->ktr_argsize, ktrlen);
917:
1.52 otto 918: narg = ktr->ktr_argsize / sizeof(register_t);
919: sep = '\0';
1.1 deraadt 920:
1.155 deraadt 921: if (ktr->ktr_code & KTRC_CODE_SYSCALL)
922: (void)printf("(via syscall) ");
923: code = ktr->ktr_code & KTRC_CODE_MASK;
924: if (code >= SYS_MAXSYSCALL || code < 0)
925: (void)printf("[%d]", code);
1.1 deraadt 926: else
1.155 deraadt 927: (void)printf("%s", syscallnames[code]);
1.1 deraadt 928: ap = (register_t *)((char *)ktr + sizeof(struct ktr_syscall));
1.27 mickey 929: (void)putchar('(');
1.52 otto 930:
1.155 deraadt 931: if (code == SYS_sysctl && fancy) {
1.62 otto 932: const char *s;
1.94 guenther 933: int n, i, *top;
1.52 otto 934:
935: n = ap[1];
936: if (n > CTL_MAXNAME)
937: n = CTL_MAXNAME;
1.93 jsg 938: if (n < 0)
939: errx(1, "invalid sysctl length %d", n);
1.94 guenther 940: if (n > 0) {
941: top = (int *)(ap + 6);
942: printf("%d", top[0]);
943: for (i = 1; i < n; i++)
944: printf(".%d", top[i]);
945: if ((s = kresolvsysctl(0, top)) != NULL) {
946: printf("<%s", s);
947: for (i = 1; i < n; i++) {
948: if ((s = kresolvsysctl(i, top)) != NULL)
949: printf(".%s", s);
950: else
951: printf(".%d", top[i]);
952: }
953: putchar('>');
954: }
1.1 deraadt 955: }
1.52 otto 956:
957: sep = ',';
958: ap += 2;
959: narg -= 2;
1.155 deraadt 960: } else if (code < nitems(scargs)) {
961: const formatter *fmts = scargs[code];
1.92 guenther 962: int fmt;
1.145 guenther 963: int arg = 0;
1.52 otto 964:
1.145 guenther 965: while (arg < narg && (fmt = *fmts) != 0) {
966: if (PAD64 && fmt == PASS_LONGLONG && (arg & 1))
967: goto skip;
1.92 guenther 968: if (sep)
969: putchar(sep);
970: sep = ',';
971: if (!fancy && !FMT_IS_NONFANCY(fmt))
972: fmt = Pnonfancy;
973: if (fmt > 0)
974: formatters[fmt]((int)*ap);
975: else if (long_formatters[-fmt](*ap))
976: sep = '\0';
977: fmts++;
1.145 guenther 978: skip:
1.92 guenther 979: ap++;
1.145 guenther 980: arg++;
1.92 guenther 981: }
1.145 guenther 982: narg -= arg;
1.52 otto 983: }
984:
1.93 jsg 985: while (narg > 0) {
1.52 otto 986: if (sep)
987: putchar(sep);
988: if (decimal)
989: (void)printf("%ld", (long)*ap);
990: else
991: (void)printf("%#lx", (long)*ap);
992: sep = ',';
993: ap++;
994: narg--;
1.1 deraadt 995: }
1.27 mickey 996: (void)printf(")\n");
1.62 otto 997: }
998:
999: static struct ctlname topname[] = CTL_NAMES;
1000: static struct ctlname kernname[] = CTL_KERN_NAMES;
1001: static struct ctlname vmname[] = CTL_VM_NAMES;
1002: static struct ctlname fsname[] = CTL_FS_NAMES;
1003: static struct ctlname netname[] = CTL_NET_NAMES;
1004: static struct ctlname hwname[] = CTL_HW_NAMES;
1005: static struct ctlname debugname[CTL_DEBUG_MAXID];
1006: static struct ctlname kernmallocname[] = CTL_KERN_MALLOC_NAMES;
1007: static struct ctlname forkstatname[] = CTL_KERN_FORKSTAT_NAMES;
1008: static struct ctlname nchstatsname[] = CTL_KERN_NCHSTATS_NAMES;
1.88 guenther 1009: static struct ctlname kernprocname[] = {
1.64 guenther 1010: { NULL },
1011: { "all" },
1012: { "pid" },
1013: { "pgrp" },
1014: { "session" },
1015: { "tty" },
1016: { "uid" },
1017: { "ruid" },
1.77 guenther 1018: { "kthread" },
1.64 guenther 1019: };
1.62 otto 1020: static struct ctlname ttysname[] = CTL_KERN_TTY_NAMES;
1021: static struct ctlname semname[] = CTL_KERN_SEMINFO_NAMES;
1022: static struct ctlname shmname[] = CTL_KERN_SHMINFO_NAMES;
1023: static struct ctlname watchdogname[] = CTL_KERN_WATCHDOG_NAMES;
1024: static struct ctlname tcname[] = CTL_KERN_TIMECOUNTER_NAMES;
1025: #ifdef CTL_MACHDEP_NAMES
1026: static struct ctlname machdepname[] = CTL_MACHDEP_NAMES;
1027: #endif
1028: static struct ctlname ddbname[] = CTL_DDB_NAMES;
1029:
1030: #ifndef nitems
1031: #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
1032: #endif
1033:
1034: #define SETNAME(name) do { names = (name); limit = nitems(name); } while (0)
1035:
1036: static const char *
1.94 guenther 1037: kresolvsysctl(int depth, const int *top)
1.62 otto 1038: {
1039: struct ctlname *names;
1040: size_t limit;
1.94 guenther 1041: int idx = top[depth];
1.62 otto 1042:
1043: names = NULL;
1044:
1045: switch (depth) {
1046: case 0:
1047: SETNAME(topname);
1048: break;
1049: case 1:
1050: switch (top[0]) {
1051: case CTL_KERN:
1052: SETNAME(kernname);
1053: break;
1054: case CTL_VM:
1055: SETNAME(vmname);
1056: break;
1057: case CTL_FS:
1058: SETNAME(fsname);
1059: break;
1060: case CTL_NET:
1061: SETNAME(netname);
1062: break;
1063: case CTL_DEBUG:
1064: SETNAME(debugname);
1065: break;
1066: case CTL_HW:
1067: SETNAME(hwname);
1068: break;
1069: #ifdef CTL_MACHDEP_NAMES
1070: case CTL_MACHDEP:
1071: SETNAME(machdepname);
1072: break;
1073: #endif
1074: case CTL_DDB:
1075: SETNAME(ddbname);
1076: break;
1077: }
1078: break;
1079: case 2:
1080: switch (top[0]) {
1081: case CTL_KERN:
1082: switch (top[1]) {
1083: case KERN_MALLOCSTATS:
1084: SETNAME(kernmallocname);
1085: break;
1086: case KERN_FORKSTAT:
1087: SETNAME(forkstatname);
1088: break;
1089: case KERN_NCHSTATS:
1090: SETNAME(nchstatsname);
1091: break;
1092: case KERN_TTY:
1093: SETNAME(ttysname);
1094: break;
1095: case KERN_SEMINFO:
1096: SETNAME(semname);
1097: break;
1098: case KERN_SHMINFO:
1099: SETNAME(shmname);
1100: break;
1101: case KERN_WATCHDOG:
1102: SETNAME(watchdogname);
1103: break;
1.64 guenther 1104: case KERN_PROC:
1105: idx++; /* zero is valid at this level */
1106: SETNAME(kernprocname);
1107: break;
1.62 otto 1108: case KERN_TIMECOUNTER:
1109: SETNAME(tcname);
1110: break;
1111: }
1112: }
1113: break;
1114: }
1115: if (names != NULL && idx > 0 && idx < limit)
1116: return (names[idx].ctl_name);
1117: return (NULL);
1.1 deraadt 1118: }
1119:
1.12 espie 1120: static void
1.103 guenther 1121: ktrsysret(struct ktr_sysret *ktr, size_t ktrlen)
1.1 deraadt 1122: {
1.103 guenther 1123: register_t ret = 0;
1124: long long retll;
1.12 espie 1125: int error = ktr->ktr_error;
1126: int code = ktr->ktr_code;
1.1 deraadt 1127:
1.103 guenther 1128: if (ktrlen < sizeof(*ktr))
1129: errx(1, "sysret length %zu < ktr header length %zu",
1130: ktrlen, sizeof(*ktr));
1131: ktrlen -= sizeof(*ktr);
1132: if (error == 0) {
1133: if (ktrlen == sizeof(ret)) {
1134: memcpy(&ret, ktr+1, sizeof(ret));
1135: retll = ret;
1136: } else if (ktrlen == sizeof(retll))
1137: memcpy(&retll, ktr+1, sizeof(retll));
1138: else
1139: errx(1, "sysret bogus length %zu", ktrlen);
1140: }
1141:
1.122 guenther 1142: if (code >= SYS_MAXSYSCALL || code < 0)
1.1 deraadt 1143: (void)printf("[%d] ", code);
1.122 guenther 1144: else
1145: (void)printf("%s ", syscallnames[code]);
1.1 deraadt 1146:
1.127 guenther 1147: doerr:
1.1 deraadt 1148: if (error == 0) {
1149: if (fancy) {
1.122 guenther 1150: switch (code) {
1.103 guenther 1151: case SYS_lseek:
1152: (void)printf("%lld", retll);
1153: if (retll < 0 || retll > 9)
1154: (void)printf("/%#llx", retll);
1155: break;
1.64 guenther 1156: case SYS_sigprocmask:
1.73 guenther 1157: case SYS_sigpending:
1.64 guenther 1158: sigset(ret);
1159: break;
1160: case SYS___thrsigdivert:
1161: signame(ret);
1.94 guenther 1162: break;
1163: case SYS_getuid:
1164: case SYS_geteuid:
1165: uidname(ret);
1166: break;
1167: case SYS_getgid:
1168: case SYS_getegid:
1169: gidname(ret);
1.64 guenther 1170: break;
1.127 guenther 1171: /* syscalls that return errno values */
1172: case SYS_getlogin_r:
1173: case SYS___thrsleep:
1.154 guenther 1174: case SYS_getthrname:
1175: case SYS_setthrname:
1.127 guenther 1176: if ((error = ret) != 0)
1177: goto doerr;
1178: /* FALLTHROUGH */
1.64 guenther 1179: default:
1180: (void)printf("%ld", (long)ret);
1181: if (ret < 0 || ret > 9)
1182: (void)printf("/%#lx", (long)ret);
1183: }
1.1 deraadt 1184: } else {
1185: if (decimal)
1.103 guenther 1186: (void)printf("%lld", retll);
1.1 deraadt 1187: else
1.103 guenther 1188: (void)printf("%#llx", retll);
1.1 deraadt 1189: }
1190: } else if (error == ERESTART)
1191: (void)printf("RESTART");
1192: else if (error == EJUSTRETURN)
1193: (void)printf("JUSTRETURN");
1194: else {
1.127 guenther 1195: (void)printf("-1 errno %d", error);
1.1 deraadt 1196: if (fancy)
1.127 guenther 1197: (void)printf(" %s", strerror(error));
1.1 deraadt 1198: }
1199: (void)putchar('\n');
1200: }
1201:
1.12 espie 1202: static void
1.37 tedu 1203: ktrnamei(const char *cp, size_t len)
1.1 deraadt 1204: {
1.126 guenther 1205: showbufc(basecol, (unsigned char *)cp, len, VIS_DQ | VIS_TAB | VIS_NL);
1.1 deraadt 1206: }
1207:
1.111 guenther 1208: void
1.126 guenther 1209: showbufc(int col, unsigned char *dp, size_t datalen, int flags)
1.106 guenther 1210: {
1.126 guenther 1211: int width;
1212: unsigned char visbuf[5], *cp;
1.106 guenther 1213:
1.126 guenther 1214: flags |= VIS_CSTYLE;
1.106 guenther 1215: putchar('"');
1.111 guenther 1216: col++;
1.106 guenther 1217: for (; datalen > 0; datalen--, dp++) {
1.126 guenther 1218: (void)vis(visbuf, *dp, flags, *(dp+1));
1.106 guenther 1219: cp = visbuf;
1220:
1221: /*
1222: * Keep track of printables and
1223: * space chars (like fold(1)).
1224: */
1225: if (col == 0) {
1226: (void)putchar('\t');
1227: col = 8;
1228: }
1229: switch (*cp) {
1230: case '\n':
1231: col = 0;
1232: (void)putchar('\n');
1233: continue;
1234: case '\t':
1235: width = 8 - (col&07);
1236: break;
1237: default:
1238: width = strlen(cp);
1239: }
1240: if (col + width > (screenwidth-2)) {
1241: (void)printf("\\\n\t");
1242: col = 8;
1243: }
1244: col += width;
1245: do {
1246: (void)putchar(*cp++);
1247: } while (*cp);
1248: }
1249: if (col == 0)
1250: (void)printf(" ");
1251: (void)printf("\"\n");
1252: }
1253:
1254: static void
1.81 miod 1255: showbuf(unsigned char *dp, size_t datalen)
1.1 deraadt 1256: {
1.37 tedu 1257: int i, j;
1.126 guenther 1258: int col = 0, bpl;
1259: unsigned char c;
1.1 deraadt 1260:
1.31 tedu 1261: if (iohex == 1) {
1262: putchar('\t');
1263: col = 8;
1264: for (i = 0; i < datalen; i++) {
1.35 tedu 1265: printf("%02x", dp[i]);
1.31 tedu 1266: col += 3;
1267: if (i < datalen - 1) {
1268: if (col + 3 > screenwidth) {
1269: printf("\n\t");
1270: col = 8;
1271: } else
1272: putchar(' ');
1273: }
1274: }
1275: putchar('\n');
1276: return;
1277: }
1278: if (iohex == 2) {
1279: bpl = (screenwidth - 13)/4;
1280: if (bpl <= 0)
1281: bpl = 1;
1282: for (i = 0; i < datalen; i += bpl) {
1283: printf(" %04x: ", i);
1284: for (j = 0; j < bpl; j++) {
1285: if (i+j >= datalen)
1286: printf(" ");
1287: else
1.35 tedu 1288: printf("%02x ", dp[i+j]);
1.31 tedu 1289: }
1290: putchar(' ');
1291: for (j = 0; j < bpl; j++) {
1292: if (i+j >= datalen)
1293: break;
1294: c = dp[i+j];
1295: if (!isprint(c))
1296: c = '.';
1297: putchar(c);
1298: }
1299: putchar('\n');
1300: }
1301: return;
1302: }
1.111 guenther 1303:
1304: (void)printf(" ");
1.126 guenther 1305: showbufc(7, dp, datalen, 0);
1.1 deraadt 1306: }
1307:
1.12 espie 1308: static void
1.81 miod 1309: ktrgenio(struct ktr_genio *ktr, size_t len)
1310: {
1311: unsigned char *dp = (unsigned char *)ktr + sizeof(struct ktr_genio);
1.93 jsg 1312: size_t datalen;
1313:
1314: if (len < sizeof(struct ktr_genio))
1315: errx(1, "invalid ktr genio length %zu", len);
1316:
1317: datalen = len - sizeof(struct ktr_genio);
1.81 miod 1318:
1319: printf("fd %d %s %zu bytes\n", ktr->ktr_fd,
1320: ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen);
1321: if (maxdata == 0)
1322: return;
1323: if (datalen > maxdata)
1324: datalen = maxdata;
1325: if (iohex && !datalen)
1326: return;
1327: showbuf(dp, datalen);
1328: }
1329:
1.153 guenther 1330: void
1331: siginfo(const siginfo_t *si, int show_signo)
1.1 deraadt 1332: {
1.153 guenther 1333: if (show_signo) {
1334: printf("signo=");
1335: signame(si->si_signo);
1.64 guenther 1336: }
1.153 guenther 1337: if (si->si_code) {
1338: printf(" code=");
1339: if (!fancy)
1340: printf("<%d>", si->si_code);
1341: else {
1342: switch (si->si_signo) {
1.63 deraadt 1343: case SIGILL:
1.153 guenther 1344: sigill_name(si->si_code);
1.63 deraadt 1345: break;
1346: case SIGTRAP:
1.153 guenther 1347: sigtrap_name(si->si_code);
1.63 deraadt 1348: break;
1349: case SIGEMT:
1.153 guenther 1350: sigemt_name(si->si_code);
1.63 deraadt 1351: break;
1352: case SIGFPE:
1.153 guenther 1353: sigfpe_name(si->si_code);
1.63 deraadt 1354: break;
1355: case SIGBUS:
1.153 guenther 1356: sigbus_name(si->si_code);
1.63 deraadt 1357: break;
1358: case SIGSEGV:
1.153 guenther 1359: sigsegv_name(si->si_code);
1.63 deraadt 1360: break;
1361: case SIGCHLD:
1.153 guenther 1362: sigchld_name(si->si_code);
1363: break;
1364: default:
1365: printf("<%d>", si->si_code);
1.63 deraadt 1366: break;
1367: }
1368: }
1369: }
1370:
1.153 guenther 1371: switch (si->si_signo) {
1.14 deraadt 1372: case SIGSEGV:
1373: case SIGILL:
1374: case SIGBUS:
1375: case SIGFPE:
1.153 guenther 1376: printf(" addr=%p trapno=%d", si->si_addr, si->si_trapno);
1377: break;
1378: case SIGCHLD:
1379: if (si->si_code == CLD_EXITED) {
1380: printf(" status=%d", si->si_status);
1381: if (si->si_status < 0 || si->si_status > 9)
1382: (void)printf("/%#x", si->si_status);
1383: } else {
1384: printf(" status=");
1385: signame(si->si_status);
1386: }
1387: printf(" pid=%d uid=", si->si_pid);
1388: uidname(si->si_uid);
1.14 deraadt 1389: break;
1390: default:
1391: break;
1392: }
1.153 guenther 1393: }
1394:
1395: static void
1396: ktrpsig(struct ktr_psig *psig)
1397: {
1398: signame(psig->signo);
1399: printf(" ");
1400: if (psig->action == SIG_DFL)
1401: printf("SIG_DFL");
1402: else {
1403: printf("caught handler=0x%lx mask=", (u_long)psig->action);
1404: sigset(psig->mask);
1405: }
1406: siginfo(&psig->si, 0);
1407: putchar('\n');
1.1 deraadt 1408: }
1409:
1.64 guenther 1410: static void
1.81 miod 1411: ktruser(struct ktr_user *usr, size_t len)
1412: {
1.93 jsg 1413: if (len < sizeof(struct ktr_user))
1414: errx(1, "invalid ktr user length %zu", len);
1.81 miod 1415: len -= sizeof(struct ktr_user);
1416: printf("%.*s:", KTR_USER_MAXIDLEN, usr->ktr_id);
1417: printf(" %zu bytes\n", len);
1418: showbuf((unsigned char *)(usr + 1), len);
1.106 guenther 1419: }
1420:
1421: static void
1422: ktrexec(const char *ptr, size_t len)
1423: {
1.111 guenther 1424: int i, col;
1.106 guenther 1425: size_t l;
1426:
1427: putchar('\n');
1428: i = 0;
1429: while (len > 0) {
1430: l = strnlen(ptr, len);
1.111 guenther 1431: col = printf("\t[%d] = ", i++);
1432: col += 7; /* tab expands from 1 to 8 columns */
1.126 guenther 1433: showbufc(col, (unsigned char *)ptr, l, VIS_DQ|VIS_TAB|VIS_NL);
1.106 guenther 1434: if (l == len) {
1435: printf("\tunterminated argument\n");
1436: break;
1437: }
1438: len -= l + 1;
1439: ptr += l + 1;
1440: }
1.117 deraadt 1441: }
1442:
1443: static void
1444: ktrpledge(struct ktr_pledge *pledge, size_t len)
1445: {
1.142 visa 1446: const char *name = "";
1.117 deraadt 1447: int i;
1448:
1449: if (len < sizeof(struct ktr_pledge))
1450: errx(1, "invalid ktr pledge length %zu", len);
1451:
1.122 guenther 1452: if (pledge->syscall >= SYS_MAXSYSCALL || pledge->syscall < 0)
1.117 deraadt 1453: (void)printf("[%d]", pledge->syscall);
1454: else
1.122 guenther 1455: (void)printf("%s", syscallnames[pledge->syscall]);
1.117 deraadt 1456: printf(", ");
1.118 deraadt 1457: for (i = 0; pledge->code && pledgenames[i].bits != 0; i++) {
1.117 deraadt 1458: if (pledgenames[i].bits & pledge->code) {
1.118 deraadt 1459: name = pledgenames[i].name;
1.117 deraadt 1460: break;
1461: }
1462: }
1.118 deraadt 1463: printf("\"%s\"", name);
1.117 deraadt 1464: (void)printf(", errno %d", pledge->error);
1465: if (fancy)
1466: (void)printf(" %s", strerror(pledge->error));
1467: printf("\n");
1.81 miod 1468: }
1469:
1470: static void
1.17 deraadt 1471: usage(void)
1.1 deraadt 1472: {
1473:
1.19 mickey 1474: extern char *__progname;
1475: fprintf(stderr, "usage: %s "
1.138 schwarze 1476: "[-dHlnRTXx] [-f file] [-m maxdata] [-p pid] [-t trstr]\n",
1477: __progname);
1.1 deraadt 1478: exit(1);
1479: }
1480:
1.61 matthew 1481:
1.92 guenther 1482: /*
1483: * FORMATTERS
1484: */
1485:
1486: static void
1487: ioctldecode(int cmd)
1488: {
1489: char dirbuf[4], *dir = dirbuf;
1490: const char *cp;
1491:
1492: if ((cp = ioctlname((unsigned)cmd)) != NULL) {
1493: (void)printf("%s", cp);
1494: return;
1495: }
1496:
1497: if (cmd & IOC_IN)
1498: *dir++ = 'W';
1499: if (cmd & IOC_OUT)
1500: *dir++ = 'R';
1501: *dir = '\0';
1502:
1.109 zhuk 1503: printf("_IO%s('%c',%d",
1.92 guenther 1504: dirbuf, (int)((cmd >> 8) & 0xff), cmd & 0xff);
1505: if ((cmd & IOC_VOID) == 0)
1506: printf(decimal ? ",%u)" : ",%#x)", (cmd >> 16) & 0xff);
1507: else
1508: printf(")");
1509: }
1510:
1511: static void
1512: ptracedecode(int request)
1513: {
1514: if (request >= 0 && request < nitems(ptrace_ops))
1515: (void)printf("%s", ptrace_ops[request]);
1516: else switch(request) {
1517: #ifdef PT_GETFPREGS
1518: case PT_GETFPREGS:
1519: (void)printf("PT_GETFPREGS");
1520: break;
1521: #endif
1522: case PT_GETREGS:
1523: (void)printf("PT_GETREGS");
1524: break;
1525: #ifdef PT_GETXMMREGS
1526: case PT_GETXMMREGS:
1527: (void)printf("PT_GETXMMREGS");
1528: break;
1529: #endif
1530: #ifdef PT_SETFPREGS
1531: case PT_SETFPREGS:
1532: (void)printf("PT_SETFPREGS");
1533: break;
1534: #endif
1535: case PT_SETREGS:
1536: (void)printf("PT_SETREGS");
1537: break;
1538: #ifdef PT_SETXMMREGS
1539: case PT_SETXMMREGS:
1540: (void)printf("PT_SETXMMREGS");
1541: break;
1542: #endif
1543: #ifdef PT_STEP
1544: case PT_STEP:
1545: (void)printf("PT_STEP");
1546: break;
1547: #endif
1548: #ifdef PT_WCOOKIE
1549: case PT_WCOOKIE:
1550: (void)printf("PT_WCOOKIE");
1551: break;
1552: #endif
1553: default:
1554: pdecint(request);
1555: }
1556: }
1557:
1558:
1.61 matthew 1559: static void
1560: atfd(int fd)
1561: {
1562: if (fd == AT_FDCWD)
1563: (void)printf("AT_FDCWD");
1564: else
1.92 guenther 1565: pdecint(fd);
1.77 guenther 1566: }
1567:
1568: static void
1569: polltimeout(int timeout)
1570: {
1571: if (timeout == INFTIM)
1572: (void)printf("INFTIM");
1573: else
1.92 guenther 1574: pdecint(timeout);
1.82 guenther 1575: }
1576:
1577: static void
1578: wait4pid(int pid)
1579: {
1580: if (pid == WAIT_ANY)
1581: (void)printf("WAIT_ANY");
1582: else if (pid == WAIT_MYPGRP)
1583: (void)printf("WAIT_MYPGRP");
1584: else
1.92 guenther 1585: pdecint(pid); /* ppgid */
1.1 deraadt 1586: }
1.83 guenther 1587:
1588: static void
1589: signame(int sig)
1590: {
1591: if (sig > 0 && sig < NSIG)
1592: (void)printf("SIG%s", sys_signame[sig]);
1593: else
1594: (void)printf("SIG %d", sig);
1595: }
1596:
1.84 guenther 1597: void
1.83 guenther 1598: sigset(int ss)
1599: {
1600: int or = 0;
1601: int cnt = 0;
1602: int i;
1603:
1604: for (i = 1; i < NSIG; i++)
1605: if (sigismember(&ss, i))
1606: cnt++;
1607: if (cnt > (NSIG-1)/2) {
1608: ss = ~ss;
1609: putchar('~');
1610: }
1611:
1612: if (ss == 0) {
1613: (void)printf("0<>");
1614: return;
1615: }
1616:
1617: printf("%#x<", ss);
1618: for (i = 1; i < NSIG; i++)
1619: if (sigismember(&ss, i)) {
1620: if (or) putchar('|'); else or=1;
1621: signame(i);
1622: }
1623: printf(">");
1624: }
1625:
1626: static void
1627: semctlname(int cmd)
1628: {
1629: switch (cmd) {
1630: case GETNCNT:
1631: (void)printf("GETNCNT");
1632: break;
1633: case GETPID:
1634: (void)printf("GETPID");
1635: break;
1636: case GETVAL:
1637: (void)printf("GETVAL");
1638: break;
1639: case GETALL:
1640: (void)printf("GETALL");
1641: break;
1642: case GETZCNT:
1643: (void)printf("GETZCNT");
1644: break;
1645: case SETVAL:
1646: (void)printf("SETVAL");
1647: break;
1648: case SETALL:
1649: (void)printf("SETALL");
1650: break;
1651: case IPC_RMID:
1652: (void)printf("IPC_RMID");
1653: break;
1654: case IPC_SET:
1655: (void)printf("IPC_SET");
1656: break;
1657: case IPC_STAT:
1658: (void)printf("IPC_STAT");
1659: break;
1660: default: /* Should not reach */
1.92 guenther 1661: (void)printf("<invalid=%d>", cmd);
1.83 guenther 1662: }
1663: }
1664:
1665: static void
1.88 guenther 1666: shmctlname(int cmd)
1667: {
1.83 guenther 1668: switch (cmd) {
1669: case IPC_RMID:
1670: (void)printf("IPC_RMID");
1671: break;
1672: case IPC_SET:
1673: (void)printf("IPC_SET");
1674: break;
1675: case IPC_STAT:
1676: (void)printf("IPC_STAT");
1677: break;
1678: default: /* Should not reach */
1.92 guenther 1679: (void)printf("<invalid=%d>", cmd);
1.83 guenther 1680: }
1681: }
1682:
1683:
1684: static void
1.88 guenther 1685: semgetname(int flag)
1686: {
1.83 guenther 1687: int or = 0;
1688: if_print_or(flag, IPC_CREAT, or);
1689: if_print_or(flag, IPC_EXCL, or);
1690: if_print_or(flag, SEM_R, or);
1691: if_print_or(flag, SEM_A, or);
1692: if_print_or(flag, (SEM_R>>3), or);
1693: if_print_or(flag, (SEM_A>>3), or);
1694: if_print_or(flag, (SEM_R>>6), or);
1695: if_print_or(flag, (SEM_A>>6), or);
1.92 guenther 1696:
1697: if (flag & ~(IPC_CREAT|IPC_EXCL|SEM_R|SEM_A|((SEM_R|SEM_A)>>3)|
1698: ((SEM_R|SEM_A)>>6)))
1699: printf("<invalid=%#x>", flag);
1.83 guenther 1700: }
1701:
1702:
1703: /*
1.92 guenther 1704: * Only used by SYS_open and SYS_openat. Unless O_CREAT is set in flags, the
1.83 guenther 1705: * mode argument is unused (and often bogus and misleading).
1706: */
1707: static void
1.92 guenther 1708: flagsandmodename(int mode)
1.88 guenther 1709: {
1.92 guenther 1710: openflagsname(arg1);
1711: if ((arg1 & O_CREAT) == O_CREAT) {
1.83 guenther 1712: (void)putchar(',');
1.92 guenther 1713: modename(mode);
1714: } else if (!fancy)
1715: (void)printf(",<unused>%#o", mode);
1.83 guenther 1716: }
1717:
1718: static void
1719: clockname(int clockid)
1720: {
1721: clocktypename(__CLOCK_TYPE(clockid));
1722: if (__CLOCK_PTID(clockid) != 0)
1723: printf("(%d)", __CLOCK_PTID(clockid));
1724: }
1725:
1726: /*
1727: * [g|s]etsockopt's level argument can either be SOL_SOCKET or a value
1.100 guenther 1728: * referring to a line in /etc/protocols.
1.83 guenther 1729: */
1730: static void
1.100 guenther 1731: sockoptlevelname(int optname)
1.83 guenther 1732: {
1.100 guenther 1733: struct protoent *pe;
1734:
1735: if (arg1 == SOL_SOCKET) {
1736: (void)printf("SOL_SOCKET,");
1737: sockoptname(optname);
1738: } else {
1739: pe = getprotobynumber(arg1);
1740: (void)printf("%u<%s>,%d", arg1,
1741: pe != NULL ? pe->p_name : "unknown", optname);
1742: }
1.83 guenther 1743: }
1744:
1.88 guenther 1745: static void
1746: ktraceopname(int ops)
1747: {
1748: int invalid = 0;
1749:
1750: printf("%#x<", ops);
1751: switch (KTROP(ops)) {
1752: case KTROP_SET:
1753: printf("KTROP_SET");
1754: break;
1755: case KTROP_CLEAR:
1756: printf("KTROP_CLEAR");
1757: break;
1758: case KTROP_CLEARFILE:
1759: printf("KTROP_CLEARFILE");
1760: break;
1761: default:
1762: printf("KTROP(%d)", KTROP(ops));
1763: invalid = 1;
1764: break;
1765: }
1.92 guenther 1766: if (ops & KTRFLAG_DESCEND) printf("|KTRFLAG_DESCEND");
1.88 guenther 1767: printf(">");
1768: if (invalid || (ops & ~(KTROP((unsigned)-1) | KTRFLAG_DESCEND)))
1.92 guenther 1769: (void)printf("<invalid>%d", ops);
1.151 guenther 1770: }
1771:
1772: static void
1773: idtypeandid(int id)
1774: {
1775: switch (arg1) {
1776: case P_PID:
1777: printf("P_PID,%d", id);
1778: break;
1779: case P_PGID:
1780: printf("P_PGID,%d", id);
1781: break;
1782: case P_ALL:
1783: printf("P_ALL,<unused>%d", id);
1784: break;
1785: default: /* Should not reach */
1786: printf("<invalid=%d>, <unused>%d", arg1, id);
1787: }
1.88 guenther 1788: }