CVE-2026-99466 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
media: microchip-csi2dc: fix async notifier leak on probe error path
csi2dc_of_parse() ends up calling csi2dc_prepare_notifier(), which registers the V4L2 async notifier with v4l2_async_nf_register(). The probe error label csi2dc_probe_cleanup_notifier is reached after csi2dc_of_parse() has already succeeded (e.g. when media entity init, csi2dc_power() or v4l2_async_register_subdev() fail), but it calls only v4l2_async_nf_cleanup() and never v4l2_async_nf_unregister().
The notifier therefore stays chained in the global notifier_list while the enclosing struct csi2dc_device is freed, leading to list corruption and a use-after-free when the list is next walked.
Unregister the notifier before cleaning it up on the error path, matching the teardown already done in csi2dc_remove().
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel driver for Microchip CSI-2 Data Converter contains a critical resource management flaw within its probe error handling logic that leads to memory corruption and potential system instability. This vulnerability arises from an asymmetry between registration and cleanup operations during the device initialization phase. Specifically, when parsing the device tree configuration via csi2dc_of_parse, the driver invokes csi2dc_prepare_notifier which registers a V4L2 async notifier using v4l2_async_nf_register. If subsequent steps in the probe sequence fail, such as media entity initialization, power management setup, or subdev registration, control flow diverts to an error handling label named csi2dc_probe_cleanup_notifier.
The core technical flaw lies in the implementation of this cleanup routine. While it correctly calls v4l2_async_nf_cleanup to release internal resources associated with the notifier structure, it fails to call v4l2_async_nf_unregister. This omission leaves the notifier object chained within a global kernel list that is traversed by other subsystems during asynchronous device matching operations. Consequently, when the enclosing csi2dc_device structure is subsequently freed due to the probe failure, the dangling pointer remains in the global list. Any subsequent iteration over this list results in a use-after-free condition as the code attempts to access memory belonging to a deallocated object.
This type of vulnerability falls under CWE-416 Use After Free and CWE-20 Improper Input Validation regarding resource lifecycle management. From an offensive security perspective, such errors can be leveraged for privilege escalation or denial-of-service attacks by triggering specific race conditions or heap corruption scenarios during device enumeration. The ATT&CK framework categorizes this behavior under techniques related to exploitation of software vulnerabilities, specifically those involving memory safety violations that allow attackers to manipulate kernel state.
The operational impact includes potential system crashes, data corruption within the media subsystem, and arbitrary code execution if an attacker can control the contents of the freed memory region before it is reallocated for malicious purposes. To mitigate this issue, developers must ensure strict symmetry in resource management by calling v4l2_async_nf_unregister prior to invoking cleanup functions on error paths. This aligns with established best practices where teardown procedures mirror initialization steps exactly, ensuring that all registered entities are properly unlinked from global lists before their memory is reclaimed.