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

Commit 3615db41 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:
 "We've had a busy two weeks of bug fixing.  The biggest patches in here
  are some long standing early-enospc problems (Josef) and a very old
  race where compression and mmap combine forces to lose writes (me).
  I'm fairly sure the mmap bug goes all the way back to the introduction
  of the compression code, which is proof that fsx doesn't trigger every
  possible mmap corner after all.

  I'm sure you'll notice one of these is from this morning, it's a small
  and isolated use-after-free fix in our scrub error reporting.  I
  double checked it here."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs:
  Btrfs: don't drop path when printing out tree errors in scrub
  Btrfs: fix wrong return value of btrfs_lookup_csum()
  Btrfs: fix wrong reservation of csums
  Btrfs: fix double free in the btrfs_qgroup_account_ref()
  Btrfs: limit the global reserve to 512mb
  Btrfs: hold the ordered operations mutex when waiting on ordered extents
  Btrfs: fix space accounting for unlink and rename
  Btrfs: fix space leak when we fail to reserve metadata space
  Btrfs: fix EIO from btrfs send in is_extent_unchanged for punched holes
  Btrfs: fix race between mmap writes and compression
  Btrfs: fix memory leak in btrfs_create_tree()
  Btrfs: fix locking on ROOT_REPLACE operations in tree mod log
  Btrfs: fix missing qgroup reservation before fallocating
  Btrfs: handle a bogus chunk tree nicely
  Btrfs: update to use fs_state bit
parents ed176886 d8fe29e9

fs/btrfs/ctree.c

+20 −10
Original line number Diff line number Diff line
@@ -651,6 +651,8 @@ tree_mod_log_insert_root(struct btrfs_fs_info *fs_info, 
	if (tree_mod_dont_log(fs_info, NULL))

		return 0;



	__tree_mod_log_free_eb(fs_info, old_root);



	ret = tree_mod_alloc(fs_info, flags, &tm);

	if (ret < 0)

		goto out;
@@ -736,7 +738,7 @@ tree_mod_log_search(struct btrfs_fs_info *fs_info, u64 start, u64 min_seq) 
static noinline void

tree_mod_log_eb_copy(struct btrfs_fs_info *fs_info, struct extent_buffer *dst,

		     struct extent_buffer *src, unsigned long dst_offset,

		     unsigned long src_offset, int nr_items)

		     unsigned long src_offset, int nr_items, int log_removal)

{

	int ret;

	int i;
@@ -750,10 +752,12 @@ tree_mod_log_eb_copy(struct btrfs_fs_info *fs_info, struct extent_buffer *dst, 
	}



	for (i = 0; i < nr_items; i++) {

		if (log_removal) {

			ret = tree_mod_log_insert_key_locked(fs_info, src,

							i + src_offset,

							MOD_LOG_KEY_REMOVE);

			BUG_ON(ret < 0);

		}

		ret = tree_mod_log_insert_key_locked(fs_info, dst,

						     i + dst_offset,

						     MOD_LOG_KEY_ADD);
@@ -927,7 +931,6 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, 
			ret = btrfs_dec_ref(trans, root, buf, 1, 1);

			BUG_ON(ret); /* -ENOMEM */

		}

		tree_mod_log_free_eb(root->fs_info, buf);

		clean_tree_block(trans, root, buf);

		*last_ref = 1;

	}
@@ -1046,6 +1049,7 @@ 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);

		tree_mod_log_free_eb(root->fs_info, buf);

		btrfs_free_tree_block(trans, root, buf, parent_start,

				      last_ref);

	}
@@ -1750,7 +1754,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
			goto enospc;

		}



		tree_mod_log_free_eb(root->fs_info, root->node);

		tree_mod_log_set_root_pointer(root, child);

		rcu_assign_pointer(root->node, child);
@@ -2995,7 +2998,7 @@ static int push_node_left(struct btrfs_trans_handle *trans, 
		push_items = min(src_nritems - 8, push_items);



	tree_mod_log_eb_copy(root->fs_info, dst, src, dst_nritems, 0,

			     push_items);

			     push_items, 1);

	copy_extent_buffer(dst, src,

			   btrfs_node_key_ptr_offset(dst_nritems),

			   btrfs_node_key_ptr_offset(0),
@@ -3066,7 +3069,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans, 
				      sizeof(struct btrfs_key_ptr));



	tree_mod_log_eb_copy(root->fs_info, dst, src, 0,

			     src_nritems - push_items, push_items);

			     src_nritems - push_items, push_items, 1);

	copy_extent_buffer(dst, src,

			   btrfs_node_key_ptr_offset(0),

			   btrfs_node_key_ptr_offset(src_nritems - push_items),
@@ -3218,12 +3221,18 @@ static noinline int split_node(struct btrfs_trans_handle *trans, 
	int mid;

	int ret;

	u32 c_nritems;

	int tree_mod_log_removal = 1;



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

		/*

		 * removal of root nodes has been logged by

		 * tree_mod_log_set_root_pointer due to locking

		 */

		tree_mod_log_removal = 0;

		if (ret)

			return ret;

	} else {
@@ -3261,7 +3270,8 @@ static noinline int split_node(struct btrfs_trans_handle *trans, 
			    (unsigned long)btrfs_header_chunk_tree_uuid(split),

			    BTRFS_UUID_SIZE);



	tree_mod_log_eb_copy(root->fs_info, split, c, 0, mid, c_nritems - mid);

	tree_mod_log_eb_copy(root->fs_info, split, c, 0, mid, c_nritems - mid,

			     tree_mod_log_removal);

	copy_extent_buffer(split, c,

			   btrfs_node_key_ptr_offset(0),

			   btrfs_node_key_ptr_offset(mid),

fs/btrfs/disk-io.c

+10 −4
Original line number Diff line number Diff line
@@ -1291,6 +1291,7 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans, 
				      0, objectid, NULL, 0, 0, 0);

	if (IS_ERR(leaf)) {

		ret = PTR_ERR(leaf);

		leaf = NULL;

		goto fail;

	}
@@ -1334,11 +1335,16 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans, 


	btrfs_tree_unlock(leaf);



	return root;



fail:

	if (ret)

		return ERR_PTR(ret);

	if (leaf) {

		btrfs_tree_unlock(leaf);

		free_extent_buffer(leaf);

	}

	kfree(root);



	return root;

	return ERR_PTR(ret);

}



static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
@@ -3253,7 +3259,7 @@ void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root) 
	if (btrfs_root_refs(&root->root_item) == 0)

		synchronize_srcu(&fs_info->subvol_srcu);



	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {

	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {

		btrfs_free_log(NULL, root);

		btrfs_free_log_root_tree(NULL, fs_info);

	}

fs/btrfs/extent-tree.c

+72 −12
Original line number Diff line number Diff line
@@ -257,7 +257,8 @@ static int exclude_super_stripes(struct btrfs_root *root, 
		cache->bytes_super += stripe_len;

		ret = add_excluded_extent(root, cache->key.objectid,

					  stripe_len);

		BUG_ON(ret); /* -ENOMEM */

		if (ret)

			return ret;

	}



	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
@@ -265,13 +266,17 @@ static int exclude_super_stripes(struct btrfs_root *root, 
		ret = btrfs_rmap_block(&root->fs_info->mapping_tree,

				       cache->key.objectid, bytenr,

				       0, &logical, &nr, &stripe_len);

		BUG_ON(ret); /* -ENOMEM */

		if (ret)

			return ret;



		while (nr--) {

			cache->bytes_super += stripe_len;

			ret = add_excluded_extent(root, logical[nr],

						  stripe_len);

			BUG_ON(ret); /* -ENOMEM */

			if (ret) {

				kfree(logical);

				return ret;

			}

		}



		kfree(logical);
@@ -4438,7 +4443,7 @@ static void update_global_block_rsv(struct btrfs_fs_info *fs_info) 
	spin_lock(&sinfo->lock);

	spin_lock(&block_rsv->lock);



	block_rsv->size = num_bytes;

	block_rsv->size = min_t(u64, num_bytes, 512 * 1024 * 1024);



	num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +

		    sinfo->bytes_reserved + sinfo->bytes_readonly +
@@ -4793,14 +4798,49 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes) 
	 * If the inodes csum_bytes is the same as the original

	 * csum_bytes then we know we haven't raced with any free()ers

	 * so we can just reduce our inodes csum bytes and carry on.

	 * Otherwise we have to do the normal free thing to account for

	 * the case that the free side didn't free up its reserve

	 * because of this outstanding reservation.

	 */

	if (BTRFS_I(inode)->csum_bytes == csum_bytes)

	if (BTRFS_I(inode)->csum_bytes == csum_bytes) {

		calc_csum_metadata_size(inode, num_bytes, 0);

	} else {

		u64 orig_csum_bytes = BTRFS_I(inode)->csum_bytes;

		u64 bytes;



		/*

		 * This is tricky, but first we need to figure out how much we

		 * free'd from any free-ers that occured during this

		 * reservation, so we reset ->csum_bytes to the csum_bytes

		 * before we dropped our lock, and then call the free for the

		 * number of bytes that were freed while we were trying our

		 * reservation.

		 */

		bytes = csum_bytes - BTRFS_I(inode)->csum_bytes;

		BTRFS_I(inode)->csum_bytes = csum_bytes;

		to_free = calc_csum_metadata_size(inode, bytes, 0);





		/*

		 * Now we need to see how much we would have freed had we not

		 * been making this reservation and our ->csum_bytes were not

		 * artificially inflated.

		 */

		BTRFS_I(inode)->csum_bytes = csum_bytes - num_bytes;

		bytes = csum_bytes - orig_csum_bytes;

		bytes = calc_csum_metadata_size(inode, bytes, 0);



		/*

		 * Now reset ->csum_bytes to what it should be.  If bytes is

		 * more than to_free then we would have free'd more space had we

		 * not had an artificially high ->csum_bytes, so we need to free

		 * the remainder.  If bytes is the same or less then we don't

		 * need to do anything, the other free-ers did the correct

		 * thing.

		 */

		BTRFS_I(inode)->csum_bytes = orig_csum_bytes - num_bytes;

		if (bytes > to_free)

			to_free = bytes - to_free;

		else

		to_free = calc_csum_metadata_size(inode, num_bytes, 0);

			to_free = 0;

	}

	spin_unlock(&BTRFS_I(inode)->lock);

	if (dropped)

		to_free += btrfs_calc_trans_metadata_size(root, dropped);
@@ -7947,7 +7987,17 @@ int btrfs_read_block_groups(struct btrfs_root *root) 
		 * info has super bytes accounted for, otherwise we'll think

		 * we have more space than we actually do.

		 */

		exclude_super_stripes(root, cache);

		ret = exclude_super_stripes(root, cache);

		if (ret) {

			/*

			 * We may have excluded something, so call this just in

			 * case.

			 */

			free_excluded_extents(root, cache);

			kfree(cache->free_space_ctl);

			kfree(cache);

			goto error;

		}



		/*

		 * check for two cases, either we are full, and therefore
@@ -8089,7 +8139,17 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, 


	cache->last_byte_to_unpin = (u64)-1;

	cache->cached = BTRFS_CACHE_FINISHED;

	exclude_super_stripes(root, cache);

	ret = exclude_super_stripes(root, cache);

	if (ret) {

		/*

		 * We may have excluded something, so call this just in

		 * case.

		 */

		free_excluded_extents(root, cache);

		kfree(cache->free_space_ctl);

		kfree(cache);

		return ret;

	}



	add_new_free_space(cache, root->fs_info, chunk_offset,

			   chunk_offset + size);

fs/btrfs/extent_io.c

+33 −0
Original line number Diff line number Diff line
@@ -1257,6 +1257,39 @@ int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end) 
				GFP_NOFS);

}



int extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end)

{

	unsigned long index = start >> PAGE_CACHE_SHIFT;

	unsigned long end_index = end >> PAGE_CACHE_SHIFT;

	struct page *page;



	while (index <= end_index) {

		page = find_get_page(inode->i_mapping, index);

		BUG_ON(!page); /* Pages should be in the extent_io_tree */

		clear_page_dirty_for_io(page);

		page_cache_release(page);

		index++;

	}

	return 0;

}



int extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end)

{

	unsigned long index = start >> PAGE_CACHE_SHIFT;

	unsigned long end_index = end >> PAGE_CACHE_SHIFT;

	struct page *page;



	while (index <= end_index) {

		page = find_get_page(inode->i_mapping, index);

		BUG_ON(!page); /* Pages should be in the extent_io_tree */

		account_page_redirty(page);

		__set_page_dirty_nobuffers(page);

		page_cache_release(page);

		index++;

	}

	return 0;

}



/*

 * helper function to set both pages and extents in the tree writeback

 */

fs/btrfs/extent_io.h

+2 −0
Original line number Diff line number Diff line
@@ -325,6 +325,8 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long offset, 
		      unsigned long *map_len);

int extent_range_uptodate(struct extent_io_tree *tree,

			  u64 start, u64 end);

int extent_range_clear_dirty_for_io(struct inode *inode, u64 start, u64 end);

int extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end);

int extent_clear_unlock_delalloc(struct inode *inode,

				struct extent_io_tree *tree,

				u64 start, u64 end, struct page *locked_page,