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