ptrace: Always put ptracee into appropriate execution state
[linux-3.10.git] / kernel / ptrace.c
index e609843..4348586 100644 (file)
@@ -41,7 +41,26 @@ void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
  * __ptrace_unlink - unlink ptracee and restore its execution state
  * @child: ptracee to be unlinked
  *
- * Remove @child from the ptrace list, move it back to the original parent.
+ * Remove @child from the ptrace list, move it back to the original parent,
+ * and restore the execution state so that it conforms to the group stop
+ * state.
+ *
+ * Unlinking can happen via two paths - explicit PTRACE_DETACH or ptracer
+ * exiting.  For PTRACE_DETACH, unless the ptracee has been killed between
+ * ptrace_check_attach() and here, it's guaranteed to be in TASK_TRACED.
+ * If the ptracer is exiting, the ptracee can be in any state.
+ *
+ * After detach, the ptracee should be in a state which conforms to the
+ * group stop.  If the group is stopped or in the process of stopping, the
+ * ptracee should be put into TASK_STOPPED; otherwise, it should be woken
+ * up from TASK_TRACED.
+ *
+ * If the ptracee is in TASK_TRACED and needs to be moved to TASK_STOPPED,
+ * it goes through TRACED -> RUNNING -> STOPPED transition which is similar
+ * to but in the opposite direction of what happens while attaching to a
+ * stopped task.  However, in this direction, the intermediate RUNNING
+ * state is not hidden even from the current ptracer and if it immediately
+ * re-attaches and performs a WNOHANG wait(2), it may fail.
  *
  * CONTEXT:
  * write_lock_irq(tasklist_lock)
@@ -55,25 +74,25 @@ void __ptrace_unlink(struct task_struct *child)
        list_del_init(&child->ptrace_entry);
 
        spin_lock(&child->sighand->siglock);
-       if (task_is_traced(child)) {
-               /*
-                * If group stop is completed or in progress, it should
-                * participate in the group stop.  Set GROUP_STOP_PENDING
-                * before kicking it.
-                *
-                * This involves TRACED -> RUNNING -> STOPPED transition
-                * which is similar to but in the opposite direction of
-                * what happens while attaching to a stopped task.
-                * However, in this direction, the intermediate RUNNING
-                * state is not hidden even from the current ptracer and if
-                * it immediately re-attaches and performs a WNOHANG
-                * wait(2), it may fail.
-                */
-               if (child->signal->flags & SIGNAL_STOP_STOPPED ||
-                   child->signal->group_stop_count)
-                       child->group_stop |= GROUP_STOP_PENDING;
-               signal_wake_up(child, 1);
-       }
+
+       /*
+        * Reinstate GROUP_STOP_PENDING if group stop is in effect and
+        * @child isn't dead.
+        */
+       if (!(child->flags & PF_EXITING) &&
+           (child->signal->flags & SIGNAL_STOP_STOPPED ||
+            child->signal->group_stop_count))
+               child->group_stop |= GROUP_STOP_PENDING;
+
+       /*
+        * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick
+        * @child in the butt.  Note that @resume should be used iff @child
+        * is in TASK_TRACED; otherwise, we might unduly disrupt
+        * TASK_KILLABLE sleeps.
+        */
+       if (child->group_stop & GROUP_STOP_PENDING || task_is_traced(child))
+               signal_wake_up(child, task_is_traced(child));
+
        spin_unlock(&child->sighand->siglock);
 }