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