Merge tag 'locking-core-2026-08-17' of git://git.kernel.org/pub/scm/linux/kernel...

Pull locking updates from Ingo Molnar:
 "Futexes:

   - Use runtime constants for futex_hash computation (K Prateek Nayak,
     Peter Zijlstra)

   - Optimise the size check get_futex_key() (Sebastian Andrzej Siewior)

   - Avoid private hash use-after-free on final put (Felix Hoffmann)

   - Tell kmemleak we're not leaking __futex_queues (Peter Zijlstra)

  Rust integration updates:

   - Implement refcounted interrupt disable and SpinLockIrq for Rust
     (Boqun Feng, Heiko Carstens, Joel Fernandes, Lyude Paul)

   - Rust sync: add helpers for mb, dma_mb and friends; add generic
     memory barriers and use LKMM atomics instead of Rust atomics in the
     revocable code (Gary Guo)

   - Add abstraction and integrate synchronize_rcu() (Philipp Stanner)

  Lock debugging:

   - Add qspinlock contended_release tracepoint (Dmitry Ilvokhin, Peter
     Zijlstra)

   - Enable the printing of held locks of remote running tasks and print
     task CPU (Ingo Molnar)

   - percpu-rwsem: Annotate intentional data race in readers_active_check()
     (Sun Shaojie)

  Misc fixes and updates by Boqun Feng, Peter Zijlstra, Fangrui Song,
  Naveen Kumar Chaudhary and Thomas Huth"

* tag 'locking-core-2026-08-17' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (44 commits)
  rust: sync: Introduce SpinLockIrq::lock_with() and friends
  rust: sync: Add SpinLockIrq
  rust: sync: Use super::* in spinlock.rs
  rust: helper: Add spin_{un,}lock_irq_{enable,disable}() helpers
  rust: Introduce interrupt module
  s390/preempt: Enable HAS_SEPARATE_PREEMPT_RESCHED_BITS
  arm64: sched/preempt: Enable HAS_SEPARATE_PREEMPT_RESCHED_BITS
  preempt: Introduce HAS_SEPARATE_PREEMPT_RESCHED_BITS
  sched: Avoid signed comparison of preempt_count() in __cant_migrate()
  sched: Remove the unused preempt_offset parameter of __cant_sleep()
  locking: Switch to _irq_{disable,enable}() variants in cleanup guards
  irq: Add KUnit test for refcounted interrupt enable/disable
  irq,spin_lock: Add counted interrupt disabling/enabling
  openrisc: Include <linux/cpumask.h> in smp.h
  preempt: Introduce __preempt_count_{sub,add}_return()
  preempt: Introduce HARDIRQ_DISABLE_BITS
  preempt: Track NMI nesting to separate per-CPU counter
  futex: Tell kmemleak we're not leaking __futex_queues
  x86/paravirt: Trace contended_release on unlock
  tracing/lock: Use TRACE_EVENT_FN() for contended_release
  ...

diff --cc arch/arm64/Kconfig
Simple merge

diff --cc arch/x86/Kconfig
Simple merge

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

diff --cc arch/x86/kernel/cpu/common.c
Simple merge

diff --cc include/asm-generic/vmlinux.lds.h
Simple merge

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

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

diff --cc rust/helpers/helpers.c
Simple merge

diff --cc rust/kernel/lib.rs
Simple merge

diff --cc rust/kernel/sync/rcu.rs
index 42d1b26a214370a966eac75b996fea5a64e9b22e,d867240be7369ae346fd2372648fc30cd81bf141..0daa1ac87d818aca467a0fb5d45f114d05d230a7
--- 1/rust/kernel/sync/rcu.rs
--- 2/rust/kernel/sync/rcu.rs
+++ b/rust/kernel/sync/rcu.rs
@@@ -51,22 -51,18 +51,38 @@@ pub fn read_lock() -> Guard 
      Guard::new()
  }
  
 +/// Wait until all in-flight `call_rcu()` callbacks complete.
 +///
 +/// Note that this primitive does not necessarily wait for an RCU grace period
 +/// to complete. For example, if there are no RCU callbacks queued anywhere
 +/// in the system, then [`rcu_barrier()`] is within its rights to return
 +/// immediately, without waiting for anything, much less an RCU grace period.
 +/// In fact, [`rcu_barrier()`] will normally not result in any RCU grace periods
 +/// beyond those that were already destined to be executed.
 +///
 +/// In kernels built with `CONFIG_RCU_LAZY=y`, this function also hurries all
 +/// pending lazy RCU callbacks.
 +///
 +/// Note that this is one of the RCU primitives which must not be called in
 +/// atomic context.
 +#[inline]
 +pub fn rcu_barrier() {
 +    // SAFETY: `rcu_barrier()` is always safe to be called. It just might wait for a grace period.
 +    unsafe { bindings::rcu_barrier() };
 +}
++
+ /// Wait for one RCU grace period.
+ ///
+ /// Waits for all RCU read-side critical sections (such as those established by
+ /// a [`Guard`]) at the moment of the function call to finish.
+ ///
+ /// Does not prevent new read-side critical sections from starting, which may
+ /// begin and run while this call is blocking.
+ ///
+ /// Note that this is one of the RCU primitives which must not be called in
+ /// atomic context.
+ #[inline]
+ pub fn synchronize_rcu() {
+     // SAFETY: `synchronize_rcu()` is always safe to be called from process context.
+     unsafe { bindings::synchronize_rcu() };
+ }

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

diff --cc tools/testing/selftests/bpf/bpf_experimental.h
index 63e4e472fe36eed4360b2dc1bf68a74fc810870d,0159a3d365c8c1b34c9add7198b2f01c922001ca..f30a4ac939dba16896e1814947fd8478a3fa7c83
--- 1/tools/testing/selftests/bpf/bpf_experimental.h
--- 2/tools/testing/selftests/bpf/bpf_experimental.h
+++ b/tools/testing/selftests/bpf/bpf_experimental.h
@@@ -364,13 -364,11 +364,14 @@@ extern void bpf_iter_dmabuf_destroy(str
  extern int bpf_cgroup_read_xattr(struct cgroup *cgroup, const char *name__str,
                                 struct bpf_dynptr *value_p) __weak __ksym;
  
 +extern int bpf_sock_read_xattr(struct socket *sock, const char *name__str,
 +                             struct bpf_dynptr *value_p) __weak __ksym;
 +
  #define PREEMPT_BITS  8
  #define SOFTIRQ_BITS  8
+ #define HARDIRQ_DISABLE_BITS  8
  #define HARDIRQ_BITS  4
- #define NMI_BITS      4
+ #define NMI_BITS      1
  
  #define PREEMPT_SHIFT 0
  #define SOFTIRQ_SHIFT (PREEMPT_SHIFT + PREEMPT_BITS)