diff mbox series

[GIT,pull] core/core for v6.7-rc1

Message ID 169861500709.181063.7816209662289132093.tglx@xen13
State New
Headers
Series [GIT,pull] core/core for v6.7-rc1 |

Commit Message

Thomas Gleixner Oct. 29, 2023, 9:33 p.m. UTC 
  Linus,

please pull the latest core/core branch from:

   git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git core-core-2023-10-29-v2

up to:  1aabbc532413: signal: Don't disable preemption in ptrace_stop() on PREEMPT_RT

Two small updates to ptrace_stop():

  - Add a comment to explain that the preempt_disable() before unlocking
    tasklist lock is not a correctness problem and just avoids the tracer
    to preempt the tracee before the tracee schedules out.

  - Make that preempt_disable() conditional on PREEMPT_RT=n.

    RT enabled kernels cannot disable preemption at this point because
    cgroup_enter_frozen() and sched_submit_work() acquire spinlocks or
    rwlocks which are substituted by sleeping locks on RT. Acquiring a
    sleeping lock in a preemption disable region is obviously not possible.

    This obviously brings back the potential slowdown of ptrace() for RT
    enabled kernels, but that's a price to be payed for latency guarantees.

Thanks,

	tglx

------------------>
Sebastian Andrzej Siewior (2):
      signal: Add a proper comment about preempt_disable() in ptrace_stop()
      signal: Don't disable preemption in ptrace_stop() on PREEMPT_RT


 kernel/signal.c | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

Comments

pr-tracker-bot@kernel.org Oct. 31, 2023, 3:52 a.m. UTC | #1 
The pull request you sent on Sun, 29 Oct 2023 22:33:24 +0100 (CET):

> git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git core-core-2023-10-29-v2

has been merged into torvalds/linux.git:
https://git.kernel.org/torvalds/c/9cc6fea175e41580000419a90fa744ba46aa4722

Thank you!
diff mbox series

Patch

diff --git a/kernel/signal.c b/kernel/signal.c
index 09019017d669..f2a5578326ad 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2329,15 +2329,38 @@  static int ptrace_stop(int exit_code, int why, unsigned long message,
 		do_notify_parent_cldstop(current, false, why);
 
 	/*
-	 * Don't want to allow preemption here, because
-	 * sys_ptrace() needs this task to be inactive.
+	 * The previous do_notify_parent_cldstop() invocation woke ptracer.
+	 * One a PREEMPTION kernel this can result in preemption requirement
+	 * which will be fulfilled after read_unlock() and the ptracer will be
+	 * put on the CPU.
+	 * The ptracer is in wait_task_inactive(, __TASK_TRACED) waiting for
+	 * this task wait in schedule(). If this task gets preempted then it
+	 * remains enqueued on the runqueue. The ptracer will observe this and
+	 * then sleep for a delay of one HZ tick. In the meantime this task
+	 * gets scheduled, enters schedule() and will wait for the ptracer.
 	 *
-	 * XXX: implement read_unlock_no_resched().
+	 * This preemption point is not bad from a correctness point of
+	 * view but extends the runtime by one HZ tick time due to the
+	 * ptracer's sleep.  The preempt-disable section ensures that there
+	 * will be no preemption between unlock and schedule() and so
+	 * improving the performance since the ptracer will observe that
+	 * the tracee is scheduled out once it gets on the CPU.
+	 *
+	 * On PREEMPT_RT locking tasklist_lock does not disable preemption.
+	 * Therefore the task can be preempted after do_notify_parent_cldstop()
+	 * before unlocking tasklist_lock so there is no benefit in doing this.
+	 *
+	 * In fact disabling preemption is harmful on PREEMPT_RT because
+	 * the spinlock_t in cgroup_enter_frozen() must not be acquired
+	 * with preemption disabled due to the 'sleeping' spinlock
+	 * substitution of RT.
 	 */
-	preempt_disable();
+	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
+		preempt_disable();
 	read_unlock(&tasklist_lock);
 	cgroup_enter_frozen();
-	preempt_enable_no_resched();
+	if (!IS_ENABLED(CONFIG_PREEMPT_RT))
+		preempt_enable_no_resched();
 	schedule();
 	cgroup_leave_frozen(true);