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

Commit f7b00693 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs 

Pull btrfs fixes from Chris Mason:
 "This has our collection of bug fixes.  I missed the last rc because I
  thought our patches were making NFS crash during my xfs test runs.
  Turns out it was an NFS client bug fixed by someone else while I tried
  to bisect it.

  All of these fixes are small, but some are fairly high impact.  The
  biggest are fixes for our mount -o remount handling, a deadlock due to
  GFP_KERNEL allocations in readdir, and a RAID10 error handling bug.

  This was tested against both 3.3 and Linus' master as of this morning."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (26 commits)
  Btrfs: reduce lock contention during extent insertion
  Btrfs: avoid deadlocks from GFP_KERNEL allocations during btrfs_real_readdir
  Btrfs: Fix space checking during fs resize
  Btrfs: fix block_rsv and space_info lock ordering
  Btrfs: Prevent root_list corruption
  Btrfs: fix repair code for RAID10
  Btrfs: do not start delalloc inodes during sync
  Btrfs: fix that check_int_data mount option was ignored
  Btrfs: don't count CRC or header errors twice while scrubbing
  Btrfs: fix btrfs_ioctl_dev_info() crash on missing device
  btrfs: don't return EINTR
  Btrfs: double unlock bug in error handling
  Btrfs: always store the mirror we read the eb from
  fs/btrfs/volumes.c: add missing free_fs_devices
  btrfs: fix early abort in 'remount'
  Btrfs: fix max chunk size check in chunk allocator
  Btrfs: add missing read locks in backref.c
  Btrfs: don't call free_extent_buffer twice in iterate_irefs
  Btrfs: Make free_ipath() deal gracefully with NULL pointers
  Btrfs: avoid possible use-after-free in clear_extent_bit()
  ...
parents b990f9b3 dc7fdde3

fs/btrfs/backref.c

+20 −7
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include "ulist.h"

#include "transaction.h"

#include "delayed-ref.h"

#include "locking.h"



/*

 * this structure records all encountered refs on the way up to the root
@@ -893,18 +894,22 @@ static char *iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
	s64 bytes_left = size - 1;

	struct extent_buffer *eb = eb_in;

	struct btrfs_key found_key;

	int leave_spinning = path->leave_spinning;



	if (bytes_left >= 0)

		dest[bytes_left] = '\0';



	path->leave_spinning = 1;

	while (1) {

		len = btrfs_inode_ref_name_len(eb, iref);

		bytes_left -= len;

		if (bytes_left >= 0)

			read_extent_buffer(eb, dest + bytes_left,

						(unsigned long)(iref + 1), len);

		if (eb != eb_in)

		if (eb != eb_in) {

			btrfs_tree_read_unlock_blocking(eb);

			free_extent_buffer(eb);

		}

		ret = inode_ref_info(parent, 0, fs_root, path, &found_key);

		if (ret > 0)

			ret = -ENOENT;
@@ -919,8 +924,11 @@ static char *iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
		slot = path->slots[0];

		eb = path->nodes[0];

		/* make sure we can use eb after releasing the path */

		if (eb != eb_in)

		if (eb != eb_in) {

			atomic_inc(&eb->refs);

			btrfs_tree_read_lock(eb);

			btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);

		}

		btrfs_release_path(path);



		iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
@@ -931,6 +939,7 @@ static char *iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
	}



	btrfs_release_path(path);

	path->leave_spinning = leave_spinning;



	if (ret)

		return ERR_PTR(ret);
@@ -1247,7 +1256,7 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root, 
				struct btrfs_path *path,

				iterate_irefs_t *iterate, void *ctx)

{

	int ret;

	int ret = 0;

	int slot;

	u32 cur;

	u32 len;
@@ -1259,7 +1268,8 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root, 
	struct btrfs_inode_ref *iref;

	struct btrfs_key found_key;



	while (1) {

	while (!ret) {

		path->leave_spinning = 1;

		ret = inode_ref_info(inum, parent ? parent+1 : 0, fs_root, path,

					&found_key);

		if (ret < 0)
@@ -1275,6 +1285,8 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root, 
		eb = path->nodes[0];

		/* make sure we can use eb after releasing the path */

		atomic_inc(&eb->refs);

		btrfs_tree_read_lock(eb);

		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);

		btrfs_release_path(path);



		item = btrfs_item_nr(eb, slot);
@@ -1288,13 +1300,12 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root, 
				 (unsigned long long)found_key.objectid,

				 (unsigned long long)fs_root->objectid);

			ret = iterate(parent, iref, eb, ctx);

			if (ret) {

				free_extent_buffer(eb);

			if (ret)

				break;

			}

			len = sizeof(*iref) + name_len;

			iref = (struct btrfs_inode_ref *)((char *)iref + len);

		}

		btrfs_tree_read_unlock_blocking(eb);

		free_extent_buffer(eb);

	}
@@ -1414,6 +1425,8 @@ struct inode_fs_paths *init_ipath(s32 total_bytes, struct btrfs_root *fs_root, 


void free_ipath(struct inode_fs_paths *ipath)

{

	if (!ipath)

		return;

	kfree(ipath->fspath);

	kfree(ipath);

}

fs/btrfs/ctree.h

+1 −1
Original line number Diff line number Diff line
@@ -1078,7 +1078,7 @@ struct btrfs_fs_info { 
	 * is required instead of the faster short fsync log commits

	 */

	u64 last_trans_log_full_commit;

	unsigned long mount_opt:21;

	unsigned long mount_opt;

	unsigned long compress_type:4;

	u64 max_inline;

	u64 alloc_start;

fs/btrfs/disk-io.c

+11 −11
Original line number Diff line number Diff line
@@ -383,17 +383,16 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root, 
		if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))

			break;



		if (!failed_mirror) {

			failed = 1;

			printk(KERN_ERR "failed mirror was %d\n", eb->failed_mirror);

			failed_mirror = eb->failed_mirror;

		}



		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,

					      eb->start, eb->len);

		if (num_copies == 1)

			break;



		if (!failed_mirror) {

			failed = 1;

			failed_mirror = eb->read_mirror;

		}



		mirror_num++;

		if (mirror_num == failed_mirror)

			mirror_num++;
@@ -564,7 +563,7 @@ struct extent_buffer *find_eb_for_page(struct extent_io_tree *tree, 
}



static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,

			       struct extent_state *state)

			       struct extent_state *state, int mirror)

{

	struct extent_io_tree *tree;

	u64 found_start;
@@ -589,6 +588,7 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end, 
	if (!reads_done)

		goto err;



	eb->read_mirror = mirror;

	if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {

		ret = -EIO;

		goto err;
@@ -652,7 +652,7 @@ static int btree_io_failed_hook(struct page *page, int failed_mirror) 


	eb = (struct extent_buffer *)page->private;

	set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);

	eb->failed_mirror = failed_mirror;

	eb->read_mirror = failed_mirror;

	if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))

		btree_readahead_hook(root, eb, eb->start, -EIO);

	return -EIO;	/* we fixed nothing */
@@ -2254,9 +2254,9 @@ int open_ctree(struct super_block *sb, 
		goto fail_sb_buffer;

	}



	if (sectorsize < PAGE_SIZE) {

		printk(KERN_WARNING "btrfs: Incompatible sector size "

		       "found on %s\n", sb->s_id);

	if (sectorsize != PAGE_SIZE) {

		printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "

		       "found on %s\n", (unsigned long)sectorsize, sb->s_id);

		goto fail_sb_buffer;

	}

fs/btrfs/extent-tree.c

+7 −8
Original line number Diff line number Diff line
@@ -2301,6 +2301,7 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, 


				if (ret) {

					printk(KERN_DEBUG "btrfs: run_delayed_extent_op returned %d\n", ret);

					spin_lock(&delayed_refs->lock);

					return ret;

				}
@@ -2331,6 +2332,7 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, 


		if (ret) {

			printk(KERN_DEBUG "btrfs: run_one_delayed_ref returned %d\n", ret);

			spin_lock(&delayed_refs->lock);

			return ret;

		}
@@ -3769,13 +3771,10 @@ static int reserve_metadata_bytes(struct btrfs_root *root, 
		 */

		if (current->journal_info)

			return -EAGAIN;

		ret = wait_event_interruptible(space_info->wait,

					       !space_info->flush);

		/* Must have been interrupted, return */

		if (ret) {

			printk(KERN_DEBUG "btrfs: %s returning -EINTR\n", __func__);

		ret = wait_event_killable(space_info->wait, !space_info->flush);

		/* Must have been killed, return */

		if (ret)

			return -EINTR;

		}



		spin_lock(&space_info->lock);

	}
@@ -4215,8 +4214,8 @@ static void update_global_block_rsv(struct btrfs_fs_info *fs_info) 


	num_bytes = calc_global_metadata_size(fs_info);



	spin_lock(&block_rsv->lock);

	spin_lock(&sinfo->lock);

	spin_lock(&block_rsv->lock);



	block_rsv->size = num_bytes;
@@ -4242,8 +4241,8 @@ static void update_global_block_rsv(struct btrfs_fs_info *fs_info) 
		block_rsv->full = 1;

	}



	spin_unlock(&sinfo->lock);

	spin_unlock(&block_rsv->lock);

	spin_unlock(&sinfo->lock);

}



static void init_global_block_rsv(struct btrfs_fs_info *fs_info)

fs/btrfs/extent_io.c

+28 −28
Original line number Diff line number Diff line
@@ -402,20 +402,28 @@ static int split_state(struct extent_io_tree *tree, struct extent_state *orig, 
	return 0;

}



static struct extent_state *next_state(struct extent_state *state)

{

	struct rb_node *next = rb_next(&state->rb_node);

	if (next)

		return rb_entry(next, struct extent_state, rb_node);

	else

		return NULL;

}



/*

 * utility function to clear some bits in an extent state struct.

 * it will optionally wake up any one waiting on this state (wake == 1), or

 * forcibly remove the state from the tree (delete == 1).

 * it will optionally wake up any one waiting on this state (wake == 1)

 *

 * If no bits are set on the state struct after clearing things, the

 * struct is freed and removed from the tree

 */

static int clear_state_bit(struct extent_io_tree *tree,

static struct extent_state *clear_state_bit(struct extent_io_tree *tree,

					    struct extent_state *state,

					    int *bits, int wake)

{

	struct extent_state *next;

	int bits_to_clear = *bits & ~EXTENT_CTLBITS;

	int ret = state->state & bits_to_clear;



	if ((bits_to_clear & EXTENT_DIRTY) && (state->state & EXTENT_DIRTY)) {

		u64 range = state->end - state->start + 1;
@@ -427,6 +435,7 @@ static int clear_state_bit(struct extent_io_tree *tree, 
	if (wake)

		wake_up(&state->wq);

	if (state->state == 0) {

		next = next_state(state);

		if (state->tree) {

			rb_erase(&state->rb_node, &tree->state);

			state->tree = NULL;
@@ -436,8 +445,9 @@ static int clear_state_bit(struct extent_io_tree *tree, 
		}

	} else {

		merge_state(tree, state);

		next = next_state(state);

	}

	return ret;

	return next;

}



static struct extent_state *
@@ -476,7 +486,6 @@ int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, 
	struct extent_state *state;

	struct extent_state *cached;

	struct extent_state *prealloc = NULL;

	struct rb_node *next_node;

	struct rb_node *node;

	u64 last_end;

	int err;
@@ -528,14 +537,11 @@ int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, 
	WARN_ON(state->end < start);

	last_end = state->end;



	if (state->end < end && !need_resched())

		next_node = rb_next(&state->rb_node);

	else

		next_node = NULL;



	/* the state doesn't have the wanted bits, go ahead */

	if (!(state->state & bits))

	if (!(state->state & bits)) {

		state = next_state(state);

		goto next;

	}



	/*

	 *     | ---- desired range ---- |
@@ -593,16 +599,13 @@ int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, 
		goto out;

	}



	clear_state_bit(tree, state, &bits, wake);

	state = clear_state_bit(tree, state, &bits, wake);

next:

	if (last_end == (u64)-1)

		goto out;

	start = last_end + 1;

	if (start <= end && next_node) {

		state = rb_entry(next_node, struct extent_state,

				 rb_node);

	if (start <= end && state && !need_resched())

		goto hit_next;

	}

	goto search_again;



out:
@@ -2301,7 +2304,7 @@ static void end_bio_extent_readpage(struct bio *bio, int err) 
	u64 start;

	u64 end;

	int whole_page;

	int failed_mirror;

	int mirror;

	int ret;



	if (err)
@@ -2340,20 +2343,18 @@ static void end_bio_extent_readpage(struct bio *bio, int err) 
		}

		spin_unlock(&tree->lock);



		mirror = (int)(unsigned long)bio->bi_bdev;

		if (uptodate && tree->ops && tree->ops->readpage_end_io_hook) {

			ret = tree->ops->readpage_end_io_hook(page, start, end,

							      state);

							      state, mirror);

			if (ret)

				uptodate = 0;

			else

				clean_io_failure(start, page);

		}



		if (!uptodate)

			failed_mirror = (int)(unsigned long)bio->bi_bdev;



		if (!uptodate && tree->ops && tree->ops->readpage_io_failed_hook) {

			ret = tree->ops->readpage_io_failed_hook(page, failed_mirror);

			ret = tree->ops->readpage_io_failed_hook(page, mirror);

			if (!ret && !err &&

			    test_bit(BIO_UPTODATE, &bio->bi_flags))

				uptodate = 1;
@@ -2368,8 +2369,7 @@ static void end_bio_extent_readpage(struct bio *bio, int err) 
			 * can't handle the error it will return -EIO and we

			 * remain responsible for that page.

			 */

			ret = bio_readpage_error(bio, page, start, end,

							failed_mirror, NULL);

			ret = bio_readpage_error(bio, page, start, end, mirror, NULL);

			if (ret == 0) {

				uptodate =

					test_bit(BIO_UPTODATE, &bio->bi_flags);
@@ -4462,7 +4462,7 @@ int read_extent_buffer_pages(struct extent_io_tree *tree, 
	}



	clear_bit(EXTENT_BUFFER_IOERR, &eb->bflags);

	eb->failed_mirror = 0;

	eb->read_mirror = 0;

	atomic_set(&eb->io_pages, num_reads);

	for (i = start_i; i < num_pages; i++) {

		page = extent_buffer_page(eb, i);