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