KEYS: Add missing linux/tracehook.h #inclusions
[linux-2.6.git] / arch / alpha / kernel / signal.c
index 08fe807..0932dbb 100644 (file)
 #include <linux/unistd.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/stddef.h>
 #include <linux/tty.h>
 #include <linux/binfmts.h>
 #include <linux/bitops.h>
+#include <linux/syscalls.h>
+#include <linux/tracehook.h>
 
 #include <asm/uaccess.h>
 #include <asm/sigcontext.h>
@@ -33,8 +34,8 @@
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
 asmlinkage void ret_from_sys_call(void);
-static int do_signal(sigset_t *, struct pt_regs *, struct switch_stack *,
-                    unsigned long, unsigned long);
+static void do_signal(struct pt_regs *, struct switch_stack *,
+                     unsigned long, unsigned long);
 
 
 /*
@@ -52,8 +53,8 @@ static int do_signal(sigset_t *, struct pt_regs *, struct switch_stack *,
  * Note that we don't need to acquire the kernel lock for SMP
  * operation, as all of this is local to this thread.
  */
-asmlinkage unsigned long
-do_osf_sigprocmask(int how, unsigned long newmask, struct pt_regs *regs)
+SYSCALL_DEFINE3(osf_sigprocmask, int, how, unsigned long, newmask,
+               struct pt_regs *, regs)
 {
        unsigned long oldmask = -EINVAL;
 
@@ -82,9 +83,9 @@ do_osf_sigprocmask(int how, unsigned long newmask, struct pt_regs *regs)
        return oldmask;
 }
 
-asmlinkage int 
-osf_sigaction(int sig, const struct osf_sigaction __user *act,
-             struct osf_sigaction __user *oact)
+SYSCALL_DEFINE3(osf_sigaction, int, sig,
+               const struct osf_sigaction __user *, act,
+               struct osf_sigaction __user *, oact)
 {
        struct k_sigaction new_ka, old_ka;
        int ret;
@@ -113,10 +114,9 @@ osf_sigaction(int sig, const struct osf_sigaction __user *act,
        return ret;
 }
 
-asmlinkage long
-sys_rt_sigaction(int sig, const struct sigaction __user *act,
-                struct sigaction __user *oact,
-                size_t sigsetsize, void __user *restorer)
+SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
+               struct sigaction __user *, oact,
+               size_t, sigsetsize, void __user *, restorer)
 {
        struct k_sigaction new_ka, old_ka;
        int ret;
@@ -147,11 +147,9 @@ sys_rt_sigaction(int sig, const struct sigaction __user *act,
 asmlinkage int
 do_sigsuspend(old_sigset_t mask, struct pt_regs *regs, struct switch_stack *sw)
 {
-       sigset_t oldset;
-
        mask &= _BLOCKABLE;
        spin_lock_irq(&current->sighand->siglock);
-       oldset = current->blocked;
+       current->saved_sigmask = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
        spin_unlock_irq(&current->sighand->siglock);
@@ -161,19 +159,17 @@ do_sigsuspend(old_sigset_t mask, struct pt_regs *regs, struct switch_stack *sw)
        regs->r0 = EINTR;
        regs->r19 = 1;
 
-       while (1) {
-               current->state = TASK_INTERRUPTIBLE;
-               schedule();
-               if (do_signal(&oldset, regs, sw, 0, 0))
-                       return -EINTR;
-       }
+       current->state = TASK_INTERRUPTIBLE;
+       schedule();
+       set_thread_flag(TIF_RESTORE_SIGMASK);
+       return -ERESTARTNOHAND;
 }
 
 asmlinkage int
 do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize,
                 struct pt_regs *regs, struct switch_stack *sw)
 {
-       sigset_t oldset, set;
+       sigset_t set;
 
        /* XXX: Don't preclude handling different sized sigset_t's.  */
        if (sigsetsize != sizeof(sigset_t))
@@ -183,7 +179,7 @@ do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize,
 
        sigdelsetmask(&set, ~_BLOCKABLE);
        spin_lock_irq(&current->sighand->siglock);
-       oldset = current->blocked;
+       current->saved_sigmask = current->blocked;
        current->blocked = set;
        recalc_sigpending();
        spin_unlock_irq(&current->sighand->siglock);
@@ -193,12 +189,10 @@ do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize,
        regs->r0 = EINTR;
        regs->r19 = 1;
 
-       while (1) {
-               current->state = TASK_INTERRUPTIBLE;
-               schedule();
-               if (do_signal(&oldset, regs, sw, 0, 0))
-                       return -EINTR;
-       }
+       current->state = TASK_INTERRUPTIBLE;
+       schedule();
+       set_thread_flag(TIF_RESTORE_SIGMASK);
+       return -ERESTARTNOHAND;
 }
 
 asmlinkage int
@@ -375,7 +369,7 @@ give_sigsegv:
 static inline void __user *
 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 {
-       if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
+       if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
                sp = current->sas_ss_sp + current->sas_ss_size;
 
        return (void __user *)((sp - frame_size) & -32ul);
@@ -437,7 +431,7 @@ setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
        return err;
 }
 
-static void
+static int
 setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
            struct pt_regs *regs, struct switch_stack * sw)
 {
@@ -482,13 +476,14 @@ setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
                current->comm, current->pid, frame, regs->pc, regs->r26);
 #endif
 
-       return;
+       return 0;
 
 give_sigsegv:
        force_sigsegv(sig, current);
+       return -EFAULT;
 }
 
-static void
+static int
 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
               sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
 {
@@ -544,35 +539,38 @@ setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
                current->comm, current->pid, frame, regs->pc, regs->r26);
 #endif
 
-       return;
+       return 0;
 
 give_sigsegv:
        force_sigsegv(sig, current);
+       return -EFAULT;
 }
 
 
 /*
  * OK, we're invoking a handler.
  */
-static inline void
+static inline int
 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
              sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw)
 {
+       int ret;
+
        if (ka->sa.sa_flags & SA_SIGINFO)
-               setup_rt_frame(sig, ka, info, oldset, regs, sw);
+               ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
        else
-               setup_frame(sig, ka, oldset, regs, sw);
+               ret = setup_frame(sig, ka, oldset, regs, sw);
 
-       if (ka->sa.sa_flags & SA_RESETHAND)
-               ka->sa.sa_handler = SIG_DFL;
-
-       if (!(ka->sa.sa_flags & SA_NODEFER)) {
+       if (ret == 0) {
                spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
-               sigaddset(&current->blocked,sig);
+               if (!(ka->sa.sa_flags & SA_NODEFER)) 
+                       sigaddset(&current->blocked,sig);
                recalc_sigpending();
                spin_unlock_irq(&current->sighand->siglock);
        }
+
+       return ret;
 }
 
 static inline void
@@ -613,30 +611,42 @@ syscall_restart(unsigned long r0, unsigned long r19,
  * restart. "r0" is also used as an indicator whether we can restart at
  * all (if we get here from anything but a syscall return, it will be 0)
  */
-static int
-do_signal(sigset_t *oldset, struct pt_regs * regs, struct switch_stack * sw,
+static void
+do_signal(struct pt_regs * regs, struct switch_stack * sw,
          unsigned long r0, unsigned long r19)
 {
        siginfo_t info;
        int signr;
        unsigned long single_stepping = ptrace_cancel_bpt(current);
        struct k_sigaction ka;
+       sigset_t *oldset;
 
-       if (!oldset)
+       if (test_thread_flag(TIF_RESTORE_SIGMASK))
+               oldset = &current->saved_sigmask;
+       else
                oldset = &current->blocked;
 
        /* This lets the debugger run, ... */
        signr = get_signal_to_deliver(&info, &ka, regs, NULL);
+
        /* ... so re-check the single stepping. */
        single_stepping |= ptrace_cancel_bpt(current);
 
        if (signr > 0) {
                /* Whee!  Actually deliver the signal.  */
-               if (r0) syscall_restart(r0, r19, regs, &ka);
-               handle_signal(signr, &ka, &info, oldset, regs, sw);
+               if (r0)
+                       syscall_restart(r0, r19, regs, &ka);
+               if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
+                       /* A signal was successfully delivered, and the
+                          saved sigmask was stored on the signal frame,
+                          and will be restored by sigreturn.  So we can
+                          simply clear the restore sigmask flag.  */
+                       if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                               clear_thread_flag(TIF_RESTORE_SIGMASK);
+               }
                if (single_stepping) 
                        ptrace_set_bpt(current); /* re-set bpt */
-               return 1;
+               return;
        }
 
        if (r0) {
@@ -656,17 +666,29 @@ do_signal(sigset_t *oldset, struct pt_regs * regs, struct switch_stack * sw,
                        break;
                }
        }
+
+       /* If there's no signal to deliver, we just restore the saved mask.  */
+       if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+               clear_thread_flag(TIF_RESTORE_SIGMASK);
+               sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+       }
+
        if (single_stepping)
                ptrace_set_bpt(current);        /* re-set breakpoint */
-
-       return 0;
 }
 
 void
-do_notify_resume(sigset_t *oldset, struct pt_regs *regs,
-                struct switch_stack *sw, unsigned long r0,
-                unsigned long r19, unsigned long thread_info_flags)
+do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
+                unsigned long thread_info_flags,
+                unsigned long r0, unsigned long r19)
 {
-       if (thread_info_flags & _TIF_SIGPENDING)
-               do_signal(oldset, regs, sw, r0, r19);
+       if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
+               do_signal(regs, sw, r0, r19);
+
+       if (thread_info_flags & _TIF_NOTIFY_RESUME) {
+               clear_thread_flag(TIF_NOTIFY_RESUME);
+               tracehook_notify_resume(regs);
+               if (current->replacement_session_keyring)
+                       key_replace_session_keyring();
+       }
 }