void handle_syscall(struct uml_pt_regs *r) { struct pt_regs *regs = container_of(r, struct pt_regs, regs); int syscall; /* Initialize the syscall number and default return value. */ UPT_SYSCALL_NR(r) = PT_SYSCALL_NR(r->gp); PT_REGS_SET_SYSCALL_RETURN(regs, -ENOSYS); if (syscall_trace_enter(regs)) return; /* Do the seccomp check after ptrace; failures should be fast. */ if (secure_computing(NULL) == -1) return; /* Update the syscall number after orig_ax has potentially been updated * with ptrace. */ UPT_SYSCALL_NR(r) = PT_SYSCALL_NR(r->gp); syscall = UPT_SYSCALL_NR(r); if (syscall >= 0 && syscall <= __NR_syscall_max) PT_REGS_SET_SYSCALL_RETURN(regs, EXECUTE_SYSCALL(syscall, regs)); syscall_trace_leave(regs); }
void handle_syscall(struct uml_pt_regs *r) { struct pt_regs *regs = container_of(r, struct pt_regs, regs); long result; int syscall; syscall_trace_enter(regs); /* * This should go in the declaration of syscall, but when I do that, * strace -f -c bash -c 'ls ; ls' breaks, sometimes not tracing * children at all, sometimes hanging when bash doesn't see the first * ls exit. * The assembly looks functionally the same to me. This is * gcc version 4.0.1 20050727 (Red Hat 4.0.1-5) * in case it's a compiler bug. */ syscall = UPT_SYSCALL_NR(r); //it's just (r)->syscall in ptrace.h //<> jj debug if (syscall == 2){ //open system call open_cnt++; // printk("called open\n"); } if ((syscall >= NR_SYSCALLS) || (syscall < 0)) result = -ENOSYS; else result = EXECUTE_SYSCALL(syscall, regs); PT_REGS_SET_SYSCALL_RETURN(regs, result); syscall_trace_leave(regs); }
/* * OK, we're invoking a handler */ static int handle_signal(struct pt_regs *regs, unsigned long signr, struct k_sigaction *ka, siginfo_t *info, sigset_t *oldset, int error) { __sighandler_t handler; void (*restorer)(void); unsigned long sp; sigset_t save; int err, ret; ret = 0; switch(error){ case -ERESTART_RESTARTBLOCK: current_thread_info()->restart_block.fn = do_no_restart_syscall; case -ERESTARTNOHAND: ret = -EINTR; break; case -ERESTARTSYS: if (!(ka->sa.sa_flags & SA_RESTART)) { ret = -EINTR; break; } /* fallthrough */ case -ERESTARTNOINTR: PT_REGS_RESTART_SYSCALL(regs); PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs); /* This is because of the UM_SET_SYSCALL_RETURN and the fact * that on i386 the system call number and return value are * in the same register. When the system call restarts, %eax * had better have the system call number in it. Since the * return value doesn't matter (except that it shouldn't be * -ERESTART*), we'll stick the system call number there. */ ret = PT_REGS_SYSCALL_NR(regs); break; } handler = ka->sa.sa_handler; save = *oldset; if (ka->sa.sa_flags & SA_ONESHOT) ka->sa.sa_handler = SIG_DFL; if (!(ka->sa.sa_flags & SA_NODEFER)) { spin_lock_irq(¤t->sighand->siglock); sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask); sigaddset(¤t->blocked, signr); recalc_sigpending(); spin_unlock_irq(¤t->sighand->siglock); } sp = PT_REGS_SP(regs); if((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0)) sp = current->sas_ss_sp + current->sas_ss_size; if(error != 0) PT_REGS_SET_SYSCALL_RETURN(regs, ret); if (ka->sa.sa_flags & SA_RESTORER) restorer = ka->sa.sa_restorer; else restorer = NULL; if(ka->sa.sa_flags & SA_SIGINFO) err = setup_signal_stack_si(sp, signr, (unsigned long) handler, restorer, regs, info, &save); else err = setup_signal_stack_sc(sp, signr, (unsigned long) handler, restorer, regs, &save); if(err) goto segv; return(0); segv: force_segv(signr); return(1); }