MPERS_PRINTER_DECL(int, decode_sg_req_info,
struct tcb *const tcp, const kernel_ulong_t arg)
{
struct_sg_req_info info;
if (entering(tcp))
return 0;
tprints(", ");
if (!umove_or_printaddr(tcp, arg, &info)) {
tprintf("{req_state=%hhd"
", orphan=%hhd"
", sg_io_owned=%hhd"
", problem=%hhd"
", pack_id=%d"
", usr_ptr=",
info.req_state,
info.orphan,
info.sg_io_owned,
info.problem,
info.pack_id);
printaddr(ptr_to_kulong(info.usr_ptr));
tprintf(", duration=%u}", info.duration);
}
return RVAL_IOCTL_DECODED;
}
static void
printsigval(const siginfo_t *sip)
{
tprintf(", si_value={int=%d, ptr=", sip->si_int);
printaddr(ptr_to_kulong(sip->si_ptr));
tprints("}");
}
static void
decode_mtd_oob_buf(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct_mtd_oob_buf mbuf;
tprints(", ");
if (umove_or_printaddr(tcp, addr, &mbuf))
return;
tprintf("{start=%#x, length=%#x, ptr=", mbuf.start, mbuf.length);
printaddr(ptr_to_kulong(mbuf.ptr));
tprints("}");
}
static void
print_stack_t(struct tcb *const tcp, const kernel_ulong_t addr)
{
stack_t ss;
if (umove_or_printaddr(tcp, addr, &ss))
return;
tprints("{ss_sp=");
printaddr(ptr_to_kulong(ss.ss_sp));
tprints(", ss_flags=");
printflags(sigaltstack_flags, ss.ss_flags, "SS_???");
tprintf(", ss_size=%" PRI_klu "}", (kernel_ulong_t) ss.ss_size);
}
static void
print_si_info(const siginfo_t *sip)
{
if (sip->si_errno) {
tprints(", si_errno=");
if ((unsigned) sip->si_errno < nerrnos
&& errnoent[sip->si_errno])
tprints(errnoent[sip->si_errno]);
else
tprintf("%d", sip->si_errno);
}
if (SI_FROMUSER(sip)) {
switch (sip->si_code) {
case SI_USER:
printsigsource(sip);
break;
case SI_TKILL:
printsigsource(sip);
break;
#if defined HAVE_SIGINFO_T_SI_TIMERID && defined HAVE_SIGINFO_T_SI_OVERRUN
case SI_TIMER:
tprintf(", si_timerid=%#x, si_overrun=%d",
sip->si_timerid, sip->si_overrun);
printsigval(sip);
break;
#endif
default:
printsigsource(sip);
if (sip->si_ptr)
printsigval(sip);
break;
}
} else {
switch (sip->si_signo) {
case SIGCHLD:
printsigsource(sip);
tprints(", si_status=");
if (sip->si_code == CLD_EXITED)
tprintf("%d", sip->si_status);
else
printsignal(sip->si_status);
tprintf(", si_utime=%llu, si_stime=%llu",
zero_extend_signed_to_ull(sip->si_utime),
zero_extend_signed_to_ull(sip->si_stime));
break;
case SIGILL: case SIGFPE:
case SIGSEGV: case SIGBUS:
tprints(", si_addr=");
printaddr(ptr_to_kulong(sip->si_addr));
break;
case SIGPOLL:
switch (sip->si_code) {
case POLL_IN: case POLL_OUT: case POLL_MSG:
tprintf(", si_band=%ld",
(long) sip->si_band);
break;
}
break;
#ifdef HAVE_SIGINFO_T_SI_SYSCALL
case SIGSYS: {
const char *scname =
syscall_name((unsigned) sip->si_syscall);
tprints(", si_call_addr=");
printaddr(ptr_to_kulong(sip->si_call_addr));
tprints(", si_syscall=");
if (scname)
tprintf("__NR_%s", scname);
else
tprintf("%u", (unsigned) sip->si_syscall);
tprints(", si_arch=");
printxval(audit_arch, sip->si_arch, "AUDIT_ARCH_???");
break;
}
#endif
default:
if (sip->si_pid || sip->si_uid)
printsigsource(sip);
if (sip->si_ptr)
printsigval(sip);
}
}
}
/*
* There are two different modes of operation:
*
* - Get buffer size. In this case, the callee sets ifc_buf to NULL,
* and the kernel returns the buffer size in ifc_len.
* - Get actual data. In this case, the callee specifies the buffer address
* in ifc_buf and its size in ifc_len. The kernel fills the buffer with
* the data, and its amount is returned in ifc_len.
*
* Note that, technically, the whole struct ifconf is overwritten,
* so ifc_buf could be different on exit, but current ioctl handler
* implementation does not touch it.
*/
static int
decode_ifconf(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct_ifconf *entering_ifc = NULL;
struct_ifconf *ifc =
entering(tcp) ? malloc(sizeof(*ifc)) : alloca(sizeof(*ifc));
if (exiting(tcp)) {
entering_ifc = get_tcb_priv_data(tcp);
if (!entering_ifc) {
error_msg("decode_ifconf: where is my ifconf?");
return 0;
}
}
if (!ifc || umove(tcp, addr, ifc) < 0) {
if (entering(tcp)) {
free(ifc);
tprints(", ");
printaddr(addr);
} else {
/*
* We failed to fetch the structure on exiting syscall,
* print whatever was fetched on entering syscall.
*/
if (!entering_ifc->ifc_buf)
print_ifc_len(entering_ifc->ifc_len);
tprints(", ifc_buf=");
printaddr(ptr_to_kulong(entering_ifc->ifc_buf));
tprints("}");
}
return RVAL_DECODED | 1;
}
if (entering(tcp)) {
tprints(", {ifc_len=");
if (ifc->ifc_buf)
print_ifc_len(ifc->ifc_len);
set_tcb_priv_data(tcp, ifc, free);
return 1;
}
/* exiting */
if (entering_ifc->ifc_buf && (entering_ifc->ifc_len != ifc->ifc_len))
tprints(" => ");
if (!entering_ifc->ifc_buf || (entering_ifc->ifc_len != ifc->ifc_len))
print_ifc_len(ifc->ifc_len);
tprints(", ifc_buf=");
if (!entering_ifc->ifc_buf || syserror(tcp)) {
printaddr(ptr_to_kulong(entering_ifc->ifc_buf));
if (entering_ifc->ifc_buf != ifc->ifc_buf) {
tprints(" => ");
printaddr(ptr_to_kulong(ifc->ifc_buf));
}
} else {
struct_ifreq ifr;
print_array(tcp, ptr_to_kulong(ifc->ifc_buf),
ifc->ifc_len / sizeof(struct_ifreq),
&ifr, sizeof(ifr),
umoven_or_printaddr, print_ifconf_ifreq, NULL);
}
tprints("}");
return RVAL_DECODED | 1;
}
static int
ff_effect_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
struct_ff_effect ffe;
if (umove_or_printaddr(tcp, arg, &ffe))
return 1;
tprints("{type=");
printxval(evdev_ff_types, ffe.type, "FF_???");
tprintf(", id=%" PRIu16
", direction=%" PRIu16 ", ",
ffe.id,
ffe.direction);
if (abbrev(tcp)) {
tprints("...}");
return 1;
}
tprintf("trigger={button=%" PRIu16
", interval=%" PRIu16 "}"
", replay={length=%" PRIu16
", delay=%" PRIu16 "}",
ffe.trigger.button,
ffe.trigger.interval,
ffe.replay.length,
ffe.replay.delay);
switch (ffe.type) {
case FF_CONSTANT:
tprintf(", constant={level=%" PRId16,
ffe.u.constant.level);
decode_envelope(&ffe.u.constant.envelope);
tprints("}");
break;
case FF_RAMP:
tprintf(", ramp={start_level=%" PRId16
", end_level=%" PRId16,
ffe.u.ramp.start_level,
ffe.u.ramp.end_level);
decode_envelope(&ffe.u.ramp.envelope);
tprints("}");
break;
case FF_PERIODIC:
tprintf(", periodic={waveform=%" PRIu16
", period=%" PRIu16
", magnitude=%" PRId16
", offset=%" PRId16
", phase=%" PRIu16,
ffe.u.periodic.waveform,
ffe.u.periodic.period,
ffe.u.periodic.magnitude,
ffe.u.periodic.offset,
ffe.u.periodic.phase);
decode_envelope(&ffe.u.periodic.envelope);
tprintf(", custom_len=%u, custom_data=",
ffe.u.periodic.custom_len);
printaddr(ptr_to_kulong(ffe.u.periodic.custom_data));
tprints("}");
break;
case FF_RUMBLE:
tprintf(", rumble={strong_magnitude=%" PRIu16
", weak_magnitude=%" PRIu16 "}",
ffe.u.rumble.strong_magnitude,
ffe.u.rumble.weak_magnitude);
break;
default:
break;
}
tprints("}");
return 1;
}
