CVE-2026-74441 in Linux
Summary
by MITRE • 08/15/2026
In the Linux kernel, the following vulnerability has been resolved:
usb: typec: ucsi: Fix race condition and ordering in port unregistration
A synchronization issue exists during port unregistration where pending partner work items can race against workqueue destruction, leading to use-after-free conditions:
cros_ec_ucsi cros_ec_ucsi.3.auto: error -ETIMEDOUT: PPM init failed BUG: kernel NULL pointer dereference, address: 0000000000000000 RIP: 0010:__queue_work+0x83/0x4a0 Call Trace: <IRQ> __cfi_delayed_work_timer_fn+0x10/0x10 run_timer_softirq+0x3b6/0xbd0 sched_clock_cpu+0xc/0x110 irq_exit_rcu+0x18d/0x330 fred_sysvec_apic_timer_interrupt+0x5e/0x80
Fix this by ensuring strict ordering and proper serialization during teardown:
1. Move ucsi_unregister_partner() to the beginning of the teardown sequence and protect it under the connector mutex lock. 2. Ensure all pending partner tasks are explicitly flushed and finished before the workqueue is destroyed. 3. Switch from mod_delayed_work() to a cancel_delayed_work() and queue_delayed_work() sequence. This guarantees that items currently marked as pending won't be scheduled an additional time, preventing a double release of resources which leads to the following crash:
Oops: general protection fault, probably for non-canonical address 0xdead000000000122: 0000 [#1] SMP NOPTI
Workqueue: cros_ec_ucsi.3.auto-con2 ucsi_poll_worker RIP: 0010:ucsi_poll_worker+0x65/0x1e0 Call Trace: <TASK> process_scheduled_works+0x218/0x6d0 worker_thread+0x188/0x3f0 __cfi_worker_thread+0x10/0x10 kthread+0x226/0x2a0
To ensure these rules are applied identically across both the normal teardown and the ucsi_init() error paths, consolidate the cleanup logic into a new helper, ucsi_unregister_port().
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 08/15/2026
The vulnerability resides within the linux kernel's usb typec ucsi subsystem where a race condition during port unregistration creates potential use-after-free conditions that can lead to system crashes and kernel oops. This issue specifically affects the chrome os embedded controller ucsi driver which manages usb type-c ports through the cros_ec_ucsi interface. The flaw manifests when pending partner work items attempt to execute concurrently with workqueue destruction, creating a scenario where memory locations are accessed after being freed. The error conditions typically present as kernel NULL pointer dereferences with addresses such as 0x0000000000000000 and general protection faults at non-canonical addresses like 0xdead000000000122, indicating memory corruption from improper resource handling during shutdown sequences.
The technical root cause stems from improper synchronization during the teardown process of usb type-c ports. During normal operation, work items are scheduled using mod_delayed_work() which can create race conditions when concurrent cleanup operations occur. The kernel's workqueue subsystem manages these asynchronous tasks but fails to properly serialize access when multiple execution paths attempt to modify shared resources simultaneously. When ucsi_unregister_partner() executes after the workqueue destruction, it attempts to access freed memory structures, particularly affecting the cros_ec_ucsi.3.auto connector instance which shows error messages indicating PPM init failures and timeout conditions. The call trace patterns show execution paths through __queue_work and __cfi_delayed_work_timer_fn functions, demonstrating how timer-based work items interact with the problematic shutdown sequence.
The operational impact of this vulnerability extends beyond simple system crashes to potentially enable privilege escalation and denial of service attacks within embedded systems that rely on chrome os hardware platforms. Attackers could exploit this timing window to cause system instability or create conditions where malicious code might gain elevated privileges through memory corruption exploits. The vulnerability affects devices using the cros_ec_ucsi driver including chromebooks, tablets, and other hardware platforms that implement usb type-c port management through chrome os embedded controllers. System reliability is compromised as the kernel becomes unstable during hotplug operations or device removal scenarios where port unregistration occurs rapidly.
The fix implements a comprehensive synchronization strategy that addresses multiple aspects of the race condition. The solution begins by reordering the teardown sequence to execute ucsi_unregister_partner() before workqueue destruction, ensuring proper resource cleanup order. Implementation uses connector mutex locking to serialize access during critical sections, preventing concurrent modifications to shared state variables. The approach replaces mod_delayed_work() with explicit cancel_delayed_work() followed by queue_delayed_work() sequences which ensures that pending items are properly canceled rather than potentially rescheduled. This prevents double release conditions that could lead to memory corruption and system crashes. Additionally, the solution consolidates cleanup logic into a dedicated helper function called ucsi_unregister_port() to ensure consistent behavior across both normal teardown paths and error handling scenarios in ucsi_init() functions, establishing uniform resource management across all execution contexts.
This vulnerability aligns with common weakness enumerations including cwe-362 for race conditions and cwe-416 for use after free conditions. The fix addresses attack patterns categorized under the attack technique of privilege escalation through memory corruption as documented in the mitre att&ck framework. The solution implements proper resource management practices that align with kernel security standards, ensuring that all work items are properly flushed before destruction occurs. The changes maintain compatibility with existing usb type-c port management functionality while preventing the conditions that led to system crashes and potential exploitation opportunities in embedded devices running chrome os or similar systems that depend on this kernel subsystem for usb type-c connectivity management.