CVE-2026-89567
NoneCVSS
—
EPSS
0.2%
Published
Sep 11, 2026
CISA due date
—
Cloudanix analysis
A problem in the Linux kernel's handling of journal buffers can make the whole system freeze or crash when the system is low on memory.
- Exploitation
- Local Privilege
- Attacker needs
- Local User
- Complexity
- Moderate
- Impact
- Denial Of Service
- Component
- OS kernel
- Class
- Race Condition
- Remediation
- Upgrade
- Effort
- Medium
- Patch risk
- Low
What it actually does
The jbd2 shrinker fails to decrement its scan budget for busy checkpoint buffers, allowing a single scan to traverse an entire checkpoint list while holding journal->j_list_lock and potentially causing soft lockups or RCU stalls on other CPUs.
Why it matters to the business
Systems may experience sudden unresponsiveness or kernel stalls under memory pressure or heavy journaling workloads, leading to degraded service availability and possible unplanned reboots; low exploit likelihood reduces immediate risk but does not eliminate operational exposure in large-scale Linux deployments.
How an attack unfolds
An attacker with local access crafts a workload that creates large checkpoint transactions dominated by busy buffers, then triggers the shrinker repeatedly to force prolonged lock contention and induce stalls or crashes without requiring network access or elevated privileges beyond standard user context.
How to fix it
Update the Linux kernel to a version containing the bound shrinker scan fix in jbd2; apply the change that passes nr_to_scan into journal_shrink_one_cp_list and decrements for every examined buffer.
How to confirm the fix worked
Confirm the presence of the upstream commit that restores scan-budget semantics in journal_shrink_one_cp_list; run targeted stress tests exercising checkpoint lists under memory pressure and verify absence of excessive j_list_lock hold times or stalls.
Typical attack path
- Obtain local unprivileged access on a Linux system using jbd2 journaling.
- Generate filesystem activity that produces checkpoint transactions containing mostly pinned buffers.
- Induce memory pressure to activate the jbd2 shrinker.
- Observe or trigger lock contention leading to soft lockups or RCU stalls.
How to detect it
Review kernel logs for repeated soft lockup or RCU stall entries mentioning j_list_lock or jbd2 shrinker activity; correlate with periods of high memory pressure and large checkpoint transactions.
What your security team should do
- Prioritize kernel updates on systems with heavy journaling or memory-constrained workloads.
- Monitor kernel logs for soft lockup and RCU stall messages referencing j_list_lock.
- Apply the fix in the next scheduled maintenance window given low EPSS and absence from KEV.
The record
In the Linux kernel, the following vulnerability has been resolved: jbd2: bound shrinker scans by examined checkpoint buffers The jbd2 shrinker currently accounts only checkpoint buffers that it successfully releases against nr_to_scan. Busy buffers therefore do not consume the scan budget. If a checkpoint transaction contains mostly busy buffers, the shrinker can scan its entire checkpoint list while holding journal->j_list_lock. Large checkpoint lists can result in excessive lock hold times and leave other CPUs spinning on j_list_lock, causing soft lockups or RCU stalls. Pass nr_to_scan into journal_shrink_one_cp_list() and decrement it for every buffer examined, including busy buffers. Pass NULL from checkpoint cleanup paths so their existing full-list behavior is preserved. This restores the scan-budget semantics that existed before journal_shrink_one_cp_list() was changed to always scan a complete checkpoint list.
Affected packages
| Ecosystem | Package | Introduced | Fixed |
|---|