Cloudanix VulnDB

CVE-2026-99207

None

CVSS

—

EPSS

0.1%

Published

Oct 28, 2026

CISA due date

—

Cloudanix analysis

Schedule a fix SSVC: Track

A locking mistake in the Linux kernel's storage target handling can cause the system to freeze when certain rare combinations of disk commands and hardware completion paths occur.

Exploitation
Local Privilege
Attacker needs
Local User
Complexity
Theoretical
Impact
Denial Of Service
Component
OS kernel
Class
Race Condition
Remediation
Patch
Effort
Medium
Patch risk
Low

What it actually does

Race condition in Linux kernel SCSI target code where target_do_delayed_work() acquires delayed_cmd_lock via plain spin_lock() while running from system_percpu_wq with interrupts enabled; other paths use spin_lock_irqsave(), and direct completions from interrupt context (complete_type=1, backend bio end_io) can deadlock when ORDERED commands trigger transport_complete_ordered_sync() or target_non_ordered_release().

Why it matters to the business

Potential kernel hangs or lockdep warnings in storage target subsystems on systems using vhost-scsi or similar fabrics with direct command completion and initiators issuing ORDERED task attributes, leading to brief storage I/O stalls until reboot; low immediate risk given 3-day publication age, zero EPSS trend, and no known exploitation.

How an attack unfolds

Attacker sends SCSI commands with ORDERED task attributes to a vhost-scsi target configured for direct completion; backend I/O completion arrives in interrupt context, target_complete_ok_work() calls transport_complete_task_attr() which acquires the lock, then target_do_delayed_work() spins indefinitely on the same lock from process context, causing deadlock only under the precise combination of non-default settings and ORDERED commands.

How to fix it

Apply the upstream fix that changes target_do_delayed_work() to acquire delayed_cmd_lock with interrupts disabled (spin_lock_irqsave equivalent); rebuild and deploy updated kernel packages containing commit that resolves the spinlock context mismatch.

How to confirm the fix worked

Boot with CONFIG_PROVE_LOCKING enabled and exercise ORDERED commands under direct-completion fabric; confirm absence of lockdep warnings on delayed_cmd_lock; verify spin_lock_irq usage in target_do_delayed_work() via source inspection or kernel symbols.

Typical attack path

  1. Configure fabric with direct_compl_supp and complete_type=1
  2. Initiator issues VIRTIO_SCSI_S_ORDERED commands
  3. Backend delivers completion from interrupt context
  4. transport_complete_task_attr() and target_do_delayed_work() contend on delayed_cmd_lock without irqsave
  5. System deadlocks or reports inconsistent lock state

How to detect it

Search kernel logs for lockdep reports mentioning delayed_cmd_lock, hardirq/softirq context mismatches, or inconsistent lock state after enabling lockdep; inspect system_percpu_wq work item activity and SCSI target completion paths for hangs; no public exploit artifacts exist.

What your security team should do

  • Prioritize kernel updates on hosts exposing vhost-scsi or equivalent direct-completion SCSI targets within standard patch windows
  • Audit storage fabrics for non-default complete_type=1 settings and restrict ORDERED task attribute acceptance if feasible
  • Monitor EPSS and KEV updates given the 3-day publication window

The record

In the Linux kernel, the following vulnerability has been resolved: scsi: target: Disable interrupts while holding delayed_cmd_lock target_do_delayed_work() takes dev->delayed_cmd_lock with a plain spin_lock(). It runs from system_percpu_wq, so interrupts stay enabled while the lock is held. Every other acquisition of that lock uses spin_lock_irqsave(): target_handle_task_attr() and transport_complete_ordered_sync() in target_core_transport.c, and target_non_ordered_release() in target_core_device.c. That was safe while every caller of transport_complete_task_attr() ran in process context: target_complete_ok_work() from target_completion_wq, transport_complete_qf() from dev->qf_work_queue, and transport_generic_request_failure() from the submit and execute paths. Since commit 06933066d88a ("scsi: target: Add support for completing commands from backend context") that is no longer true. With complete_type=1 on a fabric that sets direct_compl_supp, target_complete() runs target_complete_ok_work() inline in the backend's completion context, which target_complete_cmd_with_sense() documents as "May be called from interrupt context". For iblock that is the bio end_io. target_complete_ok_work() starts with transport_complete_task_attr(), which takes delayed_cmd_lock in two ways: - Every ORDERED command is put on dev->delayed_cmd_list by target_handle_task_attr() and dispatched from there by target_do_delayed_work(), which marks it SCF_TASK_ORDERED_SYNC. Its completion therefore goes through transport_complete_ordered_sync(). - A SIMPLE command that completes while an ORDERED command is pending drops the last reference to the killed dev->non_ordered, and percpu_ref_put() then runs target_non_ordered_release() in the completing context. Both take the lock and, if commands are waiting, call schedule_work(&dev->delayed_cmd_work), which queues on system_percpu_wq, i.e. on the CPU that took the completion. Further completions for the same queue are typically delivered there too, so one arriving while the work holds the lock spins on it forever. Reaching this needs complete_type=1, which is not the default (vhost-scsi, the only fabric with direct_compl_supp, defaults to TARGET_QUEUE_COMPL), a backend whose I/O completes from interrupt context, and ORDERED commands from the initiator. Linux virtio_scsi guests send only VIRTIO_SCSI_S_SIMPLE and never take the ordered path; any guest that uses the ORDERED task attribute, which vhost-scsi accepts, does. target_do_delayed_work() is a work item and always runs in process context, so spin_lock_irq() is sufficient. Found by inspection; no runtime report. A single ORDERED command goes through both acquisitions, so with CONFIG_PROVE_LOCKING the first one completed through direct completion should produce an inconsistent lock state report on delayed_cmd_lock (hardirq or softirq, depending on where the backend completes).

Affected packages

Ecosystem Package Introduced Fixed