ptrace: Kill tracehook_notify_jctl()

tracehook_notify_jctl() aids in determining whether and what to report
to the parent when a task is stopped or continued.  The function also
adds an extra requirement that siglock may be released across it,
which is currently unused and quite difficult to satisfy in
well-defined manner.

As job control and the notifications are about to receive major
overhaul, remove the tracehook and open code it.  If ever necessary,
let's factor it out after the overhaul.

* Oleg spotted incorrect CLD_CONTINUED/STOPPED selection when ptraced.
  Fixed.

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Roland McGrath <roland@redhat.com>

diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index 3a2e66d88a32c41db9e978c700601c4c132ea54c..b073f3c8adc30d0c8d68b3709dae5edcaae4c589 100644 (file)
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -468,33 +468,6 @@ static inline int tracehook_get_signal(struct task_struct *task,
        return 0;
 }
 
-/**
- * tracehook_notify_jctl - report about job control stop/continue
- * @notify:            zero, %CLD_STOPPED or %CLD_CONTINUED
- * @why:               %CLD_STOPPED or %CLD_CONTINUED
- *
- * This is called when we might call do_notify_parent_cldstop().
- *
- * @notify is zero if we would not ordinarily send a %SIGCHLD,
- * or is the %CLD_STOPPED or %CLD_CONTINUED .si_code for %SIGCHLD.
- *
- * @why is %CLD_STOPPED when about to stop for job control;
- * we are already in %TASK_STOPPED state, about to call schedule().
- * It might also be that we have just exited (check %PF_EXITING),
- * but need to report that a group-wide stop is complete.
- *
- * @why is %CLD_CONTINUED when waking up after job control stop and
- * ready to make a delayed @notify report.
- *
- * Return the %CLD_* value for %SIGCHLD, or zero to generate no signal.
- *
- * Called with the siglock held.
- */
-static inline int tracehook_notify_jctl(int notify, int why)
-{
-       return notify ?: (current->ptrace & PT_PTRACED) ? why : 0;
-}
-
 /**
  * tracehook_finish_jctl - report about return from job control stop
  *

diff --git a/kernel/signal.c b/kernel/signal.c
index f4db76986ec15e0338016d15f4109bbe9db1fac5..03d874e1058fe85d2317dff85cd1f2eb8d08f52c 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -1727,7 +1727,7 @@ void ptrace_notify(int exit_code)
 static int do_signal_stop(int signr)
 {
        struct signal_struct *sig = current->signal;
-       int notify;
+       int notify = 0;
 
        if (!sig->group_stop_count) {
                struct task_struct *t;
@@ -1759,19 +1759,16 @@ static int do_signal_stop(int signr)
         * a group stop in progress and we are the last to stop, report
         * to the parent.  When ptraced, every thread reports itself.
         */
-       notify = sig->group_stop_count == 1 ? CLD_STOPPED : 0;
-       notify = tracehook_notify_jctl(notify, CLD_STOPPED);
-       /*
-        * tracehook_notify_jctl() can drop and reacquire siglock, so
-        * we keep ->group_stop_count != 0 before the call. If SIGCONT
-        * or SIGKILL comes in between ->group_stop_count == 0.
-        */
-       if (sig->group_stop_count) {
-               if (!--sig->group_stop_count)
-                       sig->flags = SIGNAL_STOP_STOPPED;
-               current->exit_code = sig->group_exit_code;
-               __set_current_state(TASK_STOPPED);
+       if (!--sig->group_stop_count) {
+               sig->flags = SIGNAL_STOP_STOPPED;
+               notify = CLD_STOPPED;
        }
+       if (task_ptrace(current))
+               notify = CLD_STOPPED;
+
+       current->exit_code = sig->group_exit_code;
+       __set_current_state(TASK_STOPPED);
+
        spin_unlock_irq(&current->sighand->siglock);
 
        if (notify) {
@@ -1860,14 +1857,11 @@ relock:
 
                signal->flags &= ~SIGNAL_CLD_MASK;
 
-               why = tracehook_notify_jctl(why, CLD_CONTINUED);
                spin_unlock_irq(&sighand->siglock);
 
-               if (why) {
-                       read_lock(&tasklist_lock);
-                       do_notify_parent_cldstop(current->group_leader, why);
-                       read_unlock(&tasklist_lock);
-               }
+               read_lock(&tasklist_lock);
+               do_notify_parent_cldstop(current->group_leader, why);
+               read_unlock(&tasklist_lock);
                goto relock;
        }
 
@@ -2034,7 +2028,7 @@ void exit_signals(struct task_struct *tsk)
        if (unlikely(tsk->signal->group_stop_count) &&
                        !--tsk->signal->group_stop_count) {
                tsk->signal->flags = SIGNAL_STOP_STOPPED;
-               group_stop = tracehook_notify_jctl(CLD_STOPPED, CLD_STOPPED);
+               group_stop = CLD_STOPPED;
        }
 out:
        spin_unlock_irq(&tsk->sighand->siglock);