github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-28 18:21:24 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

btrfs: make more ASSERTs verbose, part 3

Browse Source 
We have support for optional string to be printed in ASSERT() (added in
19468a623a ("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 1c094e6cce ("btrfs: make a few
more ASSERTs verbose").

Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
David Sterba 2026-04-01 00:36:59 +02:00
parent b1db292ee3
commit 3fc0803f1c
10 changed files with 39 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fs/btrfs/backref.c
View File

@ -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) {

15
fs/btrfs/extent-tree.c
View File

@ -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) {

6
fs/btrfs/extent_map.c
View File

@ -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);
}

2
fs/btrfs/fiemap.c
View File

@ -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;

4
fs/btrfs/file-item.c
View File

@ -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) -

7
fs/btrfs/file.c
View File

@ -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,

3
fs/btrfs/ioctl.c
View File

@ -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)

12
fs/btrfs/ordered-data.c
View File

@ -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;

4
fs/btrfs/raid-stripe-tree.c
View File

@ -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;
}

5
fs/btrfs/reflink.c
View File

@ -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 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
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);