RepoMirrors/btrfs-progs
1
0
Fork 0
mirror of https://github.com/kdave/btrfs-progs synced 2025-04-01 22:48:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

btrfs-progs: check: refactor add_extent_rec, reduce argument count

Browse Source 
Similar to add_extent_rec_nolookup, pass the arguments via a temporary
structure. In case the extent is found, some of the values are not
assigned directly so the semantics is preserved.

Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
David Sterba 2016-04-01 17:46:10 +02:00
parent 5b1bbc8924
commit b241a46c7c
1 changed files with 78 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
cmds-check.c
View File

@ -4559,33 +4559,39 @@ static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
return ret; return ret;
} }
/*
* Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
* some are hints:
* - refs - if found, increase refs
* - is_root - if found, set
* - content_checked - if found, set
* - owner_ref_checked - if found, set
*
* If not found, create a new one, initialize and insert.
*/
static int add_extent_rec(struct cache_tree *extent_cache, static int add_extent_rec(struct cache_tree *extent_cache,
struct btrfs_key *parent_key, u64 parent_gen, struct extent_record *tmpl)
u64 start, u64 nr, u64 extent_item_refs,
int is_root, int inc_ref, int set_checked,
int metadata, int extent_rec, u64 max_size)
{ {
struct extent_record *rec; struct extent_record *rec;
struct cache_extent *cache; struct cache_extent *cache;
struct extent_record tmpl;
int ret = 0; int ret = 0;
int dup = 0; int dup = 0;
cache = lookup_cache_extent(extent_cache, start, nr); cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
if (cache) { if (cache) {
rec = container_of(cache, struct extent_record, cache); rec = container_of(cache, struct extent_record, cache);
if (inc_ref) if (tmpl->refs)
rec->refs++; rec->refs++;
if (rec->nr == 1) if (rec->nr == 1)
rec->nr = max(nr, max_size); rec->nr = max(tmpl->nr, tmpl->max_size);
/* /*
* We need to make sure to reset nr to whatever the extent * We need to make sure to reset nr to whatever the extent
* record says was the real size, this way we can compare it to * record says was the real size, this way we can compare it to
* the backrefs. * the backrefs.
*/ */
if (extent_rec) { if (tmpl->found_rec) {
if (start != rec->start || rec->found_rec) { if (tmpl->start != rec->start || rec->found_rec) {
struct extent_record *tmp; struct extent_record *tmp;
dup = 1; dup = 1;
@ -4602,46 +4608,44 @@ static int add_extent_rec(struct cache_tree *extent_cache,
tmp = malloc(sizeof(*tmp)); tmp = malloc(sizeof(*tmp));
if (!tmp) if (!tmp)
return -ENOMEM; return -ENOMEM;
tmp->start = start; tmp->start = tmpl->start;
tmp->max_size = max_size; tmp->max_size = tmpl->max_size;
tmp->nr = nr; tmp->nr = tmpl->nr;
tmp->found_rec = 1; tmp->found_rec = 1;
tmp->metadata = metadata; tmp->metadata = tmpl->metadata;
tmp->extent_item_refs = extent_item_refs; tmp->extent_item_refs = tmpl->extent_item_refs;
INIT_LIST_HEAD(&tmp->list); INIT_LIST_HEAD(&tmp->list);
list_add_tail(&tmp->list, &rec->dups); list_add_tail(&tmp->list, &rec->dups);
rec->num_duplicates++; rec->num_duplicates++;
} else { } else {
rec->nr = nr; rec->nr = tmpl->nr;
rec->found_rec = 1; rec->found_rec = 1;
} }
} }
if (extent_item_refs && !dup) { if (tmpl->extent_item_refs && !dup) {
if (rec->extent_item_refs) { if (rec->extent_item_refs) {
fprintf(stderr, "block %llu rec " fprintf(stderr, "block %llu rec "
"extent_item_refs %llu, passed %llu\n", "extent_item_refs %llu, passed %llu\n",
(unsigned long long)start, (unsigned long long)tmpl->start,
(unsigned long long) (unsigned long long)
rec->extent_item_refs, rec->extent_item_refs,
(unsigned long long)extent_item_refs); (unsigned long long)tmpl->extent_item_refs);
} }
rec->extent_item_refs = extent_item_refs; rec->extent_item_refs = tmpl->extent_item_refs;
} }
if (is_root) if (tmpl->is_root)
rec->is_root = 1; rec->is_root = 1;
if (set_checked) { if (tmpl->content_checked)
rec->content_checked = 1; rec->content_checked = 1;
if (tmpl->owner_ref_checked)
rec->owner_ref_checked = 1; rec->owner_ref_checked = 1;
} memcpy(&rec->parent_key, &tmpl->parent_key,
sizeof(tmpl->parent_key));
if (parent_key) if (tmpl->parent_generation)
btrfs_cpu_key_to_disk(&rec->parent_key, parent_key); rec->parent_generation = tmpl->parent_generation;
if (parent_gen) if (rec->max_size < tmpl->max_size)
rec->parent_generation = parent_gen; rec->max_size = tmpl->max_size;
if (rec->max_size < max_size)
rec->max_size = max_size;
/* /*
* A metadata extent can't cross stripe_len boundary, otherwise * A metadata extent can't cross stripe_len boundary, otherwise
@ -4649,7 +4653,7 @@ static int add_extent_rec(struct cache_tree *extent_cache,
* As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
* it. * it.
*/ */
if (metadata) if (tmpl->metadata)
rec->crossing_stripes = check_crossing_stripes( rec->crossing_stripes = check_crossing_stripes(
rec->start, rec->max_size); rec->start, rec->max_size);
check_extent_type(rec); check_extent_type(rec);
@ -4657,23 +4661,7 @@ static int add_extent_rec(struct cache_tree *extent_cache,
return ret; return ret;
} }
memset(&tmpl, 0, sizeof(tmpl)); ret = add_extent_rec_nolookup(extent_cache, tmpl);
if (parent_key)
btrfs_cpu_key_to_disk(&tmpl.parent_key, parent_key);
tmpl.parent_generation = parent_gen;
tmpl.start = start;
tmpl.nr = nr;
tmpl.extent_item_refs = extent_item_refs;
tmpl.is_root = is_root;
tmpl.metadata = metadata;
tmpl.found_rec = extent_rec;
tmpl.max_size = max_size;
tmpl.content_checked = set_checked;
tmpl.owner_ref_checked = set_checked;
tmpl.refs = !!inc_ref;
ret = add_extent_rec_nolookup(extent_cache, &tmpl);
return ret; return ret;
} }
@ -5219,6 +5207,7 @@ static int process_extent_item(struct btrfs_root *root,
struct btrfs_extent_data_ref *dref; struct btrfs_extent_data_ref *dref;
struct btrfs_shared_data_ref *sref; struct btrfs_shared_data_ref *sref;
struct btrfs_key key; struct btrfs_key key;
struct extent_record tmpl;
unsigned long end; unsigned long end;
unsigned long ptr; unsigned long ptr;
int type; int type;
@ -5246,9 +5235,15 @@ static int process_extent_item(struct btrfs_root *root,
#else #else
BUG(); BUG();
#endif #endif
return add_extent_rec(extent_cache, NULL, 0, key.objectid, memset(&tmpl, 0, sizeof(tmpl));
num_bytes, refs, 0, 0, 0, metadata, 1, tmpl.start = key.objectid;
num_bytes); tmpl.nr = num_bytes;
tmpl.extent_item_refs = refs;
tmpl.metadata = metadata;
tmpl.found_rec = 1;
tmpl.max_size = num_bytes;
return add_extent_rec(extent_cache, &tmpl);
} }
ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item); ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
@ -5258,8 +5253,14 @@ static int process_extent_item(struct btrfs_root *root,
else else
metadata = 0; metadata = 0;
add_extent_rec(extent_cache, NULL, 0, key.objectid, num_bytes, memset(&tmpl, 0, sizeof(tmpl));
refs, 0, 0, 0, metadata, 1, num_bytes); tmpl.start = key.objectid;
tmpl.nr = num_bytes;
tmpl.extent_item_refs = refs;
tmpl.metadata = metadata;
tmpl.found_rec = 1;
tmpl.max_size = num_bytes;
add_extent_rec(extent_cache, &tmpl);
ptr = (unsigned long)(ei + 1); ptr = (unsigned long)(ei + 1);
if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK && if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
@ -6222,6 +6223,8 @@ static int run_next_block(struct btrfs_root *root,
btrfs_item_key_to_cpu(buf, &first_key, 0); btrfs_item_key_to_cpu(buf, &first_key, 0);
level = btrfs_header_level(buf); level = btrfs_header_level(buf);
for (i = 0; i < nritems; i++) { for (i = 0; i < nritems; i++) {
struct extent_record tmpl;
ptr = btrfs_node_blockptr(buf, i); ptr = btrfs_node_blockptr(buf, i);
size = root->nodesize; size = root->nodesize;
btrfs_node_key_to_cpu(buf, &key, i); btrfs_node_key_to_cpu(buf, &key, i);
@ -6231,10 +6234,16 @@ static int run_next_block(struct btrfs_root *root,
continue; continue;
} }
} }
ret = add_extent_rec(extent_cache, &key,
btrfs_node_ptr_generation(buf, i), memset(&tmpl, 0, sizeof(tmpl));
ptr, size, 0, 0, 1, 0, 1, 0, btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
size); tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
tmpl.start = ptr;
tmpl.nr = size;
tmpl.refs = 1;
tmpl.metadata = 1;
tmpl.max_size = size;
ret = add_extent_rec(extent_cache, &tmpl);
BUG_ON(ret); BUG_ON(ret);
add_tree_backref(extent_cache, ptr, parent, owner, 1); add_tree_backref(extent_cache, ptr, parent, owner, 1);
@ -6270,12 +6279,21 @@ static int add_root_to_pending(struct extent_buffer *buf,
struct cache_tree *nodes, struct cache_tree *nodes,
u64 objectid) u64 objectid)
{ {
struct extent_record tmpl;
if (btrfs_header_level(buf) > 0) if (btrfs_header_level(buf) > 0)
add_pending(nodes, seen, buf->start, buf->len); add_pending(nodes, seen, buf->start, buf->len);
else else
add_pending(pending, seen, buf->start, buf->len); add_pending(pending, seen, buf->start, buf->len);
add_extent_rec(extent_cache, NULL, 0, buf->start, buf->len,
0, 1, 1, 0, 1, 0, buf->len); memset(&tmpl, 0, sizeof(tmpl));
tmpl.start = buf->start;
tmpl.nr = buf->len;
tmpl.is_root = 1;
tmpl.refs = 1;
tmpl.metadata = 1;
tmpl.max_size = buf->len;
add_extent_rec(extent_cache, &tmpl);
if (objectid == BTRFS_TREE_RELOC_OBJECTID || if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV) btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)