1 files changed, 86 insertions, 12 deletions

diff --git a/kernel/signal.c b/kernel/signal.c
index 934ae5e687b9..9dda83b9db01 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -206,13 +206,47 @@ static inline void print_dropped_signal(int sig)
                                 current->comm, current->pid, sig);
 }
 
+#ifdef __HAVE_ARCH_CMPXCHG
+static inline struct sigqueue *get_task_cache(struct task_struct *t)
+{
+        struct sigqueue *q = t->sigqueue_cache;
+
+        if (cmpxchg(&t->sigqueue_cache, q, NULL) != q)
+                return NULL;
+
+        return q;
+}
+
+static inline int put_task_cache(struct task_struct *t, struct sigqueue *q)
+{
+        if (cmpxchg(&t->sigqueue_cache, NULL, q) == NULL)
+                return 0;
+
+        return 1;
+}
+
+#else
+
+static inline struct sigqueue *get_task_cache(struct task_struct *t)
+{
+        return NULL;
+}
+
+static inline int put_task_cache(struct task_struct *t, struct sigqueue *q)
+{
+        return 1;
+}
+
+#endif
+
 /*
  * allocate a new signal queue record
  * - this may be called without locks if and only if t == current, otherwise an
  *   appopriate lock must be held to stop the target task from exiting
  */
 static struct sigqueue *
-__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
+__sigqueue_do_alloc(int sig, struct task_struct *t, gfp_t flags,
+                    int override_rlimit, int fromslab)
 {
         struct sigqueue *q = NULL;
         struct user_struct *user;
@@ -229,7 +263,10 @@ __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimi
         if (override_rlimit ||
             atomic_read(&user->sigpending) <=
                         t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur) {
-                q = kmem_cache_alloc(sigqueue_cachep, flags);
+                if (!fromslab)
+                        q = get_task_cache(t);
+                if (!q)
+                        q = kmem_cache_alloc(sigqueue_cachep, flags);
         } else {
                 print_dropped_signal(sig);
         }
@@ -246,6 +283,13 @@ __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimi
         return q;
 }
 
+static struct sigqueue *
+__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags,
+                 int override_rlimit)
+{
+        return __sigqueue_do_alloc(sig, t, flags, override_rlimit, 0);
+}
+
 static void __sigqueue_free(struct sigqueue *q)
 {
         if (q->flags & SIGQUEUE_PREALLOC)
@@ -255,6 +299,21 @@ static void __sigqueue_free(struct sigqueue *q)
         kmem_cache_free(sigqueue_cachep, q);
 }
 
+static void sigqueue_free_current(struct sigqueue *q)
+{
+        struct user_struct *up;
+
+        if (q->flags & SIGQUEUE_PREALLOC)
+                return;
+
+        up = q->user;
+        if (rt_prio(current->normal_prio) && !put_task_cache(current, q)) {
+                atomic_dec(&up->sigpending);
+                free_uid(up);
+        } else
+                  __sigqueue_free(q);
+}
+
 void flush_sigqueue(struct sigpending *queue)
 {
         struct sigqueue *q;
@@ -268,6 +327,21 @@ void flush_sigqueue(struct sigpending *queue)
 }
 
 /*
+ * Called from __exit_signal. Flush tsk->pending and
+ * tsk->sigqueue_cache
+ */
+void flush_task_sigqueue(struct task_struct *tsk)
+{
+        struct sigqueue *q;
+
+        flush_sigqueue(&tsk->pending);
+
+        q = get_task_cache(tsk);
+        if (q)
+                kmem_cache_free(sigqueue_cachep, q);
+}
+
+/*
  * Flush all pending signals for a task.
  */
 void __flush_signals(struct task_struct *t)
@@ -415,7 +489,7 @@ static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
 still_pending:
                 list_del_init(&first->list);
                 copy_siginfo(info, &first->info);
-                __sigqueue_free(first);
+                sigqueue_free_current(first);
         } else {
                 /* Ok, it wasn't in the queue.  This must be
                    a fast-pathed signal or we must have been
@@ -460,6 +534,8 @@ int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 {
         int signr;
 
+        WARN_ON_ONCE(tsk != current);
+
         /* We only dequeue private signals from ourselves, we don't let
          * signalfd steal them
          */
@@ -542,6 +618,9 @@ void signal_wake_up(struct task_struct *t, int resume)
 
         set_tsk_thread_flag(t, TIF_SIGPENDING);
 
+        if (unlikely(t == current))
+                return;
+
         /*
          * For SIGKILL, we want to wake it up in the stopped/traced/killable
          * case. We don't check t->state here because there is a race with it
@@ -870,7 +949,9 @@ static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
 
         trace_signal_generate(sig, info, t);
 
+#ifdef CONFIG_SMP
         assert_spin_locked(&t->sighand->siglock);
+#endif
 
         if (!prepare_signal(sig, t, from_ancestor_ns))
                 return 0;
@@ -1337,7 +1418,8 @@ EXPORT_SYMBOL(kill_pid);
  */
 struct sigqueue *sigqueue_alloc(void)
 {
-        struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
+        /* Preallocated sigqueue objects always from the slabcache ! */
+        struct sigqueue *q = __sigqueue_do_alloc(-1, current, GFP_KERNEL, 0, 1);
 
         if (q)
                 q->flags |= SIGQUEUE_PREALLOC;
@@ -1630,15 +1712,7 @@ static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
         read_lock(&tasklist_lock);
         if (may_ptrace_stop()) {
                 do_notify_parent_cldstop(current, CLD_TRAPPED);
-                /*
-                 * Don't want to allow preemption here, because
-                 * sys_ptrace() needs this task to be inactive.
-                 *
-                 * XXX: implement read_unlock_no_resched().
-                 */
-                preempt_disable();
                 read_unlock(&tasklist_lock);
-                preempt_enable_no_resched();
                 schedule();
         } else {
                 /*