11590Srgrimes/*- 21590Srgrimes * Copyright (c) 1988, 1993 31590Srgrimes * The Regents of the University of California. All rights reserved. 41590Srgrimes * 51590Srgrimes * Redistribution and use in source and binary forms, with or without 61590Srgrimes * modification, are permitted provided that the following conditions 71590Srgrimes * are met: 81590Srgrimes * 1. Redistributions of source code must retain the above copyright 91590Srgrimes * notice, this list of conditions and the following disclaimer. 101590Srgrimes * 2. Redistributions in binary form must reproduce the above copyright 111590Srgrimes * notice, this list of conditions and the following disclaimer in the 121590Srgrimes * documentation and/or other materials provided with the distribution. 131590Srgrimes * 4. Neither the name of the University nor the names of its contributors 141590Srgrimes * may be used to endorse or promote products derived from this software 151590Srgrimes * without specific prior written permission. 161590Srgrimes * 171590Srgrimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 181590Srgrimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 191590Srgrimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 201590Srgrimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 211590Srgrimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 221590Srgrimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 231590Srgrimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 241590Srgrimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 251590Srgrimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 261590Srgrimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 271590Srgrimes * SUCH DAMAGE. 281590Srgrimes */ 291590Srgrimes 301590Srgrimes#ifndef lint 3127443Scharnierstatic const char copyright[] = 321590Srgrimes"@(#) Copyright (c) 1988, 1993\n\ 331590Srgrimes The Regents of the University of California. All rights reserved.\n"; 341590Srgrimes#endif /* not lint */ 351590Srgrimes 361590Srgrimes#ifndef lint 3727443Scharnier#if 0 381590Srgrimesstatic char sccsid[] = "@(#)kdump.c 8.1 (Berkeley) 6/6/93"; 3927443Scharnier#endif 401590Srgrimes#endif /* not lint */ 4199112Sobrien#include <sys/cdefs.h> 4299112Sobrien__FBSDID("$FreeBSD: stable/10/usr.bin/kdump/kdump.c 311708 2017-01-09 00:09:19Z jhb $"); 431590Srgrimes 44311708Sjhb#define _WANT_KERNEL_ERRNO 451590Srgrimes#include <sys/param.h> 46280250Srwatson#include <sys/capsicum.h> 471590Srgrimes#include <sys/errno.h> 48100824Sdwmalone#define _KERNEL 491590Srgrimes#include <sys/time.h> 50100824Sdwmalone#undef _KERNEL 511590Srgrimes#include <sys/uio.h> 521590Srgrimes#include <sys/ktrace.h> 531590Srgrimes#include <sys/ioctl.h> 54165758Srodrigc#include <sys/socket.h> 55176471Sdes#include <sys/stat.h> 56219043Sdchagin#include <sys/sysent.h> 57275843Sjhb#include <sys/umtx.h> 58176471Sdes#include <sys/un.h> 59219043Sdchagin#include <sys/queue.h> 60255493Sjhb#include <sys/wait.h> 61176471Sdes#ifdef IPX 62176471Sdes#include <sys/types.h> 63176471Sdes#include <netipx/ipx.h> 64176471Sdes#endif 65176471Sdes#ifdef NETATALK 66176471Sdes#include <netatalk/at.h> 67176471Sdes#endif 68190168Sdelphij#include <arpa/inet.h> 69176471Sdes#include <netinet/in.h> 70190168Sdelphij#include <ctype.h> 71165916Sjhb#include <dlfcn.h> 7227443Scharnier#include <err.h> 73176471Sdes#include <grp.h> 74176471Sdes#include <inttypes.h> 7527443Scharnier#include <locale.h> 76251486Sae#include <netdb.h> 77251073Spjd#include <nl_types.h> 78176471Sdes#include <pwd.h> 79311546Sjhb#include <stddef.h> 801590Srgrimes#include <stdio.h> 811590Srgrimes#include <stdlib.h> 821590Srgrimes#include <string.h> 83251073Spjd#include <termios.h> 84176471Sdes#include <time.h> 8527443Scharnier#include <unistd.h> 8627443Scharnier#include <vis.h> 871590Srgrimes#include "ktrace.h" 88158766Snetchild#include "kdump_subr.h" 891590Srgrimes 90219043Sdchaginu_int abidump(struct ktr_header *); 91219043Sdchaginint fetchprocinfo(struct ktr_header *, u_int *); 92100824Sdwmaloneint fread_tail(void *, int, int); 93100824Sdwmalonevoid dumpheader(struct ktr_header *); 94219043Sdchaginvoid ktrsyscall(struct ktr_syscall *, u_int); 95219043Sdchaginvoid ktrsysret(struct ktr_sysret *, u_int); 96100824Sdwmalonevoid ktrnamei(char *, int); 97115759Spetervoid hexdump(char *, int, int); 98115759Spetervoid visdump(char *, int, int); 99100824Sdwmalonevoid ktrgenio(struct ktr_genio *, int); 100219138Sdchaginvoid ktrpsig(struct ktr_psig *); 101100824Sdwmalonevoid ktrcsw(struct ktr_csw *); 102234494Sjhbvoid ktrcsw_old(struct ktr_csw_old *); 103277106Sdchaginvoid ktruser_malloc(void *); 104277106Sdchaginvoid ktruser_rtld(int, void *); 105277106Sdchaginvoid ktruser(int, void *); 106255219Spjdvoid ktrcaprights(cap_rights_t *); 107303093Skibvoid ktritimerval(struct itimerval *it); 108176471Sdesvoid ktrsockaddr(struct sockaddr *); 109176471Sdesvoid ktrstat(struct stat *); 110176471Sdesvoid ktrstruct(char *, size_t); 111226269Sdesvoid ktrcapfail(struct ktr_cap_fail *); 112233925Sjhbvoid ktrfault(struct ktr_fault *); 113233925Sjhbvoid ktrfaultend(struct ktr_faultend *); 114251073Spjdvoid limitfd(int fd); 115100824Sdwmalonevoid usage(void); 116226157Sdesvoid ioctlname(unsigned long, int); 117100824Sdwmalone 118277106Sdchaginextern const char *signames[], *syscallnames[]; 119277106Sdchaginextern int nsyscalls; 120277106Sdchagin 121277106Sdchaginstatic int timestamp, decimal, fancy = 1, suppressdata, tail, threads, maxdata, 122264332Sbdrewery resolv = 0, abiflag = 0, syscallno = 0; 123277106Sdchaginstatic const char *tracefile = DEF_TRACEFILE; 124277106Sdchaginstatic struct ktr_header ktr_header; 1251590Srgrimes 126176471Sdes#define TIME_FORMAT "%b %e %T %Y" 1271590Srgrimes#define eqs(s1, s2) (strcmp((s1), (s2)) == 0) 1281590Srgrimes 129311546Sjhb#define print_number64(first,i,n,c) do { \ 130311546Sjhb uint64_t __v; \ 131311546Sjhb \ 132311546Sjhb if (quad_align && (((ptrdiff_t)((i) - (first))) & 1) == 1) { \ 133311546Sjhb (i)++; \ 134311546Sjhb (n)--; \ 135311546Sjhb } \ 136311546Sjhb if (quad_slots == 2) \ 137311546Sjhb __v = (uint64_t)(uint32_t)(i)[0] | \ 138311546Sjhb ((uint64_t)(uint32_t)(i)[1]) << 32; \ 139311546Sjhb else \ 140311546Sjhb __v = (uint64_t)*(i); \ 141311546Sjhb if (decimal) \ 142311546Sjhb printf("%c%jd", (c), (intmax_t)__v); \ 143311546Sjhb else \ 144311546Sjhb printf("%c%#jx", (c), (uintmax_t)__v); \ 145311546Sjhb (i) += quad_slots; \ 146311546Sjhb (n) -= quad_slots; \ 147311546Sjhb (c) = ','; \ 148311546Sjhb} while (0) 149311546Sjhb 150226262Sdes#define print_number(i,n,c) do { \ 151226262Sdes if (decimal) \ 152226262Sdes printf("%c%jd", c, (intmax_t)*i); \ 153226262Sdes else \ 154226262Sdes printf("%c%#jx", c, (uintmax_t)(u_register_t)*i); \ 155226262Sdes i++; \ 156226262Sdes n--; \ 157226262Sdes c = ','; \ 158226164Sdes} while (0) 159219138Sdchagin 160219138Sdchagin#if defined(__amd64__) || defined(__i386__) 161219138Sdchagin 162294135Sdchaginvoid linux_ktrsyscall(struct ktr_syscall *, u_int); 163294135Sdchaginvoid linux_ktrsysret(struct ktr_sysret *, u_int); 164277106Sdchaginextern const char *linux_syscallnames[]; 165219138Sdchagin 166277106Sdchagin#include <linux_syscalls.c> 167277106Sdchagin 168219138Sdchagin/* 169219138Sdchagin * from linux.h 170219138Sdchagin * Linux syscalls return negative errno's, we do positive and map them 171219138Sdchagin */ 172219138Sdchaginstatic int bsd_to_linux_errno[ELAST + 1] = { 173219138Sdchagin -0, -1, -2, -3, -4, -5, -6, -7, -8, -9, 174219138Sdchagin -10, -35, -12, -13, -14, -15, -16, -17, -18, -19, 175219138Sdchagin -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, 176219138Sdchagin -30, -31, -32, -33, -34, -11,-115,-114, -88, -89, 177219138Sdchagin -90, -91, -92, -93, -94, -95, -96, -97, -98, -99, 178219138Sdchagin -100,-101,-102,-103,-104,-105,-106,-107,-108,-109, 179219138Sdchagin -110,-111, -40, -36,-112,-113, -39, -11, -87,-122, 180219138Sdchagin -116, -66, -6, -6, -6, -6, -6, -37, -38, -9, 181219138Sdchagin -6, -6, -43, -42, -75,-125, -84, -95, -16, -74, 182219138Sdchagin -72, -67, -71 183219138Sdchagin}; 184219138Sdchagin#endif 185219138Sdchagin 186294135Sdchagin#if defined(__amd64__) 187294135Sdchaginextern const char *linux32_syscallnames[]; 188294135Sdchagin 189294135Sdchagin#include <linux32_syscalls.c> 190294135Sdchagin#endif 191294135Sdchagin 192219043Sdchaginstruct proc_info 193219043Sdchagin{ 194219043Sdchagin TAILQ_ENTRY(proc_info) info; 195219043Sdchagin u_int sv_flags; 196219043Sdchagin pid_t pid; 197219043Sdchagin}; 198219043Sdchagin 199277106Sdchaginstatic TAILQ_HEAD(trace_procs, proc_info) trace_procs; 200219043Sdchagin 201253456Spjdstatic void 202253456Spjdstrerror_init(void) 203253456Spjd{ 204253456Spjd 205253456Spjd /* 206253456Spjd * Cache NLS data before entering capability mode. 207253456Spjd * XXXPJD: There should be strerror_init() and strsignal_init() in libc. 208253456Spjd */ 209253456Spjd (void)catopen("libc", NL_CAT_LOCALE); 210253456Spjd} 211253456Spjd 212253456Spjdstatic void 213253456Spjdlocaltime_init(void) 214253456Spjd{ 215253456Spjd time_t ltime; 216253456Spjd 217253456Spjd /* 218253456Spjd * Allow localtime(3) to cache /etc/localtime content before entering 219253456Spjd * capability mode. 220253456Spjd * XXXPJD: There should be localtime_init() in libc. 221253456Spjd */ 222253456Spjd (void)time(<ime); 223253456Spjd (void)localtime(<ime); 224253456Spjd} 225253456Spjd 226100824Sdwmaloneint 227100824Sdwmalonemain(int argc, char *argv[]) 2281590Srgrimes{ 2291590Srgrimes int ch, ktrlen, size; 230100824Sdwmalone void *m; 2311590Srgrimes int trpoints = ALL_POINTS; 232112201Sjhb int drop_logged; 233115759Speter pid_t pid = 0; 234219043Sdchagin u_int sv_flags; 2351590Srgrimes 236226153Sdes setlocale(LC_CTYPE, ""); 23711823Sache 238264332Sbdrewery while ((ch = getopt(argc,argv,"f:dElm:np:AHRrSsTt:")) != -1) 239226153Sdes switch (ch) { 240219043Sdchagin case 'A': 241219043Sdchagin abiflag = 1; 242219043Sdchagin break; 2431590Srgrimes case 'f': 2441590Srgrimes tracefile = optarg; 2451590Srgrimes break; 2461590Srgrimes case 'd': 2471590Srgrimes decimal = 1; 2481590Srgrimes break; 2491590Srgrimes case 'l': 2501590Srgrimes tail = 1; 2511590Srgrimes break; 2521590Srgrimes case 'm': 2531590Srgrimes maxdata = atoi(optarg); 2541590Srgrimes break; 2551590Srgrimes case 'n': 2561590Srgrimes fancy = 0; 2571590Srgrimes break; 258115759Speter case 'p': 259115759Speter pid = atoi(optarg); 260115759Speter break; 261176471Sdes case 'r': 262176471Sdes resolv = 1; 263176471Sdes break; 264264332Sbdrewery case 'S': 265264332Sbdrewery syscallno = 1; 266264332Sbdrewery break; 267152331Srwatson case 's': 268152331Srwatson suppressdata = 1; 269152331Srwatson break; 270123187Speter case 'E': 271123187Speter timestamp = 3; /* elapsed timestamp */ 272123187Speter break; 273151930Srwatson case 'H': 274151930Srwatson threads = 1; 275151930Srwatson break; 2761590Srgrimes case 'R': 2771590Srgrimes timestamp = 2; /* relative timestamp */ 2781590Srgrimes break; 2791590Srgrimes case 'T': 2801590Srgrimes timestamp = 1; 2811590Srgrimes break; 2821590Srgrimes case 't': 2831590Srgrimes trpoints = getpoints(optarg); 28427443Scharnier if (trpoints < 0) 28527443Scharnier errx(1, "unknown trace point in %s", optarg); 2861590Srgrimes break; 2871590Srgrimes default: 2881590Srgrimes usage(); 2891590Srgrimes } 2901590Srgrimes 29119853Sfenner if (argc > optind) 2921590Srgrimes usage(); 2931590Srgrimes 294226153Sdes m = malloc(size = 1025); 29527443Scharnier if (m == NULL) 29627443Scharnier errx(1, "%s", strerror(ENOMEM)); 29727443Scharnier if (!freopen(tracefile, "r", stdin)) 29827443Scharnier err(1, "%s", tracefile); 299251073Spjd 300253456Spjd strerror_init(); 301253456Spjd localtime_init(); 302253456Spjd 303251167Spjd if (resolv == 0) { 304251167Spjd if (cap_enter() < 0 && errno != ENOSYS) 305251167Spjd err(1, "unable to enter capability mode"); 306251167Spjd } 307251073Spjd limitfd(STDIN_FILENO); 308251073Spjd limitfd(STDOUT_FILENO); 309251073Spjd limitfd(STDERR_FILENO); 310251073Spjd 311219043Sdchagin TAILQ_INIT(&trace_procs); 312112201Sjhb drop_logged = 0; 3131590Srgrimes while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) { 314112201Sjhb if (ktr_header.ktr_type & KTR_DROP) { 315112201Sjhb ktr_header.ktr_type &= ~KTR_DROP; 316151930Srwatson if (!drop_logged && threads) { 317226153Sdes printf( 318203551Sjh "%6jd %6jd %-8.*s Events dropped.\n", 319203551Sjh (intmax_t)ktr_header.ktr_pid, 320203551Sjh ktr_header.ktr_tid > 0 ? 321203551Sjh (intmax_t)ktr_header.ktr_tid : 0, 322203551Sjh MAXCOMLEN, ktr_header.ktr_comm); 323151930Srwatson drop_logged = 1; 324151930Srwatson } else if (!drop_logged) { 325226153Sdes printf("%6jd %-8.*s Events dropped.\n", 326203551Sjh (intmax_t)ktr_header.ktr_pid, MAXCOMLEN, 327112201Sjhb ktr_header.ktr_comm); 328112201Sjhb drop_logged = 1; 329112201Sjhb } 330112201Sjhb } 3311590Srgrimes if (trpoints & (1<<ktr_header.ktr_type)) 332236577Sjhb if (pid == 0 || ktr_header.ktr_pid == pid || 333236577Sjhb ktr_header.ktr_tid == pid) 334115759Speter dumpheader(&ktr_header); 33527443Scharnier if ((ktrlen = ktr_header.ktr_len) < 0) 33627443Scharnier errx(1, "bogus length 0x%x", ktrlen); 3371590Srgrimes if (ktrlen > size) { 338226153Sdes m = realloc(m, ktrlen+1); 33927443Scharnier if (m == NULL) 34027443Scharnier errx(1, "%s", strerror(ENOMEM)); 3411590Srgrimes size = ktrlen; 3421590Srgrimes } 34327443Scharnier if (ktrlen && fread_tail(m, ktrlen, 1) == 0) 34427443Scharnier errx(1, "data too short"); 345219043Sdchagin if (fetchprocinfo(&ktr_header, (u_int *)m) != 0) 346219043Sdchagin continue; 347219043Sdchagin sv_flags = abidump(&ktr_header); 348236577Sjhb if (pid && ktr_header.ktr_pid != pid && 349236577Sjhb ktr_header.ktr_tid != pid) 350115759Speter continue; 3511590Srgrimes if ((trpoints & (1<<ktr_header.ktr_type)) == 0) 3521590Srgrimes continue; 353112201Sjhb drop_logged = 0; 3541590Srgrimes switch (ktr_header.ktr_type) { 3551590Srgrimes case KTR_SYSCALL: 356219138Sdchagin#if defined(__amd64__) || defined(__i386__) 357219138Sdchagin if ((sv_flags & SV_ABI_MASK) == SV_ABI_LINUX) 358294135Sdchagin linux_ktrsyscall((struct ktr_syscall *)m, 359294135Sdchagin sv_flags); 360219138Sdchagin else 361219138Sdchagin#endif 362219138Sdchagin ktrsyscall((struct ktr_syscall *)m, sv_flags); 3631590Srgrimes break; 3641590Srgrimes case KTR_SYSRET: 365219138Sdchagin#if defined(__amd64__) || defined(__i386__) 366219138Sdchagin if ((sv_flags & SV_ABI_MASK) == SV_ABI_LINUX) 367294135Sdchagin linux_ktrsysret((struct ktr_sysret *)m, 368294135Sdchagin sv_flags); 369219138Sdchagin else 370219138Sdchagin#endif 371219138Sdchagin ktrsysret((struct ktr_sysret *)m, sv_flags); 3721590Srgrimes break; 3731590Srgrimes case KTR_NAMEI: 374189707Sjhb case KTR_SYSCTL: 3751590Srgrimes ktrnamei(m, ktrlen); 3761590Srgrimes break; 3771590Srgrimes case KTR_GENIO: 3781590Srgrimes ktrgenio((struct ktr_genio *)m, ktrlen); 3791590Srgrimes break; 3801590Srgrimes case KTR_PSIG: 381219138Sdchagin ktrpsig((struct ktr_psig *)m); 3821590Srgrimes break; 3831590Srgrimes case KTR_CSW: 384234494Sjhb if (ktrlen == sizeof(struct ktr_csw_old)) 385234494Sjhb ktrcsw_old((struct ktr_csw_old *)m); 386234494Sjhb else 387234494Sjhb ktrcsw((struct ktr_csw *)m); 3881590Srgrimes break; 38918400Sphk case KTR_USER: 39018470Sphk ktruser(ktrlen, m); 39118400Sphk break; 392176471Sdes case KTR_STRUCT: 393176471Sdes ktrstruct(m, ktrlen); 394176471Sdes break; 395226269Sdes case KTR_CAPFAIL: 396226269Sdes ktrcapfail((struct ktr_cap_fail *)m); 397233925Sjhb break; 398233925Sjhb case KTR_FAULT: 399233925Sjhb ktrfault((struct ktr_fault *)m); 400233925Sjhb break; 401233925Sjhb case KTR_FAULTEND: 402233925Sjhb ktrfaultend((struct ktr_faultend *)m); 403233925Sjhb break; 404112203Sjhb default: 405112203Sjhb printf("\n"); 406112203Sjhb break; 4071590Srgrimes } 4081590Srgrimes if (tail) 409226153Sdes fflush(stdout); 4101590Srgrimes } 411100824Sdwmalone return 0; 4121590Srgrimes} 4131590Srgrimes 414251073Spjdvoid 415251073Spjdlimitfd(int fd) 416251073Spjd{ 417251073Spjd cap_rights_t rights; 418251073Spjd unsigned long cmd; 419251073Spjd 420255219Spjd cap_rights_init(&rights, CAP_FSTAT); 421277106Sdchagin cmd = 0; 422251073Spjd 423251073Spjd switch (fd) { 424251073Spjd case STDIN_FILENO: 425255219Spjd cap_rights_set(&rights, CAP_READ); 426251073Spjd break; 427251073Spjd case STDOUT_FILENO: 428255219Spjd cap_rights_set(&rights, CAP_IOCTL, CAP_WRITE); 429251073Spjd cmd = TIOCGETA; /* required by isatty(3) in printf(3) */ 430251073Spjd break; 431251073Spjd case STDERR_FILENO: 432255219Spjd cap_rights_set(&rights, CAP_WRITE); 433251073Spjd if (!suppressdata) { 434255219Spjd cap_rights_set(&rights, CAP_IOCTL); 435251073Spjd cmd = TIOCGWINSZ; 436251073Spjd } 437251073Spjd break; 438251073Spjd default: 439251073Spjd abort(); 440251073Spjd } 441251073Spjd 442255219Spjd if (cap_rights_limit(fd, &rights) < 0 && errno != ENOSYS) 443251073Spjd err(1, "unable to limit rights for descriptor %d", fd); 444277106Sdchagin if (cmd != 0 && cap_ioctls_limit(fd, &cmd, 1) < 0 && errno != ENOSYS) 445251073Spjd err(1, "unable to limit ioctls for descriptor %d", fd); 446251073Spjd} 447251073Spjd 448100824Sdwmaloneint 449100824Sdwmalonefread_tail(void *buf, int size, int num) 4501590Srgrimes{ 4511590Srgrimes int i; 4521590Srgrimes 4531590Srgrimes while ((i = fread(buf, size, num, stdin)) == 0 && tail) { 454226153Sdes sleep(1); 4551590Srgrimes clearerr(stdin); 4561590Srgrimes } 4571590Srgrimes return (i); 4581590Srgrimes} 4591590Srgrimes 460219043Sdchaginint 461219043Sdchaginfetchprocinfo(struct ktr_header *kth, u_int *flags) 462219043Sdchagin{ 463219043Sdchagin struct proc_info *pi; 464219043Sdchagin 465219043Sdchagin switch (kth->ktr_type) { 466219043Sdchagin case KTR_PROCCTOR: 467219043Sdchagin TAILQ_FOREACH(pi, &trace_procs, info) { 468219043Sdchagin if (pi->pid == kth->ktr_pid) { 469219043Sdchagin TAILQ_REMOVE(&trace_procs, pi, info); 470219043Sdchagin break; 471219043Sdchagin } 472219043Sdchagin } 473219043Sdchagin pi = malloc(sizeof(struct proc_info)); 474219043Sdchagin if (pi == NULL) 475219043Sdchagin errx(1, "%s", strerror(ENOMEM)); 476219043Sdchagin pi->sv_flags = *flags; 477219043Sdchagin pi->pid = kth->ktr_pid; 478219043Sdchagin TAILQ_INSERT_TAIL(&trace_procs, pi, info); 479219043Sdchagin return (1); 480219043Sdchagin 481219043Sdchagin case KTR_PROCDTOR: 482219043Sdchagin TAILQ_FOREACH(pi, &trace_procs, info) { 483219043Sdchagin if (pi->pid == kth->ktr_pid) { 484219043Sdchagin TAILQ_REMOVE(&trace_procs, pi, info); 485219043Sdchagin free(pi); 486219043Sdchagin break; 487219043Sdchagin } 488219043Sdchagin } 489219043Sdchagin return (1); 490219043Sdchagin } 491219043Sdchagin 492219043Sdchagin return (0); 493219043Sdchagin} 494219043Sdchagin 495219043Sdchaginu_int 496219043Sdchaginabidump(struct ktr_header *kth) 497219043Sdchagin{ 498219043Sdchagin struct proc_info *pi; 499219043Sdchagin const char *abi; 500219043Sdchagin const char *arch; 501219043Sdchagin u_int flags = 0; 502219043Sdchagin 503219043Sdchagin TAILQ_FOREACH(pi, &trace_procs, info) { 504219043Sdchagin if (pi->pid == kth->ktr_pid) { 505219043Sdchagin flags = pi->sv_flags; 506219043Sdchagin break; 507219043Sdchagin } 508219043Sdchagin } 509219043Sdchagin 510219043Sdchagin if (abiflag == 0) 511219043Sdchagin return (flags); 512219043Sdchagin 513219043Sdchagin switch (flags & SV_ABI_MASK) { 514219043Sdchagin case SV_ABI_LINUX: 515219043Sdchagin abi = "L"; 516219043Sdchagin break; 517219043Sdchagin case SV_ABI_FREEBSD: 518219043Sdchagin abi = "F"; 519219043Sdchagin break; 520219043Sdchagin default: 521219043Sdchagin abi = "U"; 522219043Sdchagin break; 523219043Sdchagin } 524219043Sdchagin 525219043Sdchagin if (flags != 0) { 526219043Sdchagin if (flags & SV_LP64) 527219043Sdchagin arch = "64"; 528219043Sdchagin else 529219043Sdchagin arch = "32"; 530219043Sdchagin } else 531219043Sdchagin arch = "00"; 532219043Sdchagin 533219043Sdchagin printf("%s%s ", abi, arch); 534219043Sdchagin 535219043Sdchagin return (flags); 536219043Sdchagin} 537219043Sdchagin 538100824Sdwmalonevoid 539100824Sdwmalonedumpheader(struct ktr_header *kth) 5401590Srgrimes{ 5411590Srgrimes static char unknown[64]; 5421590Srgrimes static struct timeval prevtime, temp; 543100824Sdwmalone const char *type; 5441590Srgrimes 5451590Srgrimes switch (kth->ktr_type) { 5461590Srgrimes case KTR_SYSCALL: 5471590Srgrimes type = "CALL"; 5481590Srgrimes break; 5491590Srgrimes case KTR_SYSRET: 5501590Srgrimes type = "RET "; 5511590Srgrimes break; 5521590Srgrimes case KTR_NAMEI: 5531590Srgrimes type = "NAMI"; 5541590Srgrimes break; 5551590Srgrimes case KTR_GENIO: 5561590Srgrimes type = "GIO "; 5571590Srgrimes break; 5581590Srgrimes case KTR_PSIG: 5591590Srgrimes type = "PSIG"; 5601590Srgrimes break; 5611590Srgrimes case KTR_CSW: 562171333Sjhb type = "CSW "; 5631590Srgrimes break; 56418400Sphk case KTR_USER: 56518400Sphk type = "USER"; 56618400Sphk break; 567176471Sdes case KTR_STRUCT: 568176471Sdes type = "STRU"; 569176471Sdes break; 570189707Sjhb case KTR_SYSCTL: 571189707Sjhb type = "SCTL"; 572189707Sjhb break; 573219043Sdchagin case KTR_PROCCTOR: 574219043Sdchagin /* FALLTHROUGH */ 575219043Sdchagin case KTR_PROCDTOR: 576219043Sdchagin return; 577226269Sdes case KTR_CAPFAIL: 578226269Sdes type = "CAP "; 579226269Sdes break; 580233925Sjhb case KTR_FAULT: 581233925Sjhb type = "PFLT"; 582233925Sjhb break; 583233925Sjhb case KTR_FAULTEND: 584233925Sjhb type = "PRET"; 585233925Sjhb break; 5861590Srgrimes default: 587226153Sdes sprintf(unknown, "UNKNOWN(%d)", kth->ktr_type); 5881590Srgrimes type = unknown; 5891590Srgrimes } 5901590Srgrimes 591151930Srwatson /* 592151930Srwatson * The ktr_tid field was previously the ktr_buffer field, which held 593151930Srwatson * the kernel pointer value for the buffer associated with data 594151930Srwatson * following the record header. It now holds a threadid, but only 595151930Srwatson * for trace files after the change. Older trace files still contain 596151930Srwatson * kernel pointers. Detect this and suppress the results by printing 597151930Srwatson * negative tid's as 0. 598151930Srwatson */ 599151930Srwatson if (threads) 600226153Sdes printf("%6jd %6jd %-8.*s ", (intmax_t)kth->ktr_pid, 601203551Sjh kth->ktr_tid > 0 ? (intmax_t)kth->ktr_tid : 0, 602203551Sjh MAXCOMLEN, kth->ktr_comm); 603151930Srwatson else 604226153Sdes printf("%6jd %-8.*s ", (intmax_t)kth->ktr_pid, MAXCOMLEN, 605151930Srwatson kth->ktr_comm); 6061590Srgrimes if (timestamp) { 607123187Speter if (timestamp == 3) { 608123187Speter if (prevtime.tv_sec == 0) 609123187Speter prevtime = kth->ktr_time; 610123187Speter timevalsub(&kth->ktr_time, &prevtime); 611123187Speter } 6121590Srgrimes if (timestamp == 2) { 6131590Srgrimes temp = kth->ktr_time; 6141590Srgrimes timevalsub(&kth->ktr_time, &prevtime); 6151590Srgrimes prevtime = temp; 6161590Srgrimes } 617226153Sdes printf("%jd.%06ld ", (intmax_t)kth->ktr_time.tv_sec, 618203551Sjh kth->ktr_time.tv_usec); 6191590Srgrimes } 620226153Sdes printf("%s ", type); 6211590Srgrimes} 6221590Srgrimes 6231590Srgrimes#include <sys/syscall.h> 6241590Srgrimes#define KTRACE 6254721Sphk#include <sys/kern/syscalls.c> 6261590Srgrimes#undef KTRACE 6271590Srgrimesint nsyscalls = sizeof (syscallnames) / sizeof (syscallnames[0]); 6281590Srgrimes 629100824Sdwmalonevoid 630219043Sdchaginktrsyscall(struct ktr_syscall *ktr, u_int flags) 6311590Srgrimes{ 632100824Sdwmalone int narg = ktr->ktr_narg; 633311546Sjhb register_t *ip, *first; 634226269Sdes intmax_t arg; 635311546Sjhb int quad_align, quad_slots; 6361590Srgrimes 637219043Sdchagin if ((flags != 0 && ((flags & SV_ABI_MASK) != SV_ABI_FREEBSD)) || 638219043Sdchagin (ktr->ktr_code >= nsyscalls || ktr->ktr_code < 0)) 639226153Sdes printf("[%d]", ktr->ktr_code); 640264332Sbdrewery else { 641226153Sdes printf("%s", syscallnames[ktr->ktr_code]); 642264332Sbdrewery if (syscallno) 643264332Sbdrewery printf("[%d]", ktr->ktr_code); 644264332Sbdrewery } 645311546Sjhb ip = first = &ktr->ktr_args[0]; 6461590Srgrimes if (narg) { 6471590Srgrimes char c = '('; 648219043Sdchagin if (fancy && 649219043Sdchagin (flags == 0 || (flags & SV_ABI_MASK) == SV_ABI_FREEBSD)) { 650311546Sjhb quad_align = 0; 651311546Sjhb if (flags & SV_ILP32) { 652311546Sjhb#ifdef __powerpc__ 653311546Sjhb quad_align = 1; 654311546Sjhb#endif 655311546Sjhb quad_slots = 2; 656311546Sjhb } else 657311546Sjhb quad_slots = 1; 658226148Sdes switch (ktr->ktr_code) { 659254296Sjilles case SYS_bindat: 660254296Sjilles case SYS_connectat: 661254291Sjilles case SYS_faccessat: 662254291Sjilles case SYS_fchmodat: 663254291Sjilles case SYS_fchownat: 664254291Sjilles case SYS_fstatat: 665254291Sjilles case SYS_futimesat: 666254291Sjilles case SYS_linkat: 667254291Sjilles case SYS_mkdirat: 668254291Sjilles case SYS_mkfifoat: 669254291Sjilles case SYS_mknodat: 670254291Sjilles case SYS_openat: 671254291Sjilles case SYS_readlinkat: 672254291Sjilles case SYS_renameat: 673254291Sjilles case SYS_unlinkat: 674293474Sdchagin case SYS_utimensat: 675254291Sjilles putchar('('); 676254291Sjilles atfdname(*ip, decimal); 677254291Sjilles c = ','; 678254291Sjilles ip++; 679254291Sjilles narg--; 680254291Sjilles break; 681254291Sjilles } 682254291Sjilles switch (ktr->ktr_code) { 683226148Sdes case SYS_ioctl: { 684226150Sdes print_number(ip, narg, c); 685226157Sdes putchar(c); 686226157Sdes ioctlname(*ip, decimal); 6871590Srgrimes c = ','; 6881590Srgrimes ip++; 6891590Srgrimes narg--; 690226148Sdes break; 691226148Sdes } 692226148Sdes case SYS_ptrace: 693226153Sdes putchar('('); 694226164Sdes ptraceopname(*ip); 6951590Srgrimes c = ','; 6961590Srgrimes ip++; 6971590Srgrimes narg--; 698226148Sdes break; 699226148Sdes case SYS_access: 700226148Sdes case SYS_eaccess: 701254291Sjilles case SYS_faccessat: 702226150Sdes print_number(ip, narg, c); 703226153Sdes putchar(','); 704226164Sdes accessmodename(*ip); 705158766Snetchild ip++; 706158766Snetchild narg--; 707226148Sdes break; 708226148Sdes case SYS_open: 709254291Sjilles case SYS_openat: 710226150Sdes print_number(ip, narg, c); 711226153Sdes putchar(','); 712226164Sdes flagsandmodename(ip[0], ip[1], decimal); 713226148Sdes ip += 2; 714226148Sdes narg -= 2; 715226148Sdes break; 716226148Sdes case SYS_wait4: 717226150Sdes print_number(ip, narg, c); 718226150Sdes print_number(ip, narg, c); 719255493Sjhb /* 720255493Sjhb * A flags value of zero is valid for 721255493Sjhb * wait4() but not for wait6(), so 722255493Sjhb * handle zero special here. 723255493Sjhb */ 724255493Sjhb if (*ip == 0) { 725255493Sjhb print_number(ip, narg, c); 726255493Sjhb } else { 727255493Sjhb putchar(','); 728255493Sjhb wait6optname(*ip); 729255493Sjhb ip++; 730255493Sjhb narg--; 731255493Sjhb } 732255493Sjhb break; 733255493Sjhb case SYS_wait6: 734255493Sjhb putchar('('); 735255493Sjhb idtypename(*ip, decimal); 736255493Sjhb c = ','; 737255493Sjhb ip++; 738255493Sjhb narg--; 739311546Sjhb print_number64(first, ip, narg, c); 740255493Sjhb print_number(ip, narg, c); 741226153Sdes putchar(','); 742255493Sjhb wait6optname(*ip); 743158766Snetchild ip++; 744158766Snetchild narg--; 745226148Sdes break; 746226148Sdes case SYS_chmod: 747226148Sdes case SYS_fchmod: 748226148Sdes case SYS_lchmod: 749226150Sdes print_number(ip, narg, c); 750226153Sdes putchar(','); 751226164Sdes modename(*ip); 752158766Snetchild ip++; 753158766Snetchild narg--; 754226148Sdes break; 755226148Sdes case SYS_mknod: 756254291Sjilles case SYS_mknodat: 757226150Sdes print_number(ip, narg, c); 758226153Sdes putchar(','); 759226164Sdes modename(*ip); 760158766Snetchild ip++; 761158766Snetchild narg--; 762226148Sdes break; 763226148Sdes case SYS_getfsstat: 764226150Sdes print_number(ip, narg, c); 765226150Sdes print_number(ip, narg, c); 766226153Sdes putchar(','); 767226164Sdes getfsstatflagsname(*ip); 768158766Snetchild ip++; 769158766Snetchild narg--; 770226148Sdes break; 771226148Sdes case SYS_mount: 772226150Sdes print_number(ip, narg, c); 773226150Sdes print_number(ip, narg, c); 774226153Sdes putchar(','); 775226164Sdes mountflagsname(*ip); 776158766Snetchild ip++; 777158766Snetchild narg--; 778226148Sdes break; 779226148Sdes case SYS_unmount: 780226150Sdes print_number(ip, narg, c); 781226153Sdes putchar(','); 782226164Sdes mountflagsname(*ip); 783158766Snetchild ip++; 784158766Snetchild narg--; 785226148Sdes break; 786226148Sdes case SYS_recvmsg: 787226148Sdes case SYS_sendmsg: 788226150Sdes print_number(ip, narg, c); 789226150Sdes print_number(ip, narg, c); 790226153Sdes putchar(','); 791226164Sdes sendrecvflagsname(*ip); 792158766Snetchild ip++; 793158766Snetchild narg--; 794226148Sdes break; 795226148Sdes case SYS_recvfrom: 796226148Sdes case SYS_sendto: 797226150Sdes print_number(ip, narg, c); 798226150Sdes print_number(ip, narg, c); 799226150Sdes print_number(ip, narg, c); 800226153Sdes putchar(','); 801226164Sdes sendrecvflagsname(*ip); 802158766Snetchild ip++; 803158766Snetchild narg--; 804226148Sdes break; 805226148Sdes case SYS_chflags: 806226148Sdes case SYS_fchflags: 807226148Sdes case SYS_lchflags: 808226150Sdes print_number(ip, narg, c); 809226153Sdes putchar(','); 810226164Sdes modename(*ip); 811158766Snetchild ip++; 812158766Snetchild narg--; 813226148Sdes break; 814226148Sdes case SYS_kill: 815226150Sdes print_number(ip, narg, c); 816226153Sdes putchar(','); 817226164Sdes signame(*ip); 818158766Snetchild ip++; 819158766Snetchild narg--; 820226148Sdes break; 821226148Sdes case SYS_reboot: 822226153Sdes putchar('('); 823226164Sdes rebootoptname(*ip); 824158766Snetchild ip++; 825158766Snetchild narg--; 826226148Sdes break; 827226148Sdes case SYS_umask: 828226153Sdes putchar('('); 829226164Sdes modename(*ip); 830158766Snetchild ip++; 831158766Snetchild narg--; 832226148Sdes break; 833226148Sdes case SYS_msync: 834226150Sdes print_number(ip, narg, c); 835226150Sdes print_number(ip, narg, c); 836226153Sdes putchar(','); 837226164Sdes msyncflagsname(*ip); 838158766Snetchild ip++; 839158766Snetchild narg--; 840226148Sdes break; 841171221Speter#ifdef SYS_freebsd6_mmap 842226148Sdes case SYS_freebsd6_mmap: 843226150Sdes print_number(ip, narg, c); 844226150Sdes print_number(ip, narg, c); 845226153Sdes putchar(','); 846226164Sdes mmapprotname(*ip); 847226153Sdes putchar(','); 848171221Speter ip++; 849171221Speter narg--; 850226164Sdes mmapflagsname(*ip); 851171221Speter ip++; 852171221Speter narg--; 853226148Sdes break; 854171221Speter#endif 855226148Sdes case SYS_mmap: 856226150Sdes print_number(ip, narg, c); 857226150Sdes print_number(ip, narg, c); 858226153Sdes putchar(','); 859226164Sdes mmapprotname(*ip); 860226153Sdes putchar(','); 861158766Snetchild ip++; 862158766Snetchild narg--; 863226164Sdes mmapflagsname(*ip); 864158766Snetchild ip++; 865158766Snetchild narg--; 866226148Sdes break; 867226148Sdes case SYS_mprotect: 868226150Sdes print_number(ip, narg, c); 869226150Sdes print_number(ip, narg, c); 870226153Sdes putchar(','); 871226164Sdes mmapprotname(*ip); 872158766Snetchild ip++; 873158766Snetchild narg--; 874226148Sdes break; 875226148Sdes case SYS_madvise: 876226150Sdes print_number(ip, narg, c); 877226150Sdes print_number(ip, narg, c); 878226153Sdes putchar(','); 879226164Sdes madvisebehavname(*ip); 880158766Snetchild ip++; 881158766Snetchild narg--; 882226148Sdes break; 883226148Sdes case SYS_setpriority: 884226150Sdes print_number(ip, narg, c); 885226150Sdes print_number(ip, narg, c); 886226153Sdes putchar(','); 887226164Sdes prioname(*ip); 888158766Snetchild ip++; 889158766Snetchild narg--; 890226148Sdes break; 891226148Sdes case SYS_fcntl: 892226150Sdes print_number(ip, narg, c); 893226153Sdes putchar(','); 894226164Sdes fcntlcmdname(ip[0], ip[1], decimal); 895226148Sdes ip += 2; 896226148Sdes narg -= 2; 897226148Sdes break; 898226148Sdes case SYS_socket: { 899165758Srodrigc int sockdomain; 900226153Sdes putchar('('); 901226164Sdes sockdomain = *ip; 902165758Srodrigc sockdomainname(sockdomain); 903158766Snetchild ip++; 904158766Snetchild narg--; 905226153Sdes putchar(','); 906254922Sjilles socktypenamewithflags(*ip); 907158766Snetchild ip++; 908158766Snetchild narg--; 909165758Srodrigc if (sockdomain == PF_INET || 910165758Srodrigc sockdomain == PF_INET6) { 911226153Sdes putchar(','); 912226164Sdes sockipprotoname(*ip); 913165758Srodrigc ip++; 914165758Srodrigc narg--; 915165758Srodrigc } 916158766Snetchild c = ','; 917226148Sdes break; 918226148Sdes } 919226148Sdes case SYS_setsockopt: 920226148Sdes case SYS_getsockopt: 921226150Sdes print_number(ip, narg, c); 922226153Sdes putchar(','); 923226164Sdes sockoptlevelname(*ip, decimal); 924226151Sdes if (*ip == SOL_SOCKET) { 925175138Sjhb ip++; 926175138Sjhb narg--; 927226153Sdes putchar(','); 928226164Sdes sockoptname(*ip); 929175138Sjhb } 930158766Snetchild ip++; 931158766Snetchild narg--; 932226148Sdes break; 933171221Speter#ifdef SYS_freebsd6_lseek 934226148Sdes case SYS_freebsd6_lseek: 935226150Sdes print_number(ip, narg, c); 936158766Snetchild /* Hidden 'pad' argument, not in lseek(2) */ 937226150Sdes print_number(ip, narg, c); 938311546Sjhb print_number64(first, ip, narg, c); 939226153Sdes putchar(','); 940226164Sdes whencename(*ip); 941158766Snetchild ip++; 942158766Snetchild narg--; 943226148Sdes break; 944171221Speter#endif 945226148Sdes case SYS_lseek: 946226150Sdes print_number(ip, narg, c); 947311546Sjhb print_number64(first, ip, narg, c); 948226153Sdes putchar(','); 949226164Sdes whencename(*ip); 950171221Speter ip++; 951171221Speter narg--; 952226148Sdes break; 953226148Sdes case SYS_flock: 954226150Sdes print_number(ip, narg, c); 955226153Sdes putchar(','); 956226164Sdes flockname(*ip); 957158766Snetchild ip++; 958158766Snetchild narg--; 959226148Sdes break; 960226148Sdes case SYS_mkfifo: 961254291Sjilles case SYS_mkfifoat: 962226148Sdes case SYS_mkdir: 963254291Sjilles case SYS_mkdirat: 964226150Sdes print_number(ip, narg, c); 965226153Sdes putchar(','); 966226164Sdes modename(*ip); 967158766Snetchild ip++; 968158766Snetchild narg--; 969226148Sdes break; 970226148Sdes case SYS_shutdown: 971226150Sdes print_number(ip, narg, c); 972226153Sdes putchar(','); 973226164Sdes shutdownhowname(*ip); 974158766Snetchild ip++; 975158766Snetchild narg--; 976226148Sdes break; 977226148Sdes case SYS_socketpair: 978226153Sdes putchar('('); 979226164Sdes sockdomainname(*ip); 980158766Snetchild ip++; 981158766Snetchild narg--; 982226153Sdes putchar(','); 983254922Sjilles socktypenamewithflags(*ip); 984158766Snetchild ip++; 985158766Snetchild narg--; 986158766Snetchild c = ','; 987226148Sdes break; 988226148Sdes case SYS_getrlimit: 989226148Sdes case SYS_setrlimit: 990226153Sdes putchar('('); 991226164Sdes rlimitname(*ip); 992158766Snetchild ip++; 993158766Snetchild narg--; 994158766Snetchild c = ','; 995226148Sdes break; 996226148Sdes case SYS_quotactl: 997226150Sdes print_number(ip, narg, c); 998226153Sdes putchar(','); 999226164Sdes quotactlname(*ip); 1000158766Snetchild ip++; 1001158766Snetchild narg--; 1002158766Snetchild c = ','; 1003226148Sdes break; 1004226148Sdes case SYS_nfssvc: 1005226153Sdes putchar('('); 1006226164Sdes nfssvcname(*ip); 1007158766Snetchild ip++; 1008158766Snetchild narg--; 1009158766Snetchild c = ','; 1010226148Sdes break; 1011226148Sdes case SYS_rtprio: 1012226153Sdes putchar('('); 1013226164Sdes rtprioname(*ip); 1014158766Snetchild ip++; 1015158766Snetchild narg--; 1016158766Snetchild c = ','; 1017226148Sdes break; 1018226148Sdes case SYS___semctl: 1019226150Sdes print_number(ip, narg, c); 1020226150Sdes print_number(ip, narg, c); 1021226153Sdes putchar(','); 1022226164Sdes semctlname(*ip); 1023158766Snetchild ip++; 1024158766Snetchild narg--; 1025226148Sdes break; 1026226148Sdes case SYS_semget: 1027226150Sdes print_number(ip, narg, c); 1028226150Sdes print_number(ip, narg, c); 1029226153Sdes putchar(','); 1030226164Sdes semgetname(*ip); 1031158766Snetchild ip++; 1032158766Snetchild narg--; 1033226148Sdes break; 1034226148Sdes case SYS_msgctl: 1035226150Sdes print_number(ip, narg, c); 1036226153Sdes putchar(','); 1037226164Sdes shmctlname(*ip); 1038158766Snetchild ip++; 1039158766Snetchild narg--; 1040226148Sdes break; 1041226148Sdes case SYS_shmat: 1042226150Sdes print_number(ip, narg, c); 1043226150Sdes print_number(ip, narg, c); 1044226153Sdes putchar(','); 1045226164Sdes shmatname(*ip); 1046158766Snetchild ip++; 1047158766Snetchild narg--; 1048226148Sdes break; 1049226148Sdes case SYS_shmctl: 1050226150Sdes print_number(ip, narg, c); 1051226153Sdes putchar(','); 1052226164Sdes shmctlname(*ip); 1053158766Snetchild ip++; 1054158766Snetchild narg--; 1055226148Sdes break; 1056269742Srpaulo case SYS_shm_open: 1057269742Srpaulo print_number(ip, narg, c); 1058269742Srpaulo putchar(','); 1059269742Srpaulo flagsname(ip[0]); 1060277106Sdchagin printf(",0%o", (unsigned int)ip[1]); 1061269742Srpaulo ip += 3; 1062269742Srpaulo narg -= 3; 1063269742Srpaulo break; 1064226148Sdes case SYS_minherit: 1065226150Sdes print_number(ip, narg, c); 1066226150Sdes print_number(ip, narg, c); 1067226153Sdes putchar(','); 1068226164Sdes minheritname(*ip); 1069158766Snetchild ip++; 1070158766Snetchild narg--; 1071226148Sdes break; 1072226148Sdes case SYS_rfork: 1073226153Sdes putchar('('); 1074226164Sdes rforkname(*ip); 1075158766Snetchild ip++; 1076158766Snetchild narg--; 1077158766Snetchild c = ','; 1078226148Sdes break; 1079226148Sdes case SYS_lio_listio: 1080226153Sdes putchar('('); 1081226164Sdes lio_listioname(*ip); 1082158766Snetchild ip++; 1083158766Snetchild narg--; 1084158766Snetchild c = ','; 1085226148Sdes break; 1086226148Sdes case SYS_mlockall: 1087226153Sdes putchar('('); 1088226164Sdes mlockallname(*ip); 1089158766Snetchild ip++; 1090158766Snetchild narg--; 1091226148Sdes break; 1092226148Sdes case SYS_sched_setscheduler: 1093226150Sdes print_number(ip, narg, c); 1094226153Sdes putchar(','); 1095226164Sdes schedpolicyname(*ip); 1096158766Snetchild ip++; 1097158766Snetchild narg--; 1098226148Sdes break; 1099226148Sdes case SYS_sched_get_priority_max: 1100226148Sdes case SYS_sched_get_priority_min: 1101226153Sdes putchar('('); 1102226164Sdes schedpolicyname(*ip); 1103158766Snetchild ip++; 1104158766Snetchild narg--; 1105226148Sdes break; 1106226148Sdes case SYS_sendfile: 1107226150Sdes print_number(ip, narg, c); 1108226150Sdes print_number(ip, narg, c); 1109226150Sdes print_number(ip, narg, c); 1110226150Sdes print_number(ip, narg, c); 1111226150Sdes print_number(ip, narg, c); 1112226150Sdes print_number(ip, narg, c); 1113226153Sdes putchar(','); 1114279201Spluknet sendfileflagsname(*(int *)ip); 1115158766Snetchild ip++; 1116158766Snetchild narg--; 1117226148Sdes break; 1118226148Sdes case SYS_kldsym: 1119226150Sdes print_number(ip, narg, c); 1120226153Sdes putchar(','); 1121226164Sdes kldsymcmdname(*ip); 1122158766Snetchild ip++; 1123158766Snetchild narg--; 1124226148Sdes break; 1125226148Sdes case SYS_sigprocmask: 1126226153Sdes putchar('('); 1127226164Sdes sigprocmaskhowname(*ip); 1128158766Snetchild ip++; 1129158766Snetchild narg--; 1130158766Snetchild c = ','; 1131226148Sdes break; 1132226148Sdes case SYS___acl_get_file: 1133226148Sdes case SYS___acl_set_file: 1134226148Sdes case SYS___acl_get_fd: 1135226148Sdes case SYS___acl_set_fd: 1136226148Sdes case SYS___acl_delete_file: 1137226148Sdes case SYS___acl_delete_fd: 1138226148Sdes case SYS___acl_aclcheck_file: 1139226148Sdes case SYS___acl_aclcheck_fd: 1140226148Sdes case SYS___acl_get_link: 1141226148Sdes case SYS___acl_set_link: 1142226148Sdes case SYS___acl_delete_link: 1143226148Sdes case SYS___acl_aclcheck_link: 1144226150Sdes print_number(ip, narg, c); 1145226153Sdes putchar(','); 1146226164Sdes acltypename(*ip); 1147158766Snetchild ip++; 1148158766Snetchild narg--; 1149226148Sdes break; 1150226148Sdes case SYS_sigaction: 1151226153Sdes putchar('('); 1152226164Sdes signame(*ip); 1153158766Snetchild ip++; 1154158766Snetchild narg--; 1155158766Snetchild c = ','; 1156226148Sdes break; 1157226148Sdes case SYS_extattrctl: 1158226150Sdes print_number(ip, narg, c); 1159226153Sdes putchar(','); 1160226164Sdes extattrctlname(*ip); 1161158766Snetchild ip++; 1162158766Snetchild narg--; 1163226148Sdes break; 1164226148Sdes case SYS_nmount: 1165226150Sdes print_number(ip, narg, c); 1166226150Sdes print_number(ip, narg, c); 1167226153Sdes putchar(','); 1168226164Sdes mountflagsname(*ip); 1169158766Snetchild ip++; 1170158766Snetchild narg--; 1171226148Sdes break; 1172226148Sdes case SYS_thr_create: 1173226150Sdes print_number(ip, narg, c); 1174226150Sdes print_number(ip, narg, c); 1175226153Sdes putchar(','); 1176226164Sdes thrcreateflagsname(*ip); 1177158766Snetchild ip++; 1178158766Snetchild narg--; 1179226148Sdes break; 1180226148Sdes case SYS_thr_kill: 1181226150Sdes print_number(ip, narg, c); 1182226153Sdes putchar(','); 1183226164Sdes signame(*ip); 1184158766Snetchild ip++; 1185158766Snetchild narg--; 1186226148Sdes break; 1187226148Sdes case SYS_kldunloadf: 1188226150Sdes print_number(ip, narg, c); 1189226153Sdes putchar(','); 1190226164Sdes kldunloadfflagsname(*ip); 1191158766Snetchild ip++; 1192158766Snetchild narg--; 1193226148Sdes break; 1194254291Sjilles case SYS_linkat: 1195254291Sjilles case SYS_renameat: 1196254291Sjilles case SYS_symlinkat: 1197254291Sjilles print_number(ip, narg, c); 1198254291Sjilles putchar(','); 1199254291Sjilles atfdname(*ip, decimal); 1200254291Sjilles ip++; 1201254291Sjilles narg--; 1202254291Sjilles break; 1203247602Spjd case SYS_cap_fcntls_limit: 1204247602Spjd print_number(ip, narg, c); 1205247602Spjd putchar(','); 1206247602Spjd arg = *ip; 1207247602Spjd ip++; 1208247602Spjd narg--; 1209247602Spjd capfcntlname(arg); 1210247602Spjd break; 1211232072Sjhb case SYS_posix_fadvise: 1212232128Sjhb print_number(ip, narg, c); 1213232128Sjhb print_number(ip, narg, c); 1214232128Sjhb print_number(ip, narg, c); 1215232072Sjhb (void)putchar(','); 1216232072Sjhb fadvisebehavname((int)*ip); 1217232072Sjhb ip++; 1218232072Sjhb narg--; 1219232072Sjhb break; 1220255708Sjhb case SYS_procctl: 1221255708Sjhb putchar('('); 1222255708Sjhb idtypename(*ip, decimal); 1223255708Sjhb c = ','; 1224255708Sjhb ip++; 1225255708Sjhb narg--; 1226311546Sjhb print_number64(first, ip, narg, c); 1227255708Sjhb putchar(','); 1228255708Sjhb procctlcmdname(*ip); 1229255708Sjhb ip++; 1230255708Sjhb narg--; 1231255708Sjhb break; 1232275843Sjhb case SYS__umtx_op: 1233275843Sjhb print_number(ip, narg, c); 1234275843Sjhb putchar(','); 1235275843Sjhb umtxopname(*ip); 1236275843Sjhb switch (*ip) { 1237275843Sjhb case UMTX_OP_CV_WAIT: 1238275843Sjhb ip++; 1239275843Sjhb narg--; 1240275843Sjhb putchar(','); 1241275843Sjhb umtxcvwaitflags(*ip); 1242275843Sjhb break; 1243275843Sjhb case UMTX_OP_RW_RDLOCK: 1244275843Sjhb ip++; 1245275843Sjhb narg--; 1246275843Sjhb putchar(','); 1247275843Sjhb umtxrwlockflags(*ip); 1248275843Sjhb break; 1249275843Sjhb } 1250275843Sjhb ip++; 1251275843Sjhb narg--; 1252311654Sjhb break; 1253311654Sjhb case SYS_ftruncate: 1254311654Sjhb case SYS_truncate: 1255311654Sjhb print_number(ip, narg, c); 1256311654Sjhb print_number64(first, ip, narg, c); 1257311654Sjhb break; 12581590Srgrimes } 12591590Srgrimes } 1260199024Sattilio while (narg > 0) { 1261226150Sdes print_number(ip, narg, c); 12621590Srgrimes } 1263226153Sdes putchar(')'); 12641590Srgrimes } 1265226153Sdes putchar('\n'); 12661590Srgrimes} 12671590Srgrimes 1268100824Sdwmalonevoid 1269219043Sdchaginktrsysret(struct ktr_sysret *ktr, u_int flags) 12701590Srgrimes{ 1271100824Sdwmalone register_t ret = ktr->ktr_retval; 1272100824Sdwmalone int error = ktr->ktr_error; 1273100824Sdwmalone int code = ktr->ktr_code; 12741590Srgrimes 1275219043Sdchagin if ((flags != 0 && ((flags & SV_ABI_MASK) != SV_ABI_FREEBSD)) || 1276219043Sdchagin (code >= nsyscalls || code < 0)) 1277226153Sdes printf("[%d] ", code); 1278264332Sbdrewery else { 1279264332Sbdrewery printf("%s", syscallnames[code]); 1280264332Sbdrewery if (syscallno) 1281264332Sbdrewery printf("[%d]", code); 1282264332Sbdrewery printf(" "); 1283264332Sbdrewery } 12841590Srgrimes 12851590Srgrimes if (error == 0) { 12861590Srgrimes if (fancy) { 1287226153Sdes printf("%ld", (long)ret); 12881590Srgrimes if (ret < 0 || ret > 9) 1289226153Sdes printf("/%#lx", (unsigned long)ret); 12901590Srgrimes } else { 12911590Srgrimes if (decimal) 1292226153Sdes printf("%ld", (long)ret); 12931590Srgrimes else 1294226153Sdes printf("%#lx", (unsigned long)ret); 12951590Srgrimes } 12961590Srgrimes } else if (error == ERESTART) 1297226153Sdes printf("RESTART"); 12981590Srgrimes else if (error == EJUSTRETURN) 1299226153Sdes printf("JUSTRETURN"); 13001590Srgrimes else { 1301226153Sdes printf("-1 errno %d", ktr->ktr_error); 13021590Srgrimes if (fancy) 1303226153Sdes printf(" %s", strerror(ktr->ktr_error)); 13041590Srgrimes } 1305226153Sdes putchar('\n'); 13061590Srgrimes} 13071590Srgrimes 1308100824Sdwmalonevoid 1309100824Sdwmalonektrnamei(char *cp, int len) 13101590Srgrimes{ 1311226153Sdes printf("\"%.*s\"\n", len, cp); 13121590Srgrimes} 13131590Srgrimes 1314100824Sdwmalonevoid 1315115759Speterhexdump(char *p, int len, int screenwidth) 13161590Srgrimes{ 1317115759Speter int n, i; 1318115759Speter int width; 1319115759Speter 1320115759Speter width = 0; 1321115759Speter do { 1322115759Speter width += 2; 1323115759Speter i = 13; /* base offset */ 1324115759Speter i += (width / 2) + 1; /* spaces every second byte */ 1325115759Speter i += (width * 2); /* width of bytes */ 1326115759Speter i += 3; /* " |" */ 1327115759Speter i += width; /* each byte */ 1328115759Speter i += 1; /* "|" */ 1329115759Speter } while (i < screenwidth); 1330115759Speter width -= 2; 1331115759Speter 1332115759Speter for (n = 0; n < len; n += width) { 1333115759Speter for (i = n; i < n + width; i++) { 1334115759Speter if ((i % width) == 0) { /* beginning of line */ 1335115759Speter printf(" 0x%04x", i); 1336115759Speter } 1337115759Speter if ((i % 2) == 0) { 1338115759Speter printf(" "); 1339115759Speter } 1340115759Speter if (i < len) 1341115759Speter printf("%02x", p[i] & 0xff); 1342115759Speter else 1343115759Speter printf(" "); 1344115759Speter } 1345115759Speter printf(" |"); 1346115759Speter for (i = n; i < n + width; i++) { 1347115759Speter if (i >= len) 1348115759Speter break; 1349115759Speter if (p[i] >= ' ' && p[i] <= '~') 1350115759Speter printf("%c", p[i]); 1351115759Speter else 1352115759Speter printf("."); 1353115759Speter } 1354115759Speter printf("|\n"); 1355115759Speter } 1356115759Speter if ((i % width) != 0) 1357115759Speter printf("\n"); 1358115759Speter} 1359115759Speter 1360115759Spetervoid 1361115759Spetervisdump(char *dp, int datalen, int screenwidth) 1362115759Speter{ 1363115759Speter int col = 0; 1364100824Sdwmalone char *cp; 1365100824Sdwmalone int width; 13661590Srgrimes char visbuf[5]; 13671590Srgrimes 1368226153Sdes printf(" \""); 13691590Srgrimes col = 8; 13701590Srgrimes for (;datalen > 0; datalen--, dp++) { 1371226153Sdes vis(visbuf, *dp, VIS_CSTYLE, *(dp+1)); 13721590Srgrimes cp = visbuf; 13731590Srgrimes /* 13741590Srgrimes * Keep track of printables and 13751590Srgrimes * space chars (like fold(1)). 13761590Srgrimes */ 13771590Srgrimes if (col == 0) { 1378226153Sdes putchar('\t'); 13791590Srgrimes col = 8; 13801590Srgrimes } 13811590Srgrimes switch(*cp) { 13821590Srgrimes case '\n': 13831590Srgrimes col = 0; 1384226153Sdes putchar('\n'); 13851590Srgrimes continue; 13861590Srgrimes case '\t': 13871590Srgrimes width = 8 - (col&07); 13881590Srgrimes break; 13891590Srgrimes default: 13901590Srgrimes width = strlen(cp); 13911590Srgrimes } 13921590Srgrimes if (col + width > (screenwidth-2)) { 1393226153Sdes printf("\\\n\t"); 13941590Srgrimes col = 8; 13951590Srgrimes } 13961590Srgrimes col += width; 13971590Srgrimes do { 1398226153Sdes putchar(*cp++); 13991590Srgrimes } while (*cp); 14001590Srgrimes } 14011590Srgrimes if (col == 0) 1402226153Sdes printf(" "); 1403226153Sdes printf("\"\n"); 14041590Srgrimes} 14051590Srgrimes 1406115759Spetervoid 1407115759Speterktrgenio(struct ktr_genio *ktr, int len) 1408115759Speter{ 1409115759Speter int datalen = len - sizeof (struct ktr_genio); 1410115759Speter char *dp = (char *)ktr + sizeof (struct ktr_genio); 1411115759Speter static int screenwidth = 0; 1412115759Speter int i, binary; 1413115759Speter 1414251072Spjd printf("fd %d %s %d byte%s\n", ktr->ktr_fd, 1415251072Spjd ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen, 1416251072Spjd datalen == 1 ? "" : "s"); 1417251072Spjd if (suppressdata) 1418251072Spjd return; 1419115759Speter if (screenwidth == 0) { 1420115759Speter struct winsize ws; 1421115759Speter 1422115759Speter if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 && 1423115759Speter ws.ws_col > 8) 1424115759Speter screenwidth = ws.ws_col; 1425115759Speter else 1426115759Speter screenwidth = 80; 1427115759Speter } 1428115759Speter if (maxdata && datalen > maxdata) 1429115759Speter datalen = maxdata; 1430115759Speter 1431115759Speter for (i = 0, binary = 0; i < datalen && binary == 0; i++) { 1432115759Speter if (dp[i] >= 32 && dp[i] < 127) 1433115759Speter continue; 1434115759Speter if (dp[i] == 10 || dp[i] == 13 || dp[i] == 0 || dp[i] == 9) 1435115759Speter continue; 1436115759Speter binary = 1; 1437115759Speter } 1438115759Speter if (binary) 1439115759Speter hexdump(dp, datalen, screenwidth); 1440115759Speter else 1441115759Speter visdump(dp, datalen, screenwidth); 1442115759Speter} 1443115759Speter 1444100824Sdwmaloneconst char *signames[] = { 14451590Srgrimes "NULL", "HUP", "INT", "QUIT", "ILL", "TRAP", "IOT", /* 1 - 6 */ 14461590Srgrimes "EMT", "FPE", "KILL", "BUS", "SEGV", "SYS", /* 7 - 12 */ 14471590Srgrimes "PIPE", "ALRM", "TERM", "URG", "STOP", "TSTP", /* 13 - 18 */ 14481590Srgrimes "CONT", "CHLD", "TTIN", "TTOU", "IO", "XCPU", /* 19 - 24 */ 14491590Srgrimes "XFSZ", "VTALRM", "PROF", "WINCH", "29", "USR1", /* 25 - 30 */ 14501590Srgrimes "USR2", NULL, /* 31 - 32 */ 14511590Srgrimes}; 14521590Srgrimes 1453100824Sdwmalonevoid 1454219138Sdchaginktrpsig(struct ktr_psig *psig) 14551590Srgrimes{ 1456219138Sdchagin if (psig->signo > 0 && psig->signo < NSIG) 1457226153Sdes printf("SIG%s ", signames[psig->signo]); 1458160294Skib else 1459226153Sdes printf("SIG %d ", psig->signo); 1460240820Sjilles if (psig->action == SIG_DFL) { 1461240820Sjilles printf("SIG_DFL code="); 1462240820Sjilles sigcodename(psig->signo, psig->code); 1463240820Sjilles putchar('\n'); 1464240820Sjilles } else { 1465240820Sjilles printf("caught handler=0x%lx mask=0x%x code=", 1466240820Sjilles (u_long)psig->action, psig->mask.__bits[0]); 1467240820Sjilles sigcodename(psig->signo, psig->code); 1468240820Sjilles putchar('\n'); 1469100824Sdwmalone } 14701590Srgrimes} 14711590Srgrimes 1472100824Sdwmalonevoid 1473234494Sjhbktrcsw_old(struct ktr_csw_old *cs) 14741590Srgrimes{ 1475226153Sdes printf("%s %s\n", cs->out ? "stop" : "resume", 14761590Srgrimes cs->user ? "user" : "kernel"); 14771590Srgrimes} 14781590Srgrimes 1479234494Sjhbvoid 1480234494Sjhbktrcsw(struct ktr_csw *cs) 1481234494Sjhb{ 1482234494Sjhb printf("%s %s \"%s\"\n", cs->out ? "stop" : "resume", 1483234494Sjhb cs->user ? "user" : "kernel", cs->wmesg); 1484234494Sjhb} 1485234494Sjhb 1486165916Sjhb#define UTRACE_DLOPEN_START 1 1487165916Sjhb#define UTRACE_DLOPEN_STOP 2 1488165916Sjhb#define UTRACE_DLCLOSE_START 3 1489165916Sjhb#define UTRACE_DLCLOSE_STOP 4 1490165916Sjhb#define UTRACE_LOAD_OBJECT 5 1491165916Sjhb#define UTRACE_UNLOAD_OBJECT 6 1492165916Sjhb#define UTRACE_ADD_RUNDEP 7 1493165916Sjhb#define UTRACE_PRELOAD_FINISHED 8 1494165916Sjhb#define UTRACE_INIT_CALL 9 1495165916Sjhb#define UTRACE_FINI_CALL 10 1496284954Sdes#define UTRACE_DLSYM_START 11 1497284954Sdes#define UTRACE_DLSYM_STOP 12 1498165916Sjhb 1499165916Sjhbstruct utrace_rtld { 1500165916Sjhb char sig[4]; /* 'RTLD' */ 1501165916Sjhb int event; 1502165916Sjhb void *handle; 1503165916Sjhb void *mapbase; 1504165916Sjhb size_t mapsize; 1505165916Sjhb int refcnt; 1506165916Sjhb char name[MAXPATHLEN]; 1507165916Sjhb}; 1508165916Sjhb 1509165916Sjhbvoid 1510277106Sdchaginktruser_rtld(int len, void *p) 1511165916Sjhb{ 1512277106Sdchagin struct utrace_rtld *ut = p; 1513277106Sdchagin unsigned char *cp; 1514165916Sjhb void *parent; 1515165916Sjhb int mode; 1516165916Sjhb 1517165916Sjhb switch (ut->event) { 1518165916Sjhb case UTRACE_DLOPEN_START: 1519165916Sjhb mode = ut->refcnt; 1520165916Sjhb printf("dlopen(%s, ", ut->name); 1521165916Sjhb switch (mode & RTLD_MODEMASK) { 1522165916Sjhb case RTLD_NOW: 1523165916Sjhb printf("RTLD_NOW"); 1524165916Sjhb break; 1525165916Sjhb case RTLD_LAZY: 1526165916Sjhb printf("RTLD_LAZY"); 1527165916Sjhb break; 1528165916Sjhb default: 1529165916Sjhb printf("%#x", mode & RTLD_MODEMASK); 1530165916Sjhb } 1531165916Sjhb if (mode & RTLD_GLOBAL) 1532165916Sjhb printf(" | RTLD_GLOBAL"); 1533165916Sjhb if (mode & RTLD_TRACE) 1534165916Sjhb printf(" | RTLD_TRACE"); 1535165916Sjhb if (mode & ~(RTLD_MODEMASK | RTLD_GLOBAL | RTLD_TRACE)) 1536165916Sjhb printf(" | %#x", mode & 1537165916Sjhb ~(RTLD_MODEMASK | RTLD_GLOBAL | RTLD_TRACE)); 1538165916Sjhb printf(")\n"); 1539165916Sjhb break; 1540165916Sjhb case UTRACE_DLOPEN_STOP: 1541165916Sjhb printf("%p = dlopen(%s) ref %d\n", ut->handle, ut->name, 1542165916Sjhb ut->refcnt); 1543165916Sjhb break; 1544165916Sjhb case UTRACE_DLCLOSE_START: 1545165916Sjhb printf("dlclose(%p) (%s, %d)\n", ut->handle, ut->name, 1546165916Sjhb ut->refcnt); 1547165916Sjhb break; 1548165916Sjhb case UTRACE_DLCLOSE_STOP: 1549165916Sjhb printf("dlclose(%p) finished\n", ut->handle); 1550165916Sjhb break; 1551165916Sjhb case UTRACE_LOAD_OBJECT: 1552165916Sjhb printf("RTLD: loaded %p @ %p - %p (%s)\n", ut->handle, 1553165916Sjhb ut->mapbase, (char *)ut->mapbase + ut->mapsize - 1, 1554165916Sjhb ut->name); 1555165916Sjhb break; 1556165916Sjhb case UTRACE_UNLOAD_OBJECT: 1557165916Sjhb printf("RTLD: unloaded %p @ %p - %p (%s)\n", ut->handle, 1558165916Sjhb ut->mapbase, (char *)ut->mapbase + ut->mapsize - 1, 1559165916Sjhb ut->name); 1560165916Sjhb break; 1561165916Sjhb case UTRACE_ADD_RUNDEP: 1562165916Sjhb parent = ut->mapbase; 1563165916Sjhb printf("RTLD: %p now depends on %p (%s, %d)\n", parent, 1564165916Sjhb ut->handle, ut->name, ut->refcnt); 1565165916Sjhb break; 1566165916Sjhb case UTRACE_PRELOAD_FINISHED: 1567165916Sjhb printf("RTLD: LD_PRELOAD finished\n"); 1568165916Sjhb break; 1569165916Sjhb case UTRACE_INIT_CALL: 1570165916Sjhb printf("RTLD: init %p for %p (%s)\n", ut->mapbase, ut->handle, 1571165916Sjhb ut->name); 1572165916Sjhb break; 1573165916Sjhb case UTRACE_FINI_CALL: 1574165916Sjhb printf("RTLD: fini %p for %p (%s)\n", ut->mapbase, ut->handle, 1575165916Sjhb ut->name); 1576165916Sjhb break; 1577284954Sdes case UTRACE_DLSYM_START: 1578284954Sdes printf("RTLD: dlsym(%p, %s)\n", ut->handle, ut->name); 1579284954Sdes break; 1580284954Sdes case UTRACE_DLSYM_STOP: 1581284954Sdes printf("RTLD: %p = dlsym(%p, %s)\n", ut->mapbase, ut->handle, 1582284954Sdes ut->name); 1583284954Sdes break; 1584165916Sjhb default: 1585277106Sdchagin cp = p; 1586277106Sdchagin cp += 4; 1587165916Sjhb len -= 4; 1588165916Sjhb printf("RTLD: %d ", len); 1589165916Sjhb while (len--) 1590165916Sjhb if (decimal) 1591277106Sdchagin printf(" %d", *cp++); 1592165916Sjhb else 1593277106Sdchagin printf(" %02x", *cp++); 1594165916Sjhb printf("\n"); 1595165916Sjhb } 1596165916Sjhb} 1597165916Sjhb 1598165812Sjhbstruct utrace_malloc { 1599165812Sjhb void *p; 1600165812Sjhb size_t s; 1601165812Sjhb void *r; 1602165812Sjhb}; 1603165812Sjhb 1604100824Sdwmalonevoid 1605277106Sdchaginktruser_malloc(void *p) 1606165812Sjhb{ 1607277106Sdchagin struct utrace_malloc *ut = p; 1608165812Sjhb 1609199265Scperciva if (ut->p == (void *)(intptr_t)(-1)) 1610199265Scperciva printf("malloc_init()\n"); 1611199265Scperciva else if (ut->s == 0) 1612199265Scperciva printf("free(%p)\n", ut->p); 1613199265Scperciva else if (ut->p == NULL) 1614199265Scperciva printf("%p = malloc(%zu)\n", ut->r, ut->s); 1615199265Scperciva else 1616199265Scperciva printf("%p = realloc(%p, %zu)\n", ut->r, ut->p, ut->s); 1617165812Sjhb} 1618165812Sjhb 1619165812Sjhbvoid 1620277106Sdchaginktruser(int len, void *p) 162118400Sphk{ 1622277106Sdchagin unsigned char *cp; 1623165812Sjhb 1624165916Sjhb if (len >= 8 && bcmp(p, "RTLD", 4) == 0) { 1625165916Sjhb ktruser_rtld(len, p); 1626165916Sjhb return; 1627165916Sjhb } 1628165916Sjhb 1629165812Sjhb if (len == sizeof(struct utrace_malloc)) { 1630226329Sdes ktruser_malloc(p); 1631165812Sjhb return; 1632165812Sjhb } 1633165812Sjhb 1634226153Sdes printf("%d ", len); 1635277106Sdchagin cp = p; 163618470Sphk while (len--) 1637127402Sphk if (decimal) 1638277106Sdchagin printf(" %d", *cp++); 1639127402Sphk else 1640277106Sdchagin printf(" %02x", *cp++); 1641226153Sdes printf("\n"); 164218400Sphk} 164318400Sphk 1644100824Sdwmalonevoid 1645255219Spjdktrcaprights(cap_rights_t *rightsp) 1646255219Spjd{ 1647255219Spjd 1648255219Spjd printf("cap_rights_t "); 1649255219Spjd capname(rightsp); 1650255219Spjd printf("\n"); 1651255219Spjd} 1652255219Spjd 1653303093Skibstatic void 1654303093Skibktrtimeval(struct timeval *tv) 1655303093Skib{ 1656303093Skib 1657303093Skib printf("{%ld, %ld}", (long)tv->tv_sec, tv->tv_usec); 1658303093Skib} 1659303093Skib 1660255219Spjdvoid 1661303093Skibktritimerval(struct itimerval *it) 1662303093Skib{ 1663303093Skib 1664303093Skib printf("itimerval { .interval = "); 1665303093Skib ktrtimeval(&it->it_interval); 1666303093Skib printf(", .value = "); 1667303093Skib ktrtimeval(&it->it_value); 1668303093Skib printf(" }\n"); 1669303093Skib} 1670303093Skib 1671303093Skibvoid 1672176471Sdesktrsockaddr(struct sockaddr *sa) 1673176471Sdes{ 1674176471Sdes/* 1675176471Sdes TODO: Support additional address families 1676176471Sdes #include <netnatm/natm.h> 1677176471Sdes struct sockaddr_natm *natm; 1678252356Sdavide #include <netsmb/netbios.h> 1679252356Sdavide struct sockaddr_nb *nb; 1680176471Sdes*/ 1681176471Sdes char addr[64]; 1682176471Sdes 1683176471Sdes /* 1684176471Sdes * note: ktrstruct() has already verified that sa points to a 1685176471Sdes * buffer at least sizeof(struct sockaddr) bytes long and exactly 1686176471Sdes * sa->sa_len bytes long. 1687176471Sdes */ 1688176471Sdes printf("struct sockaddr { "); 1689176471Sdes sockfamilyname(sa->sa_family); 1690176471Sdes printf(", "); 1691176471Sdes 1692176471Sdes#define check_sockaddr_len(n) \ 1693226329Sdes if (sa_##n.s##n##_len < sizeof(struct sockaddr_##n)) { \ 1694176471Sdes printf("invalid"); \ 1695176471Sdes break; \ 1696176471Sdes } 1697176471Sdes 1698176471Sdes switch(sa->sa_family) { 1699176471Sdes case AF_INET: { 1700226329Sdes struct sockaddr_in sa_in; 1701176471Sdes 1702226329Sdes memset(&sa_in, 0, sizeof(sa_in)); 1703246719Szont memcpy(&sa_in, sa, sa->sa_len); 1704176471Sdes check_sockaddr_len(in); 1705226329Sdes inet_ntop(AF_INET, &sa_in.sin_addr, addr, sizeof addr); 1706226329Sdes printf("%s:%u", addr, ntohs(sa_in.sin_port)); 1707176471Sdes break; 1708176471Sdes } 1709176471Sdes#ifdef NETATALK 1710176471Sdes case AF_APPLETALK: { 1711226329Sdes struct sockaddr_at sa_at; 1712176471Sdes struct netrange *nr; 1713176471Sdes 1714226329Sdes memset(&sa_at, 0, sizeof(sa_at)); 1715246719Szont memcpy(&sa_at, sa, sa->sa_len); 1716176471Sdes check_sockaddr_len(at); 1717226329Sdes nr = &sa_at.sat_range.r_netrange; 1718226329Sdes printf("%d.%d, %d-%d, %d", ntohs(sa_at.sat_addr.s_net), 1719226329Sdes sa_at.sat_addr.s_node, ntohs(nr->nr_firstnet), 1720176471Sdes ntohs(nr->nr_lastnet), nr->nr_phase); 1721176471Sdes break; 1722176471Sdes } 1723176471Sdes#endif 1724176471Sdes case AF_INET6: { 1725226329Sdes struct sockaddr_in6 sa_in6; 1726176471Sdes 1727226329Sdes memset(&sa_in6, 0, sizeof(sa_in6)); 1728246719Szont memcpy(&sa_in6, sa, sa->sa_len); 1729176471Sdes check_sockaddr_len(in6); 1730251486Sae getnameinfo((struct sockaddr *)&sa_in6, sizeof(sa_in6), 1731251486Sae addr, sizeof(addr), NULL, 0, NI_NUMERICHOST); 1732226329Sdes printf("[%s]:%u", addr, htons(sa_in6.sin6_port)); 1733176471Sdes break; 1734176471Sdes } 1735176471Sdes#ifdef IPX 1736176471Sdes case AF_IPX: { 1737226329Sdes struct sockaddr_ipx sa_ipx; 1738176471Sdes 1739226329Sdes memset(&sa_ipx, 0, sizeof(sa_ipx)); 1740246719Szont memcpy(&sa_ipx, sa, sa->sa_len); 1741176471Sdes check_sockaddr_len(ipx); 1742176471Sdes /* XXX wish we had ipx_ntop */ 1743226329Sdes printf("%s", ipx_ntoa(sa_ipx.sipx_addr)); 1744226329Sdes free(sa_ipx); 1745176471Sdes break; 1746176471Sdes } 1747176471Sdes#endif 1748176471Sdes case AF_UNIX: { 1749226329Sdes struct sockaddr_un sa_un; 1750176471Sdes 1751226329Sdes memset(&sa_un, 0, sizeof(sa_un)); 1752246719Szont memcpy(&sa_un, sa, sa->sa_len); 1753226329Sdes printf("%.*s", (int)sizeof(sa_un.sun_path), sa_un.sun_path); 1754176471Sdes break; 1755176471Sdes } 1756176471Sdes default: 1757176471Sdes printf("unknown address family"); 1758176471Sdes } 1759176471Sdes printf(" }\n"); 1760176471Sdes} 1761176471Sdes 1762176471Sdesvoid 1763176471Sdesktrstat(struct stat *statp) 1764176471Sdes{ 1765176471Sdes char mode[12], timestr[PATH_MAX + 4]; 1766176471Sdes struct passwd *pwd; 1767176471Sdes struct group *grp; 1768176471Sdes struct tm *tm; 1769176471Sdes 1770176471Sdes /* 1771176471Sdes * note: ktrstruct() has already verified that statp points to a 1772176471Sdes * buffer exactly sizeof(struct stat) bytes long. 1773176471Sdes */ 1774176471Sdes printf("struct stat {"); 1775256107Sdes printf("dev=%ju, ino=%ju, ", 1776256107Sdes (uintmax_t)statp->st_dev, (uintmax_t)statp->st_ino); 1777256107Sdes if (resolv == 0) 1778256107Sdes printf("mode=0%jo, ", (uintmax_t)statp->st_mode); 1779256107Sdes else { 1780256107Sdes strmode(statp->st_mode, mode); 1781256107Sdes printf("mode=%s, ", mode); 1782256107Sdes } 1783256107Sdes printf("nlink=%ju, ", (uintmax_t)statp->st_nlink); 1784176471Sdes if (resolv == 0 || (pwd = getpwuid(statp->st_uid)) == NULL) 1785176471Sdes printf("uid=%ju, ", (uintmax_t)statp->st_uid); 1786176471Sdes else 1787176471Sdes printf("uid=\"%s\", ", pwd->pw_name); 1788176471Sdes if (resolv == 0 || (grp = getgrgid(statp->st_gid)) == NULL) 1789176471Sdes printf("gid=%ju, ", (uintmax_t)statp->st_gid); 1790176471Sdes else 1791176471Sdes printf("gid=\"%s\", ", grp->gr_name); 1792176471Sdes printf("rdev=%ju, ", (uintmax_t)statp->st_rdev); 1793176471Sdes printf("atime="); 1794176471Sdes if (resolv == 0) 1795205793Sed printf("%jd", (intmax_t)statp->st_atim.tv_sec); 1796176471Sdes else { 1797205793Sed tm = localtime(&statp->st_atim.tv_sec); 1798226153Sdes strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1799176471Sdes printf("\"%s\"", timestr); 1800176471Sdes } 1801205793Sed if (statp->st_atim.tv_nsec != 0) 1802205793Sed printf(".%09ld, ", statp->st_atim.tv_nsec); 1803176471Sdes else 1804176471Sdes printf(", "); 1805301617Sngie printf("mtime="); 1806176471Sdes if (resolv == 0) 1807205793Sed printf("%jd", (intmax_t)statp->st_mtim.tv_sec); 1808176471Sdes else { 1809205793Sed tm = localtime(&statp->st_mtim.tv_sec); 1810226153Sdes strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1811176471Sdes printf("\"%s\"", timestr); 1812176471Sdes } 1813205793Sed if (statp->st_mtim.tv_nsec != 0) 1814205793Sed printf(".%09ld, ", statp->st_mtim.tv_nsec); 1815176471Sdes else 1816176471Sdes printf(", "); 1817176471Sdes printf("ctime="); 1818176471Sdes if (resolv == 0) 1819205793Sed printf("%jd", (intmax_t)statp->st_ctim.tv_sec); 1820176471Sdes else { 1821205793Sed tm = localtime(&statp->st_ctim.tv_sec); 1822226153Sdes strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1823176471Sdes printf("\"%s\"", timestr); 1824176471Sdes } 1825205793Sed if (statp->st_ctim.tv_nsec != 0) 1826205793Sed printf(".%09ld, ", statp->st_ctim.tv_nsec); 1827176471Sdes else 1828176471Sdes printf(", "); 1829176471Sdes printf("birthtime="); 1830176471Sdes if (resolv == 0) 1831205793Sed printf("%jd", (intmax_t)statp->st_birthtim.tv_sec); 1832176471Sdes else { 1833205793Sed tm = localtime(&statp->st_birthtim.tv_sec); 1834226153Sdes strftime(timestr, sizeof(timestr), TIME_FORMAT, tm); 1835176471Sdes printf("\"%s\"", timestr); 1836176471Sdes } 1837205793Sed if (statp->st_birthtim.tv_nsec != 0) 1838205793Sed printf(".%09ld, ", statp->st_birthtim.tv_nsec); 1839176471Sdes else 1840176471Sdes printf(", "); 1841176471Sdes printf("size=%jd, blksize=%ju, blocks=%jd, flags=0x%x", 1842176471Sdes (uintmax_t)statp->st_size, (uintmax_t)statp->st_blksize, 1843176471Sdes (intmax_t)statp->st_blocks, statp->st_flags); 1844176471Sdes printf(" }\n"); 1845176471Sdes} 1846176471Sdes 1847176471Sdesvoid 1848176471Sdesktrstruct(char *buf, size_t buflen) 1849176471Sdes{ 1850176471Sdes char *name, *data; 1851176471Sdes size_t namelen, datalen; 1852176471Sdes int i; 1853255219Spjd cap_rights_t rights; 1854303093Skib struct itimerval it; 1855204045Simp struct stat sb; 1856204045Simp struct sockaddr_storage ss; 1857176471Sdes 1858176471Sdes for (name = buf, namelen = 0; 1859176471Sdes namelen < buflen && name[namelen] != '\0'; 1860176471Sdes ++namelen) 1861176471Sdes /* nothing */; 1862176471Sdes if (namelen == buflen) 1863176471Sdes goto invalid; 1864176471Sdes if (name[namelen] != '\0') 1865176471Sdes goto invalid; 1866176471Sdes data = buf + namelen + 1; 1867176471Sdes datalen = buflen - namelen - 1; 1868176471Sdes if (datalen == 0) 1869176471Sdes goto invalid; 1870176471Sdes /* sanity check */ 1871226329Sdes for (i = 0; i < (int)namelen; ++i) 1872226329Sdes if (!isalpha(name[i])) 1873176471Sdes goto invalid; 1874255219Spjd if (strcmp(name, "caprights") == 0) { 1875255219Spjd if (datalen != sizeof(cap_rights_t)) 1876255219Spjd goto invalid; 1877255219Spjd memcpy(&rights, data, datalen); 1878255219Spjd ktrcaprights(&rights); 1879303093Skib } else if (strcmp(name, "itimerval") == 0) { 1880303093Skib if (datalen != sizeof(struct itimerval)) 1881303093Skib goto invalid; 1882303093Skib memcpy(&it, data, datalen); 1883303093Skib ktritimerval(&it); 1884255219Spjd } else if (strcmp(name, "stat") == 0) { 1885176471Sdes if (datalen != sizeof(struct stat)) 1886176471Sdes goto invalid; 1887204045Simp memcpy(&sb, data, datalen); 1888204045Simp ktrstat(&sb); 1889176471Sdes } else if (strcmp(name, "sockaddr") == 0) { 1890204045Simp if (datalen > sizeof(ss)) 1891204045Simp goto invalid; 1892204045Simp memcpy(&ss, data, datalen); 1893246720Szont if (datalen != ss.ss_len) 1894176471Sdes goto invalid; 1895204045Simp ktrsockaddr((struct sockaddr *)&ss); 1896176471Sdes } else { 1897176471Sdes printf("unknown structure\n"); 1898176471Sdes } 1899176471Sdes return; 1900176471Sdesinvalid: 1901176471Sdes printf("invalid record\n"); 1902176471Sdes} 1903176471Sdes 1904226269Sdesvoid 1905226269Sdesktrcapfail(struct ktr_cap_fail *ktr) 1906226269Sdes{ 1907226495Sdes switch (ktr->cap_type) { 1908226495Sdes case CAPFAIL_NOTCAPABLE: 1909226495Sdes /* operation on fd with insufficient capabilities */ 1910226495Sdes printf("operation requires "); 1911255219Spjd capname(&ktr->cap_needed); 1912226495Sdes printf(", process holds "); 1913255219Spjd capname(&ktr->cap_held); 1914226495Sdes break; 1915226495Sdes case CAPFAIL_INCREASE: 1916226495Sdes /* requested more capabilities than fd already has */ 1917226495Sdes printf("attempt to increase capabilities from "); 1918255219Spjd capname(&ktr->cap_held); 1919226505Sdes printf(" to "); 1920255219Spjd capname(&ktr->cap_needed); 1921226495Sdes break; 1922226495Sdes case CAPFAIL_SYSCALL: 1923226495Sdes /* called restricted syscall */ 1924226495Sdes printf("disallowed system call"); 1925226495Sdes break; 1926226495Sdes case CAPFAIL_LOOKUP: 1927226495Sdes /* used ".." in strict-relative mode */ 1928226495Sdes printf("restricted VFS lookup"); 1929226495Sdes break; 1930226495Sdes default: 1931226495Sdes printf("unknown capability failure: "); 1932255219Spjd capname(&ktr->cap_needed); 1933226495Sdes printf(" "); 1934255219Spjd capname(&ktr->cap_held); 1935226495Sdes break; 1936226495Sdes } 1937233925Sjhb printf("\n"); 1938226269Sdes} 1939226269Sdes 1940233925Sjhbvoid 1941233925Sjhbktrfault(struct ktr_fault *ktr) 1942233925Sjhb{ 1943233925Sjhb 1944277106Sdchagin printf("0x%jx ", (uintmax_t)ktr->vaddr); 1945233925Sjhb vmprotname(ktr->type); 1946233925Sjhb printf("\n"); 1947233925Sjhb} 1948233925Sjhb 1949233925Sjhbvoid 1950233925Sjhbktrfaultend(struct ktr_faultend *ktr) 1951233925Sjhb{ 1952233925Sjhb 1953233925Sjhb vmresultname(ktr->result); 1954233925Sjhb printf("\n"); 1955233925Sjhb} 1956233925Sjhb 1957219138Sdchagin#if defined(__amd64__) || defined(__i386__) 1958294135Sdchagin 1959294135Sdchagin#if defined(__amd64__) 1960294135Sdchagin#define NLINUX_SYSCALLS(v) ((v) & SV_ILP32 ? \ 1961294135Sdchagin nitems(linux32_syscallnames) : nitems(linux_syscallnames)) 1962294135Sdchagin#define LINUX_SYSCALLNAMES(v, i) ((v) & SV_ILP32 ? \ 1963294135Sdchagin linux32_syscallnames[i] : linux_syscallnames[i]) 1964294135Sdchagin#else 1965294135Sdchagin#define NLINUX_SYSCALLS(v) (nitems(linux_syscallnames)) 1966294135Sdchagin#define LINUX_SYSCALLNAMES(v, i) (linux_syscallnames[i]) 1967294135Sdchagin#endif 1968294135Sdchagin 1969176471Sdesvoid 1970294135Sdchaginlinux_ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags) 1971219138Sdchagin{ 1972219138Sdchagin int narg = ktr->ktr_narg; 1973294135Sdchagin unsigned code = ktr->ktr_code; 1974219138Sdchagin register_t *ip; 1975219138Sdchagin 1976294135Sdchagin if (ktr->ktr_code < 0 || code >= NLINUX_SYSCALLS(sv_flags)) 1977219138Sdchagin printf("[%d]", ktr->ktr_code); 1978264332Sbdrewery else { 1979294135Sdchagin printf("%s", LINUX_SYSCALLNAMES(sv_flags, ktr->ktr_code)); 1980264332Sbdrewery if (syscallno) 1981264332Sbdrewery printf("[%d]", ktr->ktr_code); 1982264332Sbdrewery } 1983219138Sdchagin ip = &ktr->ktr_args[0]; 1984219138Sdchagin if (narg) { 1985219138Sdchagin char c = '('; 1986219138Sdchagin while (narg > 0) 1987219138Sdchagin print_number(ip, narg, c); 1988219138Sdchagin putchar(')'); 1989219138Sdchagin } 1990219138Sdchagin putchar('\n'); 1991219138Sdchagin} 1992219138Sdchagin 1993219138Sdchaginvoid 1994294135Sdchaginlinux_ktrsysret(struct ktr_sysret *ktr, u_int sv_flags) 1995219138Sdchagin{ 1996219138Sdchagin register_t ret = ktr->ktr_retval; 1997294135Sdchagin unsigned code = ktr->ktr_code; 1998219138Sdchagin int error = ktr->ktr_error; 1999219138Sdchagin 2000294135Sdchagin if (ktr->ktr_code < 0 || code >= NLINUX_SYSCALLS(sv_flags)) 2001294135Sdchagin printf("[%d] ", ktr->ktr_code); 2002264332Sbdrewery else { 2003294135Sdchagin printf("%s ", LINUX_SYSCALLNAMES(sv_flags, code)); 2004264332Sbdrewery if (syscallno) 2005264332Sbdrewery printf("[%d]", code); 2006264332Sbdrewery printf(" "); 2007264332Sbdrewery } 2008219138Sdchagin 2009219138Sdchagin if (error == 0) { 2010219138Sdchagin if (fancy) { 2011219138Sdchagin printf("%ld", (long)ret); 2012219138Sdchagin if (ret < 0 || ret > 9) 2013226153Sdes printf("/%#lx", (unsigned long)ret); 2014219138Sdchagin } else { 2015219138Sdchagin if (decimal) 2016219138Sdchagin printf("%ld", (long)ret); 2017219138Sdchagin else 2018226153Sdes printf("%#lx", (unsigned long)ret); 2019219138Sdchagin } 2020219138Sdchagin } else if (error == ERESTART) 2021219138Sdchagin printf("RESTART"); 2022219138Sdchagin else if (error == EJUSTRETURN) 2023219138Sdchagin printf("JUSTRETURN"); 2024219138Sdchagin else { 2025219138Sdchagin if (ktr->ktr_error <= ELAST + 1) 2026219138Sdchagin error = abs(bsd_to_linux_errno[ktr->ktr_error]); 2027219138Sdchagin else 2028219138Sdchagin error = 999; 2029219138Sdchagin printf("-1 errno %d", error); 2030219138Sdchagin if (fancy) 2031219138Sdchagin printf(" %s", strerror(ktr->ktr_error)); 2032219138Sdchagin } 2033219138Sdchagin putchar('\n'); 2034219138Sdchagin} 2035219138Sdchagin#endif 2036219138Sdchagin 2037219138Sdchaginvoid 2038100824Sdwmaloneusage(void) 20391590Srgrimes{ 2040264332Sbdrewery fprintf(stderr, "usage: kdump [-dEnlHRrSsTA] [-f trfile] " 2041177856Sru "[-m maxdata] [-p pid] [-t trstr]\n"); 20421590Srgrimes exit(1); 20431590Srgrimes} 2044