| /* |
| * Copyright (C) 2013-2014 Altera Corporation |
| * Copyright (C) 2011-2012 Tobias Klauser <tklauser@distanz.ch> |
| * Copyright (C) 2004 Microtronix Datacom Ltd |
| * Copyright (C) 1991, 1992 Linus Torvalds |
| * |
| * This file is subject to the terms and conditions of the GNU General Public |
| * License. See the file COPYING in the main directory of this archive |
| * for more details. |
| */ |
| |
| #include <linux/signal.h> |
| #include <linux/errno.h> |
| #include <linux/ptrace.h> |
| #include <linux/uaccess.h> |
| #include <linux/unistd.h> |
| #include <linux/personality.h> |
| #include <linux/tracehook.h> |
| |
| #include <asm/ucontext.h> |
| #include <asm/cacheflush.h> |
| |
| #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) |
| |
| /* |
| * Do a signal return; undo the signal stack. |
| * |
| * Keep the return code on the stack quadword aligned! |
| * That makes the cache flush below easier. |
| */ |
| |
| struct rt_sigframe { |
| struct siginfo info; |
| struct ucontext uc; |
| }; |
| |
| static inline int rt_restore_ucontext(struct pt_regs *regs, |
| struct switch_stack *sw, |
| struct ucontext *uc, int *pr2) |
| { |
| int temp; |
| unsigned long *gregs = uc->uc_mcontext.gregs; |
| int err; |
| |
| /* Always make any pending restarted system calls return -EINTR */ |
| current->restart_block.fn = do_no_restart_syscall; |
| |
| err = __get_user(temp, &uc->uc_mcontext.version); |
| if (temp != MCONTEXT_VERSION) |
| goto badframe; |
| /* restore passed registers */ |
| err |= __get_user(regs->r1, &gregs[0]); |
| err |= __get_user(regs->r2, &gregs[1]); |
| err |= __get_user(regs->r3, &gregs[2]); |
| err |= __get_user(regs->r4, &gregs[3]); |
| err |= __get_user(regs->r5, &gregs[4]); |
| err |= __get_user(regs->r6, &gregs[5]); |
| err |= __get_user(regs->r7, &gregs[6]); |
| err |= __get_user(regs->r8, &gregs[7]); |
| err |= __get_user(regs->r9, &gregs[8]); |
| err |= __get_user(regs->r10, &gregs[9]); |
| err |= __get_user(regs->r11, &gregs[10]); |
| err |= __get_user(regs->r12, &gregs[11]); |
| err |= __get_user(regs->r13, &gregs[12]); |
| err |= __get_user(regs->r14, &gregs[13]); |
| err |= __get_user(regs->r15, &gregs[14]); |
| err |= __get_user(sw->r16, &gregs[15]); |
| err |= __get_user(sw->r17, &gregs[16]); |
| err |= __get_user(sw->r18, &gregs[17]); |
| err |= __get_user(sw->r19, &gregs[18]); |
| err |= __get_user(sw->r20, &gregs[19]); |
| err |= __get_user(sw->r21, &gregs[20]); |
| err |= __get_user(sw->r22, &gregs[21]); |
| err |= __get_user(sw->r23, &gregs[22]); |
| /* gregs[23] is handled below */ |
| err |= __get_user(sw->fp, &gregs[24]); /* Verify, should this be |
| settable */ |
| err |= __get_user(sw->gp, &gregs[25]); /* Verify, should this be |
| settable */ |
| |
| err |= __get_user(temp, &gregs[26]); /* Not really necessary no user |
| settable bits */ |
| err |= __get_user(regs->ea, &gregs[27]); |
| |
| err |= __get_user(regs->ra, &gregs[23]); |
| err |= __get_user(regs->sp, &gregs[28]); |
| |
| regs->orig_r2 = -1; /* disable syscall checks */ |
| |
| err |= restore_altstack(&uc->uc_stack); |
| if (err) |
| goto badframe; |
| |
| *pr2 = regs->r2; |
| return err; |
| |
| badframe: |
| return 1; |
| } |
| |
| asmlinkage int do_rt_sigreturn(struct switch_stack *sw) |
| { |
| struct pt_regs *regs = (struct pt_regs *)(sw + 1); |
| /* Verify, can we follow the stack back */ |
| struct rt_sigframe *frame = (struct rt_sigframe *) regs->sp; |
| sigset_t set; |
| int rval; |
| |
| if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) |
| goto badframe; |
| |
| if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) |
| goto badframe; |
| |
| set_current_blocked(&set); |
| |
| if (rt_restore_ucontext(regs, sw, &frame->uc, &rval)) |
| goto badframe; |
| |
| return rval; |
| |
| badframe: |
| force_sig(SIGSEGV, current); |
| return 0; |
| } |
| |
| static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs) |
| { |
| struct switch_stack *sw = (struct switch_stack *)regs - 1; |
| unsigned long *gregs = uc->uc_mcontext.gregs; |
| int err = 0; |
| |
| err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version); |
| err |= __put_user(regs->r1, &gregs[0]); |
| err |= __put_user(regs->r2, &gregs[1]); |
| err |= __put_user(regs->r3, &gregs[2]); |
| err |= __put_user(regs->r4, &gregs[3]); |
| err |= __put_user(regs->r5, &gregs[4]); |
| err |= __put_user(regs->r6, &gregs[5]); |
| err |= __put_user(regs->r7, &gregs[6]); |
| err |= __put_user(regs->r8, &gregs[7]); |
| err |= __put_user(regs->r9, &gregs[8]); |
| err |= __put_user(regs->r10, &gregs[9]); |
| err |= __put_user(regs->r11, &gregs[10]); |
| err |= __put_user(regs->r12, &gregs[11]); |
| err |= __put_user(regs->r13, &gregs[12]); |
| err |= __put_user(regs->r14, &gregs[13]); |
| err |= __put_user(regs->r15, &gregs[14]); |
| err |= __put_user(sw->r16, &gregs[15]); |
| err |= __put_user(sw->r17, &gregs[16]); |
| err |= __put_user(sw->r18, &gregs[17]); |
| err |= __put_user(sw->r19, &gregs[18]); |
| err |= __put_user(sw->r20, &gregs[19]); |
| err |= __put_user(sw->r21, &gregs[20]); |
| err |= __put_user(sw->r22, &gregs[21]); |
| err |= __put_user(sw->r23, &gregs[22]); |
| err |= __put_user(regs->ra, &gregs[23]); |
| err |= __put_user(sw->fp, &gregs[24]); |
| err |= __put_user(sw->gp, &gregs[25]); |
| err |= __put_user(regs->ea, &gregs[27]); |
| err |= __put_user(regs->sp, &gregs[28]); |
| return err; |
| } |
| |
| static inline void *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, |
| size_t frame_size) |
| { |
| unsigned long usp; |
| |
| /* Default to using normal stack. */ |
| usp = regs->sp; |
| |
| /* This is the X/Open sanctioned signal stack switching. */ |
| usp = sigsp(usp, ksig); |
| |
| /* Verify, is it 32 or 64 bit aligned */ |
| return (void *)((usp - frame_size) & -8UL); |
| } |
| |
| static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, |
| struct pt_regs *regs) |
| { |
| struct rt_sigframe *frame; |
| int err = 0; |
| |
| frame = get_sigframe(ksig, regs, sizeof(*frame)); |
| |
| if (ksig->ka.sa.sa_flags & SA_SIGINFO) |
| err |= copy_siginfo_to_user(&frame->info, &ksig->info); |
| |
| /* Create the ucontext. */ |
| err |= __put_user(0, &frame->uc.uc_flags); |
| err |= __put_user(0, &frame->uc.uc_link); |
| err |= __save_altstack(&frame->uc.uc_stack, regs->sp); |
| err |= rt_setup_ucontext(&frame->uc, regs); |
| err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); |
| |
| if (err) |
| goto give_sigsegv; |
| |
| /* Set up to return from userspace; jump to fixed address sigreturn |
| trampoline on kuser page. */ |
| regs->ra = (unsigned long) (0x1044); |
| |
| /* Set up registers for signal handler */ |
| regs->sp = (unsigned long) frame; |
| regs->r4 = (unsigned long) ksig->sig; |
| regs->r5 = (unsigned long) &frame->info; |
| regs->r6 = (unsigned long) &frame->uc; |
| regs->ea = (unsigned long) ksig->ka.sa.sa_handler; |
| return 0; |
| |
| give_sigsegv: |
| force_sigsegv(ksig->sig, current); |
| return -EFAULT; |
| } |
| |
| /* |
| * OK, we're invoking a handler |
| */ |
| static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) |
| { |
| int ret; |
| sigset_t *oldset = sigmask_to_save(); |
| |
| /* set up the stack frame */ |
| ret = setup_rt_frame(ksig, oldset, regs); |
| |
| signal_setup_done(ret, ksig, 0); |
| } |
| |
| static int do_signal(struct pt_regs *regs) |
| { |
| unsigned int retval = 0, continue_addr = 0, restart_addr = 0; |
| int restart = 0; |
| struct ksignal ksig; |
| |
| current->thread.kregs = regs; |
| |
| /* |
| * If we were from a system call, check for system call restarting... |
| */ |
| if (regs->orig_r2 >= 0 && regs->r1) { |
| continue_addr = regs->ea; |
| restart_addr = continue_addr - 4; |
| retval = regs->r2; |
| |
| /* |
| * Prepare for system call restart. We do this here so that a |
| * debugger will see the already changed PC. |
| */ |
| switch (retval) { |
| case ERESTART_RESTARTBLOCK: |
| restart = -2; |
| case ERESTARTNOHAND: |
| case ERESTARTSYS: |
| case ERESTARTNOINTR: |
| restart++; |
| regs->r2 = regs->orig_r2; |
| regs->r7 = regs->orig_r7; |
| regs->ea = restart_addr; |
| break; |
| } |
| regs->orig_r2 = -1; |
| } |
| |
| if (get_signal(&ksig)) { |
| /* handler */ |
| if (unlikely(restart && regs->ea == restart_addr)) { |
| if (retval == ERESTARTNOHAND || |
| retval == ERESTART_RESTARTBLOCK || |
| (retval == ERESTARTSYS |
| && !(ksig.ka.sa.sa_flags & SA_RESTART))) { |
| regs->r2 = EINTR; |
| regs->r7 = 1; |
| regs->ea = continue_addr; |
| } |
| } |
| handle_signal(&ksig, regs); |
| return 0; |
| } |
| |
| /* |
| * No handler present |
| */ |
| if (unlikely(restart) && regs->ea == restart_addr) { |
| regs->ea = continue_addr; |
| regs->r2 = __NR_restart_syscall; |
| } |
| |
| /* |
| * If there's no signal to deliver, we just put the saved sigmask back. |
| */ |
| restore_saved_sigmask(); |
| |
| return restart; |
| } |
| |
| asmlinkage int do_notify_resume(struct pt_regs *regs) |
| { |
| /* |
| * We want the common case to go fast, which is why we may in certain |
| * cases get here from kernel mode. Just return without doing anything |
| * if so. |
| */ |
| if (!user_mode(regs)) |
| return 0; |
| |
| if (test_thread_flag(TIF_SIGPENDING)) { |
| int restart = do_signal(regs); |
| |
| if (unlikely(restart)) { |
| /* |
| * Restart without handlers. |
| * Deal with it without leaving |
| * the kernel space. |
| */ |
| return restart; |
| } |
| } else if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME)) |
| tracehook_notify_resume(regs); |
| |
| return 0; |
| } |