high CVSS 7.8

CVE-2024-35929·Kernel vulnerability

In the Linux kernel, the following vulnerability has been resolved: rcu/nocb: Fix WARN_ON_ONCE() in the rcu_nocb_bypass_lock() For the kernels built with CONFIG_RCU_NOCB_CPU_DEFAULT_ALL=y and CONFIG_RCU_LAZY=y, the following scenarios will trigger WARN_ON_ONCE() in the rcu_nocb_bypass_lock() and rcu_nocb_wait_contended() functions: CPU2 CPU11 kthread rcu_nocb_cb_kthread ksys_write rcu_do_batch vfs_write rcu_torture_timer_cb proc_sys_write __kmem_cache_free proc_sys_call_handler kmemleak_free drop_caches_sysctl_handler delete_object_full drop_slab __delete_object shrink_slab put_object lazy_rcu_shrink_scan call_rcu rcu_nocb_flush_bypass __call_rcu_commn rcu_nocb_bypass_lock raw_spin_trylock(&rdp->nocb_bypass_lock) fail atomic_inc(&rdp->nocb_lock_contended); rcu_nocb_wait_contended WARN_ON_ONCE(smp_processor_id() != rdp->cpu); WARN_ON_ONCE(atomic_read(&rdp->nocb_lock_contended)) | |_ _ _ _ _ _ _ _ _ _same rdp and rdp->cpu != 11_ _ _ _ _ _ _ _ _ __| Reproduce this bug with "echo 3 > /proc/sys/vm/drop_caches". This commit therefore uses rcu_nocb_try_flush_bypass() instead of rcu_nocb_flush_bypass() in lazy_rcu_shrink_scan(). If the nocb_bypass queue is being flushed, then rcu_nocb_try_flush_bypass will return directly.

Severity
high
Software
Kernel
Fixed in
6.8.6
Published
2024-05-19

Affected versions

From: 6.7

Until: 6.8.6

Fixed in: 6.8.6

How to fix this CVE

Update your Linux kernel to version 6.8.6 or later to resolve a race condition in the RCU nocb (no-callback) subsystem that triggers false WARN_ON_ONCE warnings under specific memory pressure conditions. Systems using CONFIG_RCU_NOCB_CPU_DEFAULT_ALL and CONFIG_RCU_LAZY should prioritize this patch, particularly those experiencing cache drop operations or memory shrinking scenarios.

sudo dnf update kernel

Defensia detects this vulnerability

How to check if you are affected

  1. Step 1: Check your kernel version with `uname -r` — compare the version string against 6.8.6; versions 6.7.x through 6.8.5 are vulnerable
  2. Step 2: Verify RCU NOCB configuration with `grep CONFIG_RCU_NOCB_CPU_DEFAULT_ALL /boot/config-$(uname -r)` and `grep CONFIG_RCU_LAZY /boot/config-$(uname -r)` — both must be set to 'y' for exploitation path to exist
  3. Step 3: Monitor kernel logs for WARN_ON_ONCE stack traces mentioning 'rcu_nocb_bypass_lock()' or 'rcu_nocb_wait_contended()' with `dmesg | grep -i 'warn_on_once\|nocb'`
  4. Step 4: After patching, confirm the new kernel is active with `uname -r` and verify no nocb-related warnings appear in logs after running cache drops like `echo 3 > /proc/sys/vm/drop_caches`

FAQ

What is CVE-2024-35929?

A race condition in the Linux kernel's RCU (Read-Copy-Update) no-callback subsystem that causes spurious WARN_ON_ONCE warnings when memory pressure triggers cache shrinking operations on systems with specific RCU configurations enabled. This is a logic bug rather than a security vulnerability, but impacts system stability and logging reliability.

Is CVE-2024-35929 being actively exploited?

No — this vulnerability is not listed in CISA's KEV catalog and there are no known public exploits. It manifests as a kernel warning condition rather than a security breach.

What versions of Kernel are affected by CVE-2024-35929?

Linux kernel versions 6.7.0 through 6.8.5 are vulnerable when compiled with CONFIG_RCU_NOCB_CPU_DEFAULT_ALL=y and CONFIG_RCU_LAZY=y. The fix is included in kernel 6.8.6 and later.

How do I check if my server is vulnerable to CVE-2024-35929?

Run `uname -r` and verify your version is between 6.7 and 6.8.5, then check `cat /boot/config-$(uname -r) | grep -E 'CONFIG_RCU_NOCB_CPU_DEFAULT_ALL|CONFIG_RCU_LAZY'` — if both are 'y', your system is vulnerable.

Does Defensia detect CVE-2024-35929?

Yes — Defensia's CVE advisory scanner compares installed package versions against the NVD database. If the Linux kernel is installed on a monitored server, CVE-2024-35929 will appear in your dashboard with remediation steps and affected version ranges.

Related Kernel CVEs

CVE-2026-100075CVSS 9.8In the Linux kernel, the following vulnerability has been resolved: RDMA/srpt: Fix srpt_alloc_rw_ctxs() unwind counters When srpt_alloc_rw_ctxs() fails partway through a multi-buffer indirect descriptor, the unwind path destroys RDMA contexts but leaves stale n_rw_ctx and n_rdma values (and a dangling rw_ctxs pointer). Later sq_wr_avail accounting in srpt_queue_response() or srpt_write_pending() can then subtract the wrong number of send queue credits. Reset the counters and clear rw_ctxs after freeing the heap allocation before returning an error.
CVE-2026-64439CVSS 9.8In the Linux kernel, the following vulnerability has been resolved: crypto: krb5 - filter out async aead implementations at alloc krb5_aead_encrypt(), krb5_aead_decrypt() in rfc3961_simplified.c and rfc8009_encrypt(), rfc8009_decrypt() in rfc8009_aes2.c set a NULL completion callback and treat any negative return from crypto_aead_{encrypt,decrypt}() as terminal, falling through to kfree_sensitive(buffer). When the encrypt_name resolves to an async AEAD instance the request returns -EINPROGRESS, the buffer is freed while the backend's worker still holds a pointer, and the worker dereferences the freed slab on completion. KASAN report under UML+SLUB with a synthetic async aead backend bound to krb5->encrypt_name: BUG: KASAN: slab-use-after-free in t5_stub_complete+0x7d/0xc7 The helpers were written synchronously, so filter the async instances out at allocation time instead of plumbing crypto_wait_req() through every call site. Reachable via net/rxrpc/rxgk.c, fs/afs/cm_security.c and net/ceph/crypto.c on systems with an async AEAD provider bound to the krb5 enctype name.
CVE-2026-64047CVSS 9.8In the Linux kernel, the following vulnerability has been resolved: net: tls: fix off-by-one in sg_chain entry count for wrapped sk_msg ring When an sk_msg scatterlist ring wraps (sg.end < sg.start), tls_push_record() chains the tail portion of the ring to the head using sg_chain(). An extra entry in the sg array is reserved for this: struct sk_msg_sg { [...] /* The extra two elements: * 1) used for chaining the front and sections when the list becomes * partitioned (e.g. end < start). The crypto APIs require the * chaining; * 2) to chain tailer SG entries after the message. */ struct scatterlist data[MAX_MSG_FRAGS + 2]; The current code uses MAX_SKB_FRAGS + 1 as the ring size: sg_chain(&msg_pl->sg.data[msg_pl->sg.start], MAX_SKB_FRAGS - msg_pl->sg.start + 1, msg_pl->sg.data); This places the chain pointer at sg_chain(data[start], (MAX_SKB_FRAGS - msg_start + 1) .. = &data[start] + (MAX_SKB_FRAGS - msg_start + 1) - 1 = data[start + (MAX_SKB_FRAGS - start + 1) - 1] = data[MAX_SKB_FRAGS] instead of the true last entry. This is likely due to a "race" of the commit under Fixes landing close to commit 031097d9e079 ("bpf: sk_msg, zap ingress queue on psock down") Convert to ARRAY_SIZE and drop the data[start] / - start (as suggested by Sabrina).
CVE-2025-38660CVSS 9.8In the Linux kernel, the following vulnerability has been resolved: [ceph] parse_longname(): strrchr() expects NUL-terminated string ... and parse_longname() is not guaranteed that. That's the reason why it uses kmemdup_nul() to build the argument for kstrtou64(); the problem is, kstrtou64() is not the only thing that need it. Just get a NUL-terminated copy of the entire thing and be done with that...
CVE-2025-39682CVSS 9.8In the Linux kernel, the following vulnerability has been resolved: tls: fix handling of zero-length records on the rx_list Each recvmsg() call must process either - only contiguous DATA records (any number of them) - one non-DATA record If the next record has different type than what has already been processed we break out of the main processing loop. If the record has already been decrypted (which may be the case for TLS 1.3 where we don't know type until decryption) we queue the pending record to the rx_list. Next recvmsg() will pick it up from there. Queuing the skb to rx_list after zero-copy decrypt is not possible, since in that case we decrypted directly to the user space buffer, and we don't have an skb to queue (darg.skb points to the ciphertext skb for access to metadata like length). Only data records are allowed zero-copy, and we break the processing loop after each non-data record. So we should never zero-copy and then find out that the record type has changed. The corner case we missed is when the initial record comes from rx_list, and it's zero length.

References

Track CVEs across your fleet automatically

Defensia scans your Linux servers and tells you exactly which ones are running vulnerable versions — including CVE-2024-35929. Free for 1 server.

Get started free