RepoMirrors/btrfs-progs
1
0
Fork 0
mirror of https://github.com/kdave/btrfs-progs synced 2025-05-02 16:07:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

btrfs-progs: introduce UASSERT() for purely userspace code

Browse Source 
While syncing messages.[ch] I had to back out the ASSERT() code in
kerncompat.h, which means we now rely on the kernel code for ASSERT().
In order to maintain some semblance of separation introduce UASSERT()
and use that in all the purely userspace code.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Josef Bacik 2023-04-19 17:13:46 -04:00 committed by David Sterba
parent c0c5ca1522
commit bf0f3db765
20 changed files with 74 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
check/clear-cache.c
View File

@ -508,12 +508,12 @@ int truncate_free_ino_items(struct btrfs_root *root)
fi = btrfs_item_ptr(leaf, path.slots[0], fi = btrfs_item_ptr(leaf, path.slots[0],
struct btrfs_file_extent_item); struct btrfs_file_extent_item);
extent_type = btrfs_file_extent_type(leaf, fi); extent_type = btrfs_file_extent_type(leaf, fi);
ASSERT(extent_type == BTRFS_FILE_EXTENT_REG); UASSERT(extent_type == BTRFS_FILE_EXTENT_REG);
extent_disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); extent_disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
extent_num_bytes = btrfs_file_extent_disk_num_bytes (leaf, fi); extent_num_bytes = btrfs_file_extent_disk_num_bytes (leaf, fi);
extent_offset = found_key.offset - extent_offset = found_key.offset -
btrfs_file_extent_offset(leaf, fi); btrfs_file_extent_offset(leaf, fi);
ASSERT(extent_offset == 0); UASSERT(extent_offset == 0);
ret = btrfs_free_extent(trans, root, extent_disk_bytenr, ret = btrfs_free_extent(trans, root, extent_disk_bytenr,
extent_num_bytes, 0, root->objectid, extent_num_bytes, 0, root->objectid,
BTRFS_FREE_INO_OBJECTID, 0); BTRFS_FREE_INO_OBJECTID, 0);

10
check/main.c
View File

@ -9680,14 +9680,14 @@ static int build_roots_info_cache(void)
rii->level = (u8)-1; rii->level = (u8)-1;
entry = &rii->cache_extent; entry = &rii->cache_extent;
ret = insert_cache_extent(roots_info_cache, entry); ret = insert_cache_extent(roots_info_cache, entry);
ASSERT(ret == 0); UASSERT(ret == 0);
} else { } else {
rii = container_of(entry, struct root_item_info, rii = container_of(entry, struct root_item_info,
cache_extent); cache_extent);
} }
ASSERT(rii->cache_extent.start == root_id); UASSERT(rii->cache_extent.start == root_id);
ASSERT(rii->cache_extent.size == 1); UASSERT(rii->cache_extent.size == 1);
if (level > rii->level || rii->level == (u8)-1) { if (level > rii->level || rii->level == (u8)-1) {
rii->level = level; rii->level = level;
@ -9726,8 +9726,8 @@ static int maybe_repair_root_item(struct btrfs_path *path,
} }
rii = container_of(entry, struct root_item_info, cache_extent); rii = container_of(entry, struct root_item_info, cache_extent);
ASSERT(rii->cache_extent.start == root_id); UASSERT(rii->cache_extent.start == root_id);
ASSERT(rii->cache_extent.size == 1); UASSERT(rii->cache_extent.size == 1);
if (rii->node_count != 1) { if (rii->node_count != 1) {
fprintf(stderr, fprintf(stderr,

10
check/mode-common.c
View File

@ -224,7 +224,7 @@ int check_prealloc_extent_written(u64 disk_bytenr, u64 num_bytes)
iref = (struct btrfs_extent_inline_ref *)ptr; iref = (struct btrfs_extent_inline_ref *)ptr;
type = btrfs_extent_inline_ref_type(path.nodes[0], iref); type = btrfs_extent_inline_ref_type(path.nodes[0], iref);
ASSERT(type == BTRFS_EXTENT_DATA_REF_KEY || UASSERT(type == BTRFS_EXTENT_DATA_REF_KEY ||
type == BTRFS_SHARED_DATA_REF_KEY); type == BTRFS_SHARED_DATA_REF_KEY);
if (type == BTRFS_EXTENT_DATA_REF_KEY) { if (type == BTRFS_EXTENT_DATA_REF_KEY) {
@ -398,7 +398,7 @@ int insert_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_stack_timespec_sec(&ii.mtime, now); btrfs_set_stack_timespec_sec(&ii.mtime, now);
ret = btrfs_insert_inode(trans, root, ino, &ii); ret = btrfs_insert_inode(trans, root, ino, &ii);
ASSERT(!ret); UASSERT(!ret);
warning("root %llu inode %llu recreating inode item, this may " warning("root %llu inode %llu recreating inode item, this may "
"be incomplete, please check permissions and content after " "be incomplete, please check permissions and content after "
@ -985,7 +985,7 @@ int repair_imode_common(struct btrfs_root *root, struct btrfs_path *path)
int ret; int ret;
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
ASSERT(key.type == BTRFS_INODE_ITEM_KEY); UASSERT(key.type == BTRFS_INODE_ITEM_KEY);
if (root->objectid == BTRFS_ROOT_TREE_OBJECTID) { if (root->objectid == BTRFS_ROOT_TREE_OBJECTID) {
/* In root tree we only have two possible imode */ /* In root tree we only have two possible imode */
if (key.objectid == BTRFS_ROOT_TREE_OBJECTID) if (key.objectid == BTRFS_ROOT_TREE_OBJECTID)
@ -1033,7 +1033,7 @@ int check_repair_free_space_inode(struct btrfs_path *path)
int ret = 0; int ret = 0;
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
ASSERT(key.type == BTRFS_INODE_ITEM_KEY && is_fstree(key.objectid)); UASSERT(key.type == BTRFS_INODE_ITEM_KEY && is_fstree(key.objectid));
iitem = btrfs_item_ptr(path->nodes[0], path->slots[0], iitem = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_item); struct btrfs_inode_item);
mode = btrfs_inode_mode(path->nodes[0], iitem); mode = btrfs_inode_mode(path->nodes[0], iitem);
@ -1607,7 +1607,7 @@ static int get_num_devs_in_chunk_tree(struct btrfs_fs_info *fs_info)
return ret; return ret;
/* We should be the first slot, and chunk tree should not be empty*/ /* We should be the first slot, and chunk tree should not be empty*/
ASSERT(path.slots[0] == 0 && btrfs_header_nritems(path.nodes[0])); UASSERT(path.slots[0] == 0 && btrfs_header_nritems(path.nodes[0]));
btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]); btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);

18
check/mode-lowmem.c
View File

@ -833,7 +833,7 @@ static int find_dir_index(struct btrfs_root *root, u64 dirid, u64 location_id,
int slot; int slot;
int ret; int ret;
ASSERT(index_ret); UASSERT(index_ret);
/* search from the last index */ /* search from the last index */
key.objectid = dirid; key.objectid = dirid;
@ -1029,7 +1029,7 @@ static int repair_ternary_lowmem(struct btrfs_root *root, u64 dir_ino, u64 ino,
stage++; stage++;
/* stage must be smllarer than 3 */ /* stage must be smllarer than 3 */
ASSERT(stage < 3); UASSERT(stage < 3);
trans = btrfs_start_transaction(root, 1); trans = btrfs_start_transaction(root, 1);
if (stage == 2) { if (stage == 2) {
@ -1351,7 +1351,7 @@ static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
int slot; int slot;
int ret; int ret;
ASSERT(index_ret); UASSERT(index_ret);
btrfs_init_path(&path); btrfs_init_path(&path);
ret = btrfs_search_slot(NULL, root, key, &path, 0, 0); ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
@ -1945,7 +1945,7 @@ recover:
recover_ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); recover_ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
/* This really shouldn't happen, or we have a big problem */ /* This really shouldn't happen, or we have a big problem */
ASSERT(recover_ret == 0); UASSERT(recover_ret == 0);
return ret; return ret;
} }
@ -2193,7 +2193,7 @@ static int __count_dir_isize(struct btrfs_root *root, u64 ino, int type,
int cur = 0; int cur = 0;
int total = 0; int total = 0;
ASSERT(size_ret); UASSERT(size_ret);
*size_ret = 0; *size_ret = 0;
key.objectid = ino; key.objectid = ino;
@ -2247,7 +2247,7 @@ static int count_dir_isize(struct btrfs_root *root, u64 ino, u64 *size)
u64 index_size; u64 index_size;
int ret; int ret;
ASSERT(size); UASSERT(size);
ret = __count_dir_isize(root, ino, BTRFS_DIR_ITEM_KEY, &item_size); ret = __count_dir_isize(root, ino, BTRFS_DIR_ITEM_KEY, &item_size);
if (ret) if (ret)
goto out; goto out;
@ -2451,7 +2451,7 @@ static int repair_inode_nlinks_lowmem(struct btrfs_root *root,
btrfs_item_key_to_cpu(path->nodes[0], &old_key, path->slots[0]); btrfs_item_key_to_cpu(path->nodes[0], &old_key, path->slots[0]);
if (name && namelen) { if (name && namelen) {
ASSERT(namelen <= BTRFS_NAME_LEN); UASSERT(namelen <= BTRFS_NAME_LEN);
memcpy(namebuf, name, namelen); memcpy(namebuf, name, namelen);
name_len = namelen; name_len = namelen;
} else { } else {
@ -2550,7 +2550,7 @@ static int repair_inode_gen_lowmem(struct btrfs_root *root,
} }
transid = trans->transid; transid = trans->transid;
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
ASSERT(key.type == BTRFS_INODE_ITEM_KEY); UASSERT(key.type == BTRFS_INODE_ITEM_KEY);
btrfs_release_path(path); btrfs_release_path(path);
@ -4188,7 +4188,7 @@ static int repair_extent_item_generation(struct btrfs_path *path)
int ret; int ret;
btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
ASSERT(key.type == BTRFS_METADATA_ITEM_KEY || UASSERT(key.type == BTRFS_METADATA_ITEM_KEY ||
key.type == BTRFS_EXTENT_ITEM_KEY); key.type == BTRFS_EXTENT_ITEM_KEY);
get_extent_item_generation(key.objectid, &new_gen); get_extent_item_generation(key.objectid, &new_gen);

2
cmds/filesystem-du.c
View File

@ -87,7 +87,7 @@ static int add_shared_extent(u64 start, u64 len, struct rb_root *root)
{ {
struct shared_extent *sh; struct shared_extent *sh;
ASSERT(len != 0); UASSERT(len != 0);
sh = calloc(1, sizeof(*sh)); sh = calloc(1, sizeof(*sh));
if (!sh) if (!sh)

6
cmds/filesystem-usage.c
View File

@ -383,15 +383,15 @@ static void get_raid56_space_info(struct btrfs_ioctl_space_args *sargs,
size = info_ptr->size / (info_ptr->num_stripes - parities_count); size = info_ptr->size / (info_ptr->num_stripes - parities_count);
if (info_ptr->type & BTRFS_BLOCK_GROUP_DATA) { if (info_ptr->type & BTRFS_BLOCK_GROUP_DATA) {
ASSERT(l_data_ratio >= 0); UASSERT(l_data_ratio >= 0);
*r_data_chunks += size; *r_data_chunks += size;
*r_data_used += size * l_data_ratio; *r_data_used += size * l_data_ratio;
} else if (info_ptr->type & BTRFS_BLOCK_GROUP_METADATA) { } else if (info_ptr->type & BTRFS_BLOCK_GROUP_METADATA) {
ASSERT(l_metadata_ratio >= 0); UASSERT(l_metadata_ratio >= 0);
*r_metadata_chunks += size; *r_metadata_chunks += size;
*r_metadata_used += size * l_metadata_ratio; *r_metadata_used += size * l_metadata_ratio;
} else if (info_ptr->type & BTRFS_BLOCK_GROUP_SYSTEM) { } else if (info_ptr->type & BTRFS_BLOCK_GROUP_SYSTEM) {
ASSERT(l_system_ratio >= 0); UASSERT(l_system_ratio >= 0);
*r_system_chunks += size; *r_system_chunks += size;
*r_system_used += size * l_system_ratio; *r_system_used += size * l_system_ratio;
} }

22
cmds/qgroup.c
View File

@ -222,7 +222,7 @@ static void qgroup_setup_print_column(enum btrfs_qgroup_column_enum column)
{ {
int i; int i;
ASSERT(0 <= column && column <= BTRFS_QGROUP_ALL); UASSERT(0 <= column && column <= BTRFS_QGROUP_ALL);
if (column < BTRFS_QGROUP_ALL) { if (column < BTRFS_QGROUP_ALL) {
btrfs_qgroup_columns[column].need_print = 1; btrfs_qgroup_columns[column].need_print = 1;
@ -332,7 +332,7 @@ static void print_qgroup_column(struct btrfs_qgroup *qgroup,
int unit_mode = btrfs_qgroup_columns[column].unit_mode; int unit_mode = btrfs_qgroup_columns[column].unit_mode;
int max_len = btrfs_qgroup_columns[column].max_len; int max_len = btrfs_qgroup_columns[column].max_len;
ASSERT(0 <= column && column < BTRFS_QGROUP_ALL); UASSERT(0 <= column && column < BTRFS_QGROUP_ALL);
switch (column) { switch (column) {
@ -617,9 +617,9 @@ static int qgroup_setup_comparer(struct btrfs_qgroup_comparer_set **comp_set,
struct btrfs_qgroup_comparer_set *set = *comp_set; struct btrfs_qgroup_comparer_set *set = *comp_set;
int size; int size;
ASSERT(set != NULL); UASSERT(set != NULL);
ASSERT(comparer < BTRFS_QGROUP_COMP_MAX); UASSERT(comparer < BTRFS_QGROUP_COMP_MAX);
ASSERT(set->ncomps <= set->total); UASSERT(set->ncomps <= set->total);
if (set->ncomps == set->total) { if (set->ncomps == set->total) {
void *tmp; void *tmp;
@ -641,7 +641,7 @@ static int qgroup_setup_comparer(struct btrfs_qgroup_comparer_set **comp_set,
*comp_set = set; *comp_set = set;
} }
ASSERT(set->comps[set->ncomps].comp_func == NULL); UASSERT(set->comps[set->ncomps].comp_func == NULL);
set->comps[set->ncomps].comp_func = all_comp_funcs[comparer]; set->comps[set->ncomps].comp_func = all_comp_funcs[comparer];
set->comps[set->ncomps].is_descending = is_descending; set->comps[set->ncomps].is_descending = is_descending;
@ -1014,9 +1014,9 @@ static int qgroup_setup_filter(struct btrfs_qgroup_filter_set **filter_set,
struct btrfs_qgroup_filter_set *set = *filter_set; struct btrfs_qgroup_filter_set *set = *filter_set;
int size; int size;
ASSERT(set != NULL); UASSERT(set != NULL);
ASSERT(filter < BTRFS_QGROUP_FILTER_MAX); UASSERT(filter < BTRFS_QGROUP_FILTER_MAX);
ASSERT(set->nfilters <= set->total); UASSERT(set->nfilters <= set->total);
if (set->nfilters == set->total) { if (set->nfilters == set->total) {
void *tmp; void *tmp;
@ -1038,7 +1038,7 @@ static int qgroup_setup_filter(struct btrfs_qgroup_filter_set **filter_set,
*filter_set = set; *filter_set = set;
} }
ASSERT(set->filters[set->nfilters].filter_func == NULL); UASSERT(set->filters[set->nfilters].filter_func == NULL);
set->filters[set->nfilters].filter_func = all_filter_funcs[filter]; set->filters[set->nfilters].filter_func = all_filter_funcs[filter];
set->filters[set->nfilters].data = data; set->filters[set->nfilters].data = data;
set->nfilters++; set->nfilters++;
@ -1114,7 +1114,7 @@ static void __update_columns_max_len(struct btrfs_qgroup *bq,
int len; int len;
unsigned unit_mode = btrfs_qgroup_columns[column].unit_mode; unsigned unit_mode = btrfs_qgroup_columns[column].unit_mode;
ASSERT(0 <= column && column < BTRFS_QGROUP_ALL); UASSERT(0 <= column && column < BTRFS_QGROUP_ALL);
switch (column) { switch (column) {

4
cmds/replace.c
View File

@ -519,7 +519,7 @@ time2string(char *buf, size_t s, __u64 t)
time_t t_time_t; time_t t_time_t;
t_time_t = (time_t)t; t_time_t = (time_t)t;
ASSERT((__u64)t_time_t == t); UASSERT((__u64)t_time_t == t);
localtime_r(&t_time_t, &t_tm); localtime_r(&t_time_t, &t_tm);
strftime(buf, s, "%e.%b %T", &t_tm); strftime(buf, s, "%e.%b %T", &t_tm);
return buf; return buf;
@ -529,7 +529,7 @@ static char *
progress2string(char *buf, size_t s, int progress_1000) progress2string(char *buf, size_t s, int progress_1000)
{ {
snprintf(buf, s, "%d.%01d%%", progress_1000 / 10, progress_1000 % 10); snprintf(buf, s, "%d.%01d%%", progress_1000 / 10, progress_1000 % 10);
ASSERT(s > 0); UASSERT(s > 0);
buf[s - 1] = '\0'; buf[s - 1] = '\0';
return buf; return buf;
} }

6
cmds/rescue-chunk-recover.c
View File

@ -1455,7 +1455,7 @@ open_ctree_with_broken_chunk(struct recover_control *rc)
goto out_devices; goto out_devices;
} }
ASSERT(!memcmp(disk_super->fsid, rc->fs_devices->fsid, BTRFS_FSID_SIZE)); UASSERT(!memcmp(disk_super->fsid, rc->fs_devices->fsid, BTRFS_FSID_SIZE));
fs_info->sectorsize = btrfs_super_sectorsize(disk_super); fs_info->sectorsize = btrfs_super_sectorsize(disk_super);
fs_info->nodesize = btrfs_super_nodesize(disk_super); fs_info->nodesize = btrfs_super_nodesize(disk_super);
fs_info->stripesize = btrfs_super_stripesize(disk_super); fs_info->stripesize = btrfs_super_stripesize(disk_super);
@ -1467,7 +1467,7 @@ open_ctree_with_broken_chunk(struct recover_control *rc)
features = btrfs_super_incompat_flags(disk_super); features = btrfs_super_incompat_flags(disk_super);
if (features & BTRFS_FEATURE_INCOMPAT_METADATA_UUID) if (features & BTRFS_FEATURE_INCOMPAT_METADATA_UUID)
ASSERT(!memcmp(disk_super->metadata_uuid, UASSERT(!memcmp(disk_super->metadata_uuid,
fs_info->fs_devices->metadata_uuid, fs_info->fs_devices->metadata_uuid,
BTRFS_FSID_SIZE)); BTRFS_FSID_SIZE));
@ -1869,7 +1869,7 @@ static int check_one_csum(int fd, u64 start, u32 len, u32 tree_csum,
int csum_size = 0; int csum_size = 0;
u8 expected_csum[BTRFS_CSUM_SIZE]; u8 expected_csum[BTRFS_CSUM_SIZE];
ASSERT(0); UASSERT(0);
data = malloc(len); data = malloc(len);
if (!data) if (!data)

4
cmds/rescue.c
View File

@ -322,8 +322,8 @@ static int clear_uuid_tree(struct btrfs_fs_info *fs_info)
ret = btrfs_search_slot(trans, uuid_root, &key, &path, -1, 1); ret = btrfs_search_slot(trans, uuid_root, &key, &path, -1, 1);
if (ret < 0) if (ret < 0)
goto out; goto out;
ASSERT(ret > 0); UASSERT(ret > 0);
ASSERT(path.slots[0] == 0); UASSERT(path.slots[0] == 0);
nr = btrfs_header_nritems(path.nodes[0]); nr = btrfs_header_nritems(path.nodes[0]);
if (nr == 0) { if (nr == 0) {

20
cmds/subvolume-list.c
View File

@ -284,7 +284,7 @@ void btrfs_list_setup_print_column(enum btrfs_list_column_enum column)
{ {
int i; int i;
ASSERT(0 <= column && column <= BTRFS_LIST_ALL); UASSERT(0 <= column && column <= BTRFS_LIST_ALL);
if (column < BTRFS_LIST_ALL) { if (column < BTRFS_LIST_ALL) {
btrfs_list_columns[column].need_print = 1; btrfs_list_columns[column].need_print = 1;
@ -367,9 +367,9 @@ static int btrfs_list_setup_comparer(struct btrfs_list_comparer_set **comp_set,
struct btrfs_list_comparer_set *set = *comp_set; struct btrfs_list_comparer_set *set = *comp_set;
int size; int size;
ASSERT(set != NULL); UASSERT(set != NULL);
ASSERT(comparer < BTRFS_LIST_COMP_MAX); UASSERT(comparer < BTRFS_LIST_COMP_MAX);
ASSERT(set->ncomps <= set->total); UASSERT(set->ncomps <= set->total);
if (set->ncomps == set->total) { if (set->ncomps == set->total) {
void *tmp; void *tmp;
@ -391,7 +391,7 @@ static int btrfs_list_setup_comparer(struct btrfs_list_comparer_set **comp_set,
*comp_set = set; *comp_set = set;
} }
ASSERT(set->comps[set->ncomps].comp_func == NULL); UASSERT(set->comps[set->ncomps].comp_func == NULL);
set->comps[set->ncomps].comp_func = all_comp_funcs[comparer]; set->comps[set->ncomps].comp_func = all_comp_funcs[comparer];
set->comps[set->ncomps].is_descending = is_descending; set->comps[set->ncomps].is_descending = is_descending;
@ -1027,9 +1027,9 @@ static void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
struct btrfs_list_filter_set *set = *filter_set; struct btrfs_list_filter_set *set = *filter_set;
int size; int size;
ASSERT(set != NULL); UASSERT(set != NULL);
ASSERT(filter < BTRFS_LIST_FILTER_MAX); UASSERT(filter < BTRFS_LIST_FILTER_MAX);
ASSERT(set->nfilters <= set->total); UASSERT(set->nfilters <= set->total);
if (set->nfilters == set->total) { if (set->nfilters == set->total) {
void *tmp; void *tmp;
@ -1051,7 +1051,7 @@ static void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
*filter_set = set; *filter_set = set;
} }
ASSERT(set->filters[set->nfilters].filter_func == NULL); UASSERT(set->filters[set->nfilters].filter_func == NULL);
if (filter == BTRFS_LIST_FILTER_DELETED) if (filter == BTRFS_LIST_FILTER_DELETED)
set->only_deleted = 1; set->only_deleted = 1;
@ -1129,7 +1129,7 @@ static void print_subvolume_column(struct root_info *subv,
char tstr[256]; char tstr[256];
char uuidparse[BTRFS_UUID_UNPARSED_SIZE]; char uuidparse[BTRFS_UUID_UNPARSED_SIZE];
ASSERT(0 <= column && column < BTRFS_LIST_ALL); UASSERT(0 <= column && column < BTRFS_LIST_ALL);
switch (column) { switch (column) {
case BTRFS_LIST_OBJECTID: case BTRFS_LIST_OBJECTID:

4
common/device-utils.c
View File

@ -539,7 +539,7 @@ ssize_t btrfs_direct_pio(int rw, int fd, void *buf, size_t count, off_t offset)
int ret; int ret;
ssize_t ret_rw; ssize_t ret_rw;
ASSERT(rw == READ || rw == WRITE); UASSERT(rw == READ || rw == WRITE);
if (fstat(fd, &stat_buf) == -1) { if (fstat(fd, &stat_buf) == -1) {
error("fstat failed: %m"); error("fstat failed: %m");
@ -579,7 +579,7 @@ ssize_t btrfs_direct_pio(int rw, int fd, void *buf, size_t count, off_t offset)
} }
if (rw == WRITE) { if (rw == WRITE) {
ASSERT(iosize == count); UASSERT(iosize == count);
memcpy(bounce_buf, buf, count); memcpy(bounce_buf, buf, count);
ret_rw = pwrite(fd, bounce_buf, iosize, offset); ret_rw = pwrite(fd, bounce_buf, iosize, offset);
} else { } else {

6
common/messages.h
View File

@ -40,6 +40,12 @@
#define DO_ABORT_ON_ERROR do { } while (0) #define DO_ABORT_ON_ERROR do { } while (0)
#endif #endif
#ifndef BTRFS_DISABLE_BACKTRACE
#define UASSERT(c) assert_trace(#c, __FILE__, __func__, __LINE__, (long)(c))
#else
#define UASSERT(c) assert(c)
#endif
#define error(fmt, ...) \ #define error(fmt, ...) \
do { \ do { \
PRINT_TRACE_ON_ERROR; \ PRINT_TRACE_ON_ERROR; \

4
common/units.c
View File

@ -79,7 +79,7 @@ int pretty_size_snprintf(u64 size, char *str, size_t str_size, unsigned unit_mod
/* Unknown mode */ /* Unknown mode */
if (!base) { if (!base) {
internal_error("unknown unit base, mode %u", unit_mode); internal_error("unknown unit base, mode %u", unit_mode);
ASSERT(0); UASSERT(0);
return -1; return -1;
} }
@ -135,7 +135,7 @@ int pretty_size_snprintf(u64 size, char *str, size_t str_size, unsigned unit_mod
if (num_divs >= ARRAY_SIZE(unit_suffix_binary)) { if (num_divs >= ARRAY_SIZE(unit_suffix_binary)) {
str[0] = '\0'; str[0] = '\0';
internal_error("unsupported unit suffix, index %d", num_divs); internal_error("unsupported unit suffix, index %d", num_divs);
ASSERT(0); UASSERT(0);
return -1; return -1;
} }

4
convert/common.c
View File

@ -44,7 +44,7 @@ static int reserve_free_space(struct cache_tree *free_tree, u64 len,
struct cache_extent *cache; struct cache_extent *cache;
int found = 0; int found = 0;
ASSERT(ret_start != NULL); UASSERT(ret_start != NULL);
cache = first_cache_extent(free_tree); cache = first_cache_extent(free_tree);
while (cache) { while (cache) {
if (cache->size > len) { if (cache->size > len) {
@ -807,7 +807,7 @@ int make_convert_btrfs(int fd, struct btrfs_mkfs_config *cfg,
int ret; int ret;
/* Source filesystem must be opened, checked and analyzed in advance */ /* Source filesystem must be opened, checked and analyzed in advance */
ASSERT(!cache_tree_empty(used_space)); UASSERT(!cache_tree_empty(used_space));
/* /*
* reserve space for temporary superblock first * reserve space for temporary superblock first

2
convert/main.c
View File

@ -1167,7 +1167,7 @@ static int do_convert(const char *devname, u32 convert_flags, u32 nodesize,
if (ret) if (ret)
goto fail; goto fail;
ASSERT(cctx.total_bytes != 0); UASSERT(cctx.total_bytes != 0);
blocksize = cctx.blocksize; blocksize = cctx.blocksize;
if (blocksize < 4096) { if (blocksize < 4096) {
error("block size is too small: %u < 4096", blocksize); error("block size is too small: %u < 4096", blocksize);

2
image/main.c
View File

@ -1399,7 +1399,7 @@ static int restore_one_work(struct mdrestore_struct *mdres,
int compress_method = mdres->compress_method; int compress_method = mdres->compress_method;
int ret; int ret;
ASSERT(is_power_of_2(bufsize)); UASSERT(is_power_of_2(bufsize));
if (compress_method == COMPRESS_ZLIB) { if (compress_method == COMPRESS_ZLIB) {
strm.zalloc = Z_NULL; strm.zalloc = Z_NULL;

3
libbtrfs/send-stream.c
View File

@ -26,6 +26,7 @@
#include "libbtrfs/send-stream.h" #include "libbtrfs/send-stream.h"
#include "libbtrfs/ctree.h" #include "libbtrfs/ctree.h"
#include "libbtrfs/crc32c.h" #include "libbtrfs/crc32c.h"
#include "common/messages.h"
struct btrfs_send_stream { struct btrfs_send_stream {
char read_buf[BTRFS_SEND_BUF_SIZE]; char read_buf[BTRFS_SEND_BUF_SIZE];
@ -108,7 +109,7 @@ static int read_cmd(struct btrfs_send_stream *sctx)
memset(sctx->cmd_attrs, 0, sizeof(sctx->cmd_attrs)); memset(sctx->cmd_attrs, 0, sizeof(sctx->cmd_attrs));
ASSERT(sizeof(*sctx->cmd_hdr) <= sizeof(sctx->read_buf)); UASSERT(sizeof(*sctx->cmd_hdr) <= sizeof(sctx->read_buf));
ret = read_buf(sctx, sctx->read_buf, sizeof(*sctx->cmd_hdr)); ret = read_buf(sctx, sctx->read_buf, sizeof(*sctx->cmd_hdr));
if (ret < 0) if (ret < 0)
goto out; goto out;

4
mkfs/main.c
View File

@ -272,7 +272,7 @@ static int __recow_root(struct btrfs_trans_handle *trans, struct btrfs_root *roo
goto out; goto out;
ret = 0; ret = 0;
btrfs_item_key_to_cpu(path.nodes[0], &found_key, 0); btrfs_item_key_to_cpu(path.nodes[0], &found_key, 0);
ASSERT(btrfs_comp_cpu_keys(&key, &found_key) == 0); UASSERT(btrfs_comp_cpu_keys(&key, &found_key) == 0);
next: next:
ret = btrfs_next_leaf(root, &path); ret = btrfs_next_leaf(root, &path);
@ -782,7 +782,7 @@ static int create_uuid_tree(struct btrfs_trans_handle *trans)
}; };
int ret = 0; int ret = 0;
ASSERT(fs_info->uuid_root == NULL); UASSERT(fs_info->uuid_root == NULL);
root = btrfs_create_tree(trans, fs_info, &key); root = btrfs_create_tree(trans, fs_info, &key);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);

2
tune/convert-bgt.c
View File

@ -236,7 +236,7 @@ iterate_bgs:
* Remove block group tree, at this stage, the block group tree root * Remove block group tree, at this stage, the block group tree root
* should be empty. * should be empty.
*/ */
ASSERT(btrfs_header_nritems(fs_info->block_group_root->node) == 0); UASSERT(btrfs_header_nritems(fs_info->block_group_root->node) == 0);
ret = btrfs_delete_and_free_root(trans, fs_info->block_group_root); ret = btrfs_delete_and_free_root(trans, fs_info->block_group_root);
if (ret < 0) { if (ret < 0) {
errno = -ret; errno = -ret;