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