static int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) { unsigned long tmp; int err = 0; err |= copy_to_user(&sc->sc_regs.r0, ®s->r00, 32*sizeof(unsigned long)); err |= __put_user(regs->sa0, &sc->sc_regs.sa0); err |= __put_user(regs->lc0, &sc->sc_regs.lc0); err |= __put_user(regs->sa1, &sc->sc_regs.sa1); err |= __put_user(regs->lc1, &sc->sc_regs.lc1); err |= __put_user(regs->m0, &sc->sc_regs.m0); err |= __put_user(regs->m1, &sc->sc_regs.m1); err |= __put_user(regs->usr, &sc->sc_regs.usr); err |= __put_user(regs->preds, &sc->sc_regs.p3_0); err |= __put_user(regs->gp, &sc->sc_regs.gp); err |= __put_user(regs->ugp, &sc->sc_regs.ugp); tmp = pt_elr(regs); err |= __put_user(tmp, &sc->sc_regs.pc); tmp = pt_cause(regs); err |= __put_user(tmp, &sc->sc_regs.cause); tmp = pt_badva(regs); err |= __put_user(tmp, &sc->sc_regs.badva); return err; }
static void do_signal(struct pt_regs *regs) { struct k_sigaction sigact; siginfo_t info; int signo; if (!user_mode(regs)) return; if (try_to_freeze()) goto no_signal; signo = get_signal_to_deliver(&info, &sigact, regs, NULL); if (signo > 0) { sigset_t *oldset; if (test_thread_flag(TIF_RESTORE_SIGMASK)) oldset = ¤t->saved_sigmask; else oldset = ¤t->blocked; if (handle_signal(signo, &info, &sigact, oldset, regs) == 0) { clear_thread_flag(TIF_RESTORE_SIGMASK); tracehook_signal_handler(signo, &info, &sigact, regs, test_thread_flag(TIF_SINGLESTEP)); } return; } no_signal: if (regs->syscall_nr >= 0) { switch (regs->r00) { case -ERESTARTNOHAND: case -ERESTARTSYS: case -ERESTARTNOINTR: regs->r06 = regs->syscall_nr; break; case -ERESTART_RESTARTBLOCK: regs->r06 = __NR_restart_syscall; break; default: goto no_restart; } pt_set_elr(regs, pt_elr(regs) - 4); regs->r00 = regs->restart_r0; } no_restart: if (test_thread_flag(TIF_RESTORE_SIGMASK)) { clear_thread_flag(TIF_RESTORE_SIGMASK); sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); } }
static int genregs_set(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, const void *kbuf, const void __user *ubuf) { int ret; unsigned long bucket; struct pt_regs *regs = task_pt_regs(target); if (!regs) return -EIO; ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, ®s->r00, 0, 32*sizeof(unsigned long)); #define INEXT(KPT_REG, USR_REG) \ if (!ret) \ ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, \ KPT_REG, offsetof(struct user_regs_struct, USR_REG), \ offsetof(struct user_regs_struct, USR_REG) + \ sizeof(unsigned long)); /* Must be exactly same sequence as struct user_regs_struct */ INEXT(®s->sa0, sa0); INEXT(®s->lc0, lc0); INEXT(®s->sa1, sa1); INEXT(®s->lc1, lc1); INEXT(®s->m0, m0); INEXT(®s->m1, m1); INEXT(®s->usr, usr); INEXT(®s->preds, p3_0); INEXT(®s->gp, gp); INEXT(®s->ugp, ugp); INEXT(&pt_elr(regs), pc); /* CAUSE and BADVA aren't writeable. */ INEXT(&bucket, cause); INEXT(&bucket, badva); /* Ignore the rest, if needed */ if (!ret) ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, offsetof(struct user_regs_struct, pad1), -1); if (ret) return ret; /* * This is special; SP is actually restored by the VM via the * special event record which is set by the special trap. */ regs->hvmer.vmpsp = regs->r29; return 0; }
/* * Setup invocation of signal handler */ static int handle_signal(int sig, siginfo_t *info, struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs) { int rc; /* * If we're handling a signal that aborted a system call, * set up the error return value before adding the signal * frame to the stack. */ if (regs->syscall_nr >= 0) { switch (regs->r00) { case -ERESTART_RESTARTBLOCK: case -ERESTARTNOHAND: regs->r00 = -EINTR; break; case -ERESTARTSYS: if (!(ka->sa.sa_flags & SA_RESTART)) { regs->r00 = -EINTR; break; } /* Fall through */ case -ERESTARTNOINTR: regs->r06 = regs->syscall_nr; pt_set_elr(regs, pt_elr(regs) - 4); regs->r00 = regs->restart_r0; break; default: break; } } /* * Set up the stack frame; not doing the SA_SIGINFO thing. We * only set up the rt_frame flavor. */ rc = setup_rt_frame(sig, ka, info, oldset, regs); /* If there was an error on setup, no signal was delivered. */ if (rc) return rc; spin_lock_irq(¤t->sighand->siglock); sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask); if (!(ka->sa.sa_flags & SA_NODEFER)) sigaddset(¤t->blocked, sig); recalc_sigpending(); spin_unlock_irq(¤t->sighand->siglock); return 0; }
static int genregs_get(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, void *kbuf, void __user *ubuf) { int ret; unsigned int dummy; struct pt_regs *regs = task_pt_regs(target); if (!regs) return -EIO; /* The general idea here is that the copyout must happen in * exactly the same order in which the userspace expects these * regs. Now, the sequence in userspace does not match the * sequence in the kernel, so everything past the 32 gprs * happens one at a time. */ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s->r00, 0, 32*sizeof(unsigned long)); #define ONEXT(KPT_REG, USR_REG) \ if (!ret) \ ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, \ KPT_REG, offsetof(struct user_regs_struct, USR_REG), \ offsetof(struct user_regs_struct, USR_REG) + \ sizeof(unsigned long)); /* Must be exactly same sequence as struct user_regs_struct */ ONEXT(®s->sa0, sa0); ONEXT(®s->lc0, lc0); ONEXT(®s->sa1, sa1); ONEXT(®s->lc1, lc1); ONEXT(®s->m0, m0); ONEXT(®s->m1, m1); ONEXT(®s->usr, usr); ONEXT(®s->preds, p3_0); ONEXT(®s->gp, gp); ONEXT(®s->ugp, ugp); ONEXT(&pt_elr(regs), pc); dummy = pt_cause(regs); ONEXT(&dummy, cause); ONEXT(&pt_badva(regs), badva); /* Pad the rest with zeros, if needed */ if (!ret) ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, offsetof(struct user_regs_struct, pad1), -1); return ret; }
/* * Setup invocation of signal handler */ static void handle_signal(int sig, siginfo_t *info, struct k_sigaction *ka, struct pt_regs *regs) { /* * If we're handling a signal that aborted a system call, * set up the error return value before adding the signal * frame to the stack. */ if (regs->syscall_nr >= 0) { switch (regs->r00) { case -ERESTART_RESTARTBLOCK: case -ERESTARTNOHAND: regs->r00 = -EINTR; break; case -ERESTARTSYS: if (!(ka->sa.sa_flags & SA_RESTART)) { regs->r00 = -EINTR; break; } /* Fall through */ case -ERESTARTNOINTR: regs->r06 = regs->syscall_nr; pt_set_elr(regs, pt_elr(regs) - 4); regs->r00 = regs->restart_r0; break; default: break; } } /* * Set up the stack frame; not doing the SA_SIGINFO thing. We * only set up the rt_frame flavor. */ /* If there was an error on setup, no signal was delivered. */ if (setup_rt_frame(sig, ka, info, sigmask_to_save(), regs) < 0) return; signal_delivered(sig, info, ka, regs, test_thread_flag(TIF_SINGLESTEP)); }
/* * Called from return-from-event code. */ static void do_signal(struct pt_regs *regs) { struct k_sigaction sigact; siginfo_t info; int signo; if (!user_mode(regs)) return; signo = get_signal_to_deliver(&info, &sigact, regs, NULL); if (signo > 0) { handle_signal(signo, &info, &sigact, regs); return; } /* * If we came from a system call, handle the restart. */ if (regs->syscall_nr >= 0) { switch (regs->r00) { case -ERESTARTNOHAND: case -ERESTARTSYS: case -ERESTARTNOINTR: regs->r06 = regs->syscall_nr; break; case -ERESTART_RESTARTBLOCK: regs->r06 = __NR_restart_syscall; break; default: goto no_restart; } pt_set_elr(regs, pt_elr(regs) - 4); regs->r00 = regs->restart_r0; } no_restart: /* If there's no signal to deliver, put the saved sigmask back */ restore_saved_sigmask(); }
static int handle_signal(int sig, siginfo_t *info, struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs) { int rc; if (regs->syscall_nr >= 0) { switch (regs->r00) { case -ERESTART_RESTARTBLOCK: case -ERESTARTNOHAND: regs->r00 = -EINTR; break; case -ERESTARTSYS: if (!(ka->sa.sa_flags & SA_RESTART)) { regs->r00 = -EINTR; break; } case -ERESTARTNOINTR: regs->r06 = regs->syscall_nr; pt_set_elr(regs, pt_elr(regs) - 4); regs->r00 = regs->restart_r0; break; default: break; } } rc = setup_rt_frame(sig, ka, info, oldset, regs); if (rc) return rc; block_sigmask(ka, sig); return 0; }
/* * Canonical page fault handler */ void do_page_fault(unsigned long address, long cause, struct pt_regs *regs) { struct vm_area_struct *vma; struct mm_struct *mm = current->mm; siginfo_t info; int si_code = SEGV_MAPERR; int fault; const struct exception_table_entry *fixup; unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE; /* * If we're in an interrupt or have no user context, * then must not take the fault. */ if (unlikely(in_interrupt() || !mm)) goto no_context; local_irq_enable(); if (user_mode(regs)) flags |= FAULT_FLAG_USER; retry: down_read(&mm->mmap_sem); vma = find_vma(mm, address); if (!vma) goto bad_area; if (vma->vm_start <= address) goto good_area; if (!(vma->vm_flags & VM_GROWSDOWN)) goto bad_area; if (expand_stack(vma, address)) goto bad_area; good_area: /* Address space is OK. Now check access rights. */ si_code = SEGV_ACCERR; switch (cause) { case FLT_IFETCH: if (!(vma->vm_flags & VM_EXEC)) goto bad_area; break; case FLT_LOAD: if (!(vma->vm_flags & VM_READ)) goto bad_area; break; case FLT_STORE: if (!(vma->vm_flags & VM_WRITE)) goto bad_area; flags |= FAULT_FLAG_WRITE; break; } fault = handle_mm_fault(mm, vma, address, flags); if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current)) return; /* The most common case -- we are done. */ if (likely(!(fault & VM_FAULT_ERROR))) { if (flags & FAULT_FLAG_ALLOW_RETRY) { if (fault & VM_FAULT_MAJOR) current->maj_flt++; else current->min_flt++; if (fault & VM_FAULT_RETRY) { flags &= ~FAULT_FLAG_ALLOW_RETRY; flags |= FAULT_FLAG_TRIED; goto retry; } } up_read(&mm->mmap_sem); return; } up_read(&mm->mmap_sem); /* Handle copyin/out exception cases */ if (!user_mode(regs)) goto no_context; if (fault & VM_FAULT_OOM) { pagefault_out_of_memory(); return; } /* User-mode address is in the memory map, but we are * unable to fix up the page fault. */ if (fault & VM_FAULT_SIGBUS) { info.si_signo = SIGBUS; info.si_code = BUS_ADRERR; } /* Address is not in the memory map */ else { info.si_signo = SIGSEGV; info.si_code = SEGV_ACCERR; } info.si_errno = 0; info.si_addr = (void __user *)address; force_sig_info(info.si_signo, &info, current); return; bad_area: up_read(&mm->mmap_sem); if (user_mode(regs)) { info.si_signo = SIGSEGV; info.si_errno = 0; info.si_code = si_code; info.si_addr = (void *)address; force_sig_info(info.si_signo, &info, current); return; } /* Kernel-mode fault falls through */ no_context: fixup = search_exception_tables(pt_elr(regs)); if (fixup) { pt_set_elr(regs, fixup->fixup); return; } /* Things are looking very, very bad now */ bust_spinlocks(1); printk(KERN_EMERG "Unable to handle kernel paging request at " "virtual address 0x%08lx, regs %p\n", address, regs); die("Bad Kernel VA", regs, SIGKILL); }
/* * Called from return-from-event code. */ static void do_signal(struct pt_regs *regs) { struct k_sigaction sigact; siginfo_t info; int signo; if (!user_mode(regs)) return; if (try_to_freeze()) goto no_signal; signo = get_signal_to_deliver(&info, &sigact, regs, NULL); if (signo > 0) { sigset_t *oldset; if (test_thread_flag(TIF_RESTORE_SIGMASK)) oldset = ¤t->saved_sigmask; else oldset = ¤t->blocked; if (handle_signal(signo, &info, &sigact, oldset, regs) == 0) { /* * Successful delivery case. The saved sigmask is * stored in the signal frame, and will be restored * by sigreturn. We can clear the TIF flag. */ clear_thread_flag(TIF_RESTORE_SIGMASK); tracehook_signal_handler(signo, &info, &sigact, regs, test_thread_flag(TIF_SINGLESTEP)); } return; } no_signal: /* * If we came from a system call, handle the restart. */ if (regs->syscall_nr >= 0) { switch (regs->r00) { case -ERESTARTNOHAND: case -ERESTARTSYS: case -ERESTARTNOINTR: regs->r06 = regs->syscall_nr; break; case -ERESTART_RESTARTBLOCK: regs->r06 = __NR_restart_syscall; break; default: goto no_restart; } pt_set_elr(regs, pt_elr(regs) - 4); regs->r00 = regs->restart_r0; } no_restart: /* If there's no signal to deliver, put the saved sigmask back */ if (test_thread_flag(TIF_RESTORE_SIGMASK)) { clear_thread_flag(TIF_RESTORE_SIGMASK); sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); } }