int SCOPE
post_vmsplice(const struct syscall_regs * regs)
{
/* i am vmsplice, i don't need to write the content. */
write_eax(regs);
return 0;
}
int SCOPE
post_pread64(const struct syscall_regs * regs)
{
write_eax(regs);
if (regs->eax > 0)
write_mem(regs->ecx, regs->eax);
return 0;
}
int SCOPE
post_lstat64(const struct syscall_regs * regs)
{
write_eax(regs);
if (regs->eax >= 0) {
write_mem(regs->ecx, sizeof(struct stat64));
}
return 0;
}
int SCOPE
post_time(const struct syscall_regs * regs)
{
write_eax(regs);
write_obj(regs->ebx);
if (regs->ebx != 0)
write_mem(regs->ebx, sizeof(time_t));
return 0;
}
int SCOPE
post_nanosleep(const struct syscall_regs * regs)
{
write_eax(regs);
uintptr_t o = regs->ecx;
write_obj(o);
if (o != 0)
write_mem(o, sizeof(struct k_timespec));
return 0;
}
int SCOPE
post_uname(const struct syscall_regs * regs)
{
write_eax(regs);
if (regs->eax >= 0) {
write_mem(regs->ebx, sizeof(struct old_utsname));
}
return 0;
}
int SCOPE
post_wait4(const struct syscall_regs * regs)
{
write_eax(regs);
uintptr_t stat_addr = regs->ecx;
uintptr_t ru = regs->esi;
write_obj(stat_addr);
if (stat_addr != 0)
write_mem(stat_addr, sizeof(int));
write_obj(ru);
if (ru != 0)
write_mem(ru, sizeof(struct rusage));
return 0;
}
int SCOPE
post_rt_sigprocmask(const struct syscall_regs * regs)
{
write_eax(regs);
if (regs->eax == 0) {
int how = regs->ebx;
int set = regs->ecx;
int oset = regs->edx;
int sigsetsize = regs->esi;
write_obj(sigsetsize);
if (sigsetsize != sizeof(k_sigset_t)) {
INJ_WARNING("sigsetsize %d != %d\n",
sigsetsize, sizeof(k_sigset_t));
return 0;
}
if (set) {
k_sigset_t mask;
__dup_mem(&mask, set, sigsetsize);
sigdelsetmask(&mask, sigmask(SIGKILL)|sigmask(SIGSTOP));
if (how == SIG_BLOCK) {
sigorsets(&state_vector.sigmask,
&state_vector.sigmask,
&mask);
} else if (how == SIG_UNBLOCK) {
signandsets(&state_vector.sigmask,
&state_vector.sigmask,
&mask);
} else {
/* SIG_SETMASK */
state_vector.sigmask = mask;
}
}
write_obj(oset);
if (oset) {
if (set == 0) {
k_sigset_t mask;
__dup_mem(&mask, oset, sigsetsize);
state_vector.sigmask = mask;
}
write_mem(oset, sigsetsize);
}
}
return 0;
}
int SCOPE
post_rt_sigaction(const struct syscall_regs * regs)
{
write_eax(regs);
int signo = regs->ebx;
if ((signo == SIGKILL) || (signo == SIGSTOP))
return 0;
if ((signo < 1) || (signo > K_NSIG))
return 0;
/* rt_sigaction should not fail... */
ASSERT(regs->eax >= 0, regs, "rt_sigaction failed, we cannot handle...\n");
uintptr_t act = regs->ecx;
uintptr_t oact = regs->edx;
int sigsetsize = regs->esi;
write_obj(sigsetsize);
write_obj(oact);
write_obj(act);
/* we need copy modified act back */
struct k_sigaction * s = &state_vector.sigactions[regs->ebx];
if (act != 0)
__upd_mem(act, s, sizeof(*s));
if (sigsetsize != sizeof(k_sigset_t)) {
INJ_WARNING("esi (%d) != %d\n",
sigsetsize, sizeof(k_sigset_t));
return 0;
}
if (oact != 0) {
/* we modify the result */
struct k_sigaction d;
__dup_mem(&d, oact, sizeof(d));
if (d.sa_handler == (void*)wrapped_sighandler) {
struct k_sigaction * p = &(state_vector.sigactions[regs->ebx]);
d = *p;
__upd_mem(oact, &d, sizeof(d));
}
write_mem(oact, sizeof(struct k_sigaction));
}
return 0;
}
int SCOPE
post_gettimeofday(const struct syscall_regs * regs)
{
write_eax(regs);
if (regs->eax >= 0) {
uintptr_t TP, TZP;
TP = regs->ebx;
TZP = regs->ecx;
write_obj(TP);
write_obj(TZP);
if (TP != 0)
write_mem(TP, sizeof(struct k_timeval));
if (TZP != 0)
write_mem(TZP, sizeof(struct k_timezone));
}
return 0;
}
int SCOPE
post__newselect(const struct syscall_regs * regs)
{
write_eax(regs);
int n = regs->ebx;
uint32_t inp = regs->ecx;
uint32_t outp = regs->edx;
uint32_t exp = regs->esi;
write_obj(n);
write_obj(inp);
write_obj(outp);
write_obj(exp);
int fd_bytes = FDS_BYTES(n);
if (inp != 0)
write_mem(inp, fd_bytes);
if (outp != 0)
write_mem(outp, fd_bytes);
if (exp != 0)
write_mem(exp, fd_bytes);
return 0;
}
int SCOPE
post_ioctl(const struct syscall_regs * regs)
{
INJ_TRACE("ioctl: fd=%d, cmd=0x%x, arg=0x%x\n",
regs->ebx, regs->ecx, regs->edx);
write_regs(regs);
int fd = regs->ebx;
int cmd = regs->ecx;
int arg = regs->edx;
write_eax(regs);
switch (_IOC_TYPE(cmd)) {
case 'T':
return post_tty_ioctl(fd, cmd, arg, regs);
case 0x12:
return post_blk_ioctl(fd, cmd, arg, regs);
default:
INJ_ERROR("no such ioctl command: 0x%x\n", cmd);
__exit(-1);
}
return 0;
}
int SCOPE
post_mprotect(const struct syscall_regs * regs)
{
write_eax(regs);
return 0;
}
int SCOPE
post_close(const struct syscall_regs * regs)
{
write_eax(regs);
return 0;
}
