CVE-2026-68222 in Linux
Summary
by MITRE • 08/10/2026
In the Linux kernel, the following vulnerability has been resolved:
media: msi2500: Return queued buffers on start_streaming() failure
The vb2 framework hands buffers to the driver via buf_queue() before calling start_streaming(). If start_streaming() returns an error without first returning those buffers via vb2_buffer_done(), vb2_start_streaming() fires WARN_ON(owned_by_drv_count) and the queued buffers leak.
msi2500_start_streaming() had five error paths that all hit this trap and were further tangled by ret-overwriting between calls:
- -ENODEV when the USB device was already disconnected - -ERESTARTSYS when mutex_lock_interruptible() was interrupted - msi2500_set_usb_adc() failure: ret was silently overwritten by the next call (msi2500_isoc_init), so the error was lost entirely - msi2500_isoc_init() failure: cleanup_queued_bufs was called, but the function then fell through to msi2500_ctrl_msg() and again masked the original error by overwriting ret - msi2500_ctrl_msg(CMD_START_STREAMING) failure: no cleanup at all, leaving isoc URBs submitted with no way for the driver to consume them
Consolidate the error paths into a small goto chain. Every failure now stops the function, drains the queued-buffer list, and returns the real error code. The ctrl_msg failure path also rolls back the preceding msi2500_isoc_init() via msi2500_isoc_cleanup() before unlocking and draining.
The cleanup helper takes a vb2_buffer_state argument so that the start_streaming error paths can pass VB2_BUF_STATE_QUEUED (as expected by userspace on start_streaming failure) while stop_streaming keeps its existing VB2_BUF_STATE_ERROR semantics.
This mirrors the uvcvideo fix in commit 4cf3b6fd54eb ("media: uvcvideo: Return queued buffers on start_streaming() failure").
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 08/11/2026
The vulnerability resides within the linux kernel's media subsystem, specifically affecting the msi2500 driver which handles USB digital television receivers. This issue represents a buffer management flaw that occurs during the streaming initialization phase of video capture devices. The problem stems from improper handling of queued buffers when the start_streaming() function encounters errors, leading to resource leaks and system instability. The vulnerability is classified under CWE-459 as incomplete cleanup of resources, specifically manifesting as buffer leaks in the videobuf2 framework.
The technical flaw manifests through a complex error handling mechanism within msi2500_start_streaming() where multiple failure paths exist without proper buffer cleanup procedures. When start_streaming() returns an error without first calling vb2_buffer_done() to return queued buffers, the vb2_start_streaming() function triggers a WARN_ON(owned_by_drv_count) condition that indicates improper buffer state management. The driver contains five distinct error paths that all lead to this problematic scenario, with additional complications from ret variable overwriting between function calls that masks original error conditions. This creates a cascading failure where errors are silently lost and buffers remain in an inconsistent state.
The operational impact of this vulnerability is significant for systems utilizing msi2500 USB receivers, particularly those in embedded or real-time environments where resource management is critical. The buffer leaks can lead to progressive system degradation, potential deadlocks, and ultimately system instability or crashes. The issue affects the reliability of video capture operations and can result in userspace applications receiving inconsistent error states when attempting to start streaming operations. This vulnerability directly impacts the media framework's ability to maintain proper buffer state transitions and can cause downstream applications to fail in predictable ways.
The mitigation strategy involves consolidating all error paths into a unified goto chain that ensures proper cleanup of queued buffers regardless of which error condition occurs during streaming initialization. Each failure path now properly stops execution, drains the queued-buffer list, and returns the actual error code rather than allowing silent failures or overwrites. The solution implements a cleanup helper function that accepts vb2_buffer_state arguments to differentiate between start_streaming() errors (which should return VB2_BUF_STATE_QUEUED) and stop_streaming() errors (which maintain existing VB2_BUF_STATE_ERROR semantics). This approach follows the established pattern used in uvcvideo driver fixes, aligning with industry best practices for buffer management in kernel media drivers. The implementation ensures that all URB submissions are properly rolled back through msi2500_isoc_cleanup() before unlocking and draining resources, preventing the accumulation of orphaned buffers and maintaining proper state transitions throughout the streaming lifecycle.