btrfs: trivial conversion to return bool instead of int

Old code has a lot of int for bool return values, bool is recommended
and done in new code. Convert the trivial cases that do simple 0/false
and 1/true. Functions comment are updated if needed.

Reviewed-by: Naohiro Aota <naohiro.aota@wdc.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index 1a37066afccff22e2b64f6dc7fc901ca22f0bc79..e3b912d539e294bab6bf774ff97886352e50dad1 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -3869,14 +3869,14 @@ static void force_metadata_allocation(struct btrfs_fs_info *info)
        }
 }
 
-static int should_alloc_chunk(const struct btrfs_fs_info *fs_info,
-                             const struct btrfs_space_info *sinfo, int force)
+static bool should_alloc_chunk(const struct btrfs_fs_info *fs_info,
+                              const struct btrfs_space_info *sinfo, int force)
 {
        u64 bytes_used = btrfs_space_info_used(sinfo, false);
        u64 thresh;
 
        if (force == CHUNK_ALLOC_FORCE)
-               return 1;
+               return true;
 
        /*
         * in limited mode, we want to have some free space up to
@@ -3887,12 +3887,12 @@ static int should_alloc_chunk(const struct btrfs_fs_info *fs_info,
                thresh = max_t(u64, SZ_64M, mult_perc(thresh, 1));
 
                if (sinfo->total_bytes - bytes_used < thresh)
-                       return 1;
+                       return true;
        }
 
        if (bytes_used + SZ_2M < mult_perc(sinfo->total_bytes, 80))
-               return 0;
-       return 1;
+               return false;
+       return true;
 }
 
 int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type)

diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index 8faee28fbf21e953ec9f446f6dd82114b161a3b9..48e12c8a90a7bd7fbfa01856b16bad3251bfe735 100644 (file)
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -105,15 +105,15 @@ static int btrfs_insert_inode_defrag(struct btrfs_inode *inode,
        return 0;
 }
 
-static inline int need_auto_defrag(struct btrfs_fs_info *fs_info)
+static inline bool need_auto_defrag(struct btrfs_fs_info *fs_info)
 {
        if (!btrfs_test_opt(fs_info, AUTO_DEFRAG))
-               return 0;
+               return false;
 
        if (btrfs_fs_closing(fs_info))
-               return 0;
+               return false;
 
-       return 1;
+       return true;
 }
 
 /*

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 2d62e9ba65a43c323e6f3ccdf3d53539817868a5..206d39e5ce5791fe9c89a168515c5ac8594c899b 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1387,17 +1387,17 @@ void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)
        WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root));
 }
 
-static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
+static bool could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
 {
        int val = atomic_read(&delayed_root->items_seq);
 
        if (val < seq || val >= seq + BTRFS_DELAYED_BATCH)
-               return 1;
+               return true;
 
        if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND)
-               return 1;
+               return true;
 
-       return 0;
+       return false;
 }
 
 void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info)

diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
index 5c26f0fcf0d500e080f826f8195ad48107ea672a..2decb9fff44519dc977fc94ace7479ab98ef3874 100644 (file)
--- a/fs/btrfs/dev-replace.c
+++ b/fs/btrfs/dev-replace.c
@@ -1265,16 +1265,16 @@ static int btrfs_dev_replace_kthread(void *data)
        return 0;
 }
 
-int __pure btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
+bool __pure btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
 {
        if (!dev_replace->is_valid)
-               return 0;
+               return false;
 
        switch (dev_replace->replace_state) {
        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
-               return 0;
+               return false;
        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
                /*
@@ -1289,7 +1289,7 @@ int __pure btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
                 */
                break;
        }
-       return 1;
+       return true;
 }
 
 void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount)

diff --git a/fs/btrfs/dev-replace.h b/fs/btrfs/dev-replace.h
index 23e480efe5e6e4050ee593ba03508a75e782c2ad..b35cecf388f2953f422030249d438617f1cf5220 100644 (file)
--- a/fs/btrfs/dev-replace.h
+++ b/fs/btrfs/dev-replace.h
@@ -25,7 +25,7 @@ void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
 int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info);
 void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info);
 int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info);
-int __pure btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace);
+bool __pure btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace);
 bool btrfs_finish_block_group_to_copy(struct btrfs_device *srcdev,
                                      struct btrfs_block_group *cache,
                                      u64 physical);

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index a7564b39eb5c9cd8fd07d1d1ec61cd472ebfbc62..23aa6d06add0ffd61c568520c2cfc2106a2d7148 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -409,15 +409,15 @@ static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
                                    btrfs_extent_data_ref_offset(leaf, ref));
 }
 
-static int match_extent_data_ref(struct extent_buffer *leaf,
-                                struct btrfs_extent_data_ref *ref,
-                                u64 root_objectid, u64 owner, u64 offset)
+static bool match_extent_data_ref(struct extent_buffer *leaf,
+                                 struct btrfs_extent_data_ref *ref,
+                                 u64 root_objectid, u64 owner, u64 offset)
 {
        if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
            btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
            btrfs_extent_data_ref_offset(leaf, ref) != offset)
-               return 0;
-       return 1;
+               return false;
+       return true;
 }
 
 static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 06f94679d84ab86f5fa494498e89190a1590a200..42d2df8ebe05d4bff9a05d55e77e4bd08e88bca6 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -508,20 +508,19 @@ out:
        return ret;
 }
 
-static int extent_mergeable(struct extent_buffer *leaf, int slot,
-                           u64 objectid, u64 bytenr, u64 orig_offset,
-                           u64 *start, u64 *end)
+static bool extent_mergeable(struct extent_buffer *leaf, int slot, u64 objectid,
+                            u64 bytenr, u64 orig_offset, u64 *start, u64 *end)
 {
        struct btrfs_file_extent_item *fi;
        struct btrfs_key key;
        u64 extent_end;
 
        if (slot < 0 || slot >= btrfs_header_nritems(leaf))
-               return 0;
+               return false;
 
        btrfs_item_key_to_cpu(leaf, &key, slot);
        if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
-               return 0;
+               return false;
 
        fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
        if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG ||
@@ -530,15 +529,15 @@ static int extent_mergeable(struct extent_buffer *leaf, int slot,
            btrfs_file_extent_compression(leaf, fi) ||
            btrfs_file_extent_encryption(leaf, fi) ||
            btrfs_file_extent_other_encoding(leaf, fi))
-               return 0;
+               return false;
 
        extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
        if ((*start && *start != key.offset) || (*end && *end != extent_end))
-               return 0;
+               return false;
 
        *start = key.offset;
        *end = extent_end;
-       return 1;
+       return true;
 }
 
 /*
@@ -2002,33 +2001,33 @@ static int btrfs_file_mmap(struct file  *filp, struct vm_area_struct *vma)
        return 0;
 }
 
-static int hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,
-                         int slot, u64 start, u64 end)
+static bool hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,
+                          int slot, u64 start, u64 end)
 {
        struct btrfs_file_extent_item *fi;
        struct btrfs_key key;
 
        if (slot < 0 || slot >= btrfs_header_nritems(leaf))
-               return 0;
+               return false;
 
        btrfs_item_key_to_cpu(leaf, &key, slot);
        if (key.objectid != btrfs_ino(inode) ||
            key.type != BTRFS_EXTENT_DATA_KEY)
-               return 0;
+               return false;
 
        fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
 
        if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
-               return 0;
+               return false;
 
        if (btrfs_file_extent_disk_bytenr(leaf, fi))
-               return 0;
+               return false;
 
        if (key.offset == end)
-               return 1;
+               return true;
        if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
-               return 1;
-       return 0;
+               return true;
+       return false;
 }
 
 static int fill_holes(struct btrfs_trans_handle *trans,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 7f64725b95b3282a34e6985a5f4aee1018aba92c..925a3c880d367ebf6d28411d6b064f7997293ba2 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3733,9 +3733,9 @@ out:
  *
  * slot is the slot the inode is in, objectid is the objectid of the inode
  */
-static noinline int acls_after_inode_item(struct extent_buffer *leaf,
-                                         int slot, u64 objectid,
-                                         int *first_xattr_slot)
+static noinline bool acls_after_inode_item(struct extent_buffer *leaf,
+                                          int slot, u64 objectid,
+                                          int *first_xattr_slot)
 {
        u32 nritems = btrfs_header_nritems(leaf);
        struct btrfs_key found_key;
@@ -3757,7 +3757,7 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
 
                /* we found a different objectid, there must not be acls */
                if (found_key.objectid != objectid)
-                       return 0;
+                       return false;
 
                /* we found an xattr, assume we've got an acl */
                if (found_key.type == BTRFS_XATTR_ITEM_KEY) {
@@ -3765,7 +3765,7 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
                                *first_xattr_slot = slot;
                        if (found_key.offset == xattr_access ||
                            found_key.offset == xattr_default)
-                               return 1;
+                               return true;
                }
 
                /*
@@ -3773,7 +3773,7 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
                 * be any acls later on
                 */
                if (found_key.type > BTRFS_XATTR_ITEM_KEY)
-                       return 0;
+                       return false;
 
                slot++;
                scanned++;
@@ -3793,7 +3793,7 @@ static noinline int acls_after_inode_item(struct extent_buffer *leaf,
         */
        if (*first_xattr_slot == -1)
                *first_xattr_slot = slot;
-       return 1;
+       return true;
 }
 
 static int btrfs_init_file_extent_tree(struct btrfs_inode *inode)

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 3341344a9fd27acf955f3a88faca8c6ccc7edf6c..a498fe524c907a20e970ba02f7f6de8c6043e5b0 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -1446,8 +1446,8 @@ out:
        return ret;
 }
 
-static noinline int key_in_sk(const struct btrfs_key *key,
-                             const struct btrfs_ioctl_search_key *sk)
+static noinline bool key_in_sk(const struct btrfs_key *key,
+                              const struct btrfs_ioctl_search_key *sk)
 {
        struct btrfs_key test;
        int ret;
@@ -1458,7 +1458,7 @@ static noinline int key_in_sk(const struct btrfs_key *key,
 
        ret = btrfs_comp_cpu_keys(key, &test);
        if (ret < 0)
-               return 0;
+               return false;
 
        test.objectid = sk->max_objectid;
        test.type = sk->max_type;
@@ -1466,8 +1466,8 @@ static noinline int key_in_sk(const struct btrfs_key *key,
 
        ret = btrfs_comp_cpu_keys(key, &test);
        if (ret > 0)
-               return 0;
-       return 1;
+               return false;
+       return true;
 }
 
 static noinline int copy_to_sk(struct btrfs_path *path,

diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
index 81e62b652e2104f5026164f859ac5c608dbf6ab8..a3e6d9616e60bf36de2456fa664d153ba654355e 100644 (file)
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -149,15 +149,15 @@ void btrfs_tree_read_lock_nested(struct extent_buffer *eb, enum btrfs_lock_nesti
 /*
  * Try-lock for read.
  *
- * Return 1 if the rwlock has been taken, 0 otherwise
+ * Return true if the rwlock has been taken, false otherwise
  */
-int btrfs_try_tree_read_lock(struct extent_buffer *eb)
+bool btrfs_try_tree_read_lock(struct extent_buffer *eb)
 {
        if (down_read_trylock(&eb->lock)) {
                trace_btrfs_try_tree_read_lock(eb);
-               return 1;
+               return true;
        }
-       return 0;
+       return false;
 }
 
 /*

diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h
index c69e57ff804bcf77b2af275b35d390e9f3bb8b81..af29df98ac14549ae0640feedd5ae33fb88088a0 100644 (file)
--- a/fs/btrfs/locking.h
+++ b/fs/btrfs/locking.h
@@ -189,7 +189,7 @@ static inline void btrfs_tree_read_lock(struct extent_buffer *eb)
 }
 
 void btrfs_tree_read_unlock(struct extent_buffer *eb);
-int btrfs_try_tree_read_lock(struct extent_buffer *eb);
+bool btrfs_try_tree_read_lock(struct extent_buffer *eb);
 struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root);
 struct extent_buffer *btrfs_read_lock_root_node(struct btrfs_root *root);
 struct extent_buffer *btrfs_try_read_lock_root_node(struct btrfs_root *root);

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 7d7001ad952930185b213d5ba740a3259e24302c..a8d2c2ca3120933e1b42422bb1615400372c4529 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1152,11 +1152,11 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
 /*
  * subvolumes are identified by ino 256
  */
-static inline int is_subvolume_inode(struct inode *inode)
+static inline bool is_subvolume_inode(struct inode *inode)
 {
        if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
-               return 1;
-       return 0;
+               return true;
+       return false;
 }
 
 static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid,

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 39e48bf610a1a424763ef0198806b5bbd9ac30ba..665c36f6e8172fa2575ee345ca7f5bfc81ca5494 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -538,15 +538,15 @@ static void wait_current_trans(struct btrfs_fs_info *fs_info)
        }
 }
 
-static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type)
+static bool may_wait_transaction(struct btrfs_fs_info *fs_info, int type)
 {
        if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))
-               return 0;
+               return false;
 
        if (type == TRANS_START)
-               return 1;
+               return true;
 
-       return 0;
+       return false;
 }
 
 static inline bool need_reserve_reloc_root(struct btrfs_root *root)

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 34d605b2faea8a9c7753e091773497a3cf4489b6..d0f8b7bd60ac216d7193becdad1cabf2270cff0e 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -3795,26 +3795,25 @@ static void reset_balance_state(struct btrfs_fs_info *fs_info)
  * Balance filters.  Return 1 if chunk should be filtered out
  * (should not be balanced).
  */
-static int chunk_profiles_filter(u64 chunk_type,
-                                struct btrfs_balance_args *bargs)
+static bool chunk_profiles_filter(u64 chunk_type, struct btrfs_balance_args *bargs)
 {
        chunk_type = chunk_to_extended(chunk_type) &
                                BTRFS_EXTENDED_PROFILE_MASK;
 
        if (bargs->profiles & chunk_type)
-               return 0;
+               return false;
 
-       return 1;
+       return true;
 }
 
-static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
-                             struct btrfs_balance_args *bargs)
+static bool chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
+                                    struct btrfs_balance_args *bargs)
 {
        struct btrfs_block_group *cache;
        u64 chunk_used;
        u64 user_thresh_min;
        u64 user_thresh_max;
-       int ret = 1;
+       bool ret = true;
 
        cache = btrfs_lookup_block_group(fs_info, chunk_offset);
        chunk_used = cache->used;
@@ -3832,18 +3831,18 @@ static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_off
                user_thresh_max = mult_perc(cache->length, bargs->usage_max);
 
        if (user_thresh_min <= chunk_used && chunk_used < user_thresh_max)
-               ret = 0;
+               ret = false;
 
        btrfs_put_block_group(cache);
        return ret;
 }
 
-static int chunk_usage_filter(struct btrfs_fs_info *fs_info,
-               u64 chunk_offset, struct btrfs_balance_args *bargs)
+static bool chunk_usage_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
+                              struct btrfs_balance_args *bargs)
 {
        struct btrfs_block_group *cache;
        u64 chunk_used, user_thresh;
-       int ret = 1;
+       bool ret = true;
 
        cache = btrfs_lookup_block_group(fs_info, chunk_offset);
        chunk_used = cache->used;
@@ -3856,15 +3855,14 @@ static int chunk_usage_filter(struct btrfs_fs_info *fs_info,
                user_thresh = mult_perc(cache->length, bargs->usage);
 
        if (chunk_used < user_thresh)
-               ret = 0;
+               ret = false;
 
        btrfs_put_block_group(cache);
        return ret;
 }
 
-static int chunk_devid_filter(struct extent_buffer *leaf,
-                             struct btrfs_chunk *chunk,
-                             struct btrfs_balance_args *bargs)
+static bool chunk_devid_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,
+                              struct btrfs_balance_args *bargs)
 {
        struct btrfs_stripe *stripe;
        int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
@@ -3873,10 +3871,10 @@ static int chunk_devid_filter(struct extent_buffer *leaf,
        for (i = 0; i < num_stripes; i++) {
                stripe = btrfs_stripe_nr(chunk, i);
                if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)
-                       return 0;
+                       return false;
        }
 
-       return 1;
+       return true;
 }
 
 static u64 calc_data_stripes(u64 type, int num_stripes)
@@ -3889,9 +3887,8 @@ static u64 calc_data_stripes(u64 type, int num_stripes)
 }
 
 /* [pstart, pend) */
-static int chunk_drange_filter(struct extent_buffer *leaf,
-                              struct btrfs_chunk *chunk,
-                              struct btrfs_balance_args *bargs)
+static bool chunk_drange_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,
+                               struct btrfs_balance_args *bargs)
 {
        struct btrfs_stripe *stripe;
        int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
@@ -3902,7 +3899,7 @@ static int chunk_drange_filter(struct extent_buffer *leaf,
        int i;
 
        if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID))
-               return 0;
+               return false;
 
        type = btrfs_chunk_type(leaf, chunk);
        factor = calc_data_stripes(type, num_stripes);
@@ -3918,56 +3915,53 @@ static int chunk_drange_filter(struct extent_buffer *leaf,
 
                if (stripe_offset < bargs->pend &&
                    stripe_offset + stripe_length > bargs->pstart)
-                       return 0;
+                       return false;
        }
 
-       return 1;
+       return true;
 }
 
 /* [vstart, vend) */
-static int chunk_vrange_filter(struct extent_buffer *leaf,
-                              struct btrfs_chunk *chunk,
-                              u64 chunk_offset,
-                              struct btrfs_balance_args *bargs)
+static bool chunk_vrange_filter(struct extent_buffer *leaf, struct btrfs_chunk *chunk,
+                               u64 chunk_offset, struct btrfs_balance_args *bargs)
 {
        if (chunk_offset < bargs->vend &&
            chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)
                /* at least part of the chunk is inside this vrange */
-               return 0;
+               return false;
 
-       return 1;
+       return true;
 }
 
-static int chunk_stripes_range_filter(struct extent_buffer *leaf,
-                              struct btrfs_chunk *chunk,
-                              struct btrfs_balance_args *bargs)
+static bool chunk_stripes_range_filter(struct extent_buffer *leaf,
+                                      struct btrfs_chunk *chunk,
+                                      struct btrfs_balance_args *bargs)
 {
        int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
 
        if (bargs->stripes_min <= num_stripes
                        && num_stripes <= bargs->stripes_max)
-               return 0;
+               return false;
 
-       return 1;
+       return true;
 }
 
-static int chunk_soft_convert_filter(u64 chunk_type,
-                                    struct btrfs_balance_args *bargs)
+static bool chunk_soft_convert_filter(u64 chunk_type, struct btrfs_balance_args *bargs)
 {
        if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
-               return 0;
+               return false;
 
        chunk_type = chunk_to_extended(chunk_type) &
                                BTRFS_EXTENDED_PROFILE_MASK;
 
        if (bargs->target == chunk_type)
-               return 1;
+               return true;
 
-       return 0;
+       return false;
 }
 
-static int should_balance_chunk(struct extent_buffer *leaf,
-                               struct btrfs_chunk *chunk, u64 chunk_offset)
+static bool should_balance_chunk(struct extent_buffer *leaf, struct btrfs_chunk *chunk,
+                                u64 chunk_offset)
 {
        struct btrfs_fs_info *fs_info = leaf->fs_info;
        struct btrfs_balance_control *bctl = fs_info->balance_ctl;
@@ -3977,7 +3971,7 @@ static int should_balance_chunk(struct extent_buffer *leaf,
        /* type filter */
        if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
              (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) {
-               return 0;
+               return false;
        }
 
        if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
@@ -3990,46 +3984,46 @@ static int should_balance_chunk(struct extent_buffer *leaf,
        /* profiles filter */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
            chunk_profiles_filter(chunk_type, bargs)) {
-               return 0;
+               return false;
        }
 
        /* usage filter */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
            chunk_usage_filter(fs_info, chunk_offset, bargs)) {
-               return 0;
+               return false;
        } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
            chunk_usage_range_filter(fs_info, chunk_offset, bargs)) {
-               return 0;
+               return false;
        }
 
        /* devid filter */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
            chunk_devid_filter(leaf, chunk, bargs)) {
-               return 0;
+               return false;
        }
 
        /* drange filter, makes sense only with devid filter */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) &&
            chunk_drange_filter(leaf, chunk, bargs)) {
-               return 0;
+               return false;
        }
 
        /* vrange filter */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) &&
            chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {
-               return 0;
+               return false;
        }
 
        /* stripes filter */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) &&
            chunk_stripes_range_filter(leaf, chunk, bargs)) {
-               return 0;
+               return false;
        }
 
        /* soft profile changing mode */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
            chunk_soft_convert_filter(chunk_type, bargs)) {
-               return 0;
+               return false;
        }
 
        /*
@@ -4037,7 +4031,7 @@ static int should_balance_chunk(struct extent_buffer *leaf,
         */
        if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) {
                if (bargs->limit == 0)
-                       return 0;
+                       return false;
                else
                        bargs->limit--;
        } else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) {
@@ -4047,12 +4041,12 @@ static int should_balance_chunk(struct extent_buffer *leaf,
                 * about the count of all chunks that satisfy the filters.
                 */
                if (bargs->limit_max == 0)
-                       return 0;
+                       return false;
                else
                        bargs->limit_max--;
        }
 
-       return 1;
+       return true;
 }
 
 static int __btrfs_balance(struct btrfs_fs_info *fs_info)