Home | History | Annotate | Line # | Download | only in kdump
      1 /*	$NetBSD: kdump.c,v 1.153 2026/11/15 22:32:54 christos Exp $	*/
      2 
      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.
     15  * 3. Neither the name of the University nor the names of its contributors
     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/cdefs.h>
     33 #ifndef lint
     34 __COPYRIGHT("@(#) Copyright (c) 1988, 1993\
     35  The Regents of the University of California.  All rights reserved.");
     36 #endif /* not lint */
     37 
     38 #ifndef lint
     39 #if 0
     40 static char sccsid[] = "@(#)kdump.c	8.4 (Berkeley) 4/28/95";
     41 #else
     42 __RCSID("$NetBSD: kdump.c,v 1.153 2026/11/15 22:32:54 christos Exp $");
     43 #endif
     44 #endif /* not lint */
     45 
     46 #include <sys/param.h>
     47 #include <sys/file.h>
     48 #define _KMEMUSER        /* To get the pseudo errors defined */
     49 #include <sys/errno.h>
     50 #undef _KMEMUSER
     51 #include <sys/mman.h>
     52 #include <sys/time.h>
     53 #include <sys/uio.h>
     54 #include <sys/ktrace.h>
     55 #include <sys/ioctl.h>
     56 #include <sys/ptrace.h>
     57 #include <sys/socket.h>
     58 #include <sys/futex.h>
     59 
     60 #include <ctype.h>
     61 #include <err.h>
     62 #include <inttypes.h>
     63 #include <signal.h>
     64 #include <stdbool.h>
     65 #include <stddef.h>
     66 #include <stdio.h>
     67 #include <stdlib.h>
     68 #include <string.h>
     69 #include <unistd.h>
     70 #include <vis.h>
     71 #include <util.h>
     72 
     73 #include <netinet/in.h>
     74 #include <netinet/tcp.h>
     75 
     76 #include "ktrace.h"
     77 #include "setemul.h"
     78 
     79 #include <sys/syscall.h>
     80 
     81 #define	CASERETURN(a)	case a:	return # a
     82 
     83 #define TIMESTAMP_NONE		0x0
     84 #define TIMESTAMP_ABSOLUTE	0x1
     85 #define TIMESTAMP_ELAPSED	0x2
     86 #define TIMESTAMP_RELATIVE	0x4
     87 
     88 static int timestamp, decimal, plain, tail, maxdata = -1, numeric;
     89 static int word_size = 0;
     90 static pid_t do_pid = -1;
     91 static const char *tracefile = NULL;
     92 static struct ktr_header ktr_header;
     93 static int emul_changed = 0;
     94 
     95 #define eqs(s1, s2)	(strcmp((s1), (s2)) == 0)
     96 #define small(v)	(((long)(v) >= 0) && ((long)(v) < 10))
     97 
     98 static const char * const ptrace_ops[] = {
     99 	PT_STRINGS
    100 };
    101 
    102 #ifdef PT_MACHDEP_STRINGS
    103 static const char * const ptrace_machdep_ops[] = { PT_MACHDEP_STRINGS };
    104 #endif
    105 
    106 static const char * const linux_ptrace_ops[] = {
    107 	"PTRACE_TRACEME",
    108 	"PTRACE_PEEKTEXT", "PTRACE_PEEKDATA", "PTRACE_PEEKUSER",
    109 	"PTRACE_POKETEXT", "PTRACE_POKEDATA", "PTRACE_POKEUSER",
    110 	"PTRACE_CONT", "PTRACE_KILL", "PTRACE_SINGLESTEP",
    111 	NULL, NULL,
    112 	"PTRACE_GETREGS", "PTRACE_SETREGS", "PTRACE_GETFPREGS",
    113 	"PTRACE_SETFPREGS", "PTRACE_ATTACH", "PTRACE_DETACH",
    114 	NULL, NULL, NULL, NULL, NULL, NULL,
    115 	"PTRACE_SYSCALL",
    116 };
    117 
    118 static const char default_format[] = { "%n\t%E\t%x\n" };
    119 
    120 static void	fmtprint(const char *, const struct ioctlinfo *ii);
    121 static int	fread_tail(void *, size_t, size_t);
    122 static int	dumpheader(struct ktr_header *);
    123 static int	output_ts(const struct timespec *);
    124 static void	output_long(u_long, int);
    125 static void	ioctldecode(u_long);
    126 static void	ktrsyscall(struct ktr_syscall *);
    127 static void	ktrsysret(struct ktr_sysret *, int);
    128 static void	ktrnamei(char *, int);
    129 static void	ktremul(char *, size_t, size_t);
    130 static void	ktrgenio(struct ktr_genio *, int);
    131 static void	ktrpsig(void *, int);
    132 static void	ktrcsw(struct ktr_csw *);
    133 static void	ktruser(struct ktr_user *, int);
    134 static void	ktrmib(int *, int);
    135 static void	ktrexecfd(struct ktr_execfd *);
    136 static void	ktrsigmask(struct ktr_sigmask *);
    137 static void	usage(void) __dead;
    138 static void	eprint(int);
    139 static void	rprint(register_t);
    140 static const char *signame(long, int);
    141 static void hexdump_buf(const void *, int, int);
    142 static void visdump_buf(const void *, int, int);
    143 static const struct ioctlinfo *find_ioctl(const char *);
    144 
    145 int
    146 main(int argc, char **argv)
    147 {
    148 	unsigned int ktrlen, size;
    149 	int ch;
    150 	void *m;
    151 	int trpoints = 0;
    152 	int trset = 0;
    153 	const char *emul_name = "netbsd";
    154 	const char *format = default_format;
    155 	int col;
    156 	char *cp;
    157 
    158 	setprogname(argv[0]);
    159 
    160 	if (strcmp(getprogname(), "ioctlprint") == 0) {
    161 		const struct ioctlinfo *ii;
    162 		int list = 0;
    163 		int i;
    164 
    165 		while ((ch = getopt(argc, argv, "e:f:l")) != -1)
    166 			switch (ch) {
    167 			case 'e':
    168 				emul_name = optarg;
    169 				break;
    170 			case 'f':
    171 				if (format != default_format)
    172 					errx(1, "Too many formats");
    173 				format = optarg;
    174 				break;
    175 			case 'l':
    176 				list = 1;
    177 				break;
    178 			default:
    179 				usage();
    180 				break;
    181 			}
    182 
    183 		setemul(emul_name, 0, 0);
    184 		argv += optind;
    185 		argc -= optind;
    186 
    187 		if (argc < 1 && !list)
    188 			usage();
    189 
    190 		if (list) {
    191 			for (i = 0; ioctlinfo[i].name != NULL; i++) {
    192 				fmtprint(format, &ioctlinfo[i]);
    193 			}
    194 			return 0;
    195 		}
    196 
    197 		for (i = 0; i < argc; i++) {
    198 			if ((ii = find_ioctl(argv[i])) == NULL) {
    199 				warnx("Can't find ioctl `%s'", argv[i]);
    200 				continue;
    201 			}
    202 			fmtprint(format, ii);
    203 		}
    204 		return 0;
    205 	}
    206 
    207 	timestamp = TIMESTAMP_NONE;
    208 
    209 	while ((ch = getopt(argc, argv, "Ee:f:dlm:Nnp:RTt:xX:")) != -1) {
    210 		switch (ch) {
    211 		case 'E':
    212 			timestamp |= TIMESTAMP_ELAPSED;
    213 			break;
    214 		case 'e':
    215 			emul_name = strdup(optarg); /* it's safer to copy it */
    216 			break;
    217 		case 'f':
    218 			tracefile = optarg;
    219 			break;
    220 		case 'd':
    221 			decimal = 1;
    222 			break;
    223 		case 'l':
    224 			tail = 1;
    225 			break;
    226 		case 'p':
    227 			do_pid = strtoul(optarg, &cp, 0);
    228 			if (*cp != 0)
    229 				errx(1,"invalid number %s", optarg);
    230 			break;
    231 		case 'm':
    232 			maxdata = strtoul(optarg, &cp, 0);
    233 			if (*cp != 0)
    234 				errx(1,"invalid number %s", optarg);
    235 			break;
    236 		case 'N':
    237 			numeric++;
    238 			break;
    239 		case 'n':
    240 			plain++;
    241 			break;
    242 		case 'R':
    243 			timestamp |= TIMESTAMP_RELATIVE;
    244 			break;
    245 		case 'T':
    246 			timestamp |= TIMESTAMP_ABSOLUTE;
    247 			break;
    248 		case 't':
    249 			trset = 1;
    250 			trpoints = getpoints(trpoints, optarg);
    251 			if (trpoints < 0)
    252 				errx(1, "unknown trace point in %s", optarg);
    253 			break;
    254 		case 'x':
    255 			word_size = 1;
    256 			break;
    257 		case 'X':
    258 			word_size = strtoul(optarg, &cp, 0);
    259 			if (*cp != 0 || word_size & (word_size - 1) ||
    260 			    word_size > 16 || word_size <= 0)
    261 				errx(1, "argument to -X must be "
    262 				    "1, 2, 4, 8 or 16");
    263 			break;
    264 		default:
    265 			usage();
    266 		}
    267 	}
    268 	argv += optind;
    269 	argc -= optind;
    270 
    271 	if (!trset)
    272 		trpoints = ALL_POINTS;
    273 
    274 	if (tracefile == NULL) {
    275 		if (argc == 1) {
    276 			tracefile = argv[0];
    277 			argv++;
    278 			argc--;
    279 		} else
    280 			tracefile = DEF_TRACEFILE;
    281 	}
    282 
    283 	if (argc > 0)
    284 		usage();
    285 
    286 	setemul(emul_name, 0, 0);
    287 
    288 	m = malloc(size = 1024);
    289 	if (m == NULL)
    290 		errx(1, "malloc: %s", strerror(ENOMEM));
    291 	if (!freopen(tracefile, "r", stdin))
    292 		err(1, "%s", tracefile);
    293 	while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) {
    294 		if (trpoints & (1 << ktr_header.ktr_type) &&
    295 		    (do_pid == -1 || ktr_header.ktr_pid == do_pid))
    296 			col = dumpheader(&ktr_header);
    297 		else
    298 			col = -1;
    299 		if ((ktrlen = ktr_header.ktr_len) > INT_MAX)
    300 			errx(1, "bogus length 0x%x", ktrlen);
    301 		if (ktrlen > size) {
    302 			while (ktrlen > size)
    303 				size *= 2;
    304 			m = realloc(m, size);
    305 			if (m == NULL)
    306 				errx(1, "realloc: %s", strerror(ENOMEM));
    307 		}
    308 		if (ktrlen && fread_tail(m, ktrlen, 1) == 0)
    309 			errx(1, "data too short");
    310 		if (col == -1)
    311 			continue;
    312 
    313 		/* update context to match currently processed record */
    314 		ectx_sanify(ktr_header.ktr_pid);
    315 
    316 		switch (ktr_header.ktr_type) {
    317 		case KTR_SYSCALL:
    318 			ktrsyscall(m);
    319 			break;
    320 		case KTR_SYSRET:
    321 			ktrsysret(m, ktrlen);
    322 			break;
    323 		case KTR_NAMEI:
    324 			ktrnamei(m, ktrlen);
    325 			break;
    326 		case KTR_GENIO:
    327 			ktrgenio(m, ktrlen);
    328 			break;
    329 		case KTR_PSIG:
    330 			ktrpsig(m, ktrlen);
    331 			break;
    332 		case KTR_CSW:
    333 			ktrcsw(m);
    334 			break;
    335 		case KTR_EMUL:
    336 			ktremul(m, ktrlen, size);
    337 			break;
    338 		case KTR_USER:
    339 			ktruser(m, ktrlen);
    340 			break;
    341 		case KTR_EXEC_ARG:
    342 		case KTR_EXEC_ENV:
    343 			visdump_buf(m, ktrlen, col);
    344 			break;
    345 		case KTR_EXEC_FD:
    346 			ktrexecfd(m);
    347 			break;
    348 		case KTR_MIB:
    349 			ktrmib(m, ktrlen);
    350 			break;
    351 		case KTR_SIGMASK:
    352 			ktrsigmask(m);
    353 			break;
    354 		default:
    355 			putchar('\n');
    356 			hexdump_buf(m, ktrlen, word_size ? word_size : 1);
    357 		}
    358 		if (tail)
    359 			(void)fflush(stdout);
    360 	}
    361 	return (0);
    362 }
    363 
    364 static void
    365 fmtprint(const char *fmt, const struct ioctlinfo *ii)
    366 {
    367 	int c;
    368 
    369 
    370 	while ((c = *fmt++) != '\0') {
    371 		switch (c) {
    372 		default:
    373 			putchar(c);
    374 			continue;
    375 		case '\\':
    376 			switch (c = *fmt) {
    377 				case '\0':
    378 				continue;
    379 			case 'n':
    380 				putchar('\n');
    381 				break;
    382 			case 't':
    383 				putchar('\t');
    384 				break;
    385 			}
    386 			break;
    387 		case '%':
    388 			switch (c = *fmt) {
    389 			case '\0':
    390 				continue;
    391 			case '%':
    392 			default:
    393 				putchar(c);
    394 				break;
    395 			case 'E':
    396 				printf("%s", ii->expr);
    397 				break;
    398 			case 'e':
    399 				ioctldecode(ii->value);
    400 				break;
    401 			case 'n':
    402 				printf("%s", ii->name);
    403 				break;
    404 			case 'x':
    405 				printf("%#lx", ii->value);
    406 				break;
    407 			case 'o':
    408 				printf("%#lo", ii->value);
    409 				break;
    410 			case 'd': case 'i':
    411 				printf("%ld", ii->value);
    412 				break;
    413 			}
    414 			break;
    415 		}
    416 		++fmt;
    417 	}
    418 }
    419 
    420 static int
    421 fread_tail(void *buf, size_t num, size_t size)
    422 {
    423 	int i;
    424 
    425 	while ((i = fread(buf, size, num, stdin)) == 0 && tail) {
    426 		(void)sleep(1);
    427 		clearerr(stdin);
    428 	}
    429 	return (i);
    430 }
    431 
    432 static int
    433 dumpheader(struct ktr_header *kth)
    434 {
    435 	char unknown[64];
    436 	const char *type;
    437 	static struct timespec starttime, prevtime;
    438 	struct timespec temp;
    439 	int col;
    440 
    441 	if (__predict_false(kth->ktr_version != KTRFAC_VERSION(KTRFACv2)))
    442 		errx(EXIT_FAILURE, "Unsupported ktrace version %x",
    443 		     kth->ktr_version);
    444 
    445 	switch (kth->ktr_type) {
    446 	case KTR_SYSCALL:
    447 		type = "CALL";
    448 		break;
    449 	case KTR_SYSRET:
    450 		type = "RET ";
    451 		break;
    452 	case KTR_NAMEI:
    453 		type = "NAMI";
    454 		break;
    455 	case KTR_GENIO:
    456 		type = "GIO ";
    457 		break;
    458 	case KTR_PSIG:
    459 		type = "PSIG";
    460 		break;
    461 	case KTR_CSW:
    462 		type = "CSW ";
    463 		break;
    464 	case KTR_EMUL:
    465 		type = "EMUL";
    466 		break;
    467 	case KTR_USER:
    468 		type = "MISC";
    469 		break;
    470 	case KTR_EXEC_ENV:
    471 		type = "ENV";
    472 		break;
    473 	case KTR_EXEC_ARG:
    474 		type = "ARG";
    475 		break;
    476 	case KTR_EXEC_FD:
    477 		type = "FD";
    478 		break;
    479 	case KTR_SAUPCALL:
    480 		type = "SAU";
    481 		break;
    482 	case KTR_MIB:
    483 		type = "MIB";
    484 		break;
    485 	case KTR_SIGMASK:
    486 		type = "MASK";
    487 		break;
    488 	default:
    489 		(void)snprintf(unknown, sizeof(unknown), "UNKNOWN(%d)",
    490 		    kth->ktr_type);
    491 		type = unknown;
    492 	}
    493 
    494 	col = printf("%6d %6d ", kth->ktr_pid, kth->ktr_lid);
    495 	col += printf("%-8.*s ", MAXCOMLEN, kth->ktr_comm);
    496 	if (timestamp) {
    497 		if (timestamp & TIMESTAMP_ABSOLUTE) {
    498 			temp.tv_sec = kth->ktr_ts.tv_sec;
    499 			temp.tv_nsec = kth->ktr_ts.tv_nsec;
    500 			col += output_ts(&temp);
    501 		}
    502 
    503 		if (timestamp & TIMESTAMP_ELAPSED) {
    504 			if (starttime.tv_sec == 0) {
    505 				starttime.tv_sec = kth->ktr_ts.tv_sec;
    506 				starttime.tv_nsec = kth->ktr_ts.tv_nsec;
    507 				temp.tv_sec = temp.tv_nsec = 0;
    508 			} else
    509 				timespecsub(&kth->ktr_ts, &starttime, &temp);
    510 			col += output_ts(&temp);
    511 		}
    512 
    513 		if (timestamp & TIMESTAMP_RELATIVE) {
    514 			if (prevtime.tv_sec == 0)
    515 				temp.tv_sec = temp.tv_nsec = 0;
    516 			else
    517 				timespecsub(&kth->ktr_ts, &prevtime, &temp);
    518 			prevtime.tv_sec = kth->ktr_ts.tv_sec;
    519 			prevtime.tv_nsec = kth->ktr_ts.tv_nsec;
    520 			col += output_ts(&temp);
    521 		}
    522 	}
    523 	col += printf("%-4s  ", type);
    524 	return col;
    525 }
    526 
    527 static int
    528 output_ts(const struct timespec *ts)
    529 {
    530 	int col;
    531 
    532 	if (__predict_true(ts->tv_sec >= 0))
    533 	    col = printf("%lld.%09ld ",
    534 			 (long long)ts->tv_sec, (long)ts->tv_nsec);
    535 	else {
    536 	    /*
    537 	     * The time represented by a timespec object ts is always
    538 	     *
    539 	     *   ts.tv_sec + ts.tv_nsec * 1e-9
    540 	     *
    541 	     * where ts.tv_sec may be negative but ts.tv_nsec is
    542 	     * always in [0, 1e9).  So, for example, -1/4 second is
    543 	     * represented by the struct timespec object
    544 	     *
    545 	     *   { .tv_sec = -1, .tv_nsec = 750000000 }
    546 	     */
    547 	    const struct timespec zero_ts = { 0, 0 };
    548 	    struct timespec abs_ts;
    549 	    timespecsub(&zero_ts, ts, &abs_ts);
    550 	    col = printf("-%lld.%09ld ",
    551 			 (long long)abs_ts.tv_sec, (long)abs_ts.tv_nsec);
    552 	}
    553 	return col;
    554 }
    555 
    556 static void
    557 output_long(u_long it, int as_x)
    558 {
    559 	if (cur_emul->flags & EMUL_FLAG_NETBSD32)
    560 		printf(as_x ? "%#x" : "%d", (u_int)it);
    561 	else
    562 		printf(as_x ? "%#lx" : "%ld", it);
    563 }
    564 
    565 static const char *
    566 fcntlname(u_long cmd)
    567 {
    568 	if (strcmp(cur_emul->name, "netbsd") != 0)
    569 		return NULL;
    570 	switch (cmd) {
    571 	CASERETURN(F_DUPFD);
    572 	CASERETURN(F_GETFD);
    573 	CASERETURN(F_SETFD);
    574 	CASERETURN(F_GETFL);
    575 	CASERETURN(F_SETFL);
    576 	CASERETURN(F_GETOWN);
    577 	CASERETURN(F_SETOWN);
    578 	CASERETURN(F_GETLK);
    579 	CASERETURN(F_SETLK);
    580 	CASERETURN(F_SETLKW);
    581 	CASERETURN(F_CLOSEM);
    582 	CASERETURN(F_MAXFD);
    583 	CASERETURN(F_DUPFD_CLOEXEC);
    584 	CASERETURN(F_GETNOSIGPIPE);
    585 	CASERETURN(F_SETNOSIGPIPE);
    586 	default:
    587 		return NULL;
    588 	}
    589 }
    590 
    591 static const char *
    592 sockproto(register_t proto)
    593 {
    594 	if (strcmp(cur_emul->name, "netbsd") != 0)
    595 		return NULL;
    596 	switch (proto) {
    597 	CASERETURN(IPPROTO_IP);
    598 	CASERETURN(IPPROTO_ICMP);
    599 	CASERETURN(IPPROTO_IGMP);
    600 	CASERETURN(IPPROTO_GGP);
    601 //	CASERETURN(IPPROTO_IPV4);
    602 	CASERETURN(IPPROTO_IPIP);
    603 	CASERETURN(IPPROTO_TCP);
    604 	CASERETURN(IPPROTO_EGP);
    605 	CASERETURN(IPPROTO_PUP);
    606 	CASERETURN(IPPROTO_UDP);
    607 	CASERETURN(IPPROTO_IDP);
    608 	CASERETURN(IPPROTO_TP);
    609 	CASERETURN(IPPROTO_DCCP);
    610 	CASERETURN(IPPROTO_IPV6);
    611 	CASERETURN(IPPROTO_ROUTING);
    612 	CASERETURN(IPPROTO_FRAGMENT);
    613 	CASERETURN(IPPROTO_RSVP);
    614 	CASERETURN(IPPROTO_GRE);
    615 	CASERETURN(IPPROTO_ESP);
    616 	CASERETURN(IPPROTO_AH);
    617 	CASERETURN(IPPROTO_MOBILE);
    618 //	CASERETURN(IPPROTO_IPV6_ICMP);
    619 	CASERETURN(IPPROTO_ICMPV6);
    620 	CASERETURN(IPPROTO_NONE);
    621 	CASERETURN(IPPROTO_DSTOPTS);
    622 	CASERETURN(IPPROTO_EON);
    623 	CASERETURN(IPPROTO_ETHERIP);
    624 	CASERETURN(IPPROTO_ENCAP);
    625 	CASERETURN(IPPROTO_PIM);
    626 	CASERETURN(IPPROTO_IPCOMP);
    627 	CASERETURN(IPPROTO_VRRP);
    628 //	CASERETURN(IPPROTO_CARP);
    629 	CASERETURN(IPPROTO_L2TP);
    630 	CASERETURN(IPPROTO_SCTP);
    631 	CASERETURN(IPPROTO_PFSYNC);
    632 	CASERETURN(IPPROTO_RAW);
    633 	CASERETURN(IPPROTO_MAX);
    634 	CASERETURN(IPPROTO_DONE);
    635 	CASERETURN(SOL_SOCKET);
    636 	default:
    637 		return NULL;
    638 	}
    639 }
    640 
    641 static const char *
    642 sockoptname(register_t optname)
    643 {
    644 	if (strcmp(cur_emul->name, "netbsd") != 0)
    645 		return NULL;
    646 	switch (optname) {
    647 	CASERETURN(SO_ACCEPTCONN);
    648 	CASERETURN(SO_ACCEPTFILTER);
    649 	CASERETURN(SO_BROADCAST);
    650 	CASERETURN(SO_DEBUG);
    651 	CASERETURN(SO_DONTROUTE);
    652 	CASERETURN(SO_ERROR);
    653 	CASERETURN(SO_KEEPALIVE);
    654 	CASERETURN(SO_LINGER);
    655 	CASERETURN(SO_NOHEADER);
    656 	CASERETURN(SO_NOSIGPIPE);
    657 	CASERETURN(SO_OOBINLINE);
    658 	CASERETURN(SO_OVERFLOWED);
    659 	CASERETURN(SO_RCVBUF);
    660 	CASERETURN(SO_RCVLOWAT);
    661 	CASERETURN(SO_RCVTIMEO);
    662 	CASERETURN(SO_RERROR);
    663 	CASERETURN(SO_REUSEADDR);
    664 	CASERETURN(SO_REUSEPORT);
    665 	CASERETURN(SO_SNDBUF);
    666 	CASERETURN(SO_SNDLOWAT);
    667 	CASERETURN(SO_SNDTIMEO);
    668 	CASERETURN(SO_TIMESTAMP);
    669 	CASERETURN(SO_TYPE);
    670 	CASERETURN(SO_USELOOPBACK);
    671 	default:
    672 		return NULL;
    673 	}
    674 }
    675 
    676 static const char *
    677 tcpoptname(register_t optname)
    678 {
    679 	if (strcmp(cur_emul->name, "netbsd") != 0)
    680 		return NULL;
    681 	switch (optname) {
    682 	CASERETURN(TCP_NODELAY);
    683 	CASERETURN(TCP_MAXSEG);
    684 	CASERETURN(TCP_MD5SIG);
    685 	CASERETURN(TCP_KEEPIDLE);
    686 	CASERETURN(TCP_KEEPINTVL);
    687 	CASERETURN(TCP_KEEPCNT);
    688 	CASERETURN(TCP_KEEPINIT);
    689 	CASERETURN(TCP_INFO);
    690 	default:
    691 		return NULL;
    692 	}
    693 }
    694 
    695 static const char *
    696 ipoptname(register_t optname)
    697 {
    698 	if (strcmp(cur_emul->name, "netbsd") != 0)
    699 		return NULL;
    700 	switch (optname) {
    701 	CASERETURN(IP_OPTIONS);
    702 	CASERETURN(IP_HDRINCL);
    703 	CASERETURN(IP_TOS);
    704 	CASERETURN(IP_TTL);
    705 	CASERETURN(IP_RECVOPTS);
    706 	CASERETURN(IP_RECVRETOPTS);
    707 	CASERETURN(IP_RECVDSTADDR);
    708 	CASERETURN(IP_RETOPTS);
    709 	CASERETURN(IP_MULTICAST_IF);
    710 	CASERETURN(IP_MULTICAST_TTL);
    711 	CASERETURN(IP_MULTICAST_LOOP);
    712 	CASERETURN(IP_ADD_MEMBERSHIP);
    713 	CASERETURN(IP_DROP_MEMBERSHIP);
    714 	CASERETURN(IP_PORTALGO);
    715 	CASERETURN(IP_PORTRANGE);
    716 	CASERETURN(IP_RECVIF);
    717 	CASERETURN(IP_ERRORMTU);
    718 	CASERETURN(IP_IPSEC_POLICY);
    719 	CASERETURN(IP_RECVTTL);
    720 	CASERETURN(IP_MINTTL);
    721 	CASERETURN(IP_PKTINFO);
    722 	CASERETURN(IP_RECVPKTINFO);
    723 	CASERETURN(IP_BINDANY);
    724 	default:
    725 		return NULL;
    726 	}
    727 }
    728 
    729 static void
    730 ioctldecode(u_long cmd)
    731 {
    732 	char dirbuf[4], *dir = dirbuf;
    733 	int c;
    734 
    735 	if (~0xffffffffULL & cmd) {
    736 		output_long(cmd, 1);
    737 		return;
    738 	}
    739 
    740 	if (cmd & IOC_IN)
    741 		*dir++ = 'W';
    742 	if (cmd & IOC_OUT)
    743 		*dir++ = 'R';
    744 	*dir = '\0';
    745 
    746 	c = (cmd >> 8) & 0xff;
    747 	if (isprint(c))
    748 		printf("_IO%s('%c',", dirbuf, c);
    749 	else
    750 		printf("_IO%s(0x%02x,", dirbuf, c);
    751 	output_long(cmd & 0xff, decimal == 0);
    752 	if ((cmd & IOC_VOID) == 0) {
    753 		putchar(',');
    754 		output_long(IOCPARM_LEN(cmd), decimal == 0);
    755 	}
    756 	putchar(')');
    757 }
    758 
    759 static void
    760 putprot(int pr)
    761 {
    762 	const char *s = "";
    763 
    764 	if (pr == PROT_NONE) {
    765 		fputs("PROT_NONE", stdout);
    766 		return;
    767 	}
    768 
    769 	if (pr & PROT_READ) {
    770 		fputs("PROT_READ", stdout);
    771 		s = "|";
    772 		pr &= ~PROT_READ;
    773 	}
    774 
    775 	if (pr & PROT_WRITE) {
    776 		printf("%sPROT_WRITE", s);
    777 		pr &= ~PROT_WRITE;
    778 		s = "|";
    779 	}
    780 	if (pr & PROT_EXEC) {
    781 		printf("%sPROT_EXEC", s);
    782 		pr &= ~PROT_EXEC;
    783 		s = "|";
    784 	}
    785 	if (pr) {
    786 		printf("%s%#lx", s, (long)pr);
    787 	}
    788 }
    789 
    790 static const char *
    791 futex_op_name(u_long op)
    792 {
    793 	switch (op & FUTEX_CMD_MASK) {
    794 	CASERETURN(FUTEX_WAIT);
    795 	CASERETURN(FUTEX_WAKE);
    796 	CASERETURN(FUTEX_FD);
    797 	CASERETURN(FUTEX_REQUEUE);
    798 	CASERETURN(FUTEX_CMP_REQUEUE);
    799 	CASERETURN(FUTEX_WAKE_OP);
    800 	CASERETURN(FUTEX_LOCK_PI);
    801 	CASERETURN(FUTEX_UNLOCK_PI);
    802 	CASERETURN(FUTEX_TRYLOCK_PI);
    803 	CASERETURN(FUTEX_WAIT_BITSET);
    804 	CASERETURN(FUTEX_WAKE_BITSET);
    805 	CASERETURN(FUTEX_WAIT_REQUEUE_PI);
    806 	CASERETURN(FUTEX_CMP_REQUEUE_PI);
    807 	default:
    808 		return NULL;
    809 	}
    810 #undef CASERETURN
    811 }
    812 
    813 static void
    814 futexput(u_long op)
    815 {
    816 	const char *opname = futex_op_name(op);
    817 	const char *s = "";
    818 
    819 	if (opname == NULL) {
    820 		printf("%#lx", op & (u_long)FUTEX_CMD_MASK);
    821 	} else {
    822 		fputs(opname, stdout);
    823 	}
    824 	op &= ~FUTEX_CMD_MASK;
    825 
    826 	if (op & FUTEX_PRIVATE_FLAG) {
    827 		fputs("_PRIVATE", stdout);
    828 		op &= ~FUTEX_PRIVATE_FLAG;
    829 	}
    830 
    831 	if (op & FUTEX_CLOCK_REALTIME) {
    832 		printf("%sFUTEX_CLOCK_REALTIME", s);
    833 		op &= ~FUTEX_CLOCK_REALTIME;
    834 		s = "|";
    835 	}
    836 
    837 	if (op) {
    838 		printf("%s%#lx", s, op);
    839 	}
    840 }
    841 
    842 static void
    843 ktrsyscall(struct ktr_syscall *ktr)
    844 {
    845 	int argcount;
    846 	const struct emulation *emul = cur_emul;
    847 	register_t *ap;
    848 	char c;
    849 	const char *cp;
    850 	const char *sys_name;
    851 
    852 	argcount = ktr->ktr_argsize / sizeof (*ap);
    853 
    854 	emul_changed = 0;
    855 
    856 	if (numeric ||
    857 	    ((ktr->ktr_code >= emul->nsysnames || ktr->ktr_code < 0))) {
    858 		sys_name = "?";
    859 		(void)printf("[%d]", ktr->ktr_code);
    860 	} else {
    861 		sys_name = emul->sysnames[ktr->ktr_code];
    862 		(void)printf("%s", sys_name);
    863 	}
    864 #define NETBSD32_	"netbsd32_"
    865 	if (cur_emul->flags & EMUL_FLAG_NETBSD32) {
    866 		size_t len = strlen(NETBSD32_);
    867 		if (strncmp(sys_name, NETBSD32_, len) == 0)
    868 			sys_name += len;
    869 	}
    870 #undef NETBSD32_
    871 
    872 	ap = (register_t *)((char *)ktr + sizeof(struct ktr_syscall));
    873 	if (argcount) {
    874 		c = '(';
    875 		if (plain) {
    876 			;
    877 
    878 		} else if (strcmp(sys_name, "exit_group") == 0 ||
    879 			   (strcmp(emul->name, "linux") != 0 &&
    880 			    strcmp(emul->name, "linux32") != 0 &&
    881 			    strcmp(sys_name, "exit") == 0)) {
    882 			ectx_delete();
    883 
    884 		} else if (strcmp(sys_name, "ioctl") == 0 && argcount >= 2) {
    885 			(void)putchar('(');
    886 			output_long((long)*ap, !(decimal || small(*ap)));
    887 			ap++;
    888 			argcount--;
    889 			if ((cp = ioctlname(*ap)) != NULL)
    890 				(void)printf(",%s", cp);
    891 			else {
    892 				(void)putchar(',');
    893 				ioctldecode(*ap);
    894 			}
    895 			ap++;
    896 			argcount--;
    897 			c = ',';
    898 
    899 		} else if (strcmp(sys_name, "fcntl") == 0 && argcount >= 2) {
    900 			(void)putchar('(');
    901 			output_long((long)*ap, !(decimal || small(*ap)));
    902 			ap++;
    903 			argcount--;
    904 			if ((cp = fcntlname(*ap)) != NULL)
    905 				(void)printf(",%s", cp);
    906 			else {
    907 				(void)printf(",%#lx", (unsigned long)*ap);
    908 			}
    909 			ap++;
    910 			argcount--;
    911 			c = ',';
    912 
    913 		} else if ((strcmp(sys_name, "setsockopt") == 0 ||
    914 		    strcmp(sys_name, "getsockopt") == 0 ||
    915 		    strcmp(sys_name, "getsockopt2") == 0) && argcount >= 3) {
    916 			(void)putchar('(');
    917 			output_long((long)*ap, !(decimal || small(*ap)));
    918 			ap++;
    919 			argcount--;
    920 			register_t level = *ap;
    921 			if ((cp = sockproto(level)) != NULL) {
    922 				(void)printf(",%s", cp);
    923 			} else {
    924 				(void)putchar(',');
    925 				output_long((long)*ap,
    926 				    !(decimal || small(*ap)));
    927 			}
    928 			ap++;
    929 			argcount--;
    930 			const char *(*f)(register_t);
    931 			switch (level) {
    932 			case SOL_SOCKET:
    933 				f = sockoptname;
    934 				break;
    935 			case IPPROTO_IP:
    936 				f = ipoptname;
    937 				break;
    938 			case IPPROTO_TCP:
    939 				f = tcpoptname;
    940 				break;
    941 			default:
    942 				f = NULL;
    943 				break;
    944 			}
    945 
    946 			if (f && (cp = (*f)(*ap)) != NULL)
    947 				(void)printf(",%s", cp);
    948 			else {
    949 				(void)putchar(',');
    950 				output_long((long)*ap,
    951 				    !(decimal || small(*ap)));
    952 			}
    953 			ap++;
    954 			argcount--;
    955 			c = ',';
    956 
    957 		} else if ((strcmp(sys_name, "futex") == 0 ||
    958 			    strcmp(sys_name, "__futex") == 0) &&
    959 			   argcount > 2) {
    960 			/*
    961 			 * Linux name is "futex".
    962 			 * Native name is "__futex".
    963 			 * Both have the same op argument.
    964 			 */
    965 			(void)putchar('(');
    966 			output_long((long)*ap, 1);
    967 			(void)putchar(',');
    968 			ap++;
    969 			argcount--;
    970 			futexput(*ap);
    971 			ap++;
    972 			argcount--;
    973 			c = ',';
    974 
    975 		} else if ((strstr(sys_name, "sigaction") != NULL ||
    976 		    strstr(sys_name, "sigvec") != NULL) && argcount >= 1) {
    977 			(void)printf("(SIG%s", signame(ap[0], 1));
    978 			ap += 1;
    979 			argcount -= 1;
    980 			c = ',';
    981 
    982 		} else if ((strcmp(sys_name, "kill") == 0 ||
    983 		    strcmp(sys_name, "killpg") == 0) && argcount >= 2) {
    984 			putchar('(');
    985 			output_long((long)ap[0], !(decimal || small(*ap)));
    986 			(void)printf(", SIG%s", signame(ap[1], 1));
    987 			ap += 2;
    988 			argcount -= 2;
    989 			c = ',';
    990 		} else if (strcmp(sys_name, "mprotect") == 0 && argcount >= 3) {
    991 			putchar('(');
    992 			output_long((long)ap[0], !(decimal || small(ap[0])));
    993 			c = ',';
    994 			putchar(c);
    995 			output_long((long)ap[1], !(decimal || small(ap[1])));
    996 			putchar(c);
    997 			putprot(ap[2]);
    998 			ap += 3;
    999 			argcount -= 3;
   1000 			c = ',';
   1001 		} else if (strcmp(sys_name, "mmap") == 0 && argcount >= 6) {
   1002 			char buf[1024];
   1003 			putchar('(');
   1004 			output_long((long)ap[0], !(decimal || small(ap[0])));
   1005 			c = ',';
   1006 			putchar(c);
   1007 			output_long((long)ap[1], !(decimal || small(ap[1])));
   1008 			putchar(c);
   1009 			putprot(ap[2]);
   1010 			snprintb(buf, sizeof(buf), MAP_FMT, ap[3]);
   1011 			printf(",%s", buf);
   1012 			ap += 4;
   1013 			argcount -= 4;
   1014 			c = ',';
   1015 		} else if (strcmp(sys_name, "ptrace") == 0 && argcount >= 1) {
   1016 			putchar('(');
   1017 			if (strcmp(emul->name, "linux") == 0 ||
   1018 			    strcmp(emul->name, "linux32") == 0) {
   1019 				if ((long)*ap >= 0 && *ap <
   1020 				    (register_t)(sizeof(linux_ptrace_ops) /
   1021 				    sizeof(linux_ptrace_ops[0])))
   1022 					(void)printf("%s",
   1023 					    linux_ptrace_ops[*ap]);
   1024 				else
   1025 					output_long((long)*ap, 1);
   1026 			} else {
   1027 				if ((long)*ap >= 0 && *ap < (register_t)
   1028 				    __arraycount(ptrace_ops))
   1029 					(void)printf("%s", ptrace_ops[*ap]);
   1030 #ifdef PT_MACHDEP_STRINGS
   1031 				else if (*ap >= PT_FIRSTMACH &&
   1032 				    *ap - PT_FIRSTMACH < (register_t)
   1033 				    __arraycount(ptrace_machdep_ops))
   1034 					(void)printf("%s", ptrace_machdep_ops[*ap - PT_FIRSTMACH]);
   1035 #endif
   1036 				else
   1037 					output_long((long)*ap, 1);
   1038 			}
   1039 			ap++;
   1040 			argcount--;
   1041 			c = ',';
   1042 
   1043 		}
   1044 		while (argcount > 0) {
   1045 			putchar(c);
   1046 			output_long((long)*ap, !(decimal || small(*ap)));
   1047 			ap++;
   1048 			argcount--;
   1049 			c = ',';
   1050 		}
   1051 		(void)putchar(')');
   1052 	}
   1053 	(void)putchar('\n');
   1054 }
   1055 
   1056 static void
   1057 ktrsysret(struct ktr_sysret *ktr, int len)
   1058 {
   1059 	const struct emulation *emul;
   1060 	int error = ktr->ktr_error;
   1061 	int code = ktr->ktr_code;
   1062 
   1063 	if (emul_changed)  {
   1064 		/* In order to get system call name right in execve return */
   1065 		emul = prev_emul;
   1066 		emul_changed = 0;
   1067 	} else
   1068 		emul = cur_emul;
   1069 
   1070 	if (numeric || ((code >= emul->nsysnames || code < 0 || plain > 1)))
   1071 		(void)printf("[%d] ", code);
   1072 	else
   1073 		(void)printf("%s ", emul->sysnames[code]);
   1074 
   1075 	switch (error) {
   1076 	case 0:
   1077 		rprint(ktr->ktr_retval);
   1078 		if (len > (int)offsetof(struct ktr_sysret, ktr_retval_1) &&
   1079 		    ktr->ktr_retval_1 != 0) {
   1080 			(void)printf(", ");
   1081 			rprint(ktr->ktr_retval_1);
   1082 		}
   1083 		break;
   1084 
   1085 	default:
   1086 		eprint(error);
   1087 		break;
   1088 	}
   1089 	(void)putchar('\n');
   1090 }
   1091 
   1092 static void
   1093 ktrexecfd(struct ktr_execfd *ktr)
   1094 {
   1095 	static const char *dnames[] = { DTYPE_NAMES };
   1096 	if (ktr->ktr_dtype < __arraycount(dnames))
   1097 		printf("%s %d\n", dnames[ktr->ktr_dtype], ktr->ktr_fd);
   1098 	else
   1099 		printf("UNKNOWN(%u) %d\n", ktr->ktr_dtype, ktr->ktr_fd);
   1100 }
   1101 
   1102 static int
   1103 psigset(char *buf, size_t size, const sigset_t *set)
   1104 {
   1105 	size_t pos = 0;
   1106 	bool first = true;
   1107 	bool in_range = false;
   1108 	int range_start = 0;
   1109 	int ret;
   1110 
   1111 	for (int sig = 1; sig < NSIG; sig++) {
   1112 		if (!sigismember(set, sig)) {
   1113 			in_range = false;
   1114 			continue;
   1115 		}
   1116 
   1117 		if (!in_range) {
   1118 			ret = snprintf(buf + pos, size - pos, "%s%d",
   1119 			    first ? "" : ",", sig);
   1120 			if ((size_t)ret >= size - pos)
   1121 				return -1;
   1122 			pos += ret;
   1123 			range_start = sig;
   1124 			in_range = true;
   1125 			first = false;
   1126 		}
   1127 
   1128 		bool isnextset = sig < NSIG - 1 && sigismember(set, sig + 1);
   1129 		if (!isnextset && sig > range_start) {
   1130 			ret = snprintf(buf + pos, size - pos, "-%d", sig);
   1131 			if ((size_t)ret >= size - pos)
   1132 				return -1;
   1133 			pos += ret;
   1134 			in_range = false;
   1135 		}
   1136 	}
   1137 
   1138 	if (first && size > 0)
   1139 		buf[0] = '\0';
   1140 
   1141 	return pos < size ? (int)pos : -1;
   1142 }
   1143 
   1144 static void
   1145 ktrsigmask(struct ktr_sigmask *ktr)
   1146 {
   1147 	static const char * const how[] = {
   1148 		"*SIG_ZERO*", "SIG_BLOCK", "SIG_UNBLOCK", "SIG_SETMASK"
   1149 	};
   1150 	char new[512], old[512], res[512];
   1151 
   1152 	psigset(new, sizeof(new), &ktr->ktr_nset);
   1153 	psigset(old, sizeof(old), &ktr->ktr_oset);
   1154 	psigset(res, sizeof(res), &ktr->ktr_rset);
   1155 	printf("%s([%s]) [%s] -> [%s]\n",
   1156 	    how[ktr->ktr_how & 3], new, old, res);
   1157 }
   1158 
   1159 static void
   1160 rprint(register_t ret)
   1161 {
   1162 
   1163 	if (!plain) {
   1164 		output_long(ret, 0);
   1165 		if (!small(ret)) {
   1166 			putchar('/');
   1167 			output_long(ret, 1);
   1168 		}
   1169 	} else {
   1170 		output_long(ret, !(decimal || small(ret)));
   1171 	}
   1172 }
   1173 
   1174 /*
   1175  * We print the original emulation's error numerically, but we
   1176  * translate it to netbsd to print it symbolically.
   1177  */
   1178 static void
   1179 eprint(int e)
   1180 {
   1181 	int i = e;
   1182 
   1183 	if (cur_emul->errnomap) {
   1184 
   1185 		/* No remapping for ERESTART and EJUSTRETURN */
   1186 		/* Kludge for linux that has negative error numbers */
   1187 		if (cur_emul->errnomap[2] > 0 && e < 0)
   1188 			goto normal;
   1189 
   1190 		for (i = 0; i < cur_emul->nerrnomap; i++)
   1191 			if (e == cur_emul->errnomap[i])
   1192 				break;
   1193 
   1194 		if (i == cur_emul->nerrnomap) {
   1195 			printf("-1 unknown errno %d", e);
   1196 			return;
   1197 		}
   1198 	}
   1199 
   1200 normal:
   1201 	switch (i) {
   1202 	case ERESTART:
   1203 		(void)printf("RESTART");
   1204 		break;
   1205 
   1206 	case EJUSTRETURN:
   1207 		(void)printf("JUSTRETURN");
   1208 		break;
   1209 
   1210 	default:
   1211 		(void)printf("-1 errno %d", e);
   1212 		if (!plain)
   1213 			(void)printf(" %s", strerror(i));
   1214 	}
   1215 }
   1216 
   1217 static void
   1218 ktrnamei(char *cp, int len)
   1219 {
   1220 
   1221 	(void)printf("\"%.*s\"\n", len, cp);
   1222 }
   1223 
   1224 static void
   1225 ktremul(char *name, size_t len, size_t bufsize)
   1226 {
   1227 
   1228 	if (len >= bufsize)
   1229 		len = bufsize - 1;
   1230 
   1231 	name[len] = '\0';
   1232 	setemul(name, ktr_header.ktr_pid, 1);
   1233 	emul_changed = 1;
   1234 
   1235 	(void)printf("\"%s\"\n", name);
   1236 }
   1237 
   1238 static void
   1239 hexdump_buf(const void *vdp, int datalen, int word_sz)
   1240 {
   1241 	const char hex[] = "0123456789abcdef";
   1242 	char chars[16], prev[16];
   1243 	char bytes[16 * 3 + 4];
   1244 	const unsigned char *dp = vdp;
   1245 	const unsigned char *datalim = dp + datalen;
   1246 	const unsigned char *line_end;
   1247 	int off, l = 0, c;
   1248 	char *cp, *bp;
   1249 	int divmask = word_sz - 1;	/* block size in bytes */
   1250 	int gdelim = 3;			/* gap between blocks */
   1251 	int bsize = 2;			/* increment for each byte */
   1252 	int width;
   1253 	int dupl = 0;
   1254 #if _BYTE_ORDER == _LITTLE_ENDIAN
   1255 	int bswap = word_sz - 1;
   1256 #else
   1257 #define	bswap 0
   1258 #endif
   1259 
   1260 	switch (word_sz) {
   1261 	case 2:
   1262 		gdelim = 2;
   1263 		break;
   1264 	case 1:
   1265 		divmask = 7;
   1266 		bsize = 3;
   1267 		gdelim = 1;
   1268 		break;
   1269 	default:
   1270 		break;
   1271 	}
   1272 	width = 16 * bsize + (16 / (divmask + 1)) * gdelim;
   1273 	if (word_sz != 1)
   1274 		width += 2;
   1275 
   1276 	for (off = 0; dp < datalim; off += l) {
   1277 		memset(bytes, ' ', sizeof bytes);
   1278 		line_end = dp + 16;
   1279 		if (line_end >= datalim) {
   1280 			line_end = datalim;
   1281 			dupl |= 1;	/* need to print */
   1282 		} else {
   1283 			if (dupl == 0 || memcmp(dp, prev, sizeof chars))
   1284 				dupl |= 1;
   1285 		}
   1286 
   1287 		if (!(dupl & 1)) {
   1288 			/* This is a duplicate of the line above, count 'em */
   1289 			dupl += 2;
   1290 			dp = line_end;
   1291 			continue;
   1292 		}
   1293 
   1294 		if (dupl > 3) {
   1295 			/* previous line as a duplicate */
   1296 			if (dupl == 5)
   1297 				/* Only one duplicate, print line */
   1298 				printf("\t%-5.3x%.*s%.*s\n",
   1299 					off - l, width, bytes, l, chars);
   1300 			else
   1301 				printf("\t%.*s\n",
   1302 					snprintf(NULL, 0, "%3x", off), "*****");
   1303 		}
   1304 
   1305 		for (l = 0, bp = bytes, cp = chars; dp < line_end; l++) {
   1306 			c = *dp++;
   1307 			prev[l] = c;
   1308 			if ((l & divmask) == 0)
   1309 				bp += gdelim;
   1310 			bp[(l ^ bswap) * bsize] = hex[c >> 4];
   1311 			bp[(l ^ bswap) * bsize + 1] = hex[c & 0xf];
   1312 			*cp++ = isgraph(c) ? c : '.';
   1313 		}
   1314 
   1315 		printf("\t%-5.3x%.*s%.*s\n", off, width, bytes, l, chars);
   1316 		dupl = 2;
   1317 	}
   1318 }
   1319 
   1320 static void
   1321 visdump_buf(const void *vdp, int datalen, int col)
   1322 {
   1323 	const unsigned char *dp = vdp;
   1324 	char *cp;
   1325 	int width;
   1326 	char visbuf[5];
   1327 	static int screenwidth = 0;
   1328 
   1329 	if (screenwidth == 0) {
   1330 		struct winsize ws;
   1331 
   1332 		if (!plain && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 &&
   1333 		    ws.ws_col > 8)
   1334 			screenwidth = ws.ws_col;
   1335 		else
   1336 			screenwidth = 80;
   1337 	}
   1338 
   1339 	(void)printf("\"");
   1340 	col++;
   1341 	for (; datalen > 0; datalen--, dp++) {
   1342 		(void)svis(visbuf, *dp, VIS_CSTYLE,
   1343 		    datalen > 1 ? *(dp + 1) : 0, "\"\n");
   1344 		cp = visbuf;
   1345 		/*
   1346 		 * Keep track of printables and
   1347 		 * space chars (like fold(1)).
   1348 		 */
   1349 		if (col == 0) {
   1350 			(void)putchar('\t');
   1351 			col = 8;
   1352 		}
   1353 		switch (*cp) {
   1354 		case '\n':
   1355 			col = 0;
   1356 			(void)putchar('\n');
   1357 			continue;
   1358 		case '\t':
   1359 			width = 8 - (col & 07);
   1360 			break;
   1361 		default:
   1362 			width = strlen(cp);
   1363 		}
   1364 		if (col + width > (screenwidth - 2)) {
   1365 			(void)printf("\\\n\t");
   1366 			col = 8;
   1367 			if (*cp == '\t')
   1368 				width = 8;
   1369 		}
   1370 		col += width;
   1371 		do {
   1372 			(void)putchar(*cp++);
   1373 		} while (*cp);
   1374 	}
   1375 	if (col == 0)
   1376 		(void)printf("       ");
   1377 	(void)printf("\"\n");
   1378 }
   1379 
   1380 static void
   1381 ktrgenio(struct ktr_genio *ktr, int len)
   1382 {
   1383 	int datalen = len - sizeof (struct ktr_genio);
   1384 	char *dp = (char *)ktr + sizeof (struct ktr_genio);
   1385 
   1386 	if (ktr->ktr_fd != -1)
   1387 		printf("fd %d ", ktr->ktr_fd);
   1388 	printf("%s %d bytes\n",
   1389 	    ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen);
   1390 	if (maxdata == 0)
   1391 		return;
   1392 	if (maxdata > 0 && datalen > maxdata)
   1393 		datalen = maxdata;
   1394 	if (word_size) {
   1395 		hexdump_buf(dp, datalen, word_size);
   1396 		return;
   1397 	}
   1398 	(void)printf("       ");
   1399 	visdump_buf(dp, datalen, 7);
   1400 }
   1401 
   1402 static void
   1403 ktrpsig(void *v, int len)
   1404 {
   1405 	struct {
   1406 		struct ktr_psig ps;
   1407 		siginfo_t si;
   1408 	} *psig = v;
   1409 	siginfo_t *si = &psig->si;
   1410 	const char *code;
   1411 
   1412 	(void)printf("SIG%s ", signame(psig->ps.signo, 0));
   1413 	if (psig->ps.action == SIG_DFL)
   1414 		(void)printf("SIG_DFL");
   1415 	else {
   1416 		char set[512];
   1417 		psigset(set, sizeof(set), &psig->ps.mask);
   1418 		(void)printf("caught handler=%p mask=[%s]", psig->ps.action,
   1419 		    set);
   1420 	}
   1421 	switch (len) {
   1422 	case sizeof(struct ktr_psig):
   1423 		if (psig->ps.code)
   1424 			printf(" code=0x%x", psig->ps.code);
   1425 		printf(psig->ps.action == SIG_DFL ? "\n" : ")\n");
   1426 		return;
   1427 	case sizeof(*psig):
   1428 		if (si->si_code == 0) {
   1429 			printf(": code=SI_USER sent by pid=%d, uid=%d)\n",
   1430 			    si->si_pid, si->si_uid);
   1431 			return;
   1432 		}
   1433 
   1434 		if (si->si_code < 0) {
   1435 			switch (si->si_code) {
   1436 			case SI_TIMER:
   1437 			case SI_QUEUE:
   1438 				printf(": code=%s sent by pid=%d, uid=%d with "
   1439 				    "sigval %p)\n", si->si_code == SI_TIMER ?
   1440 				    "SI_TIMER" : "SI_QUEUE", si->si_pid,
   1441 				    si->si_uid, si->si_value.sival_ptr);
   1442 				return;
   1443 			case SI_ASYNCIO:
   1444 			case SI_MESGQ:
   1445 				printf(": code=%s with sigval %p)\n",
   1446 				    si->si_code == SI_ASYNCIO ?
   1447 				    "SI_ASYNCIO" : "SI_MESGQ",
   1448 				    si->si_value.sival_ptr);
   1449 				return;
   1450 			case SI_LWP:
   1451 				printf(": code=SI_LWP sent by pid=%d, "
   1452 				    "uid=%d)\n", si->si_pid, si->si_uid);
   1453 				return;
   1454 			default:
   1455 				code = NULL;
   1456 				break;
   1457 			}
   1458 			if (code)
   1459 				printf(": code=%s unimplemented)\n", code);
   1460 			else
   1461 				printf(": code=%d unimplemented)\n",
   1462 				    si->si_code);
   1463 			return;
   1464 		}
   1465 
   1466 		if (si->si_code == SI_NOINFO) {
   1467 			printf(": code=SI_NOINFO\n");
   1468 			return;
   1469 		}
   1470 
   1471 		code = siginfocodename(si->si_signo, si->si_code);
   1472 		switch (si->si_signo) {
   1473 		case SIGCHLD:
   1474 			printf(": code=%s child pid=%d, uid=%d, "
   1475 			    "status=%u, utime=%lu, stime=%lu)\n",
   1476 			    code, si->si_pid,
   1477 			    si->si_uid, si->si_status,
   1478 			    (unsigned long) si->si_utime,
   1479 			    (unsigned long) si->si_stime);
   1480 			return;
   1481 		case SIGILL:
   1482 		case SIGFPE:
   1483 		case SIGSEGV:
   1484 		case SIGBUS:
   1485 		case SIGTRAP:
   1486 			printf(": code=%s, addr=%p, trap=%d)\n",
   1487 			    code, si->si_addr, si->si_trap);
   1488 			return;
   1489 		case SIGIO:
   1490 			printf(": code=%s, fd=%d, band=%lx)\n",
   1491 			    code, si->si_fd, si->si_band);
   1492 			return;
   1493 		default:
   1494 			printf(": code=%s, errno=%d)\n",
   1495 			    code, si->si_errno);
   1496 			return;
   1497 		}
   1498 		/*NOTREACHED*/
   1499 	default:
   1500 		warnx("Unhandled size %d for ktrpsig", len);
   1501 		break;
   1502 	}
   1503 }
   1504 
   1505 static void
   1506 ktrcsw(struct ktr_csw *cs)
   1507 {
   1508 
   1509 	(void)printf("%s %s\n", cs->out ? "stop" : "resume",
   1510 	    cs->user ? "user" : "kernel");
   1511 }
   1512 
   1513 static void
   1514 ktruser_msghdr(const char *name, const void *buf, size_t len)
   1515 {
   1516 	struct msghdr m;
   1517 
   1518 	if (len != sizeof(m))
   1519 		warnx("%.*s: len %zu != %zu", KTR_USER_MAXIDLEN, name, len,
   1520 		    sizeof(m));
   1521 	memcpy(&m, buf, len);
   1522 	printf("%.*s: [name=%p, namelen=%zu, iov=%p, iovlen=%zu, control=%p, "
   1523 	    "controllen=%zu, flags=%x]\n", KTR_USER_MAXIDLEN, name,
   1524 	    m.msg_name, (size_t)m.msg_namelen, m.msg_iov, (size_t)m.msg_iovlen,
   1525 	    m.msg_control, (size_t)m.msg_controllen, m.msg_flags);
   1526 }
   1527 
   1528 static void
   1529 ktruser_soname(const char *name, const void *buf, size_t len)
   1530 {
   1531 	char fmt[512];
   1532 	sockaddr_snprintf(fmt, sizeof(fmt), "%n", buf);
   1533 	printf("%.*s: [%s]\n", KTR_USER_MAXIDLEN, name, fmt);
   1534 }
   1535 
   1536 static void
   1537 ktruser_xattr_name(const char *name, const void *buf, size_t len)
   1538 {
   1539 	printf("%.*s: [%.*s]\n", KTR_USER_MAXIDLEN, name, (int)len,
   1540 	    (const char *)buf);
   1541 }
   1542 
   1543 static void
   1544 ktruser_xattr_val(const char *name, const void *buf, size_t len)
   1545 {
   1546 	const uint8_t *p = buf;
   1547 	printf("%.*s: ", KTR_USER_MAXIDLEN, name);
   1548 	for (size_t i = 0; i < len; i++)
   1549 		printf("%.2x", *p++);
   1550 	printf("\n");
   1551 }
   1552 
   1553 static void
   1554 ktruser_xattr_list(const char *name, const void *buf, size_t len)
   1555 {
   1556 	const uint8_t *p = buf, *ep = p + len;
   1557 	printf("%.*s:", KTR_USER_MAXIDLEN, name);
   1558 	while (p < ep) {
   1559 		int l = *p++;
   1560 		printf(" %.*s", l, p);
   1561 		p += l;
   1562 	}
   1563 	printf("\n");
   1564 }
   1565 
   1566 static void
   1567 ktruser_control(const char *name, const void *buf, size_t len)
   1568 {
   1569 	struct cmsghdr m;
   1570 
   1571 	if (len < sizeof(m))
   1572 		warnx("%.*s: len %zu < %zu", KTR_USER_MAXIDLEN, name, len,
   1573 		    sizeof(m));
   1574 	memcpy(&m, buf, sizeof(m));
   1575 	printf("%.*s: [len=%zu, level=%d, type=%d]\n", KTR_USER_MAXIDLEN, name,
   1576 	    (size_t)m.cmsg_len, m.cmsg_level, m.cmsg_type);
   1577 }
   1578 
   1579 static void
   1580 ktruser_malloc(const char *name, const void *buf, size_t len)
   1581 {
   1582 	struct ut { void *p; size_t s; void *r; } m;
   1583 
   1584 	if (len != sizeof(m))
   1585 		warnx("%.*s: len %zu != %zu", KTR_USER_MAXIDLEN, name, len,
   1586 		    sizeof(m));
   1587 	memcpy(&m, buf, len < sizeof(m) ? len : sizeof(m));
   1588 	if (m.p == NULL && m.s == 0 && m.r == NULL)
   1589 		printf("%.*s: malloc_init()\n", KTR_USER_MAXIDLEN, name);
   1590 	else if (m.p != NULL && m.s != 0)
   1591 		printf("%.*s: %p = realloc(%p, %zu)\n", KTR_USER_MAXIDLEN, name,
   1592 		    m.r, m.p, m.s);
   1593 	else if (m.s == 0)
   1594 		printf("%.*s: free(%p)\n", KTR_USER_MAXIDLEN, name, m.p);
   1595 	else
   1596 		printf("%.*s: %p = malloc(%zu)\n", KTR_USER_MAXIDLEN, name,
   1597 		    m.r, m.s);
   1598 }
   1599 
   1600 static void
   1601 ktruser_misc(const char *name, const void *buf, size_t len)
   1602 {
   1603 	size_t i;
   1604 	const char *dta = buf;
   1605 
   1606 	printf("%.*s: %zu, ", KTR_USER_MAXIDLEN, name, len);
   1607 	for (i = 0; i < len; i++)
   1608 		printf("%02x", (unsigned char)dta[i]);
   1609 	printf("\n");
   1610 }
   1611 
   1612 static struct {
   1613 	const char *name;
   1614 	void (*func)(const char *, const void *, size_t);
   1615 } nv[] = {
   1616 	{ "msghdr", ktruser_msghdr },
   1617 	{ "mbsoname", ktruser_soname },
   1618 	{ "mbcontrol", ktruser_control },
   1619 	{ "malloc", ktruser_malloc },
   1620 	{ "xattr-name", ktruser_xattr_name },
   1621 	{ "xattr-val", ktruser_xattr_val },
   1622 	{ "xattr-list", ktruser_xattr_list },
   1623 	{ NULL,	ktruser_misc },
   1624 };
   1625 
   1626 static void
   1627 ktruser(struct ktr_user *usr, int len)
   1628 {
   1629 	unsigned char *dta;
   1630 
   1631 	len -= sizeof(struct ktr_user);
   1632 	dta = (unsigned char *)(usr + 1);
   1633 	if (word_size) {
   1634 		printf("%.*s:", KTR_USER_MAXIDLEN, usr->ktr_id);
   1635 		printf("\n");
   1636 		hexdump_buf(dta, len, word_size);
   1637 		return;
   1638 	}
   1639 	for (size_t j = 0; j < __arraycount(nv); j++)
   1640 		if (nv[j].name == NULL ||
   1641 		    strncmp(nv[j].name, usr->ktr_id, KTR_USER_MAXIDLEN) == 0) {
   1642 			(*nv[j].func)(usr->ktr_id, dta, len);
   1643 			break;
   1644 		}
   1645 }
   1646 
   1647 static void
   1648 ktrmib(int *namep, int len)
   1649 {
   1650 	size_t i;
   1651 
   1652 	for (i = 0; i < (len / sizeof(*namep)); i++)
   1653 		printf("%s%d", (i == 0) ? "" : ".", namep[i]);
   1654 	printf("\n");
   1655 }
   1656 
   1657 static const char *
   1658 signame(long sig, int xlat)
   1659 {
   1660 	static char buf[64];
   1661 
   1662 	if (sig == 0)
   1663 		return " 0";
   1664 	else if (sig < 0 || sig >= NSIG) {
   1665 		(void)snprintf(buf, sizeof(buf), "*unknown %ld*", sig);
   1666 		return buf;
   1667 	} else
   1668 		return sys_signame[(xlat && cur_emul->signalmap != NULL) ?
   1669 		    cur_emul->signalmap[sig] : sig];
   1670 }
   1671 
   1672 static void
   1673 usage(void)
   1674 {
   1675 	if (strcmp(getprogname(), "ioctlprint") == 0) {
   1676 		(void)fprintf(stderr, "Usage: %s [-l] [-e emulation] [-f format] <ioctl> ...\n",
   1677 		    getprogname());
   1678 	} else {
   1679 		(void)fprintf(stderr, "Usage: %s [-dElNnRT] [-e emulation] "
   1680 		   "[-f file] [-m maxdata] [-p pid]\n             [-t trstr] "
   1681 		   "[-x | -X size] [file]\n", getprogname());
   1682 	}
   1683 	exit(1);
   1684 }
   1685 
   1686 static const struct ioctlinfo *
   1687 find_ioctl_by_name(const char *name)
   1688 {
   1689 	for (size_t i = 0; ioctlinfo[i].name != NULL; i++) {
   1690 		if (strcmp(name, ioctlinfo[i].name) == 0)
   1691 			return &ioctlinfo[i];
   1692 	}
   1693 	return NULL;
   1694 }
   1695 
   1696 static const struct ioctlinfo *
   1697 find_ioctl_by_value(unsigned long value)
   1698 {
   1699 	for (size_t i = 0; ioctlinfo[i].name != NULL; i++) {
   1700 		if (value == ioctlinfo[i].value)
   1701 			return &ioctlinfo[i];
   1702 	}
   1703 	return NULL;
   1704 }
   1705 
   1706 static const struct ioctlinfo *
   1707 find_ioctl(const char *name)
   1708 {
   1709 	if (isalpha((unsigned char)*name)) {
   1710 		return find_ioctl_by_name(name);
   1711 	}
   1712 	int e;
   1713 	unsigned long u = strtou(name, NULL, 0, 0, ULONG_MAX, &e);
   1714 	if (e)
   1715 		errc(1, e, "invalid argument: `%s'", name);
   1716 	return find_ioctl_by_value(u);
   1717 }
   1718