CVE-2026-99545 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
driver core: take parent lock on deferred probe
USB interfaces should be probed with the parent USB device lock held, but this is not honoured when probe is deferred.
Add a new bus_probe_device_deferred() helper to handle deferred probe where the parent device lock is not held.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel driver core subsystem manages the initialization and binding of hardware devices through a complex probing mechanism that ensures dependencies are met before resources are allocated. A specific vulnerability was identified in this process regarding USB interfaces, which require strict synchronization with their parent USB device to prevent race conditions during state transitions. The issue arises when a probe operation is deferred due to unmet dependencies, such as missing drivers or unavailable hardware resources. In these scenarios, the kernel schedules the probe for later execution via a workqueue mechanism rather than failing immediately. However, the original implementation failed to acquire the parent device lock before attempting to re-probe the child USB interface upon deferral resolution. This omission violates the locking hierarchy established by the USB subsystem, which mandates that any interaction with a USB interface must be protected by the corresponding parent device mutex to ensure data consistency and prevent concurrent access issues.
This lack of proper synchronization can lead to severe operational instability within the kernel space. When multiple threads attempt to modify or read shared structures associated with the USB device hierarchy without holding the necessary locks, it creates a classic race condition scenario. Such conditions may result in use-after-free errors, where memory is accessed after it has been freed by another thread due to incorrect state tracking during concurrent probe operations. Alternatively, it could lead to data corruption within driver-specific contexts or cause kernel panics if critical structural integrity checks fail unexpectedly. The impact extends beyond immediate crashes; it can manifest as intermittent connectivity issues for USB peripherals, unpredictable behavior in device enumeration processes, and potential security implications where an attacker might exploit these race conditions to escalate privileges or disrupt system availability through denial of service vectors targeting the driver core infrastructure.
From a vulnerability classification perspective, this flaw aligns with CWE-362, which describes concurrent execution using shared resources with improper synchronization. The absence of the parent lock during deferred probe handling represents a failure in enforcing mutual exclusion protocols required by the USB subsystem architecture. In terms of adversarial tactics, while not directly exploitable for remote code execution without additional context-dependent conditions, this type of race condition falls under ATT&CK technique T1059, specifically related to command and script interpretation or system service exploitation if leveraged in conjunction with other local privilege escalation vectors. The vulnerability highlights the critical importance of maintaining lock ordering consistency across deferred asynchronous operations within kernel subsystems, particularly those involving hierarchical device models where parent-child relationships dictate access control and resource management rules.
The resolution involves introducing a new helper function named bus_probe_device_deferred() into the driver core codebase. This specialized routine is designed to correctly handle deferred probe scenarios by explicitly acquiring the parent device lock before proceeding with the actual probing logic for USB interfaces. By centralizing this locking behavior within a dedicated helper, the kernel ensures that all deferred probes adhere to the required synchronization protocols regardless of where they are triggered from in the codebase. This change eliminates the race condition window and restores proper thread safety guarantees for USB device management. To mitigate similar issues or address existing risks until patches are applied, system administrators should ensure their kernels are updated with the latest stable releases that include this fix. Additionally, developers working on custom kernel modules involving USB subsystems must rigorously audit their deferred probe implementations to verify adherence to parent lock acquisition requirements, thereby preventing potential stability and security regressions in customized or out-of-tree driver environments.