btrfs: decrease indentation of find_free_extent_update_loop

Decrease the indentation of find_free_extent_update_loop(), by inverting
the check if the loop state is smaller than LOOP_NO_EMPTY_SIZE.

This also allows for an early return from find_free_extent_update_loop(),
in case LOOP_NO_EMPTY_SIZE is already set at this point.

While at it change a

    if () {
    }
    else if
    else

pattern to all using curly braces and be consistent with the rest of btrfs
code.

Also change 'int exists' to 'bool have_trans' giving it a more meaningful
name and type.

No functional changes intended.

Reviewed-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 92ba7867e74be33cd0367fc3b3fd966e4a1100f3..391fad41c3b6d98ab7468a5b7b0003f692871407 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -4349,71 +4349,72 @@ static int find_free_extent_update_loop(struct btrfs_fs_info *fs_info,
                return 1;
 
        /* See the comments for btrfs_loop_type for an explanation of the phases. */
-       if (ffe_ctl->loop < LOOP_NO_EMPTY_SIZE) {
-               ffe_ctl->index = 0;
-               /*
-                * We want to skip the LOOP_CACHING_WAIT step if we don't have
-                * any uncached bgs and we've already done a full search
-                * through.
-                */
-               if (ffe_ctl->loop == LOOP_CACHING_NOWAIT &&
-                   (!ffe_ctl->orig_have_caching_bg && full_search))
-                       ffe_ctl->loop++;
+       if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE)
+               return -ENOSPC;
+
+       ffe_ctl->index = 0;
+       /*
+        * We want to skip the LOOP_CACHING_WAIT step if we don't have any
+        * uncached bgs and we've already done a full search through.
+        */
+       if (ffe_ctl->loop == LOOP_CACHING_NOWAIT &&
+           (!ffe_ctl->orig_have_caching_bg && full_search))
                ffe_ctl->loop++;
+       ffe_ctl->loop++;
 
-               if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {
-                       struct btrfs_trans_handle *trans;
-                       int exist = 0;
+       if (ffe_ctl->loop == LOOP_ALLOC_CHUNK) {
+               struct btrfs_trans_handle *trans;
+               bool have_trans = false;
 
-                       /* Check if allocation policy allows to create a new chunk */
-                       ret = can_allocate_chunk(fs_info, ffe_ctl);
-                       if (ret)
-                               return ret;
+               /* Check if allocation policy allows to create a new chunk. */
+               ret = can_allocate_chunk(fs_info, ffe_ctl);
+               if (ret)
+                       return ret;
 
-                       trans = current->journal_info;
-                       if (trans)
-                               exist = 1;
-                       else
-                               trans = btrfs_join_transaction(root);
+               trans = current->journal_info;
+               if (trans)
+                       have_trans = true;
+               else
+                       trans = btrfs_join_transaction(root);
 
-                       if (IS_ERR(trans))
-                               return PTR_ERR(trans);
+               if (IS_ERR(trans))
+                       return PTR_ERR(trans);
 
-                       ret = btrfs_chunk_alloc(trans, space_info, ffe_ctl->flags,
-                                               CHUNK_ALLOC_FORCE_FOR_EXTENT);
+               ret = btrfs_chunk_alloc(trans, space_info, ffe_ctl->flags,
+                                       CHUNK_ALLOC_FORCE_FOR_EXTENT);
 
-                       /* Do not bail out on ENOSPC since we can do more. */
-                       if (ret == -ENOSPC) {
-                               ret = 0;
-                               ffe_ctl->loop++;
-                       }
-                       else if (ret < 0)
-                               btrfs_abort_transaction(trans, ret);
-                       else
-                               ret = 0;
-                       if (!exist)
-                               btrfs_end_transaction(trans);
-                       if (ret)
-                               return ret;
+               /* Do not bail out on ENOSPC since we can do more. */
+               if (ret == -ENOSPC) {
+                       ret = 0;
+                       ffe_ctl->loop++;
+               } else if (ret < 0) {
+                       btrfs_abort_transaction(trans, ret);
+               } else {
+                       ret = 0;
                }
 
-               if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {
-                       if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)
-                               return -ENOSPC;
+               if (!have_trans)
+                       btrfs_end_transaction(trans);
 
-                       /*
-                        * Don't loop again if we already have no empty_size and
-                        * no empty_cluster.
-                        */
-                       if (ffe_ctl->empty_size == 0 &&
-                           ffe_ctl->empty_cluster == 0)
-                               return -ENOSPC;
-                       ffe_ctl->empty_size = 0;
-                       ffe_ctl->empty_cluster = 0;
-               }
-               return 1;
+               if (ret)
+                       return ret;
+       }
+
+       if (ffe_ctl->loop == LOOP_NO_EMPTY_SIZE) {
+               if (ffe_ctl->policy != BTRFS_EXTENT_ALLOC_CLUSTERED)
+                       return -ENOSPC;
+
+               /*
+                * Don't loop again if we already have no empty_size and
+                * no empty_cluster.
+                */
+               if (ffe_ctl->empty_size == 0 && ffe_ctl->empty_cluster == 0)
+                       return -ENOSPC;
+               ffe_ctl->empty_size = 0;
+               ffe_ctl->empty_cluster = 0;
        }
-       return -ENOSPC;
+
+       return 1;
 }
 
 static int prepare_allocation_clustered(struct btrfs_fs_info *fs_info,