mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [PATCH v5] btrfs: tree-checker: add more checks for file extent items
@ 2026-11-21 13:25 Cheng Yongkang
  0 siblings, 0 replies; only message in thread
From: Cheng Yongkang @ 2026-11-21 13:25 UTC (permalink / raw)
  To: David Sterba; +Cc: Chris Mason, Qu Wenruo, linux-btrfs, linux-kernel

check_extent_data_item() only checks the alignment of most members of a
regular or preallocated file extent. Add the following checks, based on
what btrfs writes:

- An explicit hole (disk_bytenr == 0) must be an uncompressed regular
  extent with zero disk_num_bytes. Its offset is not checked, as
  btrfs_drop_extents() can trim the front of a hole extent.

- A preallocated extent must not be compressed.

- An extent with data on disk must have a non-zero disk_num_bytes. If it
  is compressed, disk_num_bytes must not exceed BTRFS_MAX_COMPRESSED and
  ram_bytes must not exceed BTRFS_MAX_UNCOMPRESSED, as compression and
  encoded writes never create larger ones. Otherwise both must not
  exceed U32_MAX. Uncompressed extents can be larger than 256MiB, for
  example preallocated extents from kernels before v3.9, but they should
  never get close to U32_MAX.

- offset + num_bytes of an extent with data on disk must not exceed its
  ram_bytes.

Suggested-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Cheng Yongkang <teel4res@gmail.com>
---
Note that before v3.9, __btrfs_prealloc_file_range() reserved the whole
fallocate range at once, so on a RAID0 or RAID10 filesystem with five or
more data stripes a preallocated extent can be up to the 10G data chunk
limit, above U32_MAX. Such a filesystem would fail the new check. If it
should still be accepted, BTRFS_MAX_DATA_CHUNK_SIZE could be used as the
uncompressed limit instead, as a data extent never crosses a chunk.

Changes in v5:
- Drop the crash reports from the commit message, the patch is a
  tree-checker hardening.
- Add a dedicated check for explicit holes: they must be uncompressed
  regular extents with zero disk_num_bytes, as Sashiko pointed out on
  v4 that a hole bypassed all the new checks.
- Reject compressed preallocated extents, also pointed out by Sashiko.
- Check offset + num_bytes against ram_bytes for uncompressed extents
  too.
- Only use preallocated extents from kernels before v3.9 as the example
  of uncompressed extents larger than 256MiB. A direct I/O write
  reserves its whole range, but each bio gets its own ordered extent, so
  its file extents are only as large as its bios.
- Change the subject, as the patch no longer only checks disk_num_bytes.

Changes in v4:
- Also check ram_bytes of uncompressed extents against U32_MAX, with
  max_ram_bytes picked the same way as max_disk_num_bytes.
- Reject a zero disk_num_bytes for extents with data on disk, and an
  offset + num_bytes beyond ram_bytes for compressed extents, as
  Sashiko pointed out on v2 and v3.
- Skip holes for the new checks, as their ram_bytes is the hole size
  without NO_HOLES.
- Correct the commit message: direct I/O writes can also create
  uncompressed extents larger than 256MiB.
- Rebase onto misc-next.

Changes in v3:
- Relax the uncompressed disk_num_bytes limit from 256MiB to U32_MAX,
  as preallocated extents created before v3.9 can be larger.
- Also check ram_bytes of compressed extents against
  BTRFS_MAX_UNCOMPRESSED.

Changes in v2:
- Use SZ_256M directly instead of adding a new macro, and leave
  inode.c alone.
- Shorten the comment.

 fs/btrfs/tree-checker.c | 64 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/fs/btrfs/tree-checker.c b/fs/btrfs/tree-checker.c
index f021ac14babf..0a99e628d37c 100644
--- a/fs/btrfs/tree-checker.c
+++ b/fs/btrfs/tree-checker.c
@@ -244,7 +244,10 @@ static int check_extent_data_item(struct extent_buffer *leaf,
 	struct btrfs_file_extent_item *fi;
 	u32 sectorsize = fs_info->sectorsize;
 	u32 item_size = btrfs_item_size(leaf, slot);
+	u32 max_disk_num_bytes;
+	u32 max_ram_bytes;
 	u64 extent_end;
+	u64 ram_end;
 	u8 fi_type;
 
 	if (unlikely(!IS_ALIGNED(key->offset, sectorsize))) {
@@ -377,6 +380,67 @@ static int check_extent_data_item(struct extent_buffer *leaf,
 		     CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize)))
 		return -EUCLEAN;
 
+	if (!btrfs_file_extent_disk_bytenr(leaf, fi)) {
+		/* Explicit holes are uncompressed regular extents without disk space. */
+		if (unlikely(fi_type != BTRFS_FILE_EXTENT_REG ||
+			     btrfs_file_extent_compression(leaf, fi) != BTRFS_COMPRESS_NONE ||
+			     btrfs_file_extent_disk_num_bytes(leaf, fi))) {
+			file_extent_err(leaf, slot,
+"invalid hole file extent, have type %u compression %u disk_num_bytes %llu expect type %u compression 0 disk_num_bytes 0",
+					fi_type, btrfs_file_extent_compression(leaf, fi),
+					btrfs_file_extent_disk_num_bytes(leaf, fi),
+					BTRFS_FILE_EXTENT_REG);
+			return -EUCLEAN;
+		}
+	} else {
+		if (unlikely(fi_type == BTRFS_FILE_EXTENT_PREALLOC &&
+			     btrfs_file_extent_compression(leaf, fi) != BTRFS_COMPRESS_NONE)) {
+			file_extent_err(leaf, slot,
+		"invalid compression for preallocated file extent, have %u expect 0",
+					btrfs_file_extent_compression(leaf, fi));
+			return -EUCLEAN;
+		}
+
+		/*
+		 * Compressed extents are at most 128K both on disk and
+		 * uncompressed. Uncompressed extents should never get close to
+		 * U32_MAX.
+		 */
+		if (btrfs_file_extent_compression(leaf, fi) != BTRFS_COMPRESS_NONE) {
+			max_disk_num_bytes = BTRFS_MAX_COMPRESSED;
+			max_ram_bytes = BTRFS_MAX_UNCOMPRESSED;
+		} else {
+			max_disk_num_bytes = U32_MAX;
+			max_ram_bytes = U32_MAX;
+		}
+		if (unlikely(btrfs_file_extent_disk_num_bytes(leaf, fi) == 0 ||
+			     btrfs_file_extent_disk_num_bytes(leaf, fi) > max_disk_num_bytes)) {
+			file_extent_err(leaf, slot,
+		"invalid disk_num_bytes for file extent, have %llu expect (0, %u]",
+					btrfs_file_extent_disk_num_bytes(leaf, fi),
+					max_disk_num_bytes);
+			return -EUCLEAN;
+		}
+		if (unlikely(btrfs_file_extent_ram_bytes(leaf, fi) > max_ram_bytes)) {
+			file_extent_err(leaf, slot,
+		"invalid ram_bytes for file extent, have %llu expect <= %u",
+					btrfs_file_extent_ram_bytes(leaf, fi),
+					max_ram_bytes);
+			return -EUCLEAN;
+		}
+		if (unlikely(check_add_overflow(btrfs_file_extent_offset(leaf, fi),
+						btrfs_file_extent_num_bytes(leaf, fi),
+						&ram_end) ||
+			     ram_end > btrfs_file_extent_ram_bytes(leaf, fi))) {
+			file_extent_err(leaf, slot,
+	"invalid offset + num_bytes for file extent, have %llu + %llu expect <= ram_bytes %llu",
+					btrfs_file_extent_offset(leaf, fi),
+					btrfs_file_extent_num_bytes(leaf, fi),
+					btrfs_file_extent_ram_bytes(leaf, fi));
+			return -EUCLEAN;
+		}
+	}
+
 	/* Catch extent end overflow */
 	if (unlikely(check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi),
 					key->offset, &extent_end))) {

base-commit: 0e6c0a834a2329b3a2767a4485f9891348725c0b
-- 
2.34.1


^ permalink raw reply	[flat|nested] only message in thread

only message in thread, other threads:[~2026-11-21 13:25 UTC | newest]

Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-21 13:25 [PATCH v5] btrfs: tree-checker: add more checks for file extent items Cheng Yongkang

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®