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