btrfs: send: avoid unnecessary backref lookups when finding clone source

At find_extent_clone(), unless we are given an inline extent, a file
extent item that represents hole or an extent that starts beyond the
i_size, we always do backref walking to look for clone sources, unless
if we have more than SEND_MAX_EXTENT_REFS (64) known references on the
extent.

However if we know we only have one reference in the extent item and only
one clone source (the send root), then it's pointless to do the backref
walking to search for clone sources, as we can't clone from any other
root. So skip the backref walking in that case.

The following test was run on a non-debug kernel (Debian's default kernel
config):

   $ cat test.sh
   #!/bin/bash

   DEV=/dev/sdi
   MNT=/mnt/sdi

   mkfs.btrfs -f $DEV
   mount $DEV $MNT

   # Create an extent tree that's not too small and none of the
   # extents is shared.
   for ((i = 1; i <= 50000; i++)); do
      xfs_io -f -c "pwrite 0 4K" $MNT/file_$i > /dev/null
      echo -ne "\r$i files created..."
   done
   echo

   btrfs subvolume snapshot -r $MNT $MNT/snap

   start=$(date +%s%N)
   btrfs send $MNT/snap > /dev/null
   end=$(date +%s%N)

   dur=$(( (end - start) / 1000000 ))
   echo -e "\nsend took $dur milliseconds"

   umount $MNT

Before this change:

   send took 5389 milliseconds

After this change:

   send took 4519 milliseconds  (-16.1%)

Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 7d289bd..d9e01b6 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -1354,6 +1354,7 @@ static int find_extent_clone(struct send_ctx *sctx,
        u64 disk_byte;
        u64 num_bytes;
        u64 extent_item_pos;
+       u64 extent_refs;
        u64 flags = 0;
        struct btrfs_file_extent_item *fi;
        struct extent_buffer *eb = path->nodes[0];
@@ -1408,14 +1409,22 @@ static int find_extent_clone(struct send_ctx *sctx,
 
        ei = btrfs_item_ptr(tmp_path->nodes[0], tmp_path->slots[0],
                            struct btrfs_extent_item);
+       extent_refs = btrfs_extent_refs(tmp_path->nodes[0], ei);
        /*
         * Backreference walking (iterate_extent_inodes() below) is currently
         * too expensive when an extent has a large number of references, both
         * in time spent and used memory. So for now just fallback to write
         * operations instead of clone operations when an extent has more than
         * a certain amount of references.
+        *
+        * Also, if we have only one reference and only the send root as a clone
+        * source - meaning no clone roots were given in the struct
+        * btrfs_ioctl_send_args passed to the send ioctl - then it's our
+        * reference and there's no point in doing backref walking which is
+        * expensive, so exit early.
         */
-       if (btrfs_extent_refs(tmp_path->nodes[0], ei) > SEND_MAX_EXTENT_REFS) {
+       if ((extent_refs == 1 && sctx->clone_roots_cnt == 1) ||
+           extent_refs > SEND_MAX_EXTENT_REFS) {
                ret = -ENOENT;
                goto out;
        }