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

Whenever we need to send a command for the current inode, like sending
writes, xattr updates, truncates, utimes, etc, we compute the inode's
path each time, which implies doing some memory allocations and traversing
the inode hierarchy to extract the name of the inode and each ancestor
directory, and that implies doing lookups in the subvolume tree amongst
other operations.

Most of the time, by far, the current inode's path doesn't change while
we are processing it (like if we need to issue 100 write commands, the
path remains the same and it's pointless to compute it 100 times).

To avoid this keep the current inode's path cached in the send context
and invalidate it or update it whenever it's needed (after unlinks or
renames).

A performance test, and its results, is mentioned in the next patch in
the series (subject: "btrfs: send: avoid path allocation for the current
inode when issuing commands").

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 0c496270e10f89790ca93bc5ae8154b76679af2a..e811c9237e9e166bd62007094649b08bfb32f191 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -177,6 +177,7 @@ struct send_ctx {
        u64 cur_inode_rdev;
        u64 cur_inode_last_extent;
        u64 cur_inode_next_write_offset;
+       struct fs_path cur_inode_path;
        bool cur_inode_new;
        bool cur_inode_new_gen;
        bool cur_inode_deleted;
@@ -433,6 +434,14 @@ static void fs_path_reset(struct fs_path *p)
        *p->start = 0;
 }
 
+static void init_path(struct fs_path *p)
+{
+       p->reversed = 0;
+       p->buf = p->inline_buf;
+       p->buf_len = FS_PATH_INLINE_SIZE;
+       fs_path_reset(p);
+}
+
 static struct fs_path *fs_path_alloc(void)
 {
        struct fs_path *p;
@@ -440,10 +449,7 @@ static struct fs_path *fs_path_alloc(void)
        p = kmalloc(sizeof(*p), GFP_KERNEL);
        if (!p)
                return NULL;
-       p->reversed = 0;
-       p->buf = p->inline_buf;
-       p->buf_len = FS_PATH_INLINE_SIZE;
-       fs_path_reset(p);
+       init_path(p);
        return p;
 }
 
@@ -609,6 +615,14 @@ static void fs_path_unreverse(struct fs_path *p)
        p->reversed = 0;
 }
 
+static inline bool is_current_inode_path(const struct send_ctx *sctx,
+                                        const struct fs_path *path)
+{
+       const struct fs_path *cur = &sctx->cur_inode_path;
+
+       return (strncmp(path->start, cur->start, fs_path_len(cur)) == 0);
+}
+
 static struct btrfs_path *alloc_path_for_send(void)
 {
        struct btrfs_path *path;
@@ -2415,6 +2429,14 @@ static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen,
        u64 parent_inode = 0;
        u64 parent_gen = 0;
        int stop = 0;
+       const bool is_cur_inode = (ino == sctx->cur_ino && gen == sctx->cur_inode_gen);
+
+       if (is_cur_inode && fs_path_len(&sctx->cur_inode_path) > 0) {
+               if (dest != &sctx->cur_inode_path)
+                       return fs_path_copy(dest, &sctx->cur_inode_path);
+
+               return 0;
+       }
 
        name = fs_path_alloc();
        if (!name) {
@@ -2466,8 +2488,12 @@ static int get_cur_path(struct send_ctx *sctx, u64 ino, u64 gen,
 
 out:
        fs_path_free(name);
-       if (!ret)
+       if (!ret) {
                fs_path_unreverse(dest);
+               if (is_cur_inode && dest != &sctx->cur_inode_path)
+                       ret = fs_path_copy(&sctx->cur_inode_path, dest);
+       }
+
        return ret;
 }
 
@@ -3077,6 +3103,11 @@ static int orphanize_inode(struct send_ctx *sctx, u64 ino, u64 gen,
                goto out;
 
        ret = send_rename(sctx, path, orphan);
+       if (ret < 0)
+               goto out;
+
+       if (ino == sctx->cur_ino && gen == sctx->cur_inode_gen)
+               ret = fs_path_copy(&sctx->cur_inode_path, orphan);
 
 out:
        fs_path_free(orphan);
@@ -4139,6 +4170,10 @@ static int rename_current_inode(struct send_ctx *sctx,
        if (ret < 0)
                return ret;
 
+       ret = fs_path_copy(&sctx->cur_inode_path, new_path);
+       if (ret < 0)
+               return ret;
+
        return fs_path_copy(current_path, new_path);
 }
 
@@ -4332,6 +4367,7 @@ static int process_recorded_refs(struct send_ctx *sctx, int *pending_move)
                                if (ret > 0) {
                                        orphanized_ancestor = true;
                                        fs_path_reset(valid_path);
+                                       fs_path_reset(&sctx->cur_inode_path);
                                        ret = get_cur_path(sctx, sctx->cur_ino,
                                                           sctx->cur_inode_gen,
                                                           valid_path);
@@ -4531,6 +4567,8 @@ static int process_recorded_refs(struct send_ctx *sctx, int *pending_move)
                                ret = send_unlink(sctx, cur->full_path);
                                if (ret < 0)
                                        goto out;
+                               if (is_current_inode_path(sctx, cur->full_path))
+                                       fs_path_reset(&sctx->cur_inode_path);
                        }
                        ret = dup_ref(cur, &check_dirs);
                        if (ret < 0)
@@ -6851,6 +6889,7 @@ static int changed_inode(struct send_ctx *sctx,
        sctx->cur_inode_last_extent = (u64)-1;
        sctx->cur_inode_next_write_offset = 0;
        sctx->ignore_cur_inode = false;
+       fs_path_reset(&sctx->cur_inode_path);
 
        /*
         * Set send_progress to current inode. This will tell all get_cur_xxx
@@ -8126,6 +8165,7 @@ long btrfs_ioctl_send(struct btrfs_inode *inode, const struct btrfs_ioctl_send_a
                goto out;
        }
 
+       init_path(&sctx->cur_inode_path);
        INIT_LIST_HEAD(&sctx->new_refs);
        INIT_LIST_HEAD(&sctx->deleted_refs);
 
@@ -8402,6 +8442,9 @@ out:
                btrfs_lru_cache_clear(&sctx->dir_created_cache);
                btrfs_lru_cache_clear(&sctx->dir_utimes_cache);
 
+               if (sctx->cur_inode_path.buf != sctx->cur_inode_path.inline_buf)
+                       kfree(sctx->cur_inode_path.buf);
+
                kfree(sctx);
        }