dump.c revision 1.2
1 /* $NetBSD: dump.c,v 1.2 1999/07/12 04:13:34 mrg 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 #ifndef lint 38 __COPYRIGHT("@(#) Copyright (c) 1988, 1993\n\ 39 The Regents of the University of California. All rights reserved.\n"); 40 #endif /* not lint */ 41 42 #ifndef lint 43 #if 0 44 static char sccsid[] = "@(#)kdump.c 8.4 (Berkeley) 4/28/95"; 45 #endif 46 __RCSID("$NetBSD: dump.c,v 1.2 1999/07/12 04:13:34 mrg Exp $"); 47 #endif /* not lint */ 48 49 #include <sys/param.h> 50 #define _KERNEL 51 #include <sys/errno.h> 52 #undef _KERNEL 53 #include <sys/time.h> 54 #include <sys/uio.h> 55 #include <sys/ktrace.h> 56 #include <sys/ioctl.h> 57 #include <sys/ptrace.h> 58 #define _KERNEL 59 #include <sys/errno.h> 60 #undef _KERNEL 61 62 #include <err.h> 63 #include <signal.h> 64 #include <stdio.h> 65 #include <stdlib.h> 66 #include <string.h> 67 #include <unistd.h> 68 #include <vis.h> 69 70 #include "ktrace.h" 71 #include "misc.h" 72 73 int timestamp, decimal, fancy = 1, tail, maxdata; 74 75 #define eqs(s1, s2) (strcmp((s1), (s2)) == 0) 76 77 #include <sys/syscall.h> 78 79 #include "../../sys/compat/hpux/hpux_syscall.h" 80 #include "../../sys/compat/ibcs2/ibcs2_syscall.h" 81 #include "../../sys/compat/linux/linux_syscall.h" 82 #include "../../sys/compat/osf1/osf1_syscall.h" 83 #include "../../sys/compat/sunos/sunos_syscall.h" 84 #include "../../sys/compat/svr4/svr4_syscall.h" 85 #include "../../sys/compat/ultrix/ultrix_syscall.h" 86 87 #define KTRACE 88 #include "../../sys/kern/syscalls.c" 89 90 #include "../../sys/compat/hpux/hpux_syscalls.c" 91 #include "../../sys/compat/ibcs2/ibcs2_syscalls.c" 92 #include "../../sys/compat/linux/linux_syscalls.c" 93 #include "../../sys/compat/osf1/osf1_syscalls.c" 94 #include "../../sys/compat/sunos/sunos_syscalls.c" 95 #include "../../sys/compat/svr4/svr4_syscalls.c" 96 #include "../../sys/compat/ultrix/ultrix_syscalls.c" 97 #undef KTRACE 98 99 struct emulation { 100 char *name; /* Emulation name */ 101 char **sysnames; /* Array of system call names */ 102 int nsysnames; /* Number of */ 103 }; 104 105 static struct emulation emulations[] = { 106 { "netbsd", syscallnames, SYS_MAXSYSCALL }, 107 { "hpux", hpux_syscallnames, HPUX_SYS_MAXSYSCALL }, 108 { "ibcs2", ibcs2_syscallnames, IBCS2_SYS_MAXSYSCALL }, 109 { "linux", linux_syscallnames, LINUX_SYS_MAXSYSCALL }, 110 { "osf1", osf1_syscallnames, OSF1_SYS_MAXSYSCALL }, 111 { "sunos", sunos_syscallnames, SUNOS_SYS_MAXSYSCALL }, 112 { "svr4", svr4_syscallnames, SVR4_SYS_MAXSYSCALL }, 113 { "ultrix", ultrix_syscallnames, ULTRIX_SYS_MAXSYSCALL }, 114 { NULL, NULL, NULL } 115 }; 116 117 struct emulation *current = &emulations[0]; /* NetBSD */ 118 119 120 static char *ptrace_ops[] = { 121 "PT_TRACE_ME", "PT_READ_I", "PT_READ_D", "PT_READ_U", 122 "PT_WRITE_I", "PT_WRITE_D", "PT_WRITE_U", "PT_CONTINUE", 123 "PT_KILL", "PT_ATTACH", "PT_DETACH", 124 }; 125 126 127 void dumprecord __P((struct ktr_header *, int, int, void *, FILE *)); 128 void dumpheader __P((struct ktr_header *, char *, int, int *)); 129 void dumpfile __P((char *, int, int)); 130 int fread_tail __P((char *, int, int, FILE *)); 131 void ioctldecode __P((u_long)); 132 int ktrsyscall __P((struct ktr_syscall *, int, char *, int, int *)); 133 void ktrsysret __P((struct ktr_sysret *, char *, int, int *)); 134 void ktrnamei __P((char *, int, char *, int, int *)); 135 void ktremul __P((char *, int, char *, int, int *)); 136 void ktrgenio __P((struct ktr_genio *, int, char *, int, int *)); 137 void ktrpsig __P((struct ktr_psig *)); 138 void ktrcsw __P((struct ktr_csw *)); 139 void setemul __P((char *)); 140 141 #define KTR_BUFSZ 512 142 #define BLEFT (bufsz - (bp - buff)) 143 144 145 void 146 dumprecord(ktr, trpoints, size, m, fp) 147 register struct ktr_header *ktr; 148 int trpoints, size; 149 void *m; 150 FILE *fp; 151 { 152 static void *mcopy = NULL; 153 static int linelen = 0, iolinelen = 0; 154 char buff[KTR_BUFSZ], iobuff[KTR_BUFSZ], *bp; 155 int ktrlen, *lenp; 156 157 if (!ktr) { 158 printf("%s\n", buff); 159 if (*iobuff) 160 printf("%s\n", iobuff); 161 return; 162 } 163 164 if (ktr->ktr_type == KTR_GENIO || ktr->ktr_type == KTR_EMUL) { 165 bp = iobuff; 166 lenp = &iolinelen; 167 } else { 168 bp = buff; 169 lenp = &linelen; 170 } 171 if (!mcopy && (trpoints & (1<<ktr->ktr_type))) 172 dumpheader(ktr, bp, KTR_BUFSZ, lenp); 173 174 if ((ktrlen = ktr->ktr_len) < 0) 175 errx(1, "bogus length 0x%x", ktrlen); 176 if (ktrlen > size) { 177 m = (void *)realloc(m, ktrlen+1); 178 if (m == NULL) 179 errx(1, "%s", strerror(ENOMEM)); 180 size = ktrlen; 181 } 182 if (ktrlen && fread_tail(m, ktrlen, 1, fp) == 0) 183 errx(1, "data too short"); 184 if ((trpoints & (1<<ktr->ktr_type)) == 0) 185 return; 186 switch (ktr->ktr_type) 187 { 188 case KTR_SYSCALL: 189 if (ktrsyscall((struct ktr_syscall *)m, 0, bp, KTR_BUFSZ, 190 lenp) == 0) { 191 mcopy = (void *)malloc(ktrlen + 1); 192 bcopy(m, mcopy, ktrlen); 193 return; 194 } 195 break; 196 case KTR_SYSRET: 197 ktrsysret((struct ktr_sysret *)m, bp, KTR_BUFSZ, lenp); 198 if (*iobuff || iolinelen) { 199 fputs(iobuff, stdout); 200 *iobuff = '\0'; 201 iolinelen = 0; 202 } 203 break; 204 case KTR_NAMEI: 205 ktrnamei(m, ktrlen, bp, sizeof(buff), lenp); 206 if (mcopy) { 207 (void) ktrsyscall((struct ktr_syscall *)mcopy, 1, bp, 208 KTR_BUFSZ, lenp); 209 free(mcopy); 210 mcopy = NULL; 211 } 212 break; 213 case KTR_GENIO: 214 ktrgenio((struct ktr_genio *)m, ktrlen, bp, KTR_BUFSZ, lenp); 215 break; 216 case KTR_PSIG: 217 ktrpsig((struct ktr_psig *)m); 218 break; 219 case KTR_CSW: 220 ktrcsw((struct ktr_csw *)m); 221 break; 222 case KTR_EMUL: 223 ktremul(m, ktrlen, bp, sizeof(buff), lenp); 224 break; 225 } 226 227 if (mcopy) 228 free(mcopy); 229 } 230 231 void 232 dumpfile(file, fd, trpoints) 233 char *file; 234 int fd; 235 int trpoints; 236 { 237 struct ktr_header ktr_header; 238 register void *m; 239 FILE *fp; 240 int size; 241 242 m = (void *)malloc(size = 1025); 243 if (m == NULL) 244 errx(1, "%s", strerror(ENOMEM)); 245 if (!file || !*file) { 246 if (!(fp = fdopen(fd, "r"))) 247 err(1, "fdopen(%d)", fd); 248 } else if (!strcmp(file, "-")) 249 fp = stdin; 250 else if (!(fp = fopen(file, "r"))) 251 err(1, "%s", file); 252 253 while (fread_tail((char *)&ktr_header,sizeof(struct ktr_header),1,fp)) { 254 dumprecord(&ktr_header, trpoints, size, m, fp); 255 if (tail) 256 (void)fflush(stdout); 257 } 258 dumprecord(NULL, 0, 0, 0, fp); 259 } 260 261 262 int 263 fread_tail(buf, size, num, fp) 264 char *buf; 265 int num, size; 266 FILE *fp; 267 { 268 int i; 269 270 while ((i = fread(buf, size, num, fp)) == 0 && tail) { 271 (void)sleep(1); 272 clearerr(stdin); 273 } 274 return (i); 275 } 276 277 void 278 dumpheader(kth, buff, buffsz, lenp) 279 struct ktr_header *kth; 280 char *buff; 281 int buffsz, *lenp; 282 { 283 static struct timeval prevtime; 284 char *bp = buff + *lenp; 285 struct timeval temp; 286 287 if (kth->ktr_type == KTR_SYSRET || kth->ktr_type == KTR_GENIO) 288 return; 289 *lenp = 0; 290 (void)snprintf(bp, buffsz - *lenp, "%6d %-8.*s ", 291 kth->ktr_pid, MAXCOMLEN, kth->ktr_comm); 292 *lenp += strlen(bp); 293 bp = buff + *lenp; 294 295 if (timestamp) { 296 if (timestamp == 2) { 297 timersub(&kth->ktr_time, &prevtime, &temp); 298 prevtime = kth->ktr_time; 299 } else 300 temp = kth->ktr_time; 301 (void)snprintf(bp, buffsz - *lenp, "%ld.%06ld ", temp.tv_sec, 302 temp.tv_usec); 303 *lenp += strlen(bp); 304 } 305 } 306 307 void 308 ioctldecode(cmd) 309 u_long cmd; 310 { 311 char dirbuf[4], *dir = dirbuf; 312 313 if (cmd & IOC_OUT) 314 *dir++ = 'W'; 315 if (cmd & IOC_IN) 316 *dir++ = 'R'; 317 *dir = '\0'; 318 319 printf(decimal ? ",_IO%s('%c',%ld" : ",_IO%s('%c',%#lx", 320 dirbuf, (cmd >> 8) & 0xff, cmd & 0xff); 321 if ((cmd & IOC_VOID) == 0) 322 printf(decimal ? ",%ld)" : ",%#lx)", (cmd >> 16) & 0xff); 323 else 324 printf(")"); 325 } 326 327 int 328 ktrsyscall(ktr, nohdr, buff, bufsz, lenp) 329 register struct ktr_syscall *ktr; 330 int nohdr, bufsz, *lenp; 331 char *buff; 332 { 333 register int argsize = ktr->ktr_argsize; 334 register register_t *ap; 335 char *bp = buff; 336 int eol = 1; 337 338 if (*lenp < bufsz) { 339 bp += *lenp; 340 bzero(bp, BLEFT); 341 } 342 if (!nohdr) { 343 if (ktr->ktr_code >= current->nsysnames || ktr->ktr_code < 0) 344 (void)snprintf(bp, BLEFT, "[%d]", ktr->ktr_code); 345 else 346 (void)snprintf(bp, BLEFT, 347 "%s", current->sysnames[ktr->ktr_code]); 348 bp += strlen(bp); 349 } 350 ap = (register_t *)((char *)ktr + sizeof(struct ktr_syscall)); 351 if (argsize) { 352 char *s = "("; 353 if (fancy && !nohdr) { 354 switch (ktr->ktr_code) { 355 /* 356 * All these have a path as the first param. 357 */ 358 case SYS_open : case SYS_chdir : 359 case SYS___stat13 : case SYS_chroot : 360 case SYS_execve : case SYS_pathconf : 361 case SYS_rmdir : case SYS_rename : 362 case SYS_symlink : case SYS_chflags : 363 case SYS_link : case SYS_mkdir : 364 case SYS_mknod : case SYS_mkfifo : 365 if (BLEFT > 1) 366 *bp++ = '('; 367 eol = 0; 368 break; 369 case SYS___sigaction14 : 370 (void)snprintf(bp, BLEFT, "(%s", 371 signals[(int)*ap].name); 372 s = ", "; 373 argsize -= sizeof(register_t); 374 ap++; 375 break; 376 case SYS_ioctl : 377 if (decimal) 378 (void)snprintf(bp, BLEFT, "(%ld", 379 (long)*ap); 380 else 381 (void)snprintf(bp, BLEFT, "(%#lx", 382 (long)*ap); 383 bp += strlen(bp); 384 ap++; 385 argsize -= sizeof(register_t); 386 if ((s = ioctlname(*ap)) != NULL) 387 (void)snprintf(bp, BLEFT, ", %s", s); 388 else 389 ioctldecode(*ap); 390 s = ", "; 391 ap++; 392 argsize -= sizeof(register_t); 393 break; 394 case SYS_ptrace : 395 if (*ap >= 0 && *ap <= 396 sizeof(ptrace_ops) / sizeof(ptrace_ops[0])) 397 (void)snprintf(bp, BLEFT, "(%s", 398 ptrace_ops[*ap]); 399 else 400 (void)snprintf(bp, BLEFT, "(%ld", 401 (long)*ap); 402 s = ", "; 403 ap++; 404 argsize -= sizeof(register_t); 405 break; 406 default : 407 break; 408 } 409 bp += strlen(bp); 410 } 411 if (eol) { 412 while (argsize) { 413 if (!nohdr || strcmp(s, "(")) { 414 if (decimal) 415 (void)snprintf(bp, BLEFT, 416 "%s%ld", s, 417 (long)*ap); 418 else 419 (void)snprintf(bp, BLEFT, 420 "%s%#lx", s, 421 (long)*ap); 422 bp += strlen(bp); 423 } 424 s = ", "; 425 ap++; 426 argsize -= sizeof(register_t); 427 } 428 if (BLEFT > 1) 429 *bp++ = ')'; 430 } 431 } 432 *bp = '\0'; 433 434 *lenp = bp - buff; 435 return eol; 436 } 437 438 void 439 ktrsysret(ktr, buff, buffsz, lenp) 440 struct ktr_sysret *ktr; 441 int buffsz, *lenp; 442 char *buff; 443 { 444 register int ret = ktr->ktr_retval; 445 register int error = ktr->ktr_error; 446 447 while (*lenp < 50) 448 buff[(*lenp)++] = ' '; 449 if (error == EJUSTRETURN) 450 strcpy(buff + *lenp, " JUSTRETURN"); 451 else if (error == ERESTART) 452 strcpy(buff + *lenp, " RESTART"); 453 else if (error) { 454 sprintf(buff + *lenp, " Err#%d", error); 455 if (error < MAXERRNOS && error >= -2) 456 sprintf(buff + strlen(buff), " %s",errnos[error].name); 457 } else 458 sprintf(buff + *lenp, " = %d", ret); 459 strcat(buff + *lenp, "\n"); 460 *lenp = 0; 461 fputs(buff, stdout); 462 *buff = '\0'; 463 } 464 465 void 466 ktrnamei(cp, len, buff, buffsz, lenp) 467 int buffsz, *lenp; 468 char *cp, *buff; 469 { 470 snprintf(buff + *lenp, buffsz - *lenp, "\"%.*s\"", len, cp); 471 *lenp += strlen(buff + *lenp); 472 } 473 474 void 475 ktremul(cp, len, buff, buffsz, lenp) 476 int buffsz, *lenp; 477 char *cp, *buff; 478 { 479 bzero(buff + *lenp, buffsz - *lenp); 480 cp[len] = '\0'; 481 snprintf(buff + *lenp, buffsz - *lenp, "emul(%s)\n", cp); 482 *lenp += strlen(buff + *lenp); 483 484 setemul(cp); 485 } 486 487 void 488 ktrgenio(ktr, len, buff, bufsz, lenp) 489 struct ktr_genio *ktr; 490 int len; 491 char *buff; 492 int bufsz, *lenp; 493 { 494 static int screenwidth = 0; 495 register int datalen = len - sizeof (struct ktr_genio); 496 register char *dp = (char *)ktr + sizeof (struct ktr_genio); 497 register int col = 0; 498 register int width; 499 char visbuf[5], *bp = buff; 500 501 if (*lenp < bufsz) { 502 bp += *lenp; 503 bzero(buff, BLEFT); 504 } else 505 *lenp = 0; 506 if (screenwidth == 0) { 507 struct winsize ws; 508 509 if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 && 510 ws.ws_col > 8) 511 screenwidth = ws.ws_col; 512 else 513 screenwidth = 80; 514 } 515 516 if (maxdata && datalen > maxdata) 517 datalen = maxdata; 518 strcpy(bp, " \""); 519 col = *lenp; 520 col += 8; 521 bp += 8; 522 for (; datalen > 0; datalen--, dp++) { 523 (void) vis(visbuf, *dp, VIS_NL|VIS_TAB|VIS_CSTYLE, *(dp+1)); 524 width = strlen(visbuf); 525 visbuf[4] = '\0'; 526 if (col + width + 2 >= screenwidth) 527 break; 528 col += width; 529 strncpy(bp, visbuf, width); 530 bp += width; 531 if (col + 2 >= screenwidth) 532 break; 533 } 534 strcpy(bp, "\"\n"); 535 *lenp = col + 2; 536 } 537 538 void 539 ktrpsig(psig) 540 struct ktr_psig *psig; 541 { 542 u_long msk; 543 544 (void)printf("SIG%s ", sys_signame[psig->signo]); 545 if (psig->action == SIG_DFL) 546 (void)printf("SIG_DFL\n"); 547 else { 548 msk = 0; 549 bcopy((char *)&psig->mask, (char *)msk, sizeof(psig->mask)); 550 (void)printf("caught handler=0x%lx mask=0x%lx code=0x%x\n", 551 (u_long)psig->action, msk, psig->code); 552 } 553 } 554 555 void 556 ktrcsw(cs) 557 struct ktr_csw *cs; 558 { 559 (void)printf("%s %s\n", cs->out ? "stop" : "resume", 560 cs->user ? "user" : "kernel"); 561 } 562 563 void 564 setemul(name) 565 char *name; 566 { 567 int i; 568 for (i = 0; emulations[i].name != NULL; i++) 569 if (strcmp(emulations[i].name, name) == 0) { 570 current = &emulations[i]; 571 return; 572 } 573 warnx("Emulation `%s' unknown", name); 574 } 575
Indexes created Tue Sep 23 07:09:52 GMT 2025