CVE-2026-99576 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

f2fs: zone: fix to avoid bio split on sequential zone

In the block layer, bio_split_to_limits() splits a bio if it exceeds any underlying queue limits: 1. queue_max_sectors: Splits bios larger than the transfer limit. This limit is set by the device driver/DMA controller (max_hw_sectors) and device-mapper targets. When flushing dirty pages (governed by VFS writeback_chunk_size() and f2fs nr_pages_to_skip()), f2fs merges contiguous pages into bios up to 512KB (1024 sectors) or more without checking queue_max_sectors, which will be split if the device or DM target enforces a smaller limit. 2. queue_max_segments: Splits bios exceeding scatter-gather segment limits. f2fs allocates bios with up to 256 pages, exceeding the 128-segment limit of DM targets (dm-default-key/dm-crypt) if pages are discontiguous. 3. chunk_sectors: Splits bios crossing chunk/zone boundaries. In f2fs, section_size strictly matches zone_size, and block allocation never spans across section boundaries, so bios never cross chunk_sectors.

Crucially, when bio_split_to_limits() splits a bio, bio_submit_split() submits the tail half via submit_bio_noacct() before returning the head half to the caller. On a sequential zoned device, this causes the tail bio to arrive at the zone write plug before the head:

dm-3: zone 7: prepare_bio wp mismatch: bio sector 30720 offset 2048 != wp_offset 248, len 248

The write plug rejects the out-of-order tail with BLK_STS_IOERR, causing f2fs_stop_checkpoint() and remounting the filesystem read-only:

2026-09-30T22:09:23.725678+08:00 localhost kernel: CPU: 9 UID: 0 PID: 243 Comm: kworker/9:1H Not tainted 6.12.81-gb3ef518fb26d #5 2026-09-30T22:09:23.725750+08:00 localhost kernel: Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.17.0-debian-1.17.0-1 04/01/2014 2026-09-30T22:09:23.725753+08:00 localhost kernel: Workqueue: dm-3_zwplugs blk_zone_wplug_bio_work 2026-09-30T22:09:23.725756+08:00 localhost kernel: Call Trace: 2026-09-30T22:09:23.725758+08:00 localhost kernel: <TASK> 2026-09-30T22:09:23.725758+08:00 localhost kernel: dump_stack_lvl+0x4d/0x70 2026-09-30T22:09:23.725759+08:00 localhost kernel: f2fs_stop_checkpoint+0x1df/0x5d0 2026-09-30T22:09:23.725759+08:00 localhost kernel: ? blk_zone_wplug_bio_work+0x4eb/0x740 2026-09-30T22:09:23.725760+08:00 localhost kernel: f2fs_cache_write_end_io+0x545/0x6e0 2026-09-30T22:09:23.725761+08:00 localhost kernel: blk_zone_wplug_bio_work+0x4eb/0x740 2026-09-30T22:09:23.725762+08:00 localhost kernel: process_one_work+0x5c6/0xde0 2026-09-30T22:09:23.725764+08:00 localhost kernel: ? assign_work+0x124/0x4e0 2026-09-30T22:09:23.725765+08:00 localhost kernel: worker_thread+0x403/0xb70 2026-09-30T22:09:23.725765+08:00 localhost kernel: ? __kthread_parkme+0x82/0x140 2026-09-30T22:09:23.725766+08:00 localhost kernel: ? __pfx_worker_thread+0x10/0x10 2026-09-30T22:09:23.725766+08:00 localhost kernel: kthread+0x235/0x2e0 2026-09-30T22:09:23.725767+08:00 localhost kernel: ? recalc_sigpending+0x128/0x1d0 2026-09-30T22:09:23.725767+08:00 localhost kernel: ? __pfx_kthread+0x10/0x10 2026-09-30T22:09:23.725769+08:00 localhost kernel: ret_from_fork+0x2f/0x70 2026-09-30T22:09:23.725769+08:00 localhost kernel: ? __pfx_kthread+0x10/0x10 2026-09-30T22:09:23.725770+08:00 localhost kernel: ret_from_fork_asm+0x1a/0x30 2026-09-30T22:09:23.725771+08:00 localhost kernel: </TASK> 2026-09-30T22:09:23.725771+08:00 localhost kernel: F2FS-fs (dm-0): Stopped filesystem due to reason: 3

To prevent write bios destined for sequential zones from being split: 1. In __bio_alloc(), bound npages to bdev_max_segments(bdev) for writes to sequential zone areas. 2. In page_is_mergeable(), check queue_max_segments() and queue_max_sectors() for sequential zone areas, so f2fs will not merge beyond the queue limits.

Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.

Analysis

by VulDB Data Team • 11/21/2026

The vulnerability identified in the Linux kernel's F2FS filesystem driver involves a critical misalignment between how bios are allocated and merged by the file system layer versus the constraints enforced by the underlying block device layer on sequential zone devices. This issue specifically impacts systems utilizing zoned namespace storage or virtualized environments where device-mapper targets such as dm-default-key or dm-crypt enforce strict segment and sector limits that differ from F2FS's default allocation behavior. The core technical flaw lies in the bio submission process during dirty page flushing, governed by VFS writeback mechanisms. When f2fs merges contiguous pages into bios for writing to disk, it does not adequately check queue_max_sectors or queue_max_segments before finalizing the bio structure if the target is a sequential zone area. Consequently, bios can be constructed that exceed the hardware or device-mapper limits for maximum transfer size and scatter-gather segments. Specifically, f2fs may allocate bios with up to 1024 sectors or more than 128 segments, which triggers the block layer function bio_split_to_limits() to split these oversized bios into smaller chunks to comply with queue constraints.

The operational impact of this vulnerability stems from the asynchronous nature of how the kernel handles split bios on sequential zone devices. When bio_split_to_limits() divides a large bio, it submits the tail portion immediately via submit_bio_noacct() while returning the head portion to the caller for further processing or submission. On a sequential zoned device, writes must occur in strict order within specific zones because the write pointer advances monotonically and cannot be moved backward by the host without explicit commands. Because the split bio's tail is submitted before its head, it arrives at the zone write plug out of sequence relative to the expected write position. The block layer detects this discrepancy through a mismatch between the bio sector offset and the current zone write pointer, resulting in an I/O error status code BLK_STS_IOERR. This low-level storage failure propagates up through the stack, triggering f2fs_stop_checkpoint() as part of its error recovery mechanism to prevent data corruption or inconsistent state. The immediate consequence is that the filesystem stops functioning normally and remounts itself read-only, effectively causing a denial of service for any write operations until the system administrator manually intervenes to reset the checkpoint or reboot the affected volume.

From a classification perspective, this vulnerability aligns with CWE-20 Improper Input Validation as it involves failing to validate input parameters against device-specific constraints before processing them into block layer structures. It also relates to CWE-367 Time-of-check Time-of-use issues in the broader context of state management within the kernel's I/O scheduler, although more accurately it represents a logic error in resource allocation limits (CWE-400). In terms of MITRE ATT&CK mapping, this does not represent an exploitable attack vector for privilege escalation or remote code execution but rather falls under Impact categories related to Denial of Service due to system instability. The root cause is strictly internal to the kernel's interaction with specific storage topologies and device-mapper configurations, making it a reliability issue rather than a security breach in the traditional sense, though its effect on availability is significant for production environments relying on zoned block devices or encrypted volumes using dm-crypt.

Mitigation strategies primarily involve applying the upstream kernel patches that address this logic error by enforcing stricter limits during bio allocation and merging phases within f2fs. Developers must ensure that __bio_alloc() bounds the number of pages allocated based on bdev_max_segments specifically for writes targeting sequential zone areas to prevent exceeding scatter-gather segment limits. Additionally, page_is_mergeable needs to be updated to check queue_max_sectors and queue_max_segments when dealing with sequential zones, ensuring that f2fs does not merge contiguous pages beyond what the underlying device or dm target can handle in a single bio submission. For administrators unable to immediately patch their kernels, workarounds include avoiding heavy write-back loads on zoned devices or configuring device-mapper targets to allow larger segment and sector limits if hardware compatibility permits, though this may reduce performance efficiency. Regularly updating the Linux kernel to versions containing these f2fs zone handling fixes is the most effective remediation path to restore full read-write functionality and prevent unexpected remounts to read-only states on affected systems.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Want to know what is going to be exploited?

We predict KEV entries!