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