Commit df9e2102 authored Dec 09, 2024 by Linus Torvalds

Merge tag 'sched_urgent_for_v6.13_rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull scheduler fixes from Borislav Petkov:

 - Remove wrong enqueueing of a task for a later wakeup when a task
   blocks on a RT mutex

 - Do not setup a new deadline entity on a boosted task as that has
   happened already

 - Update preempt= kernel command line param

 - Prevent needless softirqd wakeups in the idle task's context

 - Detect the case where the idle load balancer CPU becomes busy and
   avoid unnecessary load balancing invocation

 - Remove an unnecessary load balancing need_resched() call in
   nohz_csd_func()

 - Allow for raising of SCHED_SOFTIRQ softirq type on RT but retain the
   warning to catch any other cases

 - Remove a wrong warning when a cpuset update makes the task affinity
   no longer a subset of the cpuset

* tag 'sched_urgent_for_v6.13_rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  locking: rtmutex: Fix wake_q logic in task_blocks_on_rt_mutex
  sched/deadline: Fix warning in migrate_enable for boosted tasks
  sched/core: Update kernel boot parameters for LAZY preempt.
  sched/core: Prevent wakeup of ksoftirqd during idle load balance
  sched/fair: Check idle_cpu() before need_resched() to detect ilb CPU turning busy
  sched/core: Remove the unnecessary need_resched() check in nohz_csd_func()
  softirq: Allow raising SCHED_SOFTIRQ from SMP-call-function on RT kernel
  sched: fix warning in sched_setaffinity
  sched/deadline: Fix replenish_dl_new_period dl_server condition

parents aeb68937 82f9cc09

Documentation/admin-guide/kernel-parameters.txt

+5 −0

Original line number	Diff line number	Diff line
		@@ -4822,6 +4822,11 @@
		can be preempted anytime. Tasks will also yield
		contended spinlocks (if the critical section isn't
		explicitly preempt disabled beyond the lock itself).
		lazy - Scheduler controlled. Similar to full but instead
		of preempting the task immediately, the task gets
		one HZ tick time to yield itself before the
		preemption will be forced. One preemption is when the
		task returns to user space.

		print-fatal-signals=
		[KNL] debug: print fatal signals

kernel/locking/rtmutex.c

+0 −3

Original line number	Diff line number	Diff line
		@@ -1248,10 +1248,7 @@ static int __sched task_blocks_on_rt_mutex(struct rt_mutex_base *lock,

		/* Check whether the waiter should back out immediately */
		rtm = container_of(lock, struct rt_mutex, rtmutex);
		preempt_disable();
		res = __ww_mutex_add_waiter(waiter, rtm, ww_ctx, wake_q);
		wake_up_q(wake_q);
		preempt_enable();
		if (res) {
		raw_spin_lock(&task->pi_lock);
		rt_mutex_dequeue(lock, waiter);

kernel/sched/core.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -1283,9 +1283,9 @@ static void nohz_csd_func(void *info)
		WARN_ON(!(flags & NOHZ_KICK_MASK));

		rq->idle_balance = idle_cpu(cpu);
		if (rq->idle_balance && !need_resched()) {
		if (rq->idle_balance) {
		rq->nohz_idle_balance = flags;
		raise_softirq_irqoff(SCHED_SOFTIRQ);
		__raise_softirq_irqoff(SCHED_SOFTIRQ);
		}
		}

kernel/sched/deadline.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -781,7 +781,7 @@ static inline void replenish_dl_new_period(struct sched_dl_entity *dl_se,
		* If it is a deferred reservation, and the server
		* is not handling an starvation case, defer it.
		*/
		if (dl_se->dl_defer & !dl_se->dl_defer_running) {
		if (dl_se->dl_defer && !dl_se->dl_defer_running) {
		dl_se->dl_throttled = 1;
		dl_se->dl_defer_armed = 1;
		}
		@@ -2042,6 +2042,7 @@ enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags)
		} else if (flags & ENQUEUE_REPLENISH) {
		replenish_dl_entity(dl_se);
		} else if ((flags & ENQUEUE_RESTORE) &&
		!is_dl_boosted(dl_se) &&
		dl_time_before(dl_se->deadline, rq_clock(rq_of_dl_se(dl_se)))) {
		setup_new_dl_entity(dl_se);
		}

kernel/sched/fair.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -12574,7 +12574,7 @@ static void _nohz_idle_balance(struct rq *this_rq, unsigned int flags)
		* work being done for other CPUs. Next load
		* balancing owner will pick it up.
		*/
		if (need_resched()) {
		if (!idle_cpu(this_cpu) && need_resched()) {
		if (flags & NOHZ_STATS_KICK)
		has_blocked_load = true;
		if (flags & NOHZ_NEXT_KICK)