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

acpi/apei/ghes: Use raw_spinlock_t for CXL CPER work locks

The CXL CPER work registration and unregistration helpers acquire
cxl_cper_work_lock and cxl_cper_prot_err_work_lock with a spinlock
guard(), which leaves local interrupts enabled. The corresponding post
paths (cxl_cper_post_event(), cxl_cper_post_prot_err()) execute in hard
IRQ context (they are called from the GHES error notification path) and
acquire the same locks with an irqsave guard().

If a CPU is holding one of these locks via a spinlock guard() when a GHES
interrupt arrives on the same CPU, the IRQ handler spins on the held lock
waiting for it to release, while the lock holder is preempted by the IRQ.
The result is a deadlock.

Convert both locks from spinlock_t to raw_spinlock_t and use guard() at
all call sites. On PREEMPT_RT kernels spinlock_t is backed by rt_mutex and
sleeping from hard IRQ context is not permitted; raw_spinlock_t is safe in
both contexts.

Add WARN_ONCE to both register functions to surface double-registration
bugs at runtime.

Restructure both unregister functions to clear the global work pointer
under the lock before calling cancel_work_sync(), closing the window
where a CPER interrupt could schedule work on a pointer about to be
freed. Add kfifo_reset() after cancel_work_sync() so stale entries
are not replayed on next module load.

Both kfifos are single-consumer: only one work_struct is registered at
a time, enforced by the WARN_ONCE guard in the register functions.
kfifo_reset() is safe outside the lock because cancel_work_sync() has
already quiesced the consumer, and no new consumer can register until
the current module exit completes and a fresh module init runs.

Remove the redundant cancel_work_sync() call from cxl_ras_exit() and
cxl_pci_driver_exit(). The CPER unregister functions now quiesce
the work internally.
Published: 2026-09-11
Score: 4.4 Medium
EPSS: < 1% Very Low
KEV: No
Impact: Deadlock causing CPU or system stall
Action: Patch
AI Analysis

Impact

The issue arises when the Linux kernel’s CXL CPER work registration helpers acquire a normal spinlock with guard(), leaving local interrupts enabled. The GHES error notification path, which runs in hard IRQ context, acquires the same locks using an irqsave guard(), temporarily disabling interrupts. If a CPU holds the lock in normal context and a GHES interrupt fires on the same CPU, the interrupt handler spins waiting for the lock while the lock holder is preempted, resulting in a deadlock that can halt the CPU and disrupt kernel operations. This concurrency flaw corresponds to CWE‑674 (Unchecked Lock Usage) and CWE‑833 (Deadlock in Interrupt Context).

Affected Systems

Any Linux kernel installation that builds the ACPI/APEI/ghes module with CXL CPER support and has not yet integrated the fix that converts the locks to raw_spinlock_t is vulnerable. No specific version range is supplied; the risk applies to unpatched builds prior to the changes described in the CVE.

Risk and Exploitability

The CVSS score of 4.4 and an EPSS score of < 1% indicate a low likelihood of exploitation. The flaw requires a GHES interrupt, typically triggered by a hardware fault, so it is not trivially controllable from a remote client. Accordingly, the risk is primarily local: a malicious firmware or a local attacker could provoke the deadlock, leading to a system stall. The vulnerability is not listed in CISA’s KEV catalog, consistent with its limited exploitation surface.

Generated by OpenCVE AI on September 12, 2026 at 16:45 UTC.

Remediation

No vendor fix or workaround currently provided.

OpenCVE Recommended Actions

  • Upgrade the kernel to a version that implements the change converting cxl_cper_work_lock and cxl_cper_prot_err_work_lock to raw_spinlock_t and uses guard() exclusively at all call sites.
  • If an upgrade is not possible, patch the source locally by replacing the spinlock_t definitions with raw_spinlock_t in the affected lock declarations and rebuild the kernel module.
  • As a temporary protective measure, disable GHES error reporting or mask GHES interrupts on CPUs that may hold the CXL CPER locks to prevent the deadlock scenario.

Generated by OpenCVE AI on September 12, 2026 at 16:45 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories yet.

History

Sat, 12 Sep 2026 17:15:00 +0000

Type Values Removed Values Added
Weaknesses CWE-674

Sat, 12 Sep 2026 12:15:00 +0000

Type Values Removed Values Added
Weaknesses CWE-833
References
Metrics threat_severity

None

cvssV3_1

{'score': 4.4, 'vector': 'CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:N/I:N/A:H'}

threat_severity

Moderate


Sat, 12 Sep 2026 10:45:00 +0000

Type Values Removed Values Added
Weaknesses CWE-674

Fri, 11 Sep 2026 23:45:00 +0000

Type Values Removed Values Added
Description In the Linux kernel, the following vulnerability has been resolved: acpi/apei/ghes: Use raw_spinlock_t for CXL CPER work locks The CXL CPER work registration and unregistration helpers acquire cxl_cper_work_lock and cxl_cper_prot_err_work_lock with a spinlock guard(), which leaves local interrupts enabled. The corresponding post paths (cxl_cper_post_event(), cxl_cper_post_prot_err()) execute in hard IRQ context (they are called from the GHES error notification path) and acquire the same locks with an irqsave guard(). If a CPU is holding one of these locks via a spinlock guard() when a GHES interrupt arrives on the same CPU, the IRQ handler spins on the held lock waiting for it to release, while the lock holder is preempted by the IRQ. The result is a deadlock. Convert both locks from spinlock_t to raw_spinlock_t and use guard() at all call sites. On PREEMPT_RT kernels spinlock_t is backed by rt_mutex and sleeping from hard IRQ context is not permitted; raw_spinlock_t is safe in both contexts. Add WARN_ONCE to both register functions to surface double-registration bugs at runtime. Restructure both unregister functions to clear the global work pointer under the lock before calling cancel_work_sync(), closing the window where a CPER interrupt could schedule work on a pointer about to be freed. Add kfifo_reset() after cancel_work_sync() so stale entries are not replayed on next module load. Both kfifos are single-consumer: only one work_struct is registered at a time, enforced by the WARN_ONCE guard in the register functions. kfifo_reset() is safe outside the lock because cancel_work_sync() has already quiesced the consumer, and no new consumer can register until the current module exit completes and a fresh module init runs. Remove the redundant cancel_work_sync() call from cxl_ras_exit() and cxl_pci_driver_exit(). The CPER unregister functions now quiesce the work internally.
Title acpi/apei/ghes: Use raw_spinlock_t for CXL CPER work locks
First Time appeared Linux
Linux linux Kernel
CPEs cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*
Vendors & Products Linux
Linux linux Kernel
References

Subscriptions

Linux Linux Kernel
cve-icon MITRE

Status: PUBLISHED

Assigner: Linux

Published:

Updated: 2026-09-11T19:44:53.578Z

Reserved: 2026-09-11T19:38:34.729Z

Link: CVE-2026-89589

cve-icon Vulnrichment

No data.

cve-icon NVD

Status : Received

Published: 2026-09-11T20:19:43.437

Modified: 2026-09-11T20:19:43.437

Link: CVE-2026-89589

cve-icon Redhat

Severity : Moderate

Publid Date: 2026-09-11T19:44:53Z

Links: CVE-2026-89589 - Bugzilla

cve-icon OpenCVE Enrichment

Updated: 2026-09-12T17:00:15Z

Weaknesses