int __do_clear_user(void *mem, unsigned long len, void **fault_addr, void **fault_catcher) { struct tt_regs save = TASK_REGS(get_current())->tt; unsigned long fault; int faulted; fault = __do_user_copy(mem, NULL, len, fault_addr, fault_catcher, __do_clear, &faulted); TASK_REGS(get_current())->tt = save; if(!faulted) return(0); else return(len - (fault - (unsigned long) mem)); }
int __do_strncpy_from_user(char *dst, const char *src, unsigned long count, void **fault_addr, void **fault_catcher) { struct tt_regs save = TASK_REGS(get_current())->tt; unsigned long fault; int faulted; fault = __do_user_copy(dst, src, count, fault_addr, fault_catcher, __do_strncpy, &faulted); TASK_REGS(get_current())->tt = save; if(!faulted) return(strlen(dst)); else return(-1); }
void sig_handler_common_tt(int sig, void *sc_ptr) { struct sigcontext *sc = sc_ptr; struct tt_regs save_regs, *r; struct signal_info *info; int save_errno = errno, is_user; unprotect_kernel_mem(); r = &TASK_REGS(get_current())->tt; save_regs = *r; is_user = user_context(SC_SP(sc)); r->sc = sc; if(sig != SIGUSR2) r->syscall = -1; change_sig(SIGUSR1, 1); info = &sig_info[sig]; if(!info->is_irq) unblock_signals(); (*info->handler)(sig, (union uml_pt_regs *) r); if(is_user){ interrupt_end(); block_signals(); change_sig(SIGUSR1, 0); set_user_mode(NULL); } *r = save_regs; errno = save_errno; if(is_user) protect_kernel_mem(); }
int __do_strnlen_user(const char *str, unsigned long n, void **fault_addr, void **fault_catcher) { struct tt_regs save = TASK_REGS(get_current())->tt; int ret; unsigned long *faddrp = (unsigned long *)fault_addr; jmp_buf jbuf; *fault_catcher = &jbuf; if(UML_SETJMP(&jbuf) == 0) ret = strlen(str) + 1; else ret = *faddrp - (unsigned long) str; *fault_addr = NULL; *fault_catcher = NULL; TASK_REGS(get_current())->tt = save; return ret; }
int __do_copy_from_user(void *to, const void *from, int n, void **fault_addr, void **fault_catcher) { struct tt_regs save = TASK_REGS(get_current())->tt; unsigned long fault; int faulted; fault = __do_user_copy(to, from, n, fault_addr, fault_catcher, __do_copy, &faulted); TASK_REGS(get_current())->tt = save; if(!faulted) return 0; else if (fault) return n - (fault - (unsigned long) from); else /* In case of a general protection fault, we don't have the * fault address, so NULL is used instead. Pretend we didn't * copy anything. */ return n; }
void sig_handler_common_skas(int sig, void *sc_ptr) { struct sigcontext *sc = sc_ptr; struct uml_pt_regs *r; void (*handler)(int, struct uml_pt_regs *); int save_user, save_errno = errno; /* * This is done because to allow SIGSEGV to be delivered inside a SEGV * handler. This can happen in copy_user, and if SEGV is disabled, * the process will die. * XXX Figure out why this is better than SA_NODEFER */ if (sig == SIGSEGV) { change_sig(SIGSEGV, 1); /* * For segfaults, we want the data from the * sigcontext. In this case, we don't want to mangle * the process registers, so use a static set of * registers. For other signals, the process * registers are OK. */ r = &ksig_regs[cpu()]; copy_sc(r, sc_ptr); } else r = TASK_REGS(get_current()); save_user = r->is_user; r->is_user = 0; if ((sig == SIGFPE) || (sig == SIGSEGV) || (sig == SIGBUS) || (sig == SIGILL) || (sig == SIGTRAP)) GET_FAULTINFO_FROM_SC(r->faultinfo, sc); change_sig(SIGUSR1, 1); handler = sig_info[sig]; /* unblock SIGVTALRM, SIGIO if sig isn't IRQ signal */ if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGVTALRM)) unblock_signals(); handler(sig, r); errno = save_errno; r->is_user = save_user; }
void sig_handler_common_tt(int sig, void *sc_ptr) { struct sigcontext *sc = sc_ptr; struct tt_regs save_regs, *r; struct signal_info *info; int save_errno = errno, is_user; unprotect_kernel_mem(); /* This is done because to allow SIGSEGV to be delivered inside a SEGV * handler. This can happen in copy_user, and if SEGV is disabled, * the process will die. */ if(sig == SIGSEGV) change_sig(SIGSEGV, 1); /* This is done because to allow SIGSEGV to be delivered inside a SEGV * handler. This can happen in copy_user, and if SEGV is disabled, * the process will die. */ if(sig == SIGSEGV) change_sig(SIGSEGV, 1); r = &TASK_REGS(get_current())->tt; save_regs = *r; is_user = user_context(SC_SP(sc)); r->sc = sc; if(sig != SIGUSR2) r->syscall = -1; info = &sig_info[sig]; if(!info->is_irq) unblock_signals(); (*info->handler)(sig, (union uml_pt_regs *) r); if(is_user){ interrupt_end(); block_signals(); set_user_mode(NULL); } *r = save_regs; errno = save_errno; if(is_user) protect_kernel_mem(); }
void sig_handler_common_skas(int sig, void *sc_ptr) { struct sigcontext *sc = sc_ptr; struct skas_regs *r; struct signal_info *info; int save_errno = errno; int save_user; r = &TASK_REGS(get_current())->skas; save_user = r->is_user; r->is_user = 0; r->fault_addr = SC_FAULT_ADDR(sc); r->fault_type = SC_FAULT_TYPE(sc); r->trap_type = SC_TRAP_TYPE(sc); change_sig(SIGUSR1, 1); info = &sig_info[sig]; if(!info->is_irq) unblock_signals(); (*info->handler)(sig, (union uml_pt_regs *) r); errno = save_errno; r->is_user = save_user; }