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