1 /*- 2 * SPDX-License-Identifier: BSD-4-Clause 3 * 4 * Copyright 1997 Sean Eric Fagan 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Sean Eric Fagan 17 * 4. Neither the name of the author may be used to endorse or promote 18 * products derived from this software without specific prior written 19 * permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 /* 38 * This file has routines used to print out system calls and their 39 * arguments. 40 */ 41 42 #include <sys/capsicum.h> 43 #include <sys/types.h> 44 #define _WANT_FREEBSD11_KEVENT 45 #include <sys/event.h> 46 #include <sys/ioccom.h> 47 #include <sys/mount.h> 48 #include <sys/ptrace.h> 49 #include <sys/resource.h> 50 #include <sys/socket.h> 51 #define _WANT_FREEBSD11_STAT 52 #include <sys/stat.h> 53 #include <sys/un.h> 54 #include <sys/wait.h> 55 #include <netinet/in.h> 56 #include <netinet/sctp.h> 57 #include <arpa/inet.h> 58 59 #include <assert.h> 60 #include <ctype.h> 61 #include <err.h> 62 #include <fcntl.h> 63 #include <poll.h> 64 #include <sched.h> 65 #include <signal.h> 66 #include <stdbool.h> 67 #include <stdio.h> 68 #include <stdlib.h> 69 #include <string.h> 70 #include <sysdecode.h> 71 #include <unistd.h> 72 #include <vis.h> 73 74 #include <contrib/cloudabi/cloudabi_types_common.h> 75 76 #include "truss.h" 77 #include "extern.h" 78 #include "syscall.h" 79 80 /* 81 * This should probably be in its own file, sorted alphabetically. 82 */ 83 static struct syscall decoded_syscalls[] = { 84 /* Native ABI */ 85 { .name = "__acl_aclcheck_fd", .ret_type = 1, .nargs = 3, 86 .args = { { Int, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 87 { .name = "__acl_aclcheck_file", .ret_type = 1, .nargs = 3, 88 .args = { { Name, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 89 { .name = "__acl_aclcheck_link", .ret_type = 1, .nargs = 3, 90 .args = { { Name, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 91 { .name = "__acl_delete_fd", .ret_type = 1, .nargs = 2, 92 .args = { { Int, 0 }, { Acltype, 1 } } }, 93 { .name = "__acl_delete_file", .ret_type = 1, .nargs = 2, 94 .args = { { Name, 0 }, { Acltype, 1 } } }, 95 { .name = "__acl_delete_link", .ret_type = 1, .nargs = 2, 96 .args = { { Name, 0 }, { Acltype, 1 } } }, 97 { .name = "__acl_get_fd", .ret_type = 1, .nargs = 3, 98 .args = { { Int, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 99 { .name = "__acl_get_file", .ret_type = 1, .nargs = 3, 100 .args = { { Name, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 101 { .name = "__acl_get_link", .ret_type = 1, .nargs = 3, 102 .args = { { Name, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 103 { .name = "__acl_set_fd", .ret_type = 1, .nargs = 3, 104 .args = { { Int, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 105 { .name = "__acl_set_file", .ret_type = 1, .nargs = 3, 106 .args = { { Name, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 107 { .name = "__acl_set_link", .ret_type = 1, .nargs = 3, 108 .args = { { Name, 0 }, { Acltype, 1 }, { Ptr, 2 } } }, 109 { .name = "__cap_rights_get", .ret_type = 1, .nargs = 3, 110 .args = { { Int, 0 }, { Int, 1 }, { CapRights | OUT, 2 } } }, 111 { .name = "__getcwd", .ret_type = 1, .nargs = 2, 112 .args = { { Name | OUT, 0 }, { Int, 1 } } }, 113 { .name = "_umtx_op", .ret_type = 1, .nargs = 5, 114 .args = { { Ptr, 0 }, { Umtxop, 1 }, { LongHex, 2 }, { Ptr, 3 }, 115 { Ptr, 4 } } }, 116 { .name = "accept", .ret_type = 1, .nargs = 3, 117 .args = { { Int, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } }, 118 { .name = "access", .ret_type = 1, .nargs = 2, 119 .args = { { Name | IN, 0 }, { Accessmode, 1 } } }, 120 { .name = "bind", .ret_type = 1, .nargs = 3, 121 .args = { { Int, 0 }, { Sockaddr | IN, 1 }, { Socklent, 2 } } }, 122 { .name = "bindat", .ret_type = 1, .nargs = 4, 123 .args = { { Atfd, 0 }, { Int, 1 }, { Sockaddr | IN, 2 }, 124 { Int, 3 } } }, 125 { .name = "break", .ret_type = 1, .nargs = 1, 126 .args = { { Ptr, 0 } } }, 127 { .name = "cap_fcntls_get", .ret_type = 1, .nargs = 2, 128 .args = { { Int, 0 }, { CapFcntlRights | OUT, 1 } } }, 129 { .name = "cap_fcntls_limit", .ret_type = 1, .nargs = 2, 130 .args = { { Int, 0 }, { CapFcntlRights, 1 } } }, 131 { .name = "cap_getmode", .ret_type = 1, .nargs = 1, 132 .args = { { PUInt | OUT, 0 } } }, 133 { .name = "cap_rights_limit", .ret_type = 1, .nargs = 2, 134 .args = { { Int, 0 }, { CapRights, 1 } } }, 135 { .name = "chdir", .ret_type = 1, .nargs = 1, 136 .args = { { Name, 0 } } }, 137 { .name = "chflags", .ret_type = 1, .nargs = 2, 138 .args = { { Name | IN, 0 }, { FileFlags, 1 } } }, 139 { .name = "chflagsat", .ret_type = 1, .nargs = 4, 140 .args = { { Atfd, 0 }, { Name | IN, 1 }, { FileFlags, 2 }, 141 { Atflags, 3 } } }, 142 { .name = "chmod", .ret_type = 1, .nargs = 2, 143 .args = { { Name, 0 }, { Octal, 1 } } }, 144 { .name = "chown", .ret_type = 1, .nargs = 3, 145 .args = { { Name, 0 }, { Int, 1 }, { Int, 2 } } }, 146 { .name = "chroot", .ret_type = 1, .nargs = 1, 147 .args = { { Name, 0 } } }, 148 { .name = "clock_gettime", .ret_type = 1, .nargs = 2, 149 .args = { { Int, 0 }, { Timespec | OUT, 1 } } }, 150 { .name = "close", .ret_type = 1, .nargs = 1, 151 .args = { { Int, 0 } } }, 152 { .name = "compat11.fstat", .ret_type = 1, .nargs = 2, 153 .args = { { Int, 0 }, { Stat11 | OUT, 1 } } }, 154 { .name = "compat11.fstatat", .ret_type = 1, .nargs = 4, 155 .args = { { Atfd, 0 }, { Name | IN, 1 }, { Stat11 | OUT, 2 }, 156 { Atflags, 3 } } }, 157 { .name = "compat11.kevent", .ret_type = 1, .nargs = 6, 158 .args = { { Int, 0 }, { Kevent11, 1 }, { Int, 2 }, 159 { Kevent11 | OUT, 3 }, { Int, 4 }, { Timespec, 5 } } }, 160 { .name = "compat11.lstat", .ret_type = 1, .nargs = 2, 161 .args = { { Name | IN, 0 }, { Stat11 | OUT, 1 } } }, 162 { .name = "compat11.stat", .ret_type = 1, .nargs = 2, 163 .args = { { Name | IN, 0 }, { Stat11 | OUT, 1 } } }, 164 { .name = "connect", .ret_type = 1, .nargs = 3, 165 .args = { { Int, 0 }, { Sockaddr | IN, 1 }, { Socklent, 2 } } }, 166 { .name = "connectat", .ret_type = 1, .nargs = 4, 167 .args = { { Atfd, 0 }, { Int, 1 }, { Sockaddr | IN, 2 }, 168 { Int, 3 } } }, 169 { .name = "dup", .ret_type = 1, .nargs = 1, 170 .args = { { Int, 0 } } }, 171 { .name = "dup2", .ret_type = 1, .nargs = 2, 172 .args = { { Int, 0 }, { Int, 1 } } }, 173 { .name = "eaccess", .ret_type = 1, .nargs = 2, 174 .args = { { Name | IN, 0 }, { Accessmode, 1 } } }, 175 { .name = "execve", .ret_type = 1, .nargs = 3, 176 .args = { { Name | IN, 0 }, { ExecArgs | IN, 1 }, 177 { ExecEnv | IN, 2 } } }, 178 { .name = "exit", .ret_type = 0, .nargs = 1, 179 .args = { { Hex, 0 } } }, 180 { .name = "extattr_delete_fd", .ret_type = 1, .nargs = 3, 181 .args = { { Int, 0 }, { Extattrnamespace, 1 }, { Name, 2 } } }, 182 { .name = "extattr_delete_file", .ret_type = 1, .nargs = 3, 183 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { Name, 2 } } }, 184 { .name = "extattr_delete_link", .ret_type = 1, .nargs = 3, 185 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { Name, 2 } } }, 186 { .name = "extattr_get_fd", .ret_type = 1, .nargs = 5, 187 .args = { { Int, 0 }, { Extattrnamespace, 1 }, { Name, 2 }, 188 { BinString | OUT, 3 }, { Sizet, 4 } } }, 189 { .name = "extattr_get_file", .ret_type = 1, .nargs = 5, 190 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { Name, 2 }, 191 { BinString | OUT, 3 }, { Sizet, 4 } } }, 192 { .name = "extattr_get_link", .ret_type = 1, .nargs = 5, 193 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { Name, 2 }, 194 { BinString | OUT, 3 }, { Sizet, 4 } } }, 195 { .name = "extattr_list_fd", .ret_type = 1, .nargs = 4, 196 .args = { { Int, 0 }, { Extattrnamespace, 1 }, { BinString | OUT, 2 }, 197 { Sizet, 3 } } }, 198 { .name = "extattr_list_file", .ret_type = 1, .nargs = 4, 199 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { BinString | OUT, 2 }, 200 { Sizet, 3 } } }, 201 { .name = "extattr_list_link", .ret_type = 1, .nargs = 4, 202 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { BinString | OUT, 2 }, 203 { Sizet, 3 } } }, 204 { .name = "extattr_set_fd", .ret_type = 1, .nargs = 5, 205 .args = { { Int, 0 }, { Extattrnamespace, 1 }, { Name, 2 }, 206 { BinString | IN, 3 }, { Sizet, 4 } } }, 207 { .name = "extattr_set_file", .ret_type = 1, .nargs = 5, 208 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { Name, 2 }, 209 { BinString | IN, 3 }, { Sizet, 4 } } }, 210 { .name = "extattr_set_link", .ret_type = 1, .nargs = 5, 211 .args = { { Name, 0 }, { Extattrnamespace, 1 }, { Name, 2 }, 212 { BinString | IN, 3 }, { Sizet, 4 } } }, 213 { .name = "extattrctl", .ret_type = 1, .nargs = 5, 214 .args = { { Name, 0 }, { Hex, 1 }, { Name, 2 }, 215 { Extattrnamespace, 3 }, { Name, 4 } } }, 216 { .name = "faccessat", .ret_type = 1, .nargs = 4, 217 .args = { { Atfd, 0 }, { Name | IN, 1 }, { Accessmode, 2 }, 218 { Atflags, 3 } } }, 219 { .name = "fchflags", .ret_type = 1, .nargs = 2, 220 .args = { { Int, 0 }, { FileFlags, 1 } } }, 221 { .name = "fchmod", .ret_type = 1, .nargs = 2, 222 .args = { { Int, 0 }, { Octal, 1 } } }, 223 { .name = "fchmodat", .ret_type = 1, .nargs = 4, 224 .args = { { Atfd, 0 }, { Name, 1 }, { Octal, 2 }, { Atflags, 3 } } }, 225 { .name = "fchown", .ret_type = 1, .nargs = 3, 226 .args = { { Int, 0 }, { Int, 1 }, { Int, 2 } } }, 227 { .name = "fchownat", .ret_type = 1, .nargs = 5, 228 .args = { { Atfd, 0 }, { Name, 1 }, { Int, 2 }, { Int, 3 }, 229 { Atflags, 4 } } }, 230 { .name = "fcntl", .ret_type = 1, .nargs = 3, 231 .args = { { Int, 0 }, { Fcntl, 1 }, { Fcntlflag, 2 } } }, 232 { .name = "flock", .ret_type = 1, .nargs = 2, 233 .args = { { Int, 0 }, { Flockop, 1 } } }, 234 { .name = "fstat", .ret_type = 1, .nargs = 2, 235 .args = { { Int, 0 }, { Stat | OUT, 1 } } }, 236 { .name = "fstatat", .ret_type = 1, .nargs = 4, 237 .args = { { Atfd, 0 }, { Name | IN, 1 }, { Stat | OUT, 2 }, 238 { Atflags, 3 } } }, 239 { .name = "fstatfs", .ret_type = 1, .nargs = 2, 240 .args = { { Int, 0 }, { StatFs | OUT, 1 } } }, 241 { .name = "ftruncate", .ret_type = 1, .nargs = 2, 242 .args = { { Int | IN, 0 }, { QuadHex | IN, 1 } } }, 243 { .name = "futimens", .ret_type = 1, .nargs = 2, 244 .args = { { Int, 0 }, { Timespec2 | IN, 1 } } }, 245 { .name = "futimes", .ret_type = 1, .nargs = 2, 246 .args = { { Int, 0 }, { Timeval2 | IN, 1 } } }, 247 { .name = "futimesat", .ret_type = 1, .nargs = 3, 248 .args = { { Atfd, 0 }, { Name | IN, 1 }, { Timeval2 | IN, 2 } } }, 249 { .name = "getdirentries", .ret_type = 1, .nargs = 4, 250 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Int, 2 }, 251 { PQuadHex | OUT, 3 } } }, 252 { .name = "getfsstat", .ret_type = 1, .nargs = 3, 253 .args = { { Ptr, 0 }, { Long, 1 }, { Getfsstatmode, 2 } } }, 254 { .name = "getitimer", .ret_type = 1, .nargs = 2, 255 .args = { { Int, 0 }, { Itimerval | OUT, 2 } } }, 256 { .name = "getpeername", .ret_type = 1, .nargs = 3, 257 .args = { { Int, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } }, 258 { .name = "getpgid", .ret_type = 1, .nargs = 1, 259 .args = { { Int, 0 } } }, 260 { .name = "getpriority", .ret_type = 1, .nargs = 2, 261 .args = { { Priowhich, 0 }, { Int, 1 } } }, 262 { .name = "getrandom", .ret_type = 1, .nargs = 3, 263 .args = { { BinString | OUT, 0 }, { Sizet, 1 }, { UInt, 2 } } }, 264 { .name = "getrlimit", .ret_type = 1, .nargs = 2, 265 .args = { { Resource, 0 }, { Rlimit | OUT, 1 } } }, 266 { .name = "getrusage", .ret_type = 1, .nargs = 2, 267 .args = { { RusageWho, 0 }, { Rusage | OUT, 1 } } }, 268 { .name = "getsid", .ret_type = 1, .nargs = 1, 269 .args = { { Int, 0 } } }, 270 { .name = "getsockname", .ret_type = 1, .nargs = 3, 271 .args = { { Int, 0 }, { Sockaddr | OUT, 1 }, { Ptr | OUT, 2 } } }, 272 { .name = "getsockopt", .ret_type = 1, .nargs = 5, 273 .args = { { Int, 0 }, { Sockoptlevel, 1 }, { Sockoptname, 2 }, 274 { Ptr | OUT, 3 }, { Ptr | OUT, 4 } } }, 275 { .name = "gettimeofday", .ret_type = 1, .nargs = 2, 276 .args = { { Timeval | OUT, 0 }, { Ptr, 1 } } }, 277 { .name = "ioctl", .ret_type = 1, .nargs = 3, 278 .args = { { Int, 0 }, { Ioctl, 1 }, { Ptr, 2 } } }, 279 { .name = "kevent", .ret_type = 1, .nargs = 6, 280 .args = { { Int, 0 }, { Kevent, 1 }, { Int, 2 }, { Kevent | OUT, 3 }, 281 { Int, 4 }, { Timespec, 5 } } }, 282 { .name = "kill", .ret_type = 1, .nargs = 2, 283 .args = { { Int | IN, 0 }, { Signal | IN, 1 } } }, 284 { .name = "kldfind", .ret_type = 1, .nargs = 1, 285 .args = { { Name | IN, 0 } } }, 286 { .name = "kldfirstmod", .ret_type = 1, .nargs = 1, 287 .args = { { Int, 0 } } }, 288 { .name = "kldload", .ret_type = 1, .nargs = 1, 289 .args = { { Name | IN, 0 } } }, 290 { .name = "kldnext", .ret_type = 1, .nargs = 1, 291 .args = { { Int, 0 } } }, 292 { .name = "kldstat", .ret_type = 1, .nargs = 2, 293 .args = { { Int, 0 }, { Ptr, 1 } } }, 294 { .name = "kldsym", .ret_type = 1, .nargs = 3, 295 .args = { { Int, 0 }, { Kldsymcmd, 1 }, { Ptr, 2 } } }, 296 { .name = "kldunload", .ret_type = 1, .nargs = 1, 297 .args = { { Int, 0 } } }, 298 { .name = "kldunloadf", .ret_type = 1, .nargs = 2, 299 .args = { { Int, 0 }, { Kldunloadflags, 1 } } }, 300 { .name = "kse_release", .ret_type = 0, .nargs = 1, 301 .args = { { Timespec, 0 } } }, 302 { .name = "lchflags", .ret_type = 1, .nargs = 2, 303 .args = { { Name | IN, 0 }, { FileFlags, 1 } } }, 304 { .name = "lchmod", .ret_type = 1, .nargs = 2, 305 .args = { { Name, 0 }, { Octal, 1 } } }, 306 { .name = "lchown", .ret_type = 1, .nargs = 3, 307 .args = { { Name, 0 }, { Int, 1 }, { Int, 2 } } }, 308 { .name = "link", .ret_type = 1, .nargs = 2, 309 .args = { { Name, 0 }, { Name, 1 } } }, 310 { .name = "linkat", .ret_type = 1, .nargs = 5, 311 .args = { { Atfd, 0 }, { Name, 1 }, { Atfd, 2 }, { Name, 3 }, 312 { Atflags, 4 } } }, 313 { .name = "listen", .ret_type = 1, .nargs = 2, 314 .args = { { Int, 0 }, { Int, 1 } } }, 315 { .name = "lseek", .ret_type = 2, .nargs = 3, 316 .args = { { Int, 0 }, { QuadHex, 1 }, { Whence, 2 } } }, 317 { .name = "lstat", .ret_type = 1, .nargs = 2, 318 .args = { { Name | IN, 0 }, { Stat | OUT, 1 } } }, 319 { .name = "lutimes", .ret_type = 1, .nargs = 2, 320 .args = { { Name | IN, 0 }, { Timeval2 | IN, 1 } } }, 321 { .name = "madvise", .ret_type = 1, .nargs = 3, 322 .args = { { Ptr, 0 }, { Sizet, 1 }, { Madvice, 2 } } }, 323 { .name = "minherit", .ret_type = 1, .nargs = 3, 324 .args = { { Ptr, 0 }, { Sizet, 1 }, { Minherit, 2 } } }, 325 { .name = "mkdir", .ret_type = 1, .nargs = 2, 326 .args = { { Name, 0 }, { Octal, 1 } } }, 327 { .name = "mkdirat", .ret_type = 1, .nargs = 3, 328 .args = { { Atfd, 0 }, { Name, 1 }, { Octal, 2 } } }, 329 { .name = "mkfifo", .ret_type = 1, .nargs = 2, 330 .args = { { Name, 0 }, { Octal, 1 } } }, 331 { .name = "mkfifoat", .ret_type = 1, .nargs = 3, 332 .args = { { Atfd, 0 }, { Name, 1 }, { Octal, 2 } } }, 333 { .name = "mknod", .ret_type = 1, .nargs = 3, 334 .args = { { Name, 0 }, { Octal, 1 }, { Int, 2 } } }, 335 { .name = "mknodat", .ret_type = 1, .nargs = 4, 336 .args = { { Atfd, 0 }, { Name, 1 }, { Octal, 2 }, { Int, 3 } } }, 337 { .name = "mlock", .ret_type = 1, .nargs = 2, 338 .args = { { Ptr, 0 }, { Sizet, 1 } } }, 339 { .name = "mlockall", .ret_type = 1, .nargs = 1, 340 .args = { { Mlockall, 0 } } }, 341 { .name = "mmap", .ret_type = 1, .nargs = 6, 342 .args = { { Ptr, 0 }, { Sizet, 1 }, { Mprot, 2 }, { Mmapflags, 3 }, 343 { Int, 4 }, { QuadHex, 5 } } }, 344 { .name = "modfind", .ret_type = 1, .nargs = 1, 345 .args = { { Name | IN, 0 } } }, 346 { .name = "mount", .ret_type = 1, .nargs = 4, 347 .args = { { Name, 0 }, { Name, 1 }, { Mountflags, 2 }, { Ptr, 3 } } }, 348 { .name = "mprotect", .ret_type = 1, .nargs = 3, 349 .args = { { Ptr, 0 }, { Sizet, 1 }, { Mprot, 2 } } }, 350 { .name = "msync", .ret_type = 1, .nargs = 3, 351 .args = { { Ptr, 0 }, { Sizet, 1 }, { Msync, 2 } } }, 352 { .name = "munlock", .ret_type = 1, .nargs = 2, 353 .args = { { Ptr, 0 }, { Sizet, 1 } } }, 354 { .name = "munmap", .ret_type = 1, .nargs = 2, 355 .args = { { Ptr, 0 }, { Sizet, 1 } } }, 356 { .name = "nanosleep", .ret_type = 1, .nargs = 1, 357 .args = { { Timespec, 0 } } }, 358 { .name = "nmount", .ret_type = 1, .nargs = 3, 359 .args = { { Ptr, 0 }, { UInt, 1 }, { Mountflags, 2 } } }, 360 { .name = "open", .ret_type = 1, .nargs = 3, 361 .args = { { Name | IN, 0 }, { Open, 1 }, { Octal, 2 } } }, 362 { .name = "openat", .ret_type = 1, .nargs = 4, 363 .args = { { Atfd, 0 }, { Name | IN, 1 }, { Open, 2 }, 364 { Octal, 3 } } }, 365 { .name = "pathconf", .ret_type = 1, .nargs = 2, 366 .args = { { Name | IN, 0 }, { Pathconf, 1 } } }, 367 { .name = "pipe", .ret_type = 1, .nargs = 1, 368 .args = { { PipeFds | OUT, 0 } } }, 369 { .name = "pipe2", .ret_type = 1, .nargs = 2, 370 .args = { { Ptr, 0 }, { Pipe2, 1 } } }, 371 { .name = "poll", .ret_type = 1, .nargs = 3, 372 .args = { { Pollfd, 0 }, { Int, 1 }, { Int, 2 } } }, 373 { .name = "posix_fadvise", .ret_type = 1, .nargs = 4, 374 .args = { { Int, 0 }, { QuadHex, 1 }, { QuadHex, 2 }, 375 { Fadvice, 3 } } }, 376 { .name = "posix_openpt", .ret_type = 1, .nargs = 1, 377 .args = { { Open, 0 } } }, 378 { .name = "pread", .ret_type = 1, .nargs = 4, 379 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Sizet, 2 }, 380 { QuadHex, 3 } } }, 381 { .name = "procctl", .ret_type = 1, .nargs = 4, 382 .args = { { Idtype, 0 }, { Quad, 1 }, { Procctl, 2 }, { Ptr, 3 } } }, 383 { .name = "ptrace", .ret_type = 1, .nargs = 4, 384 .args = { { Ptraceop, 0 }, { Int, 1 }, { Ptr, 2 }, { Int, 3 } } }, 385 { .name = "pwrite", .ret_type = 1, .nargs = 4, 386 .args = { { Int, 0 }, { BinString | IN, 1 }, { Sizet, 2 }, 387 { QuadHex, 3 } } }, 388 { .name = "quotactl", .ret_type = 1, .nargs = 4, 389 .args = { { Name, 0 }, { Quotactlcmd, 1 }, { Int, 2 }, { Ptr, 3 } } }, 390 { .name = "read", .ret_type = 1, .nargs = 3, 391 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Sizet, 2 } } }, 392 { .name = "readlink", .ret_type = 1, .nargs = 3, 393 .args = { { Name, 0 }, { Readlinkres | OUT, 1 }, { Sizet, 2 } } }, 394 { .name = "readlinkat", .ret_type = 1, .nargs = 4, 395 .args = { { Atfd, 0 }, { Name, 1 }, { Readlinkres | OUT, 2 }, 396 { Sizet, 3 } } }, 397 { .name = "readv", .ret_type = 1, .nargs = 3, 398 .args = { { Int, 0 }, { Iovec | OUT, 1 }, { Int, 2 } } }, 399 { .name = "reboot", .ret_type = 1, .nargs = 1, 400 .args = { { Reboothowto, 0 } } }, 401 { .name = "recvfrom", .ret_type = 1, .nargs = 6, 402 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Sizet, 2 }, 403 { Msgflags, 3 }, { Sockaddr | OUT, 4 }, 404 { Ptr | OUT, 5 } } }, 405 { .name = "recvmsg", .ret_type = 1, .nargs = 3, 406 .args = { { Int, 0 }, { Msghdr | OUT, 1 }, { Msgflags, 2 } } }, 407 { .name = "rename", .ret_type = 1, .nargs = 2, 408 .args = { { Name, 0 }, { Name, 1 } } }, 409 { .name = "renameat", .ret_type = 1, .nargs = 4, 410 .args = { { Atfd, 0 }, { Name, 1 }, { Atfd, 2 }, { Name, 3 } } }, 411 { .name = "rfork", .ret_type = 1, .nargs = 1, 412 .args = { { Rforkflags, 0 } } }, 413 { .name = "rmdir", .ret_type = 1, .nargs = 1, 414 .args = { { Name, 0 } } }, 415 { .name = "rtprio", .ret_type = 1, .nargs = 3, 416 .args = { { Rtpriofunc, 0 }, { Int, 1 }, { Ptr, 2 } } }, 417 { .name = "rtprio_thread", .ret_type = 1, .nargs = 3, 418 .args = { { Rtpriofunc, 0 }, { Int, 1 }, { Ptr, 2 } } }, 419 { .name = "sched_get_priority_max", .ret_type = 1, .nargs = 1, 420 .args = { { Schedpolicy, 0 } } }, 421 { .name = "sched_get_priority_min", .ret_type = 1, .nargs = 1, 422 .args = { { Schedpolicy, 0 } } }, 423 { .name = "sched_getparam", .ret_type = 1, .nargs = 2, 424 .args = { { Int, 0 }, { Schedparam | OUT, 1 } } }, 425 { .name = "sched_getscheduler", .ret_type = 1, .nargs = 1, 426 .args = { { Int, 0 } } }, 427 { .name = "sched_rr_get_interval", .ret_type = 1, .nargs = 2, 428 .args = { { Int, 0 }, { Timespec | OUT, 1 } } }, 429 { .name = "sched_setparam", .ret_type = 1, .nargs = 2, 430 .args = { { Int, 0 }, { Schedparam, 1 } } }, 431 { .name = "sched_setscheduler", .ret_type = 1, .nargs = 3, 432 .args = { { Int, 0 }, { Schedpolicy, 1 }, { Schedparam, 2 } } }, 433 { .name = "sctp_generic_recvmsg", .ret_type = 1, .nargs = 7, 434 .args = { { Int, 0 }, { Iovec | OUT, 1 }, { Int, 2 }, 435 { Sockaddr | OUT, 3 }, { Ptr | OUT, 4 }, 436 { Sctpsndrcvinfo | OUT, 5 }, { Ptr | OUT, 6 } } }, 437 { .name = "sctp_generic_sendmsg", .ret_type = 1, .nargs = 7, 438 .args = { { Int, 0 }, { BinString | IN, 1 }, { Int, 2 }, 439 { Sockaddr | IN, 3 }, { Socklent, 4 }, 440 { Sctpsndrcvinfo | IN, 5 }, { Msgflags, 6 } } }, 441 { .name = "sctp_generic_sendmsg_iov", .ret_type = 1, .nargs = 7, 442 .args = { { Int, 0 }, { Iovec | IN, 1 }, { Int, 2 }, 443 { Sockaddr | IN, 3 }, { Socklent, 4 }, 444 { Sctpsndrcvinfo | IN, 5 }, { Msgflags, 6 } } }, 445 { .name = "select", .ret_type = 1, .nargs = 5, 446 .args = { { Int, 0 }, { Fd_set, 1 }, { Fd_set, 2 }, { Fd_set, 3 }, 447 { Timeval, 4 } } }, 448 { .name = "sendmsg", .ret_type = 1, .nargs = 3, 449 .args = { { Int, 0 }, { Msghdr | IN, 1 }, { Msgflags, 2 } } }, 450 { .name = "sendto", .ret_type = 1, .nargs = 6, 451 .args = { { Int, 0 }, { BinString | IN, 1 }, { Sizet, 2 }, 452 { Msgflags, 3 }, { Sockaddr | IN, 4 }, 453 { Socklent | IN, 5 } } }, 454 { .name = "setitimer", .ret_type = 1, .nargs = 3, 455 .args = { { Int, 0 }, { Itimerval, 1 }, { Itimerval | OUT, 2 } } }, 456 { .name = "setpriority", .ret_type = 1, .nargs = 3, 457 .args = { { Priowhich, 0 }, { Int, 1 }, { Int, 2 } } }, 458 { .name = "setrlimit", .ret_type = 1, .nargs = 2, 459 .args = { { Resource, 0 }, { Rlimit | IN, 1 } } }, 460 { .name = "setsockopt", .ret_type = 1, .nargs = 5, 461 .args = { { Int, 0 }, { Sockoptlevel, 1 }, { Sockoptname, 2 }, 462 { Ptr | IN, 3 }, { Socklent, 4 } } }, 463 { .name = "shutdown", .ret_type = 1, .nargs = 2, 464 .args = { { Int, 0 }, { Shutdown, 1 } } }, 465 { .name = "sigaction", .ret_type = 1, .nargs = 3, 466 .args = { { Signal, 0 }, { Sigaction | IN, 1 }, 467 { Sigaction | OUT, 2 } } }, 468 { .name = "sigpending", .ret_type = 1, .nargs = 1, 469 .args = { { Sigset | OUT, 0 } } }, 470 { .name = "sigprocmask", .ret_type = 1, .nargs = 3, 471 .args = { { Sigprocmask, 0 }, { Sigset, 1 }, { Sigset | OUT, 2 } } }, 472 { .name = "sigqueue", .ret_type = 1, .nargs = 3, 473 .args = { { Int, 0 }, { Signal, 1 }, { LongHex, 2 } } }, 474 { .name = "sigreturn", .ret_type = 1, .nargs = 1, 475 .args = { { Ptr, 0 } } }, 476 { .name = "sigsuspend", .ret_type = 1, .nargs = 1, 477 .args = { { Sigset | IN, 0 } } }, 478 { .name = "sigtimedwait", .ret_type = 1, .nargs = 3, 479 .args = { { Sigset | IN, 0 }, { Siginfo | OUT, 1 }, 480 { Timespec | IN, 2 } } }, 481 { .name = "sigwait", .ret_type = 1, .nargs = 2, 482 .args = { { Sigset | IN, 0 }, { PSig | OUT, 1 } } }, 483 { .name = "sigwaitinfo", .ret_type = 1, .nargs = 2, 484 .args = { { Sigset | IN, 0 }, { Siginfo | OUT, 1 } } }, 485 { .name = "socket", .ret_type = 1, .nargs = 3, 486 .args = { { Sockdomain, 0 }, { Socktype, 1 }, { Sockprotocol, 2 } } }, 487 { .name = "stat", .ret_type = 1, .nargs = 2, 488 .args = { { Name | IN, 0 }, { Stat | OUT, 1 } } }, 489 { .name = "statfs", .ret_type = 1, .nargs = 2, 490 .args = { { Name | IN, 0 }, { StatFs | OUT, 1 } } }, 491 { .name = "symlink", .ret_type = 1, .nargs = 2, 492 .args = { { Name, 0 }, { Name, 1 } } }, 493 { .name = "symlinkat", .ret_type = 1, .nargs = 3, 494 .args = { { Name, 0 }, { Atfd, 1 }, { Name, 2 } } }, 495 { .name = "sysarch", .ret_type = 1, .nargs = 2, 496 .args = { { Sysarch, 0 }, { Ptr, 1 } } }, 497 { .name = "thr_kill", .ret_type = 1, .nargs = 2, 498 .args = { { Long, 0 }, { Signal, 1 } } }, 499 { .name = "thr_self", .ret_type = 1, .nargs = 1, 500 .args = { { Ptr, 0 } } }, 501 { .name = "thr_set_name", .ret_type = 1, .nargs = 2, 502 .args = { { Long, 0 }, { Name, 1 } } }, 503 { .name = "truncate", .ret_type = 1, .nargs = 2, 504 .args = { { Name | IN, 0 }, { QuadHex | IN, 1 } } }, 505 #if 0 506 /* Does not exist */ 507 { .name = "umount", .ret_type = 1, .nargs = 2, 508 .args = { { Name, 0 }, { Int, 2 } } }, 509 #endif 510 { .name = "unlink", .ret_type = 1, .nargs = 1, 511 .args = { { Name, 0 } } }, 512 { .name = "unlinkat", .ret_type = 1, .nargs = 3, 513 .args = { { Atfd, 0 }, { Name, 1 }, { Atflags, 2 } } }, 514 { .name = "unmount", .ret_type = 1, .nargs = 2, 515 .args = { { Name, 0 }, { Mountflags, 1 } } }, 516 { .name = "utimensat", .ret_type = 1, .nargs = 4, 517 .args = { { Atfd, 0 }, { Name | IN, 1 }, { Timespec2 | IN, 2 }, 518 { Atflags, 3 } } }, 519 { .name = "utimes", .ret_type = 1, .nargs = 2, 520 .args = { { Name | IN, 0 }, { Timeval2 | IN, 1 } } }, 521 { .name = "utrace", .ret_type = 1, .nargs = 1, 522 .args = { { Utrace, 0 } } }, 523 { .name = "wait4", .ret_type = 1, .nargs = 4, 524 .args = { { Int, 0 }, { ExitStatus | OUT, 1 }, { Waitoptions, 2 }, 525 { Rusage | OUT, 3 } } }, 526 { .name = "wait6", .ret_type = 1, .nargs = 6, 527 .args = { { Idtype, 0 }, { Quad, 1 }, { ExitStatus | OUT, 2 }, 528 { Waitoptions, 3 }, { Rusage | OUT, 4 }, 529 { Siginfo | OUT, 5 } } }, 530 { .name = "write", .ret_type = 1, .nargs = 3, 531 .args = { { Int, 0 }, { BinString | IN, 1 }, { Sizet, 2 } } }, 532 { .name = "writev", .ret_type = 1, .nargs = 3, 533 .args = { { Int, 0 }, { Iovec | IN, 1 }, { Int, 2 } } }, 534 535 /* Linux ABI */ 536 { .name = "linux_access", .ret_type = 1, .nargs = 2, 537 .args = { { Name, 0 }, { Accessmode, 1 } } }, 538 { .name = "linux_execve", .ret_type = 1, .nargs = 3, 539 .args = { { Name | IN, 0 }, { ExecArgs | IN, 1 }, 540 { ExecEnv | IN, 2 } } }, 541 { .name = "linux_lseek", .ret_type = 2, .nargs = 3, 542 .args = { { Int, 0 }, { Int, 1 }, { Whence, 2 } } }, 543 { .name = "linux_mkdir", .ret_type = 1, .nargs = 2, 544 .args = { { Name | IN, 0 }, { Int, 1 } } }, 545 { .name = "linux_newfstat", .ret_type = 1, .nargs = 2, 546 .args = { { Int, 0 }, { Ptr | OUT, 1 } } }, 547 { .name = "linux_newstat", .ret_type = 1, .nargs = 2, 548 .args = { { Name | IN, 0 }, { Ptr | OUT, 1 } } }, 549 { .name = "linux_open", .ret_type = 1, .nargs = 3, 550 .args = { { Name, 0 }, { Hex, 1 }, { Octal, 2 } } }, 551 { .name = "linux_readlink", .ret_type = 1, .nargs = 3, 552 .args = { { Name, 0 }, { Name | OUT, 1 }, { Sizet, 2 } } }, 553 { .name = "linux_socketcall", .ret_type = 1, .nargs = 2, 554 .args = { { Int, 0 }, { LinuxSockArgs, 1 } } }, 555 { .name = "linux_stat64", .ret_type = 1, .nargs = 2, 556 .args = { { Name | IN, 0 }, { Ptr | OUT, 1 } } }, 557 558 /* CloudABI system calls. */ 559 { .name = "cloudabi_sys_clock_res_get", .ret_type = 1, .nargs = 1, 560 .args = { { CloudABIClockID, 0 } } }, 561 { .name = "cloudabi_sys_clock_time_get", .ret_type = 1, .nargs = 2, 562 .args = { { CloudABIClockID, 0 }, { CloudABITimestamp, 1 } } }, 563 { .name = "cloudabi_sys_condvar_signal", .ret_type = 1, .nargs = 3, 564 .args = { { Ptr, 0 }, { CloudABIMFlags, 1 }, { UInt, 2 } } }, 565 { .name = "cloudabi_sys_fd_close", .ret_type = 1, .nargs = 1, 566 .args = { { Int, 0 } } }, 567 { .name = "cloudabi_sys_fd_create1", .ret_type = 1, .nargs = 1, 568 .args = { { CloudABIFileType, 0 } } }, 569 { .name = "cloudabi_sys_fd_create2", .ret_type = 1, .nargs = 2, 570 .args = { { CloudABIFileType, 0 }, { PipeFds | OUT, 0 } } }, 571 { .name = "cloudabi_sys_fd_datasync", .ret_type = 1, .nargs = 1, 572 .args = { { Int, 0 } } }, 573 { .name = "cloudabi_sys_fd_dup", .ret_type = 1, .nargs = 1, 574 .args = { { Int, 0 } } }, 575 { .name = "cloudabi_sys_fd_replace", .ret_type = 1, .nargs = 2, 576 .args = { { Int, 0 }, { Int, 1 } } }, 577 { .name = "cloudabi_sys_fd_seek", .ret_type = 1, .nargs = 3, 578 .args = { { Int, 0 }, { Int, 1 }, { CloudABIWhence, 2 } } }, 579 { .name = "cloudabi_sys_fd_stat_get", .ret_type = 1, .nargs = 2, 580 .args = { { Int, 0 }, { CloudABIFDStat | OUT, 1 } } }, 581 { .name = "cloudabi_sys_fd_stat_put", .ret_type = 1, .nargs = 3, 582 .args = { { Int, 0 }, { CloudABIFDStat | IN, 1 }, 583 { CloudABIFDSFlags, 2 } } }, 584 { .name = "cloudabi_sys_fd_sync", .ret_type = 1, .nargs = 1, 585 .args = { { Int, 0 } } }, 586 { .name = "cloudabi_sys_file_advise", .ret_type = 1, .nargs = 4, 587 .args = { { Int, 0 }, { Int, 1 }, { Int, 2 }, 588 { CloudABIAdvice, 3 } } }, 589 { .name = "cloudabi_sys_file_allocate", .ret_type = 1, .nargs = 3, 590 .args = { { Int, 0 }, { Int, 1 }, { Int, 2 } } }, 591 { .name = "cloudabi_sys_file_create", .ret_type = 1, .nargs = 3, 592 .args = { { Int, 0 }, { BinString | IN, 1 }, 593 { CloudABIFileType, 3 } } }, 594 { .name = "cloudabi_sys_file_link", .ret_type = 1, .nargs = 4, 595 .args = { { CloudABILookup, 0 }, { BinString | IN, 1 }, 596 { Int, 3 }, { BinString | IN, 4 } } }, 597 { .name = "cloudabi_sys_file_open", .ret_type = 1, .nargs = 4, 598 .args = { { Int, 0 }, { BinString | IN, 1 }, 599 { CloudABIOFlags, 3 }, { CloudABIFDStat | IN, 4 } } }, 600 { .name = "cloudabi_sys_file_readdir", .ret_type = 1, .nargs = 4, 601 .args = { { Int, 0 }, { BinString | OUT, 1 }, { Int, 2 }, 602 { Int, 3 } } }, 603 { .name = "cloudabi_sys_file_readlink", .ret_type = 1, .nargs = 4, 604 .args = { { Int, 0 }, { BinString | IN, 1 }, 605 { BinString | OUT, 3 }, { Int, 4 } } }, 606 { .name = "cloudabi_sys_file_rename", .ret_type = 1, .nargs = 4, 607 .args = { { Int, 0 }, { BinString | IN, 1 }, 608 { Int, 3 }, { BinString | IN, 4 } } }, 609 { .name = "cloudabi_sys_file_stat_fget", .ret_type = 1, .nargs = 2, 610 .args = { { Int, 0 }, { CloudABIFileStat | OUT, 1 } } }, 611 { .name = "cloudabi_sys_file_stat_fput", .ret_type = 1, .nargs = 3, 612 .args = { { Int, 0 }, { CloudABIFileStat | IN, 1 }, 613 { CloudABIFSFlags, 2 } } }, 614 { .name = "cloudabi_sys_file_stat_get", .ret_type = 1, .nargs = 3, 615 .args = { { CloudABILookup, 0 }, { BinString | IN, 1 }, 616 { CloudABIFileStat | OUT, 3 } } }, 617 { .name = "cloudabi_sys_file_stat_put", .ret_type = 1, .nargs = 4, 618 .args = { { CloudABILookup, 0 }, { BinString | IN, 1 }, 619 { CloudABIFileStat | IN, 3 }, { CloudABIFSFlags, 4 } } }, 620 { .name = "cloudabi_sys_file_symlink", .ret_type = 1, .nargs = 3, 621 .args = { { BinString | IN, 0 }, 622 { Int, 2 }, { BinString | IN, 3 } } }, 623 { .name = "cloudabi_sys_file_unlink", .ret_type = 1, .nargs = 3, 624 .args = { { Int, 0 }, { BinString | IN, 1 }, 625 { CloudABIULFlags, 3 } } }, 626 { .name = "cloudabi_sys_lock_unlock", .ret_type = 1, .nargs = 2, 627 .args = { { Ptr, 0 }, { CloudABIMFlags, 1 } } }, 628 { .name = "cloudabi_sys_mem_advise", .ret_type = 1, .nargs = 3, 629 .args = { { Ptr, 0 }, { Int, 1 }, { CloudABIAdvice, 2 } } }, 630 { .name = "cloudabi_sys_mem_map", .ret_type = 1, .nargs = 6, 631 .args = { { Ptr, 0 }, { Int, 1 }, { CloudABIMProt, 2 }, 632 { CloudABIMFlags, 3 }, { Int, 4 }, { Int, 5 } } }, 633 { .name = "cloudabi_sys_mem_protect", .ret_type = 1, .nargs = 3, 634 .args = { { Ptr, 0 }, { Int, 1 }, { CloudABIMProt, 2 } } }, 635 { .name = "cloudabi_sys_mem_sync", .ret_type = 1, .nargs = 3, 636 .args = { { Ptr, 0 }, { Int, 1 }, { CloudABIMSFlags, 2 } } }, 637 { .name = "cloudabi_sys_mem_unmap", .ret_type = 1, .nargs = 2, 638 .args = { { Ptr, 0 }, { Int, 1 } } }, 639 { .name = "cloudabi_sys_proc_exec", .ret_type = 1, .nargs = 5, 640 .args = { { Int, 0 }, { BinString | IN, 1 }, { Int, 2 }, 641 { IntArray, 3 }, { Int, 4 } } }, 642 { .name = "cloudabi_sys_proc_exit", .ret_type = 1, .nargs = 1, 643 .args = { { Int, 0 } } }, 644 { .name = "cloudabi_sys_proc_fork", .ret_type = 1, .nargs = 0 }, 645 { .name = "cloudabi_sys_proc_raise", .ret_type = 1, .nargs = 1, 646 .args = { { CloudABISignal, 0 } } }, 647 { .name = "cloudabi_sys_random_get", .ret_type = 1, .nargs = 2, 648 .args = { { BinString | OUT, 0 }, { Int, 1 } } }, 649 { .name = "cloudabi_sys_sock_shutdown", .ret_type = 1, .nargs = 2, 650 .args = { { Int, 0 }, { CloudABISDFlags, 1 } } }, 651 { .name = "cloudabi_sys_thread_exit", .ret_type = 1, .nargs = 2, 652 .args = { { Ptr, 0 }, { CloudABIMFlags, 1 } } }, 653 { .name = "cloudabi_sys_thread_yield", .ret_type = 1, .nargs = 0 }, 654 655 { .name = 0 }, 656 }; 657 static STAILQ_HEAD(, syscall) syscalls; 658 659 /* Xlat idea taken from strace */ 660 struct xlat { 661 int val; 662 const char *str; 663 }; 664 665 #define X(a) { a, #a }, 666 #define XEND { 0, NULL } 667 668 static struct xlat poll_flags[] = { 669 X(POLLSTANDARD) X(POLLIN) X(POLLPRI) X(POLLOUT) X(POLLERR) 670 X(POLLHUP) X(POLLNVAL) X(POLLRDNORM) X(POLLRDBAND) 671 X(POLLWRBAND) X(POLLINIGNEOF) XEND 672 }; 673 674 static struct xlat sigaction_flags[] = { 675 X(SA_ONSTACK) X(SA_RESTART) X(SA_RESETHAND) X(SA_NOCLDSTOP) 676 X(SA_NODEFER) X(SA_NOCLDWAIT) X(SA_SIGINFO) XEND 677 }; 678 679 static struct xlat linux_socketcall_ops[] = { 680 X(LINUX_SOCKET) X(LINUX_BIND) X(LINUX_CONNECT) X(LINUX_LISTEN) 681 X(LINUX_ACCEPT) X(LINUX_GETSOCKNAME) X(LINUX_GETPEERNAME) 682 X(LINUX_SOCKETPAIR) X(LINUX_SEND) X(LINUX_RECV) X(LINUX_SENDTO) 683 X(LINUX_RECVFROM) X(LINUX_SHUTDOWN) X(LINUX_SETSOCKOPT) 684 X(LINUX_GETSOCKOPT) X(LINUX_SENDMSG) X(LINUX_RECVMSG) 685 XEND 686 }; 687 688 #undef X 689 #define X(a) { CLOUDABI_##a, #a }, 690 691 static struct xlat cloudabi_advice[] = { 692 X(ADVICE_DONTNEED) X(ADVICE_NOREUSE) X(ADVICE_NORMAL) 693 X(ADVICE_RANDOM) X(ADVICE_SEQUENTIAL) X(ADVICE_WILLNEED) 694 XEND 695 }; 696 697 static struct xlat cloudabi_clockid[] = { 698 X(CLOCK_MONOTONIC) X(CLOCK_PROCESS_CPUTIME_ID) 699 X(CLOCK_REALTIME) X(CLOCK_THREAD_CPUTIME_ID) 700 XEND 701 }; 702 703 static struct xlat cloudabi_fdflags[] = { 704 X(FDFLAG_APPEND) X(FDFLAG_DSYNC) X(FDFLAG_NONBLOCK) 705 X(FDFLAG_RSYNC) X(FDFLAG_SYNC) 706 XEND 707 }; 708 709 static struct xlat cloudabi_fdsflags[] = { 710 X(FDSTAT_FLAGS) X(FDSTAT_RIGHTS) 711 XEND 712 }; 713 714 static struct xlat cloudabi_filetype[] = { 715 X(FILETYPE_UNKNOWN) X(FILETYPE_BLOCK_DEVICE) 716 X(FILETYPE_CHARACTER_DEVICE) X(FILETYPE_DIRECTORY) 717 X(FILETYPE_PROCESS) X(FILETYPE_REGULAR_FILE) 718 X(FILETYPE_SHARED_MEMORY) X(FILETYPE_SOCKET_DGRAM) 719 X(FILETYPE_SOCKET_STREAM) X(FILETYPE_SYMBOLIC_LINK) 720 XEND 721 }; 722 723 static struct xlat cloudabi_fsflags[] = { 724 X(FILESTAT_ATIM) X(FILESTAT_ATIM_NOW) X(FILESTAT_MTIM) 725 X(FILESTAT_MTIM_NOW) X(FILESTAT_SIZE) 726 XEND 727 }; 728 729 static struct xlat cloudabi_mflags[] = { 730 X(MAP_ANON) X(MAP_FIXED) X(MAP_PRIVATE) X(MAP_SHARED) 731 XEND 732 }; 733 734 static struct xlat cloudabi_mprot[] = { 735 X(PROT_EXEC) X(PROT_WRITE) X(PROT_READ) 736 XEND 737 }; 738 739 static struct xlat cloudabi_msflags[] = { 740 X(MS_ASYNC) X(MS_INVALIDATE) X(MS_SYNC) 741 XEND 742 }; 743 744 static struct xlat cloudabi_oflags[] = { 745 X(O_CREAT) X(O_DIRECTORY) X(O_EXCL) X(O_TRUNC) 746 XEND 747 }; 748 749 static struct xlat cloudabi_sdflags[] = { 750 X(SHUT_RD) X(SHUT_WR) 751 XEND 752 }; 753 754 static struct xlat cloudabi_signal[] = { 755 X(SIGABRT) X(SIGALRM) X(SIGBUS) X(SIGCHLD) X(SIGCONT) X(SIGFPE) 756 X(SIGHUP) X(SIGILL) X(SIGINT) X(SIGKILL) X(SIGPIPE) X(SIGQUIT) 757 X(SIGSEGV) X(SIGSTOP) X(SIGSYS) X(SIGTERM) X(SIGTRAP) X(SIGTSTP) 758 X(SIGTTIN) X(SIGTTOU) X(SIGURG) X(SIGUSR1) X(SIGUSR2) 759 X(SIGVTALRM) X(SIGXCPU) X(SIGXFSZ) 760 XEND 761 }; 762 763 static struct xlat cloudabi_ulflags[] = { 764 X(UNLINK_REMOVEDIR) 765 XEND 766 }; 767 768 static struct xlat cloudabi_whence[] = { 769 X(WHENCE_CUR) X(WHENCE_END) X(WHENCE_SET) 770 XEND 771 }; 772 773 #undef X 774 #undef XEND 775 776 /* 777 * Searches an xlat array for a value, and returns it if found. Otherwise 778 * return a string representation. 779 */ 780 static const char * 781 lookup(struct xlat *xlat, int val, int base) 782 { 783 static char tmp[16]; 784 785 for (; xlat->str != NULL; xlat++) 786 if (xlat->val == val) 787 return (xlat->str); 788 switch (base) { 789 case 8: 790 sprintf(tmp, "0%o", val); 791 break; 792 case 16: 793 sprintf(tmp, "0x%x", val); 794 break; 795 case 10: 796 sprintf(tmp, "%u", val); 797 break; 798 default: 799 errx(1,"Unknown lookup base"); 800 break; 801 } 802 return (tmp); 803 } 804 805 static const char * 806 xlookup(struct xlat *xlat, int val) 807 { 808 809 return (lookup(xlat, val, 16)); 810 } 811 812 /* 813 * Searches an xlat array containing bitfield values. Remaining bits 814 * set after removing the known ones are printed at the end: 815 * IN|0x400. 816 */ 817 static char * 818 xlookup_bits(struct xlat *xlat, int val) 819 { 820 int len, rem; 821 static char str[512]; 822 823 len = 0; 824 rem = val; 825 for (; xlat->str != NULL; xlat++) { 826 if ((xlat->val & rem) == xlat->val) { 827 /* 828 * Don't print the "all-bits-zero" string unless all 829 * bits are really zero. 830 */ 831 if (xlat->val == 0 && val != 0) 832 continue; 833 len += sprintf(str + len, "%s|", xlat->str); 834 rem &= ~(xlat->val); 835 } 836 } 837 838 /* 839 * If we have leftover bits or didn't match anything, print 840 * the remainder. 841 */ 842 if (rem || len == 0) 843 len += sprintf(str + len, "0x%x", rem); 844 if (len && str[len - 1] == '|') 845 len--; 846 str[len] = 0; 847 return (str); 848 } 849 850 static void 851 print_integer_arg(const char *(*decoder)(int), FILE *fp, int value) 852 { 853 const char *str; 854 855 str = decoder(value); 856 if (str != NULL) 857 fputs(str, fp); 858 else 859 fprintf(fp, "%d", value); 860 } 861 862 static void 863 print_mask_arg(bool (*decoder)(FILE *, int, int *), FILE *fp, int value) 864 { 865 int rem; 866 867 if (!decoder(fp, value, &rem)) 868 fprintf(fp, "0x%x", rem); 869 else if (rem != 0) 870 fprintf(fp, "|0x%x", rem); 871 } 872 873 static void 874 print_mask_arg32(bool (*decoder)(FILE *, uint32_t, uint32_t *), FILE *fp, 875 uint32_t value) 876 { 877 uint32_t rem; 878 879 if (!decoder(fp, value, &rem)) 880 fprintf(fp, "0x%x", rem); 881 else if (rem != 0) 882 fprintf(fp, "|0x%x", rem); 883 } 884 885 #ifndef __LP64__ 886 /* 887 * Add argument padding to subsequent system calls afater a Quad 888 * syscall arguments as needed. This used to be done by hand in the 889 * decoded_syscalls table which was ugly and error prone. It is 890 * simpler to do the fixup of offsets at initalization time than when 891 * decoding arguments. 892 */ 893 static void 894 quad_fixup(struct syscall *sc) 895 { 896 int offset, prev; 897 u_int i; 898 899 offset = 0; 900 prev = -1; 901 for (i = 0; i < sc->nargs; i++) { 902 /* This arg type is a dummy that doesn't use offset. */ 903 if ((sc->args[i].type & ARG_MASK) == PipeFds) 904 continue; 905 906 assert(prev < sc->args[i].offset); 907 prev = sc->args[i].offset; 908 sc->args[i].offset += offset; 909 switch (sc->args[i].type & ARG_MASK) { 910 case Quad: 911 case QuadHex: 912 #ifdef __powerpc__ 913 /* 914 * 64-bit arguments on 32-bit powerpc must be 915 * 64-bit aligned. If the current offset is 916 * not aligned, the calling convention inserts 917 * a 32-bit pad argument that should be skipped. 918 */ 919 if (sc->args[i].offset % 2 == 1) { 920 sc->args[i].offset++; 921 offset++; 922 } 923 #endif 924 offset++; 925 default: 926 break; 927 } 928 } 929 } 930 #endif 931 932 void 933 init_syscalls(void) 934 { 935 struct syscall *sc; 936 937 STAILQ_INIT(&syscalls); 938 for (sc = decoded_syscalls; sc->name != NULL; sc++) { 939 #ifndef __LP64__ 940 quad_fixup(sc); 941 #endif 942 STAILQ_INSERT_HEAD(&syscalls, sc, entries); 943 } 944 } 945 946 static struct syscall * 947 find_syscall(struct procabi *abi, u_int number) 948 { 949 struct extra_syscall *es; 950 951 if (number < nitems(abi->syscalls)) 952 return (abi->syscalls[number]); 953 STAILQ_FOREACH(es, &abi->extra_syscalls, entries) { 954 if (es->number == number) 955 return (es->sc); 956 } 957 return (NULL); 958 } 959 960 static void 961 add_syscall(struct procabi *abi, u_int number, struct syscall *sc) 962 { 963 struct extra_syscall *es; 964 965 if (number < nitems(abi->syscalls)) { 966 assert(abi->syscalls[number] == NULL); 967 abi->syscalls[number] = sc; 968 } else { 969 es = malloc(sizeof(*es)); 970 es->sc = sc; 971 es->number = number; 972 STAILQ_INSERT_TAIL(&abi->extra_syscalls, es, entries); 973 } 974 } 975 976 /* 977 * If/when the list gets big, it might be desirable to do it 978 * as a hash table or binary search. 979 */ 980 struct syscall * 981 get_syscall(struct threadinfo *t, u_int number, u_int nargs) 982 { 983 struct syscall *sc; 984 const char *name; 985 char *new_name; 986 u_int i; 987 988 sc = find_syscall(t->proc->abi, number); 989 if (sc != NULL) 990 return (sc); 991 992 name = sysdecode_syscallname(t->proc->abi->abi, number); 993 if (name == NULL) { 994 asprintf(&new_name, "#%d", number); 995 name = new_name; 996 } else 997 new_name = NULL; 998 STAILQ_FOREACH(sc, &syscalls, entries) { 999 if (strcmp(name, sc->name) == 0) { 1000 add_syscall(t->proc->abi, number, sc); 1001 free(new_name); 1002 return (sc); 1003 } 1004 } 1005 1006 /* It is unknown. Add it into the list. */ 1007 #if DEBUG 1008 fprintf(stderr, "unknown syscall %s -- setting args to %d\n", name, 1009 nargs); 1010 #endif 1011 1012 sc = calloc(1, sizeof(struct syscall)); 1013 sc->name = name; 1014 if (new_name != NULL) 1015 sc->unknown = true; 1016 sc->ret_type = 1; 1017 sc->nargs = nargs; 1018 for (i = 0; i < nargs; i++) { 1019 sc->args[i].offset = i; 1020 /* Treat all unknown arguments as LongHex. */ 1021 sc->args[i].type = LongHex; 1022 } 1023 STAILQ_INSERT_HEAD(&syscalls, sc, entries); 1024 add_syscall(t->proc->abi, number, sc); 1025 1026 return (sc); 1027 } 1028 1029 /* 1030 * Copy a fixed amount of bytes from the process. 1031 */ 1032 static int 1033 get_struct(pid_t pid, void *offset, void *buf, int len) 1034 { 1035 struct ptrace_io_desc iorequest; 1036 1037 iorequest.piod_op = PIOD_READ_D; 1038 iorequest.piod_offs = offset; 1039 iorequest.piod_addr = buf; 1040 iorequest.piod_len = len; 1041 if (ptrace(PT_IO, pid, (caddr_t)&iorequest, 0) < 0) 1042 return (-1); 1043 return (0); 1044 } 1045 1046 #define MAXSIZE 4096 1047 1048 /* 1049 * Copy a string from the process. Note that it is 1050 * expected to be a C string, but if max is set, it will 1051 * only get that much. 1052 */ 1053 static char * 1054 get_string(pid_t pid, void *addr, int max) 1055 { 1056 struct ptrace_io_desc iorequest; 1057 char *buf, *nbuf; 1058 size_t offset, size, totalsize; 1059 1060 offset = 0; 1061 if (max) 1062 size = max + 1; 1063 else { 1064 /* Read up to the end of the current page. */ 1065 size = PAGE_SIZE - ((uintptr_t)addr % PAGE_SIZE); 1066 if (size > MAXSIZE) 1067 size = MAXSIZE; 1068 } 1069 totalsize = size; 1070 buf = malloc(totalsize); 1071 if (buf == NULL) 1072 return (NULL); 1073 for (;;) { 1074 iorequest.piod_op = PIOD_READ_D; 1075 iorequest.piod_offs = (char *)addr + offset; 1076 iorequest.piod_addr = buf + offset; 1077 iorequest.piod_len = size; 1078 if (ptrace(PT_IO, pid, (caddr_t)&iorequest, 0) < 0) { 1079 free(buf); 1080 return (NULL); 1081 } 1082 if (memchr(buf + offset, '\0', size) != NULL) 1083 return (buf); 1084 offset += size; 1085 if (totalsize < MAXSIZE && max == 0) { 1086 size = MAXSIZE - totalsize; 1087 if (size > PAGE_SIZE) 1088 size = PAGE_SIZE; 1089 nbuf = realloc(buf, totalsize + size); 1090 if (nbuf == NULL) { 1091 buf[totalsize - 1] = '\0'; 1092 return (buf); 1093 } 1094 buf = nbuf; 1095 totalsize += size; 1096 } else { 1097 buf[totalsize - 1] = '\0'; 1098 return (buf); 1099 } 1100 } 1101 } 1102 1103 static const char * 1104 strsig2(int sig) 1105 { 1106 static char tmp[32]; 1107 const char *signame; 1108 1109 signame = sysdecode_signal(sig); 1110 if (signame == NULL) { 1111 snprintf(tmp, sizeof(tmp), "%d", sig); 1112 signame = tmp; 1113 } 1114 return (signame); 1115 } 1116 1117 static void 1118 print_kevent(FILE *fp, struct kevent *ke) 1119 { 1120 1121 switch (ke->filter) { 1122 case EVFILT_READ: 1123 case EVFILT_WRITE: 1124 case EVFILT_VNODE: 1125 case EVFILT_PROC: 1126 case EVFILT_TIMER: 1127 case EVFILT_PROCDESC: 1128 case EVFILT_EMPTY: 1129 fprintf(fp, "%ju", (uintmax_t)ke->ident); 1130 break; 1131 case EVFILT_SIGNAL: 1132 fputs(strsig2(ke->ident), fp); 1133 break; 1134 default: 1135 fprintf(fp, "%p", (void *)ke->ident); 1136 } 1137 fprintf(fp, ","); 1138 print_integer_arg(sysdecode_kevent_filter, fp, ke->filter); 1139 fprintf(fp, ","); 1140 print_mask_arg(sysdecode_kevent_flags, fp, ke->flags); 1141 fprintf(fp, ","); 1142 sysdecode_kevent_fflags(fp, ke->filter, ke->fflags, 16); 1143 fprintf(fp, ",%#jx,%p", (uintmax_t)ke->data, ke->udata); 1144 } 1145 1146 static void 1147 print_utrace(FILE *fp, void *utrace_addr, size_t len) 1148 { 1149 unsigned char *utrace_buffer; 1150 1151 fprintf(fp, "{ "); 1152 if (sysdecode_utrace(fp, utrace_addr, len)) { 1153 fprintf(fp, " }"); 1154 return; 1155 } 1156 1157 utrace_buffer = utrace_addr; 1158 fprintf(fp, "%zu:", len); 1159 while (len--) 1160 fprintf(fp, " %02x", *utrace_buffer++); 1161 fprintf(fp, " }"); 1162 } 1163 1164 static void 1165 print_sockaddr(FILE *fp, struct trussinfo *trussinfo, void *arg, socklen_t len) 1166 { 1167 char addr[64]; 1168 struct sockaddr_in *lsin; 1169 struct sockaddr_in6 *lsin6; 1170 struct sockaddr_un *sun; 1171 struct sockaddr *sa; 1172 u_char *q; 1173 pid_t pid = trussinfo->curthread->proc->pid; 1174 1175 if (arg == NULL) { 1176 fputs("NULL", fp); 1177 return; 1178 } 1179 /* If the length is too small, just bail. */ 1180 if (len < sizeof(*sa)) { 1181 fprintf(fp, "%p", arg); 1182 return; 1183 } 1184 1185 sa = calloc(1, len); 1186 if (get_struct(pid, arg, sa, len) == -1) { 1187 free(sa); 1188 fprintf(fp, "%p", arg); 1189 return; 1190 } 1191 1192 switch (sa->sa_family) { 1193 case AF_INET: 1194 if (len < sizeof(*lsin)) 1195 goto sockaddr_short; 1196 lsin = (struct sockaddr_in *)(void *)sa; 1197 inet_ntop(AF_INET, &lsin->sin_addr, addr, sizeof(addr)); 1198 fprintf(fp, "{ AF_INET %s:%d }", addr, 1199 htons(lsin->sin_port)); 1200 break; 1201 case AF_INET6: 1202 if (len < sizeof(*lsin6)) 1203 goto sockaddr_short; 1204 lsin6 = (struct sockaddr_in6 *)(void *)sa; 1205 inet_ntop(AF_INET6, &lsin6->sin6_addr, addr, 1206 sizeof(addr)); 1207 fprintf(fp, "{ AF_INET6 [%s]:%d }", addr, 1208 htons(lsin6->sin6_port)); 1209 break; 1210 case AF_UNIX: 1211 sun = (struct sockaddr_un *)sa; 1212 fprintf(fp, "{ AF_UNIX \"%.*s\" }", 1213 (int)(len - offsetof(struct sockaddr_un, sun_path)), 1214 sun->sun_path); 1215 break; 1216 default: 1217 sockaddr_short: 1218 fprintf(fp, 1219 "{ sa_len = %d, sa_family = %d, sa_data = {", 1220 (int)sa->sa_len, (int)sa->sa_family); 1221 for (q = (u_char *)sa->sa_data; 1222 q < (u_char *)sa + len; q++) 1223 fprintf(fp, "%s 0x%02x", 1224 q == (u_char *)sa->sa_data ? "" : ",", 1225 *q); 1226 fputs(" } }", fp); 1227 } 1228 free(sa); 1229 } 1230 1231 #define IOV_LIMIT 16 1232 1233 static void 1234 print_iovec(FILE *fp, struct trussinfo *trussinfo, void *arg, int iovcnt) 1235 { 1236 struct iovec iov[IOV_LIMIT]; 1237 size_t max_string = trussinfo->strsize; 1238 char tmp2[max_string + 1], *tmp3; 1239 size_t len; 1240 pid_t pid = trussinfo->curthread->proc->pid; 1241 int i; 1242 bool buf_truncated, iov_truncated; 1243 1244 if (iovcnt <= 0) { 1245 fprintf(fp, "%p", arg); 1246 return; 1247 } 1248 if (iovcnt > IOV_LIMIT) { 1249 iovcnt = IOV_LIMIT; 1250 iov_truncated = true; 1251 } else { 1252 iov_truncated = false; 1253 } 1254 if (get_struct(pid, arg, &iov, iovcnt * sizeof(struct iovec)) == -1) { 1255 fprintf(fp, "%p", arg); 1256 return; 1257 } 1258 1259 fputs("[", fp); 1260 for (i = 0; i < iovcnt; i++) { 1261 len = iov[i].iov_len; 1262 if (len > max_string) { 1263 len = max_string; 1264 buf_truncated = true; 1265 } else { 1266 buf_truncated = false; 1267 } 1268 fprintf(fp, "%s{", (i > 0) ? "," : ""); 1269 if (len && get_struct(pid, iov[i].iov_base, &tmp2, len) != -1) { 1270 tmp3 = malloc(len * 4 + 1); 1271 while (len) { 1272 if (strvisx(tmp3, tmp2, len, 1273 VIS_CSTYLE|VIS_TAB|VIS_NL) <= 1274 (int)max_string) 1275 break; 1276 len--; 1277 buf_truncated = true; 1278 } 1279 fprintf(fp, "\"%s\"%s", tmp3, 1280 buf_truncated ? "..." : ""); 1281 free(tmp3); 1282 } else { 1283 fprintf(fp, "%p", iov[i].iov_base); 1284 } 1285 fprintf(fp, ",%zu}", iov[i].iov_len); 1286 } 1287 fprintf(fp, "%s%s", iov_truncated ? ",..." : "", "]"); 1288 } 1289 1290 static void 1291 print_gen_cmsg(FILE *fp, struct cmsghdr *cmsghdr) 1292 { 1293 u_char *q; 1294 1295 fputs("{", fp); 1296 for (q = CMSG_DATA(cmsghdr); 1297 q < (u_char *)cmsghdr + cmsghdr->cmsg_len; q++) { 1298 fprintf(fp, "%s0x%02x", q == CMSG_DATA(cmsghdr) ? "" : ",", *q); 1299 } 1300 fputs("}", fp); 1301 } 1302 1303 static void 1304 print_sctp_initmsg(FILE *fp, struct sctp_initmsg *init) 1305 { 1306 fprintf(fp, "{out=%u,", init->sinit_num_ostreams); 1307 fprintf(fp, "in=%u,", init->sinit_max_instreams); 1308 fprintf(fp, "max_rtx=%u,", init->sinit_max_attempts); 1309 fprintf(fp, "max_rto=%u}", init->sinit_max_init_timeo); 1310 } 1311 1312 static void 1313 print_sctp_sndrcvinfo(FILE *fp, bool receive, struct sctp_sndrcvinfo *info) 1314 { 1315 fprintf(fp, "{sid=%u,", info->sinfo_stream); 1316 if (receive) { 1317 fprintf(fp, "ssn=%u,", info->sinfo_ssn); 1318 } 1319 fputs("flgs=", fp); 1320 sysdecode_sctp_sinfo_flags(fp, info->sinfo_flags); 1321 fprintf(fp, ",ppid=%u,", ntohl(info->sinfo_ppid)); 1322 if (!receive) { 1323 fprintf(fp, "ctx=%u,", info->sinfo_context); 1324 fprintf(fp, "ttl=%u,", info->sinfo_timetolive); 1325 } 1326 if (receive) { 1327 fprintf(fp, "tsn=%u,", info->sinfo_tsn); 1328 fprintf(fp, "cumtsn=%u,", info->sinfo_cumtsn); 1329 } 1330 fprintf(fp, "id=%u}", info->sinfo_assoc_id); 1331 } 1332 1333 static void 1334 print_sctp_sndinfo(FILE *fp, struct sctp_sndinfo *info) 1335 { 1336 fprintf(fp, "{sid=%u,", info->snd_sid); 1337 fputs("flgs=", fp); 1338 print_mask_arg(sysdecode_sctp_snd_flags, fp, info->snd_flags); 1339 fprintf(fp, ",ppid=%u,", ntohl(info->snd_ppid)); 1340 fprintf(fp, "ctx=%u,", info->snd_context); 1341 fprintf(fp, "id=%u}", info->snd_assoc_id); 1342 } 1343 1344 static void 1345 print_sctp_rcvinfo(FILE *fp, struct sctp_rcvinfo *info) 1346 { 1347 fprintf(fp, "{sid=%u,", info->rcv_sid); 1348 fprintf(fp, "ssn=%u,", info->rcv_ssn); 1349 fputs("flgs=", fp); 1350 print_mask_arg(sysdecode_sctp_rcv_flags, fp, info->rcv_flags); 1351 fprintf(fp, ",ppid=%u,", ntohl(info->rcv_ppid)); 1352 fprintf(fp, "tsn=%u,", info->rcv_tsn); 1353 fprintf(fp, "cumtsn=%u,", info->rcv_cumtsn); 1354 fprintf(fp, "ctx=%u,", info->rcv_context); 1355 fprintf(fp, "id=%u}", info->rcv_assoc_id); 1356 } 1357 1358 static void 1359 print_sctp_nxtinfo(FILE *fp, struct sctp_nxtinfo *info) 1360 { 1361 fprintf(fp, "{sid=%u,", info->nxt_sid); 1362 fputs("flgs=", fp); 1363 print_mask_arg(sysdecode_sctp_nxt_flags, fp, info->nxt_flags); 1364 fprintf(fp, ",ppid=%u,", ntohl(info->nxt_ppid)); 1365 fprintf(fp, "len=%u,", info->nxt_length); 1366 fprintf(fp, "id=%u}", info->nxt_assoc_id); 1367 } 1368 1369 static void 1370 print_sctp_prinfo(FILE *fp, struct sctp_prinfo *info) 1371 { 1372 fputs("{pol=", fp); 1373 print_integer_arg(sysdecode_sctp_pr_policy, fp, info->pr_policy); 1374 fprintf(fp, ",val=%u}", info->pr_value); 1375 } 1376 1377 static void 1378 print_sctp_authinfo(FILE *fp, struct sctp_authinfo *info) 1379 { 1380 fprintf(fp, "{num=%u}", info->auth_keynumber); 1381 } 1382 1383 static void 1384 print_sctp_ipv4_addr(FILE *fp, struct in_addr *addr) 1385 { 1386 char buf[INET_ADDRSTRLEN]; 1387 const char *s; 1388 1389 s = inet_ntop(AF_INET, addr, buf, INET_ADDRSTRLEN); 1390 if (s != NULL) 1391 fprintf(fp, "{addr=%s}", s); 1392 else 1393 fputs("{addr=???}", fp); 1394 } 1395 1396 static void 1397 print_sctp_ipv6_addr(FILE *fp, struct in6_addr *addr) 1398 { 1399 char buf[INET6_ADDRSTRLEN]; 1400 const char *s; 1401 1402 s = inet_ntop(AF_INET6, addr, buf, INET6_ADDRSTRLEN); 1403 if (s != NULL) 1404 fprintf(fp, "{addr=%s}", s); 1405 else 1406 fputs("{addr=???}", fp); 1407 } 1408 1409 static void 1410 print_sctp_cmsg(FILE *fp, bool receive, struct cmsghdr *cmsghdr) 1411 { 1412 void *data; 1413 socklen_t len; 1414 1415 len = cmsghdr->cmsg_len; 1416 data = CMSG_DATA(cmsghdr); 1417 switch (cmsghdr->cmsg_type) { 1418 case SCTP_INIT: 1419 if (len == CMSG_LEN(sizeof(struct sctp_initmsg))) 1420 print_sctp_initmsg(fp, (struct sctp_initmsg *)data); 1421 else 1422 print_gen_cmsg(fp, cmsghdr); 1423 break; 1424 case SCTP_SNDRCV: 1425 if (len == CMSG_LEN(sizeof(struct sctp_sndrcvinfo))) 1426 print_sctp_sndrcvinfo(fp, receive, 1427 (struct sctp_sndrcvinfo *)data); 1428 else 1429 print_gen_cmsg(fp, cmsghdr); 1430 break; 1431 #if 0 1432 case SCTP_EXTRCV: 1433 if (len == CMSG_LEN(sizeof(struct sctp_extrcvinfo))) 1434 print_sctp_extrcvinfo(fp, 1435 (struct sctp_extrcvinfo *)data); 1436 else 1437 print_gen_cmsg(fp, cmsghdr); 1438 break; 1439 #endif 1440 case SCTP_SNDINFO: 1441 if (len == CMSG_LEN(sizeof(struct sctp_sndinfo))) 1442 print_sctp_sndinfo(fp, (struct sctp_sndinfo *)data); 1443 else 1444 print_gen_cmsg(fp, cmsghdr); 1445 break; 1446 case SCTP_RCVINFO: 1447 if (len == CMSG_LEN(sizeof(struct sctp_rcvinfo))) 1448 print_sctp_rcvinfo(fp, (struct sctp_rcvinfo *)data); 1449 else 1450 print_gen_cmsg(fp, cmsghdr); 1451 break; 1452 case SCTP_NXTINFO: 1453 if (len == CMSG_LEN(sizeof(struct sctp_nxtinfo))) 1454 print_sctp_nxtinfo(fp, (struct sctp_nxtinfo *)data); 1455 else 1456 print_gen_cmsg(fp, cmsghdr); 1457 break; 1458 case SCTP_PRINFO: 1459 if (len == CMSG_LEN(sizeof(struct sctp_prinfo))) 1460 print_sctp_prinfo(fp, (struct sctp_prinfo *)data); 1461 else 1462 print_gen_cmsg(fp, cmsghdr); 1463 break; 1464 case SCTP_AUTHINFO: 1465 if (len == CMSG_LEN(sizeof(struct sctp_authinfo))) 1466 print_sctp_authinfo(fp, (struct sctp_authinfo *)data); 1467 else 1468 print_gen_cmsg(fp, cmsghdr); 1469 break; 1470 case SCTP_DSTADDRV4: 1471 if (len == CMSG_LEN(sizeof(struct in_addr))) 1472 print_sctp_ipv4_addr(fp, (struct in_addr *)data); 1473 else 1474 print_gen_cmsg(fp, cmsghdr); 1475 break; 1476 case SCTP_DSTADDRV6: 1477 if (len == CMSG_LEN(sizeof(struct in6_addr))) 1478 print_sctp_ipv6_addr(fp, (struct in6_addr *)data); 1479 else 1480 print_gen_cmsg(fp, cmsghdr); 1481 break; 1482 default: 1483 print_gen_cmsg(fp, cmsghdr); 1484 } 1485 } 1486 1487 static void 1488 print_cmsgs(FILE *fp, pid_t pid, bool receive, struct msghdr *msghdr) 1489 { 1490 struct cmsghdr *cmsghdr; 1491 char *cmsgbuf; 1492 const char *temp; 1493 socklen_t len; 1494 int level, type; 1495 bool first; 1496 1497 len = msghdr->msg_controllen; 1498 if (len == 0) { 1499 fputs("{}", fp); 1500 return; 1501 } 1502 cmsgbuf = calloc(1, len); 1503 if (get_struct(pid, msghdr->msg_control, cmsgbuf, len) == -1) { 1504 fprintf(fp, "%p", msghdr->msg_control); 1505 free(cmsgbuf); 1506 return; 1507 } 1508 msghdr->msg_control = cmsgbuf; 1509 first = true; 1510 fputs("{", fp); 1511 for (cmsghdr = CMSG_FIRSTHDR(msghdr); 1512 cmsghdr != NULL; 1513 cmsghdr = CMSG_NXTHDR(msghdr, cmsghdr)) { 1514 level = cmsghdr->cmsg_level; 1515 type = cmsghdr->cmsg_type; 1516 len = cmsghdr->cmsg_len; 1517 fprintf(fp, "%s{level=", first ? "" : ","); 1518 print_integer_arg(sysdecode_sockopt_level, fp, level); 1519 fputs(",type=", fp); 1520 temp = sysdecode_cmsg_type(level, type); 1521 if (temp) { 1522 fputs(temp, fp); 1523 } else { 1524 fprintf(fp, "%d", type); 1525 } 1526 fputs(",data=", fp); 1527 switch (level) { 1528 case IPPROTO_SCTP: 1529 print_sctp_cmsg(fp, receive, cmsghdr); 1530 break; 1531 default: 1532 print_gen_cmsg(fp, cmsghdr); 1533 break; 1534 } 1535 fputs("}", fp); 1536 first = false; 1537 } 1538 fputs("}", fp); 1539 free(cmsgbuf); 1540 } 1541 1542 /* 1543 * Converts a syscall argument into a string. Said string is 1544 * allocated via malloc(), so needs to be free()'d. sc is 1545 * a pointer to the syscall description (see above); args is 1546 * an array of all of the system call arguments. 1547 */ 1548 char * 1549 print_arg(struct syscall_args *sc, unsigned long *args, long *retval, 1550 struct trussinfo *trussinfo) 1551 { 1552 FILE *fp; 1553 char *tmp; 1554 size_t tmplen; 1555 pid_t pid; 1556 1557 fp = open_memstream(&tmp, &tmplen); 1558 pid = trussinfo->curthread->proc->pid; 1559 switch (sc->type & ARG_MASK) { 1560 case Hex: 1561 fprintf(fp, "0x%x", (int)args[sc->offset]); 1562 break; 1563 case Octal: 1564 fprintf(fp, "0%o", (int)args[sc->offset]); 1565 break; 1566 case Int: 1567 fprintf(fp, "%d", (int)args[sc->offset]); 1568 break; 1569 case UInt: 1570 fprintf(fp, "%u", (unsigned int)args[sc->offset]); 1571 break; 1572 case PUInt: { 1573 unsigned int val; 1574 1575 if (get_struct(pid, (void *)args[sc->offset], &val, 1576 sizeof(val)) == 0) 1577 fprintf(fp, "{ %u }", val); 1578 else 1579 fprintf(fp, "0x%lx", args[sc->offset]); 1580 break; 1581 } 1582 case LongHex: 1583 fprintf(fp, "0x%lx", args[sc->offset]); 1584 break; 1585 case Long: 1586 fprintf(fp, "%ld", args[sc->offset]); 1587 break; 1588 case Sizet: 1589 fprintf(fp, "%zu", (size_t)args[sc->offset]); 1590 break; 1591 case Name: { 1592 /* NULL-terminated string. */ 1593 char *tmp2; 1594 1595 tmp2 = get_string(pid, (void*)args[sc->offset], 0); 1596 fprintf(fp, "\"%s\"", tmp2); 1597 free(tmp2); 1598 break; 1599 } 1600 case BinString: { 1601 /* 1602 * Binary block of data that might have printable characters. 1603 * XXX If type|OUT, assume that the length is the syscall's 1604 * return value. Otherwise, assume that the length of the block 1605 * is in the next syscall argument. 1606 */ 1607 int max_string = trussinfo->strsize; 1608 char tmp2[max_string + 1], *tmp3; 1609 int len; 1610 int truncated = 0; 1611 1612 if (sc->type & OUT) 1613 len = retval[0]; 1614 else 1615 len = args[sc->offset + 1]; 1616 1617 /* 1618 * Don't print more than max_string characters, to avoid word 1619 * wrap. If we have to truncate put some ... after the string. 1620 */ 1621 if (len > max_string) { 1622 len = max_string; 1623 truncated = 1; 1624 } 1625 if (len && get_struct(pid, (void*)args[sc->offset], &tmp2, len) 1626 != -1) { 1627 tmp3 = malloc(len * 4 + 1); 1628 while (len) { 1629 if (strvisx(tmp3, tmp2, len, 1630 VIS_CSTYLE|VIS_TAB|VIS_NL) <= max_string) 1631 break; 1632 len--; 1633 truncated = 1; 1634 } 1635 fprintf(fp, "\"%s\"%s", tmp3, truncated ? 1636 "..." : ""); 1637 free(tmp3); 1638 } else { 1639 fprintf(fp, "0x%lx", args[sc->offset]); 1640 } 1641 break; 1642 } 1643 case ExecArgs: 1644 case ExecEnv: 1645 case StringArray: { 1646 uintptr_t addr; 1647 union { 1648 char *strarray[0]; 1649 char buf[PAGE_SIZE]; 1650 } u; 1651 char *string; 1652 size_t len; 1653 u_int first, i; 1654 1655 /* 1656 * Only parse argv[] and environment arrays from exec calls 1657 * if requested. 1658 */ 1659 if (((sc->type & ARG_MASK) == ExecArgs && 1660 (trussinfo->flags & EXECVEARGS) == 0) || 1661 ((sc->type & ARG_MASK) == ExecEnv && 1662 (trussinfo->flags & EXECVEENVS) == 0)) { 1663 fprintf(fp, "0x%lx", args[sc->offset]); 1664 break; 1665 } 1666 1667 /* 1668 * Read a page of pointers at a time. Punt if the top-level 1669 * pointer is not aligned. Note that the first read is of 1670 * a partial page. 1671 */ 1672 addr = args[sc->offset]; 1673 if (addr % sizeof(char *) != 0) { 1674 fprintf(fp, "0x%lx", args[sc->offset]); 1675 break; 1676 } 1677 1678 len = PAGE_SIZE - (addr & PAGE_MASK); 1679 if (get_struct(pid, (void *)addr, u.buf, len) == -1) { 1680 fprintf(fp, "0x%lx", args[sc->offset]); 1681 break; 1682 } 1683 1684 fputc('[', fp); 1685 first = 1; 1686 i = 0; 1687 while (u.strarray[i] != NULL) { 1688 string = get_string(pid, u.strarray[i], 0); 1689 fprintf(fp, "%s \"%s\"", first ? "" : ",", string); 1690 free(string); 1691 first = 0; 1692 1693 i++; 1694 if (i == len / sizeof(char *)) { 1695 addr += len; 1696 len = PAGE_SIZE; 1697 if (get_struct(pid, (void *)addr, u.buf, len) == 1698 -1) { 1699 fprintf(fp, ", <inval>"); 1700 break; 1701 } 1702 i = 0; 1703 } 1704 } 1705 fputs(" ]", fp); 1706 break; 1707 } 1708 #ifdef __LP64__ 1709 case Quad: 1710 fprintf(fp, "%ld", args[sc->offset]); 1711 break; 1712 case QuadHex: 1713 fprintf(fp, "0x%lx", args[sc->offset]); 1714 break; 1715 #else 1716 case Quad: 1717 case QuadHex: { 1718 unsigned long long ll; 1719 1720 #if _BYTE_ORDER == _LITTLE_ENDIAN 1721 ll = (unsigned long long)args[sc->offset + 1] << 32 | 1722 args[sc->offset]; 1723 #else 1724 ll = (unsigned long long)args[sc->offset] << 32 | 1725 args[sc->offset + 1]; 1726 #endif 1727 if ((sc->type & ARG_MASK) == Quad) 1728 fprintf(fp, "%lld", ll); 1729 else 1730 fprintf(fp, "0x%llx", ll); 1731 break; 1732 } 1733 #endif 1734 case PQuadHex: { 1735 uint64_t val; 1736 1737 if (get_struct(pid, (void *)args[sc->offset], &val, 1738 sizeof(val)) == 0) 1739 fprintf(fp, "{ 0x%jx }", (uintmax_t)val); 1740 else 1741 fprintf(fp, "0x%lx", args[sc->offset]); 1742 break; 1743 } 1744 case Ptr: 1745 fprintf(fp, "0x%lx", args[sc->offset]); 1746 break; 1747 case Readlinkres: { 1748 char *tmp2; 1749 1750 if (retval[0] == -1) 1751 break; 1752 tmp2 = get_string(pid, (void*)args[sc->offset], retval[0]); 1753 fprintf(fp, "\"%s\"", tmp2); 1754 free(tmp2); 1755 break; 1756 } 1757 case Ioctl: { 1758 const char *temp; 1759 unsigned long cmd; 1760 1761 cmd = args[sc->offset]; 1762 temp = sysdecode_ioctlname(cmd); 1763 if (temp) 1764 fputs(temp, fp); 1765 else { 1766 fprintf(fp, "0x%lx { IO%s%s 0x%lx('%c'), %lu, %lu }", 1767 cmd, cmd & IOC_OUT ? "R" : "", 1768 cmd & IOC_IN ? "W" : "", IOCGROUP(cmd), 1769 isprint(IOCGROUP(cmd)) ? (char)IOCGROUP(cmd) : '?', 1770 cmd & 0xFF, IOCPARM_LEN(cmd)); 1771 } 1772 break; 1773 } 1774 case Timespec: { 1775 struct timespec ts; 1776 1777 if (get_struct(pid, (void *)args[sc->offset], &ts, 1778 sizeof(ts)) != -1) 1779 fprintf(fp, "{ %jd.%09ld }", (intmax_t)ts.tv_sec, 1780 ts.tv_nsec); 1781 else 1782 fprintf(fp, "0x%lx", args[sc->offset]); 1783 break; 1784 } 1785 case Timespec2: { 1786 struct timespec ts[2]; 1787 const char *sep; 1788 unsigned int i; 1789 1790 if (get_struct(pid, (void *)args[sc->offset], &ts, sizeof(ts)) 1791 != -1) { 1792 fputs("{ ", fp); 1793 sep = ""; 1794 for (i = 0; i < nitems(ts); i++) { 1795 fputs(sep, fp); 1796 sep = ", "; 1797 switch (ts[i].tv_nsec) { 1798 case UTIME_NOW: 1799 fprintf(fp, "UTIME_NOW"); 1800 break; 1801 case UTIME_OMIT: 1802 fprintf(fp, "UTIME_OMIT"); 1803 break; 1804 default: 1805 fprintf(fp, "%jd.%09ld", 1806 (intmax_t)ts[i].tv_sec, 1807 ts[i].tv_nsec); 1808 break; 1809 } 1810 } 1811 fputs(" }", fp); 1812 } else 1813 fprintf(fp, "0x%lx", args[sc->offset]); 1814 break; 1815 } 1816 case Timeval: { 1817 struct timeval tv; 1818 1819 if (get_struct(pid, (void *)args[sc->offset], &tv, sizeof(tv)) 1820 != -1) 1821 fprintf(fp, "{ %jd.%06ld }", (intmax_t)tv.tv_sec, 1822 tv.tv_usec); 1823 else 1824 fprintf(fp, "0x%lx", args[sc->offset]); 1825 break; 1826 } 1827 case Timeval2: { 1828 struct timeval tv[2]; 1829 1830 if (get_struct(pid, (void *)args[sc->offset], &tv, sizeof(tv)) 1831 != -1) 1832 fprintf(fp, "{ %jd.%06ld, %jd.%06ld }", 1833 (intmax_t)tv[0].tv_sec, tv[0].tv_usec, 1834 (intmax_t)tv[1].tv_sec, tv[1].tv_usec); 1835 else 1836 fprintf(fp, "0x%lx", args[sc->offset]); 1837 break; 1838 } 1839 case Itimerval: { 1840 struct itimerval itv; 1841 1842 if (get_struct(pid, (void *)args[sc->offset], &itv, 1843 sizeof(itv)) != -1) 1844 fprintf(fp, "{ %jd.%06ld, %jd.%06ld }", 1845 (intmax_t)itv.it_interval.tv_sec, 1846 itv.it_interval.tv_usec, 1847 (intmax_t)itv.it_value.tv_sec, 1848 itv.it_value.tv_usec); 1849 else 1850 fprintf(fp, "0x%lx", args[sc->offset]); 1851 break; 1852 } 1853 case LinuxSockArgs: 1854 { 1855 struct linux_socketcall_args largs; 1856 1857 if (get_struct(pid, (void *)args[sc->offset], (void *)&largs, 1858 sizeof(largs)) != -1) 1859 fprintf(fp, "{ %s, 0x%lx }", 1860 lookup(linux_socketcall_ops, largs.what, 10), 1861 (long unsigned int)largs.args); 1862 else 1863 fprintf(fp, "0x%lx", args[sc->offset]); 1864 break; 1865 } 1866 case Pollfd: { 1867 /* 1868 * XXX: A Pollfd argument expects the /next/ syscall argument 1869 * to be the number of fds in the array. This matches the poll 1870 * syscall. 1871 */ 1872 struct pollfd *pfd; 1873 int numfds = args[sc->offset + 1]; 1874 size_t bytes = sizeof(struct pollfd) * numfds; 1875 int i; 1876 1877 if ((pfd = malloc(bytes)) == NULL) 1878 err(1, "Cannot malloc %zu bytes for pollfd array", 1879 bytes); 1880 if (get_struct(pid, (void *)args[sc->offset], pfd, bytes) 1881 != -1) { 1882 fputs("{", fp); 1883 for (i = 0; i < numfds; i++) { 1884 fprintf(fp, " %d/%s", pfd[i].fd, 1885 xlookup_bits(poll_flags, pfd[i].events)); 1886 } 1887 fputs(" }", fp); 1888 } else { 1889 fprintf(fp, "0x%lx", args[sc->offset]); 1890 } 1891 free(pfd); 1892 break; 1893 } 1894 case Fd_set: { 1895 /* 1896 * XXX: A Fd_set argument expects the /first/ syscall argument 1897 * to be the number of fds in the array. This matches the 1898 * select syscall. 1899 */ 1900 fd_set *fds; 1901 int numfds = args[0]; 1902 size_t bytes = _howmany(numfds, _NFDBITS) * _NFDBITS; 1903 int i; 1904 1905 if ((fds = malloc(bytes)) == NULL) 1906 err(1, "Cannot malloc %zu bytes for fd_set array", 1907 bytes); 1908 if (get_struct(pid, (void *)args[sc->offset], fds, bytes) 1909 != -1) { 1910 fputs("{", fp); 1911 for (i = 0; i < numfds; i++) { 1912 if (FD_ISSET(i, fds)) 1913 fprintf(fp, " %d", i); 1914 } 1915 fputs(" }", fp); 1916 } else 1917 fprintf(fp, "0x%lx", args[sc->offset]); 1918 free(fds); 1919 break; 1920 } 1921 case Signal: 1922 fputs(strsig2(args[sc->offset]), fp); 1923 break; 1924 case Sigset: { 1925 long sig; 1926 sigset_t ss; 1927 int i, first; 1928 1929 sig = args[sc->offset]; 1930 if (get_struct(pid, (void *)args[sc->offset], (void *)&ss, 1931 sizeof(ss)) == -1) { 1932 fprintf(fp, "0x%lx", args[sc->offset]); 1933 break; 1934 } 1935 fputs("{ ", fp); 1936 first = 1; 1937 for (i = 1; i < sys_nsig; i++) { 1938 if (sigismember(&ss, i)) { 1939 fprintf(fp, "%s%s", !first ? "|" : "", 1940 strsig2(i)); 1941 first = 0; 1942 } 1943 } 1944 if (!first) 1945 fputc(' ', fp); 1946 fputc('}', fp); 1947 break; 1948 } 1949 case Sigprocmask: 1950 print_integer_arg(sysdecode_sigprocmask_how, fp, 1951 args[sc->offset]); 1952 break; 1953 case Fcntlflag: 1954 /* XXX: Output depends on the value of the previous argument. */ 1955 if (sysdecode_fcntl_arg_p(args[sc->offset - 1])) 1956 sysdecode_fcntl_arg(fp, args[sc->offset - 1], 1957 args[sc->offset], 16); 1958 break; 1959 case Open: 1960 print_mask_arg(sysdecode_open_flags, fp, args[sc->offset]); 1961 break; 1962 case Fcntl: 1963 print_integer_arg(sysdecode_fcntl_cmd, fp, args[sc->offset]); 1964 break; 1965 case Mprot: 1966 print_mask_arg(sysdecode_mmap_prot, fp, args[sc->offset]); 1967 break; 1968 case Mmapflags: 1969 print_mask_arg(sysdecode_mmap_flags, fp, args[sc->offset]); 1970 break; 1971 case Whence: 1972 print_integer_arg(sysdecode_whence, fp, args[sc->offset]); 1973 break; 1974 case Sockdomain: 1975 print_integer_arg(sysdecode_socketdomain, fp, args[sc->offset]); 1976 break; 1977 case Socktype: 1978 print_mask_arg(sysdecode_socket_type, fp, args[sc->offset]); 1979 break; 1980 case Shutdown: 1981 print_integer_arg(sysdecode_shutdown_how, fp, args[sc->offset]); 1982 break; 1983 case Resource: 1984 print_integer_arg(sysdecode_rlimit, fp, args[sc->offset]); 1985 break; 1986 case RusageWho: 1987 print_integer_arg(sysdecode_getrusage_who, fp, args[sc->offset]); 1988 break; 1989 case Pathconf: 1990 print_integer_arg(sysdecode_pathconf_name, fp, args[sc->offset]); 1991 break; 1992 case Rforkflags: 1993 print_mask_arg(sysdecode_rfork_flags, fp, args[sc->offset]); 1994 break; 1995 case Sockaddr: { 1996 socklen_t len; 1997 1998 if (args[sc->offset] == 0) { 1999 fputs("NULL", fp); 2000 break; 2001 } 2002 2003 /* 2004 * Extract the address length from the next argument. If 2005 * this is an output sockaddr (OUT is set), then the 2006 * next argument is a pointer to a socklen_t. Otherwise 2007 * the next argument contains a socklen_t by value. 2008 */ 2009 if (sc->type & OUT) { 2010 if (get_struct(pid, (void *)args[sc->offset + 1], 2011 &len, sizeof(len)) == -1) { 2012 fprintf(fp, "0x%lx", args[sc->offset]); 2013 break; 2014 } 2015 } else 2016 len = args[sc->offset + 1]; 2017 2018 print_sockaddr(fp, trussinfo, (void *)args[sc->offset], len); 2019 break; 2020 } 2021 case Sigaction: { 2022 struct sigaction sa; 2023 2024 if (get_struct(pid, (void *)args[sc->offset], &sa, sizeof(sa)) 2025 != -1) { 2026 fputs("{ ", fp); 2027 if (sa.sa_handler == SIG_DFL) 2028 fputs("SIG_DFL", fp); 2029 else if (sa.sa_handler == SIG_IGN) 2030 fputs("SIG_IGN", fp); 2031 else 2032 fprintf(fp, "%p", sa.sa_handler); 2033 fprintf(fp, " %s ss_t }", 2034 xlookup_bits(sigaction_flags, sa.sa_flags)); 2035 } else 2036 fprintf(fp, "0x%lx", args[sc->offset]); 2037 break; 2038 } 2039 case Kevent: { 2040 /* 2041 * XXX XXX: The size of the array is determined by either the 2042 * next syscall argument, or by the syscall return value, 2043 * depending on which argument number we are. This matches the 2044 * kevent syscall, but luckily that's the only syscall that uses 2045 * them. 2046 */ 2047 struct kevent *ke; 2048 int numevents = -1; 2049 size_t bytes; 2050 int i; 2051 2052 if (sc->offset == 1) 2053 numevents = args[sc->offset+1]; 2054 else if (sc->offset == 3 && retval[0] != -1) 2055 numevents = retval[0]; 2056 2057 if (numevents >= 0) { 2058 bytes = sizeof(struct kevent) * numevents; 2059 if ((ke = malloc(bytes)) == NULL) 2060 err(1, 2061 "Cannot malloc %zu bytes for kevent array", 2062 bytes); 2063 } else 2064 ke = NULL; 2065 if (numevents >= 0 && get_struct(pid, (void *)args[sc->offset], 2066 ke, bytes) != -1) { 2067 fputc('{', fp); 2068 for (i = 0; i < numevents; i++) { 2069 fputc(' ', fp); 2070 print_kevent(fp, &ke[i]); 2071 } 2072 fputs(" }", fp); 2073 } else { 2074 fprintf(fp, "0x%lx", args[sc->offset]); 2075 } 2076 free(ke); 2077 break; 2078 } 2079 case Kevent11: { 2080 struct kevent_freebsd11 *ke11; 2081 struct kevent ke; 2082 int numevents = -1; 2083 size_t bytes; 2084 int i; 2085 2086 if (sc->offset == 1) 2087 numevents = args[sc->offset+1]; 2088 else if (sc->offset == 3 && retval[0] != -1) 2089 numevents = retval[0]; 2090 2091 if (numevents >= 0) { 2092 bytes = sizeof(struct kevent_freebsd11) * numevents; 2093 if ((ke11 = malloc(bytes)) == NULL) 2094 err(1, 2095 "Cannot malloc %zu bytes for kevent array", 2096 bytes); 2097 } else 2098 ke11 = NULL; 2099 memset(&ke, 0, sizeof(ke)); 2100 if (numevents >= 0 && get_struct(pid, (void *)args[sc->offset], 2101 ke11, bytes) != -1) { 2102 fputc('{', fp); 2103 for (i = 0; i < numevents; i++) { 2104 fputc(' ', fp); 2105 ke.ident = ke11[i].ident; 2106 ke.filter = ke11[i].filter; 2107 ke.flags = ke11[i].flags; 2108 ke.fflags = ke11[i].fflags; 2109 ke.data = ke11[i].data; 2110 ke.udata = ke11[i].udata; 2111 print_kevent(fp, &ke); 2112 } 2113 fputs(" }", fp); 2114 } else { 2115 fprintf(fp, "0x%lx", args[sc->offset]); 2116 } 2117 free(ke11); 2118 break; 2119 } 2120 case Stat: { 2121 struct stat st; 2122 2123 if (get_struct(pid, (void *)args[sc->offset], &st, sizeof(st)) 2124 != -1) { 2125 char mode[12]; 2126 2127 strmode(st.st_mode, mode); 2128 fprintf(fp, 2129 "{ mode=%s,inode=%ju,size=%jd,blksize=%ld }", mode, 2130 (uintmax_t)st.st_ino, (intmax_t)st.st_size, 2131 (long)st.st_blksize); 2132 } else { 2133 fprintf(fp, "0x%lx", args[sc->offset]); 2134 } 2135 break; 2136 } 2137 case Stat11: { 2138 struct freebsd11_stat st; 2139 2140 if (get_struct(pid, (void *)args[sc->offset], &st, sizeof(st)) 2141 != -1) { 2142 char mode[12]; 2143 2144 strmode(st.st_mode, mode); 2145 fprintf(fp, 2146 "{ mode=%s,inode=%ju,size=%jd,blksize=%ld }", mode, 2147 (uintmax_t)st.st_ino, (intmax_t)st.st_size, 2148 (long)st.st_blksize); 2149 } else { 2150 fprintf(fp, "0x%lx", args[sc->offset]); 2151 } 2152 break; 2153 } 2154 case StatFs: { 2155 unsigned int i; 2156 struct statfs buf; 2157 2158 if (get_struct(pid, (void *)args[sc->offset], &buf, 2159 sizeof(buf)) != -1) { 2160 char fsid[17]; 2161 2162 bzero(fsid, sizeof(fsid)); 2163 if (buf.f_fsid.val[0] != 0 || buf.f_fsid.val[1] != 0) { 2164 for (i = 0; i < sizeof(buf.f_fsid); i++) 2165 snprintf(&fsid[i*2], 2166 sizeof(fsid) - (i*2), "%02x", 2167 ((u_char *)&buf.f_fsid)[i]); 2168 } 2169 fprintf(fp, 2170 "{ fstypename=%s,mntonname=%s,mntfromname=%s," 2171 "fsid=%s }", buf.f_fstypename, buf.f_mntonname, 2172 buf.f_mntfromname, fsid); 2173 } else 2174 fprintf(fp, "0x%lx", args[sc->offset]); 2175 break; 2176 } 2177 2178 case Rusage: { 2179 struct rusage ru; 2180 2181 if (get_struct(pid, (void *)args[sc->offset], &ru, sizeof(ru)) 2182 != -1) { 2183 fprintf(fp, 2184 "{ u=%jd.%06ld,s=%jd.%06ld,in=%ld,out=%ld }", 2185 (intmax_t)ru.ru_utime.tv_sec, ru.ru_utime.tv_usec, 2186 (intmax_t)ru.ru_stime.tv_sec, ru.ru_stime.tv_usec, 2187 ru.ru_inblock, ru.ru_oublock); 2188 } else 2189 fprintf(fp, "0x%lx", args[sc->offset]); 2190 break; 2191 } 2192 case Rlimit: { 2193 struct rlimit rl; 2194 2195 if (get_struct(pid, (void *)args[sc->offset], &rl, sizeof(rl)) 2196 != -1) { 2197 fprintf(fp, "{ cur=%ju,max=%ju }", 2198 rl.rlim_cur, rl.rlim_max); 2199 } else 2200 fprintf(fp, "0x%lx", args[sc->offset]); 2201 break; 2202 } 2203 case ExitStatus: { 2204 int status; 2205 2206 if (get_struct(pid, (void *)args[sc->offset], &status, 2207 sizeof(status)) != -1) { 2208 fputs("{ ", fp); 2209 if (WIFCONTINUED(status)) 2210 fputs("CONTINUED", fp); 2211 else if (WIFEXITED(status)) 2212 fprintf(fp, "EXITED,val=%d", 2213 WEXITSTATUS(status)); 2214 else if (WIFSIGNALED(status)) 2215 fprintf(fp, "SIGNALED,sig=%s%s", 2216 strsig2(WTERMSIG(status)), 2217 WCOREDUMP(status) ? ",cored" : ""); 2218 else 2219 fprintf(fp, "STOPPED,sig=%s", 2220 strsig2(WTERMSIG(status))); 2221 fputs(" }", fp); 2222 } else 2223 fprintf(fp, "0x%lx", args[sc->offset]); 2224 break; 2225 } 2226 case Waitoptions: 2227 print_mask_arg(sysdecode_wait6_options, fp, args[sc->offset]); 2228 break; 2229 case Idtype: 2230 print_integer_arg(sysdecode_idtype, fp, args[sc->offset]); 2231 break; 2232 case Procctl: 2233 print_integer_arg(sysdecode_procctl_cmd, fp, args[sc->offset]); 2234 break; 2235 case Umtxop: 2236 print_integer_arg(sysdecode_umtx_op, fp, args[sc->offset]); 2237 break; 2238 case Atfd: 2239 print_integer_arg(sysdecode_atfd, fp, args[sc->offset]); 2240 break; 2241 case Atflags: 2242 print_mask_arg(sysdecode_atflags, fp, args[sc->offset]); 2243 break; 2244 case Accessmode: 2245 print_mask_arg(sysdecode_access_mode, fp, args[sc->offset]); 2246 break; 2247 case Sysarch: 2248 print_integer_arg(sysdecode_sysarch_number, fp, 2249 args[sc->offset]); 2250 break; 2251 case PipeFds: 2252 /* 2253 * The pipe() system call in the kernel returns its 2254 * two file descriptors via return values. However, 2255 * the interface exposed by libc is that pipe() 2256 * accepts a pointer to an array of descriptors. 2257 * Format the output to match the libc API by printing 2258 * the returned file descriptors as a fake argument. 2259 * 2260 * Overwrite the first retval to signal a successful 2261 * return as well. 2262 */ 2263 fprintf(fp, "{ %ld, %ld }", retval[0], retval[1]); 2264 retval[0] = 0; 2265 break; 2266 case Utrace: { 2267 size_t len; 2268 void *utrace_addr; 2269 2270 len = args[sc->offset + 1]; 2271 utrace_addr = calloc(1, len); 2272 if (get_struct(pid, (void *)args[sc->offset], 2273 (void *)utrace_addr, len) != -1) 2274 print_utrace(fp, utrace_addr, len); 2275 else 2276 fprintf(fp, "0x%lx", args[sc->offset]); 2277 free(utrace_addr); 2278 break; 2279 } 2280 case IntArray: { 2281 int descriptors[16]; 2282 unsigned long i, ndescriptors; 2283 bool truncated; 2284 2285 ndescriptors = args[sc->offset + 1]; 2286 truncated = false; 2287 if (ndescriptors > nitems(descriptors)) { 2288 ndescriptors = nitems(descriptors); 2289 truncated = true; 2290 } 2291 if (get_struct(pid, (void *)args[sc->offset], 2292 descriptors, ndescriptors * sizeof(descriptors[0])) != -1) { 2293 fprintf(fp, "{"); 2294 for (i = 0; i < ndescriptors; i++) 2295 fprintf(fp, i == 0 ? " %d" : ", %d", 2296 descriptors[i]); 2297 fprintf(fp, truncated ? ", ... }" : " }"); 2298 } else 2299 fprintf(fp, "0x%lx", args[sc->offset]); 2300 break; 2301 } 2302 case Pipe2: 2303 print_mask_arg(sysdecode_pipe2_flags, fp, args[sc->offset]); 2304 break; 2305 case CapFcntlRights: { 2306 uint32_t rights; 2307 2308 if (sc->type & OUT) { 2309 if (get_struct(pid, (void *)args[sc->offset], &rights, 2310 sizeof(rights)) == -1) { 2311 fprintf(fp, "0x%lx", args[sc->offset]); 2312 break; 2313 } 2314 } else 2315 rights = args[sc->offset]; 2316 print_mask_arg32(sysdecode_cap_fcntlrights, fp, rights); 2317 break; 2318 } 2319 case Fadvice: 2320 print_integer_arg(sysdecode_fadvice, fp, args[sc->offset]); 2321 break; 2322 case FileFlags: { 2323 fflags_t rem; 2324 2325 if (!sysdecode_fileflags(fp, args[sc->offset], &rem)) 2326 fprintf(fp, "0x%x", rem); 2327 else if (rem != 0) 2328 fprintf(fp, "|0x%x", rem); 2329 break; 2330 } 2331 case Flockop: 2332 print_mask_arg(sysdecode_flock_operation, fp, args[sc->offset]); 2333 break; 2334 case Getfsstatmode: 2335 print_integer_arg(sysdecode_getfsstat_mode, fp, 2336 args[sc->offset]); 2337 break; 2338 case Kldsymcmd: 2339 print_integer_arg(sysdecode_kldsym_cmd, fp, args[sc->offset]); 2340 break; 2341 case Kldunloadflags: 2342 print_integer_arg(sysdecode_kldunload_flags, fp, 2343 args[sc->offset]); 2344 break; 2345 case Madvice: 2346 print_integer_arg(sysdecode_madvice, fp, args[sc->offset]); 2347 break; 2348 case Socklent: 2349 fprintf(fp, "%u", (socklen_t)args[sc->offset]); 2350 break; 2351 case Sockprotocol: { 2352 const char *temp; 2353 int domain, protocol; 2354 2355 domain = args[sc->offset - 2]; 2356 protocol = args[sc->offset]; 2357 if (protocol == 0) { 2358 fputs("0", fp); 2359 } else { 2360 temp = sysdecode_socket_protocol(domain, protocol); 2361 if (temp) { 2362 fputs(temp, fp); 2363 } else { 2364 fprintf(fp, "%d", protocol); 2365 } 2366 } 2367 break; 2368 } 2369 case Sockoptlevel: 2370 print_integer_arg(sysdecode_sockopt_level, fp, 2371 args[sc->offset]); 2372 break; 2373 case Sockoptname: { 2374 const char *temp; 2375 int level, name; 2376 2377 level = args[sc->offset - 1]; 2378 name = args[sc->offset]; 2379 temp = sysdecode_sockopt_name(level, name); 2380 if (temp) { 2381 fputs(temp, fp); 2382 } else { 2383 fprintf(fp, "%d", name); 2384 } 2385 break; 2386 } 2387 case Msgflags: 2388 print_mask_arg(sysdecode_msg_flags, fp, args[sc->offset]); 2389 break; 2390 case CapRights: { 2391 cap_rights_t rights; 2392 2393 if (get_struct(pid, (void *)args[sc->offset], &rights, 2394 sizeof(rights)) != -1) { 2395 fputs("{ ", fp); 2396 sysdecode_cap_rights(fp, &rights); 2397 fputs(" }", fp); 2398 } else 2399 fprintf(fp, "0x%lx", args[sc->offset]); 2400 break; 2401 } 2402 case Acltype: 2403 print_integer_arg(sysdecode_acltype, fp, args[sc->offset]); 2404 break; 2405 case Extattrnamespace: 2406 print_integer_arg(sysdecode_extattrnamespace, fp, 2407 args[sc->offset]); 2408 break; 2409 case Minherit: 2410 print_integer_arg(sysdecode_minherit_inherit, fp, 2411 args[sc->offset]); 2412 break; 2413 case Mlockall: 2414 print_mask_arg(sysdecode_mlockall_flags, fp, args[sc->offset]); 2415 break; 2416 case Mountflags: 2417 print_mask_arg(sysdecode_mount_flags, fp, args[sc->offset]); 2418 break; 2419 case Msync: 2420 print_mask_arg(sysdecode_msync_flags, fp, args[sc->offset]); 2421 break; 2422 case Priowhich: 2423 print_integer_arg(sysdecode_prio_which, fp, args[sc->offset]); 2424 break; 2425 case Ptraceop: 2426 print_integer_arg(sysdecode_ptrace_request, fp, 2427 args[sc->offset]); 2428 break; 2429 case Quotactlcmd: 2430 if (!sysdecode_quotactl_cmd(fp, args[sc->offset])) 2431 fprintf(fp, "%#x", (int)args[sc->offset]); 2432 break; 2433 case Reboothowto: 2434 print_mask_arg(sysdecode_reboot_howto, fp, args[sc->offset]); 2435 break; 2436 case Rtpriofunc: 2437 print_integer_arg(sysdecode_rtprio_function, fp, 2438 args[sc->offset]); 2439 break; 2440 case Schedpolicy: 2441 print_integer_arg(sysdecode_scheduler_policy, fp, 2442 args[sc->offset]); 2443 break; 2444 case Schedparam: { 2445 struct sched_param sp; 2446 2447 if (get_struct(pid, (void *)args[sc->offset], &sp, 2448 sizeof(sp)) != -1) 2449 fprintf(fp, "{ %d }", sp.sched_priority); 2450 else 2451 fprintf(fp, "0x%lx", args[sc->offset]); 2452 break; 2453 } 2454 case PSig: { 2455 int sig; 2456 2457 if (get_struct(pid, (void *)args[sc->offset], &sig, 2458 sizeof(sig)) == 0) 2459 fprintf(fp, "{ %s }", strsig2(sig)); 2460 else 2461 fprintf(fp, "0x%lx", args[sc->offset]); 2462 break; 2463 } 2464 case Siginfo: { 2465 siginfo_t si; 2466 2467 if (get_struct(pid, (void *)args[sc->offset], &si, 2468 sizeof(si)) != -1) { 2469 fprintf(fp, "{ signo=%s", strsig2(si.si_signo)); 2470 decode_siginfo(fp, &si); 2471 fprintf(fp, " }"); 2472 } else 2473 fprintf(fp, "0x%lx", args[sc->offset]); 2474 break; 2475 } 2476 case Iovec: 2477 /* 2478 * Print argument as an array of struct iovec, where the next 2479 * syscall argument is the number of elements of the array. 2480 */ 2481 2482 print_iovec(fp, trussinfo, (void *)args[sc->offset], 2483 (int)args[sc->offset + 1]); 2484 break; 2485 case Sctpsndrcvinfo: { 2486 struct sctp_sndrcvinfo info; 2487 2488 if (get_struct(pid, (void *)args[sc->offset], 2489 &info, sizeof(struct sctp_sndrcvinfo)) == -1) { 2490 fprintf(fp, "0x%lx", args[sc->offset]); 2491 break; 2492 } 2493 print_sctp_sndrcvinfo(fp, sc->type & OUT, &info); 2494 break; 2495 } 2496 case Msghdr: { 2497 struct msghdr msghdr; 2498 2499 if (get_struct(pid, (void *)args[sc->offset], 2500 &msghdr, sizeof(struct msghdr)) == -1) { 2501 fprintf(fp, "0x%lx", args[sc->offset]); 2502 break; 2503 } 2504 fputs("{", fp); 2505 print_sockaddr(fp, trussinfo, msghdr.msg_name, msghdr.msg_namelen); 2506 fprintf(fp, ",%d,", msghdr.msg_namelen); 2507 print_iovec(fp, trussinfo, msghdr.msg_iov, msghdr.msg_iovlen); 2508 fprintf(fp, ",%d,", msghdr.msg_iovlen); 2509 print_cmsgs(fp, pid, sc->type & OUT, &msghdr); 2510 fprintf(fp, ",%u,", msghdr.msg_controllen); 2511 print_mask_arg(sysdecode_msg_flags, fp, msghdr.msg_flags); 2512 fputs("}", fp); 2513 break; 2514 } 2515 2516 case CloudABIAdvice: 2517 fputs(xlookup(cloudabi_advice, args[sc->offset]), fp); 2518 break; 2519 case CloudABIClockID: 2520 fputs(xlookup(cloudabi_clockid, args[sc->offset]), fp); 2521 break; 2522 case CloudABIFDSFlags: 2523 fputs(xlookup_bits(cloudabi_fdsflags, args[sc->offset]), fp); 2524 break; 2525 case CloudABIFDStat: { 2526 cloudabi_fdstat_t fds; 2527 if (get_struct(pid, (void *)args[sc->offset], &fds, sizeof(fds)) 2528 != -1) { 2529 fprintf(fp, "{ %s, ", 2530 xlookup(cloudabi_filetype, fds.fs_filetype)); 2531 fprintf(fp, "%s, ... }", 2532 xlookup_bits(cloudabi_fdflags, fds.fs_flags)); 2533 } else 2534 fprintf(fp, "0x%lx", args[sc->offset]); 2535 break; 2536 } 2537 case CloudABIFileStat: { 2538 cloudabi_filestat_t fsb; 2539 if (get_struct(pid, (void *)args[sc->offset], &fsb, sizeof(fsb)) 2540 != -1) 2541 fprintf(fp, "{ %s, %ju }", 2542 xlookup(cloudabi_filetype, fsb.st_filetype), 2543 (uintmax_t)fsb.st_size); 2544 else 2545 fprintf(fp, "0x%lx", args[sc->offset]); 2546 break; 2547 } 2548 case CloudABIFileType: 2549 fputs(xlookup(cloudabi_filetype, args[sc->offset]), fp); 2550 break; 2551 case CloudABIFSFlags: 2552 fputs(xlookup_bits(cloudabi_fsflags, args[sc->offset]), fp); 2553 break; 2554 case CloudABILookup: 2555 if ((args[sc->offset] & CLOUDABI_LOOKUP_SYMLINK_FOLLOW) != 0) 2556 fprintf(fp, "%d|LOOKUP_SYMLINK_FOLLOW", 2557 (int)args[sc->offset]); 2558 else 2559 fprintf(fp, "%d", (int)args[sc->offset]); 2560 break; 2561 case CloudABIMFlags: 2562 fputs(xlookup_bits(cloudabi_mflags, args[sc->offset]), fp); 2563 break; 2564 case CloudABIMProt: 2565 fputs(xlookup_bits(cloudabi_mprot, args[sc->offset]), fp); 2566 break; 2567 case CloudABIMSFlags: 2568 fputs(xlookup_bits(cloudabi_msflags, args[sc->offset]), fp); 2569 break; 2570 case CloudABIOFlags: 2571 fputs(xlookup_bits(cloudabi_oflags, args[sc->offset]), fp); 2572 break; 2573 case CloudABISDFlags: 2574 fputs(xlookup_bits(cloudabi_sdflags, args[sc->offset]), fp); 2575 break; 2576 case CloudABISignal: 2577 fputs(xlookup(cloudabi_signal, args[sc->offset]), fp); 2578 break; 2579 case CloudABITimestamp: 2580 fprintf(fp, "%lu.%09lus", args[sc->offset] / 1000000000, 2581 args[sc->offset] % 1000000000); 2582 break; 2583 case CloudABIULFlags: 2584 fputs(xlookup_bits(cloudabi_ulflags, args[sc->offset]), fp); 2585 break; 2586 case CloudABIWhence: 2587 fputs(xlookup(cloudabi_whence, args[sc->offset]), fp); 2588 break; 2589 2590 default: 2591 errx(1, "Invalid argument type %d\n", sc->type & ARG_MASK); 2592 } 2593 fclose(fp); 2594 return (tmp); 2595 } 2596 2597 /* 2598 * Print (to outfile) the system call and its arguments. 2599 */ 2600 void 2601 print_syscall(struct trussinfo *trussinfo) 2602 { 2603 struct threadinfo *t; 2604 const char *name; 2605 char **s_args; 2606 int i, len, nargs; 2607 2608 t = trussinfo->curthread; 2609 2610 name = t->cs.sc->name; 2611 nargs = t->cs.nargs; 2612 s_args = t->cs.s_args; 2613 2614 len = print_line_prefix(trussinfo); 2615 len += fprintf(trussinfo->outfile, "%s(", name); 2616 2617 for (i = 0; i < nargs; i++) { 2618 if (s_args[i] != NULL) 2619 len += fprintf(trussinfo->outfile, "%s", s_args[i]); 2620 else 2621 len += fprintf(trussinfo->outfile, 2622 "<missing argument>"); 2623 len += fprintf(trussinfo->outfile, "%s", i < (nargs - 1) ? 2624 "," : ""); 2625 } 2626 len += fprintf(trussinfo->outfile, ")"); 2627 for (i = 0; i < 6 - (len / 8); i++) 2628 fprintf(trussinfo->outfile, "\t"); 2629 } 2630 2631 void 2632 print_syscall_ret(struct trussinfo *trussinfo, int errorp, long *retval) 2633 { 2634 struct timespec timediff; 2635 struct threadinfo *t; 2636 struct syscall *sc; 2637 int error; 2638 2639 t = trussinfo->curthread; 2640 sc = t->cs.sc; 2641 if (trussinfo->flags & COUNTONLY) { 2642 timespecsubt(&t->after, &t->before, &timediff); 2643 timespecadd(&sc->time, &timediff, &sc->time); 2644 sc->ncalls++; 2645 if (errorp) 2646 sc->nerror++; 2647 return; 2648 } 2649 2650 print_syscall(trussinfo); 2651 fflush(trussinfo->outfile); 2652 2653 if (retval == NULL) { 2654 /* 2655 * This system call resulted in the current thread's exit, 2656 * so there is no return value or error to display. 2657 */ 2658 fprintf(trussinfo->outfile, "\n"); 2659 return; 2660 } 2661 2662 if (errorp) { 2663 error = sysdecode_abi_to_freebsd_errno(t->proc->abi->abi, 2664 retval[0]); 2665 fprintf(trussinfo->outfile, " ERR#%ld '%s'\n", retval[0], 2666 error == INT_MAX ? "Unknown error" : strerror(error)); 2667 } 2668 #ifndef __LP64__ 2669 else if (sc->ret_type == 2) { 2670 off_t off; 2671 2672 #if _BYTE_ORDER == _LITTLE_ENDIAN 2673 off = (off_t)retval[1] << 32 | retval[0]; 2674 #else 2675 off = (off_t)retval[0] << 32 | retval[1]; 2676 #endif 2677 fprintf(trussinfo->outfile, " = %jd (0x%jx)\n", (intmax_t)off, 2678 (intmax_t)off); 2679 } 2680 #endif 2681 else 2682 fprintf(trussinfo->outfile, " = %ld (0x%lx)\n", retval[0], 2683 retval[0]); 2684 } 2685 2686 void 2687 print_summary(struct trussinfo *trussinfo) 2688 { 2689 struct timespec total = {0, 0}; 2690 struct syscall *sc; 2691 int ncall, nerror; 2692 2693 fprintf(trussinfo->outfile, "%-20s%15s%8s%8s\n", 2694 "syscall", "seconds", "calls", "errors"); 2695 ncall = nerror = 0; 2696 STAILQ_FOREACH(sc, &syscalls, entries) 2697 if (sc->ncalls) { 2698 fprintf(trussinfo->outfile, "%-20s%5jd.%09ld%8d%8d\n", 2699 sc->name, (intmax_t)sc->time.tv_sec, 2700 sc->time.tv_nsec, sc->ncalls, sc->nerror); 2701 timespecadd(&total, &sc->time, &total); 2702 ncall += sc->ncalls; 2703 nerror += sc->nerror; 2704 } 2705 fprintf(trussinfo->outfile, "%20s%15s%8s%8s\n", 2706 "", "-------------", "-------", "-------"); 2707 fprintf(trussinfo->outfile, "%-20s%5jd.%09ld%8d%8d\n", 2708 "", (intmax_t)total.tv_sec, total.tv_nsec, ncall, nerror); 2709 } 2710