btrfs: send: avoid path allocation for the current inode when issuing commands

Whenever we issue a command we allocate a path and then compute it. For
the current inode this is not necessary since we have one preallocated
and computed in the send context structure, so we can use it instead
and avoid allocating and freeing a path.

For example if we have 100 extents to send (100 write commands) for a
file, we are allocating and freeing paths 100 times.

So improve on this by avoiding path allocation and freeing whenever a
command is for the current inode by using the current inode's path
stored in the send context structure.

A test was run before applying this patch and the previous one in the
series:

  "btrfs: send: keep the current inode's path cached"

The test script is the following:

  $ cat test.sh
  #!/bin/bash

  DEV=/dev/nullb0
  MNT=/mnt/nullb0

  mkfs.btrfs -f $DEV > /dev/null
  mount $DEV $MNT

  DIR="$MNT/one/two/three/four"
  FILE="$DIR/foobar"

  mkdir -p $DIR

  # Create some empty files to get a deeper btree and therefore make
  # path computations slower.
  for ((i = 1; i <= 30000; i++)); do
      echo -n > "$DIR/filler_$i"
  done

  for ((i = 0; i < 10000; i += 2)); do
     offset=$(( i * 4096 ))
     xfs_io -f -c "pwrite -S 0xab $offset 4K" $FILE > /dev/null
  done

  btrfs subvolume snapshot -r $MNT $MNT/snap

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

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

  umount $MNT

Result before applying the 2 patches:  1121 milliseconds
Result after applying the 2 patches:    815 milliseconds  (-31.6%)

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

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index e811c9237e9e166bd62007094649b08bfb32f191..2c1259068b761b8a339356200e61a97ea3cba16f 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -2588,6 +2588,47 @@ out:
        return ret;
 }
 
+static struct fs_path *get_cur_inode_path(struct send_ctx *sctx)
+{
+       if (fs_path_len(&sctx->cur_inode_path) == 0) {
+               int ret;
+
+               ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen,
+                                  &sctx->cur_inode_path);
+               if (ret < 0)
+                       return ERR_PTR(ret);
+       }
+
+       return &sctx->cur_inode_path;
+}
+
+static struct fs_path *get_path_for_command(struct send_ctx *sctx, u64 ino, u64 gen)
+{
+       struct fs_path *path;
+       int ret;
+
+       if (ino == sctx->cur_ino && gen == sctx->cur_inode_gen)
+               return get_cur_inode_path(sctx);
+
+       path = fs_path_alloc();
+       if (!path)
+               return ERR_PTR(-ENOMEM);
+
+       ret = get_cur_path(sctx, ino, gen, path);
+       if (ret < 0) {
+               fs_path_free(path);
+               return ERR_PTR(ret);
+       }
+
+       return path;
+}
+
+static void free_path_for_command(const struct send_ctx *sctx, struct fs_path *path)
+{
+       if (path != &sctx->cur_inode_path)
+               fs_path_free(path);
+}
+
 static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
 {
        struct btrfs_fs_info *fs_info = sctx->send_root->fs_info;
@@ -2596,17 +2637,14 @@ static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
 
        btrfs_debug(fs_info, "send_truncate %llu size=%llu", ino, size);
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
+       p = get_path_for_command(sctx, ino, gen);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
        ret = begin_cmd(sctx, BTRFS_SEND_C_TRUNCATE);
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, ino, gen, p);
-       if (ret < 0)
-               goto out;
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_SIZE, size);
 
@@ -2614,7 +2652,7 @@ static int send_truncate(struct send_ctx *sctx, u64 ino, u64 gen, u64 size)
 
 tlv_put_failure:
 out:
-       fs_path_free(p);
+       free_path_for_command(sctx, p);
        return ret;
 }
 
@@ -2626,17 +2664,14 @@ static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode)
 
        btrfs_debug(fs_info, "send_chmod %llu mode=%llu", ino, mode);
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
+       p = get_path_for_command(sctx, ino, gen);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
        ret = begin_cmd(sctx, BTRFS_SEND_C_CHMOD);
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, ino, gen, p);
-       if (ret < 0)
-               goto out;
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode & 07777);
 
@@ -2644,7 +2679,7 @@ static int send_chmod(struct send_ctx *sctx, u64 ino, u64 gen, u64 mode)
 
 tlv_put_failure:
 out:
-       fs_path_free(p);
+       free_path_for_command(sctx, p);
        return ret;
 }
 
@@ -2659,17 +2694,14 @@ static int send_fileattr(struct send_ctx *sctx, u64 ino, u64 gen, u64 fileattr)
 
        btrfs_debug(fs_info, "send_fileattr %llu fileattr=%llu", ino, fileattr);
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
+       p = get_path_for_command(sctx, ino, gen);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
        ret = begin_cmd(sctx, BTRFS_SEND_C_FILEATTR);
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, ino, gen, p);
-       if (ret < 0)
-               goto out;
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_FILEATTR, fileattr);
 
@@ -2677,7 +2709,7 @@ static int send_fileattr(struct send_ctx *sctx, u64 ino, u64 gen, u64 fileattr)
 
 tlv_put_failure:
 out:
-       fs_path_free(p);
+       free_path_for_command(sctx, p);
        return ret;
 }
 
@@ -2690,17 +2722,14 @@ static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid)
        btrfs_debug(fs_info, "send_chown %llu uid=%llu, gid=%llu",
                    ino, uid, gid);
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
+       p = get_path_for_command(sctx, ino, gen);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
        ret = begin_cmd(sctx, BTRFS_SEND_C_CHOWN);
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, ino, gen, p);
-       if (ret < 0)
-               goto out;
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_UID, uid);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_GID, gid);
@@ -2709,7 +2738,7 @@ static int send_chown(struct send_ctx *sctx, u64 ino, u64 gen, u64 uid, u64 gid)
 
 tlv_put_failure:
 out:
-       fs_path_free(p);
+       free_path_for_command(sctx, p);
        return ret;
 }
 
@@ -2726,9 +2755,9 @@ static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
 
        btrfs_debug(fs_info, "send_utimes %llu", ino);
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
+       p = get_path_for_command(sctx, ino, gen);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
        path = alloc_path_for_send();
        if (!path) {
@@ -2753,9 +2782,6 @@ static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, ino, gen, p);
-       if (ret < 0)
-               goto out;
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_ATIME, eb, &ii->atime);
        TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_MTIME, eb, &ii->mtime);
@@ -2767,7 +2793,7 @@ static int send_utimes(struct send_ctx *sctx, u64 ino, u64 gen)
 
 tlv_put_failure:
 out:
-       fs_path_free(p);
+       free_path_for_command(sctx, p);
        btrfs_free_path(path);
        return ret;
 }
@@ -4885,13 +4911,9 @@ static int send_set_xattr(struct send_ctx *sctx,
        struct fs_path *path;
        int ret;
 
-       path = fs_path_alloc();
-       if (!path)
-               return -ENOMEM;
-
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, path);
-       if (ret < 0)
-               goto out;
+       path = get_cur_inode_path(sctx);
+       if (IS_ERR(path))
+               return PTR_ERR(path);
 
        ret = begin_cmd(sctx, BTRFS_SEND_C_SET_XATTR);
        if (ret < 0)
@@ -4905,8 +4927,6 @@ static int send_set_xattr(struct send_ctx *sctx,
 
 tlv_put_failure:
 out:
-       fs_path_free(path);
-
        return ret;
 }
 
@@ -4963,23 +4983,14 @@ static int __process_deleted_xattr(int num, struct btrfs_key *di_key,
                                   const char *name, int name_len,
                                   const char *data, int data_len, void *ctx)
 {
-       int ret;
        struct send_ctx *sctx = ctx;
        struct fs_path *p;
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
-
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
-       if (ret < 0)
-               goto out;
-
-       ret = send_remove_xattr(sctx, p, name, name_len);
+       p = get_cur_inode_path(sctx);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
-out:
-       fs_path_free(p);
-       return ret;
+       return send_remove_xattr(sctx, p, name, name_len);
 }
 
 static int process_new_xattr(struct send_ctx *sctx)
@@ -5205,21 +5216,13 @@ static int process_verity(struct send_ctx *sctx)
        if (ret < 0)
                goto iput;
 
-       p = fs_path_alloc();
-       if (!p) {
-               ret = -ENOMEM;
+       p = get_cur_inode_path(sctx);
+       if (IS_ERR(p)) {
+               ret = PTR_ERR(p);
                goto iput;
        }
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
-       if (ret < 0)
-               goto free_path;
 
        ret = send_verity(sctx, p, sctx->verity_descriptor);
-       if (ret < 0)
-               goto free_path;
-
-free_path:
-       fs_path_free(p);
 iput:
        iput(inode);
        return ret;
@@ -5341,31 +5344,25 @@ static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
        int ret = 0;
        struct fs_path *p;
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
-
        btrfs_debug(fs_info, "send_write offset=%llu, len=%d", offset, len);
 
-       ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
-       if (ret < 0)
-               goto out;
+       p = get_cur_inode_path(sctx);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
+       ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
        if (ret < 0)
-               goto out;
+               return ret;
 
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
        ret = put_file_data(sctx, offset, len);
        if (ret < 0)
-               goto out;
+               return ret;
 
        ret = send_cmd(sctx);
 
 tlv_put_failure:
-out:
-       fs_path_free(p);
        return ret;
 }
 
@@ -5378,6 +5375,7 @@ static int send_clone(struct send_ctx *sctx,
 {
        int ret = 0;
        struct fs_path *p;
+       struct fs_path *cur_inode_path;
        u64 gen;
 
        btrfs_debug(sctx->send_root->fs_info,
@@ -5385,6 +5383,10 @@ static int send_clone(struct send_ctx *sctx,
                    offset, len, btrfs_root_id(clone_root->root),
                    clone_root->ino, clone_root->offset);
 
+       cur_inode_path = get_cur_inode_path(sctx);
+       if (IS_ERR(cur_inode_path))
+               return PTR_ERR(cur_inode_path);
+
        p = fs_path_alloc();
        if (!p)
                return -ENOMEM;
@@ -5393,13 +5395,9 @@ static int send_clone(struct send_ctx *sctx,
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
-       if (ret < 0)
-               goto out;
-
        TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
-       TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
+       TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, cur_inode_path);
 
        if (clone_root->root == sctx->send_root) {
                ret = get_inode_gen(sctx->send_root, clone_root->ino, &gen);
@@ -5450,17 +5448,13 @@ static int send_update_extent(struct send_ctx *sctx,
        int ret = 0;
        struct fs_path *p;
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
+       p = get_cur_inode_path(sctx);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
 
        ret = begin_cmd(sctx, BTRFS_SEND_C_UPDATE_EXTENT);
        if (ret < 0)
-               goto out;
-
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
-       if (ret < 0)
-               goto out;
+               return ret;
 
        TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
        TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
@@ -5469,8 +5463,6 @@ static int send_update_extent(struct send_ctx *sctx,
        ret = send_cmd(sctx);
 
 tlv_put_failure:
-out:
-       fs_path_free(p);
        return ret;
 }
 
@@ -5499,12 +5491,10 @@ static int send_hole(struct send_ctx *sctx, u64 end)
        if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
                return send_update_extent(sctx, offset, end - offset);
 
-       p = fs_path_alloc();
-       if (!p)
-               return -ENOMEM;
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
-       if (ret < 0)
-               goto tlv_put_failure;
+       p = get_cur_inode_path(sctx);
+       if (IS_ERR(p))
+               return PTR_ERR(p);
+
        while (offset < end) {
                u64 len = min(end - offset, read_size);
 
@@ -5525,7 +5515,6 @@ static int send_hole(struct send_ctx *sctx, u64 end)
        }
        sctx->cur_inode_next_write_offset = offset;
 tlv_put_failure:
-       fs_path_free(p);
        return ret;
 }
 
@@ -5548,9 +5537,9 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
        if (IS_ERR(inode))
                return PTR_ERR(inode);
 
-       fspath = fs_path_alloc();
-       if (!fspath) {
-               ret = -ENOMEM;
+       fspath = get_cur_inode_path(sctx);
+       if (IS_ERR(fspath)) {
+               ret = PTR_ERR(fspath);
                goto out;
        }
 
@@ -5558,10 +5547,6 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
-       if (ret < 0)
-               goto out;
-
        btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
        ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);
        ram_bytes = btrfs_file_extent_ram_bytes(leaf, ei);
@@ -5590,7 +5575,6 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
 
 tlv_put_failure:
 out:
-       fs_path_free(fspath);
        iput(inode);
        return ret;
 }
@@ -5615,9 +5599,9 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path,
        if (IS_ERR(inode))
                return PTR_ERR(inode);
 
-       fspath = fs_path_alloc();
-       if (!fspath) {
-               ret = -ENOMEM;
+       fspath = get_cur_inode_path(sctx);
+       if (IS_ERR(fspath)) {
+               ret = PTR_ERR(fspath);
                goto out;
        }
 
@@ -5625,10 +5609,6 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path,
        if (ret < 0)
                goto out;
 
-       ret = get_cur_path(sctx, sctx->cur_ino, sctx->cur_inode_gen, fspath);
-       if (ret < 0)
-               goto out;
-
        btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
        ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);
        disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
@@ -5696,7 +5676,6 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path,
 
 tlv_put_failure:
 out:
-       fs_path_free(fspath);
        iput(inode);
        return ret;
 }