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

Commit 1d4284bd authored by Chris Mason's avatar Chris Mason
Browse files

Merge branch 'error-handling' into for-linus 



Conflicts:
	fs/btrfs/ctree.c
	fs/btrfs/disk-io.c
	fs/btrfs/extent-tree.c
	fs/btrfs/extent_io.c
	fs/btrfs/extent_io.h
	fs/btrfs/inode.c
	fs/btrfs/scrub.c

Signed-off-by: default avatarChris Mason <chris.mason@oracle.com>
parents b5d67f64 65139ed9

fs/btrfs/async-thread.c

+5 −10
Original line number Diff line number Diff line
@@ -171,11 +171,11 @@ out: 
	spin_unlock_irqrestore(&workers->lock, flags);

}



static noinline int run_ordered_completions(struct btrfs_workers *workers,

static noinline void run_ordered_completions(struct btrfs_workers *workers,

					    struct btrfs_work *work)

{

	if (!workers->ordered)

		return 0;

		return;



	set_bit(WORK_DONE_BIT, &work->flags);
@@ -213,7 +213,6 @@ static noinline int run_ordered_completions(struct btrfs_workers *workers, 
	}



	spin_unlock(&workers->order_lock);

	return 0;

}



static void put_worker(struct btrfs_worker_thread *worker)
@@ -399,7 +398,7 @@ again: 
/*

 * this will wait for all the worker threads to shutdown

 */

int btrfs_stop_workers(struct btrfs_workers *workers)

void btrfs_stop_workers(struct btrfs_workers *workers)

{

	struct list_head *cur;

	struct btrfs_worker_thread *worker;
@@ -427,7 +426,6 @@ int btrfs_stop_workers(struct btrfs_workers *workers) 
		put_worker(worker);

	}

	spin_unlock_irq(&workers->lock);

	return 0;

}



/*
@@ -615,14 +613,14 @@ found: 
 * it was taken from.  It is intended for use with long running work functions

 * that make some progress and want to give the cpu up for others.

 */

int btrfs_requeue_work(struct btrfs_work *work)

void btrfs_requeue_work(struct btrfs_work *work)

{

	struct btrfs_worker_thread *worker = work->worker;

	unsigned long flags;

	int wake = 0;



	if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags))

		goto out;

		return;



	spin_lock_irqsave(&worker->lock, flags);

	if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags))
@@ -649,9 +647,6 @@ int btrfs_requeue_work(struct btrfs_work *work) 
	if (wake)

		wake_up_process(worker->task);

	spin_unlock_irqrestore(&worker->lock, flags);

out:



	return 0;

}



void btrfs_set_work_high_prio(struct btrfs_work *work)

fs/btrfs/async-thread.h

+2 −2
Original line number Diff line number Diff line
@@ -111,9 +111,9 @@ struct btrfs_workers { 


void btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work);

int btrfs_start_workers(struct btrfs_workers *workers);

int btrfs_stop_workers(struct btrfs_workers *workers);

void btrfs_stop_workers(struct btrfs_workers *workers);

void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,

			struct btrfs_workers *async_starter);

int btrfs_requeue_work(struct btrfs_work *work);

void btrfs_requeue_work(struct btrfs_work *work);

void btrfs_set_work_high_prio(struct btrfs_work *work);

#endif

fs/btrfs/compression.c

+18 −20
Original line number Diff line number Diff line
@@ -226,7 +226,7 @@ out: 
 * Clear the writeback bits on all of the file

 * pages for a compressed write

 */

static noinline int end_compressed_writeback(struct inode *inode, u64 start,

static noinline void end_compressed_writeback(struct inode *inode, u64 start,

					      unsigned long ram_size)

{

	unsigned long index = start >> PAGE_CACHE_SHIFT;
@@ -253,7 +253,6 @@ static noinline int end_compressed_writeback(struct inode *inode, u64 start, 
		index += ret;

	}

	/* the inode may be gone now */

	return 0;

}



/*
@@ -392,16 +391,16 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
			 */

			atomic_inc(&cb->pending_bios);

			ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */



			if (!skip_sum) {

				ret = btrfs_csum_one_bio(root, inode, bio,

							 start, 1);

				BUG_ON(ret);

				BUG_ON(ret); /* -ENOMEM */

			}



			ret = btrfs_map_bio(root, WRITE, bio, 0, 1);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */



			bio_put(bio);
@@ -421,15 +420,15 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, 
	bio_get(bio);



	ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);

	BUG_ON(ret);

	BUG_ON(ret); /* -ENOMEM */



	if (!skip_sum) {

		ret = btrfs_csum_one_bio(root, inode, bio, start, 1);

		BUG_ON(ret);

		BUG_ON(ret); /* -ENOMEM */

	}



	ret = btrfs_map_bio(root, WRITE, bio, 0, 1);

	BUG_ON(ret);

	BUG_ON(ret); /* -ENOMEM */



	bio_put(bio);

	return 0;
@@ -497,7 +496,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
		 * sure they map to this compressed extent on disk.

		 */

		set_page_extent_mapped(page);

		lock_extent(tree, last_offset, end, GFP_NOFS);

		lock_extent(tree, last_offset, end);

		read_lock(&em_tree->lock);

		em = lookup_extent_mapping(em_tree, last_offset,

					   PAGE_CACHE_SIZE);
@@ -507,7 +506,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
		    (last_offset + PAGE_CACHE_SIZE > extent_map_end(em)) ||

		    (em->block_start >> 9) != cb->orig_bio->bi_sector) {

			free_extent_map(em);

			unlock_extent(tree, last_offset, end, GFP_NOFS);

			unlock_extent(tree, last_offset, end);

			unlock_page(page);

			page_cache_release(page);

			break;
@@ -535,7 +534,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, 
			nr_pages++;

			page_cache_release(page);

		} else {

			unlock_extent(tree, last_offset, end, GFP_NOFS);

			unlock_extent(tree, last_offset, end);

			unlock_page(page);

			page_cache_release(page);

			break;
@@ -662,7 +661,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
			bio_get(comp_bio);



			ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */



			/*

			 * inc the count before we submit the bio so
@@ -675,14 +674,14 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
			if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {

				ret = btrfs_lookup_bio_sums(root, inode,

							comp_bio, sums);

				BUG_ON(ret);

				BUG_ON(ret); /* -ENOMEM */

			}

			sums += (comp_bio->bi_size + root->sectorsize - 1) /

				root->sectorsize;



			ret = btrfs_map_bio(root, READ, comp_bio,

					    mirror_num, 0);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */



			bio_put(comp_bio);
@@ -698,15 +697,15 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, 
	bio_get(comp_bio);



	ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);

	BUG_ON(ret);

	BUG_ON(ret); /* -ENOMEM */



	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {

		ret = btrfs_lookup_bio_sums(root, inode, comp_bio, sums);

		BUG_ON(ret);

		BUG_ON(ret); /* -ENOMEM */

	}



	ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);

	BUG_ON(ret);

	BUG_ON(ret); /* -ENOMEM */



	bio_put(comp_bio);

	return 0;
@@ -734,7 +733,7 @@ struct btrfs_compress_op *btrfs_compress_op[] = { 
	&btrfs_lzo_compress,

};



int __init btrfs_init_compress(void)

void __init btrfs_init_compress(void)

{

	int i;
@@ -744,7 +743,6 @@ int __init btrfs_init_compress(void) 
		atomic_set(&comp_alloc_workspace[i], 0);

		init_waitqueue_head(&comp_workspace_wait[i]);

	}

	return 0;

}



/*

fs/btrfs/compression.h

+1 −1
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 
#ifndef __BTRFS_COMPRESSION_

#define __BTRFS_COMPRESSION_



int btrfs_init_compress(void);

void btrfs_init_compress(void);

void btrfs_exit_compress(void);



int btrfs_compress_pages(int type, struct address_space *mapping,

fs/btrfs/ctree.c

+102 −148
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans, 
			      struct btrfs_root *root,

			      struct extent_buffer *dst_buf,

			      struct extent_buffer *src_buf);

static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,

static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,

		   struct btrfs_path *path, int level, int slot);



struct btrfs_path *btrfs_alloc_path(void)
@@ -344,8 +344,13 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
	if (btrfs_block_can_be_shared(root, buf)) {

		ret = btrfs_lookup_extent_info(trans, root, buf->start,

					       buf->len, &refs, &flags);

		BUG_ON(ret);

		BUG_ON(refs == 0);

		if (ret)

			return ret;

		if (refs == 0) {

			ret = -EROFS;

			btrfs_std_error(root->fs_info, ret);

			return ret;

		}

	} else {

		refs = 1;

		if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
@@ -364,14 +369,14 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
		     root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) &&

		    !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)) {

			ret = btrfs_inc_ref(trans, root, buf, 1, 1);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */



			if (root->root_key.objectid ==

			    BTRFS_TREE_RELOC_OBJECTID) {

				ret = btrfs_dec_ref(trans, root, buf, 0, 1);

				BUG_ON(ret);

				BUG_ON(ret); /* -ENOMEM */

				ret = btrfs_inc_ref(trans, root, cow, 1, 1);

				BUG_ON(ret);

				BUG_ON(ret); /* -ENOMEM */

			}

			new_flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;

		} else {
@@ -381,14 +386,15 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
				ret = btrfs_inc_ref(trans, root, cow, 1, 1);

			else

				ret = btrfs_inc_ref(trans, root, cow, 0, 1);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */

		}

		if (new_flags != 0) {

			ret = btrfs_set_disk_extent_flags(trans, root,

							  buf->start,

							  buf->len,

							  new_flags, 0);

			BUG_ON(ret);

			if (ret)

				return ret;

		}

	} else {

		if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
@@ -397,9 +403,9 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
				ret = btrfs_inc_ref(trans, root, cow, 1, 1);

			else

				ret = btrfs_inc_ref(trans, root, cow, 0, 1);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */

			ret = btrfs_dec_ref(trans, root, buf, 1, 1);

			BUG_ON(ret);

			BUG_ON(ret); /* -ENOMEM */

		}

		clean_tree_block(trans, root, buf);

		*last_ref = 1;
@@ -428,7 +434,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 level, ret;

	int last_ref = 0;

	int unlock_orig = 0;

	u64 parent_start;
@@ -480,7 +486,11 @@ 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, &last_ref);

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

	if (ret) {

		btrfs_abort_transaction(trans, root, ret);

		return ret;

	}



	if (root->ref_cows)

		btrfs_reloc_cow_block(trans, root, buf, cow);
@@ -947,7 +957,12 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 


		/* promote the child to a root */

		child = read_node_slot(root, mid, 0);

		BUG_ON(!child);

		if (!child) {

			ret = -EROFS;

			btrfs_std_error(root->fs_info, ret);

			goto enospc;

		}



		btrfs_tree_lock(child);

		btrfs_set_lock_blocking(child);

		ret = btrfs_cow_block(trans, root, child, mid, 0, &child);
@@ -1023,10 +1038,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		if (btrfs_header_nritems(right) == 0) {

			clean_tree_block(trans, root, right);

			btrfs_tree_unlock(right);

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

				       1);

			if (wret)

				ret = wret;

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

			root_sub_used(root, right->len);

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

			free_extent_buffer_stale(right);
@@ -1048,7 +1060,11 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		 * otherwise we would have pulled some pointers from the

		 * right

		 */

		BUG_ON(!left);

		if (!left) {

			ret = -EROFS;

			btrfs_std_error(root->fs_info, ret);

			goto enospc;

		}

		wret = balance_node_right(trans, root, mid, left);

		if (wret < 0) {

			ret = wret;
@@ -1064,9 +1080,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
	if (btrfs_header_nritems(mid) == 0) {

		clean_tree_block(trans, root, mid);

		btrfs_tree_unlock(mid);

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

		if (wret)

			ret = wret;

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

		root_sub_used(root, mid->len);

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

		free_extent_buffer_stale(mid);
@@ -1905,15 +1919,12 @@ done: 
 * fixing up pointers when a given leaf/node is not in slot 0 of the

 * higher levels

 *

 * If this fails to write a tree block, it returns -1, but continues

 * fixing up the blocks in ram so the tree is consistent.

 */

static int fixup_low_keys(struct btrfs_trans_handle *trans,

static void fixup_low_keys(struct btrfs_trans_handle *trans,

			   struct btrfs_root *root, struct btrfs_path *path,

			   struct btrfs_disk_key *key, int level)

{

	int i;

	int ret = 0;

	struct extent_buffer *t;



	for (i = level; i < BTRFS_MAX_LEVEL; i++) {
@@ -1926,7 +1937,6 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, 
		if (tslot != 0)

			break;

	}

	return ret;

}



/*
@@ -1935,7 +1945,7 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, 
 * This function isn't completely safe. It's the caller's responsibility

 * that the new key won't break the order

 */

int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,

void btrfs_set_item_key_safe(struct btrfs_trans_handle *trans,

			     struct btrfs_root *root, struct btrfs_path *path,

			     struct btrfs_key *new_key)

{
@@ -1947,13 +1957,11 @@ int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, 
	slot = path->slots[0];

	if (slot > 0) {

		btrfs_item_key(eb, &disk_key, slot - 1);

		if (comp_keys(&disk_key, new_key) >= 0)

			return -1;

		BUG_ON(comp_keys(&disk_key, new_key) >= 0);

	}

	if (slot < btrfs_header_nritems(eb) - 1) {

		btrfs_item_key(eb, &disk_key, slot + 1);

		if (comp_keys(&disk_key, new_key) <= 0)

			return -1;

		BUG_ON(comp_keys(&disk_key, new_key) <= 0);

	}



	btrfs_cpu_key_to_disk(&disk_key, new_key);
@@ -1961,7 +1969,6 @@ int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, 
	btrfs_mark_buffer_dirty(eb);

	if (slot == 0)

		fixup_low_keys(trans, root, path, &disk_key, 1);

	return 0;

}



/*
@@ -2164,12 +2171,11 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans, 
 *

 * slot and level indicate where you want the key to go, and

 * blocknr is the block the key points to.

 *

 * returns zero on success and < 0 on any error

 */

static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root

		      *root, struct btrfs_path *path, struct btrfs_disk_key

		      *key, u64 bytenr, int slot, int level)

static void insert_ptr(struct btrfs_trans_handle *trans,

		       struct btrfs_root *root, struct btrfs_path *path,

		       struct btrfs_disk_key *key, u64 bytenr,

		       int slot, int level)

{

	struct extent_buffer *lower;

	int nritems;
@@ -2179,8 +2185,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root 
	lower = path->nodes[level];

	nritems = btrfs_header_nritems(lower);

	BUG_ON(slot > nritems);

	if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root))

		BUG();

	BUG_ON(nritems == BTRFS_NODEPTRS_PER_BLOCK(root));

	if (slot != nritems) {

		memmove_extent_buffer(lower,

			      btrfs_node_key_ptr_offset(slot + 1),
@@ -2193,7 +2198,6 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root 
	btrfs_set_node_ptr_generation(lower, slot, trans->transid);

	btrfs_set_header_nritems(lower, nritems + 1);

	btrfs_mark_buffer_dirty(lower);

	return 0;

}



/*
@@ -2214,7 +2218,6 @@ static noinline int split_node(struct btrfs_trans_handle *trans, 
	struct btrfs_disk_key disk_key;

	int mid;

	int ret;

	int wret;

	u32 c_nritems;



	c = path->nodes[level];
@@ -2271,11 +2274,8 @@ static noinline int split_node(struct btrfs_trans_handle *trans, 
	btrfs_mark_buffer_dirty(c);

	btrfs_mark_buffer_dirty(split);



	wret = insert_ptr(trans, root, path, &disk_key, split->start,

			  path->slots[level + 1] + 1,

			  level + 1);

	if (wret)

		ret = wret;

	insert_ptr(trans, root, path, &disk_key, split->start,

		   path->slots[level + 1] + 1, level + 1);



	if (path->slots[level] >= mid) {

		path->slots[level] -= mid;
@@ -2564,7 +2564,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans, 
	u32 old_left_nritems;

	u32 nr;

	int ret = 0;

	int wret;

	u32 this_item_size;

	u32 old_left_item_size;

	struct btrfs_map_token token;
@@ -2675,9 +2674,7 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans, 
		clean_tree_block(trans, root, right);



	btrfs_item_key(right, &disk_key, 0);

	wret = fixup_low_keys(trans, root, path, &disk_key, 1);

	if (wret)

		ret = wret;

	fixup_low_keys(trans, root, path, &disk_key, 1);



	/* then fixup the leaf pointer in the path */

	if (path->slots[0] < push_items) {
@@ -2748,6 +2745,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root 
			      path->nodes[1], slot - 1, &left);

	if (ret) {

		/* we hit -ENOSPC, but it isn't fatal here */

		if (ret == -ENOSPC)

			ret = 1;

		goto out;

	}
@@ -2770,10 +2768,8 @@ out: 
/*

 * split the path's leaf in two, making sure there is at least data_size

 * available for the resulting leaf level of the path.

 *

 * returns 0 if all went well and < 0 on failure.

 */

static noinline int copy_for_split(struct btrfs_trans_handle *trans,

static noinline void copy_for_split(struct btrfs_trans_handle *trans,

				    struct btrfs_root *root,

				    struct btrfs_path *path,

				    struct extent_buffer *l,
@@ -2783,8 +2779,6 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, 
	int data_copy_size;

	int rt_data_off;

	int i;

	int ret = 0;

	int wret;

	struct btrfs_disk_key disk_key;

	struct btrfs_map_token token;
@@ -2816,12 +2810,9 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, 
	}



	btrfs_set_header_nritems(l, mid);

	ret = 0;

	btrfs_item_key(right, &disk_key, 0);

	wret = insert_ptr(trans, root, path, &disk_key, right->start,

	insert_ptr(trans, root, path, &disk_key, right->start,

		   path->slots[1] + 1, 1);

	if (wret)

		ret = wret;



	btrfs_mark_buffer_dirty(right);

	btrfs_mark_buffer_dirty(l);
@@ -2839,8 +2830,6 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, 
	}



	BUG_ON(path->slots[0] < 0);



	return ret;

}



/*
@@ -3029,12 +3018,8 @@ again: 
	if (split == 0) {

		if (mid <= slot) {

			btrfs_set_header_nritems(right, 0);

			wret = insert_ptr(trans, root, path,

					  &disk_key, right->start,

			insert_ptr(trans, root, path, &disk_key, right->start,

				   path->slots[1] + 1, 1);

			if (wret)

				ret = wret;



			btrfs_tree_unlock(path->nodes[0]);

			free_extent_buffer(path->nodes[0]);

			path->nodes[0] = right;
@@ -3042,29 +3027,21 @@ again: 
			path->slots[1] += 1;

		} else {

			btrfs_set_header_nritems(right, 0);

			wret = insert_ptr(trans, root, path,

					  &disk_key,

					  right->start,

			insert_ptr(trans, root, path, &disk_key, right->start,

					  path->slots[1], 1);

			if (wret)

				ret = wret;

			btrfs_tree_unlock(path->nodes[0]);

			free_extent_buffer(path->nodes[0]);

			path->nodes[0] = right;

			path->slots[0] = 0;

			if (path->slots[1] == 0) {

				wret = fixup_low_keys(trans, root,

						path, &disk_key, 1);

				if (wret)

					ret = wret;

			}

			if (path->slots[1] == 0)

				fixup_low_keys(trans, root, path,

					       &disk_key, 1);

		}

		btrfs_mark_buffer_dirty(right);

		return ret;

	}



	ret = copy_for_split(trans, root, path, l, right, slot, mid, nritems);

	BUG_ON(ret);

	copy_for_split(trans, root, path, l, right, slot, mid, nritems);



	if (split == 2) {

		BUG_ON(num_doubles != 0);
@@ -3072,7 +3049,7 @@ again: 
		goto again;

	}



	return ret;

	return 0;



push_for_double:

	push_for_double_split(trans, root, path, data_size);
@@ -3274,11 +3251,9 @@ int btrfs_duplicate_item(struct btrfs_trans_handle *trans, 
		return ret;



	path->slots[0]++;

	ret = setup_items_for_insert(trans, root, path, new_key, &item_size,

	setup_items_for_insert(trans, root, path, new_key, &item_size,

			       item_size, item_size +

			       sizeof(struct btrfs_item), 1);

	BUG_ON(ret);



	leaf = path->nodes[0];

	memcpy_extent_buffer(leaf,

			     btrfs_item_ptr_offset(leaf, path->slots[0]),
@@ -3293,7 +3268,7 @@ int btrfs_duplicate_item(struct btrfs_trans_handle *trans, 
 * off the end of the item or if we shift the item to chop bytes off

 * the front.

 */

int btrfs_truncate_item(struct btrfs_trans_handle *trans,

void btrfs_truncate_item(struct btrfs_trans_handle *trans,

			 struct btrfs_root *root,

			 struct btrfs_path *path,

			 u32 new_size, int from_end)
@@ -3316,7 +3291,7 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans, 


	old_size = btrfs_item_size_nr(leaf, slot);

	if (old_size == new_size)

		return 0;

		return;



	nritems = btrfs_header_nritems(leaf);

	data_end = leaf_data_end(root, leaf);
@@ -3390,13 +3365,12 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans, 
		btrfs_print_leaf(root, leaf);

		BUG();

	}

	return 0;

}



/*

 * make the item pointed to by the path bigger, data_size is the new size.

 */

int btrfs_extend_item(struct btrfs_trans_handle *trans,

void btrfs_extend_item(struct btrfs_trans_handle *trans,

		       struct btrfs_root *root, struct btrfs_path *path,

		       u32 data_size)

{
@@ -3460,7 +3434,6 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans, 
		btrfs_print_leaf(root, leaf);

		BUG();

	}

	return 0;

}



/*
@@ -3593,7 +3566,7 @@ int btrfs_insert_some_items(struct btrfs_trans_handle *trans, 
	ret = 0;

	if (slot == 0) {

		btrfs_cpu_key_to_disk(&disk_key, cpu_key);

		ret = fixup_low_keys(trans, root, path, &disk_key, 1);

		fixup_low_keys(trans, root, path, &disk_key, 1);

	}



	if (btrfs_leaf_free_space(root, leaf) < 0) {
@@ -3611,7 +3584,7 @@ out: 
 * to save stack depth by doing the bulk of the work in a function

 * that doesn't call btrfs_search_slot

 */

int setup_items_for_insert(struct btrfs_trans_handle *trans,

void setup_items_for_insert(struct btrfs_trans_handle *trans,

			    struct btrfs_root *root, struct btrfs_path *path,

			    struct btrfs_key *cpu_key, u32 *data_size,

			    u32 total_data, u32 total_size, int nr)
@@ -3621,7 +3594,6 @@ int setup_items_for_insert(struct btrfs_trans_handle *trans, 
	u32 nritems;

	unsigned int data_end;

	struct btrfs_disk_key disk_key;

	int ret;

	struct extent_buffer *leaf;

	int slot;

	struct btrfs_map_token token;
@@ -3687,10 +3659,9 @@ int setup_items_for_insert(struct btrfs_trans_handle *trans, 


	btrfs_set_header_nritems(leaf, nritems + nr);



	ret = 0;

	if (slot == 0) {

		btrfs_cpu_key_to_disk(&disk_key, cpu_key);

		ret = fixup_low_keys(trans, root, path, &disk_key, 1);

		fixup_low_keys(trans, root, path, &disk_key, 1);

	}

	btrfs_unlock_up_safe(path, 1);

	btrfs_mark_buffer_dirty(leaf);
@@ -3699,7 +3670,6 @@ int setup_items_for_insert(struct btrfs_trans_handle *trans, 
		btrfs_print_leaf(root, leaf);

		BUG();

	}

	return ret;

}



/*
@@ -3726,16 +3696,14 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, 
	if (ret == 0)

		return -EEXIST;

	if (ret < 0)

		goto out;

		return ret;



	slot = path->slots[0];

	BUG_ON(slot < 0);



	ret = setup_items_for_insert(trans, root, path, cpu_key, data_size,

	setup_items_for_insert(trans, root, path, cpu_key, data_size,

			       total_data, total_size, nr);



out:

	return ret;

	return 0;

}



/*
@@ -3771,13 +3739,11 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root 
 * the tree should have been previously balanced so the deletion does not

 * empty a node.

 */

static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,

static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,

		    struct btrfs_path *path, int level, int slot)

{

	struct extent_buffer *parent = path->nodes[level];

	u32 nritems;

	int ret = 0;

	int wret;



	nritems = btrfs_header_nritems(parent);

	if (slot != nritems - 1) {
@@ -3797,12 +3763,9 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		struct btrfs_disk_key disk_key;



		btrfs_node_key(parent, &disk_key, 0);

		wret = fixup_low_keys(trans, root, path, &disk_key, level + 1);

		if (wret)

			ret = wret;

		fixup_low_keys(trans, root, path, &disk_key, level + 1);

	}

	btrfs_mark_buffer_dirty(parent);

	return ret;

}



/*
@@ -3815,17 +3778,13 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
 * The path must have already been setup for deleting the leaf, including

 * all the proper balancing.  path->nodes[1] must be locked.

 */

static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans,

static noinline void btrfs_del_leaf(struct btrfs_trans_handle *trans,

				    struct btrfs_root *root,

				    struct btrfs_path *path,

				    struct extent_buffer *leaf)

{

	int ret;



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

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

	if (ret)

		return ret;

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



	/*

	 * btrfs_free_extent is expensive, we want to make sure we
@@ -3838,7 +3797,6 @@ static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans, 
	extent_buffer_get(leaf);

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

	free_extent_buffer_stale(leaf);

	return 0;

}

/*

 * delete the item at the leaf level in path.  If that empties
@@ -3899,8 +3857,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		} else {

			btrfs_set_path_blocking(path);

			clean_tree_block(trans, root, leaf);

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

			BUG_ON(ret);

			btrfs_del_leaf(trans, root, path, leaf);

		}

	} else {

		int used = leaf_space_used(leaf, 0, nritems);
@@ -3908,10 +3865,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
			struct btrfs_disk_key disk_key;



			btrfs_item_key(leaf, &disk_key, 0);

			wret = fixup_low_keys(trans, root, path,

					      &disk_key, 1);

			if (wret)

				ret = wret;

			fixup_low_keys(trans, root, path, &disk_key, 1);

		}



		/* delete the leaf if it is mostly empty */
@@ -3939,9 +3893,9 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 


			if (btrfs_header_nritems(leaf) == 0) {

				path->slots[1] = slot;

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

				BUG_ON(ret);

				btrfs_del_leaf(trans, root, path, leaf);

				free_extent_buffer(leaf);

				ret = 0;

			} else {

				/* if we're still in the path, make sure

				 * we're dirty.  Otherwise, one of the
@@ -4124,7 +4078,7 @@ find_next_key: 
		}

		btrfs_set_path_blocking(path);

		cur = read_node_slot(root, cur, slot);

		BUG_ON(!cur);

		BUG_ON(!cur); /* -ENOMEM */



		btrfs_tree_read_lock(cur);