CVE-2026-99301 in Linuxinfo

Summary

by MITRE • 11/16/2026

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

virtio_net: atomically disable rx mode work

virtio-net uses a boolean to gate rx_mode_work during device teardown. The flag is changed under RTNL, but ndo_set_rx_mode checks it under the address-list lock. A callback can therefore pass the check and enqueue work after teardown has flushed it. The work is also enabled before late probe operations that can fail, allowing probe unwind to free the netdev with work still queued.

KASAN reports the worker using a virtqueue that probe unwind already freed:

BUG: KASAN: slab-use-after-free in virtqueue_add_split Workqueue: events virtnet_rx_mode_work Call Trace: virtqueue_add_split (drivers/virtio/virtio_ring.c:706) virtqueue_add_sgs (drivers/virtio/virtio_ring.c:2839) virtnet_send_command_reply (drivers/net/virtio_net.c:3565) virtnet_rx_mode_work (drivers/net/virtio_net.c:3833) process_one_work (kernel/workqueue.c:3322) worker_thread (kernel/workqueue.c:3405) Freed by task 119: kfree (mm/slub.c:6625) vp_del_vq.isra.0 (drivers/virtio/virtio_pci_common.c:259) vp_del_vqs (drivers/virtio/virtio_pci_common.c:285) virtnet_probe (drivers/net/virtio_net.c:7129)

Use the workqueue disable mechanism to atomically reject new queue attempts and drain running work. Keep work disabled until probe succeeds or restore has reattached the netdev, then enable it and replay receive-mode state for a running interface. Disable it before resource teardown in freeze and remove.

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

Analysis

by VulDB Data Team • 11/16/2026

The vulnerability identified within the Linux kernel's virtio_net driver represents a critical race condition involving asynchronous workqueue execution during device initialization and teardown phases. This flaw stems from an improper synchronization mechanism used to gate the rx_mode_work function, which is responsible for updating receive mode settings on virtual network interfaces. The core issue lies in the mismatch between locking contexts: while the boolean flag controlling the work queue's state is modified under the RTNL lock, the check performed by ndo_set_rx_mode occurs under a different address-list lock. This discrepancy creates a window where a callback can pass the validity check and successfully enqueue new work items even after the device teardown process has already initiated or completed the flushing of existing work. Consequently, this leads to use-after-free scenarios where kernel memory that has been deallocated is accessed by lingering asynchronous tasks.

The operational impact of this vulnerability is severe, manifesting as kernel crashes detected via Kernel Address Sanitizer (KASAN) reports indicating slab-use-after-free errors within virtqueue_add_split. The call trace reveals that the virtnet_rx_mode_work function attempts to interact with a virtqueue structure that has already been freed by the probe unwind logic in vp_del_vqs and vp_del_vq functions during failed or aborted device initialization sequences. This race condition not only causes immediate system instability but also poses significant security risks, as use-after-free vulnerabilities can potentially be exploited for arbitrary code execution or privilege escalation if an attacker can influence the timing of these operations through crafted network configurations or virtualization environments.

To resolve this issue, the fix implements a robust mechanism using workqueue disable functions to atomically reject new queue submissions and drain any currently running work items. This ensures that no new rx_mode_work tasks are queued once the device teardown process begins. The implementation mandates keeping the work disabled until either the probe operation successfully completes or the system restores state after resuming from suspend, at which point receive-mode state is replayed for a fully operational interface. Furthermore, the disable action is explicitly placed before resource teardown in freeze and remove handlers to guarantee that no asynchronous tasks remain active when network device structures are being released. This approach aligns with best practices for concurrent programming in kernel space by ensuring strict serialization of access to shared resources during lifecycle transitions.

From a vulnerability classification perspective, this issue corresponds to CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition'). The lack of proper locking granularity allows multiple execution paths to interfere with each other's state management. In terms of the MITRE ATT&CK framework for enterprise security, while primarily an internal kernel stability flaw, such race conditions can be categorized under T1059: Command and Scripting Interpreter if leveraged in conjunction with other vulnerabilities to execute malicious payloads during the brief window where memory is freed but not yet reallocated. Mitigation strategies involve applying the provided kernel patch which enforces atomic state transitions for workqueue management. System administrators should ensure their kernels are updated to versions containing this fix, particularly those running virtualized environments that utilize virtio network interfaces, as these are most susceptible to triggering the race condition during device hot-plug events or hypervisor-initiated suspend-resume cycles.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/16/2026

Moderation

accepted

CPE

ready

EPSS

0.00000

KEV

no

Activities

very low

Sources

Do you know our Splunk app?

Download it now for free!