Commit 9cc6fea1 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull core updates from Thomas Gleixner:
 "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 paid for latency
     guarantees"

* tag 'core-core-2023-10-29-v2' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  signal: Don't disable preemption in ptrace_stop() on PREEMPT_RT
  signal: Add a proper comment about preempt_disable() in ptrace_stop()
parents ecb8cd2a 1aabbc53

kernel/signal.c

+28 −5
Original line number Diff line number Diff line
@@ -2329,14 +2329,37 @@ 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.

	 */

	if (!IS_ENABLED(CONFIG_PREEMPT_RT))

		preempt_disable();

	read_unlock(&tasklist_lock);

	cgroup_enter_frozen();

	if (!IS_ENABLED(CONFIG_PREEMPT_RT))

		preempt_enable_no_resched();

	schedule();

	cgroup_leave_frozen(true);