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