CVE-2026-99569 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
f2fs: release a removed xattr node in roll-forward recovery
When xattrs shrink enough to fit in the inline xattr area, write_all_xattrs() truncates the xattr node and clears i_xattr_nid. If the file is then fsynced without a checkpoint, only the inode block is written, with i_xattr_nid of 0.
Roll-forward recovery starts from the checkpointed inode, whose i_xattr_nid still points to the old xattr node. f2fs_recover_inline_xattr() copies only the inline xattr area, and f2fs_update_inode() writes the old i_xattr_nid back. So the inode keeps the stale xattr node:
- The node block is never released, and fsck reports "nonzero bytes in xattr space after end of list". - If the inline xattr list ends exactly at the end of the inline area, its terminator is read from the stale node, and the removed xattrs come back after recovery.
When the fsynced inode has no xattr node but the checkpointed one has, release the old xattr node as truncate_node() does: check its block address, invalidate the block and drop its node cache, which may still be dirty.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/21/2026
The f2fs file system in the Linux kernel contains a logic flaw within its roll-forward recovery mechanism that leads to resource leaks and data inconsistency during specific fsync operations. This vulnerability arises from an asymmetry between how inode metadata is updated during normal operation versus how it is restored after a crash or power loss. Specifically, when extended attributes (xattrs) on a file shrink sufficiently to fit entirely within the inline xattr area of the inode structure, the write_all_xattrs function truncates the separate external xattr node and clears the i_xattr_nid field in memory to indicate that no external node is required. If an fsync operation occurs immediately after this change but before a full checkpoint is written to disk, only the updated inode block containing the cleared i_xattr_nid value of zero is persisted to storage media.
The core technical flaw manifests during roll-forward recovery, which is triggered when the file system detects inconsistencies or needs to replay journal entries following an unclean shutdown. The recovery process begins by loading the last known good checkpointed version of the inode from disk. Since the previous fsync did not trigger a full checkpoint that included the updated metadata state where i_xattr_nid was zero, the recovered inode retains the old value pointing to the now-redundant external xattr node block. The recovery function f2fs_recover_inline_xattr correctly copies the inline data, but subsequent calls to f2fs_update_inode erroneously write back the stale i_xattr_nid from the checkpointed state rather than recognizing that the current in-memory state has already discarded the node. This results in the inode structure being restored with a pointer to an xattr node that is no longer logically part of the file's attribute list.
The operational impact of this vulnerability includes both resource exhaustion and data integrity issues. Because the external xattr node block remains referenced by the recovered inode, it is never released or deallocated from the storage subsystem. This leads to a persistent leak where space marked as used cannot be reclaimed, eventually causing filesystem corruption warnings such as nonzero bytes in xattr space after end of list during fsck operations. Furthermore, if the inline xattr data happens to fill exactly up to the boundary of the inline area without its own terminator byte, the system may read past this boundary into the stale external node block for termination information. This can cause previously removed extended attributes to reappear in the file's attribute list after recovery, leading to unexpected behavior in applications relying on accurate xattr states and potentially exposing sensitive data that was intended to be deleted.
From a classification perspective, this issue aligns with CWE-401 Missing Release of Memory after Effective Lifetime, as the node block is not freed when it becomes obsolete. It also relates to CWE-835 Loop into Dead End due to improper handling of state transitions during recovery. In terms of attack vectors and defensive mapping, while primarily a stability issue rather than an exploit vector for privilege escalation, the potential for data resurrection touches upon aspects of CWE-209 Generation of Error Condition Leading to Information Exposure if sensitive attributes are inadvertently restored. The ATT&CK framework does not have a direct tactic for this specific kernel bug, but it falls under broader categories of system configuration errors or resource management failures that degrade availability and integrity.
To mitigate this vulnerability, the Linux kernel has been patched to ensure consistency between checkpointed states and in-memory updates during recovery. The fix involves modifying the roll-forward recovery logic to detect when a file's current state indicates no xattr node exists while the checkpointed inode still references one. In such cases, the system now explicitly releases the old xattr node by checking its block address, invalidating the corresponding buffer head, and dropping it from the node cache even if it is dirty. This ensures that stale metadata pointers are cleared during recovery, preventing both memory leaks and the resurrection of deleted attributes. Users should apply kernel updates containing this fix to maintain filesystem integrity and prevent gradual storage degradation caused by unreleased xattr nodes.