btrfs: rename err to ret in btrfs_cleanup_fs_roots()

Since err represents the function return value, rename it as ret,
and rename the original ret, which serves as a helper return value,
to found. Also, optimize the code to continue call btrfs_put_root()
for the rest of the root if even after btrfs_orphan_cleanup() returns
error.

Signed-off-by: Anand Jain <anand.jain@oracle.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 6b19c2de2c0faf54e281f0529f18ea970e4d27c0..b1daaaec06144aca54761b2c8ba7e6a0cdf02415 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -2914,22 +2914,22 @@ static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
 {
        u64 root_objectid = 0;
        struct btrfs_root *gang[8];
-       int i = 0;
-       int err = 0;
-       unsigned int ret = 0;
+       int ret = 0;
 
        while (1) {
+               unsigned int found;
+
                spin_lock(&fs_info->fs_roots_radix_lock);
-               ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
+               found = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
                                             (void **)gang, root_objectid,
                                             ARRAY_SIZE(gang));
-               if (!ret) {
+               if (!found) {
                        spin_unlock(&fs_info->fs_roots_radix_lock);
                        break;
                }
-               root_objectid = btrfs_root_id(gang[ret - 1]) + 1;
+               root_objectid = btrfs_root_id(gang[found - 1]) + 1;
 
-               for (i = 0; i < ret; i++) {
+               for (int i = 0; i < found; i++) {
                        /* Avoid to grab roots in dead_roots. */
                        if (btrfs_root_refs(&gang[i]->root_item) == 0) {
                                gang[i] = NULL;
@@ -2940,24 +2940,25 @@ static int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
                }
                spin_unlock(&fs_info->fs_roots_radix_lock);
 
-               for (i = 0; i < ret; i++) {
+               for (int i = 0; i < found; i++) {
                        if (!gang[i])
                                continue;
                        root_objectid = btrfs_root_id(gang[i]);
-                       err = btrfs_orphan_cleanup(gang[i]);
-                       if (err)
-                               goto out;
+                       /*
+                        * Continue to release the remaining roots after the first
+                        * error without cleanup and preserve the first error
+                        * for the return.
+                        */
+                       if (!ret)
+                               ret = btrfs_orphan_cleanup(gang[i]);
                        btrfs_put_root(gang[i]);
                }
+               if (ret)
+                       break;
+
                root_objectid++;
        }
-out:
-       /* Release the uncleaned roots due to error. */
-       for (; i < ret; i++) {
-               if (gang[i])
-                       btrfs_put_root(gang[i]);
-       }
-       return err;
+       return ret;
 }
 
 /*