Merge tag 'kernel.sys.v5.16' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner...

[linux-2.6-microblaze.git] / kernel / signal.c

diff --git a/kernel/signal.c b/kernel/signal.c
index e99aff3..6f3476d 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2145,40 +2145,6 @@ static void do_notify_parent_cldstop(struct task_struct *tsk,
        spin_unlock_irqrestore(&sighand->siglock, flags);
 }
 
-static inline bool may_ptrace_stop(void)
-{
-       if (!likely(current->ptrace))
-               return false;
-       /*
-        * Are we in the middle of do_coredump?
-        * If so and our tracer is also part of the coredump stopping
-        * is a deadlock situation, and pointless because our tracer
-        * is dead so don't allow us to stop.
-        * If SIGKILL was already sent before the caller unlocked
-        * ->siglock we must see ->core_state != NULL. Otherwise it
-        * is safe to enter schedule().
-        *
-        * This is almost outdated, a task with the pending SIGKILL can't
-        * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
-        * after SIGKILL was already dequeued.
-        */
-       if (unlikely(current->mm->core_state) &&
-           unlikely(current->mm == current->parent->mm))
-               return false;
-
-       return true;
-}
-
-/*
- * Return non-zero if there is a SIGKILL that should be waking us up.
- * Called with the siglock held.
- */
-static bool sigkill_pending(struct task_struct *tsk)
-{
-       return sigismember(&tsk->pending.signal, SIGKILL) ||
-              sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
-}
-
 /*
  * This must be called with current->sighand->siglock held.
  *
@@ -2196,7 +2162,7 @@ static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t
 {
        bool gstop_done = false;
 
-       if (arch_ptrace_stop_needed(exit_code, info)) {
+       if (arch_ptrace_stop_needed()) {
                /*
                 * The arch code has something special to do before a
                 * ptrace stop.  This is allowed to block, e.g. for faults
@@ -2204,17 +2170,16 @@ static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t
                 * calling arch_ptrace_stop, so we must release it now.
                 * To preserve proper semantics, we must do this before
                 * any signal bookkeeping like checking group_stop_count.
-                * Meanwhile, a SIGKILL could come in before we retake the
-                * siglock.  That must prevent us from sleeping in TASK_TRACED.
-                * So after regaining the lock, we must check for SIGKILL.
                 */
                spin_unlock_irq(&current->sighand->siglock);
-               arch_ptrace_stop(exit_code, info);
+               arch_ptrace_stop();
                spin_lock_irq(&current->sighand->siglock);
-               if (sigkill_pending(current))
-                       return;
        }
 
+       /*
+        * schedule() will not sleep if there is a pending signal that
+        * can awaken the task.
+        */
        set_special_state(TASK_TRACED);
 
        /*
@@ -2260,7 +2225,7 @@ static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t
 
        spin_unlock_irq(&current->sighand->siglock);
        read_lock(&tasklist_lock);
-       if (may_ptrace_stop()) {
+       if (likely(current->ptrace)) {
                /*
                 * Notify parents of the stop.
                 *