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