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