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

Commit 7cf5b976 authored by Qu Wenruo's avatar Qu Wenruo Committed by Chris Mason
Browse files

btrfs: qgroup: Cleanup old inaccurate facilities 



Cleanup the old facilities which use old btrfs_qgroup_reserve() function
call, replace them with the newer version, and remove the "__" prefix in
them.

Also, make btrfs_qgroup_reserve/free() functions private, as they are
now only used inside qgroup codes.

Now, the whole btrfs qgroup is swithed to use the new reserve facilities.

Signed-off-by: default avatarQu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: default avatarChris Mason <clm@fb.com>
parent df480633

fs/btrfs/ctree.h

+4 −8
Original line number Diff line number Diff line
@@ -3452,11 +3452,9 @@ enum btrfs_reserve_flush_enum { 
	BTRFS_RESERVE_FLUSH_ALL,

};



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

int __btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);

int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len);

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

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

void __btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);

void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len);

void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,

				struct btrfs_root *root);

void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans);
@@ -3472,10 +3470,8 @@ void btrfs_subvolume_release_metadata(struct btrfs_root *root, 
				      u64 qgroup_reserved);

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

int __btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);

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

void __btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);

int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len);

void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len);

void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);

struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,

					      unsigned short type);

fs/btrfs/extent-tree.c

+11 −98
Original line number Diff line number Diff line
@@ -3356,7 +3356,7 @@ static int cache_save_setup(struct btrfs_block_group_cache *block_group, 
	num_pages *= 16;

	num_pages *= PAGE_CACHE_SIZE;



	ret = __btrfs_check_data_free_space(inode, 0, num_pages);

	ret = btrfs_check_data_free_space(inode, 0, num_pages);

	if (ret)

		goto out_put;
@@ -3365,7 +3365,7 @@ static int cache_save_setup(struct btrfs_block_group_cache *block_group, 
					      &alloc_hint);

	if (!ret)

		dcs = BTRFS_DC_SETUP;

	__btrfs_free_reserved_data_space(inode, 0, num_pages);

	btrfs_free_reserved_data_space(inode, 0, num_pages);



out_put:

	iput(inode);
@@ -4033,28 +4033,12 @@ int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes) 
	return ret;

}



/*

 * This will check the space that the inode allocates from to make sure we have

 * enough space for bytes.

 */

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

{

	struct btrfs_root *root = BTRFS_I(inode)->root;

	int ret;



	ret = btrfs_alloc_data_chunk_ondemand(inode, bytes);

	if (ret < 0)

		return ret;

	ret = btrfs_qgroup_reserve(root, write_bytes);

	return ret;

}



/*

 * New check_data_free_space() with ability for precious data reservation

 * Will replace old btrfs_check_data_free_space(), but for patch split,

 * add a new function first and then replace it.

 */

int __btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len)

int btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len)

{

	struct btrfs_root *root = BTRFS_I(inode)->root;

	int ret;
@@ -4073,26 +4057,6 @@ int __btrfs_check_data_free_space(struct inode *inode, u64 start, u64 len) 
	return ret;

}



/*

 * Called if we need to clear a data reservation for this inode.

 */

void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)

{

	struct btrfs_root *root = BTRFS_I(inode)->root;

	struct btrfs_space_info *data_sinfo;



	/* make sure bytes are sectorsize aligned */

	bytes = ALIGN(bytes, root->sectorsize);



	data_sinfo = root->fs_info->data_sinfo;

	spin_lock(&data_sinfo->lock);

	WARN_ON(data_sinfo->bytes_may_use < bytes);

	data_sinfo->bytes_may_use -= bytes;

	trace_btrfs_space_reservation(root->fs_info, "space_info",

				      data_sinfo->flags, bytes, 0);

	spin_unlock(&data_sinfo->lock);

}



/*

 * Called if we need to clear a data reservation for this inode

 * Normally in a error case.
@@ -4100,7 +4064,7 @@ void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes) 
 * This one will handle the per-indoe data rsv map for accurate reserved

 * space framework.

 */

void __btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len)

void btrfs_free_reserved_data_space(struct inode *inode, u64 start, u64 len)

{

	struct btrfs_root *root = BTRFS_I(inode)->root;

	struct btrfs_space_info *data_sinfo;
@@ -5715,7 +5679,7 @@ void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes) 
}



/**

 * __btrfs_delalloc_reserve_space - reserve data and metadata space for

 * btrfs_delalloc_reserve_space - reserve data and metadata space for

 * delalloc

 * @inode: inode we're writing to

 * @start: start range we are writing to
@@ -5739,53 +5703,21 @@ void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes) 
 * Return 0 for success

 * Return <0 for error(-ENOSPC or -EQUOT)

 */

int __btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len)

int btrfs_delalloc_reserve_space(struct inode *inode, u64 start, u64 len)

{

	int ret;



	ret = __btrfs_check_data_free_space(inode, start, len);

	ret = btrfs_check_data_free_space(inode, start, len);

	if (ret < 0)

		return ret;

	ret = btrfs_delalloc_reserve_metadata(inode, len);

	if (ret < 0)

		__btrfs_free_reserved_data_space(inode, start, len);

		btrfs_free_reserved_data_space(inode, start, len);

	return ret;

}



/**

 * btrfs_delalloc_reserve_space - reserve data and metadata space for delalloc

 * @inode: inode we're writing to

 * @num_bytes: the number of bytes we want to allocate

 *

 * This will do the following things

 *

 * o reserve space in the data space info for num_bytes

 * o reserve space in the metadata space info based on number of outstanding

 *   extents and how much csums will be needed

 * o add to the inodes ->delalloc_bytes

 * o add it to the fs_info's delalloc inodes list.

 *

 * This will return 0 for success and -ENOSPC if there is no space left.

 */

int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes)

{

	int ret;



	ret = btrfs_check_data_free_space(inode, num_bytes, num_bytes);

	if (ret)

		return ret;



	ret = btrfs_delalloc_reserve_metadata(inode, num_bytes);

	if (ret) {

		btrfs_free_reserved_data_space(inode, num_bytes);

		return ret;

	}



	return 0;

}



/**

 * __btrfs_delalloc_release_space - release data and metadata space for delalloc

 * btrfs_delalloc_release_space - release data and metadata space for delalloc

 * @inode: inode we're releasing space for

 * @start: start position of the space already reserved

 * @len: the len of the space already reserved
@@ -5799,29 +5731,10 @@ int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes) 
 * list if there are no delalloc bytes left.

 * Also it will handle the qgroup reserved space.

 */

void __btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len)

void btrfs_delalloc_release_space(struct inode *inode, u64 start, u64 len)

{

	btrfs_delalloc_release_metadata(inode, len);

	__btrfs_free_reserved_data_space(inode, start, len);

}



/**

 * btrfs_delalloc_release_space - release data and metadata space for delalloc

 * @inode: inode we're releasing space for

 * @num_bytes: the number of bytes we want to free up

 *

 * This must be matched with a call to btrfs_delalloc_reserve_space.  This is

 * called in the case that we don't need the metadata AND data reservations

 * anymore.  So if there is an error or we insert an inline extent.

 *

 * This function will release the metadata space that was not used and will

 * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes

 * list if there are no delalloc bytes left.

 */

void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes)

{

	btrfs_delalloc_release_metadata(inode, num_bytes);

	btrfs_free_reserved_data_space(inode, num_bytes);

	btrfs_free_reserved_data_space(inode, start, len);

}



static int update_block_group(struct btrfs_trans_handle *trans,

fs/btrfs/file.c

+7 −8
Original line number Diff line number Diff line
@@ -1529,7 +1529,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file, 
				goto reserve_metadata;

			}

		}

		ret = __btrfs_check_data_free_space(inode, pos, write_bytes);

		ret = btrfs_check_data_free_space(inode, pos, write_bytes);

		if (ret < 0)

			break;
@@ -1537,7 +1537,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file, 
		ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes);

		if (ret) {

			if (!only_release_metadata)

				__btrfs_free_reserved_data_space(inode, pos,

				btrfs_free_reserved_data_space(inode, pos,

							       write_bytes);

			else

				btrfs_end_write_no_snapshoting(root);
@@ -1608,7 +1608,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file, 
				btrfs_delalloc_release_metadata(inode,

								release_bytes);

			else

				__btrfs_delalloc_release_space(inode, pos,

				btrfs_delalloc_release_space(inode, pos,

							     release_bytes);

		}
@@ -1661,8 +1661,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file, 
			btrfs_end_write_no_snapshoting(root);

			btrfs_delalloc_release_metadata(inode, release_bytes);

		} else {

			__btrfs_delalloc_release_space(inode, pos,

						       release_bytes);

			btrfs_delalloc_release_space(inode, pos, release_bytes);

		}

	}
@@ -2708,7 +2707,7 @@ static long btrfs_fallocate(struct file *file, int mode, 
out:

	mutex_unlock(&inode->i_mutex);

	/* Let go of our reservation. */

	__btrfs_free_reserved_data_space(inode, alloc_start,

	btrfs_free_reserved_data_space(inode, alloc_start,

				       alloc_end - alloc_start);

	return ret;

}

fs/btrfs/inode-map.c

+3 −3
Original line number Diff line number Diff line
@@ -488,17 +488,17 @@ int btrfs_save_ino_cache(struct btrfs_root *root, 
	/* Just to make sure we have enough space */

	prealloc += 8 * PAGE_CACHE_SIZE;



	ret = __btrfs_delalloc_reserve_space(inode, 0, prealloc);

	ret = btrfs_delalloc_reserve_space(inode, 0, prealloc);

	if (ret)

		goto out_put;



	ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, prealloc,

					      prealloc, prealloc, &alloc_hint);

	if (ret) {

		__btrfs_delalloc_release_space(inode, 0, prealloc);

		btrfs_delalloc_release_space(inode, 0, prealloc);

		goto out_put;

	}

	__btrfs_free_reserved_data_space(inode, 0, prealloc);

	btrfs_free_reserved_data_space(inode, 0, prealloc);



	ret = btrfs_write_out_ino_cache(root, trans, path, inode);

out_put:

fs/btrfs/inode.c

+17 −17
Original line number Diff line number Diff line
@@ -1769,7 +1769,7 @@ static void btrfs_clear_bit_hook(struct inode *inode, 


		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID

		    && do_list && !(state->state & EXTENT_NORESERVE))

			__btrfs_free_reserved_data_space(inode, state->start,

			btrfs_free_reserved_data_space(inode, state->start,

						       len);



		__percpu_counter_add(&root->fs_info->delalloc_bytes, -len,
@@ -1993,7 +1993,7 @@ static void btrfs_writepage_fixup_worker(struct btrfs_work *work) 
		goto again;

	}



	ret = __btrfs_delalloc_reserve_space(inode, page_start,

	ret = btrfs_delalloc_reserve_space(inode, page_start,

					   PAGE_CACHE_SIZE);

	if (ret) {

		mapping_set_error(page->mapping, ret);
@@ -4640,7 +4640,7 @@ int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len, 
	if ((offset & (blocksize - 1)) == 0 &&

	    (!len || ((len & (blocksize - 1)) == 0)))

		goto out;

	ret = __btrfs_delalloc_reserve_space(inode,

	ret = btrfs_delalloc_reserve_space(inode,

			round_down(from, PAGE_CACHE_SIZE), PAGE_CACHE_SIZE);

	if (ret)

		goto out;
@@ -4648,7 +4648,7 @@ int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len, 
again:

	page = find_or_create_page(mapping, index, mask);

	if (!page) {

		__btrfs_delalloc_release_space(inode,

		btrfs_delalloc_release_space(inode,

				round_down(from, PAGE_CACHE_SIZE),

				PAGE_CACHE_SIZE);

		ret = -ENOMEM;
@@ -4718,7 +4718,7 @@ int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len, 


out_unlock:

	if (ret)

		__btrfs_delalloc_release_space(inode, page_start,

		btrfs_delalloc_release_space(inode, page_start,

					     PAGE_CACHE_SIZE);

	unlock_page(page);

	page_cache_release(page);
@@ -7650,7 +7650,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock, 
			spin_unlock(&BTRFS_I(inode)->lock);

		}



		__btrfs_free_reserved_data_space(inode, start, len);

		btrfs_free_reserved_data_space(inode, start, len);

		WARN_ON(dio_data->reserve < len);

		dio_data->reserve -= len;

		current->journal_info = dio_data;
@@ -8440,7 +8440,7 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, 
			mutex_unlock(&inode->i_mutex);

			relock = true;

		}

		ret = __btrfs_delalloc_reserve_space(inode, offset, count);

		ret = btrfs_delalloc_reserve_space(inode, offset, count);

		if (ret)

			goto out;

		dio_data.outstanding_extents = div64_u64(count +
@@ -8469,10 +8469,10 @@ static ssize_t btrfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter, 
		current->journal_info = NULL;

		if (ret < 0 && ret != -EIOCBQUEUED) {

			if (dio_data.reserve)

				__btrfs_delalloc_release_space(inode, offset,

				btrfs_delalloc_release_space(inode, offset,

							     dio_data.reserve);

		} else if (ret >= 0 && (size_t)ret < count)

			__btrfs_delalloc_release_space(inode, offset,

			btrfs_delalloc_release_space(inode, offset,

						     count - (size_t)ret);

	}

out:
@@ -8684,7 +8684,7 @@ int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 
	page_start = page_offset(page);

	page_end = page_start + PAGE_CACHE_SIZE - 1;



	ret = __btrfs_delalloc_reserve_space(inode, page_start,

	ret = btrfs_delalloc_reserve_space(inode, page_start,

					   PAGE_CACHE_SIZE);

	if (!ret) {

		ret = file_update_time(vma->vm_file);
@@ -8780,7 +8780,7 @@ int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 
	}

	unlock_page(page);

out:

	__btrfs_delalloc_release_space(inode, page_start, PAGE_CACHE_SIZE);

	btrfs_delalloc_release_space(inode, page_start, PAGE_CACHE_SIZE);

out_noreserve:

	sb_end_pagefault(inode->i_sb);

	return ret;