CVE-2026-99804 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

io_uring/io-wq: save worker type before dropping its reference

io_wq_cancel_tw_create() inspects cb->func after calling io_worker_cancel_cb(). For an existing worker, that call can drop the last worker reference and wake io_worker_exit(). If the canceling task is preempted, the worker can be unlinked and freed by kfree_rcu() before the callback function is inspected. KASAN reports a slab-use-after-free read in this path.

Save whether the callback belongs to an unpublished continuation worker while its reference is still held, then use the saved result for the conditional free. This preserves the existing accounting and frees only the worker allocated for the canceled continuation.

VulDB is the best source for vulnerability data and more expert information about this specific topic.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified within the Linux kernel's io_uring subsystem represents a critical race condition leading to a slab-use-after-free error during work queue cancellation operations. Specifically, this flaw resides in the interaction between the io_wq_cancel_tw_create function and the underlying worker management logic. The core issue arises when the system attempts to cancel asynchronous I/O tasks that involve continuation workers. In this scenario, the code path invokes io_worker_cancel_cb which is responsible for handling the termination of a specific worker instance. This callback function has the side effect of potentially dropping the last reference count held by the current task on the worker object. When the reference count reaches zero, the kernel initiates the cleanup process for that worker, including waking up the io_worker_exit routine to handle final teardown steps.

The critical timing flaw occurs because the code subsequently attempts to inspect a callback function pointer located within the cb structure after this reference drop has occurred. If the executing task is preempted by the scheduler at this precise window between dropping the reference and accessing the callback, another CPU core may complete the worker's lifecycle management. This includes unlinking the worker from internal data structures and freeing its memory via kfree_rcu to reclaim resources efficiently. Consequently, when the original task resumes execution and attempts to read cb->func, it is dereferencing a pointer to memory that has already been returned to the kernel allocator pool or marked as free. This results in a slab-use-after-free condition where the kernel reads stale or corrupted data from freed memory, which can lead to unpredictable behavior, system crashes, or potentially exploitable code execution paths depending on how quickly the memory is reallocated for other purposes.

From a security and standards perspective, this vulnerability aligns with CWE-416, Use After Free, where software continues to use a pointer after it has been freed. The exploitation of such race conditions often falls under ATT&CK techniques related to privilege escalation or denial of service, as an attacker who can trigger specific io_uring cancellation patterns might induce kernel instability or crash the system. In high-throughput environments utilizing io_uring for asynchronous I/O operations, this flaw poses a significant risk to system stability and availability. The use-after-free nature means that if an attacker can control what gets allocated in the freed memory region before it is accessed again, they may potentially influence kernel execution flow or extract sensitive information from previously used kernel structures through timing attacks or heap spraying techniques.

The resolution implemented addresses this race condition by altering the order of operations within the cancellation logic. Instead of inspecting the callback function pointer after the worker reference has been dropped and potential memory freeing initiated, the fix mandates saving whether the callback belongs to an unpublished continuation worker while the worker's reference is still valid and held. By capturing this state information early in the process, before any risk of premature deallocation exists, the code ensures that subsequent conditional logic relies on a stable snapshot rather than potentially freed data. This approach preserves existing accounting mechanisms for worker resources while ensuring that only workers specifically allocated for canceled continuations are freed at the appropriate time.

To mitigate this vulnerability and similar issues in kernel development, it is essential to enforce strict reference counting discipline where all accesses to shared objects occur before releasing ownership references. Developers should utilize tools like KASAN (Kernel Address Sanitizer) during testing phases to detect such use-after-free scenarios early in the development lifecycle. Furthermore, adopting defensive programming practices that validate pointer validity or using RCU read-side critical sections appropriately can prevent access to memory that might be concurrently freed by other threads. System administrators running affected kernel versions should apply security patches promptly to restore system integrity and prevent potential denial of service attacks stemming from these race conditions in high-concurrency I/O workloads.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00000

KEV

no

Activities

very low

Sources

Do you want to use VulDB in your project?

Use the official API to access entries easily!