static void btrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key, uint64_t buf_addr, uint64_t buf_size, bool print_size) { if (entering(tcp)) { tprintf("{key={tree_id="); btrfs_print_objectid(key->tree_id); if (key->min_objectid != BTRFS_FIRST_FREE_OBJECTID || !abbrev(tcp)) { tprints(", min_objectid="); btrfs_print_objectid(key->min_objectid); } if (key->max_objectid != BTRFS_LAST_FREE_OBJECTID || !abbrev(tcp)) { tprints(", max_objectid="); btrfs_print_objectid(key->max_objectid); } print_key_value(tcp, key, min_offset); print_key_value(tcp, key, max_offset); print_key_value(tcp, key, min_transid); print_key_value(tcp, key, max_transid); tprints(", min_type="); btrfs_print_key_type(key->min_type); tprints(", max_type="); btrfs_print_key_type(key->max_type); tprintf(", nr_items=%u}", key->nr_items); if (print_size) tprintf(", buf_size=%" PRIu64, buf_size); tprints("}"); } else { tprintf("{key={nr_items=%u}", key->nr_items); if (print_size) tprintf(", buf_size=%" PRIu64, buf_size); tprints(", buf="); if (abbrev(tcp)) tprints("..."); else { struct btrfs_ioctl_search_header sh; print_array(tcp, buf_addr, key->nr_items, &sh, sizeof(sh), umoven_or_printaddr, print_btrfs_ioctl_search_header, 0); } tprints("}"); } }
static void tprint_sembuf(struct tcb *tcp, long addr, unsigned long count) { unsigned long i, max_count; if (abbrev(tcp)) max_count = (max_strlen < count) ? max_strlen : count; else max_count = count; if (!max_count) { tprintf("%#lx, %lu", addr, count); return; } for (i = 0; i < max_count; ++i) { struct sembuf sb; if (i) tprints(", "); if (umove(tcp, addr + i * sizeof(struct sembuf), &sb) < 0) { if (i) { tprints("{???}"); break; } else { tprintf("%#lx, %lu", addr, count); return; } } else { if (!i) tprints("{"); tprintf("{%u, %d, ", sb.sem_num, sb.sem_op); printflags(semop_flags, sb.sem_flg, "SEM_???"); tprints("}"); } } if (i < max_count || max_count < count) tprints(", ..."); tprintf("}, %lu", count); }
int sys_sigsetmask(struct tcb *tcp) { if (entering(tcp)) { tprints(sprintsigmask_long("", tcp->u_arg[0])); } else if (!syserror(tcp)) { tcp->auxstr = sprintsigmask_long("old mask ", tcp->u_rval); return RVAL_HEX | RVAL_STR; } return 0; }
static int do_eventfd(struct tcb *tcp, int flags_arg) { if (entering(tcp)) { tprintf("%lu", tcp->u_arg[0]); if (flags_arg >= 0) { tprints(", "); printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); } } return 0; }
static int do_pipe(struct tcb *tcp, int flags_arg) { if (exiting(tcp)) { decode_pair_fd(tcp, tcp->u_arg[0]); if (flags_arg >= 0) { tprints(", "); printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???"); } } return 0; }
int sys_setsockopt(struct tcb *tcp) { if (entering(tcp)) { printfd(tcp, tcp->u_arg[0]); tprints(", "); printsockopt(tcp, tcp->u_arg[1], tcp->u_arg[2], tcp->u_arg[3], tcp->u_arg[4]); tprintf(", %lu", tcp->u_arg[4]); } return 0; }
static void printicmpfilter(struct tcb *tcp, long addr) { struct icmp_filter filter; if (!addr) { tprints("NULL"); return; } if (syserror(tcp) || !verbose(tcp)) { tprintf("%#lx", addr); return; } if (umove(tcp, addr, &filter) < 0) { tprints("{...}"); return; } tprints("~("); printflags(icmpfilterflags, ~filter.data, "ICMP_???"); tprints(")"); }
static void decode_erase_info_user64(struct tcb *const tcp, const kernel_ulong_t addr) { struct erase_info_user64 einfo64; tprints(", "); if (umove_or_printaddr(tcp, addr, &einfo64)) return; tprintf("{start=%#" PRIx64 ", length=%#" PRIx64 "}", (uint64_t) einfo64.start, (uint64_t) einfo64.length); }
static void decode_mtd_ecc_stats(struct tcb *const tcp, const kernel_ulong_t addr) { struct mtd_ecc_stats es; tprints(", "); if (umove_or_printaddr(tcp, addr, &es)) return; tprintf("{corrected=%#x, failed=%#x, badblocks=%#x, bbtblocks=%#x}", es.corrected, es.failed, es.badblocks, es.bbtblocks); }
static void decode_otp_info(struct tcb *const tcp, const kernel_ulong_t addr) { struct otp_info oinfo; tprints(", "); if (umove_or_printaddr(tcp, addr, &oinfo)) return; tprintf("{start=%#x, length=%#x, locked=%u}", oinfo.start, oinfo.length, oinfo.locked); }
static void print_mreq(struct tcb *tcp, long addr, unsigned int len) { struct ip_mreq mreq; if (len < sizeof(mreq)) { printstr(tcp, addr, len); return; } if (umove(tcp, addr, &mreq) < 0) { tprintf("%#lx", addr); return; } tprints("{imr_multiaddr=inet_addr("); print_quoted_string(inet_ntoa(mreq.imr_multiaddr), 16, QUOTE_0_TERMINATED); tprints("), imr_interface=inet_addr("); print_quoted_string(inet_ntoa(mreq.imr_interface), 16, QUOTE_0_TERMINATED); tprints(")}"); }
int sys_getrlimit(struct tcb *tcp) { if (entering(tcp)) { printxval(resources, tcp->u_arg[0], "RLIMIT_???"); tprints(", "); } else { decode_rlimit(tcp, tcp->u_arg[1]); } return 0; }
int sys_epoll_pwait(struct tcb *tcp) { epoll_wait_common(tcp); if (exiting(tcp)) { tprints(", "); /* NB: kernel requires arg[5] == NSIG / 8 */ print_sigset_addr_len(tcp, tcp->u_arg[4], tcp->u_arg[5]); tprintf(", %lu", tcp->u_arg[5]); } return 0; }
static void print_scm_rights(struct tcb *tcp, const void *cmsg_data, const size_t data_len) { const int *fds = cmsg_data; const size_t nfds = data_len / sizeof(*fds); size_t i; tprints("["); for (i = 0; i < nfds; ++i) { if (i) tprints(", "); if (abbrev(tcp) && i >= max_strlen) { tprints("..."); break; } printfd(tcp, fds[i]); } tprints("]"); }
int osf_statfs(struct tcb *tcp) { if (entering(tcp)) { printpath(tcp, tcp->u_arg[0]); tprints(", "); } else { printstatfs(tcp, tcp->u_arg[1]); tprintf(", %lu", tcp->u_arg[2]); } return 0; }
int sys_mbind(struct tcb *tcp) { if (entering(tcp)) { tprintf("%#lx, %lu, ", tcp->u_arg[0], tcp->u_arg[1]); printxval(policies, tcp->u_arg[2], "MPOL_???"); get_nodes(tcp, tcp->u_arg[3], tcp->u_arg[4], 0); tprints(", "); printflags(mbindflags, tcp->u_arg[5], "MPOL_???"); } return 0; }
int sys_write(struct tcb *tcp) { if (entering(tcp)) { printfd(tcp, tcp->u_arg[0]); tprints(", "); printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); dump_bytes(tcp, tcp->u_arg[1], tcp->u_arg[2]); tprintf(", %lu", tcp->u_arg[2]); } return 0; }
void print_loff_t(struct tcb *tcp, long addr) { loff_t offset; if (!addr) tprints("NULL"); else if (umove(tcp, addr, &offset) < 0) tprintf("%#lx", addr); else tprintf("[%llu]", (unsigned long long int) offset); }
int sys_ppoll(struct tcb *tcp) { int rc = decode_poll(tcp, tcp->u_arg[2]); if (entering(tcp)) { print_timespec(tcp, tcp->u_arg[2]); tprints(", "); print_sigset(tcp, tcp->u_arg[3], 0); tprintf(", %lu", tcp->u_arg[4]); } return rc; }
int sys_rt_sigsuspend(struct tcb *tcp) { if (entering(tcp)) { sigset_t sigm; if (copy_sigset_len(tcp, tcp->u_arg[0], &sigm, tcp->u_arg[1]) < 0) tprints("[?]"); else printsigmask(&sigm, 1); } return 0; }
void print_sigset(struct tcb *tcp, long addr, int rt) { sigset_t ss; if (!addr) tprints("NULL"); else if (copy_sigset(tcp, addr, &ss) < 0) tprintf("%#lx", addr); else printsigmask(&ss, rt); }
static void print_scm_rights(struct tcb *tcp, const void *cmsg_data, const size_t data_len) { const int *fds = cmsg_data; const char *end = (const char *) cmsg_data + data_len; bool seen = false; if (sizeof(*fds) > data_len) return; tprints(", ["); while ((const char *) fds < end) { if (seen) tprints(", "); else seen = true; printfd(tcp, *fds++); } tprints("]"); }
int sys_sigaltstack(struct tcb *tcp) { if (entering(tcp)) { print_stack_t(tcp, tcp->u_arg[0]); } else { tprints(", "); print_stack_t(tcp, tcp->u_arg[1]); } return 0; }
static int keyctl_reject_key(struct tcb *tcp, key_serial_t id1, unsigned timeout, unsigned error, key_serial_t id2) { if (entering(tcp)) { tprints(", "); print_keyring_serial_number(id1); tprintf(", %u, %u, ", timeout, error); print_keyring_serial_number(id2); } return 0; }
static bool decode_rtnl_link_stats(struct tcb *const tcp, const kernel_ulong_t addr, const unsigned int len, const void *const opaque_data) { struct rtnl_link_stats st; const unsigned int min_size = offsetofend(struct rtnl_link_stats, tx_compressed); const unsigned int def_size = sizeof(st); const unsigned int size = (len >= def_size) ? def_size : ((len == min_size) ? min_size : 0); if (!size) return false; if (!umoven_or_printaddr(tcp, addr, size, &st)) { PRINT_FIELD_U("{", st, rx_packets); PRINT_FIELD_U(", ", st, tx_packets); PRINT_FIELD_U(", ", st, rx_bytes); PRINT_FIELD_U(", ", st, tx_bytes); PRINT_FIELD_U(", ", st, rx_errors); PRINT_FIELD_U(", ", st, tx_errors); PRINT_FIELD_U(", ", st, rx_dropped); PRINT_FIELD_U(", ", st, tx_dropped); PRINT_FIELD_U(", ", st, multicast); PRINT_FIELD_U(", ", st, collisions); PRINT_FIELD_U(", ", st, rx_length_errors); PRINT_FIELD_U(", ", st, rx_over_errors); PRINT_FIELD_U(", ", st, rx_crc_errors); PRINT_FIELD_U(", ", st, rx_frame_errors); PRINT_FIELD_U(", ", st, rx_fifo_errors); PRINT_FIELD_U(", ", st, rx_missed_errors); PRINT_FIELD_U(", ", st, tx_aborted_errors); PRINT_FIELD_U(", ", st, tx_carrier_errors); PRINT_FIELD_U(", ", st, tx_fifo_errors); PRINT_FIELD_U(", ", st, tx_heartbeat_errors); PRINT_FIELD_U(", ", st, tx_window_errors); PRINT_FIELD_U(", ", st, rx_compressed); PRINT_FIELD_U(", ", st, tx_compressed); #ifdef HAVE_STRUCT_RTNL_LINK_STATS_RX_NOHANDLER if (len >= def_size) PRINT_FIELD_U(", ", st, rx_nohandler); #endif tprints("}"); } return true; }
int sys_pwritev(struct tcb *tcp) { if (entering(tcp)) { printfd(tcp, tcp->u_arg[0]); tprints(", "); tprint_iov(tcp, tcp->u_arg[2], tcp->u_arg[1], 1); tprintf(", %lu, ", tcp->u_arg[2]); print_llu_from_low_high_val(tcp, 3); } return 0; }
int sys_pwrite(struct tcb *tcp) { if (entering(tcp)) { printfd(tcp, tcp->u_arg[0]); tprints(", "); printstr(tcp, tcp->u_arg[1], tcp->u_arg[2]); tprintf(", %lu, ", tcp->u_arg[2]); printllval(tcp, "%llu", PREAD_OFFSET_ARG); } return 0; }
static void print_cap_bits(const uint32_t lo, const uint32_t hi) { if (lo || !hi) printflags(cap_mask0, lo, "CAP_???"); if (hi) { if (lo) tprints("|"); printflags(cap_mask1, hi, "CAP_???"); } }
static void decode_old_sigaction(struct tcb *tcp, long addr) { struct old_sigaction sa; #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4 if (current_wordsize != sizeof(sa.__sa_handler) && current_wordsize == 4) { struct old_sigaction32 sa32; if (umove_or_printaddr(tcp, addr, &sa32)) return; memset(&sa, 0, sizeof(sa)); sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler; sa.sa_flags = sa32.sa_flags; #if HAVE_SA_RESTORER && defined SA_RESTORER sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer; #endif sa.sa_mask = sa32.sa_mask; } else #endif if (umove_or_printaddr(tcp, addr, &sa)) return; /* Architectures using function pointers, like * hppa, may need to manipulate the function pointer * to compute the result of a comparison. However, * the __sa_handler function pointer exists only in * the address space of the traced process, and can't * be manipulated by strace. In order to prevent the * compiler from generating code to manipulate * __sa_handler we cast the function pointers to long. */ tprints("{"); if ((long)sa.__sa_handler == (long)SIG_ERR) tprints("SIG_ERR"); else if ((long)sa.__sa_handler == (long)SIG_DFL) tprints("SIG_DFL"); else if ((long)sa.__sa_handler == (long)SIG_IGN) tprints("SIG_IGN"); else printaddr((long) sa.__sa_handler); tprints(", "); #ifdef MIPS tprintsigmask_addr("", sa.sa_mask); #else tprintsigmask_val("", sa.sa_mask); #endif tprints(", "); printflags(sigact_flags, sa.sa_flags, "SA_???"); #if HAVE_SA_RESTORER && defined SA_RESTORER if (sa.sa_flags & SA_RESTORER) tprintf(", %p", sa.sa_restorer); #endif tprints("}"); }
void printsigevent(struct tcb *tcp, long arg) { struct sigevent sev; #if SUPPORTED_PERSONALITIES > 1 if (current_wordsize == 4) { printsigevent32(tcp, arg); return; } #endif if (umove(tcp, arg, &sev) < 0) tprints("{...}"); else { tprintf("{%p, ", sev.sigev_value.sival_ptr); if (sev.sigev_notify == SIGEV_SIGNAL) tprintf("%s, ", signame(sev.sigev_signo)); else tprintf("%u, ", sev.sigev_signo); printxval(sigev_value, sev.sigev_notify, "SIGEV_???"); tprints(", "); if (sev.sigev_notify == SIGEV_THREAD_ID) #if defined(HAVE_STRUCT_SIGEVENT__SIGEV_UN__PAD) /* _pad[0] is the _tid field which might not be present in the userlevel definition of the struct. */ tprintf("{%d}", sev._sigev_un._pad[0]); #elif defined(HAVE_STRUCT_SIGEVENT___PAD) tprintf("{%d}", sev.__pad[0]); #else # warning unfamiliar struct sigevent => incomplete SIGEV_THREAD_ID decoding tprints("{...}"); #endif else if (sev.sigev_notify == SIGEV_THREAD) tprintf("{%p, %p}", sev.sigev_notify_function, sev.sigev_notify_attributes); else tprints("{...}"); tprints("}"); }