1/* 2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) 3 * Licensed under the GPL 4 */ 5 6#include <linux/module.h> 7#include <linux/ptrace.h> 8#include <linux/sched.h> 9#include <asm/siginfo.h> 10#include <asm/signal.h> 11#include <asm/unistd.h> 12#include "frame_kern.h" 13#include "kern_util.h" 14#include <sysdep/sigcontext.h> 15 16EXPORT_SYMBOL(block_signals); 17EXPORT_SYMBOL(unblock_signals); 18 19#define _S(nr) (1<<((nr)-1)) 20 21#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP))) 22 23/* 24 * OK, we're invoking a handler 25 */ 26static int handle_signal(struct pt_regs *regs, unsigned long signr, 27 struct k_sigaction *ka, siginfo_t *info, 28 sigset_t *oldset) 29{ 30 unsigned long sp; 31 int err; 32 33 /* Always make any pending restarted system calls return -EINTR */ 34 current_thread_info()->restart_block.fn = do_no_restart_syscall; 35 36 /* Did we come from a system call? */ 37 if (PT_REGS_SYSCALL_NR(regs) >= 0) { 38 /* If so, check system call restarting.. */ 39 switch (PT_REGS_SYSCALL_RET(regs)) { 40 case -ERESTART_RESTARTBLOCK: 41 case -ERESTARTNOHAND: 42 PT_REGS_SYSCALL_RET(regs) = -EINTR; 43 break; 44 45 case -ERESTARTSYS: 46 if (!(ka->sa.sa_flags & SA_RESTART)) { 47 PT_REGS_SYSCALL_RET(regs) = -EINTR; 48 break; 49 } 50 /* fallthrough */ 51 case -ERESTARTNOINTR: 52 PT_REGS_RESTART_SYSCALL(regs); 53 PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs); 54 break; 55 } 56 } 57 58 sp = PT_REGS_SP(regs); 59 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0)) 60 sp = current->sas_ss_sp + current->sas_ss_size; 61 62#ifdef CONFIG_ARCH_HAS_SC_SIGNALS 63 if (!(ka->sa.sa_flags & SA_SIGINFO)) 64 err = setup_signal_stack_sc(sp, signr, ka, regs, oldset); 65 else 66#endif 67 err = setup_signal_stack_si(sp, signr, ka, regs, info, oldset); 68 69 if (err) { 70 spin_lock_irq(¤t->sighand->siglock); 71 current->blocked = *oldset; 72 recalc_sigpending(); 73 spin_unlock_irq(¤t->sighand->siglock); 74 force_sigsegv(signr, current); 75 } else { 76 spin_lock_irq(¤t->sighand->siglock); 77 sigorsets(¤t->blocked, ¤t->blocked, 78 &ka->sa.sa_mask); 79 if (!(ka->sa.sa_flags & SA_NODEFER)) 80 sigaddset(¤t->blocked, signr); 81 recalc_sigpending(); 82 spin_unlock_irq(¤t->sighand->siglock); 83 } 84 85 return err; 86} 87 88static int kern_do_signal(struct pt_regs *regs) 89{ 90 struct k_sigaction ka_copy; 91 siginfo_t info; 92 sigset_t *oldset; 93 int sig, handled_sig = 0; 94 95 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 96 oldset = ¤t->saved_sigmask; 97 else 98 oldset = ¤t->blocked; 99 100 while ((sig = get_signal_to_deliver(&info, &ka_copy, regs, NULL)) > 0) { 101 handled_sig = 1; 102 /* Whee! Actually deliver the signal. */ 103 if (!handle_signal(regs, sig, &ka_copy, &info, oldset)) { 104 /* 105 * a signal was successfully delivered; the saved 106 * sigmask will have been stored in the signal frame, 107 * and will be restored by sigreturn, so we can simply 108 * clear the TIF_RESTORE_SIGMASK flag 109 */ 110 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 111 clear_thread_flag(TIF_RESTORE_SIGMASK); 112 break; 113 } 114 } 115 116 /* Did we come from a system call? */ 117 if (!handled_sig && (PT_REGS_SYSCALL_NR(regs) >= 0)) { 118 /* Restart the system call - no handlers present */ 119 switch (PT_REGS_SYSCALL_RET(regs)) { 120 case -ERESTARTNOHAND: 121 case -ERESTARTSYS: 122 case -ERESTARTNOINTR: 123 PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs); 124 PT_REGS_RESTART_SYSCALL(regs); 125 break; 126 case -ERESTART_RESTARTBLOCK: 127 PT_REGS_ORIG_SYSCALL(regs) = __NR_restart_syscall; 128 PT_REGS_RESTART_SYSCALL(regs); 129 break; 130 } 131 } 132 133 /* 134 * This closes a way to execute a system call on the host. If 135 * you set a breakpoint on a system call instruction and singlestep 136 * from it, the tracing thread used to PTRACE_SINGLESTEP the process 137 * rather than PTRACE_SYSCALL it, allowing the system call to execute 138 * on the host. The tracing thread will check this flag and 139 * PTRACE_SYSCALL if necessary. 140 */ 141 if (current->ptrace & PT_DTRACE) 142 current->thread.singlestep_syscall = 143 is_syscall(PT_REGS_IP(¤t->thread.regs)); 144 145 /* 146 * if there's no signal to deliver, we just put the saved sigmask 147 * back 148 */ 149 if (!handled_sig && test_thread_flag(TIF_RESTORE_SIGMASK)) { 150 clear_thread_flag(TIF_RESTORE_SIGMASK); 151 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 152 } 153 return handled_sig; 154} 155 156int do_signal(void) 157{ 158 return kern_do_signal(¤t->thread.regs); 159} 160 161/* 162 * Atomically swap in the new signal mask, and wait for a signal. 163 */ 164long sys_sigsuspend(int history0, int history1, old_sigset_t mask) 165{ 166 mask &= _BLOCKABLE; 167 spin_lock_irq(¤t->sighand->siglock); 168 current->saved_sigmask = current->blocked; 169 siginitset(¤t->blocked, mask); 170 recalc_sigpending(); 171 spin_unlock_irq(¤t->sighand->siglock); 172 173 current->state = TASK_INTERRUPTIBLE; 174 schedule(); 175 set_thread_flag(TIF_RESTORE_SIGMASK); 176 return -ERESTARTNOHAND; 177} 178 179long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss) 180{ 181 return do_sigaltstack(uss, uoss, PT_REGS_SP(¤t->thread.regs)); 182} 183