btrfs: make more ASSERTs verbose, part 3

We have support for optional string to be printed in ASSERT() (added in
19468a623a9109 ("btrfs: enhance ASSERT() to take optional format
string")), it's not yet everywhere it could be so add a few more files.

Try to finish what was left after 1c094e6ccead7a ("btrfs: make a few
more ASSERTs verbose").

Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 273924ca912c2f0a02ac5c6312bb73a61eb60424..2c25e5d86f3e42ba8b3fc1a53f325f4fe11d92fc 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -2367,7 +2367,7 @@ int tree_backref_for_extent(unsigned long *ptr, struct extent_buffer *eb,
                info = (struct btrfs_tree_block_info *)(ei + 1);
                *out_level = btrfs_tree_block_level(eb, info);
        } else {
-               ASSERT(key->type == BTRFS_METADATA_ITEM_KEY);
+               ASSERT(key->type == BTRFS_METADATA_ITEM_KEY, "key->type=%hhu", key->type);
                *out_level = (u8)key->offset;
        }
 
@@ -3199,7 +3199,7 @@ static int handle_direct_tree_backref(struct btrfs_backref_cache *cache,
        struct btrfs_backref_node *upper;
        struct rb_node *rb_node;
 
-       ASSERT(ref_key->type == BTRFS_SHARED_BLOCK_REF_KEY);
+       ASSERT(ref_key->type == BTRFS_SHARED_BLOCK_REF_KEY, "ref_key->type=%hhu", ref_key->type);
 
        /* Only reloc root uses backref pointing to itself */
        if (ref_key->objectid == ref_key->offset) {

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 5d5b42ea4adef7a901a318ccb0cf6857cf9c3df1..420d52b097d990961a86671292675689a0725414 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -385,7 +385,7 @@ int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
                                        return type;
                        }
                } else {
-                       ASSERT(is_data == BTRFS_REF_TYPE_ANY);
+                       ASSERT(is_data == BTRFS_REF_TYPE_ANY, "is_data=%d", is_data);
                        return type;
                }
        }
@@ -2531,8 +2531,11 @@ int btrfs_cross_ref_exist(struct btrfs_inode *inode, u64 offset,
                                struct btrfs_key key;
 
                                btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
-                               ASSERT(key.objectid == bytenr);
-                               ASSERT(key.type == BTRFS_EXTENT_ITEM_KEY);
+                               ASSERT(key.objectid == bytenr,
+                                      "key.objectid=%llu bytenr=%llu",
+                                      key.objectid, bytenr);
+                               ASSERT(key.type == BTRFS_EXTENT_ITEM_KEY, "key.type=%u",
+                                      key.type);
                        }
                }
 
@@ -4598,10 +4601,12 @@ static noinline int find_free_extent(struct btrfs_root *root,
                /* Use dedicated sub-space_info for dedicated block group users. */
                if (ffe_ctl->for_data_reloc) {
                        space_info = space_info->sub_group[0];
-                       ASSERT(space_info->subgroup_id == BTRFS_SUB_GROUP_DATA_RELOC);
+                       ASSERT(space_info->subgroup_id == BTRFS_SUB_GROUP_DATA_RELOC,
+                              "space_info->subgroup_id=%d", space_info->subgroup_id);
                } else if (ffe_ctl->for_treelog) {
                        space_info = space_info->sub_group[0];
-                       ASSERT(space_info->subgroup_id == BTRFS_SUB_GROUP_TREELOG);
+                       ASSERT(space_info->subgroup_id == BTRFS_SUB_GROUP_TREELOG,
+                              "space_info->subgroup_id=%d", space_info->subgroup_id);
                }
        }
        if (!space_info) {

diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 6b79bff241f21dc0b7fac11d949c4627b3e080ef..fce9c5cc012283dddb891c0e45b06180878a6148 100644 (file)
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -717,7 +717,7 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode,
         * file offset. Here just do a sanity check.
         */
        if (em->disk_bytenr == EXTENT_MAP_INLINE)
-               ASSERT(em->start == 0);
+               ASSERT(em->start == 0, "em->start=%llu", em->start);
 
        ret = add_extent_mapping(inode, em, false);
        /* it is possible that someone inserted the extent into the tree
@@ -761,7 +761,7 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode,
                }
        }
 
-       ASSERT(ret == 0 || ret == -EEXIST);
+       ASSERT(ret == 0 || ret == -EEXIST, "ret=%d", ret);
        return ret;
 }
 
@@ -943,7 +943,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end,
 
                                ret = add_extent_mapping(inode, split, modified);
                                /* Logic error, shouldn't happen. */
-                               ASSERT(ret == 0);
+                               ASSERT(ret == 0, "ret=%d", ret);
                                if (WARN_ON(ret != 0) && modified)
                                        btrfs_set_inode_full_sync(inode);
                        }

diff --git a/fs/btrfs/fiemap.c b/fs/btrfs/fiemap.c
index 27d361c7adc4d82fa67d2eb331e58bd80562d0bf..6263e837093e42c36dec84f46e833a8ee955d403 100644 (file)
--- a/fs/btrfs/fiemap.c
+++ b/fs/btrfs/fiemap.c
@@ -112,7 +112,7 @@ static int emit_fiemap_extent(struct fiemap_extent_info *fieinfo,
        u64 cache_end;
 
        /* Set at the end of extent_fiemap(). */
-       ASSERT((flags & FIEMAP_EXTENT_LAST) == 0);
+       ASSERT((flags & FIEMAP_EXTENT_LAST) == 0, "flags=0x%u", flags);
 
        if (!cache->cached)
                goto assign;

diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index d72249390030f490002c78512a8bd386e3a282ce..82ae4a2afd34717bb623833747f1d4ec1ceb8be5 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -325,7 +325,9 @@ static int search_csum_tree(struct btrfs_fs_info *fs_info,
 
        csum_start = key.offset;
        csum_len = (itemsize / csum_size) * sectorsize;
-       ASSERT(in_range(disk_bytenr, csum_start, csum_len));
+       ASSERT(in_range(disk_bytenr, csum_start, csum_len),
+              "disk_bytenr=%llu csum_start=%llu csum_len=%llu",
+              disk_bytenr, csum_start, csum_len);
 
 found:
        ret = (min(csum_start + csum_len, disk_bytenr + len) -

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 2c1862ee99984eadd120a63ed22fc7ad1946105c..7dbba3acb674c12a1b7c8ba04715e2675ecc9ffb 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1223,8 +1223,11 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
                return ret;
        reserved_len = ret;
        /* Write range must be inside the reserved range. */
-       ASSERT(reserved_start <= start);
-       ASSERT(start + write_bytes <= reserved_start + reserved_len);
+       ASSERT(reserved_start <= start, "reserved_start=%llu start=%llu",
+              reserved_start, start);
+       ASSERT(start + write_bytes <= reserved_start + reserved_len,
+              "start=%llu write_bytes=%zu reserved_start=%llu reserved_len=%llu",
+              start, write_bytes, reserved_start, reserved_len);
 
 again:
        ret = balance_dirty_pages_ratelimited_flags(inode->vfs_inode.i_mapping,

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index db7ffabbd3a47e7372ccf6ebe29b9993433422fe..e60b13b27a6d8e2a8733e4c5ea155a9ae873a121 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -5011,7 +5011,8 @@ static int btrfs_ioctl_subvol_sync(struct btrfs_fs_info *fs_info, void __user *a
                        return -ENOENT;
 
                wait_for_deletion = true;
-               ASSERT(root_flags & BTRFS_ROOT_SUBVOL_DEAD);
+               ASSERT(root_flags & BTRFS_ROOT_SUBVOL_DEAD, "root_flags=0x%llx",
+                      root_flags);
                sched_ret = schedule_timeout_interruptible(HZ);
                /* Early wake up or error. */
                if (sched_ret != 0)

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index e5a24b3ff95e46b6c5eb9c55a6c5c519a9bb0df9..f5f77c33cf592dde40883735ae528369d7a3a4dc 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -157,7 +157,8 @@ static struct btrfs_ordered_extent *alloc_ordered_extent(
               ((1U << BTRFS_ORDERED_NOCOW) | (1U << BTRFS_ORDERED_PREALLOC)));
 
        /* Only one type flag can be set. */
-       ASSERT(has_single_bit_set(flags & BTRFS_ORDERED_EXCLUSIVE_FLAGS));
+       ASSERT(has_single_bit_set(flags & BTRFS_ORDERED_EXCLUSIVE_FLAGS),
+              "flags=0x%lx", flags);
 
        /* DIRECT cannot be set with COMPRESSED nor ENCODED. */
        if (test_bit(BTRFS_ORDERED_DIRECT, &flags)) {
@@ -302,7 +303,7 @@ struct btrfs_ordered_extent *btrfs_alloc_ordered_extent(
 {
        struct btrfs_ordered_extent *entry;
 
-       ASSERT((flags & ~BTRFS_ORDERED_TYPE_FLAGS) == 0);
+       ASSERT((flags & ~BTRFS_ORDERED_TYPE_FLAGS) == 0, "flags=0x%lx", flags);
 
        /*
         * For regular writes, we just use the members in @file_extent.
@@ -1238,7 +1239,7 @@ struct btrfs_ordered_extent *btrfs_split_ordered_extent(
 
        trace_btrfs_ordered_extent_split(inode, ordered);
 
-       ASSERT(!(flags & (1U << BTRFS_ORDERED_COMPRESSED)));
+       ASSERT(!(flags & (1U << BTRFS_ORDERED_COMPRESSED)), "flags=0x%lx", flags);
 
        /*
         * The entire bio must be covered by the ordered extent, but we can't
@@ -1260,7 +1261,7 @@ struct btrfs_ordered_extent *btrfs_split_ordered_extent(
        }
        /* We cannot split partially completed ordered extents. */
        if (ordered->bytes_left) {
-               ASSERT(!(flags & ~BTRFS_ORDERED_TYPE_FLAGS));
+               ASSERT(!(flags & ~BTRFS_ORDERED_TYPE_FLAGS), "flags=0x%lx", flags);
                if (WARN_ON_ONCE(ordered->bytes_left != ordered->disk_num_bytes))
                        return ERR_PTR(-EINVAL);
        }
@@ -1307,7 +1308,8 @@ struct btrfs_ordered_extent *btrfs_split_ordered_extent(
        ordered->ram_bytes -= len;
 
        if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags)) {
-               ASSERT(ordered->bytes_left == 0);
+               ASSERT(ordered->bytes_left == 0, "ordered->bytes_left=%llu",
+                      ordered->bytes_left);
                new->bytes_left = 0;
        } else {
                ordered->bytes_left -= len;

diff --git a/fs/btrfs/raid-stripe-tree.c b/fs/btrfs/raid-stripe-tree.c
index 4b0186c83ad1d8857c673455d0207d695adeeb38..454a95bf542a0dcce694e76d92bea47dacdf9e36 100644 (file)
--- a/fs/btrfs/raid-stripe-tree.c
+++ b/fs/btrfs/raid-stripe-tree.c
@@ -272,7 +272,9 @@ int btrfs_delete_raid_extent(struct btrfs_trans_handle *trans, u64 start, u64 le
                                                                 &key,
                                                                 key.offset - length,
                                                                 length);
-                       ASSERT(key.offset - diff_end == length);
+                       ASSERT(key.offset - diff_end == length,
+                              "key.offset=%llu diff_end=%llu length=%llu",
+                              key.offset, diff_end, length);
                        break;
                }
 

diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c
index 14742abe0f92b40f47c699e110c7ec95595cc997..86fa8d92e15bbd306f23ac929c355fa217619385 100644 (file)
--- a/fs/btrfs/reflink.c
+++ b/fs/btrfs/reflink.c
@@ -69,7 +69,8 @@ static int copy_inline_to_page(struct btrfs_inode *inode,
        struct address_space *mapping = inode->vfs_inode.i_mapping;
        int ret;
 
-       ASSERT(IS_ALIGNED(file_offset, block_size));
+       ASSERT(IS_ALIGNED(file_offset, block_size), "file_offset=%llu block_size=%u",
+              file_offset, block_size);
 
        /*
         * We have flushed and locked the ranges of the source and destination
@@ -458,7 +459,7 @@ process_slot:
                    key.objectid != btrfs_ino(BTRFS_I(src)))
                        break;
 
-               ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
+               ASSERT(key.type == BTRFS_EXTENT_DATA_KEY, "key.type=%u", key.type);
 
                extent = btrfs_item_ptr(leaf, slot,
                                        struct btrfs_file_extent_item);