Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7bb86316 authored by Chris Mason's avatar Chris Mason
Browse files

Btrfs: Add back pointers from extents to the btree or file referencing them 



Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parent 74493f7a

fs/btrfs/ctree.c

+176 −20
Original line number Diff line number Diff line
@@ -77,13 +77,37 @@ static int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
			     struct extent_buffer **cow_ret,

			     u64 search_start, u64 empty_size)

{

	u64 root_gen;

	struct extent_buffer *cow;

	u32 nritems;

	int ret = 0;

	int different_trans = 0;

	int level;

	struct btrfs_key first_key;



	if (root->ref_cows) {

		root_gen = trans->transid;

	} else {

		root_gen = 0;

	}



	WARN_ON(root->ref_cows && trans->transid !=

		root->fs_info->running_transaction->transid);

	WARN_ON(root->ref_cows && trans->transid != root->last_trans);



	cow = btrfs_alloc_free_block(trans, root, buf->len,

	level = btrfs_header_level(buf);

	nritems = btrfs_header_nritems(buf);

	if (nritems) {

		if (level == 0)

			btrfs_item_key_to_cpu(buf, &first_key, 0);

		else

			btrfs_node_key_to_cpu(buf, &first_key, 0);

	} else {

		first_key.objectid = 0;

	}

	cow = __btrfs_alloc_free_block(trans, root, buf->len,

				     root->root_key.objectid,

				     root_gen, first_key.objectid, level,

				     search_start, empty_size);

	if (IS_ERR(cow))

		return PTR_ERR(cow);
@@ -104,14 +128,17 @@ static int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
	}



	if (buf == root->node) {

		root_gen = btrfs_header_generation(buf);

		root->node = cow;

		extent_buffer_get(cow);

		if (buf != root->commit_root) {

			btrfs_free_extent(trans, root, buf->start,

					  buf->len, 1);

					  buf->len, root->root_key.objectid,

					  root_gen, 0, 0, 1);

		}

		free_extent_buffer(buf);

	} else {

		root_gen = btrfs_header_generation(parent);

		btrfs_set_node_blockptr(parent, parent_slot,

					cow->start);

		WARN_ON(trans->transid == 0);
@@ -119,7 +146,9 @@ static int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
					      trans->transid);

		btrfs_mark_buffer_dirty(parent);

		WARN_ON(btrfs_header_generation(parent) != trans->transid);

		btrfs_free_extent(trans, root, buf->start, buf->len, 1);

		btrfs_free_extent(trans, root, buf->start, buf->len,

				  btrfs_header_owner(parent), root_gen,

				  0, 0, 1);

	}

	free_extent_buffer(buf);

	btrfs_mark_buffer_dirty(cow);
@@ -606,6 +635,8 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root 
		return 0;



	mid = path->nodes[level];

	WARN_ON(btrfs_header_generation(mid) != trans->transid);



	orig_ptr = btrfs_node_blockptr(mid, orig_slot);



	if (level < BTRFS_MAX_LEVEL - 1)
@@ -631,7 +662,9 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root 
		wait_on_tree_block_writeback(root, mid);

		/* once for the path */

		free_extent_buffer(mid);

		ret = btrfs_free_extent(trans, root, mid->start, mid->len, 1);

		ret = btrfs_free_extent(trans, root, mid->start, mid->len,

					root->root_key.objectid,

					btrfs_header_generation(mid), 0, 0, 1);

		/* once for the root ptr */

		free_extent_buffer(mid);

		return ret;
@@ -681,6 +714,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root 
			ret = wret;

		if (btrfs_header_nritems(right) == 0) {

			u64 bytenr = right->start;

			u64 generation = btrfs_header_generation(parent);

			u32 blocksize = right->len;



			clean_tree_block(trans, root, right);
@@ -692,7 +726,9 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root 
			if (wret)

				ret = wret;

			wret = btrfs_free_extent(trans, root, bytenr,

						 blocksize, 1);

						 blocksize,

						 btrfs_header_owner(parent),

						 generation, 0, 0, 1);

			if (wret)

				ret = wret;

		} else {
@@ -722,6 +758,7 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root 
	}

	if (btrfs_header_nritems(mid) == 0) {

		/* we've managed to empty the middle node, drop it */

		u64 root_gen = btrfs_header_generation(parent);

		u64 bytenr = mid->start;

		u32 blocksize = mid->len;

		clean_tree_block(trans, root, mid);
@@ -731,7 +768,9 @@ static int balance_level(struct btrfs_trans_handle *trans, struct btrfs_root 
		wret = del_ptr(trans, root, path, level + 1, pslot);

		if (wret)

			ret = wret;

		wret = btrfs_free_extent(trans, root, bytenr, blocksize, 1);

		wret = btrfs_free_extent(trans, root, bytenr, blocksize,

					 btrfs_header_owner(parent),

					 root_gen, 0, 0, 1);

		if (wret)

			ret = wret;

	} else {
@@ -788,6 +827,7 @@ static int push_nodes_for_insert(struct btrfs_trans_handle *trans, 
		return 1;



	mid = path->nodes[level];

	WARN_ON(btrfs_header_generation(mid) != trans->transid);

	orig_ptr = btrfs_node_blockptr(mid, orig_slot);



	if (level < BTRFS_MAX_LEVEL - 1)
@@ -1113,6 +1153,8 @@ static int push_node_left(struct btrfs_trans_handle *trans, struct btrfs_root 
	src_nritems = btrfs_header_nritems(src);

	dst_nritems = btrfs_header_nritems(dst);

	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;

	WARN_ON(btrfs_header_generation(src) != trans->transid);

	WARN_ON(btrfs_header_generation(dst) != trans->transid);



	if (push_items <= 0) {

		return 1;
@@ -1159,6 +1201,9 @@ static int balance_node_right(struct btrfs_trans_handle *trans, 
	int dst_nritems;

	int ret = 0;



	WARN_ON(btrfs_header_generation(src) != trans->transid);

	WARN_ON(btrfs_header_generation(dst) != trans->transid);



	src_nritems = btrfs_header_nritems(src);

	dst_nritems = btrfs_header_nritems(dst);

	push_items = BTRFS_NODEPTRS_PER_BLOCK(root) - dst_nritems;
@@ -1202,6 +1247,8 @@ static int insert_new_root(struct btrfs_trans_handle *trans, 
			   struct btrfs_root *root,

			   struct btrfs_path *path, int level)

{

	u64 root_gen;

	u64 lower_gen;

	struct extent_buffer *lower;

	struct extent_buffer *c;

	struct btrfs_disk_key lower_key;
@@ -1209,7 +1256,20 @@ static int insert_new_root(struct btrfs_trans_handle *trans, 
	BUG_ON(path->nodes[level]);

	BUG_ON(path->nodes[level-1] != root->node);



	c = btrfs_alloc_free_block(trans, root, root->nodesize,

	if (root->ref_cows)

		root_gen = trans->transid;

	else

		root_gen = 0;



	lower = path->nodes[level-1];

	if (level == 1)

		btrfs_item_key(lower, &lower_key, 0);

	else

		btrfs_node_key(lower, &lower_key, 0);



	c = __btrfs_alloc_free_block(trans, root, root->nodesize,

				   root->root_key.objectid,

				   root_gen, lower_key.objectid, level,

				   root->node->start, 0);

	if (IS_ERR(c))

		return PTR_ERR(c);
@@ -1219,19 +1279,16 @@ static int insert_new_root(struct btrfs_trans_handle *trans, 
	btrfs_set_header_bytenr(c, c->start);

	btrfs_set_header_generation(c, trans->transid);

	btrfs_set_header_owner(c, root->root_key.objectid);

	lower = path->nodes[level-1];



	write_extent_buffer(c, root->fs_info->fsid,

			    (unsigned long)btrfs_header_fsid(c),

			    BTRFS_FSID_SIZE);

	if (level == 1)

		btrfs_item_key(lower, &lower_key, 0);

	else

		btrfs_node_key(lower, &lower_key, 0);

	btrfs_set_node_key(c, &lower_key, 0);

	btrfs_set_node_blockptr(c, 0, lower->start);

	WARN_ON(btrfs_header_generation(lower) == 0);

	btrfs_set_node_ptr_generation(c, 0, btrfs_header_generation(lower));

	lower_gen = btrfs_header_generation(lower);

	WARN_ON(lower_gen == 0);



	btrfs_set_node_ptr_generation(c, 0, lower_gen);



	btrfs_mark_buffer_dirty(c);
@@ -1241,6 +1298,18 @@ static int insert_new_root(struct btrfs_trans_handle *trans, 
	extent_buffer_get(c);

	path->nodes[level] = c;

	path->slots[level] = 0;



	if (root->ref_cows && lower_gen != trans->transid) {

		struct btrfs_path *back_path = btrfs_alloc_path();

		int ret;

		ret = btrfs_insert_extent_backref(trans,

						  root->fs_info->extent_root,

						  path, lower->start,

						  root->root_key.objectid,

						  trans->transid, 0, 0);

		BUG_ON(ret);

		btrfs_free_path(back_path);

	}

	return 0;

}
@@ -1294,6 +1363,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root 
static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root

		      *root, struct btrfs_path *path, int level)

{

	u64 root_gen;

	struct extent_buffer *c;

	struct extent_buffer *split;

	struct btrfs_disk_key disk_key;
@@ -1303,6 +1373,7 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root 
	u32 c_nritems;



	c = path->nodes[level];

	WARN_ON(btrfs_header_generation(c) != trans->transid);

	if (c == root->node) {

		/* trying to split the root, lets make a new one */

		ret = insert_new_root(trans, root, path, level + 1);
@@ -1319,8 +1390,17 @@ static int split_node(struct btrfs_trans_handle *trans, struct btrfs_root 
	}



	c_nritems = btrfs_header_nritems(c);

	split = btrfs_alloc_free_block(trans, root, root->nodesize,

				       c->start, 0);

	if (root->ref_cows)

		root_gen = trans->transid;

	else

		root_gen = 0;



	btrfs_node_key(c, &disk_key, 0);

	split = __btrfs_alloc_free_block(trans, root, root->nodesize,

					 root->root_key.objectid,

					 root_gen,

					 btrfs_disk_key_objectid(&disk_key),

					 level, c->start, 0);

	if (IS_ERR(split))

		return PTR_ERR(split);
@@ -1789,6 +1869,7 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root 
		      *root, struct btrfs_key *ins_key,

		      struct btrfs_path *path, int data_size, int extend)

{

	u64 root_gen;

	struct extent_buffer *l;

	u32 nritems;

	int mid;
@@ -1807,6 +1888,11 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root 
	if (extend)

		space_needed = data_size;



	if (root->ref_cows)

		root_gen = trans->transid;

	else

		root_gen = 0;



	/* first try to make some room by pushing left and right */

	if (ins_key->type != BTRFS_DIR_ITEM_KEY) {

		wret = push_leaf_right(trans, root, path, data_size, 0);
@@ -1837,7 +1923,11 @@ static int split_leaf(struct btrfs_trans_handle *trans, struct btrfs_root 
	nritems = btrfs_header_nritems(l);

	mid = (nritems + 1)/ 2;



	right = btrfs_alloc_free_block(trans, root, root->leafsize,

	btrfs_item_key(l, &disk_key, 0);



	right = __btrfs_alloc_free_block(trans, root, root->leafsize,

					 root->root_key.objectid,

					 root_gen, disk_key.objectid, 0,

					 l->start, 0);

	if (IS_ERR(right))

		return PTR_ERR(right);
@@ -2413,13 +2503,16 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		if (leaf == root->node) {

			btrfs_set_header_level(leaf, 0);

		} else {

			u64 root_gen = btrfs_header_generation(path->nodes[1]);

			clean_tree_block(trans, root, leaf);

			wait_on_tree_block_writeback(root, leaf);

			wret = del_ptr(trans, root, path, 1, path->slots[1]);

			if (wret)

				ret = wret;

			wret = btrfs_free_extent(trans, root,

						 leaf->start, leaf->len, 1);

					 leaf->start, leaf->len,

					 btrfs_header_owner(path->nodes[1]),

					 root_gen, 0, 0, 1);

			if (wret)

				ret = wret;

		}
@@ -2456,9 +2549,13 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
			}



			if (btrfs_header_nritems(leaf) == 0) {

				u64 root_gen;

				u64 bytenr = leaf->start;

				u32 blocksize = leaf->len;



				root_gen = btrfs_header_generation(

							   path->nodes[1]);



				clean_tree_block(trans, root, leaf);

				wait_on_tree_block_writeback(root, leaf);
@@ -2468,7 +2565,9 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 


				free_extent_buffer(leaf);

				wret = btrfs_free_extent(trans, root, bytenr,

							 blocksize, 1);

					     blocksize,

					     btrfs_header_owner(path->nodes[1]),

					     root_gen, 0, 0, 1);

				if (wret)

					ret = wret;

			} else {
@@ -2482,6 +2581,61 @@ int btrfs_del_item(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
	return ret;

}



/*

 * walk up the tree as far as required to find the previous leaf.

 * returns 0 if it found something or 1 if there are no lesser leaves.

 * returns < 0 on io errors.

 */

int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)

{

	int slot;

	int level = 1;

	u64 bytenr;

	struct extent_buffer *c;

	struct extent_buffer *next = NULL;



	while(level < BTRFS_MAX_LEVEL) {

		if (!path->nodes[level])

			return 1;



		slot = path->slots[level];

		c = path->nodes[level];

		if (slot == 0) {

			level++;

			if (level == BTRFS_MAX_LEVEL)

				return 1;

			continue;

		}

		slot--;



		bytenr = btrfs_node_blockptr(c, slot);

		if (next)

			free_extent_buffer(next);



		if (path->reada < 0)

			reada_for_search(root, path, level, slot);



		next = read_tree_block(root, bytenr,

				       btrfs_level_size(root, level - 1));

		break;

	}

	path->slots[level] = slot;

	while(1) {

		level--;

		c = path->nodes[level];

		free_extent_buffer(c);

		path->nodes[level] = next;

		path->slots[level] = 0;

		if (!level)

			break;

		if (path->reada)

			reada_for_search(root, path, level, 0);

		next = read_tree_block(root, btrfs_node_blockptr(next, 0),

				       btrfs_level_size(root, level - 1));

	}

	return 0;

}



/*

 * walk up the tree as far as required to find the next leaf.

 * returns 0 if it found something or 1 if there are no greater leaves.
@@ -2503,6 +2657,8 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path) 
		c = path->nodes[level];

		if (slot >= btrfs_header_nritems(c)) {

			level++;

			if (level == BTRFS_MAX_LEVEL)

				return 1;

			continue;

		}

fs/btrfs/ctree.h

+32 −9
Original line number Diff line number Diff line
@@ -544,11 +544,12 @@ 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_STACK_FUNCS(ref_root, struct btrfs_extent_ref, root, 64);

BTRFS_SETGET_STACK_FUNCS(ref_generation, struct btrfs_extent_ref,

BTRFS_SETGET_STACK_FUNCS(stack_ref_root, struct btrfs_extent_ref, root, 64);

BTRFS_SETGET_STACK_FUNCS(stack_ref_generation, struct btrfs_extent_ref,

			 generation, 64);

BTRFS_SETGET_STACK_FUNCS(ref_objectid, struct btrfs_extent_ref, objectid, 64);

BTRFS_SETGET_STACK_FUNCS(ref_offset, struct btrfs_extent_ref, offset, 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_extent_refs, struct btrfs_extent_item,

			 refs, 32);
@@ -914,24 +915,45 @@ struct btrfs_block_group_cache *btrfs_find_block_group(struct btrfs_root *root, 
						 *hint, u64 search_start,

						 int data, int owner);

int btrfs_inc_root_ref(struct btrfs_trans_handle *trans,

		       struct btrfs_root *root);

		       struct btrfs_root *root, u64 owner_objectid);

struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,

					    struct btrfs_root *root, u32 size,

					    u64 root_objectid,

					    u64 hint, u64 empty_size);

struct extent_buffer *__btrfs_alloc_free_block(struct btrfs_trans_handle *trans,

					     struct btrfs_root *root,

					     u32 blocksize,

					     u64 root_objectid,

					     u64 ref_generation,

					     u64 first_objectid,

					     int level,

					     u64 hint,

					     u64 empty_size);

int btrfs_insert_extent_backref(struct btrfs_trans_handle *trans,

				 struct btrfs_root *root,

				 struct btrfs_path *path, u64 bytenr,

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

		       u64 num_bytes, u64 empty_size, u64 search_start,

		       struct btrfs_root *root,

		       u64 num_bytes, u64 root_objectid, u64 ref_generation,

		       u64 owner, u64 owner_offset,

		       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 *buf);

int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root

		      *root, u64 bytenr, u64 num_bytes, int pin);

		      *root, u64 bytenr, u64 num_bytes,

		      u64 root_objectid, u64 ref_generation,

		      u64 owner_objectid, u64 owner_offset, int pin);

int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,

			       struct btrfs_root *root,

			       struct extent_map_tree *unpin);

int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,

				struct btrfs_root *root,

				u64 bytenr, u64 num_bytes);

				u64 bytenr, u64 num_bytes,

				u64 root_objectid, u64 ref_generation,

				u64 owner, u64 owner_offset);

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);
@@ -966,6 +988,7 @@ int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, struct btrfs_root 
			    *root, struct btrfs_path *path, struct btrfs_key

			    *cpu_key, u32 data_size);

int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);

int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);

int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);

int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root

			*root);

fs/btrfs/disk-io.c

+1 −1
Original line number Diff line number Diff line
@@ -210,7 +210,7 @@ static int btree_writepages(struct address_space *mapping, 
{

	struct extent_map_tree *tree;

	tree = &BTRFS_I(mapping->host)->extent_tree;

	if (wbc->sync_mode == WB_SYNC_NONE) {

	if (0 && wbc->sync_mode == WB_SYNC_NONE) {

		u64 num_dirty;

		u64 start = 0;

		unsigned long thresh = 96 * 1024 * 1024;

fs/btrfs/extent-tree.c

+311 −62

File changed.

Preview size limit exceeded, changes collapsed.

fs/btrfs/file.c

+17 −3
Original line number Diff line number Diff line
@@ -496,7 +496,10 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, 
						   sizeof(old));

				if (disk_bytenr != 0) {

					ret = btrfs_inc_extent_ref(trans, root,

					         disk_bytenr, disk_num_bytes);

					         disk_bytenr, disk_num_bytes,

						 root->root_key.objectid,

						 trans->transid,

						 key.objectid, end);

					BUG_ON(ret);

				}

			}
@@ -541,6 +544,14 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, 
			u64 disk_bytenr = 0;

			u64 disk_num_bytes = 0;

			u64 extent_num_bytes = 0;

			u64 root_gen;



			if (leaf != root->node) {

				root_gen =

					btrfs_header_generation(path->nodes[1]);

			} else {

				root_gen = btrfs_header_generation(leaf);

			}

			if (found_extent) {

				disk_bytenr =

				      btrfs_file_extent_disk_bytenr(leaf,
@@ -563,7 +574,10 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, 
				inode->i_blocks -= extent_num_bytes >> 9;

				ret = btrfs_free_extent(trans, root,

						disk_bytenr,

							disk_num_bytes, 0);

						disk_num_bytes,

						root->root_key.objectid,

						root_gen, inode->i_ino,

						key.offset, 0);

			}



			BUG_ON(ret);