signals: move handle_stop_signal() into send_signal()

[linux-2.6-omap-h63xx.git] / kernel / signal.c

diff --git a/kernel/signal.c b/kernel/signal.c
index b266fa46402aea734f0dce3e7b40cbc57e8ca51e..b3dedf1f932367ca09062d69a3ee6852984d34a8 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -660,8 +660,10 @@ static inline int legacy_queue(struct sigpending *signals, int sig)
 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
                        struct sigpending *signals)
 {
-       struct sigqueue * q = NULL;
+       struct sigqueue *q;
 
+       assert_spin_locked(&t->sighand->siglock);
+       handle_stop_signal(sig, t);
        /*
         * Short-circuit ignored signals and support queuing
         * exactly one non-rt signal, so that we can get more
@@ -766,9 +768,6 @@ specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
 {
        int ret;
 
-       BUG_ON(!irqs_disabled());
-       assert_spin_locked(&t->sighand->siglock);
-
        ret = send_signal(sig, info, t, &t->pending);
        if (ret <= 0)
                return ret;
@@ -842,6 +841,7 @@ static inline int wants_signal(int sig, struct task_struct *p)
 static void
 __group_complete_signal(int sig, struct task_struct *p)
 {
+       struct signal_struct *signal = p->signal;
        struct task_struct *t;
 
        /*
@@ -862,14 +862,14 @@ __group_complete_signal(int sig, struct task_struct *p)
                /*
                 * Otherwise try to find a suitable thread.
                 */
-               t = p->signal->curr_target;
+               t = signal->curr_target;
                if (t == NULL)
                        /* restart balancing at this thread */
-                       t = p->signal->curr_target = p;
+                       t = signal->curr_target = p;
 
                while (!wants_signal(sig, t)) {
                        t = next_thread(t);
-                       if (t == p->signal->curr_target)
+                       if (t == signal->curr_target)
                                /*
                                 * No thread needs to be woken.
                                 * Any eligible threads will see
@@ -877,14 +877,14 @@ __group_complete_signal(int sig, struct task_struct *p)
                                 */
                                return;
                }
-               p->signal->curr_target = t;
+               signal->curr_target = t;
        }
 
        /*
         * Found a killable thread.  If the signal will be fatal,
         * then start taking the whole group down immediately.
         */
-       if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
+       if (sig_fatal(p, sig) && !(signal->flags & SIGNAL_GROUP_EXIT) &&
            !sigismember(&t->real_blocked, sig) &&
            (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
                /*
@@ -897,9 +897,9 @@ __group_complete_signal(int sig, struct task_struct *p)
                         * running and doing things after a slower
                         * thread has the fatal signal pending.
                         */
-                       p->signal->flags = SIGNAL_GROUP_EXIT;
-                       p->signal->group_exit_code = sig;
-                       p->signal->group_stop_count = 0;
+                       signal->flags = SIGNAL_GROUP_EXIT;
+                       signal->group_exit_code = sig;
+                       signal->group_stop_count = 0;
                        t = p;
                        do {
                                sigaddset(&t->pending.signal, SIGKILL);
@@ -922,9 +922,6 @@ __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
 {
        int ret;
 
-       assert_spin_locked(&p->sighand->siglock);
-       handle_stop_signal(sig, p);
-
        /*
         * Put this signal on the shared-pending queue, or fail with EAGAIN.
         * We always use the shared queue for process-wide signals,
@@ -1274,8 +1271,10 @@ void sigqueue_free(struct sigqueue *q)
 }
 
 static int do_send_sigqueue(int sig, struct sigqueue *q, struct task_struct *t,
-               struct sigpending *pending)
+                               struct sigpending *pending)
 {
+       handle_stop_signal(sig, t);
+
        if (unlikely(!list_empty(&q->list))) {
                /*
                 * If an SI_TIMER entry is already queue just increment
@@ -1311,8 +1310,6 @@ int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
         * We return -1, when the task is marked exiting, so
         * posix_timer_event can redirect it to the group leader
         */
-       rcu_read_lock();
-
        if (!likely(lock_task_sighand(p, &flags)))
                goto out_err;
 
@@ -1323,8 +1320,6 @@ int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
 
        unlock_task_sighand(p, &flags);
 out_err:
-       rcu_read_unlock();
-
        return ret;
 }
 
@@ -1336,17 +1331,15 @@ send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
 
        BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
 
-       read_lock(&tasklist_lock);
        /* Since it_lock is held, p->sighand cannot be NULL. */
        spin_lock_irqsave(&p->sighand->siglock, flags);
-       handle_stop_signal(sig, p);
 
        ret = do_send_sigqueue(sig, q, p, &p->signal->shared_pending);
 
        __group_complete_signal(sig, p);
 
        spin_unlock_irqrestore(&p->sighand->siglock, flags);
-       read_unlock(&tasklist_lock);
+
        return ret;
 }
 
@@ -1753,8 +1746,9 @@ static int ptrace_signal(int signr, siginfo_t *info,
 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
                          struct pt_regs *regs, void *cookie)
 {
-       sigset_t *mask = &current->blocked;
-       int signr = 0;
+       struct sighand_struct *sighand = current->sighand;
+       struct signal_struct *signal = current->signal;
+       int signr;
 
 relock:
        /*
@@ -1765,13 +1759,13 @@ relock:
         */
        try_to_freeze();
 
-       spin_lock_irq(&current->sighand->siglock);
+       spin_lock_irq(&sighand->siglock);
 
-       if (unlikely(current->signal->flags & SIGNAL_CLD_MASK)) {
-               int why = (current->signal->flags & SIGNAL_STOP_CONTINUED)
+       if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
+               int why = (signal->flags & SIGNAL_STOP_CONTINUED)
                                ? CLD_CONTINUED : CLD_STOPPED;
-               current->signal->flags &= ~SIGNAL_CLD_MASK;
-               spin_unlock_irq(&current->sighand->siglock);
+               signal->flags &= ~SIGNAL_CLD_MASK;
+               spin_unlock_irq(&sighand->siglock);
 
                read_lock(&tasklist_lock);
                do_notify_parent_cldstop(current->group_leader, why);
@@ -1782,12 +1776,11 @@ relock:
        for (;;) {
                struct k_sigaction *ka;
 
-               if (unlikely(current->signal->group_stop_count > 0) &&
+               if (unlikely(signal->group_stop_count > 0) &&
                    do_signal_stop(0))
                        goto relock;
 
-               signr = dequeue_signal(current, mask, info);
-
+               signr = dequeue_signal(current, &current->blocked, info);
                if (!signr)
                        break; /* will return 0 */
 
@@ -1797,7 +1790,7 @@ relock:
                                continue;
                }
 
-               ka = &current->sighand->action[signr-1];
+               ka = &sighand->action[signr-1];
                if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
                        continue;
                if (ka->sa.sa_handler != SIG_DFL) {
@@ -1834,14 +1827,14 @@ relock:
                         * We need to check for that and bail out if necessary.
                         */
                        if (signr != SIGSTOP) {
-                               spin_unlock_irq(&current->sighand->siglock);
+                               spin_unlock_irq(&sighand->siglock);
 
                                /* signals can be posted during this window */
 
                                if (is_current_pgrp_orphaned())
                                        goto relock;
 
-                               spin_lock_irq(&current->sighand->siglock);
+                               spin_lock_irq(&sighand->siglock);
                        }
 
                        if (likely(do_signal_stop(signr))) {
@@ -1856,7 +1849,7 @@ relock:
                        continue;
                }
 
-               spin_unlock_irq(&current->sighand->siglock);
+               spin_unlock_irq(&sighand->siglock);
 
                /*
                 * Anything else is fatal, maybe with a core dump.
@@ -1882,7 +1875,7 @@ relock:
                do_group_exit(signr);
                /* NOTREACHED */
        }
-       spin_unlock_irq(&current->sighand->siglock);
+       spin_unlock_irq(&sighand->siglock);
        return signr;
 }
 
@@ -2244,7 +2237,6 @@ static int do_tkill(int tgid, int pid, int sig)
                 */
                if (!error && sig && p->sighand) {
                        spin_lock_irq(&p->sighand->siglock);
-                       handle_stop_signal(sig, p);
                        error = specific_send_sig_info(sig, &info, p);
                        spin_unlock_irq(&p->sighand->siglock);
                }