xref: /netbsd-src/usr.bin/ktruss/dump.c (revision bdc22b2e01993381dcefeff2bc9b56ca75a4235c) 
1 /*	$NetBSD: dump.c,v 1.43 2018/06/03 13:41:30 kamil 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 #endif
42 __RCSID("$NetBSD: dump.c,v 1.43 2018/06/03 13:41:30 kamil Exp $");
43 #endif /* not lint */
44 
45 #include <sys/param.h>
46 #define	_KERNEL
47 #include <sys/errno.h>
48 #undef _KERNEL
49 #include <sys/ioctl.h>
50 #include <sys/time.h>
51 #include <sys/uio.h>
52 #include <sys/ktrace.h>
53 #include <sys/ptrace.h>
54 #include <sys/queue.h>
55 
56 #include <err.h>
57 #include <signal.h>
58 #include <stdarg.h>
59 #include <stddef.h>
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63 #include <unistd.h>
64 #include <vis.h>
65 
66 #include "ktrace.h"
67 #include "misc.h"
68 #include "setemul.h"
69 
70 int timestamp, decimal, fancy = 1, tail, maxdata;
71 
72 int width;			/* Keep track of current columns. */
73 
74 #include <sys/syscall.h>
75 
76 static const char *const ptrace_ops[] = {
77 	"PT_TRACE_ME",	"PT_READ_I",	"PT_READ_D",	"PT_READ_U",
78 	"PT_WRITE_I",	"PT_WRITE_D",	"PT_WRITE_U",	"PT_CONTINUE",
79 	"PT_KILL",	"PT_ATTACH",	"PT_DETACH",
80 };
81 
82 struct ktr_entry {
83 	TAILQ_ENTRY(ktr_entry) kte_list;
84 	struct ktr_header kte_kth;
85 };
86 
87 TAILQ_HEAD(kteq, ktr_entry) ktependq = TAILQ_HEAD_INITIALIZER(ktependq);
88 
89 void	argprint(const char *, register_t **, int *);
90 void	dumpheader(struct ktr_header *);
91 int	dumprecord(int, FILE *);
92 void	flushpendq(struct ktr_entry *);
93 int	fread_tail(void *, int, int, FILE *);
94 void	genioprint(struct ktr_header *);
95 struct ktr_entry *
96 	getpendq(struct ktr_header *, int, struct kteq *);
97 struct ktr_entry *
98 	getrecord(FILE *);
99 void	indent(int);
100 void	ioctldecode(u_long);
101 void	ktrcsw(struct ktr_entry *);
102 void	ktremul(struct ktr_entry *);
103 void	ktrgenio(struct ktr_entry *);
104 void	ktrnamei(struct ktr_entry *);
105 void	ktrpsig(struct ktr_entry *);
106 void	ktrsyscall(struct ktr_entry *);
107 void	ktrsysret(struct ktr_entry *);
108 void	nameiargprint(const char *, struct ktr_header *, register_t **, int *);
109 void	nameiprint(struct ktr_header *);
110 void	newline(void);
111 void	putpendq(struct ktr_entry *);
112 void	syscallnameprint(int);
113 void	syscallprint(struct ktr_header *);
114 void	sysretprint(struct ktr_header *);
115 int	xwprintf(const char *, ...) __printflike(1, 2);
116 void	*xrealloc(void *, size_t *, size_t);
117 
118 int
119 xwprintf(const char *fmt, ...)
120 {
121 	va_list ap;
122 	int w;
123 
124 	va_start(ap, fmt);
125 	w = vprintf(fmt, ap);
126 	if (w == -1)
127 		warn("vprintf");
128 	else
129 		width += w;
130 	va_end(ap);
131 	return (w);
132 }
133 
134 void
135 newline(void)
136 {
137 
138 	if (width > 0) {
139 		printf("\n");
140 		width = 0;
141 	}
142 }
143 
144 void
145 indent(int col)
146 {
147 
148 	while (width < col)
149 		if (xwprintf(" ") < 0)
150 			break;
151 }
152 
153 void *
154 xrealloc(void *p, size_t *siz, size_t req)
155 {
156 
157 	if (*siz < req) {
158 		if (*siz == 0)
159 			*siz = 1;
160 		while (*siz < req)
161 			*siz <<= 1;
162 		p = realloc(p, *siz);
163 		if (p == NULL)
164 			err(EXIT_FAILURE, "realloc: %lu bytes",
165 			    (u_long)*siz);
166 	}
167 	return (p);
168 }
169 
170 struct ktr_entry *
171 getrecord(FILE *fp)
172 {
173 	struct ktr_entry *kte;
174 	struct ktr_header *kth;
175 	char *cp;
176 	size_t siz, len;
177 
178 	siz = 0;
179 	kte = xrealloc(NULL, &siz, sizeof(struct ktr_entry));
180 	kth = &kte->kte_kth;
181 	if (fread_tail(kth, sizeof(struct ktr_header), 1, fp) == 0) {
182 		free(kte);
183 		return (NULL);
184 	}
185 
186 	if (kth->ktr_len < 0)
187 		errx(EXIT_FAILURE, "bogus length 0x%x", kth->ktr_len);
188 	len = kth->ktr_len;
189 	if (len > 0) {
190 		/* + 1 to ensure room for NUL terminate */
191 		kte = xrealloc(kte, &siz, sizeof(struct ktr_entry) + len + 1);
192 		if (fread_tail(cp = (char *)(&kte->kte_kth + 1),
193 		    len, 1, fp) == 0)
194 			errx(EXIT_FAILURE, "data too short");
195 		cp[len] = 0;
196 	}
197 
198 	return (kte);
199 }
200 
201 #define	KTE_TYPE(kte)		((kte)->kte_kth.ktr_type)
202 #define	KTE_PID(kte)		((kte)->kte_kth.ktr_pid)
203 #define	KTE_LID(kte)		((kte)->kte_kth.ktr_lid)
204 #define	KTE_MATCH(kte, type, pid, lid)				\
205 	(KTE_TYPE(kte) == (type) && KTE_PID(kte) == (pid) &&	\
206 	KTE_LID(kte) == (lid))
207 
208 void
209 putpendq(struct ktr_entry *kte)
210 {
211 
212 	TAILQ_INSERT_TAIL(&ktependq, kte, kte_list);
213 }
214 
215 void
216 flushpendq(struct ktr_entry *us)
217 {
218 	struct ktr_entry *kte, *kte_next;
219 	int pid = KTE_PID(us), lid = KTE_LID(us);
220 
221 	for (kte = TAILQ_FIRST(&ktependq); kte != NULL; kte = kte_next) {
222 		kte_next = TAILQ_NEXT(kte, kte_list);
223 		if (KTE_PID(kte) == pid || KTE_LID(kte) == lid) {
224 			TAILQ_REMOVE(&ktependq, kte, kte_list);
225 			free(kte);
226 		}
227 	}
228 }
229 
230 struct ktr_entry *
231 getpendq(struct ktr_header *us, int type, struct kteq *kteq)
232 {
233 	struct ktr_entry *kte, *kte_next;
234 	int pid = us->ktr_pid, lid = us->ktr_lid;
235 
236 	if (kteq != NULL)
237 		TAILQ_INIT(kteq);
238 	for (kte = TAILQ_FIRST(&ktependq); kte != NULL; kte = kte_next) {
239 		kte_next = TAILQ_NEXT(kte, kte_list);
240 		if (KTE_MATCH(kte, type, pid, lid)) {
241 			TAILQ_REMOVE(&ktependq, kte, kte_list);
242 			if (kteq != NULL)
243 				TAILQ_INSERT_TAIL(kteq, kte, kte_list);
244 			else
245 				break;
246 		}
247 	}
248 
249 	return (kteq ? TAILQ_FIRST(kteq) : kte);
250 }
251 
252 int
253 dumprecord(int trpoints, FILE *fp)
254 {
255 	struct ktr_entry *kte;
256 	struct ktr_header *kth;
257 
258 	kte = getrecord(fp);
259 	if (kte == NULL)
260 		return (0);
261 
262 	kth = &kte->kte_kth;
263 	if ((trpoints & (1 << kth->ktr_type)) == 0) {
264 		free(kte);
265 		goto out;
266 	}
267 
268 	/* Update context to match currently processed record. */
269 	ectx_sanify(kth->ktr_pid);
270 
271 	switch (kth->ktr_type) {
272 	case KTR_SYSCALL:
273 		ktrsyscall(kte);
274 		break;
275 	case KTR_SYSRET:
276 		ktrsysret(kte);
277 		break;
278 	case KTR_NAMEI:
279 		putpendq(kte);
280 		break;
281 	case KTR_GENIO:
282 		putpendq(kte);
283 		break;
284 	case KTR_PSIG:
285 		ktrpsig(kte);
286 		break;
287 	case KTR_CSW:
288 		ktrcsw(kte);
289 		break;
290 	case KTR_EMUL:
291 		putpendq(kte);
292 		break;
293 	default:
294 		/*
295 		 * XXX: Other types added recently.
296 		 */
297 		free(kte);
298 		break;
299 	}
300 	newline();
301 
302 out:
303 	return (1);
304 }
305 
306 void
307 dumpfile(const char *file, int fd, int trpoints)
308 {
309 	FILE *fp;
310 
311 	if (file == NULL || *file == 0) {
312 		if ((fp = fdopen(fd, "r")) == NULL)
313 			err(EXIT_FAILURE, "fdopen(%d)", fd);
314 	} else if (strcmp(file, "-") == 0)
315 		fp = stdin;
316 	else if ((fp = fopen(file, "r")) == NULL)
317 		err(EXIT_FAILURE, "fopen: %s", file);
318 
319 	for (width = 0; dumprecord(trpoints, fp) != 0;)
320 		if (tail)
321 			(void)fflush(stdout);
322 
323 	newline();
324 
325 	/*
326 	 * XXX: Dump pending KTR_SYSCALL if any?
327 	 */
328 }
329 
330 int
331 fread_tail(void *buf, int size, int num, FILE *fp)
332 {
333 	int i;
334 
335 	while ((i = fread(buf, size, num, fp)) == 0 && tail) {
336 		(void)sleep(1);
337 		clearerr(fp);
338 	}
339 	return (i);
340 }
341 
342 void
343 dumpheader(struct ktr_header *kth)
344 {
345 	union timeholder {
346 		struct timeval tv;
347 		struct timespec ts;
348 	};
349 	static union timeholder prevtime;
350 	union timeholder temp;
351 
352 	temp.tv.tv_sec = temp.tv.tv_usec = 0;
353 	xwprintf("%6d ", kth->ktr_pid);
354 	if (kth->ktr_version > KTRFAC_VERSION(KTRFACv0))
355 		xwprintf("%6d ", kth->ktr_lid);
356 	xwprintf("%-8.*s ", MAXCOMLEN, kth->ktr_comm);
357 	if (timestamp) {
358 		if (timestamp == 2) {
359 			switch (kth->ktr_version) {
360 			case KTRFAC_VERSION(KTRFACv0):
361 				if (prevtime.tv.tv_sec == 0)
362 					temp.tv.tv_sec = temp.tv.tv_usec = 0;
363 				else
364 					timersub(&kth->ktr_otv,
365 					    &prevtime.tv, &temp.tv);
366 				prevtime.tv.tv_sec = kth->ktr_otv.tv_sec;
367 				prevtime.tv.tv_usec = kth->ktr_otv.tv_usec;
368 				break;
369 
370 			case KTRFAC_VERSION(KTRFACv1):
371 				if (prevtime.ts.tv_sec == 0)
372 					temp.ts.tv_sec = temp.ts.tv_nsec = 0;
373 				else
374 					timespecsub(&kth->ktr_time,
375 					    &prevtime.ts, &temp.ts);
376 				prevtime.ts.tv_sec = kth->ktr_ots.tv_sec;
377 				prevtime.ts.tv_nsec = kth->ktr_ots.tv_nsec;
378 				break;
379 
380 			case KTRFAC_VERSION(KTRFACv2):
381 				if (prevtime.ts.tv_sec == 0)
382 					temp.ts.tv_sec = temp.ts.tv_nsec = 0;
383 				else
384 					timespecsub(&kth->ktr_time,
385 					    &prevtime.ts, &temp.ts);
386 				prevtime.ts.tv_sec = kth->ktr_ts.tv_sec;
387 				prevtime.ts.tv_nsec = kth->ktr_ts.tv_nsec;
388 				break;
389 			}
390 		} else {
391 			switch (kth->ktr_version) {
392 			case KTRFAC_VERSION(KTRFACv0):
393 				temp.tv.tv_sec = kth->ktr_otv.tv_sec;
394 				temp.tv.tv_usec = kth->ktr_otv.tv_usec;
395 				break;
396 			case KTRFAC_VERSION(KTRFACv1):
397 				temp.ts.tv_sec = kth->ktr_ots.tv_sec;
398 				temp.ts.tv_nsec = kth->ktr_ots.tv_nsec;
399 				break;
400 			case KTRFAC_VERSION(KTRFACv2):
401 				temp.ts.tv_sec = kth->ktr_ts.tv_sec;
402 				temp.ts.tv_nsec = kth->ktr_ts.tv_nsec;
403 				break;
404 			}
405 		}
406 		if (kth->ktr_version == KTRFAC_VERSION(KTRFACv0))
407 			xwprintf("%lld.%06ld ",
408 			    (long long)temp.tv.tv_sec, (long)temp.tv.tv_usec);
409 		else
410 			xwprintf("%lld.%09ld ",
411 			    (long long)temp.ts.tv_sec, (long)temp.ts.tv_nsec);
412 	}
413 }
414 
415 void
416 ioctldecode(u_long cmd)
417 {
418 	char dirbuf[4], *dir = dirbuf;
419 
420 	if (cmd & IOC_OUT)
421 		*dir++ = 'W';
422 	if (cmd & IOC_IN)
423 		*dir++ = 'R';
424 	*dir = '\0';
425 
426 	xwprintf(decimal ? ", _IO%s('%c',%ld" : ", _IO%s('%c',%#lx",
427 	    dirbuf, (int) ((cmd >> 8) & 0xff), cmd & 0xff);
428 	if ((cmd & IOC_VOID) == 0)
429 		xwprintf(decimal ? ",%ld)" : ",%#lx)",
430 		    (cmd >> 16) & 0xff);
431 	else
432 		xwprintf(")");
433 }
434 
435 void
436 nameiargprint(const char *prefix, struct ktr_header *kth,
437     register_t **ap, int *argsize)
438 {
439 	struct ktr_entry *kte;
440 
441 	if (*argsize == 0)
442 		errx(EXIT_FAILURE, "argument expected");
443 	/*
444 	 * XXX: binary emulation mode.
445 	 */
446 	kte = getpendq(kth, KTR_NAMEI, NULL);
447 	if (kte == NULL)
448 		argprint(prefix, ap, argsize);
449 	else {
450 		xwprintf("%s", prefix);
451 		nameiprint(&kte->kte_kth);
452 		free(kte);
453 		(*ap)++;
454 		*argsize -= sizeof(register_t);
455 	}
456 }
457 
458 void
459 syscallnameprint(int code)
460 {
461 
462 	if (code >= cur_emul->nsysnames || code < 0)
463 		xwprintf("[%d]", code);
464 	else
465 		xwprintf("%s", cur_emul->sysnames[code]);
466 }
467 
468 void
469 argprint(const char *prefix, register_t **ap, int *argsize)
470 {
471 
472 	if (decimal)
473 		xwprintf("%s%ld", prefix, (long)**ap);
474 	else
475 		xwprintf("%s%#lx", prefix, (long)**ap);
476 	(*ap)++;
477 	*argsize -= sizeof(register_t);
478 }
479 
480 void
481 syscallprint(struct ktr_header *kth)
482 {
483 	struct ktr_syscall *ktr = (struct ktr_syscall *)(kth + 1);
484 	register_t *ap;
485 	const char *s;
486 	int argsize;
487 
488 	syscallnameprint(ktr->ktr_code);
489 
490 	/*
491 	 * Arguments processing.
492 	 */
493 	argsize = ktr->ktr_argsize;
494 	if (argsize == 0) {
495 		xwprintf("(");
496 		goto noargument;
497 	}
498 
499 	ap = (register_t *)(ktr + 1);
500 	if (!fancy)
501 		goto print_first;
502 
503 	switch (ktr->ktr_code) {
504 	/*
505 	 * All these have a path as the first param.
506 	 * The order is same as syscalls.master.
507 	 */
508 	case SYS_open:
509 	case SYS_link:
510 	case SYS_unlink:
511 	case SYS_chdir:
512 	case SYS___mknod50:
513 	case SYS_chmod:
514 	case SYS_chown:
515 	case SYS_unmount:
516 	case SYS_access:
517 	case SYS_chflags:
518 	case SYS_acct:
519 	case SYS_revoke:
520 	case SYS_symlink:
521 	case SYS_readlink:
522 	case SYS_execve:
523 	case SYS_chroot:
524 	case SYS_rename:
525 	case SYS_mkfifo:
526 	case SYS_mkdir:
527 	case SYS_rmdir:
528 	case SYS___utimes50:
529 	case SYS_compat_50_quotactl:
530 	case SYS___quotactl:
531 	case SYS_statvfs1:
532 	case SYS_compat_30_getfh:
533 	case SYS_pathconf:
534 	case SYS_truncate:
535 	case SYS_undelete:
536 	case SYS___posix_rename:
537 	case SYS_lchmod:
538 	case SYS_lchown:
539 	case SYS___lutimes50:
540 	case SYS___stat50:
541 	case SYS___lstat50:
542 	case SYS___posix_chown:
543 	case SYS___posix_lchown:
544 	case SYS_lchflags:
545 	case SYS___getfh30:
546 		nameiargprint("(", kth, &ap, &argsize);
547 
548 		/*
549 		 * 2nd argument is also pathname.
550 		 */
551 		switch (ktr->ktr_code) {
552 		case SYS_link:
553 		case SYS_rename:
554 		case SYS___posix_rename:
555 			nameiargprint(", ", kth, &ap, &argsize);
556 			break;
557 		}
558 		break;
559 
560 	case SYS_compat_16___sigaction14 :
561 		xwprintf("(%s", signals[(int)*ap].name);
562 		ap++;
563 		argsize -= sizeof(register_t);
564 		break;
565 
566 	case SYS_ioctl :
567 		argprint("(", &ap, &argsize);
568 		if ((s = ioctlname(*ap)) != NULL)
569 			xwprintf(", %s", s);
570 		else
571 			ioctldecode(*ap);
572 		ap++;
573 		argsize -= sizeof(register_t);
574 		break;
575 
576 	case SYS_ptrace :
577 		if ((long)*ap >= 0 &&
578 		    *ap < (register_t)(sizeof(ptrace_ops) / sizeof(ptrace_ops[0])))
579 			xwprintf("(%s", ptrace_ops[*ap]);
580 		else
581 			xwprintf("(%ld", (long)*ap);
582 		ap++;
583 		argsize -= sizeof(register_t);
584 		break;
585 
586 	default:
587 print_first:
588 		argprint("(", &ap, &argsize);
589 		break;
590 	}
591 
592 	/* Print rest of argument. */
593 	while (argsize > 0)
594 		argprint(", ", &ap, &argsize);
595 
596 noargument:
597 	xwprintf(")");
598 }
599 
600 void
601 ktrsyscall(struct ktr_entry *kte)
602 {
603 	struct ktr_header *kth = &kte->kte_kth;
604 	struct ktr_syscall *ktr = (struct ktr_syscall *)(kth + 1);
605 
606 	switch (ktr->ktr_code) {
607 	case SYS_exit:
608 		dumpheader(kth);
609 		syscallprint(kth);
610 		break;
611 	default:
612 		putpendq(kte);
613 		return;
614 	}
615 
616 	free(kte);
617 }
618 
619 void
620 sysretprint(struct ktr_header *kth)
621 {
622 	struct ktr_sysret *ktr = (struct ktr_sysret *)(kth + 1);
623 	register_t ret = ktr->ktr_retval;
624 	int error = ktr->ktr_error;
625 
626 	indent(50);
627 	if (error == EJUSTRETURN)
628 		xwprintf(" JUSTRETURN");
629 	else if (error == ERESTART)
630 		xwprintf(" RESTART");
631 	else if (error) {
632 		xwprintf(" Err#%d", error);
633 		if (error < MAXERRNOS && error >= -2)
634 			xwprintf(" %s", errnos[error].name);
635 	} else
636 		switch (ktr->ktr_code) {
637 		case SYS_mremap:
638 		case SYS_mmap:
639 			xwprintf(" = %p", (void *)(intptr_t)ret);
640 			break;
641 		default:
642 			xwprintf(" = %ld", (long)ret);
643 			if (kth->ktr_len > (int)offsetof(struct ktr_sysret,
644 			    ktr_retval_1) && ktr->ktr_retval_1 != 0)
645 				xwprintf(", %ld", (long)ktr->ktr_retval_1);
646 			break;
647 		}
648 }
649 
650 void
651 ktrsysret(struct ktr_entry *kte)
652 {
653 	struct ktr_header *kth = &kte->kte_kth;
654 	struct ktr_sysret *ktr = (struct ktr_sysret *)(kth + 1);
655 	struct ktr_entry *emul;
656 	struct ktr_entry *genio;
657 	struct ktr_entry *syscall_ent;
658 
659 	dumpheader(kth);
660 
661 	/* Print syscall name and arguments. */
662 	syscall_ent = getpendq(kth, KTR_SYSCALL, NULL);
663 	if (syscall_ent == NULL) {
664 		/*
665 		 * Possibilly a child of fork/vfork, or tracing of
666 		 * process started during system call.
667 		 */
668 		syscallnameprint(ktr->ktr_code);
669 	} else {
670 		syscallprint(&syscall_ent->kte_kth);
671 		free(syscall_ent);
672 	}
673 
674 	/* Print return value and an error if any. */
675 	sysretprint(kth);
676 
677 	genio = getpendq(kth, KTR_GENIO, NULL);
678 	if (genio != NULL) {
679 		genioprint(&genio->kte_kth);
680 		free(genio);
681 	}
682 
683 	emul = getpendq(kth, KTR_EMUL, NULL);
684 	if (emul != NULL) {
685 		newline();
686 		ktremul(emul);
687 	}
688 
689 	flushpendq(kte);
690 	free(kte);
691 }
692 
693 void
694 nameiprint(struct ktr_header *kth)
695 {
696 
697 	xwprintf("\"%.*s\"", kth->ktr_len, (char *)(kth + 1));
698 }
699 
700 #ifdef notused
701 void
702 ktrnamei(struct ktr_entry *kte)
703 {
704 	struct ktr_header *kth = &kte->kte_kth;
705 
706 	dumpheader(kth);
707 	xwprintf("namei(");
708 	nameiprint(kth);
709 	xwprintf(")");
710 
711 	free(kte);
712 }
713 #endif
714 
715 void
716 ktremul(struct ktr_entry *kte)
717 {
718 	struct ktr_header *kth = &kte->kte_kth;
719 	char *emul = (char *)(kth + 1);
720 
721 	dumpheader(kth);
722 	xwprintf("emul(%s)", emul);
723 	setemul(emul, kth->ktr_pid, 1);
724 
725 	free(kte);
726 }
727 
728 void
729 genioprint(struct ktr_header *kth)
730 {
731 	struct ktr_genio *ktr = (struct ktr_genio *)(kth + 1);
732 	static int screenwidth = 0;
733 	int datalen = kth->ktr_len - sizeof(struct ktr_genio);
734 	/*
735 	 * Need to be unsigned type so that positive value is passed
736 	 * to vis(), which will call isgraph().
737 	 */
738 	unsigned char *dp = (unsigned char *)(ktr + 1);
739 	int w;
740 	char visbuf[5];
741 
742 	if (screenwidth == 0) {
743 		struct winsize ws;
744 
745 		if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 &&
746 		    ws.ws_col > 8)
747 			screenwidth = ws.ws_col;
748 		else
749 			screenwidth = 80;
750 	}
751 
752 	if (maxdata && datalen > maxdata)
753 		datalen = maxdata;
754 	newline();
755 	xwprintf("       \"");
756 	for (; datalen > 0; datalen--, dp++) {
757 		(void) vis(visbuf, *dp, VIS_NL|VIS_TAB|VIS_CSTYLE,
758 		    /* We put NUL at the end of buffer when reading */
759 		    *(dp + 1));
760 		visbuf[4] = '\0';
761 		w = strlen(visbuf);
762 		if (width + w + 2 >= screenwidth)
763 			break;
764 		xwprintf("%s", visbuf);
765 		if (width + 2 >= screenwidth)
766 			break;
767 	}
768 	xwprintf("\"");
769 }
770 
771 #ifdef notused
772 void
773 ktrgenio(struct ktr_entry *kte)
774 {
775 	struct ktr_header *kth = &kte->kte_kth;
776 	struct ktr_genio *ktr = (struct ktr_genio *)(kth + 1);
777 
778 	dumpheader(kth);
779 	xwprintf("genio fd %d %s",
780 	    ktr->ktr_fd, ktr->ktr_rw ? "write" : "read");
781 	genioprint(kth);
782 
783 	free(kte);
784 }
785 #endif
786 
787 void
788 ktrpsig(struct ktr_entry *kte)
789 {
790 	struct ktr_header *kth = &kte->kte_kth;
791 	struct ktr_psig *psig = (struct ktr_psig *)(kth + 1);
792 
793 	dumpheader(kth);
794 	xwprintf("SIG%s ", sys_signame[psig->signo]);
795 	if (psig->action == SIG_DFL)
796 		xwprintf("SIG_DFL");
797 	else {
798 		xwprintf("caught handler=0x%lx mask=0x%lx code=0x%x",
799 		    (u_long)psig->action, (unsigned long)psig->mask.__bits[0],
800 		    psig->code);
801 	}
802 
803 	free(kte);
804 }
805 
806 void
807 ktrcsw(struct ktr_entry *kte)
808 {
809 	struct ktr_header *kth = &kte->kte_kth;
810 	struct ktr_csw *cs = (struct ktr_csw *)(kth + 1);
811 
812 	dumpheader(kth);
813 	xwprintf("%s %s", cs->out ? "stop" : "resume",
814 	    cs->user ? "user" : "kernel");
815 
816 	free(kte);
817 }
818