CVE-2026-68087 in Linux
Summary
by MITRE • 08/10/2026
In the Linux kernel, the following vulnerability has been resolved:
HID: wacom: use GFP_ATOMIC in wacom_wac_queue_flush()
wacom_wac_queue_flush() is called via the .raw_event callback (wacom_raw_event → wacom_wac_pen_serial_enforce → wacom_wac_queue_flush). For USB HID devices, this callback is invoked from hid_irq_in(), which is a URB completion handler running in atomic context. Using GFP_KERNEL in this path can sleep, leading to a "scheduling while atomic" bug.
Use GFP_ATOMIC instead. The existing code already handles allocation failure by skipping the fifo entry and continuing.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 08/10/2026
The vulnerability identified in the Linux kernel's HID wacom driver represents a critical scheduling issue that arises from improper memory allocation context within interrupt handling code paths. This flaw exists in the wacom_wac_queue_flush() function which is invoked through the HID raw_event callback mechanism, specifically when processing USB HID device events. The function is called from wacom_raw_event which subsequently triggers wacom_wac_pen_serial_enforce and finally wacom_wac_queue_flush(), creating a chain that ultimately executes within the hid_irq_in() URB completion handler context.
The technical root cause stems from the use of GFP_KERNEL memory allocation flags within an atomic execution context where sleeping is strictly prohibited. The HID subsystem's USB interrupt handling operates in atomic mode to maintain system responsiveness and prevent deadlocks, making it incompatible with kernel memory allocators that may block or sleep during allocation operations. When wacom_wac_queue_flush() attempts to allocate memory using GFP_KERNEL while executing within this atomic context, it triggers the kernel's "scheduling while atomic" bug, which manifests as a system crash or panic due to attempting to schedule tasks during interrupt processing.
This vulnerability directly impacts the stability and reliability of Linux systems that utilize Wacom tablet devices, particularly those connected via USB HID interfaces. The operational consequences extend beyond simple system crashes to potentially disrupt user workflows and compromise system integrity during critical input operations. The issue affects any system where Wacom tablets are actively used and processed through the HID subsystem, creating a persistent risk for desktop environments, digital art applications, and professional workstations that depend on reliable input device handling.
The fix implemented addresses this by changing memory allocation flags from GFP_KERNEL to GFP_ATOMIC, which is specifically designed for atomic contexts and prevents any potential blocking operations. This solution aligns with CWE-362, which describes the weakness of concurrent execution using lockless code or improper use of atomic operations in interrupt handlers. The mitigation strategy maintains the existing error handling behavior where allocation failures result in skipping fifo entries rather than causing system crashes, demonstrating adherence to defensive programming principles. This approach follows ATT&CK technique T1059.006 for kernel-level exploitation prevention and represents a standard practice in embedded systems and real-time operating environments where atomic context integrity must be maintained.
The remediation approach is minimal yet effective, requiring only a single flag change in the memory allocation call while preserving all existing functionality and error handling mechanisms. This preserves system compatibility while eliminating the critical scheduling conflict that could lead to system instability or complete system failure during normal operation of Wacom tablet devices. The solution demonstrates proper kernel development practices by ensuring context-appropriate resource management and maintaining the principle that interrupt handlers must remain non-blocking to preserve system responsiveness and prevent deadlocks in concurrent execution environments.