CVE-2026-99564 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

smb: smbdirect: don't wait for RDMA_CM_EVENT_DISCONNECTED in smbdirect_socket_destroy_sync()

smbdirect_socket_destroy_sync() waited for RDMA_CM_EVENT_DISCONNECTED after smbdirect_socket_cleanup_work() called rdma_disconnect(). That can take very long, e.g. if the peer just disappeared, until the rdma cm gives up, or forever if the event already happened, but the status was overwritten afterwards.

This is not needed: smbdirect_socket_destroy() drains the qp under rdma_lock_handler(), destroys it and calls rdma_destroy_id(), which only waits for a currently running event handler and makes sure no further events are delivered. The rest of the disconnect protocol (DREQ/DREP and timewait for IB, abrupt close for iWarp) is handled by the rdma core asynchronously. drivers/nvme/host/rdma.c also just calls rdma_disconnect() and ib_drain_qp() before rdma_destroy_id().

So smbdirect_socket_destroy() now also accepts SMBDIRECT_SOCKET_DISCONNECTING and changes the status to SMBDIRECT_SOCKET_DISCONNECTED itself under rdma_lock_handler().

We could still get RDMA_CM_EVENT_DISCONNECTED in the small windows between rdma_unlock_handler() and rdma_destroy_id(), but in that case smbdirect_connection_rdma_event_handler() is basically a no-op.

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 Linux kernel vulnerability addressed involves an inefficiency within the SMB Direct (SMBD) subsystem, specifically concerning socket destruction synchronization mechanisms. The core issue resides in the function smb_direct_socket_destroy_sync(), which previously attempted to wait for an RDMA_CM_EVENT_DISCONNECTED event after initiating a disconnect via rdma_disconnect(). This approach introduced significant latency and potential operational stalls because waiting for this specific network layer event can take an excessive amount of time if the peer has disappeared or become unreachable. In scenarios where the connection status had already been overwritten prior to the event arrival, the system could potentially wait indefinitely, leading to resource exhaustion or process hangs that degrade overall system stability and responsiveness.

From a technical perspective, this flaw stems from a misunderstanding of how the RDMA core handles asynchronous disconnect protocols. The previous implementation incorrectly assumed explicit synchronization with the network layer's disconnection events was necessary for safe cleanup. In reality, the rdma_destroy_id() function is designed to handle finalization by waiting only for currently running event handlers and ensuring no further events are delivered. The actual teardown of the Queue Pair (QP) occurs under the protection of the rdma_lock_handler(), which drains the QP and destroys it safely. Furthermore, the complex disconnect protocol details, such as DREQ/DREP exchanges in InfiniBand or abrupt closes for iWARP, are managed asynchronously by the RDMA core itself. Consequently, explicit waiting for a disconnected event is redundant and counterproductive to performance.

The operational impact of this vulnerability primarily manifests as high latency during socket cleanup operations, particularly in environments with unstable network connections or when dealing with unresponsive remote peers. This can lead to thread blocking within kernel space, potentially causing timeouts in higher-level storage protocols like NVMe over RDMA that rely on SMB Direct for data transfer. Such delays affect the reliability of block storage services and can result in application-level time-outs if the underlying filesystem operations are blocked waiting for these socket resources to be fully released. This behavior represents a denial-of-service condition caused by inefficient resource management rather than a direct exploitation vector, though it impacts system availability.

To mitigate this issue, the fix modifies smb_direct_socket_destroy() to accept SMBDIRECT_SOCKET_DISCONNECTING states and transition them directly to SMBDIRECT_SOCKET_DISCONNECTED under the rdma_lock_handler(). This change eliminates the need for synchronous waiting on network events during cleanup. By allowing the kernel to proceed with resource deallocation without blocking on potentially delayed or irrelevant RDMA_CM_EVENT_DISCONNECTED signals, the system ensures timely release of memory and file descriptors. Although there remains a small window between unlocking the handler and destroying the ID where an event might still arrive, the updated event handler is designed to act as a no-op in such cases, ensuring that race conditions do not compromise data integrity or cause crashes.

This vulnerability aligns with CWE-400, which covers Uncontrolled Resource Consumption, specifically regarding resource exhaustion due to excessive waiting times. It also relates to CWE-362, Concurrent Execution using Shared Resource with Improper Synchronization of Read/Write Access, as the original code attempted manual synchronization that conflicted with asynchronous kernel mechanisms. In terms of MITRE ATT&CK, this issue does not represent a direct attack technique but rather highlights weaknesses in system resilience and availability management. Proper handling of asynchronous events is critical for maintaining service continuity in network-dependent storage subsystems, ensuring that transient network failures do not cascade into persistent system hangs or performance degradation across the host infrastructure.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00155

KEV

no

Activities

very low

Sources

Do you know our Splunk app?

Download it now for free!