/usr/src/usr.bin/kdump/kdump.c

Bug Summary

File:	src/usr.bin/kdump/kdump.c
Warning:	line 1424, column 2 1st function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name kdump.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/kdump/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/usr.bin/kdump/../ktrace -I /usr/src/usr.bin/kdump -I /usr/src/usr.bin/kdump/../../sys -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/kdump/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.bin/kdump/kdump.c
1/*	$OpenBSD: kdump.c,v 1.161 2023/12/15 15:12:08 deraadt Exp $	*/

3/*-
* Copyright (c) 1988, 1993
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

32#include <sys/time.h>
33#include <sys/signal.h>
34#include <sys/uio.h>
35#include <sys/ktrace.h>
36#include <sys/ioctl.h>
37#include <sys/malloc.h>
38#include <sys/namei.h>
39#include <sys/ptrace.h>
40#include <sys/sem.h>
41#include <sys/shm.h>
42#include <sys/socket.h>
43#include <sys/sysctl.h>
44#include <sys/siginfo.h>
45#include <sys/vmmeter.h>
46#include <sys/tty.h>
47#include <sys/wait.h>
48#define PLEDGENAMES
49#include <sys/pledge.h>
50#undef PLEDGENAMES
51#define _KERNEL
52#include <errno(*__errno()).h>
53#undef _KERNEL
54#include <ddb/db_var.h>
55#include <machine/cpu.h>

57#include <ctype.h>
58#include <err.h>
59#include <fcntl.h>
60#include <limits.h>
61#include <netdb.h>
62#include <poll.h>
63#include <signal.h>
64#include <stddef.h>
65#include <stdint.h>
66#include <stdio.h>
67#include <stdlib.h>
68#include <string.h>
69#include <unistd.h>
70#include <vis.h>

72#include "ktrace.h"
73#include "kdump.h"
74#include "kdump_subr.h"
75#include "extern.h"

77#define nitems(_a)(sizeof((_a)) / sizeof((_a)[0]))	(sizeof((_a)) / sizeof((_a)[0]))

79enum {
TIMESTAMP_NONE,
TIMESTAMP_ABSOLUTE,
TIMESTAMP_RELATIVE,
TIMESTAMP_ELAPSED
84} timestamp = TIMESTAMP_NONE;

86int decimal, iohex, fancy = 1, maxdata = INT_MAX0x7fffffff;
87int needtid, tail, basecol;
88char *tracefile = DEF_TRACEFILE"ktrace.out";
89struct ktr_header ktr_header;
90pid_t pid_opt = -1;
91const char *program;
92char* utracefilter;

94#define eqs(s1, s2)(strcmp((s1), (s2)) == 0)	(strcmp((s1), (s2)) == 0)

96#include <sys/syscall.h>

98#define KTRACE
99#define PTRACE
100#define NFSCLIENT
101#define NFSSERVER
102#define SYSVSEM
103#define SYSVMSG
104#define SYSVSHM
105#define ACCOUNTING
106#include <kern/syscalls.c>
107#undef KTRACE
108#undef PTRACE
109#undef NFSCLIENT
110#undef NFSSERVER
111#undef SYSVSEM
112#undef SYSVMSG
113#undef SYSVSHM
114#undef ACCOUNTING


117static char *ptrace_ops[] = {
"PT_TRACE_ME",	"PT_READ_I",	"PT_READ_D",	"PT_READ_U",
"PT_WRITE_I",	"PT_WRITE_D",	"PT_WRITE_U",	"PT_CONTINUE",
"PT_KILL",	"PT_ATTACH",	"PT_DETACH",	"PT_IO",
"PT_SET_EVENT_MASK", "PT_GET_EVENT_MASK", "PT_GET_PROCESS_STATE",
"PT_GET_THREAD_FIRST", "PT_GET_THREAD_NEXT",
123};

125static int fread_tail(void *, size_t, size_t);
126static void dumpheader(struct ktr_header *);
127static void ktrgenio(struct ktr_genio *, size_t);
128static void ktrnamei(const char *, size_t);
129static void ktrpsig(struct ktr_psig *);
130static void ktrsyscall(struct ktr_syscall *, size_t);
131static const char *kresolvsysctl(int, const int *);
132static void ktrsysret(struct ktr_sysret *, size_t);
133static void ktruser(struct ktr_user *, size_t);
134static void ktrexec(const char*, size_t);
135static void ktrpledge(struct ktr_pledge *, size_t);
136static void ktrpinsyscall(struct ktr_pinsyscall *, size_t);
137static void usage(void);
138static void ioctldecode(int);
139static void ptracedecode(int);
140static void atfd(int);
141static void polltimeout(int);
142static void wait4pid(int);
143static void signame(int);
144static void semctlname(int);
145static void shmctlname(int);
146static void semgetname(int);
147static void flagsandmodename(int);
148static void clockname(int);
149static void sockoptlevelname(int);
150static void ktraceopname(int);
151static void idtypeandid(int);

153static int screenwidth;

155int
156main(int argc, char *argv[])
157{
int ch, silent;
size_t ktrlen, size;
int trpoints = ALL_POINTS(((1<<1) | (1<<2) | (1<<3) | (1<<4) |
 (1<<5) | (1<<8) | (1<<9) | (1<<10) |
 (1<<12) | (1<<13)) | (1<<11));
const char *errstr;
void *m;

if (screenwidth == 0) {
1
Assuming 'screenwidth' is not equal to 0→
2
←
Taking false branch→
struct winsize ws;

if (fancy && ioctl(fileno(stderr)(!__isthreaded ? (((&__sF[2]))->_file) : (fileno)((&
__sF[2]))), TIOCGWINSZ((unsigned long)0x40000000 | ((sizeof(struct winsize) & 0x1fff
) << 16) | ((('t')) << 8) | ((104))), &ws) != -1 &&
    ws.ws_col > 8)
	screenwidth = ws.ws_col;
else
	screenwidth = 80;
}

while ((ch = getopt(argc, argv, "f:dHlm:nP:p:RTt:u:xX")) != -1)
3
←
Assuming the condition is false→
4
←
Loop condition is false. Execution continues on line 235→
switch (ch) {
case 'f':
	tracefile = optarg;
	break;
case 'd':
	decimal = 1;
	break;
case 'H':
	needtid = 1;
	break;
case 'l':
	tail = 1;
	break;
case 'm':
	maxdata = strtonum(optarg, 0, INT_MAX0x7fffffff, &errstr);
	if (errstr)
		errx(1, "-m %s: %s", optarg, errstr);
	break;
case 'n':
	fancy = 0;
	break;
case 'P':
	program = optarg;
	break;
case 'p':
	pid_opt = strtonum(optarg, 1, INT_MAX0x7fffffff, &errstr);
	if (errstr)
		errx(1, "-p %s: %s", optarg, errstr);
	break;
case 'R':	/* relative timestamp */
	if (timestamp == TIMESTAMP_ABSOLUTE)
		timestamp = TIMESTAMP_ELAPSED;
	else
		timestamp = TIMESTAMP_RELATIVE;
	break;
case 'T':
	if (timestamp == TIMESTAMP_RELATIVE)
		timestamp = TIMESTAMP_ELAPSED;
	else
		timestamp = TIMESTAMP_ABSOLUTE;
	break;
case 't':
	trpoints = getpoints(optarg, DEF_POINTS((1<<1) | (1<<2) | (1<<3) | (1<<4) | (
1<<5) | (1<<8) | (1<<9) | (1<<10) | (
1<<12) | (1<<13)));
	if (trpoints < 0)
		errx(1, "unknown trace point in %s", optarg);
	utracefilter = NULL((void *)0);
	break;
case 'u':
	utracefilter = optarg;
	trpoints = KTRFAC_USER(1<<9);
	break;
case 'x':
	iohex = 1;
	break;
case 'X':
	iohex = 2;
	break;
default:
	usage();
}
if (argc > optind)
5
←
Assuming 'argc' is <= 'optind'→
6
←
Taking false branch→
usage();

if (strcmp(tracefile, "-") != 0)
7
←
Taking true branch→
if (unveil(tracefile, "r") == -1)
8
←
Assuming the condition is false→
9
←
Taking false branch→
	err(1, "unveil %s", tracefile);
if (unveil(_PATH_PROTOCOLS"/etc/protocols", "r") == -1)
10
←
Assuming the condition is false→
11
←
Taking false branch→
err(1, "unveil %s", _PATH_PROTOCOLS"/etc/protocols");
if (pledge("stdio rpath getpw", NULL((void *)0)) == -1)
12
←
Assuming the condition is false→
13
←
Taking false branch→
err(1, "pledge");

m = malloc(size = 1025);
14
←
Uninitialized value stored to field 'signo'→
if (m == NULL((void *)0))
15
←
Assuming 'm' is not equal to NULL→
16
←
Taking false branch→
err(1, NULL((void *)0));
if (strcmp(tracefile, "-") != 0)
if (!freopen(tracefile, "r", stdin(&__sF[0])))
	err(1, "%s", tracefile);

if (fread_tail(&ktr_header, sizeof(struct ktr_header), 1) == 0 ||
19
←
Taking false branch→
   ktr_header.ktr_type != htobe32(KTR_START)(__uint32_t)(__builtin_constant_p(0x4b545200) ? (__uint32_t)(
((__uint32_t)(0x4b545200) & 0xff) << 24 | ((__uint32_t
)(0x4b545200) & 0xff00) << 8 | ((__uint32_t)(0x4b545200
) & 0xff0000) >> 8 | ((__uint32_t)(0x4b545200) &
 0xff000000) >> 24) : __swap32md(0x4b545200)))
17
←
'?' condition is true→
18
←
Assuming the condition is false→
errx(1, "%s: not a dump", tracefile);
while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) {
20
←
Loop condition is true.  Entering loop body→
silent = 0;
if (pid_opt != -1 && pid_opt != ktr_header.ktr_pid)
21
←
Assuming the condition is false→
	silent = 1;
if (program != NULL((void *)0) &&
22
←
Assuming 'program' is equal to NULL→
    strcmp(ktr_header.ktr_comm, program) != 0)
	silent = 1;
if (utracefilter == NULL((void *)0) && silent == 0 &&
23
←
Assuming 'utracefilter' is not equal to NULL→
    trpoints & (1<<ktr_header.ktr_type))
	dumpheader(&ktr_header);
ktrlen = ktr_header.ktr_len;
if (ktrlen > size) {
24
←
Assuming 'ktrlen' is <= 'size'→
	void *newm;

	if (ktrlen == SIZE_MAX0xffffffffffffffffUL)
		errx(1, "data too long");
	newm = realloc(m, ktrlen+1);
	if (newm == NULL((void *)0))
		err(1, "realloc");
	m = newm;
	size = ktrlen;
}
if (ktrlen && fread_tail(m, ktrlen, 1) == 0)
25
←
Assuming 'ktrlen' is 0→
	errx(1, "data too short");
if (silent25.1
'silent' is 0
)
26
←
Taking false branch→
	continue;
if ((trpoints & (1<<ktr_header.ktr_type)) == 0)
27
←
Assuming the condition is false→
28
←
Taking false branch→
	continue;
switch (ktr_header.ktr_type) {
29
←
Control jumps to 'case 5:'  at line 297→
case KTR_SYSCALL1:
	ktrsyscall(m, ktrlen);
	break;
case KTR_SYSRET2:
	ktrsysret(m, ktrlen);
	break;
case KTR_NAMEI3:
	ktrnamei(m, ktrlen);
	break;
case KTR_GENIO4:
	ktrgenio(m, ktrlen);
	break;
case KTR_PSIG5:
	ktrpsig(m);
30
←
Calling 'ktrpsig'→
	break;
case KTR_STRUCT8:
	ktrstruct(m, ktrlen);
	break;
case KTR_USER9:
	ktruser(m, ktrlen);
	break;
case KTR_EXECARGS10:
case KTR_EXECENV11:
	ktrexec(m, ktrlen);
	break;
case KTR_PLEDGE12:
	ktrpledge(m, ktrlen);
	break;
case KTR_PINSYSCALL13:
	ktrpinsyscall(m, ktrlen);
	break;
default:
	printf("\n");
	break;
}
if (tail)
	(void)fflush(stdout(&__sF[1]));
}
exit(0);
324}

326static int
327fread_tail(void *buf, size_t size, size_t num)
328{
int i;

while ((i = fread(buf, size, num, stdin(&__sF[0]))) == 0 && tail) {
(void)sleep(1);
clearerr(stdin)(!__isthreaded ? ((void)(((&__sF[0]))->_flags &= ~
(0x0040|0x0020))) : (clearerr)((&__sF[0])));
}
return (i);
336}

338static void
339dumpheader(struct ktr_header *kth)
340{
static struct timespec prevtime;
char unknown[64], *type;
struct timespec temp;

switch (kth->ktr_type) {
case KTR_SYSCALL1:
type = "CALL";
break;
case KTR_SYSRET2:
type = "RET ";
break;
case KTR_NAMEI3:
type = "NAMI";
break;
case KTR_GENIO4:
type = "GIO ";
break;
case KTR_PSIG5:
type = "PSIG";
break;
case KTR_STRUCT8:
type = "STRU";
break;
case KTR_USER9:
type = "USER";
break;
case KTR_EXECARGS10:
type = "ARGS";
break;
case KTR_EXECENV11:
type = "ENV ";
break;
case KTR_PLEDGE12:
type = "PLDG";
break;
case KTR_PINSYSCALL13:
type = "PINS";
break;
default:
/* htobe32() not guaranteed to work as case label */
if (kth->ktr_type == htobe32(KTR_START)(__uint32_t)(__builtin_constant_p(0x4b545200) ? (__uint32_t)(
((__uint32_t)(0x4b545200) & 0xff) << 24 | ((__uint32_t
)(0x4b545200) & 0xff00) << 8 | ((__uint32_t)(0x4b545200
) & 0xff0000) >> 8 | ((__uint32_t)(0x4b545200) &
 0xff000000) >> 24) : __swap32md(0x4b545200))) {
	type = "STRT";
	break;
}
(void)snprintf(unknown, sizeof unknown, "UNKNOWN(%u)",
    kth->ktr_type);
type = unknown;
}

basecol = printf("%6ld", (long)kth->ktr_pid);
if (needtid)
basecol += printf("/%-7ld", (long)kth->ktr_tid);
basecol += printf(" %-8s ", kth->ktr_comm);
if (timestamp != TIMESTAMP_NONE) {
if (timestamp == TIMESTAMP_ELAPSED) {
	if (prevtime.tv_sec == 0)
		prevtime = kth->ktr_time;
	timespecsub(&kth->ktr_time, &prevtime, &temp)do { (&temp)->tv_sec = (&kth->ktr_time)->tv_sec
 - (&prevtime)->tv_sec; (&temp)->tv_nsec = (&
kth->ktr_time)->tv_nsec - (&prevtime)->tv_nsec; if
 ((&temp)->tv_nsec < 0) { (&temp)->tv_sec--;
 (&temp)->tv_nsec += 1000000000L; } } while (0);
} else if (timestamp == TIMESTAMP_RELATIVE) {
	timespecsub(&kth->ktr_time, &prevtime, &temp)do { (&temp)->tv_sec = (&kth->ktr_time)->tv_sec
 - (&prevtime)->tv_sec; (&temp)->tv_nsec = (&
kth->ktr_time)->tv_nsec - (&prevtime)->tv_nsec; if
 ((&temp)->tv_nsec < 0) { (&temp)->tv_sec--;
 (&temp)->tv_nsec += 1000000000L; } } while (0);
	prevtime = kth->ktr_time;
} else
	temp = kth->ktr_time;
basecol += printf("%lld.%06ld ", (long long)temp.tv_sec,
    temp.tv_nsec / 1000);
}
basecol += printf("%s  ", type);
408}

410/*
* Base Formatters
*/

414/* some syscalls have padding that shouldn't be shown */
415static int
416pad(long arg)
417{
/* nothing printed */
return (1);
420}

422/* a formatter that just saves the argument for the next formatter */
423int arg1;
424static int
425pass_two(long arg)
426{
arg1 = (int)arg;

/* nothing printed */
return (1);
431}

433static int
434pdeclong(long arg)
435{
(void)printf("%ld", arg);
return (0);
438}

440static int
441pdeculong(long arg)
442{
(void)printf("%lu", arg);
return (0);
445}

447static int
448phexlong(long arg)
449{
(void)printf("%#lx", arg);
return (0);
452}

454static int
455pnonfancy(long arg)
456{
if (decimal)
(void)printf("%ld", arg);
else
(void)printf("%#lx", arg);
return (0);
462}

464static void
465pdecint(int arg)
466{
(void)printf("%d", arg);
468}

470static void
471pdecuint(int arg)
472{
(void)printf("%u", arg);
474}

476static void
477phexint(int arg)
478{
(void)printf("%#x", arg);
480}

482static void
483poctint(int arg)
484{
(void)printf("%#o", arg);
486}


489#ifdef __LP64__1

491/* on LP64, long long arguments are the same as long arguments */
492#define PhexlonglongPhexlong	Phexlong
493#define phexll((void *)0)		NULL((void *)0)		/* not actually used on LP64 */

495/* no padding before long long arguments, nor at end */
496#define PAD640		0
497#define END64end_of_args		end_of_args

499#else /* __LP64__ */

501/* on ILP32, long long arguments are passed as two 32bit args */
502#define PhexlonglongPhexlong	PASS_LONGLONG, Phexll

504static int
505phexll((void *)0)(long arg2)
506{
long long val;

509#if _BYTE_ORDER1234 == _LITTLE_ENDIAN1234
val = ((long long)arg2 << 32) | ((long long)arg1 & 0xffffffff);
511#else
val = ((long long)arg1 << 32) | ((long long)arg2 & 0xffffffff);
513#endif

if (fancy || !decimal)
(void)printf("%#llx", val);
else
(void)printf("%lld", val);
return (0);
520}

522/*
* Some ILP32 archs naturally align off_t arguments to 8byte boundaries
* Get the compiler to tell if this arch is one of them.
*/
526struct padding_test {
int padtest_one;
off_t padtest_two;
529};
530#define PAD640	(offsetof(struct padding_test,padtest_two)__builtin_offsetof(struct padding_test, padtest_two) == 8)
531#define END64end_of_args	(PAD640 ? PASS_LONGLONG : end_of_args)

533#endif /* __LP64__ */

535static int (*long_formatters[])(long) = {
NULL((void *)0),
pdeclong,
pdeculong,
phexlong,
pass_two,
pass_two,
phexll((void *)0),
pad,
pnonfancy,
545};

547static void (*formatters[])(int) = {
NULL((void *)0),
pdecint,
phexint,
poctint,
pdecuint,
ioctldecode,
ptracedecode,
atfd,
polltimeout,
wait4pid,
signame,
semctlname,
shmctlname,
semgetname,
flagsandmodename,
clockname,
sockoptlevelname,
ktraceopname,
fcntlcmdname,
modename,
flagsname,
openflagsname,
atflagsname,
accessmodename,
mmapprotname,
mmapflagsname,
wait4optname,
sendrecvflagsname,
mountflagsname,
rebootoptname,
flockname,
sockoptname,
sockipprotoname,
socktypename,
sockflagsname,
sockfamilyname,
mlockallname,
shmatname,
whencename,
pathconfname,
rlimitname,
shutdownhowname,
prioname,
madvisebehavname,
msyncflagsname,
clocktypename,
rusagewho,
sigactionflagname,
sigprocmaskhowname,
minheritname,
quotactlname,
sigill_name,
sigtrap_name,
sigemt_name,
sigfpe_name,
sigbus_name,
sigsegv_name,
sigchld_name,
ktracefacname,
itimername,
sigset,
uidname,
gidname,
syslogflagname,
futexflagname,
waitidoptname,
idtypeandid,
615};

617enum {
/* the end of the (known) arguments is recognized by the zero fill */
end_of_args	=  0,

/* negative are the negative of the index into long_formatters[] */
Pdeclong	= -1,
Pdeculong	= -2,
Phexlong	= -3,
PASS_TWO	= -4,

627/* the remaining long formatters still get called when non-fancy (-n option) */
628#define FMT_IS_NONFANCY(x)((x) <= PASS_LONGLONG)	((x) <= PASS_LONGLONG)
PASS_LONGLONG	= -5,
Phexll		= -6,
PAD		= -7,
Pnonfancy	= -8,

/* positive values are the index into formatters[] */
Pdecint		= 1,
Phexint,
Poctint,
Pdecuint,
Ioctldecode,
Ptracedecode,
Atfd,
Polltimeout,
Wait4pid,
Signame,
Semctlname,
Shmctlname,
Semgetname,
Flagsandmodename,
Clockname,
Sockoptlevelname,
Ktraceopname,
Fcntlcmdname,
Modename,
Flagsname,
Openflagsname,
Atflagsname,
Accessmodename,
Mmapprotname,
Mmapflagsname,
Wait4optname,
Sendrecvflagsname,
Mountflagsname,
Rebootoptname,
Flockname,
Sockoptname,
Sockipprotoname,
Socktypename,
Sockflagsname,
Sockfamilyname,
Mlockallname,
Shmatname,
Whencename,
Pathconfname,
Rlimitname,
Shutdownhowname,
Prioname,
Madvisebehavname,
Msyncflagsname,
Clocktypename,
Rusagewho,
Sigactionflagname,
Sigprocmaskhowname,
Minheritname,
Quotactlname,
Sigill_name,
Sigtrap_name,
Sigemt_name,
Sigfpe_name,
Sigbus_name,
Sigsegv_name,
Sigchld_name,
Ktracefacname,
Itimername,
Sigset,
Uidname,
Gidname,
Syslogflagname,
Futexflagname,
Waitidoptname,
Idtypeandid,
701};

703#define PptrPhexlong		Phexlong
704#define	PsizePdeculong		Pdeculong	/* size_t for small buffers */
705#define	PbigsizePhexlong	Phexlong	/* size_t for I/O buffers */
706#define PcountPdecint		Pdecint		/* int for a count of something */
707#define PfdPdecint		Pdecint
708#define PpathPhexlong		Phexlong
709#define Pdev_tPdecint		Pdecint
710#define Ppid_tPdecint		Pdecint
711#define PpgidPdecint		Pdecint		/* pid or negative pgid */
712#define Poff_tPhexlong		PhexlonglongPhexlong
713#define PmsqidPdecint		Pdecint
714#define PshmidPdecint		Pdecint
715#define PsemidPdecint		Pdecint
716#define Pkey_tPdecint		Pdecint
717#define PucountPdecuint		Pdecuint
718#define ChflagsnamePhexlong	Phexlong	/* to be added */
719#define SockprotonamePhexlong	Phexlong	/* to be added */
720#define SwapctlnamePhexlong	Phexlong	/* to be added */
721#define MsgflgnamePhexlong	Phexlong	/* to be added */


724/* includes relevant entries as of syscalls.master rev 1.238 */
725typedef signed char formatter;
726static const formatter scargs[][8] = {
  [SYS_exit1]		= { Pdecint },
  [SYS_read3]		= { PfdPdecint, PptrPhexlong, PbigsizePhexlong },
  [SYS_write4]		= { PfdPdecint, PptrPhexlong, PbigsizePhexlong },
  [SYS_open5]		= { PpathPhexlong, PASS_TWO, Flagsandmodename },
  [SYS_close6]		= { PfdPdecint },
  [SYS_getentropy7]	= { PptrPhexlong, PsizePdeculong },
  [SYS___tfork8]	= { PptrPhexlong, PsizePdeculong },
  [SYS_link9]		= { PpathPhexlong, PpathPhexlong },
  [SYS_unlink10]	= { PpathPhexlong },
  [SYS_wait411]		= { Wait4pid, PptrPhexlong, Wait4optname },
  [SYS_chdir12]		= { PpathPhexlong },
  [SYS_fchdir13]	= { PfdPdecint },
  [SYS_mknod14]		= { PpathPhexlong, Modename, Pdev_tPdecint },
  [SYS_chmod15]		= { PpathPhexlong, Modename },
  [SYS_chown16]		= { PpathPhexlong, Uidname, Gidname },
  [SYS_break17]		= { PptrPhexlong },
  [SYS_getrusage19]	= { Rusagewho, PptrPhexlong },
  [SYS_mount21]		= { PptrPhexlong, PpathPhexlong, Mountflagsname, PptrPhexlong },
  [SYS_unmount22]	= { PpathPhexlong, Mountflagsname },
  [SYS_setuid23]	= { Uidname },
  [SYS_ptrace26]	= { Ptracedecode, Ppid_tPdecint, PptrPhexlong, Pdecint },
  [SYS_recvmsg27]	= { PfdPdecint, PptrPhexlong, Sendrecvflagsname },
  [SYS_sendmsg28]	= { PfdPdecint, PptrPhexlong, Sendrecvflagsname },
  [SYS_recvfrom29]	= { PfdPdecint, PptrPhexlong, PbigsizePhexlong, Sendrecvflagsname },
  [SYS_accept30]	= { PfdPdecint, PptrPhexlong, PptrPhexlong },
  [SYS_getpeername31]	= { PfdPdecint, PptrPhexlong, PptrPhexlong },
  [SYS_getsockname32]	= { PfdPdecint, PptrPhexlong, PptrPhexlong },
  [SYS_access33]	= { PpathPhexlong, Accessmodename },
  [SYS_chflags34]	= { PpathPhexlong, ChflagsnamePhexlong },
  [SYS_fchflags35]	= { PfdPdecint, ChflagsnamePhexlong },
  [SYS_msyscall37]	= { PptrPhexlong, PbigsizePhexlong },
  [SYS_stat38]		= { PpathPhexlong, PptrPhexlong },
  [SYS_lstat40]		= { PpathPhexlong, PptrPhexlong },
  [SYS_dup41]		= { PfdPdecint },
  [SYS_fstatat42]	= { Atfd, PpathPhexlong, PptrPhexlong, Atflagsname },
  [SYS_profil44]	= { PptrPhexlong, PbigsizePhexlong, PbigsizePhexlong, Pdecuint },
  [SYS_ktrace45]	= { PpathPhexlong, Ktraceopname, Ktracefacname, PpgidPdecint },
  [SYS_sigaction46]	= { Signame, PptrPhexlong, PptrPhexlong },
  [SYS_sigprocmask48]	= { Sigprocmaskhowname, Sigset },
  [SYS_mmap49]		= { PptrPhexlong, PbigsizePhexlong, Mmapprotname, Mmapflagsname, PfdPdecint, Poff_tPhexlong, END64end_of_args },
  [SYS_setlogin50]	= { PptrPhexlong },
  [SYS_acct51]		= { PpathPhexlong },
  [SYS_fstat53]		= { PfdPdecint, PptrPhexlong },
  [SYS_ioctl54]		= { PfdPdecint, Ioctldecode, PptrPhexlong },
  [SYS_reboot55]	= { Rebootoptname },
  [SYS_revoke56]	= { PpathPhexlong },
  [SYS_symlink57]	= { PpathPhexlong, PpathPhexlong },
  [SYS_readlink58]	= { PpathPhexlong, PptrPhexlong, PsizePdeculong },
  [SYS_execve59]	= { PpathPhexlong, PptrPhexlong, PptrPhexlong },
  [SYS_umask60]		= { Modename },
  [SYS_chroot61]	= { PpathPhexlong },
  [SYS_getfsstat62]	= { PptrPhexlong, PbigsizePhexlong, Mountflagsname },
  [SYS_statfs63]	= { PpathPhexlong, PptrPhexlong },
  [SYS_fstatfs64]	= { PfdPdecint, PptrPhexlong },
  [SYS_fhstatfs65]	= { PptrPhexlong, PptrPhexlong },
  [SYS_gettimeofday67]	= { PptrPhexlong, PptrPhexlong },
  [SYS_settimeofday68]	= { PptrPhexlong, PptrPhexlong },
  [SYS_setitimer69]	= { Itimername, PptrPhexlong, PptrPhexlong },
  [SYS_getitimer70]	= { Itimername, PptrPhexlong },
  [SYS_select71]	= { PcountPdecint, PptrPhexlong, PptrPhexlong, PptrPhexlong, PptrPhexlong },
  [SYS_kevent72]	= { PfdPdecint, PptrPhexlong, PcountPdecint, PptrPhexlong, PcountPdecint, PptrPhexlong },
  [SYS_munmap73]	= { PptrPhexlong, PbigsizePhexlong },
  [SYS_mprotect74]	= { PptrPhexlong, PbigsizePhexlong, Mmapprotname },
  [SYS_madvise75]	= { PptrPhexlong, PbigsizePhexlong, Madvisebehavname },
  [SYS_utimes76]	= { PpathPhexlong, PptrPhexlong },
  [SYS_futimes77]	= { PfdPdecint, PptrPhexlong },
  [SYS_mquery78]	= { PptrPhexlong, PbigsizePhexlong, Mmapprotname, Mmapflagsname, PfdPdecint, Poff_tPhexlong, END64end_of_args },
  [SYS_getgroups79]	= { PcountPdecint, PptrPhexlong },
  [SYS_setgroups80]	= { PcountPdecint, PptrPhexlong },
  [SYS_setpgid82]	= { Ppid_tPdecint, Ppid_tPdecint },
  [SYS_futex83]		= { PptrPhexlong, Futexflagname, PcountPdecint, PptrPhexlong, PptrPhexlong },
  [SYS_utimensat84]	= { Atfd, PpathPhexlong, PptrPhexlong, Atflagsname },
  [SYS_futimens85]	= { PfdPdecint, PptrPhexlong },
  [SYS_kbind86]		= { PptrPhexlong, PsizePdeculong, PhexlonglongPhexlong },
  [SYS_clock_gettime87]	= { Clockname, PptrPhexlong },
  [SYS_clock_settime88]	= { Clockname, PptrPhexlong },
  [SYS_clock_getres89]	= { Clockname, PptrPhexlong },
  [SYS_dup290]		= { PfdPdecint, PfdPdecint },
  [SYS_nanosleep91]	= { PptrPhexlong, PptrPhexlong },
  [SYS_fcntl92]		= { PfdPdecint, PASS_TWO, Fcntlcmdname },
  [SYS_accept493]	= { PfdPdecint, PptrPhexlong, PptrPhexlong, Sockflagsname },
  [SYS___thrsleep94]	= { PptrPhexlong, Clockname, PptrPhexlong, PptrPhexlong, PptrPhexlong },
  [SYS_fsync95]		= { PfdPdecint },
  [SYS_setpriority96]	= { Prioname, Ppid_tPdecint, Pdecint },
  [SYS_socket97]	= { Sockfamilyname, Socktypename, SockprotonamePhexlong },
  [SYS_connect98]	= { PfdPdecint, PptrPhexlong, PucountPdecuint },
  [SYS_getdents99]	= { PfdPdecint, PptrPhexlong, PbigsizePhexlong },
  [SYS_getpriority100]	= { Prioname, Ppid_tPdecint },
  [SYS_pipe2101]		= { PptrPhexlong, Flagsname },
  [SYS_dup3102]		= { PfdPdecint, PfdPdecint, Flagsname },
  [SYS_sigreturn103]	= { PptrPhexlong },
  [SYS_bind104]		= { PfdPdecint, PptrPhexlong, PucountPdecuint },
  [SYS_setsockopt105]	= { PfdPdecint, PASS_TWO, Sockoptlevelname, PptrPhexlong, Pdecint },
  [SYS_listen106]	= { PfdPdecint, Pdecint },
  [SYS_chflagsat107]	= { Atfd, PpathPhexlong, ChflagsnamePhexlong, Atflagsname },
  [SYS_pledge108]	= { PptrPhexlong, PptrPhexlong },
  [SYS_ppoll109]		= { PptrPhexlong, PucountPdecuint, PptrPhexlong, PptrPhexlong },
  [SYS_pselect110]	= { PcountPdecint, PptrPhexlong, PptrPhexlong, PptrPhexlong, PptrPhexlong, PptrPhexlong },
  [SYS_sigsuspend111]	= { Sigset },
  [SYS_sendsyslog112]	= { PptrPhexlong, PsizePdeculong, Syslogflagname },
  [SYS_unveil114]	= { PpathPhexlong, PptrPhexlong },
  [SYS___realpath115]	= { PpathPhexlong, PptrPhexlong },
  [SYS_recvmmsg116]	= { PfdPdecint, PptrPhexlong, PucountPdecuint, Sendrecvflagsname, PptrPhexlong },
  [SYS_sendmmsg117]	= { PfdPdecint, PptrPhexlong, PucountPdecuint, Sendrecvflagsname },
  [SYS_getsockopt118]	= { PfdPdecint, PASS_TWO, Sockoptlevelname, PptrPhexlong, PptrPhexlong },
  [SYS_thrkill119]	= { Ppid_tPdecint, Signame, PptrPhexlong },
  [SYS_readv120]		= { PfdPdecint, PptrPhexlong, PcountPdecint },
  [SYS_writev121]	= { PfdPdecint, PptrPhexlong, PcountPdecint },
  [SYS_kill122]		= { PpgidPdecint, Signame },
  [SYS_fchown123]	= { PfdPdecint, Uidname, Gidname },
  [SYS_fchmod124]	= { PfdPdecint, Modename },
  [SYS_setreuid126]	= { Uidname, Uidname },
  [SYS_setregid127]	= { Gidname, Gidname },
  [SYS_rename128]	= { PpathPhexlong, PpathPhexlong },
  [SYS_flock131]		= { PfdPdecint, Flockname },
  [SYS_mkfifo132]	= { PpathPhexlong, Modename },
  [SYS_sendto133]	= { PfdPdecint, PptrPhexlong, PbigsizePhexlong, Sendrecvflagsname },
  [SYS_shutdown134]	= { PfdPdecint, Shutdownhowname },
  [SYS_socketpair135]	= { Sockfamilyname, Socktypename, SockprotonamePhexlong, PptrPhexlong },
  [SYS_mkdir136]		= { PpathPhexlong, Modename },
  [SYS_rmdir137]		= { PpathPhexlong },
  [SYS_adjtime140]	= { PptrPhexlong, PptrPhexlong },
  [SYS_getlogin_r141]	= { PptrPhexlong, PsizePdeculong },
  [SYS_getthrname142]	= { Ppid_tPdecint, PptrPhexlong, PsizePdeculong },
  [SYS_setthrname143]	= { Ppid_tPdecint, PptrPhexlong },
  [SYS_quotactl148]	= { PpathPhexlong, Quotactlname, Uidname, PptrPhexlong },
  [SYS_ypconnect150]	= { Socktypename },
  [SYS_nfssvc155]	= { Phexint, PptrPhexlong },
  [SYS_mimmutable159]	= { PptrPhexlong, PbigsizePhexlong },
  [SYS_waitid160]	= { PASS_TWO, Idtypeandid, PptrPhexlong, Waitidoptname },
  [SYS_getfh161]		= { PpathPhexlong, PptrPhexlong },
  [SYS___tmpfd164]	= { Openflagsname },
  [SYS_sysarch165]	= { Pdecint, PptrPhexlong },
  [SYS_lseek166]		= { PfdPdecint, Poff_tPhexlong, Whencename, END64end_of_args },
  [SYS_truncate167]	= { PpathPhexlong, Poff_tPhexlong, END64end_of_args },
  [SYS_ftruncate168]	= { PfdPdecint, Poff_tPhexlong, END64end_of_args },
  [SYS_pread169]		= { PfdPdecint, PptrPhexlong, PbigsizePhexlong, Poff_tPhexlong, END64end_of_args },
  [SYS_pwrite170]        = { PfdPdecint, PptrPhexlong, PbigsizePhexlong, Poff_tPhexlong, END64end_of_args },
  [SYS_preadv171]	= { PfdPdecint, PptrPhexlong, PcountPdecint, Poff_tPhexlong, END64end_of_args },
  [SYS_pwritev172]	= { PfdPdecint, PptrPhexlong, PcountPdecint, Poff_tPhexlong, END64end_of_args },
  [SYS_setgid181]	= { Gidname },
  [SYS_setegid182]	= { Gidname },
  [SYS_seteuid183]	= { Uidname },
  [SYS_pathconf191]	= { PpathPhexlong, Pathconfname },
  [SYS_fpathconf192]	= { PfdPdecint, Pathconfname },
  [SYS_swapctl193]	= { SwapctlnamePhexlong, PptrPhexlong, Pdecint },
  [SYS_getrlimit194]	= { Rlimitname, PptrPhexlong },
  [SYS_setrlimit195]	= { Rlimitname, PptrPhexlong },
  [SYS_sysctl202]	= { PptrPhexlong, PcountPdecint, PptrPhexlong, PptrPhexlong, PptrPhexlong, PsizePdeculong },
  [SYS_mlock203]		= { PptrPhexlong, PbigsizePhexlong },
  [SYS_munlock204]	= { PptrPhexlong, PbigsizePhexlong },
  [SYS_getpgid207]	= { Ppid_tPdecint },
  [SYS_utrace209]	= { PptrPhexlong, PptrPhexlong, PsizePdeculong },
  [SYS_semget221]	= { Pkey_tPdecint, PcountPdecint, Semgetname },
  [SYS_msgget225]	= { Pkey_tPdecint, MsgflgnamePhexlong },
  [SYS_msgsnd226]	= { PmsqidPdecint, PptrPhexlong, PsizePdeculong, MsgflgnamePhexlong },
  [SYS_msgrcv227]	= { PmsqidPdecint, PptrPhexlong, PsizePdeculong, Pdeclong, MsgflgnamePhexlong },
  [SYS_shmat228]		= { PshmidPdecint, PptrPhexlong, Shmatname },
  [SYS_shmdt230]		= { PptrPhexlong },
  [SYS_minherit250]	= { PptrPhexlong, PbigsizePhexlong, Minheritname },
  [SYS_poll252]		= { PptrPhexlong, PucountPdecuint, Polltimeout },
  [SYS_lchown254]	= { PpathPhexlong, Uidname, Gidname },
  [SYS_getsid255]	= { Ppid_tPdecint },
  [SYS_msync256]		= { PptrPhexlong, PbigsizePhexlong, Msyncflagsname },
  [SYS_pipe263]		= { PptrPhexlong },
  [SYS_fhopen264]	= { PptrPhexlong, Openflagsname },
  [SYS_kqueue1270]	= { Flagsname },
  [SYS_mlockall271]	= { Mlockallname },
  [SYS_getresuid281]	= { PptrPhexlong, PptrPhexlong, PptrPhexlong },
  [SYS_setresuid282]	= { Uidname, Uidname, Uidname },
  [SYS_getresgid283]	= { PptrPhexlong, PptrPhexlong, PptrPhexlong },
  [SYS_setresgid284]	= { Gidname, Gidname, Gidname },
  [SYS_closefrom287]	= { PfdPdecint },
  [SYS_sigaltstack288]	= { PptrPhexlong, PptrPhexlong },
  [SYS_shmget289]	= { Pkey_tPdecint, PbigsizePhexlong, Semgetname },
  [SYS_semop290]		= { PsemidPdecint, PptrPhexlong, PsizePdeculong },
  [SYS_fhstat294]	= { PptrPhexlong, PptrPhexlong },
  [SYS___semctl295]	= { PsemidPdecint, PcountPdecint, Semctlname, PptrPhexlong },
  [SYS_shmctl296]	= { PshmidPdecint, Shmctlname, PptrPhexlong },
  [SYS_msgctl297]	= { PmsqidPdecint, Shmctlname, PptrPhexlong },
  [SYS___thrwakeup301]	= { PptrPhexlong, PcountPdecint },
  [SYS___threxit302]	= { PptrPhexlong },
  [SYS___thrsigdivert303] = { Sigset, PptrPhexlong, PptrPhexlong },
  [SYS___getcwd304]	= { PptrPhexlong, PsizePdeculong },
  [SYS_adjfreq305]	= { PptrPhexlong, PptrPhexlong },
  [SYS_setrtable310]	= { Pdecint },
  [SYS_faccessat313]	= { Atfd, PpathPhexlong, Accessmodename, Atflagsname },
  [SYS_fchmodat314]	= { Atfd, PpathPhexlong, Modename, Atflagsname },
  [SYS_fchownat315]	= { Atfd, PpathPhexlong, Uidname, Gidname, Atflagsname },
  [SYS_linkat317]	= { Atfd, PpathPhexlong, Atfd, PpathPhexlong, Atflagsname },
  [SYS_mkdirat318]	= { Atfd, PpathPhexlong, Modename },
  [SYS_mkfifoat319]	= { Atfd, PpathPhexlong, Modename },
  [SYS_mknodat320]	= { Atfd, PpathPhexlong, Modename, Pdev_tPdecint },
  [SYS_openat321]	= { Atfd, PpathPhexlong, PASS_TWO, Flagsandmodename },
  [SYS_readlinkat322]	= { Atfd, PpathPhexlong, PptrPhexlong, PsizePdeculong },
  [SYS_renameat323]	= { Atfd, PpathPhexlong, Atfd, PpathPhexlong },
  [SYS_symlinkat324]	= { PpathPhexlong, Atfd, PpathPhexlong },
  [SYS_unlinkat325]	= { Atfd, PpathPhexlong, Atflagsname },
  [SYS___set_tcb329]	= { PptrPhexlong },
926};


929static void
930ktrsyscall(struct ktr_syscall *ktr, size_t ktrlen)
931{
register_t *ap;
int narg, code;
char sep;

if (ktr->ktr_argsize > ktrlen)
errx(1, "syscall argument length %d > ktr header length %zu",
    ktr->ktr_argsize, ktrlen);

narg = ktr->ktr_argsize / sizeof(register_t);
sep = '\0';

code = ktr->ktr_code;
if (code >= SYS_MAXSYSCALL331 || code < 0)
(void)printf("[%d]", code);
else
(void)printf("%s", syscallnames[code]);
ap = (register_t *)((char *)ktr + sizeof(struct ktr_syscall));
(void)putchar('(')(!__isthreaded ? __sputc('(', (&__sF[1])) : (putc)('(', (
&__sF[1])));

if (code == SYS_sysctl202 && fancy) {
const char *s;
int n, i, *top;

n = ap[1];
if (n > CTL_MAXNAME12)
	n = CTL_MAXNAME12;
if (n < 0)
	errx(1, "invalid sysctl length %d", n);
if (n > 0) {
	top = (int *)(ap + 6);
	printf("%d", top[0]);
	for (i = 1; i < n; i++)
		printf(".%d", top[i]);
	if ((s = kresolvsysctl(0, top)) != NULL((void *)0)) {
		printf("<%s", s);
		for (i = 1; i < n; i++) {
			if ((s = kresolvsysctl(i, top)) != NULL((void *)0))
				printf(".%s", s);
			else
				printf(".%d", top[i]);
		}
		putchar('>')(!__isthreaded ? __sputc('>', (&__sF[1])) : (putc)('>'
, (&__sF[1])));
	}
}

sep = ',';
ap += 2;
narg -= 2;
} else if (code < nitems(scargs)(sizeof((scargs)) / sizeof((scargs)[0]))) {
const formatter *fmts = scargs[code];
int fmt;
int arg = 0;

while (arg < narg && (fmt = *fmts) != 0) {
	if (PAD640 && fmt == PASS_LONGLONG && (arg & 1))
		goto skip;
	if (sep)
		putchar(sep)(!__isthreaded ? __sputc(sep, (&__sF[1])) : (putc)(sep, (
&__sF[1])));
	sep = ',';
	if (!fancy && !FMT_IS_NONFANCY(fmt)((fmt) <= PASS_LONGLONG))
		fmt = Pnonfancy;
	if (fmt > 0)
		formatters[fmt]((int)*ap);
	else if (long_formatters[-fmt](*ap))
		sep = '\0';
	fmts++;
998skip:
	ap++;
	arg++;
}
narg -= arg;
}

while (narg > 0) {
if (sep)
	putchar(sep)(!__isthreaded ? __sputc(sep, (&__sF[1])) : (putc)(sep, (
&__sF[1])));
if (decimal)
	(void)printf("%ld", (long)*ap);
else
	(void)printf("%#lx", (long)*ap);
sep = ',';
ap++;
narg--;
}
(void)printf(")\n");
1017}

1019static struct ctlname topname[] = CTL_NAMES{ { 0, 0 }, { "kern", 1 }, { "vm", 1 }, { "fs", 1 }, { "net",
}, { "debug", 1 }, { "hw", 1 }, { "machdep", 1 }, { "gap",
}, { "ddb", 1 }, { "vfs", 1 }, };
1020static struct ctlname kernname[] = CTL_KERN_NAMES{ { 0, 0 }, { "ostype", 3 }, { "osrelease", 3 }, { "osrevision"
, 2 }, { "version", 3 }, { "maxvnodes", 2 }, { "maxproc", 2 }
, { "maxfiles", 2 }, { "argmax", 2 }, { "securelevel", 2 }, {
 "hostname", 3 }, { "hostid", 2 }, { "clockrate", 5 }, { "gap"
, 0 }, { "gap", 0 }, { "gap", 0 }, { "profiling", 1 }, { "posix1version"
, 2 }, { "ngroups", 2 }, { "job_control", 2 }, { "saved_ids",
}, { "boottime", 5 }, { "domainname", 3 }, { "maxpartitions"
, 2 }, { "rawpartition", 2 }, { "maxthread", 2 }, { "nthreads"
, 2 }, { "osversion", 3 }, { "somaxconn", 2 }, { "sominconn",
}, { "gap", 0 }, { "gap", 0 }, { "nosuidcoredump", 2 }, { "fsync"
, 2 }, { "sysvmsg", 2 }, { "sysvsem", 2 }, { "sysvshm", 2 }, {
 "gap", 0 }, { "msgbufsize", 2 }, { "malloc", 1 }, { "cp_time"
, 5 }, { "nchstats", 5 }, { "forkstat", 5 }, { "gap", 0 }, { "tty"
, 1 }, { "ccpu", 2 }, { "fscale", 2 }, { "nprocs", 2 }, { "msgbuf"
, 5 }, { "pool", 1 }, { "stackgap_random", 2 }, { "sysvipc_info"
, 2 }, { "allowkmem", 2 }, { "witnesswatch", 2 }, { "splassert"
, 2 }, { "procargs", 1 }, { "nfiles", 2 }, { "ttycount", 2 },
 { "numvnodes", 2 }, { "mbstat", 5 }, { "witness", 1 }, { "seminfo"
, 5 }, { "shminfo", 5 }, { "intrcnt", 1 }, { "watchdog", 1 },
 { "allowdt", 2 }, { "proc", 5 }, { "maxclusters", 2 }, { "evcount"
, 1 }, { "timecounter", 1 }, { "maxlocksperuid", 2 }, { "cp_time2"
, 5 }, { "bufcachepercent", 2 }, { "file", 5 }, { "wxabort", 2
 }, { "consdev", 5 }, { "netlivelocks", 2 }, { "pool_debug", 2
 }, { "proc_cwd", 1 }, { "proc_nobroadcastkill", 1 }, { "proc_vmmap"
, 1 }, { "global_ptrace", 2 }, { "consbufsize", 2 }, { "consbuf"
, 5 }, { "audio", 5 }, { "cpustats", 5 }, { "pfstatus", 5 }, {
 "timeout_stats", 5 }, { "utc_offset", 2 }, { "video", 5 }, {
 "clockintr", 1 }, { "autoconf_serial", 2 }, };
1021static struct ctlname vmname[] = CTL_VM_NAMES{ { 0, 0 }, { "vmmeter", 5 }, { "loadavg", 5 }, { "psstrings"
, 5 }, { "uvmexp", 5 }, { "swapencrypt", 1 }, { "nkmempages",
}, { "anonmin", 2 }, { "vtextmin", 2 }, { "vnodemin", 2 },
 { "maxslp", 2 }, { "uspace", 2 }, { "malloc_conf", 3 }, };
1022static struct ctlname fsname[] = CTL_FS_NAMES{ { 0, 0 }, { "posix", 1 }, };
1023static struct ctlname netname[] = CTL_NET_NAMES{ { 0, 0 }, { "unix", 1 }, { "inet", 1 }, { "implink", 1 }, {
 "pup", 1 }, { "chaos", 1 }, { "xerox_ns", 1 }, { "iso", 1 },
 { "ecma", 1 }, { "datakit", 1 }, { "ccitt", 1 }, { "ibm_sna"
, 1 }, { "decnet", 1 }, { "dec_dli", 1 }, { "lat", 1 }, { "hylink"
, 1 }, { "appletalk", 1 }, { "route", 1 }, { "link", 1 }, { "xtp"
, 1 }, { "coip", 1 }, { "cnt", 1 }, { "rtip", 1 }, { "ipx", 1
 }, { "inet6", 1 }, { "pip", 1 }, { "isdn", 1 }, { "natm", 1 }
, { "encap", 1 }, { "sip", 1 }, { "key", 1 }, { "bpf", 1 }, {
 "bluetooth", 1 }, { "mpls", 1 }, { "pflow", 1 }, { "pipex", 1
 }, };
1024static struct ctlname hwname[] = CTL_HW_NAMES{ { 0, 0 }, { "machine", 3 }, { "model", 3 }, { "ncpu", 2 }, {
 "byteorder", 2 }, { "gap", 0 }, { "gap", 0 }, { "pagesize", 2
 }, { "disknames", 3 }, { "diskstats", 5 }, { "diskcount", 2 }
, { "sensors", 1}, { "cpuspeed", 2 }, { "setperf", 2 }, { "vendor"
, 3 }, { "product", 3 }, { "version", 3 }, { "serialno", 3 },
 { "uuid", 3 }, { "physmem", 4 }, { "usermem", 4 }, { "ncpufound"
, 2 }, { "allowpowerdown", 2 }, { "perfpolicy", 3 }, { "smt",
}, { "ncpuonline", 2 }, { "power", 2 }, { "battery", 1 }, {
 "ucomnames", 3 }, };
1025static struct ctlname debugname[CTL_DEBUG_MAXID20];
1026static struct ctlname kernmallocname[] = CTL_KERN_MALLOC_NAMES{ { 0, 0 }, { "buckets", 3 }, { "bucket", 1 }, { "kmemnames",
}, { "kmemstat", 1 }, };
1027static struct ctlname forkstatname[] = CTL_KERN_FORKSTAT_NAMES{ { 0, 0 }, { "forks", 2 }, { "vforks", 2 }, { "tforks", 2 },
 { "kthreads", 2 }, { "fork_pages", 2 }, { "vfork_pages", 2 }
, { "tfork_pages", 2 }, { "kthread_pages", 2 }, };
1028static struct ctlname nchstatsname[] = CTL_KERN_NCHSTATS_NAMES{ { 0, 0 }, { "good_hits", 4 }, { "negative_hits", 4 }, { "bad_hits"
, 4 }, { "false_hits", 4 }, { "misses", 4 }, { "long_names", 4
 }, { "pass2", 4 }, { "2passes", 4 }, { "ncs_revhits", 4 }, {
 "ncs_revmiss", 4 }, { "ncs_dothits", 4 }, { "nch_dotdothits"
, 4 }, };
1029static struct ctlname kernprocname[] = {
{ NULL((void *)0) },
{ "all" },
{ "pid" },
{ "pgrp" },
{ "session" },
{ "tty" },
{ "uid" },
{ "ruid" },
{ "kthread" },
1039};
1040static struct ctlname ttysname[] = CTL_KERN_TTY_NAMES{ { 0, 0 }, { "tk_nin", 4 }, { "tk_nout", 4 }, { "tk_rawcc", 4
 }, { "tk_cancc", 4 }, { "ttyinfo", 5 }, { "gap", 0 }, { "gap"
, 0 }, };
1041static struct ctlname semname[] = CTL_KERN_SEMINFO_NAMES{ { 0, 0 }, { "semmni", 2 }, { "semmns", 2 }, { "semmnu", 2 }
, { "semmsl", 2 }, { "semopm", 2 }, { "semume", 2 }, { "semusz"
, 2 }, { "semvmx", 2 }, { "semaem", 2 }, };
1042static struct ctlname shmname[] = CTL_KERN_SHMINFO_NAMES{ { 0, 0 }, { "shmmax", 2 }, { "shmmin", 2 }, { "shmmni", 2 }
, { "shmseg", 2 }, { "shmall", 2 }, };
1043static struct ctlname watchdogname[] = CTL_KERN_WATCHDOG_NAMES{ { 0, 0 }, { "period", 2 }, { "auto", 2 }, };
1044static struct ctlname tcname[] = CTL_KERN_TIMECOUNTER_NAMES{ { 0, 0 }, { "tick", 2 }, { "timestepwarnings", 2 }, { "hardware"
, 3 }, { "choice", 3 }, };
1045#ifdef CTL_MACHDEP_NAMES{ { 0, 0 }, { "console_device", 5 }, { "bios", 2 }, { "blk2chr"
, 5 }, { "chr2blk", 5 }, { "allowaperture", 2 }, { "cpuvendor"
, 3 }, { "cpuid", 2 }, { "cpufeature", 2 }, { 0, 0 }, { "kbdreset"
, 2 }, { 0, 0 }, { "xcrypt", 2 }, { 0, 0 }, { "lidaction", 2 }
, { "forceukbd", 2 }, { "tscfreq", 4 }, { "invarianttsc", 2 }
, { "pwraction", 2 }, }
1046static struct ctlname machdepname[] = CTL_MACHDEP_NAMES{ { 0, 0 }, { "console_device", 5 }, { "bios", 2 }, { "blk2chr"
, 5 }, { "chr2blk", 5 }, { "allowaperture", 2 }, { "cpuvendor"
, 3 }, { "cpuid", 2 }, { "cpufeature", 2 }, { 0, 0 }, { "kbdreset"
, 2 }, { 0, 0 }, { "xcrypt", 2 }, { 0, 0 }, { "lidaction", 2 }
, { "forceukbd", 2 }, { "tscfreq", 4 }, { "invarianttsc", 2 }
, { "pwraction", 2 }, };
1047#endif
1048static struct ctlname ddbname[] = CTL_DDB_NAMES{ { ((void *)0), 0 }, { "radix", 2 }, { "max_width", 2 }, { "max_line"
, 2 }, { "tab_stop_width", 2 }, { "panic", 2 }, { "console", 2
 }, { "log", 2 }, { "trigger", 2 }, { "profile", 2 }, };

1050#ifndef nitems
1051#define nitems(_a)(sizeof((_a)) / sizeof((_a)[0]))    (sizeof((_a)) / sizeof((_a)[0]))
1052#endif

1054#define SETNAME(name)do { names = (name); limit = (sizeof((name)) / sizeof((name)[
0])); } while (0) do { names = (name); limit = nitems(name)(sizeof((name)) / sizeof((name)[0])); } while (0)

1056static const char *
1057kresolvsysctl(int depth, const int *top)
1058{
struct ctlname *names;
size_t		limit;
int		idx = top[depth];

names = NULL((void *)0);

switch (depth) {
case 0:
SETNAME(topname)do { names = (topname); limit = (sizeof((topname)) / sizeof((
topname)[0])); } while (0);
break;
case 1:
switch (top[0]) {
case CTL_KERN1:
	SETNAME(kernname)do { names = (kernname); limit = (sizeof((kernname)) / sizeof
((kernname)[0])); } while (0);
	break;
case CTL_VM2:
	SETNAME(vmname)do { names = (vmname); limit = (sizeof((vmname)) / sizeof((vmname
)[0])); } while (0);
	break;
case CTL_FS3:
	SETNAME(fsname)do { names = (fsname); limit = (sizeof((fsname)) / sizeof((fsname
)[0])); } while (0);
	break;
case CTL_NET4:
	SETNAME(netname)do { names = (netname); limit = (sizeof((netname)) / sizeof((
netname)[0])); } while (0);
	break;
case CTL_DEBUG5:
	SETNAME(debugname)do { names = (debugname); limit = (sizeof((debugname)) / sizeof
((debugname)[0])); } while (0);
	break;
case CTL_HW6:
	SETNAME(hwname)do { names = (hwname); limit = (sizeof((hwname)) / sizeof((hwname
)[0])); } while (0);
	break;
1089#ifdef CTL_MACHDEP_NAMES{ { 0, 0 }, { "console_device", 5 }, { "bios", 2 }, { "blk2chr"
, 5 }, { "chr2blk", 5 }, { "allowaperture", 2 }, { "cpuvendor"
, 3 }, { "cpuid", 2 }, { "cpufeature", 2 }, { 0, 0 }, { "kbdreset"
, 2 }, { 0, 0 }, { "xcrypt", 2 }, { 0, 0 }, { "lidaction", 2 }
, { "forceukbd", 2 }, { "tscfreq", 4 }, { "invarianttsc", 2 }
, { "pwraction", 2 }, }
case CTL_MACHDEP7:
	SETNAME(machdepname)do { names = (machdepname); limit = (sizeof((machdepname)) / sizeof
((machdepname)[0])); } while (0);
	break;
1093#endif
case CTL_DDB9:
	SETNAME(ddbname)do { names = (ddbname); limit = (sizeof((ddbname)) / sizeof((
ddbname)[0])); } while (0);
	break;
}
break;
case 2:
switch (top[0]) {
case CTL_KERN1:
	switch (top[1]) {
	case KERN_MALLOCSTATS39:
		SETNAME(kernmallocname)do { names = (kernmallocname); limit = (sizeof((kernmallocname
)) / sizeof((kernmallocname)[0])); } while (0);
		break;
	case KERN_FORKSTAT42:
		SETNAME(forkstatname)do { names = (forkstatname); limit = (sizeof((forkstatname)) /
 sizeof((forkstatname)[0])); } while (0);
		break;
	case KERN_NCHSTATS41:
		SETNAME(nchstatsname)do { names = (nchstatsname); limit = (sizeof((nchstatsname)) /
 sizeof((nchstatsname)[0])); } while (0);
		break;
	case KERN_TTY44:
		SETNAME(ttysname)do { names = (ttysname); limit = (sizeof((ttysname)) / sizeof
((ttysname)[0])); } while (0);
		break;
	case KERN_SEMINFO61:
		SETNAME(semname)do { names = (semname); limit = (sizeof((semname)) / sizeof((
semname)[0])); } while (0);
		break;
	case KERN_SHMINFO62:
		SETNAME(shmname)do { names = (shmname); limit = (sizeof((shmname)) / sizeof((
shmname)[0])); } while (0);
		break;
	case KERN_WATCHDOG64:
		SETNAME(watchdogname)do { names = (watchdogname); limit = (sizeof((watchdogname)) /
 sizeof((watchdogname)[0])); } while (0);
		break;
	case KERN_PROC66:
		idx++;	/* zero is valid at this level */
		SETNAME(kernprocname)do { names = (kernprocname); limit = (sizeof((kernprocname)) /
 sizeof((kernprocname)[0])); } while (0);
		break;
	case KERN_TIMECOUNTER69:
		SETNAME(tcname)do { names = (tcname); limit = (sizeof((tcname)) / sizeof((tcname
)[0])); } while (0);
		break;
	}
}
break;
}
if (names != NULL((void *)0) && idx > 0 && idx < limit)
return (names[idx].ctl_name);
return (NULL((void *)0));
1138}

1140static void
1141ktrsysret(struct ktr_sysret *ktr, size_t ktrlen)
1142{
register_t ret = 0;
long long retll;
int error = ktr->ktr_error;
int code = ktr->ktr_code;

if (ktrlen < sizeof(*ktr))
errx(1, "sysret length %zu < ktr header length %zu",
    ktrlen, sizeof(*ktr));
ktrlen -= sizeof(*ktr);
if (error == 0) {
if (ktrlen == sizeof(ret)) {
	memcpy(&ret, ktr+1, sizeof(ret));
	retll = ret;
} else if (ktrlen == sizeof(retll))
	memcpy(&retll, ktr+1, sizeof(retll));
else
	errx(1, "sysret bogus length %zu", ktrlen);
}

if (code >= SYS_MAXSYSCALL331 || code < 0)
(void)printf("[%d] ", code);
else
(void)printf("%s ", syscallnames[code]);

1167doerr:
if (error == 0) {
if (fancy) {
	switch (code) {
	case SYS_lseek166:
		(void)printf("%lld", retll);
		if (retll < 0 || retll > 9)
			(void)printf("/%#llx", retll);
		break;
	case SYS_sigprocmask48:
	case SYS_sigpending52:
		sigset(ret);
		break;
	case SYS___thrsigdivert303:
		signame(ret);
		break;
	case SYS_getuid24:
	case SYS_geteuid25:
		uidname(ret);
		break;
	case SYS_getgid47:
	case SYS_getegid43:
		gidname(ret);
		break;
	/* syscalls that return errno values */
	case SYS_getlogin_r141:
	case SYS___thrsleep94:
	case SYS_getthrname142:
	case SYS_setthrname143:
		if ((error = ret) != 0)
			goto doerr;
		/* FALLTHROUGH */
	default:
		(void)printf("%ld", (long)ret);
		if (ret < 0 || ret > 9)
			(void)printf("/%#lx", (long)ret);
	}
} else {
	if (decimal)
		(void)printf("%lld", retll);
	else
		(void)printf("%#llx", retll);
}
} else if (error == ERESTART-1)
(void)printf("RESTART");
else if (error == EJUSTRETURN-2)
(void)printf("JUSTRETURN");
else {
(void)printf("-1 errno %d", error);
if (fancy)
	(void)printf(" %s", strerror(error));
}
(void)putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
1220}

1222static void
1223ktrnamei(const char *cp, size_t len)
1224{
showbufc(basecol, (unsigned char *)cp, len, VIS_DQ0x200 | VIS_TAB0x08 | VIS_NL0x10);
1226}

1228void
1229showbufc(int col, unsigned char *dp, size_t datalen, int flags)
1230{
int width;
unsigned char visbuf[5], *cp;

flags |= VIS_CSTYLE0x02;
putchar('"')(!__isthreaded ? __sputc('"', (&__sF[1])) : (putc)('"', (
&__sF[1])));
col++;
for (; datalen > 0; datalen--, dp++) {
(void)vis(visbuf, *dp, flags, *(dp+1));
cp = visbuf;

/*
 * Keep track of printables and
 * space chars (like fold(1)).
 */
if (col == 0) {
	(void)putchar('\t')(!__isthreaded ? __sputc('\t', (&__sF[1])) : (putc)('\t',
 (&__sF[1])));
	col = 8;
}
switch (*cp) {
case '\n':
	col = 0;
	(void)putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
	continue;
case '\t':
	width = 8 - (col&07);
	break;
default:
	width = strlen(cp);
}
if (col + width > (screenwidth-2)) {
	(void)printf("\\\n\t");
	col = 8;
}
col += width;
do {
	(void)putchar(*cp++)(!__isthreaded ? __sputc(*cp++, (&__sF[1])) : (putc)(*cp++
, (&__sF[1])));
} while (*cp);
}
if (col == 0)
(void)printf("       ");
(void)printf("\"\n");
1272}

1274static void
1275showbuf(unsigned char *dp, size_t datalen)
1276{
size_t i, j;
int col = 0, bpl;
unsigned char c;
char visbuf[4 * KTR_USER_MAXLEN2048 + 1];

if (utracefilter != NULL((void *)0)) {
strvisx(visbuf, dp, datalen, VIS_SAFE0x20 | VIS_OCTAL0x01);
printf("%s", visbuf);
return;
}
if (iohex == 1) {
putchar('\t')(!__isthreaded ? __sputc('\t', (&__sF[1])) : (putc)('\t',
 (&__sF[1])));
col = 8;
for (i = 0; i < datalen; i++) {
	printf("%02x", dp[i]);
	col += 3;
	if (i < datalen - 1) {
		if (col + 3 > screenwidth) {
			printf("\n\t");
			col = 8;
		} else
			putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1])));
	}
}
putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
return;
}
if (iohex == 2) {
bpl = (screenwidth - 13)/4;
if (bpl <= 0)
	bpl = 1;
for (i = 0; i < datalen; i += bpl) {
	printf("   %04zx:  ", i);
	for (j = 0; j < bpl; j++) {
		if (i+j >= datalen)
			printf("   ");
		else
			printf("%02x ", dp[i+j]);
	}
	putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', (
&__sF[1])));
	for (j = 0; j < bpl; j++) {
		if (i+j >= datalen)
			break;
		c = dp[i+j];
		if (!isprint(c))
			c = '.';
		putchar(c)(!__isthreaded ? __sputc(c, (&__sF[1])) : (putc)(c, (&
__sF[1])));
	}
	putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
}
return;
}

(void)printf("       ");
showbufc(7, dp, datalen, 0);
1332}

1334static void
1335ktrgenio(struct ktr_genio *ktr, size_t len)
1336{
unsigned char *dp = (unsigned char *)ktr + sizeof(struct ktr_genio);
size_t datalen;

if (len < sizeof(struct ktr_genio))
errx(1, "invalid ktr genio length %zu", len);

datalen = len - sizeof(struct ktr_genio);

printf("fd %d %s %zu bytes\n", ktr->ktr_fd,
ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen);
if (maxdata == 0)
return;
if (datalen > maxdata)
datalen = maxdata;
if (iohex && !datalen)
return;
showbuf(dp, datalen);
1354}

1356void
1357siginfo(const siginfo_t *si, int show_signo)
1358{
if (show_signo) {
printf("signo=");
signame(si->si_signo);
}
if (si->si_code) {
printf(" code=");
if (!fancy)
	printf("<%d>", si->si_code);
else {
	switch (si->si_signo) {
	case SIGILL4:
		sigill_name(si->si_code);
		break;
	case SIGTRAP5:
		sigtrap_name(si->si_code);
		break;
	case SIGEMT7:
		sigemt_name(si->si_code);
		break;
	case SIGFPE8:
		sigfpe_name(si->si_code);
		break;
	case SIGBUS10:
		sigbus_name(si->si_code);
		break;
	case SIGSEGV11:
		sigsegv_name(si->si_code);
		break;
	case SIGCHLD20:
		sigchld_name(si->si_code);
		break;
	default:
		printf("<%d>", si->si_code);
		break;
	}
}
}

switch (si->si_signo) {
case SIGSEGV11:
case SIGILL4:
case SIGBUS10:
case SIGFPE8:
printf(" addr=%p trapno=%d", si->si_addr_data._fault._addr, si->si_trapno_data._fault._trapno);
break;
case SIGCHLD20:
if (si->si_code == CLD_EXITED1) {
	printf(" status=%d", si->si_status_data._proc._pdata._cld._status);
	if (si->si_status_data._proc._pdata._cld._status < 0 || si->si_status_data._proc._pdata._cld._status > 9)
		(void)printf("/%#x", si->si_status_data._proc._pdata._cld._status);
} else {
	printf(" status=");
	signame(si->si_status_data._proc._pdata._cld._status);
}
printf(" pid=%d uid=", si->si_pid_data._proc._pid);
uidname(si->si_uid_data._proc._uid);
break;
default:
break;
}
1419}

1421static void
1422ktrpsig(struct ktr_psig *psig)
1423{
signame(psig->signo);
31
←
1st function call argument is an uninitialized value
printf(" ");
if (psig->action == SIG_DFL(void (*)(int))0)
printf("SIG_DFL");
else {
printf("caught handler=0x%lx mask=", (u_long)psig->action);
sigset(psig->mask);
}
siginfo(&psig->si, 0);
putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
1434}

1436static void
1437ktruser(struct ktr_user *usr, size_t len)
1438{
if (len < sizeof(struct ktr_user))
errx(1, "invalid ktr user length %zu", len);
len -= sizeof(struct ktr_user);
if (utracefilter == NULL((void *)0)) {
printf("%.*s:", KTR_USER_MAXIDLEN20, usr->ktr_id);
printf(" %zu bytes\n", len);
showbuf((unsigned char *)(usr + 1), len);
} else if (strncmp(usr->ktr_id, utracefilter, KTR_USER_MAXIDLEN20) == 0)
showbuf((unsigned char *)(usr + 1), len);
1448}

1450static void
1451ktrexec(const char *ptr, size_t len)
1452{
int i, col;
size_t l;

putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n',
 (&__sF[1])));
i = 0;
while (len > 0) {
l = strnlen(ptr, len);
col = printf("\t[%d] = ", i++);
col += 7;	/* tab expands from 1 to 8 columns */
showbufc(col, (unsigned char *)ptr, l, VIS_DQ0x200|VIS_TAB0x08|VIS_NL0x10);
if (l == len) {
	printf("\tunterminated argument\n");
	break;
}
len -= l + 1;
ptr += l + 1;
}
1470}

1472static void
1473ktrpledge(struct ktr_pledge *pledge, size_t len)
1474{
const char *name = "";
int i;

if (len < sizeof(struct ktr_pledge))
errx(1, "invalid ktr pledge length %zu", len);

if (pledge->syscall >= SYS_MAXSYSCALL331 || pledge->syscall < 0)
(void)printf("[%d]", pledge->syscall);
else
(void)printf("%s", syscallnames[pledge->syscall]);
printf(", ");
for (i = 0; pledge->code && pledgenames[i].bits != 0; i++) {
if (pledgenames[i].bits & pledge->code) {
	name = pledgenames[i].name;
	break;
}
}
printf("\"%s\"", name);
(void)printf(", errno %d", pledge->error);
if (fancy)
(void)printf(" %s", strerror(pledge->error));
printf("\n");
1497}

1499static void
1500ktrpinsyscall(struct ktr_pinsyscall *pinsyscall, size_t len)
1501{
const char *name = "";
int i;

if (len < sizeof(struct ktr_pinsyscall))
errx(1, "invalid ktr pinsyscall length %zu", len);

if (pinsyscall->syscall >= SYS_MAXSYSCALL331 || pinsyscall->syscall < 0)
(void)printf("[%d]", pinsyscall->syscall);
else
(void)printf("%s", syscallnames[pinsyscall->syscall]);
(void)printf(", addr %lx, errno %d", pinsyscall->addr,
   pinsyscall->error);
(void)printf(", errno %d", pinsyscall->error);
if (fancy)
(void)printf(" %s", strerror(pinsyscall->error));
printf("\n");
1518}

1520static void
1521usage(void)
1522{

extern char *__progname;
fprintf(stderr(&__sF[2]), "usage: %s "
   "[-dHlnRTXx] [-f file] [-m maxdata] [-P program] [-p pid] "
   "[-t trstr]\n\t[-u label]\n", __progname);
exit(1);
1529}


1532/*
* FORMATTERS
*/

1536static void
1537ioctldecode(int cmd)
1538{
char dirbuf[4], *dir = dirbuf;
const char *cp;

if ((cp = ioctlname((unsigned)cmd)) != NULL((void *)0)) {
(void)printf("%s", cp);
return;
}

if (cmd & IOC_IN(unsigned long)0x80000000)
*dir++ = 'W';
if (cmd & IOC_OUT(unsigned long)0x40000000)
*dir++ = 'R';
*dir = '\0';

printf("_IO%s('%c',%d",
   dirbuf, (int)((cmd >> 8) & 0xff), cmd & 0xff);
if ((cmd & IOC_VOID(unsigned long)0x20000000) == 0)
printf(decimal ? ",%u)" : ",%#x)", (cmd >> 16) & 0xff);
else
printf(")");
1559}

1561static void
1562ptracedecode(int request)
1563{
if (request >= 0 && request < nitems(ptrace_ops)(sizeof((ptrace_ops)) / sizeof((ptrace_ops)[0])))
(void)printf("%s", ptrace_ops[request]);
else switch(request) {
1567#ifdef PT_GETFPREGS(32 + 3)
case PT_GETFPREGS(32 + 3):
(void)printf("PT_GETFPREGS");
break;
1571#endif
case PT_GETREGS(32 + 1):
(void)printf("PT_GETREGS");
break;
1575#ifdef PT_GETXMMREGS
case PT_GETXMMREGS:
(void)printf("PT_GETXMMREGS");
break;
1579#endif
1580#ifdef PT_SETFPREGS(32 + 4)
case PT_SETFPREGS(32 + 4):
(void)printf("PT_SETFPREGS");
break;
1584#endif
case PT_SETREGS(32 + 2):
(void)printf("PT_SETREGS");
break;
1588#ifdef PT_SETXMMREGS
case PT_SETXMMREGS:
(void)printf("PT_SETXMMREGS");
break;
1592#endif
1593#ifdef PT_STEP(32 + 0)
case PT_STEP(32 + 0):
(void)printf("PT_STEP");
break;
1597#endif
1598#ifdef PT_WCOOKIE
case PT_WCOOKIE:
(void)printf("PT_WCOOKIE");
break;
1602#endif
default:
pdecint(request);
}
1606}


1609static void
1610atfd(int fd)
1611{
if (fd == AT_FDCWD-100)
(void)printf("AT_FDCWD");
else
pdecint(fd);
1616}

1618static void
1619polltimeout(int timeout)
1620{
if (timeout == INFTIM(-1))
(void)printf("INFTIM");
else
pdecint(timeout);
1625}

1627static void
1628wait4pid(int pid)
1629{
if (pid == WAIT_ANY(-1))
(void)printf("WAIT_ANY");
else if (pid == WAIT_MYPGRP0)
(void)printf("WAIT_MYPGRP");
else
pdecint(pid);		/* ppgid */
1636}

1638static void
1639signame(int sig)
1640{
if (sig > 0 && sig < NSIG33)
(void)printf("SIG%s", sys_signame[sig]);
else
(void)printf("SIG %d", sig);
1645}

1647void
1648sigset(int ss)
1649{
int	or = 0;
int	cnt = 0;
int	i;

for (i = 1; i < NSIG33; i++)
if (sigismember(&ss, i))
	cnt++;
if (cnt > (NSIG33-1)/2) {
ss = ~ss;
putchar('~')(!__isthreaded ? __sputc('~', (&__sF[1])) : (putc)('~', (
&__sF[1])));
}

if (ss == 0) {
(void)printf("0<>");
return;
}

printf("%#x<", ss);
for (i = 1; i < NSIG33; i++)
if (sigismember(&ss, i)) {
	if (or) putchar('|')(!__isthreaded ? __sputc('|', (&__sF[1])) : (putc)('|', (
&__sF[1]))); else or=1;
	signame(i);
}
printf(">");
1674}

1676static void
1677semctlname(int cmd)
1678{
switch (cmd) {
case GETNCNT3:
(void)printf("GETNCNT");
break;
case GETPID4:
(void)printf("GETPID");
break;
case GETVAL5:
(void)printf("GETVAL");
break;
case GETALL6:
(void)printf("GETALL");
break;
case GETZCNT7:
(void)printf("GETZCNT");
break;
case SETVAL8:
(void)printf("SETVAL");
break;
case SETALL9:
(void)printf("SETALL");
break;
case IPC_RMID0:
(void)printf("IPC_RMID");
break;
case IPC_SET1:
(void)printf("IPC_SET");
break;
case IPC_STAT2:
(void)printf("IPC_STAT");
break;
default: /* Should not reach */
(void)printf("<invalid=%d>", cmd);
}
1713}

1715static void
1716shmctlname(int cmd)
1717{
switch (cmd) {
case IPC_RMID0:
(void)printf("IPC_RMID");
break;
case IPC_SET1:
(void)printf("IPC_SET");
break;
case IPC_STAT2:
(void)printf("IPC_STAT");
break;
default: /* Should not reach */
(void)printf("<invalid=%d>", cmd);
}
1731}


1734static void
1735semgetname(int flag)
1736{
int	or = 0;
if_print_or(flag, IPC_CREAT, or)do { if ((flag & 001000) == 001000) do { if (or) (!__isthreaded
 ? __sputc('|', (&__sF[1])) : (putc)('|', (&__sF[1]))
); else or = 1; printf ("%s", "IPC_CREAT"); } while (0); } while
 (0);
if_print_or(flag, IPC_EXCL, or)do { if ((flag & 002000) == 002000) do { if (or) (!__isthreaded
 ? __sputc('|', (&__sF[1])) : (putc)('|', (&__sF[1]))
); else or = 1; printf ("%s", "IPC_EXCL"); } while (0); } while
 (0);
if_print_or(flag, SEM_R, or)do { if ((flag & 0400) == 0400) do { if (or) (!__isthreaded
 ? __sputc('|', (&__sF[1])) : (putc)('|', (&__sF[1]))
); else or = 1; printf ("%s", "SEM_R"); } while (0); } while (
0);
if_print_or(flag, SEM_A, or)do { if ((flag & 0200) == 0200) do { if (or) (!__isthreaded
 ? __sputc('|', (&__sF[1])) : (putc)('|', (&__sF[1]))
); else or = 1; printf ("%s", "SEM_A"); } while (0); } while (
0);
if_print_or(flag, (SEM_R>>3), or)do { if ((flag & (0400>>3)) == (0400>>3)) do {
 if (or) (!__isthreaded ? __sputc('|', (&__sF[1])) : (putc
)('|', (&__sF[1]))); else or = 1; printf ("%s", "(SEM_R>>3)"
); } while (0); } while (0);
if_print_or(flag, (SEM_A>>3), or)do { if ((flag & (0200>>3)) == (0200>>3)) do {
 if (or) (!__isthreaded ? __sputc('|', (&__sF[1])) : (putc
)('|', (&__sF[1]))); else or = 1; printf ("%s", "(SEM_A>>3)"
); } while (0); } while (0);
if_print_or(flag, (SEM_R>>6), or)do { if ((flag & (0400>>6)) == (0400>>6)) do {
 if (or) (!__isthreaded ? __sputc('|', (&__sF[1])) : (putc
)('|', (&__sF[1]))); else or = 1; printf ("%s", "(SEM_R>>6)"
); } while (0); } while (0);
if_print_or(flag, (SEM_A>>6), or)do { if ((flag & (0200>>6)) == (0200>>6)) do {
 if (or) (!__isthreaded ? __sputc('|', (&__sF[1])) : (putc
)('|', (&__sF[1]))); else or = 1; printf ("%s", "(SEM_A>>6)"
); } while (0); } while (0);

if (flag & ~(IPC_CREAT001000|IPC_EXCL002000|SEM_R0400|SEM_A0200|((SEM_R0400|SEM_A0200)>>3)|
   ((SEM_R0400|SEM_A0200)>>6)))
printf("<invalid=%#x>", flag);
1750}


1753/*
* Only used by SYS_open and SYS_openat. Unless O_CREAT is set in flags, the
* mode argument is unused (and often bogus and misleading).
*/
1757static void
1758flagsandmodename(int mode)
1759{
openflagsname(arg1);
if ((arg1 & O_CREAT0x0200) == O_CREAT0x0200) {
(void)putchar(',')(!__isthreaded ? __sputc(',', (&__sF[1])) : (putc)(',', (
&__sF[1])));
modename(mode);
} else if (!fancy)
(void)printf(",<unused>%#o", mode);
1766}

1768static void
1769clockname(int clockid)
1770{
clocktypename(__CLOCK_TYPE(clockid)((clockid) & 0xfff));
if (__CLOCK_PTID(clockid)(((clockid) >> 12) & 0xfffff) != 0)
printf("(%d)", __CLOCK_PTID(clockid)(((clockid) >> 12) & 0xfffff));
1774}

1776/*
* [g|s]etsockopt's level argument can either be SOL_SOCKET or a value
* referring to a line in /etc/protocols.
*/
1780static void
1781sockoptlevelname(int optname)
1782{
struct protoent *pe;

if (arg1 == SOL_SOCKET0xffff) {
(void)printf("SOL_SOCKET,");
sockoptname(optname);
} else {
pe = getprotobynumber(arg1);
(void)printf("%u<%s>,%d", arg1,
    pe != NULL((void *)0) ? pe->p_name : "unknown", optname);
}
1793}

1795static void
1796ktraceopname(int ops)
1797{
int invalid = 0;

printf("%#x<", ops);
switch (KTROP(ops)((ops)&3)) {
case KTROP_SET0:
printf("KTROP_SET");
break;
case KTROP_CLEAR1:
printf("KTROP_CLEAR");
break;
case KTROP_CLEARFILE2:
printf("KTROP_CLEARFILE");
break;
default:
printf("KTROP(%d)", KTROP(ops)((ops)&3));
invalid = 1;
break;
}
if (ops & KTRFLAG_DESCEND4) printf("|KTRFLAG_DESCEND");
printf(">");
if (invalid || (ops & ~(KTROP((unsigned)-1)(((unsigned)-1)&3) | KTRFLAG_DESCEND4)))
(void)printf("<invalid>%d", ops);
1820}

1822static void
1823idtypeandid(int id)
1824{
switch (arg1) {
case P_PID:
printf("P_PID,%d", id);
break;
case P_PGID:
printf("P_PGID,%d", id);
break;
case P_ALL:
printf("P_ALL,<unused>%d", id);
break;
default: /* Should not reach */
printf("<invalid=%d>, <unused>%d", arg1, id);
}
1838}