btrfs: send: directly return from will_overwrite_ref() and simplify it

There are no resources to release before will_overwrite_ref() returns, so
we don't really need the 'out' label and jumping to it when conditions are
met - we can directly return and get rid of the label and jumps. Also we
can deal with -ENOENT and other errors in a single if-else logic, as it's
more straightforward.

This helps the next patch in the series to be more simple as well.

This patch is part of a larger patchset and the changelog of the last
patch in the series contains a sample performance test and results.
The patches that comprise the patchset are the following:

  btrfs: send: directly return from did_overwrite_ref() and simplify it
  btrfs: send: avoid unnecessary generation search at did_overwrite_ref()
  btrfs: send: directly return from will_overwrite_ref() and simplify it
  btrfs: send: avoid extra b+tree searches when checking reference overrides
  btrfs: send: remove send_progress argument from can_rmdir()
  btrfs: send: avoid duplicated orphan dir allocation and initialization
  btrfs: send: avoid unnecessary orphan dir rbtree search at can_rmdir()
  btrfs: send: reduce searches on parent root when checking if dir can be removed
  btrfs: send: iterate waiting dir move rbtree only once when processing refs
  btrfs: send: initialize all the red black trees earlier
  btrfs: send: genericize the backref cache to allow it to be reused
  btrfs: adapt lru cache to allow for 64 bits keys on 32 bits systems
  btrfs: send: cache information about created directories
  btrfs: allow a generation number to be associated with lru cache entries
  btrfs: add an api to delete a specific entry from the lru cache
  btrfs: send: use the lru cache to implement the name cache
  btrfs: send: update size of roots array for backref cache entries
  btrfs: send: cache utimes operations for directories if possible

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 73017be632edf2169fb2ba3c3e39af52ed4be113..ec14c97ce2ee702c0b1ec142b15e0de2d3e36995 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -2119,17 +2119,17 @@ static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
                              const char *name, int name_len,
                              u64 *who_ino, u64 *who_gen, u64 *who_mode)
 {
-       int ret = 0;
+       int ret;
        u64 gen;
        u64 other_inode = 0;
        struct btrfs_inode_info info;
 
        if (!sctx->parent_root)
-               goto out;
+               return 0;
 
        ret = is_inode_existent(sctx, dir, dir_gen);
        if (ret <= 0)
-               goto out;
+               return 0;
 
        /*
         * If we have a parent root we need to verify that the parent dir was
@@ -2138,24 +2138,21 @@ static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
         */
        if (sctx->parent_root && dir != BTRFS_FIRST_FREE_OBJECTID) {
                ret = get_inode_gen(sctx->parent_root, dir, &gen);
-               if (ret < 0 && ret != -ENOENT)
-                       goto out;
-               if (ret) {
-                       ret = 0;
-                       goto out;
-               }
+               if (ret == -ENOENT)
+                       return 0;
+               else if (ret < 0)
+                       return ret;
+
                if (gen != dir_gen)
-                       goto out;
+                       return 0;
        }
 
        ret = lookup_dir_item_inode(sctx->parent_root, dir, name, name_len,
                                    &other_inode);
-       if (ret < 0 && ret != -ENOENT)
-               goto out;
-       if (ret) {
-               ret = 0;
-               goto out;
-       }
+       if (ret == -ENOENT)
+               return 0;
+       else if (ret < 0)
+               return ret;
 
        /*
         * Check if the overwritten ref was already processed. If yes, the ref
@@ -2166,18 +2163,15 @@ static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
            is_waiting_for_move(sctx, other_inode)) {
                ret = get_inode_info(sctx->parent_root, other_inode, &info);
                if (ret < 0)
-                       goto out;
+                       return ret;
 
-               ret = 1;
                *who_ino = other_inode;
                *who_gen = info.gen;
                *who_mode = info.mode;
-       } else {
-               ret = 0;
+               return 1;
        }
 
-out:
-       return ret;
+       return 0;
 }
 
 /*