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

fsnotify: Fix stale object mask after concurrent mark updates

When a mark gets a new event bit, fanotify and inotify may avoid
recalculating the object mask if the cached aggregate already contains that
bit. This is racy with a recalculation triggered by a concurrent update to
another mark on the same connector.

The concurrent scan can read the mark before the new bit is added, while
the updater reads the old aggregate before that scan publishes its result.
The updater then skips recalculation and the scan publishes a mask without
the bit, leaving the object mask stale after both updates complete.

This can be reproduced with two fanotify groups watching the same inode:
one thread removes FAN_MODIFY from one existing mark while another thread
adds FAN_MODIFY to the other mark. After both fanotify_mark() calls return,
writes can fail to produce FAN_MODIFY for the group whose mark now contains
the bit. This was reproduced on an unmodified v6.12.95 kernel. The
equivalent inotify interleaving loses IN_MODIFY events.

For normal fanotify additions, recalculate whenever the raw mark mask
changes. The normal mask is not cleared asynchronously, so an unchanged
addition cannot introduce missing interest. Always recalculate ignore-mask
updates because FS_MODIFY handling may clear the ignore mask without taking
mark->lock, making snapshot comparisons unreliable.

Always recalculate after updating an existing inotify watch. Its replace
path temporarily sets mark->mask to zero, so a concurrent scan can observe
zero even when the old and final masks are equal. Assigning the replacement
mask directly would avoid the transient zero, but existing-watch updates
are infrequent, so unconditional recalculation is simpler.
Published: 2026-09-11
Score: 2.5 Low
EPSS: < 1% Very Low
KEV: No
Impact: Stale event mask causing missing modification notifications
Action: Update kernel
AI Analysis

Impact

A race condition in the Linux kernel’s fsnotify subsystem can leave the cached object mask stale after concurrent fanotify or inotify mark updates. When a mark gains an event bit, the kernel may skip recalculation if the cached aggregate already contains that bit, but a concurrent update on the same connector can cause the cached mask to be published without the new bit. The result is that a watcher may miss FAN_MODIFY or IN_MODIFY events even though the file has been modified. The flaw does not provide direct control over memory, data, or code execution, so it does not lead to privilege escalation, but it can cause application logic errors or data loss when real‑time change notifications are relied upon.

Affected Systems

The issue affects all Linux kernel releases that contain the vulnerable fsnotify logic, beginning with kernel v6.12.95 and earlier until the patch is back‑ported. Distributions shipping those kernels, or any kernel that has not incorporated the fix, are impacted.

Risk and Exploitability

The CVSS base score is 2.5, the EPSS score is < 1%, and the vulnerability is not listed in the CISA KEV catalog. The EPSS score of < 1% indicates a very low probability of exploitation. Exploitation requires a race between two locally executed threads that add or modify fanotify or inotify marks; thus it is limited to local or privileged processes. Because the consequence is limited to missing modification notifications rather than escalation or arbitrary code execution, the overall risk is low. However, applications that depend on precise file‑change events may behave incorrectly or lose data when the bug manifests.

Generated by OpenCVE AI on September 13, 2026 at 04:39 UTC.

Remediation

No vendor fix or workaround currently provided.

OpenCVE Recommended Actions

  • Apply a kernel update that includes the fsnotify fix (any kernel newer than v6.12.95)
  • Ensure distributions are pulling the latest patch set from their upstream mirrors
  • If a patch is unavailable, avoid relying on real‑time FAN_MODIFY/IN_MODIFY notifications in critical workloads until the kernel is updated

Generated by OpenCVE AI on September 13, 2026 at 04:39 UTC.

Tracking

Sign in to view the affected projects.

Advisories

No advisories yet.

History

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

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

None

cvssV3_1

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

threat_severity

Low


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

Type Values Removed Values Added
Description In the Linux kernel, the following vulnerability has been resolved: fsnotify: Fix stale object mask after concurrent mark updates When a mark gets a new event bit, fanotify and inotify may avoid recalculating the object mask if the cached aggregate already contains that bit. This is racy with a recalculation triggered by a concurrent update to another mark on the same connector. The concurrent scan can read the mark before the new bit is added, while the updater reads the old aggregate before that scan publishes its result. The updater then skips recalculation and the scan publishes a mask without the bit, leaving the object mask stale after both updates complete. This can be reproduced with two fanotify groups watching the same inode: one thread removes FAN_MODIFY from one existing mark while another thread adds FAN_MODIFY to the other mark. After both fanotify_mark() calls return, writes can fail to produce FAN_MODIFY for the group whose mark now contains the bit. This was reproduced on an unmodified v6.12.95 kernel. The equivalent inotify interleaving loses IN_MODIFY events. For normal fanotify additions, recalculate whenever the raw mark mask changes. The normal mask is not cleared asynchronously, so an unchanged addition cannot introduce missing interest. Always recalculate ignore-mask updates because FS_MODIFY handling may clear the ignore mask without taking mark->lock, making snapshot comparisons unreliable. Always recalculate after updating an existing inotify watch. Its replace path temporarily sets mark->mask to zero, so a concurrent scan can observe zero even when the old and final masks are equal. Assigning the replacement mask directly would avoid the transient zero, but existing-watch updates are infrequent, so unconditional recalculation is simpler.
Title fsnotify: Fix stale object mask after concurrent mark updates
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:58.057Z

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

Link: CVE-2026-89595

cve-icon Vulnrichment

No data.

cve-icon NVD

Status : Received

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

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

Link: CVE-2026-89595

cve-icon Redhat

Severity : Low

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

Links: CVE-2026-89595 - Bugzilla

cve-icon OpenCVE Enrichment

Updated: 2026-09-13T04:45:18Z

Weaknesses
  • CWE-367

    Time-of-check Time-of-use (TOCTOU) Race Condition