CVE-2026-99499 in Linuxinfo

Summary

by MITRE • 11/19/2026

In the Linux kernel, the following vulnerability has been resolved:

s390/pci: Fix use-after-free race in zpci floating interrupt cleanup

zpci_clear_irq() stops the adapter from raising new interrupts for the function, but a zpci_floating_irq_handler() already running on another CPU can still be scanning zdev->aibv when zpci_msi_teardown_floating() releases it.

Clear the zpci_ibv[] entry so no further handler picks the vector up, then
wait for a grace period before releasing it. The handler runs inside the rcu_read_lock() section that do_airq_interrupt() holds across airq->handler(), so synchronize_rcu() drains any handler still in flight. Release the vector and free the summary bit only after the grace period, so neither can be reused while a reader still holds the old pointer.

zpci_ibv served both delivery modes, indexed by function under FLOATING and by cpu under DIRECTED. Only the floating vectors are published to and torn down under the interrupt handler, so split the directed vectors out into zpci_dibv and annotate zpci_ibv __rcu, which lets sparse check the accessors above.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel vulnerability identified in the s390 PCI subsystem involves a critical use-after-free race condition during the cleanup of floating interrupts for PCI functions on IBM Z architecture systems. This flaw occurs within the zpci_clear_irq function, which is responsible for stopping an adapter from raising new interrupts for a specific device function. The core issue arises because while one CPU executes zpci_msi_teardown_floating to release resources associated with the interrupt vector, another CPU may simultaneously be executing the zpci_floating_irq_handler. This handler continues to scan and access the zdev->aibv data structure even after it has been scheduled for deallocation by the tearing down process. Such a race condition leads to memory corruption or system instability as the kernel attempts to dereference pointers that are no longer valid, potentially resulting in crashes or exploitable conditions where an attacker could influence control flow through corrupted memory states.

The technical root cause lies in the lack of proper synchronization between interrupt handler execution and resource teardown operations. The zpci_ibv array served dual purposes for both floating and directed delivery modes, indexed by function under FLOATING mode and by CPU under DIRECTED mode. Because only floating vectors are published to and torn down within the context of the interrupt handler, there was insufficient protection against concurrent access during cleanup. When the teardown routine released the vector memory without ensuring that all in-flight handlers had completed their execution, it created a window where stale pointers remained accessible. This violates fundamental concurrency safety principles required for kernel-level resource management, particularly in multi-processor environments where race conditions are prevalent due to non-deterministic scheduling of interrupt service routines across different cores.

To resolve this vulnerability, the fix implements several layered defensive measures aligned with established memory safety practices. First, the zpci_ibv entry is explicitly cleared before initiating any release operations, ensuring that no subsequent handler can pick up a stale vector reference. Second, a grace period is introduced using synchronize_rcu to drain any handlers still in flight within their respective RCU read-side critical sections held by do_airq_interrupt across airq->handler calls. This ensures that all ongoing executions complete before the memory is freed. Third, the directed vectors are separated into a distinct zpci_dibv array, isolating them from floating vector management and reducing complexity. The zpci_ibv structure is annotated with __rcu to enable static analysis tools like sparse to verify correct access patterns, thereby preventing future regressions in RCU usage semantics.

The operational impact of this vulnerability extends beyond immediate system stability risks. In production environments running on IBM Z mainframes or Linux-based virtualized instances thereof, such race conditions can lead to unpredictable kernel panics, data corruption within PCI device contexts, and potential denial-of-service scenarios if triggered repeatedly under load. From a security perspective, use-after-free vulnerabilities are particularly dangerous as they often allow arbitrary code execution when combined with other weaknesses like heap spraying or information disclosure techniques that help an attacker locate freed memory regions for reuse. The fix mitigates these risks by enforcing strict ordering between interrupt handler completion and resource deallocation, thereby eliminating the window of opportunity for exploitation through concurrent access to released memory.

This vulnerability aligns with Common Weakness Enumeration category CWE-416, which describes use-after-free errors resulting from improper handling of freed memory references. It also relates to ATT&CK technique T1059, specifically subtechniques involving command and script interpretation or system services abuse if the race condition were leveraged for privilege escalation or persistence mechanisms within compromised systems. Industry standards such as Linux kernel coding guidelines emphasize the importance of RCU synchronization primitives in interrupt contexts to prevent exactly this class of concurrency bugs. The implementation of synchronize_rcu ensures that all readers have exited their critical sections before writers proceed with memory reclamation, adhering to best practices for lock-free data structure management and concurrent programming safety in high-performance computing environments.

Mitigation strategies include applying the provided kernel patch immediately upon availability through standard update channels maintained by distribution vendors or upstream Linux maintainers. For organizations unable to apply patches instantly, monitoring system logs for unexpected interrupt-related errors or performance anomalies may provide early indicators of exploitation attempts. Additionally, enabling Kernel Address Sanitizer (KASAN) in development and testing environments helps detect similar memory safety violations before they reach production deployments. Long-term remediation involves rigorous code review processes focused on concurrency patterns involving RCU usage, ensuring that all shared data structures are properly annotated with appropriate synchronization primitives to prevent future occurrences of this class of vulnerabilities across the s390 PCI subsystem and related kernel components.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00156

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!