fs/btrfs/block-rsv.c

1 // SPDX-License-Identifier: GPL-2.0
5 #include "block-rsv.h"
6 #include "space-info.h"
8 #include "block-group.h"
16  *   reservations.  Each block_rsv has a ->size and a ->reserved.  ->size is
17  *   how large we want our block rsv to be, ->reserved is how much space is
20  *   ->failfast exists for the truncate case, and is described below.
24  *   -> Reserve
28  *     accounted for in space_info->bytes_may_use, and then add the bytes to
29  *     ->reserved, and ->size in the case of btrfs_block_rsv_add.
31  *     ->size is an over-estimation of how much we may use for a particular
34  *   -> Use
39  *     ->reserved has enough space for our tree block allocation.  Once
40  *     successful we subtract fs_info->nodesize from ->reserved.
42  *   -> Finish
46  *     from ->size, and then subtract ->size from ->reserved and free up the
51  *     space_info->bytes_may_use.
70  *   The individual item sizes are determined by the per-inode size
72  *   straightforward, it's just the calculation of ->size encodes a lot of
78  *   We assume each one of these delayed refs are going to use a full
79  *   reservation.  We use the transaction items and pre-reserve space for every
80  *   operation, and use this reservation to refill any gap between ->size and
81  *   ->reserved that may exist.
84  *   count from ->size and free up reservations as necessary.  Since this is
96  *   allocate a block reserve, set it to some size, and then truncate bytes
97  *   until we have no space left.  With ->failfast set we'll simply return
101  *   re-reserve.
109 	struct btrfs_space_info *space_info = block_rsv->space_info;
113 	spin_lock(&block_rsv->lock);
114 	if (num_bytes == (u64)-1) {
115 		num_bytes = block_rsv->size;
116 		qgroup_to_release = block_rsv->qgroup_rsv_size;
118 	block_rsv->size -= num_bytes;
119 	if (block_rsv->reserved >= block_rsv->size) {
120 		num_bytes = block_rsv->reserved - block_rsv->size;
121 		block_rsv->reserved = block_rsv->size;
122 		block_rsv->full = true;
127 	    block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {
128 		qgroup_to_release = block_rsv->qgroup_rsv_reserved -
129 				    block_rsv->qgroup_rsv_size;
130 		block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;
134 	spin_unlock(&block_rsv->lock);
139 			spin_lock(&dest->lock);
140 			if (!dest->full) {
143 				bytes_to_add = dest->size - dest->reserved;
145 				dest->reserved += bytes_to_add;
146 				if (dest->reserved >= dest->size)
147 					dest->full = true;
148 				num_bytes -= bytes_to_add;
150 			spin_unlock(&dest->lock);
177 	spin_lock_init(&rsv->lock);
178 	rsv->type = type;
186 	rsv->space_info = btrfs_find_space_info(fs_info,
208 	btrfs_block_rsv_release(fs_info, rsv, (u64)-1, NULL);
221 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,
232 	int ret = -ENOSPC;
234 	spin_lock(&block_rsv->lock);
235 	num_bytes = mult_perc(block_rsv->size, min_percent);
236 	if (block_rsv->reserved >= num_bytes)
238 	spin_unlock(&block_rsv->lock);
247 	int ret = -ENOSPC;
252 	spin_lock(&block_rsv->lock);
253 	if (block_rsv->reserved >= num_bytes)
256 		num_bytes -= block_rsv->reserved;
257 	spin_unlock(&block_rsv->lock);
262 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,
276 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
277 	struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
282 	 * otherwise dump into the global delayed reserve if it is not full.
284 	if (block_rsv->type == BTRFS_BLOCK_RSV_DELOPS)
289 	if (target && block_rsv->space_info != target->space_info)
298 	int ret = -ENOSPC;
300 	spin_lock(&block_rsv->lock);
301 	if (block_rsv->reserved >= num_bytes) {
302 		block_rsv->reserved -= num_bytes;
303 		if (block_rsv->reserved < block_rsv->size)
304 			block_rsv->full = false;
307 	spin_unlock(&block_rsv->lock);
314 	spin_lock(&block_rsv->lock);
315 	block_rsv->reserved += num_bytes;
317 		block_rsv->size += num_bytes;
318 	else if (block_rsv->reserved >= block_rsv->size)
319 		block_rsv->full = true;
320 	spin_unlock(&block_rsv->lock);
325 	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
326 	struct btrfs_space_info *sinfo = block_rsv->space_info;
328 	u64 num_bytes = btrfs_root_used(&fs_info->tree_root->root_item);
332 	 * The global block rsv is based on the size of the extent tree, the
339 	read_lock(&fs_info->global_root_lock);
340 	rbtree_postorder_for_each_entry_safe(root, tmp, &fs_info->global_root_tree,
345 			num_bytes += btrfs_root_used(&root->root_item);
349 	read_unlock(&fs_info->global_root_lock);
352 		num_bytes += btrfs_root_used(&fs_info->block_group_root->root_item);
357 		num_bytes += btrfs_root_used(&fs_info->stripe_root->root_item);
377 	spin_lock(&sinfo->lock);
378 	spin_lock(&block_rsv->lock);
380 	block_rsv->size = min_t(u64, num_bytes, SZ_512M);
382 	if (block_rsv->reserved < block_rsv->size) {
383 		num_bytes = block_rsv->size - block_rsv->reserved;
385 		block_rsv->reserved = block_rsv->size;
386 	} else if (block_rsv->reserved > block_rsv->size) {
387 		num_bytes = block_rsv->reserved - block_rsv->size;
388 		btrfs_space_info_update_bytes_may_use(sinfo, -num_bytes);
389 		block_rsv->reserved = block_rsv->size;
393 	block_rsv->full = (block_rsv->reserved == block_rsv->size);
395 	if (block_rsv->size >= sinfo->total_bytes)
396 		sinfo->force_alloc = CHUNK_ALLOC_FORCE;
397 	spin_unlock(&block_rsv->lock);
398 	spin_unlock(&sinfo->lock);
403 	struct btrfs_fs_info *fs_info = root->fs_info;
411 		root->block_rsv = &fs_info->delayed_refs_rsv;
416 		root->block_rsv = &fs_info->global_block_rsv;
419 		root->block_rsv = &fs_info->chunk_block_rsv;
422 		root->block_rsv = &fs_info->treelog_rsv;
425 		root->block_rsv = NULL;
435 	fs_info->chunk_block_rsv.space_info = space_info;
438 	fs_info->global_block_rsv.space_info = space_info;
439 	fs_info->trans_block_rsv.space_info = space_info;
440 	fs_info->empty_block_rsv.space_info = space_info;
441 	fs_info->delayed_block_rsv.space_info = space_info;
442 	fs_info->delayed_refs_rsv.space_info = space_info;
446 		fs_info->treelog_rsv.space_info = space_info;
448 		ASSERT(space_info->sub_group[0]->subgroup_id == BTRFS_SUB_GROUP_TREELOG);
449 		fs_info->treelog_rsv.space_info = space_info->sub_group[0];
457 	btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1,
459 	WARN_ON(fs_info->trans_block_rsv.size > 0);
460 	WARN_ON(fs_info->trans_block_rsv.reserved > 0);
461 	WARN_ON(fs_info->chunk_block_rsv.size > 0);
462 	WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
463 	WARN_ON(fs_info->delayed_block_rsv.size > 0);
464 	WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
465 	WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);
466 	WARN_ON(fs_info->delayed_refs_rsv.size > 0);
473 	struct btrfs_fs_info *fs_info = root->fs_info;
476 	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||
477 	    (root == fs_info->uuid_root) ||
478 	    (trans->adding_csums && btrfs_root_id(root) == BTRFS_CSUM_TREE_OBJECTID))
479 		block_rsv = trans->block_rsv;
482 		block_rsv = root->block_rsv;
485 		block_rsv = &fs_info->empty_block_rsv;
494 	struct btrfs_fs_info *fs_info = root->fs_info;
496 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
509 	if (block_rsv->failfast)
512 	if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {
522 	if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&
530 				block_rsv->type, ret);
533 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,
542 	if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&
543 	    block_rsv->space_info == global_rsv->space_info) {
555 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info, blocksize,
573 	spin_lock(&rsv->lock);
574 	if (rsv->reserved < needed_bytes)
575 		ret = -ENOSPC;
578 	spin_unlock(&rsv->lock);