CVE-2026-43420
NoneCVSS
—
EPSS
0.1%
Published
May 8, 2026
CISA due date
—
Cloudanix analysis
A bug in the Linux Ceph file system client can make some systems unstable or crash when files are deleted at the same time from shared storage.
- Exploitation
- Local Privilege
- Attacker needs
- Local User
- Complexity
- Moderate
- Impact
- Denial Of Service
- Component
- OS kernel
- Class
- Race Condition
- Remediation
- Patch
- Effort
- Low
- Patch risk
- Low
What it actually does
This is a race condition in the Linux kernel CephFS client during asynchronous unlink handling. The client submits an unlink request to the Ceph Metadata Server and, before completion is fully synchronized, may decrement the inode link count based on the assumption that the unlink will succeed. If a concurrent MDS reply, capability import, capability grant, or another client’s deletion updates the inode link count to zero first, the local client can call drop_nlink() on an inode whose i_nlink is already zero. The observed impact is a kernel WARNING in the Ceph unlink path; on systems configured to panic on WARN, this can become a local denial-of-service condition. The available information does not indicate memory corruption, privilege escalation, or remote unauthenticated code execution.
Why it matters to the business
Organizations using CephFS-backed workloads on affected Linux kernels may experience kernel warnings, service instability, or node crashes if kernel warning conditions are configured to trigger panics. The operational impact is most relevant for systems with high file deletion activity, shared CephFS access from multiple clients, web/application workloads using CephFS storage, build systems, cache directories, or other environments where many clients can delete the same or related files concurrently. The vulnerability is not listed in CISA KEV, is not known to be used in ransomware campaigns, and has a very low EPSS score, so urgency is primarily driven by CephFS usage and the business impact of node instability rather than broad active exploitation.
How an attack unfolds
An attacker or untrusted workload needs the ability to perform file deletions on a CephFS mount from an affected Linux client. The attacker repeatedly triggers unlink or unlinkat operations against files where asynchronous unlink behavior is possible, ideally while another client, worker thread, or MDS reply updates the same inode’s link count. If the timing is won, the kernel Ceph client receives or processes metadata updates that set the inode link count to zero before the original unlink path performs its local decrement. The subsequent drop_nlink() call attempts to decrement an already-zero counter, producing a kernel WARNING in the drop_nlink/ceph_unlink call path. On default systems this may only produce logs and instability symptoms; on hardened or debugging-oriented systems where panic_on_warn is enabled, the same condition may crash the node, causing denial of service for workloads running there.
How to fix it
Apply the Linux kernel update from the relevant distribution or kernel supplier that contains the CephFS fix for the asynchronous unlink i_nlink race. No exact fixed package versions were provided in the input, so remediation should be based on vendor advisories, stable kernel changelogs, or distribution security updates that reference this Ceph unlink fix. Prioritize systems that mount CephFS with write access, run high-delete workloads, or have kernel.panic_on_warn enabled. As temporary mitigations, restrict write/delete permissions on CephFS to trusted workloads, reduce highly concurrent deletion patterns where practical, isolate untrusted workloads from CephFS mounts, and consider disabling panic-on-warning behavior where consistent with operational policy to reduce the chance of a warning becoming a crash. These mitigations reduce exposure but do not correct the underlying kernel race.
How to confirm the fix worked
Confirm that the running kernel includes the CephFS async unlink link-count fix by checking the active kernel version with uname -r and comparing it to the distribution’s fixed kernel advisory or changelog. Validate that all CephFS client nodes, not only Ceph storage or MDS nodes, have been updated and rebooted into the fixed kernel. Review /proc/mounts or findmnt output to identify systems with CephFS mounts and verify they are running the remediated kernel. After patching, monitor dmesg, journalctl -k, and kernel logs during representative CephFS deletion workloads to ensure the drop_nlink/ceph_unlink WARNING no longer appears. If crash dumps were previously collected, confirm no new vmcore or kdump artifacts are generated from the same warning path.
Typical attack path
- Obtain local code execution or application-level ability to create and delete files on a CephFS-mounted path.
- Identify or generate a workload that causes frequent unlink/unlinkat operations on CephFS files.
- Increase race likelihood by using concurrent deletion activity from multiple processes or multiple CephFS clients against overlapping file sets.
- Trigger the affected asynchronous unlink path while Ceph MDS replies or capability updates are processed concurrently.
- Cause the kernel client to update i_nlink to zero and then attempt an additional drop_nlink() decrement.
- Observe kernel WARNING output, service disruption, or a node crash if panic-on-warning behavior is enabled.
How to detect it
To determine whether this condition has already occurred, review kernel logs rather than network telemetry. Primary sources are dmesg output, journalctl -k, /var/log/kern.log, /var/log/messages, crash dump metadata, kdump/vmcore records, and centralized syslog/SIEM copies of kernel logs. Look for WARNING entries with a call trace containing drop_nlink, ceph_unlink, vfs_unlink, do_unlinkat, or __x64_sys_unlinkat/__arm64_sys_unlinkat. Correlate timestamps with CephFS client activity, Ceph MDS logs, application logs showing high deletion rates, and auditd records for unlink/unlinkat syscalls on CephFS-mounted paths. If panic_on_warn is enabled, also investigate unexpected reboots, kernel panic records, watchdog resets, or vmcore files around the same time. There are no known public threat actors or ransomware campaigns associated with this issue in the supplied data, so detection should focus on evidence of the kernel warning, repeated triggering, and suspicious or untrusted workloads generating high-volume CephFS deletions.
- WARNING: CPU:
- at fs/inode.c:407 drop_nlink
- drop_nlink+
- ceph_unlink+
- vfs_unlink+
- do_unlinkat+
- __arm64_sys_unlinkat+
- __x64_sys_unlinkat+
- CEPH_MDS_OP_UNLINK
- CEPH_CAP_OP_IMPORT
- CEPH_CAP_OP_GRANT
- CEPH_MSG_CLIENT_REPLY
- Call trace:
- kernel.panic_on_warn = 1
- panic_on_warn
What your security team should do
- Inventory Linux systems that mount CephFS, especially those with write access or high-volume file deletion workloads.
- Patch and reboot affected CephFS client systems using vendor-supplied kernels that include the Ceph async unlink fix.
- Prioritize remediation for nodes where kernel.panic_on_warn is enabled, because the warning can become a service-impacting crash.
- Search historical kernel logs, system journals, and crash dumps for drop_nlink and ceph_unlink warnings to determine whether the race has already occurred.
- Restrict untrusted users, containers, and application workloads from writing to shared CephFS paths until affected clients are updated.
- Add temporary monitoring for repeated unlink/unlinkat activity against CephFS combined with kernel WARNING messages.
- Track distribution advisories for exact fixed kernel package versions because none were provided in the source data.
The record
In the Linux kernel, the following vulnerability has been resolved: ceph: fix i_nlink underrun during async unlink During async unlink, we drop the `i_nlink` counter before we receive the completion (that will eventually update the `i_nlink`) because "we assume that the unlink will succeed". That is not a bad idea, but it races against deletions by other clients (or against the completion of our own unlink) and can lead to an underrun which emits a WARNING like this one: WARNING: CPU: 85 PID: 25093 at fs/inode.c:407 drop_nlink+0x50/0x68 Modules linked in: CPU: 85 UID: 3221252029 PID: 25093 Comm: php-cgi8.1 Not tainted 6.14.11-cm4all1-ampere #655 Hardware name: Supermicro ARS-110M-NR/R12SPD-A, BIOS 1.1b 10/17/2023 pstate: 60400009 (nZCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--) pc : drop_nlink+0x50/0x68 lr : ceph_unlink+0x6c4/0x720 sp : ffff80012173bc90 x29: ffff80012173bc90 x28: ffff086d0a45aaf8 x27: ffff0871d0eb5680 x26: ffff087f2a64a718 x25: 0000020000000180 x24: 0000000061c88647 x23: 0000000000000002 x22: ffff07ff9236d800 x21: 0000000000001203 x20: ffff07ff9237b000 x19: ffff088b8296afc0 x18: 00000000f3c93365 x17: 0000000000070000 x16: ffff08faffcbdfe8 x15: ffff08faffcbdfec x14: 0000000000000000 x13: 45445f65645f3037 x12: 34385f6369706f74 x11: 0000a2653104bb20 x10: ffffd85f26d73290 x9 : ffffd85f25664f94 x8 : 00000000000000c0 x7 : 0000000000000000 x6 : 0000000000000002 x5 : 0000000000000081 x4 : 0000000000000481 x3 : 0000000000000000 x2 : 0000000000000000 x1 : 0000000000000000 x0 : ffff08727d3f91e8 Call trace: drop_nlink+0x50/0x68 (P) vfs_unlink+0xb0/0x2e8 do_unlinkat+0x204/0x288 __arm64_sys_unlinkat+0x3c/0x80 invoke_syscall.constprop.0+0x54/0xe8 do_el0_svc+0xa4/0xc8 el0_svc+0x18/0x58 el0t_64_sync_handler+0x104/0x130 el0t_64_sync+0x154/0x158 In ceph_unlink(), a call to ceph_mdsc_submit_request() submits the CEPH_MDS_OP_UNLINK to the MDS, but does not wait for completion. Meanwhile, between this call and the following drop_nlink() call, a worker thread may process a CEPH_CAP_OP_IMPORT, CEPH_CAP_OP_GRANT or just a CEPH_MSG_CLIENT_REPLY (the latter of which could be our own completion). These will lead to a set_nlink() call, updating the `i_nlink` counter to the value received from the MDS. If that new `i_nlink` value happens to be zero, it is illegal to decrement it further. But that is exactly what ceph_unlink() will do then. The WARNING can be reproduced this way: 1. Force async unlink; only the async code path is affected. Having no real clue about Ceph internals, I was unable to find out why the MDS wouldn't give me the "Fxr" capabilities, so I patched get_caps_for_async_unlink() to always succeed. (Note that the WARNING dump above was found on an unpatched kernel, without this kludge - this is not a theoretical bug.) 2. Add a sleep call after ceph_mdsc_submit_request() so the unlink completion gets handled by a worker thread before drop_nlink() is called. This guarantees that the `i_nlink` is already zero before drop_nlink() runs. The solution is to skip the counter decrement when it is already zero, but doing so without a lock is still racy (TOCTOU). Since ceph_fill_inode() and handle_cap_grant() both hold the `ceph_inode_info.i_ceph_lock` spinlock while set_nlink() runs, this seems like the proper lock to protect the `i_nlink` updates. I found prior art in NFS and SMB (using `inode.i_lock`) and AFS (using `afs_vnode.cb_lock`). All three have the zero check as well.
Affected packages
| Ecosystem | Package | Introduced | Fixed |
|---|