u64 root;
u64 generation;
u64 owner;
- u64 offset;
u32 num_refs;
u32 found_ref;
int found_extent_tree;
if (!print_errs)
goto out;
fprintf(stderr, "Backref %llu parent %llu"
- " [%llu %llu %llu %llu %lu]"
+ " [%llu %llu %llu %lu]"
" not found in extent tree\n",
(unsigned long long)rec->start,
(unsigned long long)back->parent,
(unsigned long long)back->root,
(unsigned long long)back->generation,
(unsigned long long)back->owner,
- (unsigned long long)back->offset,
(unsigned long)back->num_refs);
}
if (!back->found_ref) {
if (!print_errs)
goto out;
fprintf(stderr, "Backref %llu parent %llu"
- " [%llu %llu %llu %llu %lu]"
+ " [%llu %llu %llu %lu]"
" not referenced\n",
(unsigned long long)rec->start,
(unsigned long long)back->parent,
(unsigned long long)back->root,
(unsigned long long)back->generation,
(unsigned long long)back->owner,
- (unsigned long long)back->offset,
(unsigned long)back->num_refs);
}
if (back->found_ref != back->num_refs) {
static struct extent_backref *alloc_backref(struct extent_record *rec,
u64 parent, u64 root, u64 gen,
- u64 owner, u64 owner_offset)
+ u64 owner)
{
struct extent_backref *ref = malloc(sizeof(*ref));
ref->parent = parent;
ref->root = root;
ref->generation = gen;
ref->owner = owner;
- ref->offset = owner_offset;
ref->num_refs = 0;
ref->found_extent_tree = 0;
ref->found_ref = 0;
static int add_backref(struct cache_tree *extent_cache, u64 bytenr,
u64 parent, u64 root, u64 gen, u64 owner,
- u64 owner_offset, u32 num_refs, int found_ref)
+ u32 num_refs, int found_ref)
{
struct extent_record *rec;
struct extent_backref *back;
}
back = find_backref(rec, parent, root, gen);
if (!back)
- back = alloc_backref(rec, parent, root, gen, owner,
- owner_offset);
+ back = alloc_backref(rec, parent, root, gen, owner);
if (found_ref) {
if (back->found_ref > 0 &&
back->owner < BTRFS_FIRST_FREE_OBJECTID) {
fprintf(stderr, "Extent back ref already exists "
"for %llu parent %llu root %llu gen %llu "
- "owner %llu offset %llu num_refs %lu\n",
+ "owner %llu num_refs %lu\n",
(unsigned long long)parent,
(unsigned long long)bytenr,
(unsigned long long)root,
(unsigned long long)gen,
(unsigned long long)owner,
- (unsigned long long)owner_offset,
(unsigned long)num_refs);
}
BUG_ON(num_refs != 1);
if (back->found_extent_tree) {
fprintf(stderr, "Extent back ref already exists "
"for %llu parent %llu root %llu gen %llu "
- "owner %llu offset %llu num_refs %lu\n",
+ "owner %llu num_refs %lu\n",
(unsigned long long)parent,
(unsigned long long)bytenr,
(unsigned long long)root,
(unsigned long long)gen,
(unsigned long long)owner,
- (unsigned long long)owner_offset,
(unsigned long)num_refs);
}
back->num_refs = num_refs;
btrfs_ref_root(buf, ref),
btrfs_ref_generation(buf, ref),
btrfs_ref_objectid(buf, ref),
- btrfs_ref_offset(buf, ref),
btrfs_ref_num_refs(buf, ref), 0);
continue;
}
buf->start,
btrfs_header_owner(buf),
btrfs_header_generation(buf),
- btrfs_disk_key_objectid(&disk_key),
- btrfs_disk_key_offset(&disk_key), 1, 1);
+ btrfs_disk_key_objectid(&disk_key), 1, 1);
BUG_ON(ret);
}
} else {
add_backref(extent_cache, ptr, buf->start,
btrfs_header_owner(buf),
btrfs_header_generation(buf),
- level - 1, 0, 1, 1);
+ level - 1, 1, 1);
if (level > 1) {
add_pending(nodes, seen, ptr, size);
add_backref(extent_cache, buf->start, buf->start, root_objectid,
btrfs_header_generation(buf),
- btrfs_header_level(buf), 0, 1, 1);
+ btrfs_header_level(buf), 1, 1);
return 0;
}
__le64 root;
__le64 generation;
__le64 objectid;
- __le64 offset;
__le32 num_refs;
} __attribute__ ((__packed__));
BTRFS_SETGET_FUNCS(ref_root, struct btrfs_extent_ref, root, 64);
BTRFS_SETGET_FUNCS(ref_generation, struct btrfs_extent_ref, generation, 64);
BTRFS_SETGET_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64);
-BTRFS_SETGET_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 64);
BTRFS_SETGET_FUNCS(ref_num_refs, struct btrfs_extent_ref, num_refs, 32);
BTRFS_SETGET_STACK_FUNCS(stack_ref_root, struct btrfs_extent_ref, root, 64);
generation, 64);
BTRFS_SETGET_STACK_FUNCS(stack_ref_objectid, struct btrfs_extent_ref,
objectid, 64);
-BTRFS_SETGET_STACK_FUNCS(stack_ref_offset, struct btrfs_extent_ref,
- offset, 64);
BTRFS_SETGET_STACK_FUNCS(stack_ref_num_refs, struct btrfs_extent_ref,
num_refs, 32);
int level,
u64 hint,
u64 empty_size);
-int btrfs_grow_extent_tree(struct btrfs_trans_handle *trans,
- struct btrfs_root *root, u64 new_size);
-int btrfs_shrink_extent_tree(struct btrfs_root *root, u64 new_size);
-int btrfs_insert_extent_backref(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_path *path,
- u64 bytenr, u64 parent,
- u64 root_objectid, u64 ref_generation,
- u64 owner, u64 owner_offset);
int btrfs_alloc_extent(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
u64 num_bytes, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner, u64 owner_offset,
- u64 empty_size, u64 hint_byte,
+ u64 owner, u64 empty_size, u64 hint_byte,
u64 search_end, struct btrfs_key *ins, int data);
int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
struct extent_buffer *orig_buf, struct extent_buffer *buf,
int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 bytenr, u64 num_bytes, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset, int pin);
+ u64 owner_objectid, int pin);
int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct extent_io_tree *unpin);
struct btrfs_root *root,
u64 bytenr, u64 num_bytes, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner, u64 owner_offset);
+ u64 owner_objectid);
int btrfs_update_extent_ref(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u64 bytenr,
u64 orig_parent, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset);
+ u64 owner_objectid);
int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
struct btrfs_root *root);
int btrfs_free_block_groups(struct btrfs_fs_info *info);
static int noinline lookup_extent_backref(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
- struct btrfs_path *path, u64 bytenr,
- u64 parent, u64 ref_root,
- u64 ref_generation, int del)
+ struct btrfs_path *path,
+ u64 bytenr, u64 parent,
+ u64 ref_root, u64 ref_generation,
+ u64 owner_objectid, int del)
{
struct btrfs_key key;
struct btrfs_extent_ref *ref;
struct extent_buffer *leaf;
+ u64 ref_objectid;
int ret;
key.objectid = bytenr;
leaf = path->nodes[0];
ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_ref);
+ ref_objectid = btrfs_ref_objectid(leaf, ref);
if (btrfs_ref_root(leaf, ref) != ref_root ||
- btrfs_ref_generation(leaf, ref) != ref_generation) {
+ btrfs_ref_generation(leaf, ref) != ref_generation ||
+ (ref_objectid != owner_objectid &&
+ ref_objectid != BTRFS_MULTIPLE_OBJECTIDS)) {
ret = -EIO;
WARN_ON(1);
goto out;
struct btrfs_path *path,
u64 bytenr, u64 parent,
u64 ref_root, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset)
+ u64 owner_objectid)
{
struct btrfs_key key;
struct extent_buffer *leaf;
btrfs_set_ref_root(leaf, ref, ref_root);
btrfs_set_ref_generation(leaf, ref, ref_generation);
btrfs_set_ref_objectid(leaf, ref, owner_objectid);
- btrfs_set_ref_offset(leaf, ref, owner_offset);
btrfs_set_ref_num_refs(leaf, ref, 1);
} else if (ret == -EEXIST) {
u64 existing_owner;
btrfs_set_ref_num_refs(leaf, ref, num_refs + 1);
existing_owner = btrfs_ref_objectid(leaf, ref);
- if (existing_owner == owner_objectid &&
- btrfs_ref_offset(leaf, ref) > owner_offset) {
- btrfs_set_ref_offset(leaf, ref, owner_offset);
- } else if (existing_owner != owner_objectid &&
- existing_owner != BTRFS_MULTIPLE_OBJECTIDS) {
+ if (existing_owner != owner_objectid &&
+ existing_owner != BTRFS_MULTIPLE_OBJECTIDS) {
btrfs_set_ref_objectid(leaf, ref,
BTRFS_MULTIPLE_OBJECTIDS);
- btrfs_set_ref_offset(leaf, ref, 0);
}
ret = 0;
} else {
u64 orig_parent, u64 parent,
u64 orig_root, u64 ref_root,
u64 orig_generation, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset)
+ u64 owner_objectid)
{
int ret;
struct btrfs_root *extent_root = root->fs_info->extent_root;
return -ENOMEM;
ret = lookup_extent_backref(trans, extent_root, path,
bytenr, orig_parent, orig_root,
- orig_generation, 1);
+ orig_generation, owner_objectid, 1);
if (ret)
goto out;
ret = remove_extent_backref(trans, extent_root, path);
goto out;
ret = insert_extent_backref(trans, extent_root, path, bytenr,
parent, ref_root, ref_generation,
- owner_objectid, owner_offset);
+ owner_objectid);
BUG_ON(ret);
finish_current_insert(trans, extent_root);
del_pending_extents(trans, extent_root);
struct btrfs_root *root, u64 bytenr,
u64 orig_parent, u64 parent,
u64 ref_root, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset)
+ u64 owner_objectid)
{
int ret;
if (ref_root == BTRFS_TREE_LOG_OBJECTID &&
ret = __btrfs_update_extent_ref(trans, root, bytenr, orig_parent,
parent, ref_root, ref_root,
ref_generation, ref_generation,
- owner_objectid, owner_offset);
+ owner_objectid);
maybe_unlock_mutex(root);
return ret;
}
u64 orig_parent, u64 parent,
u64 orig_root, u64 ref_root,
u64 orig_generation, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset)
+ u64 owner_objectid)
{
struct btrfs_path *path;
int ret;
ret = insert_extent_backref(trans, root->fs_info->extent_root,
path, bytenr, parent,
ref_root, ref_generation,
- owner_objectid, owner_offset);
+ owner_objectid);
BUG_ON(ret);
finish_current_insert(trans, root->fs_info->extent_root);
del_pending_extents(trans, root->fs_info->extent_root);
struct btrfs_root *root,
u64 bytenr, u64 num_bytes, u64 parent,
u64 ref_root, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset)
+ u64 owner_objectid)
{
int ret;
if (ref_root == BTRFS_TREE_LOG_OBJECTID &&
maybe_lock_mutex(root);
ret = __btrfs_inc_extent_ref(trans, root, bytenr, 0, parent,
0, ref_root, 0, ref_generation,
- owner_objectid, owner_offset);
+ owner_objectid);
maybe_unlock_mutex(root);
return ret;
}
int ret = 0;
int faili = 0;
int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
- u64, u64, u64, u64, u64, u64, u64, u64, u64);
+ u64, u64, u64, u64, u64, u64, u64, u64);
ref_root = btrfs_header_owner(buf);
ref_generation = btrfs_header_generation(buf);
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
- key.objectid, key.offset);
+ key.objectid);
maybe_unlock_mutex(root);
if (ret) {
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
- level - 1, 0);
+ level - 1);
maybe_unlock_mutex(root);
if (ret) {
faili = i;
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
- key.objectid, key.offset);
+ key.objectid);
maybe_unlock_mutex(root);
if (ret)
goto fail;
orig_buf->start, buf->start,
orig_root, ref_root,
orig_generation, ref_generation,
- level - 1, 0);
+ level - 1);
maybe_unlock_mutex(root);
if (ret)
goto fail;
start, extent_op->parent,
extent_root->root_key.objectid,
extent_op->generation,
- extent_op->level, 0);
+ extent_op->level);
BUG_ON(err);
} else if (extent_op->type == PENDING_BACKREF_UPDATE) {
err = lookup_extent_backref(trans, extent_root, path,
start, extent_op->orig_parent,
extent_root->root_key.objectid,
- extent_op->orig_generation, 0);
+ extent_op->orig_generation,
+ extent_op->level, 0);
BUG_ON(err);
clear_extent_bits(&info->extent_ins, start, end,
static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 bytenr, u64 num_bytes, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset, int pin,
- int mark_free)
+ u64 owner_objectid, int pin, int mark_free)
{
struct btrfs_path *path;
struct btrfs_key key;
if (!path)
return -ENOMEM;
- ret = lookup_extent_backref(trans, extent_root, path, bytenr, parent,
- root_objectid, ref_generation, 1);
+ ret = lookup_extent_backref(trans, extent_root, path,
+ bytenr, parent, root_objectid,
+ ref_generation, owner_objectid, 1);
if (ret == 0) {
struct btrfs_key found_key;
extent_slot = path->slots[0];
} else {
btrfs_print_leaf(extent_root, path->nodes[0]);
printk("Unable to find ref byte nr %llu root %llu "
- " gen %llu owner %llu offset %llu\n",
+ " gen %llu owner %llu\n",
(unsigned long long)bytenr,
(unsigned long long)root_objectid,
(unsigned long long)ref_generation,
- (unsigned long long)owner_objectid,
- (unsigned long long)owner_offset);
+ (unsigned long long)owner_objectid);
BUG_ON(1);
}
extent_op->orig_parent,
extent_root->root_key.objectid,
extent_op->orig_generation,
- extent_op->level, 0, 0, mark_free);
+ extent_op->level, 0, mark_free);
kfree(extent_op);
} else {
kfree(extent_op);
int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root
*root, u64 bytenr, u64 num_bytes, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner_objectid, u64 owner_offset, int pin)
+ u64 owner_objectid, int pin)
{
struct btrfs_root *extent_root = root->fs_info->extent_root;
int pending_ret;
}
ret = __free_extent(trans, root, bytenr, num_bytes, parent,
root_objectid, ref_generation,
- owner_objectid, owner_offset, pin, pin == 0);
+ owner_objectid, pin, pin == 0);
pending_ret = del_pending_extents(trans, root->fs_info->extent_root);
return ret ? ret : pending_ret;
}
struct btrfs_root *root,
u64 num_bytes, u64 parent,
u64 root_objectid, u64 ref_generation,
- u64 owner, u64 owner_offset,
- u64 empty_size, u64 hint_byte,
+ u64 owner, u64 empty_size, u64 hint_byte,
u64 search_end, struct btrfs_key *ins, int data)
{
int ret;
btrfs_set_ref_root(path->nodes[0], ref, root_objectid);
btrfs_set_ref_generation(path->nodes[0], ref, ref_generation);
btrfs_set_ref_objectid(path->nodes[0], ref, owner);
- btrfs_set_ref_offset(path->nodes[0], ref, owner_offset);
btrfs_set_ref_num_refs(path->nodes[0], ref, 1);
btrfs_mark_buffer_dirty(path->nodes[0]);
ret = btrfs_alloc_extent(trans, root, blocksize, parent,
root_objectid, ref_generation,
- level, 0, empty_size, hint,
+ level, empty_size, hint,
(u64)-1, &ins, 0);
if (ret) {
BUG_ON(ret > 0);
parent = ins.objectid;
btrfs_free_extent(trans, root, ins.objectid, blocksize,
parent, root->root_key.objectid,
- ref_generation, 0, 0, 0);
+ ref_generation, level, 0);
BUG_ON(1);
return ERR_PTR(-ENOMEM);
}
ret = btrfs_free_extent(trans, root, disk_bytenr,
btrfs_file_extent_disk_num_bytes(leaf, fi),
leaf->start, leaf_owner, leaf_generation,
- key.objectid, key.offset, 0);
+ key.objectid, 0);
BUG_ON(ret);
}
return 0;
path->slots[*level]++;
ret = btrfs_free_extent(trans, root, bytenr, blocksize,
parent->start, root_owner,
- root_gen, 0, 0, 1);
+ root_gen, *level - 1, 1);
BUG_ON(ret);
continue;
}
next = read_tree_block(root, bytenr, blocksize,
ptr_gen);
mutex_lock(&root->fs_info->fs_mutex);
-
- /* we dropped the lock, check one more time */
- ret = lookup_extent_ref(trans, root, bytenr,
- blocksize, &refs);
- BUG_ON(ret);
- if (refs != 1) {
- parent = path->nodes[*level];
- root_owner = btrfs_header_owner(parent);
- root_gen = btrfs_header_generation(parent);
-
- path->slots[*level]++;
- free_extent_buffer(next);
- ret = btrfs_free_extent(trans, root, bytenr,
- blocksize, parent->start,
- root_owner, root_gen, 0, 0, 1);
- BUG_ON(ret);
- continue;
- }
}
WARN_ON(*level <= 0);
if (path->nodes[*level-1])
root_gen = btrfs_header_generation(parent);
ret = btrfs_free_extent(trans, root, path->nodes[*level]->start,
path->nodes[*level]->len, parent->start,
- root_owner, root_gen, 0, 0, 1);
+ root_owner, root_gen, *level, 1);
free_extent_buffer(path->nodes[*level]);
path->nodes[*level] = NULL;
*level += 1;
path->nodes[*level]->start,
path->nodes[*level]->len,
parent->start, root_owner,
- root_gen, 0, 0, 1);
+ root_gen, *level, 1);
BUG_ON(ret);
free_extent_buffer(path->nodes[*level]);
path->nodes[*level] = NULL;