VYPR
Unrated severityNVD Advisory· Published Dec 22, 2025· Updated Apr 15, 2026

CVE-2025-68336

CVE-2025-68336

Description

In the Linux kernel, the following vulnerability has been resolved:

locking/spinlock/debug: Fix data-race in do_raw_write_lock

KCSAN reports:

BUG: KCSAN: data-race in do_raw_write_lock / do_raw_write_lock

write (marked) to 0xffff800009cf504c of 4 bytes by task 1102 on cpu 1: do_raw_write_lock+0x120/0x204 _raw_write_lock_irq do_exit call_usermodehelper_exec_async ret_from_fork

read to 0xffff800009cf504c of 4 bytes by task 1103 on cpu 0: do_raw_write_lock+0x88/0x204 _raw_write_lock_irq do_exit call_usermodehelper_exec_async ret_from_fork

value changed: 0xffffffff -> 0x00000001

Reported by Kernel Concurrency Sanitizer on: CPU: 0 PID: 1103 Comm: kworker/u4:1 6.1.111

Commit 1a365e822372 ("locking/spinlock/debug: Fix various data races") has adressed most of these races, but seems to be not consistent/not complete.

>From do_raw_write_lock() only debug_write_lock_after() part has been converted to WRITE_ONCE(), but not debug_write_lock_before() part. Do it now.

AI Insight

LLM-synthesized narrative grounded in this CVE's description and references.

A data race in do_raw_write_lock in the Linux kernel's spinlock debug code can cause concurrent read/write access, leading to undefined behavior.

Vulnerability

In the Linux kernel, the do_raw_write_lock function in the spinlock debug code contains a data race. The Kernel Concurrency Sanitizer (KCSAN) reported concurrent write and read accesses to the same memory location (0xffff800009cf504c) by different tasks. The previous fix in commit 1a365e822372 addressed most similar races but incomplete: debug_write_lock_before was not converted to use WRITE_ONCE(), leaving the race unfixed.

Exploitation

An attacker can exploit this race by triggering concurrent execution of do_raw_write_lock on multiple CPUs, for example, through parallel do_exit calls via call_usermodehelper_exec_async. No special privileges are needed beyond ability to run code that causes concurrent lock acquisition.

Impact

A successful exploit can lead to data corruption or other undefined behavior due to unsynchronized access to shared data in the lock debugging infrastructure. This could potentially be leveraged to cause system instability or privilege escalation, though specifics depend on the environment.

Mitigation

The fix is to add WRITE_ONCE() to the debug_write_lock_before part of do_raw_write_lock, making the access consistent with debug_write_lock_after. The patch has been merged into stable kernel branches. Users should update to a kernel containing the fix referenced by the commit [1].

AI Insight generated on May 19, 2026. Synthesized from this CVE's description and the cited reference URLs; citations are validated against the source bundle.

Affected products

1

Patches

0

No patches discovered yet.

Vulnerability mechanics

AI mechanics synthesis has not run for this CVE yet.

References

8

News mentions

0

No linked articles in our index yet.