CVE-2026-99784 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
9p/xen: fix refcount leak in p9_xen_response() on wrong tag
p9_xen_response() looks up the request for an incoming reply with p9_tag_lookup(), which takes a reference on the returned p9_req_t. When the tag does not resolve to a request in REQ_STATUS_SENT, the function warns and continues the loop without dropping that reference, permanently leaking the p9_req_t and its msize buffers. The reply header, including the tag, is supplied by the backend, so a malicious or buggy 9P backend can leak kernel memory on every crafted response.
Drop the reference before continuing.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The vulnerability identified in the Linux kernel's 9p/xen subsystem represents a significant resource management flaw within the Xen-based virtual file system implementation. Specifically, the issue resides in the p9_xen_response function, which is responsible for processing incoming replies from the backend domain. The core of the problem lies in how request references are handled during error conditions. When an incoming reply arrives, the kernel invokes p9_tag_lookup to locate the corresponding pending request object based on a tag provided in the response header. This lookup operation inherently increments the reference count of the returned p9_req_t structure to ensure it remains valid for subsequent processing. However, if the identified request is not in the expected REQ_STATUS_SENT state, indicating that the request was either already completed or invalid, the function triggers a warning and proceeds to continue the loop without releasing this acquired reference. This omission results in a persistent memory leak where each such erroneous response causes the kernel to retain ownership of the p9_req_t structure and its associated msize buffers indefinitely until system reboot or manual intervention.
From an operational perspective, this vulnerability allows for a denial-of-service attack vector against systems utilizing Xen with 9p filesystems. Because the reply header, including the tag used for lookup, is supplied entirely by the backend domain, a malicious or buggy virtual machine acting as the backend can craft responses that trigger this code path repeatedly. Each crafted response leads to an incremental allocation of kernel memory that is never freed. Over time, this unbounded accumulation of leaked memory resources depletes available system RAM and slab cache entries, potentially causing severe performance degradation, system instability, or a complete crash due to out-of-memory conditions. The impact is particularly acute in multi-tenant environments where one compromised guest could destabilize the host kernel or other guests sharing those resources.
This flaw aligns with CWE-401, which describes missing release of memory after effective usage, and falls under the broader category of resource exhaustion attacks as defined by MITRE ATT&CK technique T1499. The vulnerability exploits a logic error in reference counting mechanisms that are critical for maintaining kernel object lifecycle integrity. In secure software design, every acquisition of a resource handle or reference must have a corresponding release path, especially within conditional branches where early exits or loop continuations occur. Failure to balance these operations creates predictable leak points that attackers can leverage to exhaust system resources without requiring privilege escalation beyond the initial access granted to the backend domain.
Mitigation for this vulnerability requires applying the upstream kernel patch that corrects the reference counting logic in p9_xen_response. The fix involves ensuring that when a request is not found or does not match the expected status, the function explicitly drops the reference acquired by p9_tag_lookup before continuing execution. Administrators should update their Linux kernels to versions containing this specific commit. Additionally, implementing strict monitoring of kernel memory usage and slab caches can help detect early signs of such leaks in production environments. For organizations relying on Xen virtualization with 9p mounts, it is also advisable to enforce trust boundaries between domains and validate backend behavior where possible, although the primary defense remains timely patching of the host kernel to eliminate the code path that permits these unbounded allocations.