CVE-2026-99797 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

io_uring/cancel: drop sqd->lock while SQPOLL waits

An exiting SQPOLL thread calls io_uring_cancel_generic() with sqd->lock held, and keeps it across cond_resched() and the sleep until nothing is in flight anymore. A zero-copy send notification can't be canceled and stays pending as long as the peer doesn't read, so the lock is held for as long as a user cares to. io_ring_exit_work() needs it to park the thread, and so do IORING_REGISTER_IOWQ_AFF and IOWQ_MAX_WORKERS. With 64 such rings sharing the thread, every iou_exit slot sleeps on the lock and no ring gets freed for anyone.

Drop the lock around cond_resched() and the sleep, like the main loop of the thread does. Each walk of ctx_list is still under one hold, and nothing is kept across the unlock. The thread drops its io-wq, frees its tctx and clears sqd->thread under one hold after the loop, so whoever holds the lock and finds sqd->thread set can still use them.

[axboe: adapted to the schedule_timeout() based loop]

Be aware that VulDB is the high quality source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability described involves a concurrency issue within the Linux kernel's io_uring subsystem, specifically affecting the SQPOLL (Submission Queue Polling) thread mechanism. This feature allows user-space applications to offload submission queue processing to dedicated kernel threads for improved performance and reduced context switching overhead. The core technical flaw arises during the cleanup phase when an SQPOLL thread is exiting. In this scenario, the function io_uring_cancel_generic() is invoked while holding the sqd->lock, a critical synchronization primitive used to protect shared data structures within the submission queue descriptor. Crucially, this lock is retained across calls to cond_resched(), which may trigger voluntary context switches and subsequent sleeps until all in-flight operations are completed. This design choice creates a significant contention point because certain asynchronous notifications, particularly zero-copy send completions, cannot be forcibly canceled by the kernel. These pending events remain unresolved as long as the peer application does not consume them via read operations. Consequently, if an attacker or misconfigured user space holds these connections open indefinitely, the sqd->lock remains held for an extended duration, effectively blocking other threads that require access to this resource.

The operational impact of this lock contention is severe and can lead to system-wide performance degradation or denial of service conditions. The io_ring_exit_work() function requires the sqd->lock to properly park the exiting thread, and other critical operations such as IORING_REGISTER_IOWQ_AFFinity and management of IOWQ_MAX_WORKERS also depend on this lock for synchronization. When multiple io_uring instances share a single SQPOLL thread, each instance's exit slot attempts to sleep while holding the same lock. With a high number of rings, such as sixty-four sharing one thread, every exiting ring blocks the others from completing their cleanup routines. This results in a deadlock-like scenario where no ring can be freed because they are all waiting for the lock held by another sleeping process that is itself blocked on an uncancellable network event. The system effectively stalls, preventing new io_uring registrations or completions and potentially exhausting kernel resources associated with these stuck threads.

The resolution to this vulnerability involves modifying the locking strategy within the SQPOLL thread exit path. Instead of holding the sqd->lock across cond_resched() calls and subsequent sleeps, the patch instructs the code to drop the lock during these periods, mirroring the behavior already present in the main execution loop of the SQPOLL thread. This ensures that while individual walks through the context list remain protected by a single hold on the lock, no state is kept across unlock boundaries unnecessarily. After iterating through all contexts, the thread drops its io-wq reference, frees its task context structure, and clears the sqd->thread pointer under one final atomic operation. This approach allows any other entity holding the lock to safely access these structures if they find sqd->thread still set, thereby preventing the deadlock scenario without compromising data integrity or introducing race conditions during the cleanup phase.

From a security perspective, this issue is classified as a Denial of Service vulnerability due to its potential to exhaust system resources and block legitimate operations through resource contention rather than memory corruption. It aligns with CWE-400: Uncontrolled Resource Consumption, where an attacker can cause the system to consume excessive time or computational resources by manipulating the lifecycle of io_uring rings and keeping network connections open to prevent cancellation. In terms of the MITRE ATT&CK framework, this vulnerability relates to techniques involving resource exhaustion that hinder availability, potentially falling under T1499: Endpoint Denial of Service if exploited in a manner intended to disrupt service for other users or processes on the same host. Mitigation strategies primarily involve applying the kernel patch provided by the maintainers, which adjusts the locking granularity during thread exit sequences. Administrators should ensure that their Linux kernels are updated to versions containing this fix. Additionally, application developers utilizing io_uring should be aware of the implications of zero-copy operations and implement proper timeout mechanisms or connection closure policies in user-space applications to prevent indefinite blocking of kernel threads. Regular auditing of resource usage patterns for high-concurrency networked services can also help identify potential abuse vectors before they lead to system instability.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00296

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!