Merge tag 'sched-core-2026-06-14' of gitolite.kernel.org:pub/scm/linux/kernel/git...

Pull scheduler updates from Ingo Molnar:
 "SMP load-balancing updates:

   - A large series to introduce infrastructure for cache-aware load
     balancing, with the goal of co-locating tasks that share data
     within the same Last Level Cache (LLC) domain. By improving cache
     locality, the scheduler can reduce cache bouncing and cache misses,
     ultimately improving data access efficiency.

     Implemented by Chen Yu and Tim Chen, based on early prototype work
     by Peter Zijlstra, with fixes by Jianyong Wu, Peter Zijlstra and
     Shrikanth Hegde.

   - A series to simplify CONFIG_SCHED_SMT ifdef usage (Shrikanth Hegde)

  Fair scheduler updates:

   - A series to improve SD_ASYM_CPUCAPACITY scheduling by introducing
     SMT awareness (Andrea Righi, K Prateek Nayak)

   - A series to optimize cfs_rq and sched_entity allocation for better
     data locality (Zecheng Li)

   - A preparatory series to change fair/cgroup scheduling to a single
     runqueue, without the final change (Peter Zijlstra)

   - Auto-manage ext/fair dl_server bandwidth (Andrea Righi)

   - Fix cpu_util runnable_avg arithmetic (Hongyan Xia)

   - Optimize update_tg_load_avg()'s rate-limiting code (Rik van Riel)

   - Allow account_cfs_rq_runtime() to throttle current hierarchy
     (K Prateek Nayak)

   - Update util_est after updating util_avg during dequeue, to fix the
     util signal update logic, which reduces signal noise (Vincent
     Guittot)

  Scheduler topology updates:

   - Allow multiple domains to claim sched_domain_shared (K Prateek
     Nayak)

   - Add parameter to split LLC (Peter Zijlstra)

  Core scheduler updates:

   - Use trace_call__<tp>() to save a static branch (Gabriele Monaco)

  Scheduler statistics updates:

   - Drop now-stale mul_u64_u64_div_u64() cputime over-approximation
     guard (Nicolas Pitre)

  Deadline scheduler updates:

   - Reject debugfs dl_server writes for offline CPUs (Andrea Righi)

   - Fix replenishment logic for non-deferred servers (Yuri Andriaccio)

  RT scheduling updates:

   - Turn RT_PUSH_IPI default off for non PREEMPT_RT (Steven Rostedt)

   - Update default bandwidth for real-time tasks to 1.0 (Yuri
     Andriaccio)

  Proxy scheduling updates:

   - A series to implement Optimized Donor Migration for Proxy Execution
     (John Stultz, Peter Zijlstra)

   - Various proxy scheduling cleanups and fixes (Peter Zijlstra,
     K Prateek Nayak)

  Misc fixes, improvements and cleanups by Aaron Lu, Andrea Righi,
  Zenghui Yu, Chen Yu, Guanyou.Chen, John Stultz, Shrikanth Hegde,
  Peter Zijlstra, Liang Luo and Yiyang Chen"

* tag 'sched-core-2026-06-14' of gitolite.kernel.org:pub/scm/linux/kernel/git/tip/tip: (91 commits)
  sched/fair: Fix newidle vs core-sched
  sched/deadline: Use task_on_rq_migrating() helper
  sched/core: Combine separate 'else' and 'if' statements
  sched/fair: Fix cpu_util runnable_avg arithmetic
  sched/fair: Unify cfs_rq throttling via account_cfs_rq_runtime()
  sched/fair: Move the throttled tasks to a local list in tg_unthrottle_up()
  sched/fair: Call update_curr() before unthrottling the hierarchy
  sched/fair: Use throttled_csd_list for local unthrottle
  sched/fair: Convert cfs bandwidth throttling to use guards
  sched/fair: Allocate cfs_tg_state with percpu allocator
  sched/fair: Remove task_group->se pointer array
  sched/fair: Co-locate cfs_rq and sched_entity in cfs_tg_state
  sched: restore timer_slack_ns when resetting RT policy on fork
  MAINTAINERS: Fix spelling mistake in Peter's name
  sched: Simplify ttwu_runnable()
  sched/proxy: Remove superfluous clear_task_blocked_in()
  sched/proxy: Remove PROXY_WAKING
  sched/proxy: Switch proxy to use p->is_blocked
  sched/proxy: Only return migrate when needed
  sched: Be more strict about p->is_blocked
  ...

diff --cc Documentation/admin-guide/kernel-parameters.txt
Simple merge

diff --cc MAINTAINERS
Simple merge

diff --cc arch/x86/include/asm/processor.h
Simple merge

diff --cc include/linux/mm_types.h
Simple merge

diff --cc include/linux/sched.h
Simple merge

diff --cc init/Kconfig
Simple merge

diff --cc init/init_task.c
Simple merge

diff --cc kernel/exit.c
Simple merge

diff --cc kernel/fork.c
Simple merge

diff --cc kernel/locking/mutex.c
index 43b7f7e281a0fa90fadbfa991d4b715335a7d7e0,89d01f7889736b8fbcfe7aab0d1239a7230579ca..8a85912d7ee6ce8dddfff657afbe70e249f3d169
--- 1/kernel/locking/mutex.c
--- 2/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@@ -1013,19 -1027,44 +1027,47 @@@ static noinline void __sched __mutex_un
        }
  
        raw_spin_lock_irqsave(&lock->wait_lock, flags);
+       raw_spin_lock(&current->blocked_lock);
        debug_mutex_unlock(lock);
+ 
+       if (sched_proxy_exec()) {
+               /*
+                * If we have a task boosting current, and that task was boosting
+                * current through this lock, hand the lock to that task, as that
+                * is the highest waiter, as selected by the scheduling function.
+                */
+               donor = current->blocked_donor;
+               if (donor) {
+                       struct mutex *next_lock;
+ 
+                       raw_spin_lock_nested(&donor->blocked_lock, SINGLE_DEPTH_NESTING);
+                       next_lock = __get_task_blocked_on(donor);
+                       if (next_lock == lock) {
+                               next = get_task_struct(donor);
+                               __clear_task_blocked_on(next, lock);
+                               current->blocked_donor = NULL;
+                       }
+                       raw_spin_unlock(&donor->blocked_lock);
+               }
+       }
+ 
+       /*
+        * Failing that, pick first on the wait list.
+        */
        waiter = lock->first_waiter;
-       if (waiter) {
-               next = waiter->task;
+       if (!next && waiter) {
+               next = get_task_struct(waiter->task);
  
+               raw_spin_lock_nested(&next->blocked_lock, SINGLE_DEPTH_NESTING);
                debug_mutex_wake_waiter(lock, waiter);
-               set_task_blocked_on_waking(next, lock);
-               wake_q_add(&wake_q, next);
+               __clear_task_blocked_on(next, lock);
+               raw_spin_unlock(&next->blocked_lock);
+ 
        }
  
 +      if (trace_contended_release_enabled() && waiter)
 +              trace_call__contended_release(lock);
 +
        if (owner & MUTEX_FLAG_HANDOFF)
                __mutex_handoff(lock, next);
  

diff --cc kernel/sched/core.c
Simple merge

diff --cc kernel/sched/cputime.c
Simple merge

diff --cc kernel/sched/deadline.c
Simple merge

diff --cc kernel/sched/ext.c
Simple merge

diff --cc kernel/sched/ext_idle.c
Simple merge

diff --cc kernel/sched/idle.c
Simple merge

diff --cc kernel/trace/ring_buffer.c
Simple merge

diff --cc kernel/workqueue.c
Simple merge