]> git.hungrycats.org Git - linux/commitdiff
btrfs: send: fix missing hole punching during incremental send
authorFilipe Manana <fdmanana@suse.com>
Wed, 21 Oct 2026 19:34:59 +0000 (20:34 +0100)
committerDavid Sterba <dsterba@suse.com>
Fri, 30 Oct 2026 20:36:18 +0000 (21:36 +0100)
When using the no-holes feature (enabled by default since btrfs-progs
v5.15) and doing an incremental send, we can miss issuing a hole punching
command when the following conditions happen:

1) A hole is punched in a tail section of a file extent item that happens
   to be the last item in a leaf (for example the extent covers the file
   range [1M, 3M) and a hole is punched in the range [2M, 3M)). Between
   the end of this file extent item's range and the i_size, there are
   other file extent items;

2) The next leaf was not modified in the send snapshot, remaining shared
   with the parent snapshot.

In this scenario we are unable to detect a hole was punched and never
issue a hole punch command because with no-holes there we don't have an
explicit file extent item to mark a hole.

Fix this by teaching maybe_send_hole() to detect such case.
A test case for fstests will follow soon.

Reported-by: Tristan Elvers <tristanelvers@gmail.com>
Link: https://lore.kernel.org/linux-btrfs/CAFoLKK+aErV4p6ZJPnVeH5SHQ5++0f=8ZgxPWe-E-CkeKBs8PA@mail.gmail.com/
Fixes: 16e7549f045d ("Btrfs: incompatible format change to remove hole extents")
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
fs/btrfs/send.c

index c523bf950c898f63b177130f3dabc43fb0c4dc6a..1b903e75cec0ab0261a0bc46f8afeeaf7947f303 100644 (file)
@@ -6371,6 +6371,9 @@ next:
 static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
                           struct btrfs_key *key)
 {
+       BTRFS_PATH_AUTO_FREE(next_path);
+       const u64 cur_extent_end = btrfs_file_extent_end(path);
+       u64 next_offset;
        int ret = 0;
 
        if (sctx->cur_ino != key->objectid || !need_send_hole(sctx))
@@ -6397,14 +6400,72 @@ static int maybe_send_hole(struct send_ctx *sctx, struct btrfs_path *path,
                ret = range_is_hole_in_parent(sctx,
                                              sctx->cur_inode_last_extent,
                                              key->offset);
+               if (ret == 0)
+                       ret = send_hole(sctx, key->offset);
+               else if (ret == 1)
+                       ret = 0;
+
                if (ret < 0)
                        return ret;
-               else if (ret == 0)
-                       ret = send_hole(sctx, key->offset);
+       }
+       sctx->cur_inode_last_extent = cur_extent_end;
+
+       /*
+        * If we are the last file extent item in a leaf, we may have had a tail
+        * section that got a hole punched or the extent replaced with a smaller
+        * one, and if there is no change in the next leaf, we must find out if
+        * we have such a hole and punch it.
+        */
+       if (!btrfs_fs_incompat(sctx->send_root->fs_info, NO_HOLES) ||
+           (sctx->cur_inode_size <= cur_extent_end) ||
+           (path->slots[0] != btrfs_header_nritems(path->nodes[0]) - 1))
+               return 0;
+
+       next_path = alloc_path_for_send();
+       if (!next_path)
+               return -ENOMEM;
+
+       ret = btrfs_search_slot(NULL, sctx->send_root, key, next_path, 0, 0);
+       if (ret < 0)
+               return ret;
+       if (WARN_ON(ret != 0))
+               return -EUCLEAN;
+
+       ret = btrfs_next_leaf(sctx->send_root, next_path);
+       if (ret < 0) {
+               return ret;
+       } else if (ret > 0) {
+               /*
+                * No next leaf, must punch hole to i_size and set the path back
+                * to where it was before.
+                */
+               next_offset = sctx->cur_inode_size;
+       } else {
+               struct btrfs_key next_key;
+
+               btrfs_item_key_to_cpu(next_path->nodes[0], &next_key,
+                                     next_path->slots[0]);
+               if (next_key.objectid != key->objectid ||
+                   next_key.type != BTRFS_EXTENT_DATA_KEY)
+                       next_offset = sctx->cur_inode_size;
                else
-                       ret = 0;
+                       next_offset = next_key.offset;
        }
-       sctx->cur_inode_last_extent = btrfs_file_extent_end(path);
+
+       if (next_offset == cur_extent_end)
+               return 0;
+
+       btrfs_free_path(next_path);
+       next_path = NULL;
+
+       ret = range_is_hole_in_parent(sctx, sctx->cur_inode_last_extent, next_offset);
+       if (ret == 0)
+               ret = send_hole(sctx, next_offset);
+       else if (ret == 1)
+               ret = 0;
+
+       sctx->cur_inode_last_extent = next_offset;
+
        return ret;
 }