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

Commit 105a048a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable 

* git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable: (27 commits)
  Btrfs: add more error checking to btrfs_dirty_inode
  Btrfs: allow unaligned DIO
  Btrfs: drop verbose enospc printk
  Btrfs: Fix block generation verification race
  Btrfs: fix preallocation and nodatacow checks in O_DIRECT
  Btrfs: avoid ENOSPC errors in btrfs_dirty_inode
  Btrfs: move O_DIRECT space reservation to btrfs_direct_IO
  Btrfs: rework O_DIRECT enospc handling
  Btrfs: use async helpers for DIO write checksumming
  Btrfs: don't walk around with task->state != TASK_RUNNING
  Btrfs: do aio_write instead of write
  Btrfs: add basic DIO read/write support
  direct-io: do not merge logically non-contiguous requests
  direct-io: add a hook for the fs to provide its own submit_bio function
  fs: allow short direct-io reads to be completed via buffered IO
  Btrfs: Metadata ENOSPC handling for balance
  Btrfs: Pre-allocate space for data relocation
  Btrfs: Metadata ENOSPC handling for tree log
  Btrfs: Metadata reservation for orphan inodes
  Btrfs: Introduce global metadata reservation
  ...
parents 00b9b0af 9aeead73

fs/btrfs/async-thread.c

+1 −0
Original line number Diff line number Diff line
@@ -377,6 +377,7 @@ static int worker_loop(void *arg) 
				if (!list_empty(&worker->pending) ||

				    !list_empty(&worker->prio_pending)) {

					spin_unlock_irq(&worker->lock);

					set_current_state(TASK_RUNNING);

					goto again;

				}

fs/btrfs/btrfs_inode.h

+2 −1
Original line number Diff line number Diff line
@@ -137,8 +137,8 @@ struct btrfs_inode { 
	 * of extent items we've reserved metadata for.

	 */

	spinlock_t accounting_lock;

	atomic_t outstanding_extents;

	int reserved_extents;

	int outstanding_extents;



	/*

	 * ordered_data_close is set by truncate when a file that used
@@ -151,6 +151,7 @@ struct btrfs_inode { 
	 * of these.

	 */

	unsigned ordered_data_close:1;

	unsigned orphan_meta_reserved:1;

	unsigned dummy_inode:1;



	/*

fs/btrfs/ctree.c

+67 −42
Original line number Diff line number Diff line
@@ -280,7 +280,8 @@ int btrfs_block_can_be_shared(struct btrfs_root *root, 
static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans,

				       struct btrfs_root *root,

				       struct extent_buffer *buf,

				       struct extent_buffer *cow)

				       struct extent_buffer *cow,

				       int *last_ref)

{

	u64 refs;

	u64 owner;
@@ -366,6 +367,7 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
			BUG_ON(ret);

		}

		clean_tree_block(trans, root, buf);

		*last_ref = 1;

	}

	return 0;

}
@@ -392,6 +394,7 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
	struct btrfs_disk_key disk_key;

	struct extent_buffer *cow;

	int level;

	int last_ref = 0;

	int unlock_orig = 0;

	u64 parent_start;
@@ -442,7 +445,10 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
			    (unsigned long)btrfs_header_fsid(cow),

			    BTRFS_FSID_SIZE);



	update_ref_for_cow(trans, root, buf, cow);

	update_ref_for_cow(trans, root, buf, cow, &last_ref);



	if (root->ref_cows)

		btrfs_reloc_cow_block(trans, root, buf, cow);



	if (buf == root->node) {

		WARN_ON(parent && parent != buf);
@@ -457,8 +463,8 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
		extent_buffer_get(cow);

		spin_unlock(&root->node_lock);



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

				parent_start, root->root_key.objectid, level);

		btrfs_free_tree_block(trans, root, buf, parent_start,

				      last_ref);

		free_extent_buffer(buf);

		add_root_to_dirty_list(root);

	} else {
@@ -473,8 +479,8 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, 
		btrfs_set_node_ptr_generation(parent, parent_slot,

					      trans->transid);

		btrfs_mark_buffer_dirty(parent);

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

				parent_start, root->root_key.objectid, level);

		btrfs_free_tree_block(trans, root, buf, parent_start,

				      last_ref);

	}

	if (unlock_orig)

		btrfs_tree_unlock(buf);
@@ -949,6 +955,22 @@ int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key, 
	return bin_search(eb, key, level, slot);

}



static void root_add_used(struct btrfs_root *root, u32 size)

{

	spin_lock(&root->accounting_lock);

	btrfs_set_root_used(&root->root_item,

			    btrfs_root_used(&root->root_item) + size);

	spin_unlock(&root->accounting_lock);

}



static void root_sub_used(struct btrfs_root *root, u32 size)

{

	spin_lock(&root->accounting_lock);

	btrfs_set_root_used(&root->root_item,

			    btrfs_root_used(&root->root_item) - size);

	spin_unlock(&root->accounting_lock);

}



/* given a node and slot number, this reads the blocks it points to.  The

 * extent buffer is returned with a reference taken (but unlocked).

 * NULL is returned on error.
@@ -1019,7 +1041,11 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		btrfs_tree_lock(child);

		btrfs_set_lock_blocking(child);

		ret = btrfs_cow_block(trans, root, child, mid, 0, &child);

		BUG_ON(ret);

		if (ret) {

			btrfs_tree_unlock(child);

			free_extent_buffer(child);

			goto enospc;

		}



		spin_lock(&root->node_lock);

		root->node = child;
@@ -1034,11 +1060,12 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		btrfs_tree_unlock(mid);

		/* once for the path */

		free_extent_buffer(mid);

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

					    0, root->root_key.objectid, level);



		root_sub_used(root, mid->len);

		btrfs_free_tree_block(trans, root, mid, 0, 1);

		/* once for the root ptr */

		free_extent_buffer(mid);

		return ret;

		return 0;

	}

	if (btrfs_header_nritems(mid) >

	    BTRFS_NODEPTRS_PER_BLOCK(root) / 4)
@@ -1088,23 +1115,16 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		if (wret < 0 && wret != -ENOSPC)

			ret = wret;

		if (btrfs_header_nritems(right) == 0) {

			u64 bytenr = right->start;

			u32 blocksize = right->len;



			clean_tree_block(trans, root, right);

			btrfs_tree_unlock(right);

			free_extent_buffer(right);

			right = NULL;

			wret = del_ptr(trans, root, path, level + 1, pslot +

				       1);

			if (wret)

				ret = wret;

			wret = btrfs_free_tree_block(trans, root,

						     bytenr, blocksize, 0,

						     root->root_key.objectid,

						     level);

			if (wret)

				ret = wret;

			root_sub_used(root, right->len);

			btrfs_free_tree_block(trans, root, right, 0, 1);

			free_extent_buffer(right);

			right = NULL;

		} else {

			struct btrfs_disk_key right_key;

			btrfs_node_key(right, &right_key, 0);
@@ -1136,21 +1156,15 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		BUG_ON(wret == 1);

	}

	if (btrfs_header_nritems(mid) == 0) {

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

		u64 bytenr = mid->start;

		u32 blocksize = mid->len;



		clean_tree_block(trans, root, mid);

		btrfs_tree_unlock(mid);

		free_extent_buffer(mid);

		mid = NULL;

		wret = del_ptr(trans, root, path, level + 1, pslot);

		if (wret)

			ret = wret;

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

					 0, root->root_key.objectid, level);

		if (wret)

			ret = wret;

		root_sub_used(root, mid->len);

		btrfs_free_tree_block(trans, root, mid, 0, 1);

		free_extent_buffer(mid);

		mid = NULL;

	} else {

		/* update the parent key to reflect our changes */

		struct btrfs_disk_key mid_key;
@@ -1590,7 +1604,7 @@ read_block_for_search(struct btrfs_trans_handle *trans, 
	btrfs_release_path(NULL, p);



	ret = -EAGAIN;

	tmp = read_tree_block(root, blocknr, blocksize, gen);

	tmp = read_tree_block(root, blocknr, blocksize, 0);

	if (tmp) {

		/*

		 * If the read above didn't mark this buffer up to date,
@@ -1740,7 +1754,6 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root 
					      p->nodes[level + 1],

					      p->slots[level + 1], &b);

			if (err) {

				free_extent_buffer(b);

				ret = err;

				goto done;

			}
@@ -2076,6 +2089,8 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans, 
	if (IS_ERR(c))

		return PTR_ERR(c);



	root_add_used(root, root->nodesize);



	memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));

	btrfs_set_header_nritems(c, 1);

	btrfs_set_header_level(c, level);
@@ -2134,6 +2149,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root 
	int nritems;



	BUG_ON(!path->nodes[level]);

	btrfs_assert_tree_locked(path->nodes[level]);

	lower = path->nodes[level];

	nritems = btrfs_header_nritems(lower);

	BUG_ON(slot > nritems);
@@ -2202,6 +2218,8 @@ static noinline int split_node(struct btrfs_trans_handle *trans, 
	if (IS_ERR(split))

		return PTR_ERR(split);



	root_add_used(root, root->nodesize);



	memset_extent_buffer(split, 0, 0, sizeof(struct btrfs_header));

	btrfs_set_header_level(split, btrfs_header_level(c));

	btrfs_set_header_bytenr(split, split->start);
@@ -2415,6 +2433,9 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans, 


	if (left_nritems)

		btrfs_mark_buffer_dirty(left);

	else

		clean_tree_block(trans, root, left);



	btrfs_mark_buffer_dirty(right);



	btrfs_item_key(right, &disk_key, 0);
@@ -2660,6 +2681,8 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans, 
	btrfs_mark_buffer_dirty(left);

	if (right_nritems)

		btrfs_mark_buffer_dirty(right);

	else

		clean_tree_block(trans, root, right);



	btrfs_item_key(right, &disk_key, 0);

	wret = fixup_low_keys(trans, root, path, &disk_key, 1);
@@ -2669,8 +2692,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans, 
	/* then fixup the leaf pointer in the path */

	if (path->slots[0] < push_items) {

		path->slots[0] += old_left_nritems;

		if (btrfs_header_nritems(path->nodes[0]) == 0)

			clean_tree_block(trans, root, path->nodes[0]);

		btrfs_tree_unlock(path->nodes[0]);

		free_extent_buffer(path->nodes[0]);

		path->nodes[0] = left;
@@ -2932,10 +2953,10 @@ static noinline int split_leaf(struct btrfs_trans_handle *trans, 
	right = btrfs_alloc_free_block(trans, root, root->leafsize, 0,

					root->root_key.objectid,

					&disk_key, 0, l->start, 0);

	if (IS_ERR(right)) {

		BUG_ON(1);

	if (IS_ERR(right))

		return PTR_ERR(right);

	}



	root_add_used(root, root->leafsize);



	memset_extent_buffer(right, 0, 0, sizeof(struct btrfs_header));

	btrfs_set_header_bytenr(right, right->start);
@@ -3054,7 +3075,8 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, 


	btrfs_set_path_blocking(path);

	ret = split_leaf(trans, root, &key, path, ins_len, 1);

	BUG_ON(ret);

	if (ret)

		goto err;



	path->keep_locks = 0;

	btrfs_unlock_up_safe(path, 1);
@@ -3796,9 +3818,10 @@ static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans, 
	 */

	btrfs_unlock_up_safe(path, 0);



	ret = btrfs_free_tree_block(trans, root, leaf->start, leaf->len,

				    0, root->root_key.objectid, 0);

	return ret;

	root_sub_used(root, leaf->len);



	btrfs_free_tree_block(trans, root, leaf, 0, 1);

	return 0;

}

/*

 * delete the item at the leaf level in path.  If that empties
@@ -3865,6 +3888,8 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		if (leaf == root->node) {

			btrfs_set_header_level(leaf, 0);

		} else {

			btrfs_set_path_blocking(path);

			clean_tree_block(trans, root, leaf);

			ret = btrfs_del_leaf(trans, root, path, leaf);

			BUG_ON(ret);

		}

fs/btrfs/ctree.h

+122 −41
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 


struct btrfs_trans_handle;

struct btrfs_transaction;

struct btrfs_pending_snapshot;

extern struct kmem_cache *btrfs_trans_handle_cachep;

extern struct kmem_cache *btrfs_transaction_cachep;

extern struct kmem_cache *btrfs_bit_radix_cachep;
@@ -663,6 +664,7 @@ struct btrfs_csum_item { 
#define BTRFS_BLOCK_GROUP_RAID1    (1 << 4)

#define BTRFS_BLOCK_GROUP_DUP	   (1 << 5)

#define BTRFS_BLOCK_GROUP_RAID10   (1 << 6)

#define BTRFS_NR_RAID_TYPES	   5



struct btrfs_block_group_item {

	__le64 used;
@@ -674,42 +676,46 @@ struct btrfs_space_info { 
	u64 flags;



	u64 total_bytes;	/* total bytes in the space */

	u64 bytes_used;		/* total bytes used on disk */

	u64 bytes_used;		/* total bytes used,

				   this does't take mirrors into account */

	u64 bytes_pinned;	/* total bytes pinned, will be freed when the

				   transaction finishes */

	u64 bytes_reserved;	/* total bytes the allocator has reserved for

				   current allocations */

	u64 bytes_readonly;	/* total bytes that are read only */

	u64 bytes_super;	/* total bytes reserved for the super blocks */

	u64 bytes_root;		/* the number of bytes needed to commit a

				   transaction */



	u64 bytes_may_use;	/* number of bytes that may be used for

				   delalloc/allocations */

	u64 bytes_delalloc;	/* number of bytes currently reserved for

				   delayed allocation */

	u64 disk_used;		/* total bytes used on disk */



	int full;		/* indicates that we cannot allocate any more

				   chunks for this space */

	int force_alloc;	/* set if we need to force a chunk alloc for

				   this space */

	int force_delalloc;	/* make people start doing filemap_flush until

				   we're under a threshold */



	struct list_head list;



	/* for controlling how we free up space for allocations */

	wait_queue_head_t allocate_wait;

	wait_queue_head_t flush_wait;

	int allocating_chunk;

	int flushing;



	/* for block groups in our same type */

	struct list_head block_groups;

	struct list_head block_groups[BTRFS_NR_RAID_TYPES];

	spinlock_t lock;

	struct rw_semaphore groups_sem;

	atomic_t caching_threads;

};



struct btrfs_block_rsv {

	u64 size;

	u64 reserved;

	u64 freed[2];

	struct btrfs_space_info *space_info;

	struct list_head list;

	spinlock_t lock;

	atomic_t usage;

	unsigned int priority:8;

	unsigned int durable:1;

	unsigned int refill_used:1;

	unsigned int full:1;

};



/*

 * free clusters are used to claim free space in relatively large chunks,

 * allowing us to do less seeky writes.  They are used for all metadata
@@ -760,6 +766,7 @@ struct btrfs_block_group_cache { 
	spinlock_t lock;

	u64 pinned;

	u64 reserved;

	u64 reserved_pinned;

	u64 bytes_super;

	u64 flags;

	u64 sectorsize;
@@ -825,6 +832,22 @@ struct btrfs_fs_info { 
	/* logical->physical extent mapping */

	struct btrfs_mapping_tree mapping_tree;



	/* block reservation for extent, checksum and root tree */

	struct btrfs_block_rsv global_block_rsv;

	/* block reservation for delay allocation */

	struct btrfs_block_rsv delalloc_block_rsv;

	/* block reservation for metadata operations */

	struct btrfs_block_rsv trans_block_rsv;

	/* block reservation for chunk tree */

	struct btrfs_block_rsv chunk_block_rsv;



	struct btrfs_block_rsv empty_block_rsv;



	/* list of block reservations that cross multiple transactions */

	struct list_head durable_block_rsv_list;



	struct mutex durable_block_rsv_mutex;



	u64 generation;

	u64 last_trans_committed;
@@ -927,7 +950,6 @@ struct btrfs_fs_info { 
	struct btrfs_workers endio_meta_write_workers;

	struct btrfs_workers endio_write_workers;

	struct btrfs_workers submit_workers;

	struct btrfs_workers enospc_workers;

	/*

	 * fixup workers take dirty pages that didn't properly go through

	 * the cow mechanism and make them safe to write.  It happens
@@ -943,6 +965,7 @@ struct btrfs_fs_info { 
	int do_barriers;

	int closing;

	int log_root_recovering;

	int enospc_unlink;



	u64 total_pinned;
@@ -1012,6 +1035,9 @@ struct btrfs_root { 
	struct completion kobj_unregister;

	struct mutex objectid_mutex;



	spinlock_t accounting_lock;

	struct btrfs_block_rsv *block_rsv;



	struct mutex log_mutex;

	wait_queue_head_t log_writer_wait;

	wait_queue_head_t log_commit_wait[2];
@@ -1043,7 +1069,6 @@ struct btrfs_root { 
	int ref_cows;

	int track_dirty;

	int in_radix;

	int clean_orphans;



	u64 defrag_trans_start;

	struct btrfs_key defrag_progress;
@@ -1057,8 +1082,11 @@ struct btrfs_root { 


	struct list_head root_list;



	spinlock_t list_lock;

	spinlock_t orphan_lock;

	struct list_head orphan_list;

	struct btrfs_block_rsv *orphan_block_rsv;

	int orphan_item_inserted;

	int orphan_cleanup_state;



	spinlock_t inode_lock;

	/* red-black tree that keeps track of in-memory inodes */
@@ -1965,6 +1993,9 @@ void btrfs_put_block_group(struct btrfs_block_group_cache *cache); 
int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, unsigned long count);

int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len);

int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,

			     struct btrfs_root *root, u64 bytenr,

			     u64 num_bytes, u64 *refs, u64 *flags);

int btrfs_pin_extent(struct btrfs_root *root,

		     u64 bytenr, u64 num, int reserved);

int btrfs_drop_leaf_ref(struct btrfs_trans_handle *trans,
@@ -1984,10 +2015,10 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, 
					u64 parent, u64 root_objectid,

					struct btrfs_disk_key *key, int level,

					u64 hint, u64 empty_size);

int btrfs_free_tree_block(struct btrfs_trans_handle *trans,

void btrfs_free_tree_block(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root,

			  u64 bytenr, u32 blocksize,

			  u64 parent, u64 root_objectid, int level);

			   struct extent_buffer *buf,

			   u64 parent, int last_ref);

struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,

					    struct btrfs_root *root,

					    u64 bytenr, u32 blocksize,
@@ -2041,27 +2072,49 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, 
			   u64 size);

int btrfs_remove_block_group(struct btrfs_trans_handle *trans,

			     struct btrfs_root *root, u64 group_start);

int btrfs_prepare_block_group_relocation(struct btrfs_root *root,

				struct btrfs_block_group_cache *group);



u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);

void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *ionde);

void btrfs_clear_space_info_full(struct btrfs_fs_info *info);



int btrfs_reserve_metadata_space(struct btrfs_root *root, int num_items);

int btrfs_unreserve_metadata_space(struct btrfs_root *root, int num_items);

int btrfs_unreserve_metadata_for_delalloc(struct btrfs_root *root,

					  struct inode *inode, int num_items);

int btrfs_reserve_metadata_for_delalloc(struct btrfs_root *root,

					struct inode *inode, int num_items);

int btrfs_check_data_free_space(struct btrfs_root *root, struct inode *inode,

				u64 bytes);

void btrfs_free_reserved_data_space(struct btrfs_root *root,

				    struct inode *inode, u64 bytes);

void btrfs_delalloc_reserve_space(struct btrfs_root *root, struct inode *inode,

				 u64 bytes);

void btrfs_delalloc_free_space(struct btrfs_root *root, struct inode *inode,

			      u64 bytes);

int btrfs_check_data_free_space(struct inode *inode, u64 bytes);

void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);

int btrfs_trans_reserve_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_root *root,

				int num_items, int *retries);

void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_root *root);

int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,

				  struct inode *inode);

void btrfs_orphan_release_metadata(struct inode *inode);

int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_pending_snapshot *pending);

int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);

void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);

int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);

void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);

void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv);

struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root);

void btrfs_free_block_rsv(struct btrfs_root *root,

			  struct btrfs_block_rsv *rsv);

void btrfs_add_durable_block_rsv(struct btrfs_fs_info *fs_info,

				 struct btrfs_block_rsv *rsv);

int btrfs_block_rsv_add(struct btrfs_trans_handle *trans,

			struct btrfs_root *root,

			struct btrfs_block_rsv *block_rsv,

			u64 num_bytes, int *retries);

int btrfs_block_rsv_check(struct btrfs_trans_handle *trans,

			  struct btrfs_root *root,

			  struct btrfs_block_rsv *block_rsv,

			  u64 min_reserved, int min_factor);

int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,

			    struct btrfs_block_rsv *dst_rsv,

			    u64 num_bytes);

void btrfs_block_rsv_release(struct btrfs_root *root,

			     struct btrfs_block_rsv *block_rsv,

			     u64 num_bytes);

int btrfs_set_block_group_ro(struct btrfs_root *root,

			     struct btrfs_block_group_cache *cache);

int btrfs_set_block_group_rw(struct btrfs_root *root,

			     struct btrfs_block_group_cache *cache);

/* ctree.c */

int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,

		     int level, int *slot);
@@ -2152,7 +2205,8 @@ static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans, 
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_root *root, int update_ref);

int btrfs_drop_snapshot(struct btrfs_root *root,

			struct btrfs_block_rsv *block_rsv, int update_ref);

int btrfs_drop_subtree(struct btrfs_trans_handle *trans,

			struct btrfs_root *root,

			struct extent_buffer *node,
@@ -2245,6 +2299,12 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, 
			   struct btrfs_root *root,

			   const char *name, int name_len,

			   u64 inode_objectid, u64 ref_objectid, u64 *index);

struct btrfs_inode_ref *

btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,

			struct btrfs_root *root,

			struct btrfs_path *path,

			const char *name, int name_len,

			u64 inode_objectid, u64 ref_objectid, int mod);

int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,

			     struct btrfs_root *root,

			     struct btrfs_path *path, u64 objectid);
@@ -2257,6 +2317,8 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans, 
		    struct btrfs_root *root, u64 bytenr, u64 len);

int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,

			  struct bio *bio, u32 *dst);

int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode,

			      struct bio *bio, u64 logical_offset, u32 *dst);

int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,

			     struct btrfs_root *root,

			     u64 objectid, u64 pos,
@@ -2311,6 +2373,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, 
			       u32 min_type);



int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);

int btrfs_start_one_delalloc_inode(struct btrfs_root *root, int delay_iput);

int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,

			      struct extent_state **cached_state);

int btrfs_writepages(struct address_space *mapping,
@@ -2349,10 +2412,20 @@ int btrfs_update_inode(struct btrfs_trans_handle *trans, 
int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);

int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);

void btrfs_orphan_cleanup(struct btrfs_root *root);

void btrfs_orphan_pre_snapshot(struct btrfs_trans_handle *trans,

				struct btrfs_pending_snapshot *pending,

				u64 *bytes_to_reserve);

void btrfs_orphan_post_snapshot(struct btrfs_trans_handle *trans,

				struct btrfs_pending_snapshot *pending);

void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,

			      struct btrfs_root *root);

int btrfs_cont_expand(struct inode *inode, loff_t size);

int btrfs_invalidate_inodes(struct btrfs_root *root);

void btrfs_add_delayed_iput(struct inode *inode);

void btrfs_run_delayed_iputs(struct btrfs_root *root);

int btrfs_prealloc_file_range(struct inode *inode, int mode,

			      u64 start, u64 num_bytes, u64 min_size,

			      loff_t actual_len, u64 *alloc_hint);

extern const struct dentry_operations btrfs_dentry_operations;



/* ioctl.c */
@@ -2409,4 +2482,12 @@ int btrfs_update_reloc_root(struct btrfs_trans_handle *trans, 
			    struct btrfs_root *root);

int btrfs_recover_relocation(struct btrfs_root *root);

int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);

void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, struct extent_buffer *buf,

			   struct extent_buffer *cow);

void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,

			      struct btrfs_pending_snapshot *pending,

			      u64 *bytes_to_reserve);

void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,

			      struct btrfs_pending_snapshot *pending);

#endif

fs/btrfs/delayed-ref.c

+0 −101
Original line number Diff line number Diff line
@@ -318,107 +318,6 @@ int btrfs_delayed_ref_pending(struct btrfs_trans_handle *trans, u64 bytenr) 
	return ret;

}



/*

 * helper function to lookup reference count and flags of extent.

 *

 * the head node for delayed ref is used to store the sum of all the

 * reference count modifications queued up in the rbtree. the head

 * node may also store the extent flags to set. This way you can check

 * to see what the reference count and extent flags would be if all of

 * the delayed refs are not processed.

 */

int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,

			     struct btrfs_root *root, u64 bytenr,

			     u64 num_bytes, u64 *refs, u64 *flags)

{

	struct btrfs_delayed_ref_node *ref;

	struct btrfs_delayed_ref_head *head;

	struct btrfs_delayed_ref_root *delayed_refs;

	struct btrfs_path *path;

	struct btrfs_extent_item *ei;

	struct extent_buffer *leaf;

	struct btrfs_key key;

	u32 item_size;

	u64 num_refs;

	u64 extent_flags;

	int ret;



	path = btrfs_alloc_path();

	if (!path)

		return -ENOMEM;



	key.objectid = bytenr;

	key.type = BTRFS_EXTENT_ITEM_KEY;

	key.offset = num_bytes;

	delayed_refs = &trans->transaction->delayed_refs;

again:

	ret = btrfs_search_slot(trans, root->fs_info->extent_root,

				&key, path, 0, 0);

	if (ret < 0)

		goto out;



	if (ret == 0) {

		leaf = path->nodes[0];

		item_size = btrfs_item_size_nr(leaf, path->slots[0]);

		if (item_size >= sizeof(*ei)) {

			ei = btrfs_item_ptr(leaf, path->slots[0],

					    struct btrfs_extent_item);

			num_refs = btrfs_extent_refs(leaf, ei);

			extent_flags = btrfs_extent_flags(leaf, ei);

		} else {

#ifdef BTRFS_COMPAT_EXTENT_TREE_V0

			struct btrfs_extent_item_v0 *ei0;

			BUG_ON(item_size != sizeof(*ei0));

			ei0 = btrfs_item_ptr(leaf, path->slots[0],

					     struct btrfs_extent_item_v0);

			num_refs = btrfs_extent_refs_v0(leaf, ei0);

			/* FIXME: this isn't correct for data */

			extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;

#else

			BUG();

#endif

		}

		BUG_ON(num_refs == 0);

	} else {

		num_refs = 0;

		extent_flags = 0;

		ret = 0;

	}



	spin_lock(&delayed_refs->lock);

	ref = find_ref_head(&delayed_refs->root, bytenr, NULL);

	if (ref) {

		head = btrfs_delayed_node_to_head(ref);

		if (!mutex_trylock(&head->mutex)) {

			atomic_inc(&ref->refs);

			spin_unlock(&delayed_refs->lock);



			btrfs_release_path(root->fs_info->extent_root, path);



			mutex_lock(&head->mutex);

			mutex_unlock(&head->mutex);

			btrfs_put_delayed_ref(ref);

			goto again;

		}

		if (head->extent_op && head->extent_op->update_flags)

			extent_flags |= head->extent_op->flags_to_set;

		else

			BUG_ON(num_refs == 0);



		num_refs += ref->ref_mod;

		mutex_unlock(&head->mutex);

	}

	WARN_ON(num_refs == 0);

	if (refs)

		*refs = num_refs;

	if (flags)

		*flags = extent_flags;

out:

	spin_unlock(&delayed_refs->lock);

	btrfs_free_path(path);

	return ret;

}



/*

 * helper function to update an extent delayed ref in the

 * rbtree.  existing and update must both have the same