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