u64 info_objectid;
u32 num_duplicates;
u8 info_level;
+ int flag_block_full_backref;
unsigned int found_rec:1;
unsigned int content_checked:1;
unsigned int owner_ref_checked:1;
unsigned int is_root:1;
unsigned int metadata:1;
- unsigned int flag_block_full_backref:1;
+ unsigned int bad_full_backref:1;
};
struct inode_backref {
struct list_head list;
u64 objectid;
u64 bytenr;
+ u64 last_snapshot;
u8 level;
u8 drop_level;
int level_size;
{
if (rec->content_checked && rec->owner_ref_checked &&
rec->extent_item_refs == rec->refs && rec->refs > 0 &&
- rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0)) {
+ rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
+ !rec->bad_full_backref) {
remove_cache_extent(extent_cache, &rec->cache);
free_all_extent_backrefs(rec);
list_del_init(&rec->list);
rec->owner_ref_checked = 0;
rec->num_duplicates = 0;
rec->metadata = metadata;
+ rec->flag_block_full_backref = -1;
+ rec->bad_full_backref = 0;
INIT_LIST_HEAD(&rec->backrefs);
INIT_LIST_HEAD(&rec->dups);
INIT_LIST_HEAD(&rec->list);
return 0;
}
+/*
+ * Here are the rules for FULL_BACKREF.
+ *
+ * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
+ * 2) If btrfs_header_owner(buf) no longer points to buf then we have
+ * FULL_BACKREF set.
+ * 3) We cow'ed the block walking down a reloc tree. This is impossible to tell
+ * if it happened after the relocation occurred since we'll have dropped the
+ * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
+ * have no real way to know for sure.
+ *
+ * We process the blocks one root at a time, and we start from the lowest root
+ * objectid and go to the highest. So we can just lookup the owner backref for
+ * the record and if we don't find it then we know it doesn't exist and we have
+ * a FULL BACKREF.
+ *
+ * FIXME: if we ever start reclaiming root objectid's then we need to fix this
+ * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
+ * be set or not and then we can check later once we've gathered all the refs.
+ */
static int calc_extent_flag(struct btrfs_root *root,
struct cache_tree *extent_cache,
struct extent_buffer *buf,
struct root_item_record *ri,
u64 *flags)
{
- int i;
- int nritems = btrfs_header_nritems(buf);
- struct btrfs_key key;
struct extent_record *rec;
struct cache_extent *cache;
- struct data_backref *dback;
struct tree_backref *tback;
- struct extent_buffer *new_buf;
u64 owner = 0;
- u64 bytenr;
- u64 offset;
- u64 ptr;
- int size;
- int ret;
- u8 level;
+
+ cache = lookup_cache_extent(extent_cache, buf->start, 1);
+ /* we have added this extent before */
+ BUG_ON(!cache);
+ rec = container_of(cache, struct extent_record, cache);
/*
* Except file/reloc tree, we can not have
*/
if (buf->start == ri->bytenr)
goto normal;
- if (btrfs_is_leaf(buf)) {
- /*
- * we are searching from original root, world
- * peace is achieved, we use normal backref.
- */
- owner = btrfs_header_owner(buf);
- if (owner == ri->objectid)
- goto normal;
- /*
- * we check every eb here, and if any of
- * eb dosen't have original root refers
- * to this eb, we set full backref flag for
- * this extent, otherwise normal backref.
- */
- for (i = 0; i < nritems; i++) {
- struct btrfs_file_extent_item *fi;
- btrfs_item_key_to_cpu(buf, &key, i);
- if (key.type != BTRFS_EXTENT_DATA_KEY)
- continue;
- fi = btrfs_item_ptr(buf, i,
- struct btrfs_file_extent_item);
- if (btrfs_file_extent_type(buf, fi) ==
- BTRFS_FILE_EXTENT_INLINE)
- continue;
- if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
- continue;
- bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
- cache = lookup_cache_extent(extent_cache, bytenr, 1);
- if (!cache)
- goto full_backref;
- offset = btrfs_file_extent_offset(buf, fi);
- rec = container_of(cache, struct extent_record, cache);
- dback = find_data_backref(rec, 0, ri->objectid, owner,
- key.offset - offset, 1, bytenr, bytenr);
- if (!dback)
- goto full_backref;
- }
+ if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
goto full_backref;
- } else {
- level = btrfs_header_level(buf);
- for (i = 0; i < nritems; i++) {
- ptr = btrfs_node_blockptr(buf, i);
- size = btrfs_level_size(root, level);
- if (i == 0) {
- new_buf = read_tree_block(root, ptr, size, 0);
- if (!extent_buffer_uptodate(new_buf)) {
- free_extent_buffer(new_buf);
- ret = -EIO;
- return ret;
- }
- /*
- * we are searching from origin root, world
- * peace is achieved, we use normal backref.
- */
- owner = btrfs_header_owner(new_buf);
- free_extent_buffer(new_buf);
- if (owner == ri->objectid)
- goto normal;
- }
- cache = lookup_cache_extent(extent_cache, ptr, size);
- if (!cache)
- goto full_backref;
- rec = container_of(cache, struct extent_record, cache);
- tback = find_tree_backref(rec, 0, owner);
- if (!tback)
- goto full_backref;
- }
- }
+ owner = btrfs_header_owner(buf);
+ if (owner == ri->objectid)
+ goto normal;
+
+ tback = find_tree_backref(rec, 0, owner);
+ if (!tback)
+ goto full_backref;
normal:
*flags = 0;
- cache = lookup_cache_extent(extent_cache, buf->start, 1);
- /* we have added this extent before */
- BUG_ON(!cache);
- rec = container_of(cache, struct extent_record, cache);
- rec->flag_block_full_backref = 0;
+ if (rec->flag_block_full_backref != -1 &&
+ rec->flag_block_full_backref != 0)
+ rec->bad_full_backref = 1;
return 0;
full_backref:
*flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
- cache = lookup_cache_extent(extent_cache, buf->start, 1);
- /* we have added this extent before */
- BUG_ON(!cache);
- rec = container_of(cache, struct extent_record, cache);
- rec->flag_block_full_backref = 1;
+ if (rec->flag_block_full_backref != -1 &&
+ rec->flag_block_full_backref != 1)
+ rec->bad_full_backref = 1;
return 0;
}
nritems = btrfs_header_nritems(buf);
- /*
- * FIXME, this only works only if we don't have any full
- * backref mode.
- */
flags = 0;
if (!init_extent_tree) {
ret = btrfs_lookup_extent_info(NULL, root, bytenr,
}
if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
- if (rec)
- rec->flag_block_full_backref = 1;
+ if (ri != NULL &&
+ ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
+ ri->objectid == btrfs_header_owner(buf)) {
+ /*
+ * Ok we got to this block from it's original owner and
+ * we have FULL_BACKREF set. Relocation can leave
+ * converted blocks over so this is altogether possible,
+ * however it's not possible if the generation > the
+ * last snapshot, so check for this case.
+ */
+ if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
+ btrfs_header_generation(buf) > ri->last_snapshot) {
+ flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
+ rec->bad_full_backref = 1;
+ }
+ }
+ } else {
+ if (ri != NULL &&
+ (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
+ btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
+ flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
+ rec->bad_full_backref = 1;
+ }
+ }
+
+ if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
+ rec->flag_block_full_backref = 1;
parent = bytenr;
owner = 0;
} else {
+ rec->flag_block_full_backref = 0;
parent = 0;
owner = btrfs_header_owner(buf);
}
parent, tback->root, 0, 0);
fprintf(stderr, "adding new tree backref on "
"start %llu len %llu parent %llu root %llu\n",
- rec->start, rec->max_size, tback->parent, tback->root);
+ rec->start, rec->max_size, parent, tback->root);
}
if (ret)
goto fail;
if (!back->found_ref)
continue;
+ rec->bad_full_backref = 0;
ret = record_extent(trans, info, path, rec, back, allocated, flags);
allocated = 1;
return ret;
}
+static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
+ struct extent_record *rec)
+{
+ struct btrfs_trans_handle *trans;
+ struct btrfs_root *root = fs_info->extent_root;
+ struct btrfs_path *path;
+ struct btrfs_extent_item *ei;
+ struct btrfs_key key;
+ u64 flags;
+ int ret = 0;
+
+ key.objectid = rec->start;
+ if (rec->metadata) {
+ key.type = BTRFS_METADATA_ITEM_KEY;
+ key.offset = rec->info_level;
+ } else {
+ key.type = BTRFS_EXTENT_ITEM_KEY;
+ key.offset = rec->max_size;
+ }
+
+ path = btrfs_alloc_path();
+ if (!path)
+ return -ENOMEM;
+
+ trans = btrfs_start_transaction(root, 0);
+ if (IS_ERR(trans)) {
+ btrfs_free_path(path);
+ return PTR_ERR(trans);
+ }
+
+ ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
+ if (ret < 0) {
+ btrfs_free_path(path);
+ btrfs_commit_transaction(trans, root);
+ return ret;
+ } else if (ret) {
+ fprintf(stderr, "Didn't find extent for %llu\n",
+ (unsigned long long)rec->start);
+ btrfs_free_path(path);
+ btrfs_commit_transaction(trans, root);
+ return -ENOENT;
+ }
+
+ ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
+ struct btrfs_extent_item);
+ flags = btrfs_extent_flags(path->nodes[0], ei);
+ if (rec->flag_block_full_backref) {
+ fprintf(stderr, "setting full backref on %llu\n",
+ (unsigned long long)key.objectid);
+ flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
+ } else {
+ fprintf(stderr, "clearing full backref on %llu\n",
+ (unsigned long long)key.objectid);
+ flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
+ }
+ btrfs_set_extent_flags(path->nodes[0], ei, flags);
+ btrfs_mark_buffer_dirty(path->nodes[0]);
+ btrfs_free_path(path);
+ return btrfs_commit_transaction(trans, root);
+}
+
/* right now we only prune from the extent allocation tree */
static int prune_one_block(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *info,
err = 1;
cur_err = 1;
}
+ if (rec->bad_full_backref) {
+ fprintf(stderr, "bad full backref, on [%llu]\n",
+ (unsigned long long)rec->start);
+ if (repair) {
+ ret = fixup_extent_flags(root->fs_info, rec);
+ if (ret)
+ goto repair_abort;
+ fixed = 1;
+ }
+ err = 1;
+ cur_err = 1;
+ }
remove_cache_extent(extent_cache, cache);
free_all_extent_backrefs(rec);
}
static int add_root_item_to_list(struct list_head *head,
- u64 objectid, u64 bytenr,
+ u64 objectid, u64 bytenr, u64 last_snapshot,
u8 level, u8 drop_level,
int level_size, struct btrfs_key *drop_key)
{
ri_rec->level = level;
ri_rec->level_size = level_size;
ri_rec->drop_level = drop_level;
+ ri_rec->last_snapshot = last_snapshot;
if (drop_key)
memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
list_add_tail(&ri_rec->list, head);
root1 = root->fs_info->tree_root;
level = btrfs_header_level(root1->node);
ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
- root1->node->start, level, 0,
+ root1->node->start, 0, level, 0,
btrfs_level_size(root1, level), NULL);
if (ret < 0)
goto out;
root1 = root->fs_info->chunk_root;
level = btrfs_header_level(root1->node);
ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
- root1->node->start, level, 0,
+ root1->node->start, 0, level, 0,
btrfs_level_size(root1, level), NULL);
if (ret < 0)
goto out;
btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
if (btrfs_key_type(&found_key) == BTRFS_ROOT_ITEM_KEY) {
unsigned long offset;
+ u64 last_snapshot;
offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
read_extent_buffer(leaf, &ri, offset, sizeof(ri));
+ last_snapshot = btrfs_root_last_snapshot(&ri);
if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
level = btrfs_root_level(&ri);
level_size = btrfs_level_size(root, level);
ret = add_root_item_to_list(&normal_trees,
found_key.objectid,
- btrfs_root_bytenr(&ri), level,
+ btrfs_root_bytenr(&ri),
+ last_snapshot, level,
0, level_size, NULL);
if (ret < 0)
goto out;
ret = add_root_item_to_list(&dropping_trees,
objectid,
btrfs_root_bytenr(&ri),
- level, ri.drop_level,
+ last_snapshot, level,
+ ri.drop_level,
level_size, &found_key);
if (ret < 0)
goto out;
projects / platform / upstream / btrfs-progs.git / commitdiff