1 /* 2 * Copyright 1997 Sean Eric Fagan 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. All advertising materials mentioning features or use of this software 13 * must display the following acknowledgement: 14 * This product includes software developed by Sean Eric Fagan 15 * 4. Neither the name of the author may be used to endorse or promote 16 * products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 #ifndef lint 33 static const char rcsid[] = 34 "$FreeBSD$"; 35 #endif /* not lint */ 36 37 /* 38 * This file has routines used to print out system calls and their 39 * arguments. 40 */ 41 42 #include <sys/types.h> 43 #include <sys/mman.h> 44 #include <sys/procctl.h> 45 #include <sys/ptrace.h> 46 #include <sys/socket.h> 47 #include <sys/time.h> 48 #include <sys/un.h> 49 #include <sys/wait.h> 50 #include <netinet/in.h> 51 #include <arpa/inet.h> 52 #include <sys/ioccom.h> 53 #include <machine/atomic.h> 54 #include <errno.h> 55 #include <sys/umtx.h> 56 #include <sys/event.h> 57 #include <sys/stat.h> 58 #include <sys/resource.h> 59 60 #include <ctype.h> 61 #include <err.h> 62 #include <fcntl.h> 63 #include <poll.h> 64 #include <signal.h> 65 #include <stdint.h> 66 #include <stdio.h> 67 #include <stdlib.h> 68 #include <string.h> 69 #include <time.h> 70 #include <unistd.h> 71 #include <vis.h> 72 73 #include "truss.h" 74 #include "extern.h" 75 #include "syscall.h" 76 77 /* 64-bit alignment on 32-bit platforms. */ 78 #ifdef __powerpc__ 79 #define QUAD_ALIGN 1 80 #else 81 #define QUAD_ALIGN 0 82 #endif 83 84 /* Number of slots needed for a 64-bit argument. */ 85 #ifdef __LP64__ 86 #define QUAD_SLOTS 1 87 #else 88 #define QUAD_SLOTS 2 89 #endif 90 91 /* 92 * This should probably be in its own file, sorted alphabetically. 93 */ 94 static struct syscall syscalls[] = { 95 { .name = "fcntl", .ret_type = 1, .nargs = 3, 96 .args = { { Int, 0 } , { Fcntl, 1 }, { Fcntlflag | OUT, 2 } } }, 97 { .name = "fork", .ret_type = 1, .nargs = 0 }, 98 { .name = "vfork", .ret_type = 1, .nargs = 0 }, 99 { .name = "rfork", .ret_type = 1, .nargs = 1, 100 .args = { { Rforkflags, 0 } } }, 101 { .name = "getegid", .ret_type = 1, .nargs = 0 }, 102 { .name = "geteuid", .ret_type = 1, .nargs = 0 }, 103 { .name = "linux_readlink", .ret_type = 1, .nargs = 3, 104 .args = { { Name, 0 } , { Name | OUT, 1 }, { Int, 2 }}}, 105 { .name = "linux_socketcall", .ret_type = 1, .nargs = 2, 106 .args = { { Int, 0 } , { LinuxSockArgs, 1 }}}, 107 { .name = "getgid", .ret_type = 1, .nargs = 0 }, 108 { .name = "getpid", .ret_type = 1, .nargs = 0 }, 109 { .name = "getpgid", .ret_type = 1, .nargs = 1, 110 .args = { { Int, 0 } } }, 111 { .name = "getpgrp", .ret_type = 1, .nargs = 0 }, 112 { .name = "getppid", .ret_type = 1, .nargs = 0 }, 113 { .name = "getsid", .ret_type = 1, .nargs = 1, 114 .args = { { Int, 0 } } }, 115 { .name = "getuid", .ret_type = 1, .nargs = 0 }, 116 { .name = "readlink", .ret_type = 1, .nargs = 3, 117 .args = { { Name, 0 } , { Readlinkres | OUT, 1 }, { Int, 2 } } }, 118 { .name = "lseek", .ret_type = 2, .nargs = 3, 119 .args = { { Int, 0 }, { Quad, 1 + QUAD_ALIGN }, { Whence, 1 + QUAD_SLOTS + QUAD_ALIGN } } }, 120 { .name = "linux_lseek", .ret_type = 2, .nargs = 3, 121 .args = { { Int, 0 }, { Int, 1 }, { Whence, 2 } } }, 122 { .name = "mmap", .ret_type = 2, .nargs = 6, 123 .args = { { Ptr, 0 }, { Int, 1 }, { Mprot, 2 }, { Mmapflags, 3 }, { Int, 4 }, { Quad, 5 + QUAD_ALIGN } } }, 124 { .name = "linux_mkdir", .ret_type = 1, .nargs = 2, 125 .args = { { Name | IN, 0} , {Int, 1}}}, 126 { .name = "mprotect", .ret_type = 1, .nargs = 3, 127 .args = { { Ptr, 0 }, { Int, 1 }, { Mprot, 2 } } }, 128 { .name = "open", .ret_type = 1, .nargs = 3, 129 .args = { { Name | IN, 0 } , { Open, 1 }, { Octal, 2 } } }, 130 { .name = "mkdir", .ret_type = 1, .nargs = 2, 131 .args = { { Name, 0 } , { Octal, 1 } } }, 132 { .name = "linux_open", .ret_type = 1, .nargs = 3, 133 .args = { { Name, 0 }, { Hex, 1 }, { Octal, 2 } } }, 134 { .name = "close", .ret_type = 1, .nargs = 1, 135 .args = { { Int, 0 } } }, 136 { .name = "link", .ret_type = 0, .nargs = 2, 137 .args = { { Name, 0 }, { Name, 1 } } }, 138 { .name = "unlink", .ret_type = 0, .nargs = 1, 139 .args = { { Name, 0 } } }, 140 { .name = "chdir", .ret_type = 0, .nargs = 1, 141 .args = { { Name, 0 } } }, 142 { .name = "chroot", .ret_type = 0, .nargs = 1, 143 .args = { { Name, 0 } } }, 144 { .name = "mknod", .ret_type = 0, .nargs = 3, 145 .args = { { Name, 0 }, { Octal, 1 }, { Int, 3 } } }, 146 { .name = "chmod", .ret_type = 0, .nargs = 2, 147 .args = { { Name, 0 }, { Octal, 1 } } }, 148 { .name = "chown", .ret_type = 0, .nargs = 3, 149 .args = { { Name, 0 }, { Int, 1 }, { Int, 2 } } }, 150 { .name = "linux_stat64", .ret_type = 1, .nargs = 3, 151 .args = { { Name | IN, 0 }, { Ptr | OUT, 1 }, { Ptr | IN, 1 }}}, 152 { .name = "mount", .ret_type = 0, .nargs = 4, 153 .args = { { Name, 0 }, { Name, 1 }, { Int, 2 }, { Ptr, 3 } } }, 154 { .name = "umount", .ret_type = 0, .nargs = 2, 155 .args = { { Name, 0 }, { Int, 2 } } }, 156 { .name = "fstat", .ret_type = 1, .nargs = 2, 157 .args = { { Int, 0 }, { Stat | OUT , 1 } } }, 158 { .name = "stat", .ret_type = 1, .nargs = 2, 159 .args = { { Name | IN, 0 }, { Stat | OUT, 1 } } }, 160 { .name = "lstat", .ret_type = 1, .nargs = 2, 161 .args = { { Name | IN, 0 }, { Stat | OUT, 1 } } }, 162 { .name = "linux_newstat", .ret_type = 1, .nargs = 2, 163 .args = { { Name | IN, 0 }, { Ptr | OUT, 1 } } }, 164 { .name = "linux_access", .ret_type = 1, .nargs = 2, 165 .args = { { Name, 0 }, { Int, 1 }}}, 166 { .name = "linux_newfstat", .ret_type = 1, .nargs = 2, 167 .args = { { Int, 0 }, { Ptr | OUT, 1 } } }, 168 { .name = "write", .ret_type = 1, .nargs = 3, 169 .args = { { Int, 0 }, { BinString | IN, 1 }, { Int, 2 } } }, 170 { .name = "ioctl", .ret_type = 1, .nargs = 3, 171 .args = { { Int, 0 }, { Ioctl, 1 }, { Hex, 2 } } }, 172 { .name = "break", .ret_type = 1, .nargs = 1, 173 .args = { { Ptr, 0 } } }, 174 { .name = "exit", .ret_type = 0, .nargs = 1, 175 .args = { { Hex, 0 } } }, 176 { .name = "access", .ret_type = 1, .nargs = 2, 177 .args = { { Name | IN, 0 }, { Int, 1 } } }, 178 { .name = "sigaction", .ret_type = 1, .nargs = 3, 179 .args = { { Signal, 0 }, { Sigaction | IN, 1 }, { Sigaction | OUT, 2 } } }, 180 { .name = "accept", .ret_type = 1, .nargs = 3, 181 .args = { { Int, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } }, 182 { .name = "bind", .ret_type = 1, .nargs = 3, 183 .args = { { Int, 0 }, { Sockaddr | IN, 1 }, { Int, 2 } } }, 184 { .name = "connect", .ret_type = 1, .nargs = 3, 185 .args = { { Int, 0 }, { Sockaddr | IN, 1 }, { Int, 2 } } }, 186 { .name = "getpeername", .ret_type = 1, .nargs = 3, 187 .args = { { Int, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } }, 188 { .name = "getsockname", .ret_type = 1, .nargs = 3, 189 .args = { { Int, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } }, 190 { .name = "recvfrom", .ret_type = 1, .nargs = 6, 191 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Int, 2 }, { Hex, 3 }, { Sockaddr | OUT, 4 }, { Ptr | OUT, 5 } } }, 192 { .name = "sendto", .ret_type = 1, .nargs = 6, 193 .args = { { Int, 0 }, { BinString | IN, 1 }, { Int, 2 }, { Hex, 3 }, { Sockaddr | IN, 4 }, { Ptr | IN, 5 } } }, 194 { .name = "execve", .ret_type = 1, .nargs = 3, 195 .args = { { Name | IN, 0 }, { StringArray | IN, 1 }, { StringArray | IN, 2 } } }, 196 { .name = "linux_execve", .ret_type = 1, .nargs = 3, 197 .args = { { Name | IN, 0 }, { StringArray | IN, 1 }, { StringArray | IN, 2 } } }, 198 { .name = "kldload", .ret_type = 0, .nargs = 1, 199 .args = { { Name | IN, 0 } } }, 200 { .name = "kldunload", .ret_type = 0, .nargs = 1, 201 .args = { { Int, 0 } } }, 202 { .name = "kldfind", .ret_type = 0, .nargs = 1, 203 .args = { { Name | IN, 0 } } }, 204 { .name = "kldnext", .ret_type = 0, .nargs = 1, 205 .args = { { Int, 0 } } }, 206 { .name = "kldstat", .ret_type = 0, .nargs = 2, 207 .args = { { Int, 0 }, { Ptr, 1 } } }, 208 { .name = "kldfirstmod", .ret_type = 0, .nargs = 1, 209 .args = { { Int, 0 } } }, 210 { .name = "nanosleep", .ret_type = 0, .nargs = 1, 211 .args = { { Timespec, 0 } } }, 212 { .name = "select", .ret_type = 1, .nargs = 5, 213 .args = { { Int, 0 }, { Fd_set, 1 }, { Fd_set, 2 }, { Fd_set, 3 }, { Timeval, 4 } } }, 214 { .name = "poll", .ret_type = 1, .nargs = 3, 215 .args = { { Pollfd, 0 }, { Int, 1 }, { Int, 2 } } }, 216 { .name = "gettimeofday", .ret_type = 1, .nargs = 2, 217 .args = { { Timeval | OUT, 0 }, { Ptr, 1 } } }, 218 { .name = "clock_gettime", .ret_type = 1, .nargs = 2, 219 .args = { { Int, 0 }, { Timespec | OUT, 1 } } }, 220 { .name = "getitimer", .ret_type = 1, .nargs = 2, 221 .args = { { Int, 0 }, { Itimerval | OUT, 2 } } }, 222 { .name = "setitimer", .ret_type = 1, .nargs = 3, 223 .args = { { Int, 0 }, { Itimerval, 1 } , { Itimerval | OUT, 2 } } }, 224 { .name = "kse_release", .ret_type = 0, .nargs = 1, 225 .args = { { Timespec, 0 } } }, 226 { .name = "kevent", .ret_type = 0, .nargs = 6, 227 .args = { { Int, 0 }, { Kevent, 1 }, { Int, 2 }, { Kevent | OUT, 3 }, { Int, 4 }, { Timespec, 5 } } }, 228 { .name = "sigprocmask", .ret_type = 0, .nargs = 3, 229 .args = { { Sigprocmask, 0 }, { Sigset, 1 }, { Sigset | OUT, 2 } } }, 230 { .name = "unmount", .ret_type = 1, .nargs = 2, 231 .args = { { Name, 0 }, { Int, 1 } } }, 232 { .name = "socket", .ret_type = 1, .nargs = 3, 233 .args = { { Sockdomain, 0 }, { Socktype, 1 }, { Int, 2 } } }, 234 { .name = "getrusage", .ret_type = 1, .nargs = 2, 235 .args = { { Int, 0 }, { Rusage | OUT, 1 } } }, 236 { .name = "__getcwd", .ret_type = 1, .nargs = 2, 237 .args = { { Name | OUT, 0 }, { Int, 1 } } }, 238 { .name = "shutdown", .ret_type = 1, .nargs = 2, 239 .args = { { Int, 0 }, { Shutdown, 1 } } }, 240 { .name = "getrlimit", .ret_type = 1, .nargs = 2, 241 .args = { { Resource, 0 }, { Rlimit | OUT, 1 } } }, 242 { .name = "setrlimit", .ret_type = 1, .nargs = 2, 243 .args = { { Resource, 0 }, { Rlimit | IN, 1 } } }, 244 { .name = "utimes", .ret_type = 1, .nargs = 2, 245 .args = { { Name | IN, 0 }, { Timeval2 | IN, 1 } } }, 246 { .name = "lutimes", .ret_type = 1, .nargs = 2, 247 .args = { { Name | IN, 0 }, { Timeval2 | IN, 1 } } }, 248 { .name = "futimes", .ret_type = 1, .nargs = 2, 249 .args = { { Int, 0 }, { Timeval | IN, 1 } } }, 250 { .name = "chflags", .ret_type = 1, .nargs = 2, 251 .args = { { Name | IN, 0 }, { Hex, 1 } } }, 252 { .name = "lchflags", .ret_type = 1, .nargs = 2, 253 .args = { { Name | IN, 0 }, { Hex, 1 } } }, 254 { .name = "pathconf", .ret_type = 1, .nargs = 2, 255 .args = { { Name | IN, 0 }, { Pathconf, 1 } } }, 256 { .name = "pipe", .ret_type = 1, .nargs = 1, 257 .args = { { Ptr, 0 } } }, 258 { .name = "truncate", .ret_type = 1, .nargs = 3, 259 .args = { { Name | IN, 0 }, { Int | IN, 1 }, { Quad | IN, 2 } } }, 260 { .name = "ftruncate", .ret_type = 1, .nargs = 3, 261 .args = { { Int | IN, 0 }, { Int | IN, 1 }, { Quad | IN, 2 } } }, 262 { .name = "kill", .ret_type = 1, .nargs = 2, 263 .args = { { Int | IN, 0 }, { Signal | IN, 1 } } }, 264 { .name = "munmap", .ret_type = 1, .nargs = 2, 265 .args = { { Ptr, 0 }, { Int, 1 } } }, 266 { .name = "read", .ret_type = 1, .nargs = 3, 267 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Int, 2 } } }, 268 { .name = "rename", .ret_type = 1, .nargs = 2, 269 .args = { { Name , 0 } , { Name, 1 } } }, 270 { .name = "symlink", .ret_type = 1, .nargs = 2, 271 .args = { { Name , 0 } , { Name, 1 } } }, 272 { .name = "posix_openpt", .ret_type = 1, .nargs = 1, 273 .args = { { Open, 0 } } }, 274 { .name = "wait4", .ret_type = 1, .nargs = 4, 275 .args = { { Int, 0 }, { ExitStatus | OUT, 1 }, { Waitoptions, 2 }, 276 { Rusage | OUT, 3 } } }, 277 { .name = "wait6", .ret_type = 1, .nargs = 6, 278 .args = { { Idtype, 0 }, { Int, 1 }, { ExitStatus | OUT, 2 }, 279 { Waitoptions, 3 }, { Rusage | OUT, 4 }, { Ptr, 5 } } }, 280 { .name = "procctl", .ret_type = 1, .nargs = 4, 281 .args = { { Idtype, 0 }, { Int, 1 }, { Procctl, 2 }, { Ptr, 3 } } }, 282 { .name = "_umtx_op", .ret_type = 1, .nargs = 5, 283 .args = { { Ptr, 0 }, { Umtxop, 1 }, { LongHex, 2 }, { Ptr, 3 }, 284 { Ptr, 4 } } }, 285 { .name = 0 }, 286 }; 287 288 /* Xlat idea taken from strace */ 289 struct xlat { 290 int val; 291 const char *str; 292 }; 293 294 #define X(a) { a, #a }, 295 #define XEND { 0, NULL } 296 297 static struct xlat kevent_filters[] = { 298 X(EVFILT_READ) X(EVFILT_WRITE) X(EVFILT_AIO) X(EVFILT_VNODE) 299 X(EVFILT_PROC) X(EVFILT_SIGNAL) X(EVFILT_TIMER) 300 X(EVFILT_FS) X(EVFILT_READ) XEND 301 }; 302 303 static struct xlat kevent_flags[] = { 304 X(EV_ADD) X(EV_DELETE) X(EV_ENABLE) X(EV_DISABLE) X(EV_ONESHOT) 305 X(EV_CLEAR) X(EV_FLAG1) X(EV_ERROR) X(EV_EOF) XEND 306 }; 307 308 static struct xlat poll_flags[] = { 309 X(POLLSTANDARD) X(POLLIN) X(POLLPRI) X(POLLOUT) X(POLLERR) 310 X(POLLHUP) X(POLLNVAL) X(POLLRDNORM) X(POLLRDBAND) 311 X(POLLWRBAND) X(POLLINIGNEOF) XEND 312 }; 313 314 static struct xlat mmap_flags[] = { 315 X(MAP_SHARED) X(MAP_PRIVATE) X(MAP_FIXED) X(MAP_RESERVED0020) 316 X(MAP_RESERVED0040) X(MAP_RESERVED0080) X(MAP_RESERVED0100) 317 X(MAP_HASSEMAPHORE) X(MAP_STACK) X(MAP_NOSYNC) X(MAP_ANON) 318 X(MAP_NOCORE) X(MAP_PREFAULT_READ) 319 #ifdef MAP_32BIT 320 X(MAP_32BIT) 321 #endif 322 XEND 323 }; 324 325 static struct xlat mprot_flags[] = { 326 X(PROT_NONE) X(PROT_READ) X(PROT_WRITE) X(PROT_EXEC) XEND 327 }; 328 329 static struct xlat whence_arg[] = { 330 X(SEEK_SET) X(SEEK_CUR) X(SEEK_END) XEND 331 }; 332 333 static struct xlat sigaction_flags[] = { 334 X(SA_ONSTACK) X(SA_RESTART) X(SA_RESETHAND) X(SA_NOCLDSTOP) 335 X(SA_NODEFER) X(SA_NOCLDWAIT) X(SA_SIGINFO) XEND 336 }; 337 338 static struct xlat fcntl_arg[] = { 339 X(F_DUPFD) X(F_GETFD) X(F_SETFD) X(F_GETFL) X(F_SETFL) 340 X(F_GETOWN) X(F_SETOWN) X(F_GETLK) X(F_SETLK) X(F_SETLKW) XEND 341 }; 342 343 static struct xlat fcntlfd_arg[] = { 344 X(FD_CLOEXEC) XEND 345 }; 346 347 static struct xlat fcntlfl_arg[] = { 348 X(O_APPEND) X(O_ASYNC) X(O_FSYNC) X(O_NONBLOCK) X(O_NOFOLLOW) 349 X(O_DIRECT) XEND 350 }; 351 352 static struct xlat sockdomain_arg[] = { 353 X(PF_UNSPEC) X(PF_LOCAL) X(PF_UNIX) X(PF_INET) X(PF_IMPLINK) 354 X(PF_PUP) X(PF_CHAOS) X(PF_NETBIOS) X(PF_ISO) X(PF_OSI) 355 X(PF_ECMA) X(PF_DATAKIT) X(PF_CCITT) X(PF_SNA) X(PF_DECnet) 356 X(PF_DLI) X(PF_LAT) X(PF_HYLINK) X(PF_APPLETALK) X(PF_ROUTE) 357 X(PF_LINK) X(PF_XTP) X(PF_COIP) X(PF_CNT) X(PF_SIP) X(PF_IPX) 358 X(PF_RTIP) X(PF_PIP) X(PF_ISDN) X(PF_KEY) X(PF_INET6) 359 X(PF_NATM) X(PF_ATM) X(PF_NETGRAPH) X(PF_SLOW) X(PF_SCLUSTER) 360 X(PF_ARP) X(PF_BLUETOOTH) XEND 361 }; 362 363 static struct xlat socktype_arg[] = { 364 X(SOCK_STREAM) X(SOCK_DGRAM) X(SOCK_RAW) X(SOCK_RDM) 365 X(SOCK_SEQPACKET) XEND 366 }; 367 368 static struct xlat open_flags[] = { 369 X(O_RDONLY) X(O_WRONLY) X(O_RDWR) X(O_ACCMODE) X(O_NONBLOCK) 370 X(O_APPEND) X(O_SHLOCK) X(O_EXLOCK) X(O_ASYNC) X(O_FSYNC) 371 X(O_NOFOLLOW) X(O_CREAT) X(O_TRUNC) X(O_EXCL) X(O_NOCTTY) 372 X(O_DIRECT) X(O_DIRECTORY) X(O_EXEC) X(O_TTY_INIT) X(O_CLOEXEC) XEND 373 }; 374 375 static struct xlat shutdown_arg[] = { 376 X(SHUT_RD) X(SHUT_WR) X(SHUT_RDWR) XEND 377 }; 378 379 static struct xlat resource_arg[] = { 380 X(RLIMIT_CPU) X(RLIMIT_FSIZE) X(RLIMIT_DATA) X(RLIMIT_STACK) 381 X(RLIMIT_CORE) X(RLIMIT_RSS) X(RLIMIT_MEMLOCK) X(RLIMIT_NPROC) 382 X(RLIMIT_NOFILE) X(RLIMIT_SBSIZE) X(RLIMIT_VMEM) XEND 383 }; 384 385 static struct xlat pathconf_arg[] = { 386 X(_PC_LINK_MAX) X(_PC_MAX_CANON) X(_PC_MAX_INPUT) 387 X(_PC_NAME_MAX) X(_PC_PATH_MAX) X(_PC_PIPE_BUF) 388 X(_PC_CHOWN_RESTRICTED) X(_PC_NO_TRUNC) X(_PC_VDISABLE) 389 X(_PC_ASYNC_IO) X(_PC_PRIO_IO) X(_PC_SYNC_IO) 390 X(_PC_ALLOC_SIZE_MIN) X(_PC_FILESIZEBITS) 391 X(_PC_REC_INCR_XFER_SIZE) X(_PC_REC_MAX_XFER_SIZE) 392 X(_PC_REC_MIN_XFER_SIZE) X(_PC_REC_XFER_ALIGN) 393 X(_PC_SYMLINK_MAX) X(_PC_ACL_EXTENDED) X(_PC_ACL_PATH_MAX) 394 X(_PC_CAP_PRESENT) X(_PC_INF_PRESENT) X(_PC_MAC_PRESENT) 395 XEND 396 }; 397 398 static struct xlat rfork_flags[] = { 399 X(RFPROC) X(RFNOWAIT) X(RFFDG) X(RFCFDG) X(RFTHREAD) X(RFMEM) 400 X(RFSIGSHARE) X(RFTSIGZMB) X(RFLINUXTHPN) XEND 401 }; 402 403 static struct xlat wait_options[] = { 404 X(WNOHANG) X(WUNTRACED) X(WCONTINUED) X(WNOWAIT) X(WEXITED) 405 X(WTRAPPED) XEND 406 }; 407 408 static struct xlat idtype_arg[] = { 409 X(P_PID) X(P_PPID) X(P_PGID) X(P_SID) X(P_CID) X(P_UID) X(P_GID) 410 X(P_ALL) X(P_LWPID) X(P_TASKID) X(P_PROJID) X(P_POOLID) X(P_JAILID) 411 X(P_CTID) X(P_CPUID) X(P_PSETID) XEND 412 }; 413 414 static struct xlat procctl_arg[] = { 415 X(PROC_SPROTECT) XEND 416 }; 417 418 static struct xlat umtx_ops[] = { 419 X(UMTX_OP_RESERVED0) X(UMTX_OP_RESERVED1) X(UMTX_OP_WAIT) 420 X(UMTX_OP_WAKE) X(UMTX_OP_MUTEX_TRYLOCK) X(UMTX_OP_MUTEX_LOCK) 421 X(UMTX_OP_MUTEX_UNLOCK) X(UMTX_OP_SET_CEILING) X(UMTX_OP_CV_WAIT) 422 X(UMTX_OP_CV_SIGNAL) X(UMTX_OP_CV_BROADCAST) X(UMTX_OP_WAIT_UINT) 423 X(UMTX_OP_RW_RDLOCK) X(UMTX_OP_RW_WRLOCK) X(UMTX_OP_RW_UNLOCK) 424 X(UMTX_OP_WAIT_UINT_PRIVATE) X(UMTX_OP_WAKE_PRIVATE) 425 X(UMTX_OP_MUTEX_WAIT) X(UMTX_OP_MUTEX_WAKE) X(UMTX_OP_SEM_WAIT) 426 X(UMTX_OP_SEM_WAKE) X(UMTX_OP_NWAKE_PRIVATE) X(UMTX_OP_MUTEX_WAKE2) 427 X(UMTX_OP_SEM2_WAIT) X(UMTX_OP_SEM2_WAKE) 428 XEND 429 }; 430 431 #undef X 432 #undef XEND 433 434 /* 435 * Searches an xlat array for a value, and returns it if found. Otherwise 436 * return a string representation. 437 */ 438 static const char * 439 lookup(struct xlat *xlat, int val, int base) 440 { 441 static char tmp[16]; 442 443 for (; xlat->str != NULL; xlat++) 444 if (xlat->val == val) 445 return (xlat->str); 446 switch (base) { 447 case 8: 448 sprintf(tmp, "0%o", val); 449 break; 450 case 16: 451 sprintf(tmp, "0x%x", val); 452 break; 453 case 10: 454 sprintf(tmp, "%u", val); 455 break; 456 default: 457 errx(1,"Unknown lookup base"); 458 break; 459 } 460 return (tmp); 461 } 462 463 static const char * 464 xlookup(struct xlat *xlat, int val) 465 { 466 467 return (lookup(xlat, val, 16)); 468 } 469 470 /* Searches an xlat array containing bitfield values. Remaining bits 471 set after removing the known ones are printed at the end: 472 IN|0x400 */ 473 static char * 474 xlookup_bits(struct xlat *xlat, int val) 475 { 476 int len, rem; 477 static char str[512]; 478 479 len = 0; 480 rem = val; 481 for (; xlat->str != NULL; xlat++) { 482 if ((xlat->val & rem) == xlat->val) { 483 /* don't print the "all-bits-zero" string unless all 484 bits are really zero */ 485 if (xlat->val == 0 && val != 0) 486 continue; 487 len += sprintf(str + len, "%s|", xlat->str); 488 rem &= ~(xlat->val); 489 } 490 } 491 /* if we have leftover bits or didn't match anything */ 492 if (rem || len == 0) 493 len += sprintf(str + len, "0x%x", rem); 494 if (len && str[len - 1] == '|') 495 len--; 496 str[len] = 0; 497 return (str); 498 } 499 500 /* 501 * If/when the list gets big, it might be desirable to do it 502 * as a hash table or binary search. 503 */ 504 505 struct syscall * 506 get_syscall(const char *name) 507 { 508 struct syscall *sc; 509 510 sc = syscalls; 511 if (name == NULL) 512 return (NULL); 513 while (sc->name) { 514 if (strcmp(name, sc->name) == 0) 515 return (sc); 516 sc++; 517 } 518 return (NULL); 519 } 520 521 /* 522 * get_struct 523 * 524 * Copy a fixed amount of bytes from the process. 525 */ 526 527 static int 528 get_struct(pid_t pid, void *offset, void *buf, int len) 529 { 530 struct ptrace_io_desc iorequest; 531 532 iorequest.piod_op = PIOD_READ_D; 533 iorequest.piod_offs = offset; 534 iorequest.piod_addr = buf; 535 iorequest.piod_len = len; 536 if (ptrace(PT_IO, pid, (caddr_t)&iorequest, 0) < 0) 537 return (-1); 538 return (0); 539 } 540 541 #define MAXSIZE 4096 542 #define BLOCKSIZE 1024 543 /* 544 * get_string 545 * Copy a string from the process. Note that it is 546 * expected to be a C string, but if max is set, it will 547 * only get that much. 548 */ 549 550 static char * 551 get_string(pid_t pid, void *offset, int max) 552 { 553 struct ptrace_io_desc iorequest; 554 char *buf; 555 int diff, i, size, totalsize; 556 557 diff = 0; 558 totalsize = size = max ? (max + 1) : BLOCKSIZE; 559 buf = malloc(totalsize); 560 if (buf == NULL) 561 return (NULL); 562 for (;;) { 563 diff = totalsize - size; 564 iorequest.piod_op = PIOD_READ_D; 565 iorequest.piod_offs = (char *)offset + diff; 566 iorequest.piod_addr = buf + diff; 567 iorequest.piod_len = size; 568 if (ptrace(PT_IO, pid, (caddr_t)&iorequest, 0) < 0) { 569 free(buf); 570 return (NULL); 571 } 572 for (i = 0 ; i < size; i++) { 573 if (buf[diff + i] == '\0') 574 return (buf); 575 } 576 if (totalsize < MAXSIZE - BLOCKSIZE && max == 0) { 577 totalsize += BLOCKSIZE; 578 buf = realloc(buf, totalsize); 579 size = BLOCKSIZE; 580 } else { 581 buf[totalsize - 1] = '\0'; 582 return (buf); 583 } 584 } 585 } 586 587 static char * 588 strsig2(int sig) 589 { 590 char *tmp; 591 592 tmp = strsig(sig); 593 if (tmp == NULL) 594 asprintf(&tmp, "%d", sig); 595 return (tmp); 596 } 597 598 /* 599 * print_arg 600 * Converts a syscall argument into a string. Said string is 601 * allocated via malloc(), so needs to be free()'d. The file 602 * descriptor is for the process' memory (via /proc), and is used 603 * to get any data (where the argument is a pointer). sc is 604 * a pointer to the syscall description (see above); args is 605 * an array of all of the system call arguments. 606 */ 607 608 char * 609 print_arg(struct syscall_args *sc, unsigned long *args, long retval, 610 struct trussinfo *trussinfo) 611 { 612 char *tmp; 613 pid_t pid; 614 615 tmp = NULL; 616 pid = trussinfo->pid; 617 switch (sc->type & ARG_MASK) { 618 case Hex: 619 asprintf(&tmp, "0x%x", (int)args[sc->offset]); 620 break; 621 case Octal: 622 asprintf(&tmp, "0%o", (int)args[sc->offset]); 623 break; 624 case Int: 625 asprintf(&tmp, "%d", (int)args[sc->offset]); 626 break; 627 case LongHex: 628 asprintf(&tmp, "0x%lx", args[sc->offset]); 629 break; 630 case Name: { 631 /* NULL-terminated string. */ 632 char *tmp2; 633 tmp2 = get_string(pid, (void*)args[sc->offset], 0); 634 asprintf(&tmp, "\"%s\"", tmp2); 635 free(tmp2); 636 break; 637 } 638 case BinString: { 639 /* Binary block of data that might have printable characters. 640 XXX If type|OUT, assume that the length is the syscall's 641 return value. Otherwise, assume that the length of the block 642 is in the next syscall argument. */ 643 int max_string = trussinfo->strsize; 644 char tmp2[max_string+1], *tmp3; 645 int len; 646 int truncated = 0; 647 648 if (sc->type & OUT) 649 len = retval; 650 else 651 len = args[sc->offset + 1]; 652 653 /* Don't print more than max_string characters, to avoid word 654 wrap. If we have to truncate put some ... after the string. 655 */ 656 if (len > max_string) { 657 len = max_string; 658 truncated = 1; 659 } 660 if (len && get_struct(pid, (void*)args[sc->offset], &tmp2, len) 661 != -1) { 662 tmp3 = malloc(len * 4 + 1); 663 while (len) { 664 if (strvisx(tmp3, tmp2, len, 665 VIS_CSTYLE|VIS_TAB|VIS_NL) <= max_string) 666 break; 667 len--; 668 truncated = 1; 669 }; 670 asprintf(&tmp, "\"%s\"%s", tmp3, truncated ? 671 "..." : ""); 672 free(tmp3); 673 } else { 674 asprintf(&tmp, "0x%lx", args[sc->offset]); 675 } 676 break; 677 } 678 case StringArray: { 679 int num, size, i; 680 char *tmp2; 681 char *string; 682 char *strarray[100]; /* XXX This is ugly. */ 683 684 if (get_struct(pid, (void *)args[sc->offset], 685 (void *)&strarray, sizeof(strarray)) == -1) 686 err(1, "get_struct %p", (void *)args[sc->offset]); 687 num = 0; 688 size = 0; 689 690 /* Find out how large of a buffer we'll need. */ 691 while (strarray[num] != NULL) { 692 string = get_string(pid, (void*)strarray[num], 0); 693 size += strlen(string); 694 free(string); 695 num++; 696 } 697 size += 4 + (num * 4); 698 tmp = (char *)malloc(size); 699 tmp2 = tmp; 700 701 tmp2 += sprintf(tmp2, " ["); 702 for (i = 0; i < num; i++) { 703 string = get_string(pid, (void*)strarray[i], 0); 704 tmp2 += sprintf(tmp2, " \"%s\"%c", string, 705 (i + 1 == num) ? ' ' : ','); 706 free(string); 707 } 708 tmp2 += sprintf(tmp2, "]"); 709 break; 710 } 711 #ifdef __LP64__ 712 case Quad: 713 asprintf(&tmp, "0x%lx", args[sc->offset]); 714 break; 715 #else 716 case Quad: { 717 unsigned long long ll; 718 ll = *(unsigned long long *)(args + sc->offset); 719 asprintf(&tmp, "0x%llx", ll); 720 break; 721 } 722 #endif 723 case Ptr: 724 asprintf(&tmp, "0x%lx", args[sc->offset]); 725 break; 726 case Readlinkres: { 727 char *tmp2; 728 if (retval == -1) { 729 tmp = strdup(""); 730 break; 731 } 732 tmp2 = get_string(pid, (void*)args[sc->offset], retval); 733 asprintf(&tmp, "\"%s\"", tmp2); 734 free(tmp2); 735 break; 736 } 737 case Ioctl: { 738 const char *temp = ioctlname(args[sc->offset]); 739 if (temp) 740 tmp = strdup(temp); 741 else { 742 unsigned long arg = args[sc->offset]; 743 asprintf(&tmp, "0x%lx { IO%s%s 0x%lx('%c'), %lu, %lu }", 744 arg, arg & IOC_OUT ? "R" : "", 745 arg & IOC_IN ? "W" : "", IOCGROUP(arg), 746 isprint(IOCGROUP(arg)) ? (char)IOCGROUP(arg) : '?', 747 arg & 0xFF, IOCPARM_LEN(arg)); 748 } 749 break; 750 } 751 case Timespec: { 752 struct timespec ts; 753 if (get_struct(pid, (void *)args[sc->offset], &ts, 754 sizeof(ts)) != -1) 755 asprintf(&tmp, "{%ld.%09ld }", (long)ts.tv_sec, 756 ts.tv_nsec); 757 else 758 asprintf(&tmp, "0x%lx", args[sc->offset]); 759 break; 760 } 761 case Timeval: { 762 struct timeval tv; 763 if (get_struct(pid, (void *)args[sc->offset], &tv, sizeof(tv)) 764 != -1) 765 asprintf(&tmp, "{%ld.%06ld }", (long)tv.tv_sec, 766 tv.tv_usec); 767 else 768 asprintf(&tmp, "0x%lx", args[sc->offset]); 769 break; 770 } 771 case Timeval2: { 772 struct timeval tv[2]; 773 if (get_struct(pid, (void *)args[sc->offset], &tv, sizeof(tv)) 774 != -1) 775 asprintf(&tmp, "{%ld.%06ld, %ld.%06ld }", 776 (long)tv[0].tv_sec, tv[0].tv_usec, 777 (long)tv[1].tv_sec, tv[1].tv_usec); 778 else 779 asprintf(&tmp, "0x%lx", args[sc->offset]); 780 break; 781 } 782 case Itimerval: { 783 struct itimerval itv; 784 if (get_struct(pid, (void *)args[sc->offset], &itv, 785 sizeof(itv)) != -1) 786 asprintf(&tmp, "{%ld.%06ld, %ld.%06ld }", 787 (long)itv.it_interval.tv_sec, 788 itv.it_interval.tv_usec, 789 (long)itv.it_value.tv_sec, 790 itv.it_value.tv_usec); 791 else 792 asprintf(&tmp, "0x%lx", args[sc->offset]); 793 break; 794 } 795 case LinuxSockArgs: 796 { 797 struct linux_socketcall_args largs; 798 if (get_struct(pid, (void *)args[sc->offset], (void *)&largs, 799 sizeof(largs)) == -1) { 800 err(1, "get_struct %p", (void *)args[sc->offset]); 801 } 802 const char *what; 803 char buf[30]; 804 805 switch (largs.what) { 806 case LINUX_SOCKET: 807 what = "LINUX_SOCKET"; 808 break; 809 case LINUX_BIND: 810 what = "LINUX_BIND"; 811 break; 812 case LINUX_CONNECT: 813 what = "LINUX_CONNECT"; 814 break; 815 case LINUX_LISTEN: 816 what = "LINUX_LISTEN"; 817 break; 818 case LINUX_ACCEPT: 819 what = "LINUX_ACCEPT"; 820 break; 821 case LINUX_GETSOCKNAME: 822 what = "LINUX_GETSOCKNAME"; 823 break; 824 case LINUX_GETPEERNAME: 825 what = "LINUX_GETPEERNAME"; 826 break; 827 case LINUX_SOCKETPAIR: 828 what = "LINUX_SOCKETPAIR"; 829 break; 830 case LINUX_SEND: 831 what = "LINUX_SEND"; 832 break; 833 case LINUX_RECV: 834 what = "LINUX_RECV"; 835 break; 836 case LINUX_SENDTO: 837 what = "LINUX_SENDTO"; 838 break; 839 case LINUX_RECVFROM: 840 what = "LINUX_RECVFROM"; 841 break; 842 case LINUX_SHUTDOWN: 843 what = "LINUX_SHUTDOWN"; 844 break; 845 case LINUX_SETSOCKOPT: 846 what = "LINUX_SETSOCKOPT"; 847 break; 848 case LINUX_GETSOCKOPT: 849 what = "LINUX_GETSOCKOPT"; 850 break; 851 case LINUX_SENDMSG: 852 what = "LINUX_SENDMSG"; 853 break; 854 case LINUX_RECVMSG: 855 what = "LINUX_RECVMSG"; 856 break; 857 default: 858 sprintf(buf, "%d", largs.what); 859 what = buf; 860 break; 861 } 862 asprintf(&tmp, "(0x%lx)%s, 0x%lx", args[sc->offset], what, (long unsigned int)largs.args); 863 break; 864 } 865 case Pollfd: { 866 /* 867 * XXX: A Pollfd argument expects the /next/ syscall argument 868 * to be the number of fds in the array. This matches the poll 869 * syscall. 870 */ 871 struct pollfd *pfd; 872 int numfds = args[sc->offset+1]; 873 int bytes = sizeof(struct pollfd) * numfds; 874 int i, tmpsize, u, used; 875 const int per_fd = 100; 876 877 if ((pfd = malloc(bytes)) == NULL) 878 err(1, "Cannot malloc %d bytes for pollfd array", 879 bytes); 880 if (get_struct(pid, (void *)args[sc->offset], pfd, bytes) 881 != -1) { 882 used = 0; 883 tmpsize = 1 + per_fd * numfds + 2; 884 if ((tmp = malloc(tmpsize)) == NULL) 885 err(1, "Cannot alloc %d bytes for poll output", 886 tmpsize); 887 888 tmp[used++] = '{'; 889 for (i = 0; i < numfds; i++) { 890 891 u = snprintf(tmp + used, per_fd, "%s%d/%s", 892 i > 0 ? " " : "", pfd[i].fd, 893 xlookup_bits(poll_flags, pfd[i].events)); 894 if (u > 0) 895 used += u < per_fd ? u : per_fd; 896 } 897 tmp[used++] = '}'; 898 tmp[used++] = '\0'; 899 } else { 900 asprintf(&tmp, "0x%lx", args[sc->offset]); 901 } 902 free(pfd); 903 break; 904 } 905 case Fd_set: { 906 /* 907 * XXX: A Fd_set argument expects the /first/ syscall argument 908 * to be the number of fds in the array. This matches the 909 * select syscall. 910 */ 911 fd_set *fds; 912 int numfds = args[0]; 913 int bytes = _howmany(numfds, _NFDBITS) * _NFDBITS; 914 int i, tmpsize, u, used; 915 const int per_fd = 20; 916 917 if ((fds = malloc(bytes)) == NULL) 918 err(1, "Cannot malloc %d bytes for fd_set array", 919 bytes); 920 if (get_struct(pid, (void *)args[sc->offset], fds, bytes) 921 != -1) { 922 used = 0; 923 tmpsize = 1 + numfds * per_fd + 2; 924 if ((tmp = malloc(tmpsize)) == NULL) 925 err(1, "Cannot alloc %d bytes for fd_set " 926 "output", tmpsize); 927 928 tmp[used++] = '{'; 929 for (i = 0; i < numfds; i++) { 930 if (FD_ISSET(i, fds)) { 931 u = snprintf(tmp + used, per_fd, "%d ", 932 i); 933 if (u > 0) 934 used += u < per_fd ? u : per_fd; 935 } 936 } 937 if (tmp[used-1] == ' ') 938 used--; 939 tmp[used++] = '}'; 940 tmp[used++] = '\0'; 941 } else 942 asprintf(&tmp, "0x%lx", args[sc->offset]); 943 free(fds); 944 break; 945 } 946 case Signal: 947 tmp = strsig2(args[sc->offset]); 948 break; 949 case Sigset: { 950 long sig; 951 sigset_t ss; 952 int i, used; 953 char *signame; 954 955 sig = args[sc->offset]; 956 if (get_struct(pid, (void *)args[sc->offset], (void *)&ss, 957 sizeof(ss)) == -1) { 958 asprintf(&tmp, "0x%lx", args[sc->offset]); 959 break; 960 } 961 tmp = malloc(sys_nsig * 8); /* 7 bytes avg per signal name */ 962 used = 0; 963 for (i = 1; i < sys_nsig; i++) { 964 if (sigismember(&ss, i)) { 965 signame = strsig(i); 966 used += sprintf(tmp + used, "%s|", signame); 967 free(signame); 968 } 969 } 970 if (used) 971 tmp[used-1] = 0; 972 else 973 strcpy(tmp, "0x0"); 974 break; 975 } 976 case Sigprocmask: { 977 switch (args[sc->offset]) { 978 #define S(a) case a: tmp = strdup(#a); break; 979 S(SIG_BLOCK); 980 S(SIG_UNBLOCK); 981 S(SIG_SETMASK); 982 #undef S 983 } 984 if (tmp == NULL) 985 asprintf(&tmp, "0x%lx", args[sc->offset]); 986 break; 987 } 988 case Fcntlflag: { 989 /* XXX output depends on the value of the previous argument */ 990 switch (args[sc->offset-1]) { 991 case F_SETFD: 992 tmp = strdup(xlookup_bits(fcntlfd_arg, 993 args[sc->offset])); 994 break; 995 case F_SETFL: 996 tmp = strdup(xlookup_bits(fcntlfl_arg, 997 args[sc->offset])); 998 break; 999 case F_GETFD: 1000 case F_GETFL: 1001 case F_GETOWN: 1002 tmp = strdup(""); 1003 break; 1004 default: 1005 asprintf(&tmp, "0x%lx", args[sc->offset]); 1006 break; 1007 } 1008 break; 1009 } 1010 case Open: 1011 tmp = strdup(xlookup_bits(open_flags, args[sc->offset])); 1012 break; 1013 case Fcntl: 1014 tmp = strdup(xlookup(fcntl_arg, args[sc->offset])); 1015 break; 1016 case Mprot: 1017 tmp = strdup(xlookup_bits(mprot_flags, args[sc->offset])); 1018 break; 1019 case Mmapflags: { 1020 char *base, *alignstr; 1021 int align, flags; 1022 1023 /* 1024 * MAP_ALIGNED can't be handled by xlookup_bits(), so 1025 * generate that string manually and prepend it to the 1026 * string from xlookup_bits(). Have to be careful to 1027 * avoid outputting MAP_ALIGNED|0 if MAP_ALIGNED is 1028 * the only flag. 1029 */ 1030 flags = args[sc->offset] & ~MAP_ALIGNMENT_MASK; 1031 align = args[sc->offset] & MAP_ALIGNMENT_MASK; 1032 if (align != 0) { 1033 if (align == MAP_ALIGNED_SUPER) 1034 alignstr = strdup("MAP_ALIGNED_SUPER"); 1035 else 1036 asprintf(&alignstr, "MAP_ALIGNED(%d)", 1037 align >> MAP_ALIGNMENT_SHIFT); 1038 if (flags == 0) { 1039 tmp = alignstr; 1040 break; 1041 } 1042 } else 1043 alignstr = NULL; 1044 base = strdup(xlookup_bits(mmap_flags, flags)); 1045 if (alignstr == NULL) { 1046 tmp = base; 1047 break; 1048 } 1049 asprintf(&tmp, "%s|%s", alignstr, base); 1050 free(alignstr); 1051 free(base); 1052 break; 1053 } 1054 case Whence: 1055 tmp = strdup(xlookup(whence_arg, args[sc->offset])); 1056 break; 1057 case Sockdomain: 1058 tmp = strdup(xlookup(sockdomain_arg, args[sc->offset])); 1059 break; 1060 case Socktype: 1061 tmp = strdup(xlookup(socktype_arg, args[sc->offset])); 1062 break; 1063 case Shutdown: 1064 tmp = strdup(xlookup(shutdown_arg, args[sc->offset])); 1065 break; 1066 case Resource: 1067 tmp = strdup(xlookup(resource_arg, args[sc->offset])); 1068 break; 1069 case Pathconf: 1070 tmp = strdup(xlookup(pathconf_arg, args[sc->offset])); 1071 break; 1072 case Rforkflags: 1073 tmp = strdup(xlookup_bits(rfork_flags, args[sc->offset])); 1074 break; 1075 case Sockaddr: { 1076 struct sockaddr_storage ss; 1077 char addr[64]; 1078 struct sockaddr_in *lsin; 1079 struct sockaddr_in6 *lsin6; 1080 struct sockaddr_un *sun; 1081 struct sockaddr *sa; 1082 char *p; 1083 u_char *q; 1084 int i; 1085 1086 if (args[sc->offset] == 0) { 1087 asprintf(&tmp, "NULL"); 1088 break; 1089 } 1090 1091 /* yuck: get ss_len */ 1092 if (get_struct(pid, (void *)args[sc->offset], (void *)&ss, 1093 sizeof(ss.ss_len) + sizeof(ss.ss_family)) == -1) 1094 err(1, "get_struct %p", (void *)args[sc->offset]); 1095 /* 1096 * If ss_len is 0, then try to guess from the sockaddr type. 1097 * AF_UNIX may be initialized incorrectly, so always frob 1098 * it by using the "right" size. 1099 */ 1100 if (ss.ss_len == 0 || ss.ss_family == AF_UNIX) { 1101 switch (ss.ss_family) { 1102 case AF_INET: 1103 ss.ss_len = sizeof(*lsin); 1104 break; 1105 case AF_UNIX: 1106 ss.ss_len = sizeof(*sun); 1107 break; 1108 default: 1109 /* hurrrr */ 1110 break; 1111 } 1112 } 1113 if (get_struct(pid, (void *)args[sc->offset], (void *)&ss, 1114 ss.ss_len) == -1) { 1115 err(2, "get_struct %p", (void *)args[sc->offset]); 1116 } 1117 1118 switch (ss.ss_family) { 1119 case AF_INET: 1120 lsin = (struct sockaddr_in *)&ss; 1121 inet_ntop(AF_INET, &lsin->sin_addr, addr, sizeof addr); 1122 asprintf(&tmp, "{ AF_INET %s:%d }", addr, 1123 htons(lsin->sin_port)); 1124 break; 1125 case AF_INET6: 1126 lsin6 = (struct sockaddr_in6 *)&ss; 1127 inet_ntop(AF_INET6, &lsin6->sin6_addr, addr, 1128 sizeof addr); 1129 asprintf(&tmp, "{ AF_INET6 [%s]:%d }", addr, 1130 htons(lsin6->sin6_port)); 1131 break; 1132 case AF_UNIX: 1133 sun = (struct sockaddr_un *)&ss; 1134 asprintf(&tmp, "{ AF_UNIX \"%s\" }", sun->sun_path); 1135 break; 1136 default: 1137 sa = (struct sockaddr *)&ss; 1138 asprintf(&tmp, "{ sa_len = %d, sa_family = %d, sa_data " 1139 "= {%n%*s } }", (int)sa->sa_len, (int)sa->sa_family, 1140 &i, 6 * (int)(sa->sa_len - ((char *)&sa->sa_data - 1141 (char *)sa)), ""); 1142 if (tmp != NULL) { 1143 p = tmp + i; 1144 for (q = (u_char *)&sa->sa_data; 1145 q < (u_char *)sa + sa->sa_len; q++) 1146 p += sprintf(p, " %#02x,", *q); 1147 } 1148 } 1149 break; 1150 } 1151 case Sigaction: { 1152 struct sigaction sa; 1153 char *hand; 1154 const char *h; 1155 1156 if (get_struct(pid, (void *)args[sc->offset], &sa, sizeof(sa)) 1157 != -1) { 1158 asprintf(&hand, "%p", sa.sa_handler); 1159 if (sa.sa_handler == SIG_DFL) 1160 h = "SIG_DFL"; 1161 else if (sa.sa_handler == SIG_IGN) 1162 h = "SIG_IGN"; 1163 else 1164 h = hand; 1165 1166 asprintf(&tmp, "{ %s %s ss_t }", h, 1167 xlookup_bits(sigaction_flags, sa.sa_flags)); 1168 free(hand); 1169 } else 1170 asprintf(&tmp, "0x%lx", args[sc->offset]); 1171 break; 1172 } 1173 case Kevent: { 1174 /* 1175 * XXX XXX: the size of the array is determined by either the 1176 * next syscall argument, or by the syscall returnvalue, 1177 * depending on which argument number we are. This matches the 1178 * kevent syscall, but luckily that's the only syscall that uses 1179 * them. 1180 */ 1181 struct kevent *ke; 1182 int numevents = -1; 1183 int bytes = 0; 1184 int i, tmpsize, u, used; 1185 const int per_ke = 100; 1186 1187 if (sc->offset == 1) 1188 numevents = args[sc->offset+1]; 1189 else if (sc->offset == 3 && retval != -1) 1190 numevents = retval; 1191 1192 if (numevents >= 0) 1193 bytes = sizeof(struct kevent) * numevents; 1194 if ((ke = malloc(bytes)) == NULL) 1195 err(1, "Cannot malloc %d bytes for kevent array", 1196 bytes); 1197 if (numevents >= 0 && get_struct(pid, (void *)args[sc->offset], 1198 ke, bytes) != -1) { 1199 used = 0; 1200 tmpsize = 1 + per_ke * numevents + 2; 1201 if ((tmp = malloc(tmpsize)) == NULL) 1202 err(1, "Cannot alloc %d bytes for kevent " 1203 "output", tmpsize); 1204 1205 tmp[used++] = '{'; 1206 for (i = 0; i < numevents; i++) { 1207 u = snprintf(tmp + used, per_ke, 1208 "%s%p,%s,%s,%d,%p,%p", 1209 i > 0 ? " " : "", 1210 (void *)ke[i].ident, 1211 xlookup(kevent_filters, ke[i].filter), 1212 xlookup_bits(kevent_flags, ke[i].flags), 1213 ke[i].fflags, 1214 (void *)ke[i].data, 1215 (void *)ke[i].udata); 1216 if (u > 0) 1217 used += u < per_ke ? u : per_ke; 1218 } 1219 tmp[used++] = '}'; 1220 tmp[used++] = '\0'; 1221 } else { 1222 asprintf(&tmp, "0x%lx", args[sc->offset]); 1223 } 1224 free(ke); 1225 break; 1226 } 1227 case Stat: { 1228 struct stat st; 1229 if (get_struct(pid, (void *)args[sc->offset], &st, sizeof(st)) 1230 != -1) { 1231 char mode[12]; 1232 strmode(st.st_mode, mode); 1233 asprintf(&tmp, 1234 "{ mode=%s,inode=%jd,size=%jd,blksize=%ld }", mode, 1235 (intmax_t)st.st_ino, (intmax_t)st.st_size, 1236 (long)st.st_blksize); 1237 } else { 1238 asprintf(&tmp, "0x%lx", args[sc->offset]); 1239 } 1240 break; 1241 } 1242 case Rusage: { 1243 struct rusage ru; 1244 if (get_struct(pid, (void *)args[sc->offset], &ru, sizeof(ru)) 1245 != -1) { 1246 asprintf(&tmp, 1247 "{ u=%ld.%06ld,s=%ld.%06ld,in=%ld,out=%ld }", 1248 (long)ru.ru_utime.tv_sec, ru.ru_utime.tv_usec, 1249 (long)ru.ru_stime.tv_sec, ru.ru_stime.tv_usec, 1250 ru.ru_inblock, ru.ru_oublock); 1251 } else 1252 asprintf(&tmp, "0x%lx", args[sc->offset]); 1253 break; 1254 } 1255 case Rlimit: { 1256 struct rlimit rl; 1257 if (get_struct(pid, (void *)args[sc->offset], &rl, sizeof(rl)) 1258 != -1) { 1259 asprintf(&tmp, "{ cur=%ju,max=%ju }", 1260 rl.rlim_cur, rl.rlim_max); 1261 } else 1262 asprintf(&tmp, "0x%lx", args[sc->offset]); 1263 break; 1264 } 1265 case ExitStatus: { 1266 char *signame; 1267 int status; 1268 signame = NULL; 1269 if (get_struct(pid, (void *)args[sc->offset], &status, 1270 sizeof(status)) != -1) { 1271 if (WIFCONTINUED(status)) 1272 tmp = strdup("{ CONTINUED }"); 1273 else if (WIFEXITED(status)) 1274 asprintf(&tmp, "{ EXITED,val=%d }", 1275 WEXITSTATUS(status)); 1276 else if (WIFSIGNALED(status)) 1277 asprintf(&tmp, "{ SIGNALED,sig=%s%s }", 1278 signame = strsig2(WTERMSIG(status)), 1279 WCOREDUMP(status) ? ",cored" : ""); 1280 else 1281 asprintf(&tmp, "{ STOPPED,sig=%s }", 1282 signame = strsig2(WTERMSIG(status))); 1283 } else 1284 asprintf(&tmp, "0x%lx", args[sc->offset]); 1285 free(signame); 1286 break; 1287 } 1288 case Waitoptions: 1289 tmp = strdup(xlookup_bits(wait_options, args[sc->offset])); 1290 break; 1291 case Idtype: 1292 tmp = strdup(xlookup(idtype_arg, args[sc->offset])); 1293 break; 1294 case Procctl: 1295 tmp = strdup(xlookup(procctl_arg, args[sc->offset])); 1296 break; 1297 case Umtxop: 1298 tmp = strdup(xlookup(umtx_ops, args[sc->offset])); 1299 break; 1300 default: 1301 errx(1, "Invalid argument type %d\n", sc->type & ARG_MASK); 1302 } 1303 return (tmp); 1304 } 1305 1306 /* 1307 * print_syscall 1308 * Print (to outfile) the system call and its arguments. Note that 1309 * nargs is the number of arguments (not the number of words; this is 1310 * potentially confusing, I know). 1311 */ 1312 1313 void 1314 print_syscall(struct trussinfo *trussinfo, const char *name, int nargs, 1315 char **s_args) 1316 { 1317 struct timespec timediff; 1318 int i, len; 1319 1320 len = 0; 1321 if (trussinfo->flags & FOLLOWFORKS) 1322 len += fprintf(trussinfo->outfile, "%5d: ", trussinfo->pid); 1323 1324 if (name != NULL && (strcmp(name, "execve") == 0 || 1325 strcmp(name, "exit") == 0)) { 1326 clock_gettime(CLOCK_REALTIME, &trussinfo->curthread->after); 1327 } 1328 1329 if (trussinfo->flags & ABSOLUTETIMESTAMPS) { 1330 timespecsubt(&trussinfo->curthread->after, 1331 &trussinfo->start_time, &timediff); 1332 len += fprintf(trussinfo->outfile, "%ld.%09ld ", 1333 (long)timediff.tv_sec, timediff.tv_nsec); 1334 } 1335 1336 if (trussinfo->flags & RELATIVETIMESTAMPS) { 1337 timespecsubt(&trussinfo->curthread->after, 1338 &trussinfo->curthread->before, &timediff); 1339 len += fprintf(trussinfo->outfile, "%ld.%09ld ", 1340 (long)timediff.tv_sec, timediff.tv_nsec); 1341 } 1342 1343 len += fprintf(trussinfo->outfile, "%s(", name); 1344 1345 for (i = 0; i < nargs; i++) { 1346 if (s_args[i]) 1347 len += fprintf(trussinfo->outfile, "%s", s_args[i]); 1348 else 1349 len += fprintf(trussinfo->outfile, 1350 "<missing argument>"); 1351 len += fprintf(trussinfo->outfile, "%s", i < (nargs - 1) ? 1352 "," : ""); 1353 } 1354 len += fprintf(trussinfo->outfile, ")"); 1355 for (i = 0; i < 6 - (len / 8); i++) 1356 fprintf(trussinfo->outfile, "\t"); 1357 } 1358 1359 void 1360 print_syscall_ret(struct trussinfo *trussinfo, const char *name, int nargs, 1361 char **s_args, int errorp, long retval, struct syscall *sc) 1362 { 1363 struct timespec timediff; 1364 1365 if (trussinfo->flags & COUNTONLY) { 1366 if (!sc) 1367 return; 1368 clock_gettime(CLOCK_REALTIME, &trussinfo->curthread->after); 1369 timespecsubt(&trussinfo->curthread->after, 1370 &trussinfo->curthread->before, &timediff); 1371 timespecadd(&sc->time, &timediff, &sc->time); 1372 sc->ncalls++; 1373 if (errorp) 1374 sc->nerror++; 1375 return; 1376 } 1377 1378 print_syscall(trussinfo, name, nargs, s_args); 1379 fflush(trussinfo->outfile); 1380 if (errorp) 1381 fprintf(trussinfo->outfile, " ERR#%ld '%s'\n", retval, 1382 strerror(retval)); 1383 else { 1384 /* 1385 * Because pipe(2) has a special assembly glue to provide the 1386 * libc API, we have to adjust retval. 1387 */ 1388 if (name != NULL && strcmp(name, "pipe") == 0) 1389 retval = 0; 1390 fprintf(trussinfo->outfile, " = %ld (0x%lx)\n", retval, retval); 1391 } 1392 } 1393 1394 void 1395 print_summary(struct trussinfo *trussinfo) 1396 { 1397 struct timespec total = {0, 0}; 1398 struct syscall *sc; 1399 int ncall, nerror; 1400 1401 fprintf(trussinfo->outfile, "%-20s%15s%8s%8s\n", 1402 "syscall", "seconds", "calls", "errors"); 1403 ncall = nerror = 0; 1404 for (sc = syscalls; sc->name != NULL; sc++) 1405 if (sc->ncalls) { 1406 fprintf(trussinfo->outfile, "%-20s%5jd.%09ld%8d%8d\n", 1407 sc->name, (intmax_t)sc->time.tv_sec, 1408 sc->time.tv_nsec, sc->ncalls, sc->nerror); 1409 timespecadd(&total, &sc->time, &total); 1410 ncall += sc->ncalls; 1411 nerror += sc->nerror; 1412 } 1413 fprintf(trussinfo->outfile, "%20s%15s%8s%8s\n", 1414 "", "-------------", "-------", "-------"); 1415 fprintf(trussinfo->outfile, "%-20s%5jd.%09ld%8d%8d\n", 1416 "", (intmax_t)total.tv_sec, total.tv_nsec, ncall, nerror); 1417 } 1418