Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs (521d4746) · Commits · 戴 / test

fs/btrfs/ctree.h

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -3387,6 +3387,8 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,

	int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,		int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
	struct btrfs_root *root);		struct btrfs_root *root);
			int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
			struct btrfs_root *root);
	int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);		int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr);
	int btrfs_free_block_groups(struct btrfs_fs_info *info);		int btrfs_free_block_groups(struct btrfs_fs_info *info);
	int btrfs_read_block_groups(struct btrfs_root *root);		int btrfs_read_block_groups(struct btrfs_root *root);
	@@ -3909,6 +3911,9 @@ int btrfs_prealloc_file_range_trans(struct inode *inode,
	loff_t actual_len, u64 *alloc_hint);		loff_t actual_len, u64 *alloc_hint);
	int btrfs_inode_check_errors(struct inode *inode);		int btrfs_inode_check_errors(struct inode *inode);
	extern const struct dentry_operations btrfs_dentry_operations;		extern const struct dentry_operations btrfs_dentry_operations;
			#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
			void btrfs_test_inode_set_ops(struct inode *inode);
			#endif

	/* ioctl.c */		/* ioctl.c */
	long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);		long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

fs/btrfs/disk-io.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -3921,7 +3921,7 @@ static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
	}		}
	if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)		if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
	+ sizeof(struct btrfs_chunk)) {		+ sizeof(struct btrfs_chunk)) {
	printk(KERN_ERR "BTRFS: system chunk array too small %u < %lu\n",		printk(KERN_ERR "BTRFS: system chunk array too small %u < %zu\n",
	btrfs_super_sys_array_size(sb),		btrfs_super_sys_array_size(sb),
	sizeof(struct btrfs_disk_key)		sizeof(struct btrfs_disk_key)
	+ sizeof(struct btrfs_chunk));		+ sizeof(struct btrfs_chunk));

fs/btrfs/extent-tree.c

+34 −1

Original line number	Original line	Diff line number	Diff line
	@@ -3325,6 +3325,32 @@ out:
	return ret;		return ret;
	}		}

			int btrfs_setup_space_cache(struct btrfs_trans_handle *trans,
			struct btrfs_root *root)
			{
			struct btrfs_block_group_cache cache, tmp;
			struct btrfs_transaction *cur_trans = trans->transaction;
			struct btrfs_path *path;

			if (list_empty(&cur_trans->dirty_bgs) \|\|
			!btrfs_test_opt(root, SPACE_CACHE))
			return 0;

			path = btrfs_alloc_path();
			if (!path)
			return -ENOMEM;

			/* Could add new block groups, use _safe just in case */
			list_for_each_entry_safe(cache, tmp, &cur_trans->dirty_bgs,
			dirty_list) {
			if (cache->disk_cache_state == BTRFS_DC_CLEAR)
			cache_save_setup(cache, trans, path);
			}

			btrfs_free_path(path);
			return 0;
			}

	int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,		int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
	struct btrfs_root *root)		struct btrfs_root *root)
	{		{
	@@ -5110,7 +5136,11 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
	num_bytes = ALIGN(num_bytes, root->sectorsize);		num_bytes = ALIGN(num_bytes, root->sectorsize);

	spin_lock(&BTRFS_I(inode)->lock);		spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents++;		nr_extents = (unsigned)div64_u64(num_bytes +
			BTRFS_MAX_EXTENT_SIZE - 1,
			BTRFS_MAX_EXTENT_SIZE);
			BTRFS_I(inode)->outstanding_extents += nr_extents;
			nr_extents = 0;

	if (BTRFS_I(inode)->outstanding_extents >		if (BTRFS_I(inode)->outstanding_extents >
	BTRFS_I(inode)->reserved_extents)		BTRFS_I(inode)->reserved_extents)
	@@ -5255,6 +5285,9 @@ void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
	if (dropped > 0)		if (dropped > 0)
	to_free += btrfs_calc_trans_metadata_size(root, dropped);		to_free += btrfs_calc_trans_metadata_size(root, dropped);

			if (btrfs_test_is_dummy_root(root))
			return;

	trace_btrfs_space_reservation(root->fs_info, "delalloc",		trace_btrfs_space_reservation(root->fs_info, "delalloc",
	btrfs_ino(inode), to_free, 0);		btrfs_ino(inode), to_free, 0);
	if (root->fs_info->quota_enabled) {		if (root->fs_info->quota_enabled) {

fs/btrfs/extent_io.c

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -4968,6 +4968,12 @@ static int release_extent_buffer(struct extent_buffer *eb)

	/* Should be safe to release our pages at this point */		/* Should be safe to release our pages at this point */
	btrfs_release_extent_buffer_page(eb);		btrfs_release_extent_buffer_page(eb);
			#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
			if (unlikely(test_bit(EXTENT_BUFFER_DUMMY, &eb->bflags))) {
			__free_extent_buffer(eb);
			return 1;
			}
			#endif
	call_rcu(&eb->rcu_head, btrfs_release_extent_buffer_rcu);		call_rcu(&eb->rcu_head, btrfs_release_extent_buffer_rcu);
	return 1;		return 1;
	}		}

fs/btrfs/inode.c

+84 −28

Original line number	Original line	Diff line number	Diff line
	@@ -108,6 +108,13 @@ static struct extent_map create_pinned_em(struct inode inode, u64 start,

	static int btrfs_dirty_inode(struct inode *inode);		static int btrfs_dirty_inode(struct inode *inode);

			#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
			void btrfs_test_inode_set_ops(struct inode *inode)
			{
			BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
			}
			#endif

	static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,		static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
	struct inode inode, struct inode dir,		struct inode inode, struct inode dir,
	const struct qstr *qstr)		const struct qstr *qstr)
	@@ -1542,30 +1549,17 @@ static void btrfs_split_extent_hook(struct inode *inode,
	u64 new_size;		u64 new_size;

	/*		/*
	* We need the largest size of the remaining extent to see if we		* See the explanation in btrfs_merge_extent_hook, the same
	* need to add a new outstanding extent. Think of the following		* applies here, just in reverse.
	* case
	*
	* [MEAX_EXTENT_SIZEx2 - 4k][4k]
	*
	* The new_size would just be 4k and we'd think we had enough
	* outstanding extents for this if we only took one side of the
	* split, same goes for the other direction. We need to see if
	* the larger size still is the same amount of extents as the
	* original size, because if it is we need to add a new
	* outstanding extent. But if we split up and the larger size
	* is less than the original then we are good to go since we've
	* already accounted for the extra extent in our original
	* accounting.
	*/		*/
	new_size = orig->end - split + 1;		new_size = orig->end - split + 1;
	if ((split - orig->start) > new_size)		num_extents = div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,
			BTRFS_MAX_EXTENT_SIZE);
	new_size = split - orig->start;		new_size = split - orig->start;
			num_extents += div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,
	num_extents = div64_u64(size + BTRFS_MAX_EXTENT_SIZE - 1,
	BTRFS_MAX_EXTENT_SIZE);		BTRFS_MAX_EXTENT_SIZE);
	if (div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,		if (div64_u64(size + BTRFS_MAX_EXTENT_SIZE - 1,
	BTRFS_MAX_EXTENT_SIZE) < num_extents)		BTRFS_MAX_EXTENT_SIZE) >= num_extents)
	return;		return;
	}		}

	@@ -1591,8 +1585,10 @@ static void btrfs_merge_extent_hook(struct inode *inode,
	if (!(other->state & EXTENT_DELALLOC))		if (!(other->state & EXTENT_DELALLOC))
	return;		return;

	old_size = other->end - other->start + 1;		if (new->start > other->start)
	new_size = old_size + (new->end - new->start + 1);		new_size = new->end - other->start + 1;
			else
			new_size = other->end - new->start + 1;

	/* we're not bigger than the max, unreserve the space and go */		/* we're not bigger than the max, unreserve the space and go */
	if (new_size <= BTRFS_MAX_EXTENT_SIZE) {		if (new_size <= BTRFS_MAX_EXTENT_SIZE) {
	@@ -1603,13 +1599,32 @@ static void btrfs_merge_extent_hook(struct inode *inode,
	}		}

	/*		/*
	* If we grew by another max_extent, just return, we want to keep that		* We have to add up either side to figure out how many extents were
	* reserved amount.		* accounted for before we merged into one big extent. If the number of
			* extents we accounted for is <= the amount we need for the new range
			* then we can return, otherwise drop. Think of it like this
			*
			* [ 4k][MAX_SIZE]
			*
			* So we've grown the extent by a MAX_SIZE extent, this would mean we
			* need 2 outstanding extents, on one side we have 1 and the other side
			* we have 1 so they are == and we can return. But in this case
			*
			* [MAX_SIZE+4k][MAX_SIZE+4k]
			*
			* Each range on their own accounts for 2 extents, but merged together
			* they are only 3 extents worth of accounting, so we need to drop in
			* this case.
	*/		*/
			old_size = other->end - other->start + 1;
	num_extents = div64_u64(old_size + BTRFS_MAX_EXTENT_SIZE - 1,		num_extents = div64_u64(old_size + BTRFS_MAX_EXTENT_SIZE - 1,
	BTRFS_MAX_EXTENT_SIZE);		BTRFS_MAX_EXTENT_SIZE);
			old_size = new->end - new->start + 1;
			num_extents += div64_u64(old_size + BTRFS_MAX_EXTENT_SIZE - 1,
			BTRFS_MAX_EXTENT_SIZE);

	if (div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,		if (div64_u64(new_size + BTRFS_MAX_EXTENT_SIZE - 1,
	BTRFS_MAX_EXTENT_SIZE) > num_extents)		BTRFS_MAX_EXTENT_SIZE) >= num_extents)
	return;		return;

	spin_lock(&BTRFS_I(inode)->lock);		spin_lock(&BTRFS_I(inode)->lock);
	@@ -1686,6 +1701,10 @@ static void btrfs_set_bit_hook(struct inode *inode,
	spin_unlock(&BTRFS_I(inode)->lock);		spin_unlock(&BTRFS_I(inode)->lock);
	}		}

			/* For sanity tests */
			if (btrfs_test_is_dummy_root(root))
			return;

	__percpu_counter_add(&root->fs_info->delalloc_bytes, len,		__percpu_counter_add(&root->fs_info->delalloc_bytes, len,
	root->fs_info->delalloc_batch);		root->fs_info->delalloc_batch);
	spin_lock(&BTRFS_I(inode)->lock);		spin_lock(&BTRFS_I(inode)->lock);
	@@ -1741,6 +1760,10 @@ static void btrfs_clear_bit_hook(struct inode *inode,
	root != root->fs_info->tree_root)		root != root->fs_info->tree_root)
	btrfs_delalloc_release_metadata(inode, len);		btrfs_delalloc_release_metadata(inode, len);

			/* For sanity tests. */
			if (btrfs_test_is_dummy_root(root))
			return;

	if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
	&& do_list && !(state->state & EXTENT_NORESERVE))		&& do_list && !(state->state & EXTENT_NORESERVE))
	btrfs_free_reserved_data_space(inode, len);		btrfs_free_reserved_data_space(inode, len);
	@@ -7213,7 +7236,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
	u64 start = iblock << inode->i_blkbits;		u64 start = iblock << inode->i_blkbits;
	u64 lockstart, lockend;		u64 lockstart, lockend;
	u64 len = bh_result->b_size;		u64 len = bh_result->b_size;
	u64 orig_len = len;		u64 *outstanding_extents = NULL;
	int unlock_bits = EXTENT_LOCKED;		int unlock_bits = EXTENT_LOCKED;
	int ret = 0;		int ret = 0;

	@@ -7225,6 +7248,16 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
	lockstart = start;		lockstart = start;
	lockend = start + len - 1;		lockend = start + len - 1;

			if (current->journal_info) {
			/*
			* Need to pull our outstanding extents and set journal_info to NULL so
			* that anything that needs to check if there's a transction doesn't get
			* confused.
			*/
			outstanding_extents = current->journal_info;
			current->journal_info = NULL;
			}

	/*		/*
	* If this errors out it's because we couldn't invalidate pagecache for		* If this errors out it's because we couldn't invalidate pagecache for
	* this range and we need to fallback to buffered.		* this range and we need to fallback to buffered.
	@@ -7348,11 +7381,20 @@ unlock:
	if (start + len > i_size_read(inode))		if (start + len > i_size_read(inode))
	i_size_write(inode, start + len);		i_size_write(inode, start + len);

	if (len < orig_len) {		/*
			* If we have an outstanding_extents count still set then we're
			* within our reservation, otherwise we need to adjust our inode
			* counter appropriately.
			*/
			if (*outstanding_extents) {
			(*outstanding_extents)--;
			} else {
	spin_lock(&BTRFS_I(inode)->lock);		spin_lock(&BTRFS_I(inode)->lock);
	BTRFS_I(inode)->outstanding_extents++;		BTRFS_I(inode)->outstanding_extents++;
	spin_unlock(&BTRFS_I(inode)->lock);		spin_unlock(&BTRFS_I(inode)->lock);
	}		}

			current->journal_info = outstanding_extents;
	btrfs_free_reserved_data_space(inode, len);		btrfs_free_reserved_data_space(inode, len);
	}		}

	@@ -7376,6 +7418,8 @@ unlock:
	unlock_err:		unlock_err:
	clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,		clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
	unlock_bits, 1, 0, &cached_state, GFP_NOFS);		unlock_bits, 1, 0, &cached_state, GFP_NOFS);
			if (outstanding_extents)
			current->journal_info = outstanding_extents;
	return ret;		return ret;
	}		}

	@@ -8075,6 +8119,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
	{		{
	struct file *file = iocb->ki_filp;		struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;		struct inode *inode = file->f_mapping->host;
			u64 outstanding_extents = 0;
	size_t count = 0;		size_t count = 0;
	int flags = 0;		int flags = 0;
	bool wakeup = true;		bool wakeup = true;
	@@ -8112,6 +8157,16 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
	ret = btrfs_delalloc_reserve_space(inode, count);		ret = btrfs_delalloc_reserve_space(inode, count);
	if (ret)		if (ret)
	goto out;		goto out;
			outstanding_extents = div64_u64(count +
			BTRFS_MAX_EXTENT_SIZE - 1,
			BTRFS_MAX_EXTENT_SIZE);

			/*
			* We need to know how many extents we reserved so that we can
			* do the accounting properly if we go over the number we
			* originally calculated. Abuse current->journal_info for this.
			*/
			current->journal_info = &outstanding_extents;
	} else if (test_bit(BTRFS_INODE_READDIO_NEED_LOCK,		} else if (test_bit(BTRFS_INODE_READDIO_NEED_LOCK,
	&BTRFS_I(inode)->runtime_flags)) {		&BTRFS_I(inode)->runtime_flags)) {
	inode_dio_done(inode);		inode_dio_done(inode);
	@@ -8124,6 +8179,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
	iter, offset, btrfs_get_blocks_direct, NULL,		iter, offset, btrfs_get_blocks_direct, NULL,
	btrfs_submit_direct, flags);		btrfs_submit_direct, flags);
	if (rw & WRITE) {		if (rw & WRITE) {
			current->journal_info = NULL;
	if (ret < 0 && ret != -EIOCBQUEUED)		if (ret < 0 && ret != -EIOCBQUEUED)
	btrfs_delalloc_release_space(inode, count);		btrfs_delalloc_release_space(inode, count);
	else if (ret >= 0 && (size_t)ret < count)		else if (ret >= 0 && (size_t)ret < count)

Admin message