Jeff Dike | 1d3468a | 2006-07-10 04:45:13 -0700 | [diff] [blame] | 1 | /* |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 2 | * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Licensed under the GPL |
| 4 | */ |
| 5 | |
Jeff Dike | c5d4bb1 | 2008-02-04 22:31:14 -0800 | [diff] [blame] | 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> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include "frame_kern.h" |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 13 | #include "kern_util.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include "sigcontext.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | EXPORT_SYMBOL(block_signals); |
| 17 | EXPORT_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 |
Jeff Dike | 1d3468a | 2006-07-10 04:45:13 -0700 | [diff] [blame] | 25 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | static 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? */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 37 | if (PT_REGS_SYSCALL_NR(regs) >= 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | /* If so, check system call restarting.. */ |
Jeff Dike | c5d4bb1 | 2008-02-04 22:31:14 -0800 | [diff] [blame] | 39 | switch (PT_REGS_SYSCALL_RET(regs)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 59 | if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | sp = current->sas_ss_sp + current->sas_ss_size; |
| 61 | |
| 62 | #ifdef CONFIG_ARCH_HAS_SC_SIGNALS |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 63 | if (!(ka->sa.sa_flags & SA_SIGINFO)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 69 | if (err) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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); |
Steven Rostedt | 69be8f1 | 2005-08-29 11:44:09 -0400 | [diff] [blame] | 75 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | spin_lock_irq(¤t->sighand->siglock); |
Jeff Dike | 1d3468a | 2006-07-10 04:45:13 -0700 | [diff] [blame] | 77 | sigorsets(¤t->blocked, ¤t->blocked, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | &ka->sa.sa_mask); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 79 | if (!(ka->sa.sa_flags & SA_NODEFER)) |
Steven Rostedt | 69be8f1 | 2005-08-29 11:44:09 -0400 | [diff] [blame] | 80 | sigaddset(¤t->blocked, signr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | recalc_sigpending(); |
| 82 | spin_unlock_irq(¤t->sighand->siglock); |
| 83 | } |
| 84 | |
| 85 | return err; |
| 86 | } |
| 87 | |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 88 | static int kern_do_signal(struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | { |
| 90 | struct k_sigaction ka_copy; |
| 91 | siginfo_t info; |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 92 | sigset_t *oldset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | int sig, handled_sig = 0; |
| 94 | |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 95 | if (test_thread_flag(TIF_RESTORE_SIGMASK)) |
| 96 | oldset = ¤t->saved_sigmask; |
| 97 | else |
| 98 | oldset = ¤t->blocked; |
| 99 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 100 | while ((sig = get_signal_to_deliver(&info, &ka_copy, regs, NULL)) > 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | handled_sig = 1; |
| 102 | /* Whee! Actually deliver the signal. */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 103 | if (!handle_signal(regs, sig, &ka_copy, &info, oldset)) { |
| 104 | /* |
| 105 | * a signal was successfully delivered; the saved |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 106 | * sigmask will have been stored in the signal frame, |
| 107 | * and will be restored by sigreturn, so we can simply |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 108 | * clear the TIF_RESTORE_SIGMASK flag |
| 109 | */ |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 110 | if (test_thread_flag(TIF_RESTORE_SIGMASK)) |
| 111 | clear_thread_flag(TIF_RESTORE_SIGMASK); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | break; |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 113 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | /* Did we come from a system call? */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 117 | if (!handled_sig && (PT_REGS_SYSCALL_NR(regs) >= 0)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | /* Restart the system call - no handlers present */ |
Jeff Dike | c5d4bb1 | 2008-02-04 22:31:14 -0800 | [diff] [blame] | 119 | switch (PT_REGS_SYSCALL_RET(regs)) { |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 120 | case -ERESTARTNOHAND: |
| 121 | case -ERESTARTSYS: |
| 122 | case -ERESTARTNOINTR: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs); |
| 124 | PT_REGS_RESTART_SYSCALL(regs); |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 125 | break; |
| 126 | case -ERESTART_RESTARTBLOCK: |
Jeff Dike | 1d3468a | 2006-07-10 04:45:13 -0700 | [diff] [blame] | 127 | PT_REGS_ORIG_SYSCALL(regs) = __NR_restart_syscall; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | PT_REGS_RESTART_SYSCALL(regs); |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 129 | break; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 130 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | } |
| 132 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 133 | /* |
| 134 | * This closes a way to execute a system call on the host. If |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Jeff Dike | 1d3468a | 2006-07-10 04:45:13 -0700 | [diff] [blame] | 138 | * on the host. The tracing thread will check this flag and |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | * PTRACE_SYSCALL if necessary. |
| 140 | */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 141 | if (current->ptrace & PT_DTRACE) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | current->thread.singlestep_syscall = |
| 143 | is_syscall(PT_REGS_IP(¤t->thread.regs)); |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 144 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 145 | /* |
| 146 | * if there's no signal to deliver, we just put the saved sigmask |
| 147 | * back |
| 148 | */ |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 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 | } |
Jeff Dike | 7c7a894 | 2007-03-06 01:42:18 -0800 | [diff] [blame] | 153 | return handled_sig; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | int do_signal(void) |
| 157 | { |
Jeff Dike | 7c7a894 | 2007-03-06 01:42:18 -0800 | [diff] [blame] | 158 | return kern_do_signal(¤t->thread.regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | /* |
| 162 | * Atomically swap in the new signal mask, and wait for a signal. |
| 163 | */ |
| 164 | long sys_sigsuspend(int history0, int history1, old_sigset_t mask) |
| 165 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | mask &= _BLOCKABLE; |
| 167 | spin_lock_irq(¤t->sighand->siglock); |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 168 | current->saved_sigmask = current->blocked; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | siginitset(¤t->blocked, mask); |
| 170 | recalc_sigpending(); |
| 171 | spin_unlock_irq(¤t->sighand->siglock); |
| 172 | |
Jeff Dike | 2fc1062 | 2006-01-18 17:44:02 -0800 | [diff] [blame] | 173 | current->state = TASK_INTERRUPTIBLE; |
| 174 | schedule(); |
| 175 | set_thread_flag(TIF_RESTORE_SIGMASK); |
| 176 | return -ERESTARTNOHAND; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | } |
| 178 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss) |
| 180 | { |
Jeff Dike | 7c7a894 | 2007-03-06 01:42:18 -0800 | [diff] [blame] | 181 | return do_sigaltstack(uss, uoss, PT_REGS_SP(¤t->thread.regs)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | } |