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

io_uring/wait: don't spin on a stuck overflow list

As long as IO_CHECK_CQ_OVERFLOW_BIT is set, io_cqring_wait_schedule()
returns right away, before it gets to look at signals or arms the timeout,
for io_cqring_wait() to flush the overflow list. If that doesn't empty the
list, and the CQ ring doesn't hold the number of events the caller wants,
the loop starts over, with the same result. The task spins in the kernel,
and can't be killed.

The assumption is that this can't happen: if CQEs can't be flushed, the
ring is full, and min_events is capped to the size of the ring. But:

- With IORING_SETUP_CQE_MIXED a 32b CQE needs two contiguous entries. It
is stuck on the list if a single one is free, and then the ring holds
less than cq_entries events. A single threaded application that asks
for as many events as the ring has entries never gets out of
io_uring_enter().

- Whether the ring is full is up to the CQ head, which the application
can write to. While one thread waits for events on an empty ring,
another one can move the head back so that the ring looks full and
have a CQE overflow. The waiter can't be stopped any more, not even by
SIGKILL.

Only the application can make room in the CQ ring. Return to it if the
list could not be flushed.
Published: 2026-11-02
Score: n/a
EPSS: n/a
KEV: No
Impact: Denial of Service – a kernel task can spin indefinitely and become non‑killable, potentially rendering the system or application unresponsive
Action: Apply Patch
AI Analysis

Impact

A bug in the Linux kernel’s io_uring subsystem causes a task that is waiting for completion events to enter an endless kernel loop. The spin prevents the task from being terminated, even with SIGKILL, which can stall progress of that process and degrade overall system responsiveness. The flaw can lead to a denial of service condition by exhausting scheduling resources or blocking critical paths.

Affected Systems

The vulnerability affects Linux kernel implementations that expose the io_uring/wait subsystem. Specific kernel versions are not enumerated in the advisory, but any build that includes the affected code path – particularly those compiled with support for the io_uring interface – is potentially impacted.

Risk and Exploitability

The flaw is local and requires an application that uses io_uring with the IORING_SETUP_CQE_MIXED flag and a multithreaded or full‑ring event wait scenario to trigger. No remote or network trigger is required. The exploit is observable only through controlled use of io_uring; once triggered, the kernel task cannot be preempted. The EPSS score is unavailable, and the vulnerability is not listed in the CISA KEV catalog, but the potential for system‑wide disruption makes it a high‑concern DoS vector.

Generated by OpenCVE AI on November 2, 2026 at 17:39 UTC.

Remediation

No solution or workaround provided in the CVE record.

OpenCVE Recommended Actions

  • Update the Linux kernel to the latest stable release or apply the patch commit referenced in the advisory that addresses io_uring/wait spinning
  • Avoid using the IORING_SETUP_CQE_MIXED flag or configure io_uring to avoid waiting for event counts that match the ring size
  • Implement a software-level timeout or limit the number of concurrent io_uring threads to reduce the chance of the overflow list becoming stuck

Generated by OpenCVE AI on November 2, 2026 at 17:39 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories yet.

History

Mon, 02 Nov 2026 19:45:00 +0000

Type Values Removed Values Added
First Time appeared Linux linux
Vendors & Products Linux linux

Mon, 02 Nov 2026 16:15:00 +0000

Type Values Removed Values Added
Description In the Linux kernel, the following vulnerability has been resolved: io_uring/wait: don't spin on a stuck overflow list As long as IO_CHECK_CQ_OVERFLOW_BIT is set, io_cqring_wait_schedule() returns right away, before it gets to look at signals or arms the timeout, for io_cqring_wait() to flush the overflow list. If that doesn't empty the list, and the CQ ring doesn't hold the number of events the caller wants, the loop starts over, with the same result. The task spins in the kernel, and can't be killed. The assumption is that this can't happen: if CQEs can't be flushed, the ring is full, and min_events is capped to the size of the ring. But: - With IORING_SETUP_CQE_MIXED a 32b CQE needs two contiguous entries. It is stuck on the list if a single one is free, and then the ring holds less than cq_entries events. A single threaded application that asks for as many events as the ring has entries never gets out of io_uring_enter(). - Whether the ring is full is up to the CQ head, which the application can write to. While one thread waits for events on an empty ring, another one can move the head back so that the ring looks full and have a CQE overflow. The waiter can't be stopped any more, not even by SIGKILL. Only the application can make room in the CQ ring. Return to it if the list could not be flushed.
Title io_uring/wait: don't spin on a stuck overflow list
First Time appeared Linux
Linux linux Kernel
CPEs cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
Vendors & Products Linux
Linux linux Kernel
References

Subscriptions

Linux Linux Linux Kernel
cve-icon MITRE

Status: PUBLISHED

Assigner: Linux

Published:

Updated: 2026-11-02T16:06:37.423Z

Reserved: 2026-09-25T10:25:14.402Z

Link: CVE-2026-99229

cve-icon Vulnrichment

No data.

cve-icon NVD

Status : Received

Published: 2026-11-02T16:17:47.780

Modified: 2026-11-02T16:17:47.780

Link: CVE-2026-99229

cve-icon Redhat

No data.

cve-icon OpenCVE Enrichment

Updated: 2026-11-02T19:30:17Z

Weaknesses

No weakness.