static void print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type, const void *cmsg_data, const size_t data_len) { const unsigned int utype = cmsg_type; switch (cmsg_level) { case SOL_SOCKET: printxval(scmvals, cmsg_type, "SCM_???"); if (utype < ARRAY_SIZE(cmsg_socket_printers) && cmsg_socket_printers[utype].printer && data_len >= cmsg_socket_printers[utype].min_len) { tprints(", cmsg_data="); cmsg_socket_printers[utype].printer(tcp, cmsg_data, data_len); } break; case SOL_IP: printxval(ip_cmsg_types, cmsg_type, "IP_???"); if (utype < ARRAY_SIZE(cmsg_ip_printers) && cmsg_ip_printers[utype].printer && data_len >= cmsg_ip_printers[utype].min_len) { tprints(", cmsg_data="); cmsg_ip_printers[utype].printer(tcp, cmsg_data, data_len); } break; default: tprintf("%#x", cmsg_type); } }
int sys_socket(struct tcb *tcp) { if (entering(tcp)) { printxval(domains, tcp->u_arg[0], "PF_???"); tprints(", "); tprint_sock_type(tcp, tcp->u_arg[1]); tprints(", "); switch (tcp->u_arg[0]) { case PF_INET: #ifdef PF_INET6 case PF_INET6: #endif printxval(inet_protocols, tcp->u_arg[2], "IPPROTO_???"); break; #ifdef PF_IPX case PF_IPX: /* BTW: I don't believe this.. */ tprints("["); printxval(domains, tcp->u_arg[2], "PF_???"); tprints("]"); break; #endif /* PF_IPX */ #ifdef PF_NETLINK case PF_NETLINK: printxval(netlink_protocols, tcp->u_arg[2], "NETLINK_???"); break; #endif default: tprintf("%lu", tcp->u_arg[2]); break; } } return 0; }
static void printflock(struct tcb *tcp, long addr, int getlk) { struct flock fl; int r; #if SUPPORTED_PERSONALITIES > 1 if ( # if SIZEOF_OFF_T > SIZEOF_LONG current_personality > 0 && #endif current_wordsize != sizeof(fl.l_start)) { if (current_wordsize == 4) { /* 32-bit x86 app on x86_64 and similar cases */ struct { short int l_type; short int l_whence; int32_t l_start; /* off_t */ int32_t l_len; /* off_t */ int32_t l_pid; /* pid_t */ } fl32; r = umove(tcp, addr, &fl32); if (r >= 0) { fl.l_type = fl32.l_type; fl.l_whence = fl32.l_whence; fl.l_start = fl32.l_start; fl.l_len = fl32.l_len; fl.l_pid = fl32.l_pid; } } else { /* let people know we have a problem here */ tprintf("<decode error: unsupported wordsize %d>", current_wordsize); return; } } else #endif { r = umove(tcp, addr, &fl); } if (r < 0) { tprints("{...}"); return; } tprints("{type="); printxval(lockfcmds, fl.l_type, "F_???"); tprints(", whence="); printxval(whence_codes, fl.l_whence, "SEEK_???"); #if SIZEOF_OFF_T > SIZEOF_LONG tprintf(", start=%lld, len=%lld", fl.l_start, fl.l_len); #else tprintf(", start=%ld, len=%ld", fl.l_start, fl.l_len); #endif if (getlk) tprintf(", pid=%lu}", (unsigned long) fl.l_pid); else tprints("}"); }
int sys_quotactl(struct tcb *tcp) { /* * The Linux kernel only looks at the low 32 bits of command and id * arguments, but on some 64-bit architectures (s390x) this word * will have been sign-extended when we see it. The high 1 bits * don't mean anything, so don't confuse the output with them. */ u_int32_t qcmd = tcp->u_arg[0]; u_int32_t cmd = QCMD_CMD(qcmd); u_int32_t type = QCMD_TYPE(qcmd); u_int32_t id = tcp->u_arg[2]; if (!verbose(tcp)) return printargs(tcp); if (entering(tcp)) { printxval(quotacmds, cmd, "Q_???"); tprintf("|"); printxval(quotatypes, type, "???QUOTA"); tprintf(", "); printstr(tcp, tcp->u_arg[1], -1); tprintf(", "); switch (cmd) { case Q_V1_QUOTAON: case Q_QUOTAON: printxval(quota_formats, id, "QFMT_VFS_???"); break; case Q_V1_GETQUOTA: case Q_V2_GETQUOTA: case Q_GETQUOTA: case Q_V1_SETQUOTA: case Q_V2_SETQUOTA: case Q_V1_SETUSE: case Q_V2_SETUSE: case Q_SETQLIM: case Q_SETQUOTA: case Q_XGETQUOTA: case Q_XSETQLIM: tprintf("%u", id); break; default: tprintf("%#lx", tcp->u_arg[2]); break; } tprintf(", "); } else { if (!tcp->u_arg[3]) tprintf("NULL"); else decode_cmd_data(tcp, cmd, tcp->u_arg[3]); } return 0; }
static void print_cmsg_type_data(struct tcb *tcp, const int cmsg_level, const int cmsg_type, const void *cmsg_data, const size_t data_len) { switch (cmsg_level) { case SOL_SOCKET: printxval(scmvals, cmsg_type, "SCM_???"); switch (cmsg_type) { case SCM_RIGHTS: print_scm_rights(tcp, cmsg_data, data_len); break; case SCM_CREDENTIALS: print_scm_creds(tcp, cmsg_data, data_len); break; case SCM_SECURITY: print_scm_security(tcp, cmsg_data, data_len); break; } break; case SOL_IP: printxval(ip_cmsg_types, cmsg_type, "IP_???"); switch (cmsg_type) { case IP_PKTINFO: print_cmsg_ip_pktinfo(tcp, cmsg_data, data_len); break; case IP_TTL: print_cmsg_ip_ttl(tcp, cmsg_data, data_len); break; case IP_TOS: print_cmsg_ip_tos(tcp, cmsg_data, data_len); break; case IP_RECVOPTS: case IP_RETOPTS: print_cmsg_ip_opts(tcp, cmsg_data, data_len); break; case IP_RECVERR: print_cmsg_ip_recverr(tcp, cmsg_data, data_len); break; case IP_ORIGDSTADDR: print_cmsg_ip_origdstaddr(tcp, cmsg_data, data_len); break; case IP_CHECKSUM: print_cmsg_ip_checksum(tcp, cmsg_data, data_len); break; case SCM_SECURITY: print_scm_security(tcp, cmsg_data, data_len); break; } break; default: tprintf("%u", cmsg_type); } }
static void printcmsghdr(struct tcb *tcp, unsigned long addr, unsigned long len) { struct cmsghdr *cmsg = len < sizeof(struct cmsghdr) ? NULL : malloc(len); if (cmsg == NULL || umoven(tcp, addr, len, (char *) cmsg) < 0) { tprintf(", msg_control=%#lx", addr); free(cmsg); return; } tprintf(", {cmsg_len=%u, cmsg_level=", (unsigned) cmsg->cmsg_len); printxval(socketlayers, cmsg->cmsg_level, "SOL_???"); tprints(", cmsg_type="); if (cmsg->cmsg_level == SOL_SOCKET) { unsigned long cmsg_len; printxval(scmvals, cmsg->cmsg_type, "SCM_???"); cmsg_len = (len < cmsg->cmsg_len) ? len : cmsg->cmsg_len; if (cmsg->cmsg_type == SCM_RIGHTS && CMSG_LEN(sizeof(int)) <= cmsg_len) { int *fds = (int *) CMSG_DATA(cmsg); int first = 1; tprints(", {"); while ((char *) fds < ((char *) cmsg + cmsg_len)) { if (!first) tprints(", "); printfd(tcp, *fds++); first = 0; } tprints("}}"); free(cmsg); return; } if (cmsg->cmsg_type == SCM_CREDENTIALS && CMSG_LEN(sizeof(struct ucred)) <= cmsg_len) { struct ucred *uc = (struct ucred *) CMSG_DATA(cmsg); tprintf("{pid=%ld, uid=%ld, gid=%ld}}", (long)uc->pid, (long)uc->uid, (long)uc->gid); free(cmsg); return; } } free(cmsg); tprints(", ...}"); }
/* fcntl/lockf */ static void printflock(struct tcb *tcp, long addr, int getlk) { struct flock fl; #if SUPPORTED_PERSONALITIES > 1 if (personality_wordsize[current_personality] != sizeof(fl.l_start)) { if (personality_wordsize[current_personality] == 4) { /* 32-bit x86 app on x86_64 and similar cases */ struct { short int l_type; short int l_whence; int32_t l_start; /* off_t */ int32_t l_len; /* off_t */ int32_t l_pid; /* pid_t */ } fl32; if (umove(tcp, addr, &fl32) < 0) { tprintf("{...}"); return; } fl.l_type = fl32.l_type; fl.l_whence = fl32.l_whence; fl.l_start = fl32.l_start; fl.l_len = fl32.l_len; fl.l_pid = fl32.l_pid; } else { /* let people know we have a problem here */ tprintf("{ <decode error: unsupported wordsize %d> }", personality_wordsize[current_personality]); return; } } else #endif { if (umove(tcp, addr, &fl) < 0) { tprintf("{...}"); return; } } tprintf("{type="); printxval(lockfcmds, fl.l_type, "F_???"); tprintf(", whence="); printxval(whence, fl.l_whence, "SEEK_???"); tprintf(", start=%ld, len=%ld", fl.l_start, fl.l_len); if (getlk) tprintf(", pid=%lu}", (unsigned long) fl.l_pid); else tprintf("}"); }
static void decode_nand_oobinfo(struct tcb *const tcp, const kernel_ulong_t addr) { struct nand_oobinfo ninfo; unsigned int i, j; tprints(", "); if (umove_or_printaddr(tcp, addr, &ninfo)) return; tprints("{useecc="); printxval(mtd_nandecc_options, ninfo.useecc, "MTD_NANDECC_???"); tprintf(", eccbytes=%#x", ninfo.eccbytes); tprints(", oobfree={"); for (i = 0; i < ARRAY_SIZE(ninfo.oobfree); ++i) { if (i) tprints("}, "); tprints("{"); for (j = 0; j < ARRAY_SIZE(ninfo.oobfree[0]); ++j) { if (j) tprints(", "); tprintf("%#x", ninfo.oobfree[i][j]); } } tprints("}}, eccpos={"); for (i = 0; i < ARRAY_SIZE(ninfo.eccpos); ++i) { if (i) tprints(", "); tprintf("%#x", ninfo.eccpos[i]); } tprints("}"); }
int sys_personality(struct tcb *tcp) { if (entering(tcp)) printxval(personality_options, tcp->u_arg[0], "PER_???"); return 0; }
int sys_or1k_atomic(struct tcb *tcp) { if (entering(tcp)) { printxval(atomic_ops, tcp->u_arg[0], "???"); switch(tcp->u_arg[0]) { case OR1K_ATOMIC_SWAP: tprintf(", 0x%lx, 0x%lx", tcp->u_arg[1], tcp->u_arg[2]); break; case OR1K_ATOMIC_CMPXCHG: tprintf(", 0x%lx, %#lx, %#lx", tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3]); break; case OR1K_ATOMIC_XCHG: case OR1K_ATOMIC_ADD: case OR1K_ATOMIC_AND: case OR1K_ATOMIC_OR: case OR1K_ATOMIC_UMAX: case OR1K_ATOMIC_UMIN: tprintf(", 0x%lx, %#lx", tcp->u_arg[1], tcp->u_arg[2]); break; case OR1K_ATOMIC_DECPOS: tprintf(", 0x%lx", tcp->u_arg[1]); break; default: break; } } return RVAL_HEX; }
int sys_epoll_ctl(struct tcb *tcp) { if (entering(tcp)) { printfd(tcp, tcp->u_arg[0]); tprints(", "); printxval(epollctls, tcp->u_arg[1], "EPOLL_CTL_???"); tprints(", "); printfd(tcp, tcp->u_arg[2]); tprints(", "); if (tcp->u_arg[3] == 0) tprints("NULL"); else { #ifdef HAVE_SYS_EPOLL_H struct epoll_event ev; if ( #ifdef EPOLL_CTL_DEL (tcp->u_arg[1] != EPOLL_CTL_DEL) && #endif umove(tcp, tcp->u_arg[3], &ev) == 0) print_epoll_event(&ev); else #endif tprintf("%lx", tcp->u_arg[3]); } } return 0; }
static int mtslots_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg) { tprints(", "); const size_t size = _IOC_SIZE(code) / sizeof(int); if (!size) { printaddr(arg); return 1; } int buffer[size]; if (umove_or_printaddr(tcp, arg, &buffer)) return 1; tprints("{code="); printxval(evdev_mtslots, buffer[0], "ABS_MT_???"); tprints(", values=["); unsigned int i; for (i = 1; i < ARRAY_SIZE(buffer); i++) tprintf("%s%d", i > 1 ? ", " : "", buffer[i]); tprints("]}"); return 1; }
static void decode_termios(struct tcb *const tcp, const kernel_ulong_t addr) { struct termios tios; tprints(", "); if (umove_or_printaddr(tcp, addr, &tios)) return; if (abbrev(tcp)) { tprints("{"); printxval(baud_options, tios.c_cflag & CBAUD, "B???"); tprintf(" %sopost %sisig %sicanon %secho ...}", (tios.c_oflag & OPOST) ? "" : "-", (tios.c_lflag & ISIG) ? "" : "-", (tios.c_lflag & ICANON) ? "" : "-", (tios.c_lflag & ECHO) ? "" : "-"); return; } tprintf("{c_iflags=%#lx, c_oflags=%#lx, ", (long) tios.c_iflag, (long) tios.c_oflag); tprintf("c_cflags=%#lx, c_lflags=%#lx, ", (long) tios.c_cflag, (long) tios.c_lflag); tprintf("c_line=%u, ", tios.c_line); if (!(tios.c_lflag & ICANON)) tprintf("c_cc[VMIN]=%d, c_cc[VTIME]=%d, ", tios.c_cc[VMIN], tios.c_cc[VTIME]); tprints("c_cc="); print_quoted_string((char *) tios.c_cc, NCCS, QUOTE_FORCE_HEX); tprints("}"); }
int sys_rt_sigprocmask(struct tcb *tcp) { sigset_t sigset; /* Note: arg[3] is the length of the sigset. */ if (entering(tcp)) { printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); tprints(", "); if (!tcp->u_arg[1]) tprints("NULL, "); else if (copy_sigset_len(tcp, tcp->u_arg[1], &sigset, tcp->u_arg[3]) < 0) tprintf("%#lx, ", tcp->u_arg[1]); else { printsigmask(&sigset, 1); tprints(", "); } } else { if (!tcp->u_arg[2]) tprints("NULL"); else if (syserror(tcp)) tprintf("%#lx", tcp->u_arg[2]); else if (copy_sigset_len(tcp, tcp->u_arg[2], &sigset, tcp->u_arg[3]) < 0) tprints("[?]"); else printsigmask(&sigset, 1); tprintf(", %lu", tcp->u_arg[3]); } return 0; }
int sys_kexec_load(struct tcb *tcp) { unsigned long n; if (exiting(tcp)) return 0; /* entry, nr_segments */ tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]); /* segments */ print_kexec_segments(tcp, tcp->u_arg[2], tcp->u_arg[1]); tprints(", "); /* flags */ n = tcp->u_arg[3]; printxval(kexec_arch_values, n & KEXEC_ARCH_MASK, "KEXEC_ARCH_???"); n &= ~KEXEC_ARCH_MASK; if (n) { tprints("|"); printflags(kexec_load_flags, n, "KEXEC_???"); } return 0; }
static void print_sched_attr(struct tcb *const tcp, const kernel_ulong_t addr, unsigned int size) { struct { uint32_t size; uint32_t sched_policy; uint64_t sched_flags; uint32_t sched_nice; uint32_t sched_priority; uint64_t sched_runtime; uint64_t sched_deadline; uint64_t sched_period; } attr = {}; if (size > sizeof(attr)) size = sizeof(attr); if (umoven_or_printaddr(tcp, addr, size, &attr)) return; tprintf("{size=%u, sched_policy=", attr.size); printxval(schedulers, attr.sched_policy, "SCHED_???"); tprints(", sched_flags="); printflags64(sched_flags, attr.sched_flags, "SCHED_FLAG_???"); tprintf(", sched_nice=%d", attr.sched_nice); tprintf(", sched_priority=%u", attr.sched_priority); tprintf(", sched_runtime=%" PRIu64, attr.sched_runtime); tprintf(", sched_deadline=%" PRIu64, attr.sched_deadline); tprintf(", sched_period=%" PRIu64 "}", attr.sched_period); }
static int print_sg_io_v3_req(struct tcb *tcp, const long arg) { struct sg_io_hdr sg_io; if (umove(tcp, arg, &sg_io) < 0) { tprints("???}"); return RVAL_DECODED | 1; } printxval(sg_io_dxfer_direction, sg_io.dxfer_direction, "SG_DXFER_???"); tprintf(", cmd[%u]=", sg_io.cmd_len); print_sg_io_buffer(tcp, (unsigned long) sg_io.cmdp, sg_io.cmd_len); tprintf(", mx_sb_len=%d", sg_io.mx_sb_len); tprintf(", iovec_count=%d", sg_io.iovec_count); tprintf(", dxfer_len=%u", sg_io.dxfer_len); tprintf(", timeout=%u", sg_io.timeout); tprintf(", flags=%#x", sg_io.flags); if (sg_io.dxfer_direction == SG_DXFER_TO_DEV || sg_io.dxfer_direction == SG_DXFER_TO_FROM_DEV) { tprintf(", data[%u]=", sg_io.dxfer_len); if (sg_io.iovec_count) tprint_iov_upto(tcp, sg_io.iovec_count, (unsigned long) sg_io.dxferp, 1, sg_io.dxfer_len); else print_sg_io_buffer(tcp, (unsigned long) sg_io.dxferp, sg_io.dxfer_len); } return 1; }
static int print_mmap(struct tcb *tcp, long *u_arg, unsigned long long offset) { if (entering(tcp)) { /* addr */ if (!u_arg[0]) tprints("NULL, "); else tprintf("%#lx, ", u_arg[0]); /* len */ tprintf("%lu, ", u_arg[1]); /* prot */ printflags(mmap_prot, u_arg[2], "PROT_???"); tprints(", "); /* flags */ #ifdef MAP_TYPE printxval(mmap_flags, u_arg[3] & MAP_TYPE, "MAP_???"); addflags(mmap_flags, u_arg[3] & ~MAP_TYPE); #else printflags(mmap_flags, u_arg[3], "MAP_???"); #endif tprints(", "); /* fd */ printfd(tcp, u_arg[4]); /* offset */ tprintf(", %#llx", offset); } return RVAL_HEX; }
static int keycode_V2_ioctl(struct tcb *const tcp, const kernel_ulong_t arg) { tprints(", "); struct input_keymap_entry ike; if (umove_or_printaddr(tcp, arg, &ike)) return 1; tprintf("{flags=%" PRIu8 ", len=%" PRIu8 ", ", ike.flags, ike.len); if (!abbrev(tcp)) { unsigned int i; tprintf("index=%" PRIu16 ", keycode=", ike.index); printxval(evdev_keycode, ike.keycode, "KEY_???"); tprints(", scancode=["); for (i = 0; i < ARRAY_SIZE(ike.scancode); i++) { if (i > 0) tprints(", "); tprintf("%" PRIx8, ike.scancode[i]); } tprints("]"); } else { tprints("..."); } tprints("}"); return 1; }
int sys_sigprocmask(struct tcb *tcp) { #ifdef ALPHA sigset_t ss; if (entering(tcp)) { /* * Alpha/OSF is different: it doesn't pass in two pointers, * but rather passes in the new bitmask as an argument and * then returns the old bitmask. This "works" because we * only have 64 signals to worry about. If you want more, * use of the rt_sigprocmask syscall is required. * Alpha: * old = osf_sigprocmask(how, new); * Everyone else: * ret = sigprocmask(how, &new, &old, ...); */ memcpy(&ss, &tcp->u_arg[1], sizeof(long)); printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); tprints(", "); printsigmask(&ss, 0); } else if (!syserror(tcp)) { memcpy(&ss, &tcp->u_rval, sizeof(long)); tcp->auxstr = sprintsigmask("old mask ", &ss, 0); return RVAL_HEX | RVAL_STR; } #else /* !ALPHA */ if (entering(tcp)) { printxval(sigprocmaskcmds, tcp->u_arg[0], "SIG_???"); tprints(", "); print_sigset(tcp, tcp->u_arg[1], 0); tprints(", "); } else { if (!tcp->u_arg[2]) tprints("NULL"); else if (syserror(tcp)) tprintf("%#lx", tcp->u_arg[2]); else print_sigset(tcp, tcp->u_arg[2], 0); } #endif /* !ALPHA */ return 0; }
static int keyctl_set_reqkey_keyring(struct tcb *tcp, int reqkey) { if (entering(tcp)) { tprints(", "); printxval(key_reqkeys, reqkey, "KEY_REQKEY_DEFL_???"); } return 0; }
int sys_set_mempolicy(struct tcb *tcp) { if (entering(tcp)) { printxval(policies, tcp->u_arg[0], "MPOL_???"); get_nodes(tcp, tcp->u_arg[1], tcp->u_arg[2], 0); } return 0; }
int sys_madvise(struct tcb *tcp) { if (entering(tcp)) { tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]); printxval(madvise_cmds, tcp->u_arg[2], "MADV_???"); } return 0; }
int sys_setpriority(struct tcb *tcp) { if (entering(tcp)) { printxval(priorities, tcp->u_arg[0], "PRIO_???"); tprintf(", %lu, %ld", tcp->u_arg[1], tcp->u_arg[2]); } return 0; }
int sys_setrlimit(struct tcb *tcp) { if (entering(tcp)) { printxval(resources, tcp->u_arg[0], "RLIMIT_???"); tprints(", "); decode_rlimit(tcp, tcp->u_arg[1]); } return 0; }
static void decode_bpf_code(uint16_t code) { uint16_t i = code & ~BPF_CLASS(code); printxval(bpf_class, BPF_CLASS(code), "BPF_???"); switch (BPF_CLASS(code)) { case BPF_LD: case BPF_LDX: tprints(" | "); printxval(bpf_size, BPF_SIZE(code), "BPF_???"); tprints(" | "); printxval(bpf_mode, BPF_MODE(code), "BPF_???"); break; case BPF_ST: case BPF_STX: if (i) tprintf(" | %#x /* %s */", i, "BPF_???"); break; case BPF_ALU: tprints(" | "); printxval(bpf_src, BPF_SRC(code), "BPF_???"); tprints(" | "); printxval(bpf_op_alu, BPF_OP(code), "BPF_???"); break; case BPF_JMP: tprints(" | "); printxval(bpf_src, BPF_SRC(code), "BPF_???"); tprints(" | "); printxval(bpf_op_jmp, BPF_OP(code), "BPF_???"); break; case BPF_RET: tprints(" | "); printxval(bpf_rval, BPF_RVAL(code), "BPF_???"); i &= ~BPF_RVAL(code); if (i) tprintf(" | %#x /* %s */", i, "BPF_???"); break; case BPF_MISC: tprints(" | "); printxval(bpf_miscop, BPF_MISCOP(code), "BPF_???"); i &= ~BPF_MISCOP(code); if (i) tprintf(" | %#x /* %s */", i, "BPF_???"); break; } }
static void printflock64(struct tcb *tcp, long addr, int getlk) { struct flock64 fl; if (umove(tcp, addr, &fl) < 0) { tprints("{...}"); return; } tprints("{type="); printxval(lockfcmds, fl.l_type, "F_???"); tprints(", whence="); printxval(whence_codes, fl.l_whence, "SEEK_???"); tprintf(", start=%lld, len=%lld", (long long) fl.l_start, (long long) fl.l_len); if (getlk) tprintf(", pid=%lu}", (unsigned long) fl.l_pid); else tprints("}"); }
int sys_shutdown(struct tcb *tcp) { if (entering(tcp)) { printfd(tcp, tcp->u_arg[0]); tprints(", "); printxval(shutdown_modes, tcp->u_arg[1], "SHUT_???"); } return 0; }
static int printstatus(int status) { int exited = 0; /* * Here is a tricky presentation problem. This solution * is still not entirely satisfactory but since there * are no wait status constructors it will have to do. */ if (WIFSTOPPED(status)) { int sig = WSTOPSIG(status); tprintf("[{WIFSTOPPED(s) && WSTOPSIG(s) == %s%s}", signame(sig & 0x7f), sig & 0x80 ? " | 0x80" : ""); status &= ~W_STOPCODE(sig); } else if (WIFSIGNALED(status)) { tprintf("[{WIFSIGNALED(s) && WTERMSIG(s) == %s%s}", signame(WTERMSIG(status)), WCOREDUMP(status) ? " && WCOREDUMP(s)" : ""); status &= ~(W_EXITCODE(0, WTERMSIG(status)) | WCOREFLAG); } else if (WIFEXITED(status)) { tprintf("[{WIFEXITED(s) && WEXITSTATUS(s) == %d}", WEXITSTATUS(status)); exited = 1; status &= ~W_EXITCODE(WEXITSTATUS(status), 0); } #ifdef WIFCONTINUED else if (WIFCONTINUED(status)) { tprints("[{WIFCONTINUED(s)}"); status &= ~W_CONTINUED; } #endif else { tprintf("[%#x]", status); return 0; } if (status) { unsigned int event = (unsigned int) status >> 16; if (event) { tprints(" | "); printxval(ptrace_events, event, "PTRACE_EVENT_???"); tprints(" << 16"); status &= 0xffff; } if (status) tprintf(" | %#x", status); } tprints("]"); return exited; }
int sys_sram_alloc(struct tcb *tcp) { if (entering(tcp)) { /* size */ tprintf("%lu, ", tcp->u_arg[0]); /* flags */ printxval(sram_alloc_flags, tcp->u_arg[1], "???_SRAM"); } return 1; }