1 // SPDX-License-Identifier: GPL-2.0
5 #include "block-rsv.h"
6 #include "space-info.h"
8 #include "block-group.h"
9 #include "disk-io.h"
17  *   reservations.  Each block_rsv has a ->size and a ->reserved.  ->size is
18  *   how large we want our block rsv to be, ->reserved is how much space is
21  *   ->failfast exists for the truncate case, and is described below.
25  *   -> Reserve
29  *     accounted for in space_info->bytes_may_use, and then add the bytes to
30  *     ->reserved, and ->size in the case of btrfs_block_rsv_add.
32  *     ->size is an over-estimation of how much we may use for a particular
35  *   -> Use
40  *     ->reserved has enough space for our tree block allocation.  Once
41  *     successful we subtract fs_info->nodesize from ->reserved.
43  *   -> Finish
47  *     from ->size, and then subtract ->size from ->reserved and free up the
52  *     space_info->bytes_may_use.
71  *   The individual item sizes are determined by the per-inode size
73  *   straightforward, it's just the calculation of ->size encodes a lot of
79  *   We assume each one of these delayed refs are going to use a full
80  *   reservation.  We use the transaction items and pre-reserve space for every
81  *   operation, and use this reservation to refill any gap between ->size and
82  *   ->reserved that may exist.
85  *   count from ->size and free up reservations as necessary.  Since this is
97  *   allocate a block reserve, set it to some size, and then truncate bytes
98  *   until we have no space left.  With ->failfast set we'll simply return
102  *   re-reserve.
110 	struct btrfs_space_info *space_info = block_rsv->space_info;  in block_rsv_release_bytes()
114 	spin_lock(&block_rsv->lock);  in block_rsv_release_bytes()
115 	if (num_bytes == (u64)-1) {  in block_rsv_release_bytes()
116 		num_bytes = block_rsv->size;  in block_rsv_release_bytes()
117 		qgroup_to_release = block_rsv->qgroup_rsv_size;  in block_rsv_release_bytes()
119 	block_rsv->size -= num_bytes;  in block_rsv_release_bytes()
120 	if (block_rsv->reserved >= block_rsv->size) {  in block_rsv_release_bytes()
121 		num_bytes = block_rsv->reserved - block_rsv->size;  in block_rsv_release_bytes()
122 		block_rsv->reserved = block_rsv->size;  in block_rsv_release_bytes()
123 		block_rsv->full = true;  in block_rsv_release_bytes()
128 	    block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {  in block_rsv_release_bytes()
129 		qgroup_to_release = block_rsv->qgroup_rsv_reserved -  in block_rsv_release_bytes()
130 				    block_rsv->qgroup_rsv_size;  in block_rsv_release_bytes()
131 		block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;  in block_rsv_release_bytes()
135 	spin_unlock(&block_rsv->lock);  in block_rsv_release_bytes()
140 			spin_lock(&dest->lock);  in block_rsv_release_bytes()
141 			if (!dest->full) {  in block_rsv_release_bytes()
144 				bytes_to_add = dest->size - dest->reserved;  in block_rsv_release_bytes()
146 				dest->reserved += bytes_to_add;  in block_rsv_release_bytes()
147 				if (dest->reserved >= dest->size)  in block_rsv_release_bytes()
148 					dest->full = true;  in block_rsv_release_bytes()
149 				num_bytes -= bytes_to_add;  in block_rsv_release_bytes()
151 			spin_unlock(&dest->lock);  in block_rsv_release_bytes()
180 	spin_lock_init(&rsv->lock);  in btrfs_init_block_rsv()
181 	rsv->type = type;  in btrfs_init_block_rsv()
189 	rsv->space_info = btrfs_find_space_info(fs_info,  in btrfs_init_metadata_block_rsv()
211 	btrfs_block_rsv_release(fs_info, rsv, (u64)-1, NULL);  in btrfs_free_block_rsv()
224 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,  in btrfs_block_rsv_add()
235 	int ret = -ENOSPC;  in btrfs_block_rsv_check()
237 	spin_lock(&block_rsv->lock);  in btrfs_block_rsv_check()
238 	num_bytes = mult_perc(block_rsv->size, min_percent);  in btrfs_block_rsv_check()
239 	if (block_rsv->reserved >= num_bytes)  in btrfs_block_rsv_check()
241 	spin_unlock(&block_rsv->lock);  in btrfs_block_rsv_check()
250 	int ret = -ENOSPC;  in btrfs_block_rsv_refill()
255 	spin_lock(&block_rsv->lock);  in btrfs_block_rsv_refill()
256 	if (block_rsv->reserved >= num_bytes)  in btrfs_block_rsv_refill()
259 		num_bytes -= block_rsv->reserved;  in btrfs_block_rsv_refill()
260 	spin_unlock(&block_rsv->lock);  in btrfs_block_rsv_refill()
265 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,  in btrfs_block_rsv_refill()
279 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in btrfs_block_rsv_release()
280 	struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;  in btrfs_block_rsv_release()
285 	 * otherwise dump into the global delayed reserve if it is not full.  in btrfs_block_rsv_release()
287 	if (block_rsv->type == BTRFS_BLOCK_RSV_DELOPS)  in btrfs_block_rsv_release()
292 	if (target && block_rsv->space_info != target->space_info)  in btrfs_block_rsv_release()
301 	int ret = -ENOSPC;  in btrfs_block_rsv_use_bytes()
303 	spin_lock(&block_rsv->lock);  in btrfs_block_rsv_use_bytes()
304 	if (block_rsv->reserved >= num_bytes) {  in btrfs_block_rsv_use_bytes()
305 		block_rsv->reserved -= num_bytes;  in btrfs_block_rsv_use_bytes()
306 		if (block_rsv->reserved < block_rsv->size)  in btrfs_block_rsv_use_bytes()
307 			block_rsv->full = false;  in btrfs_block_rsv_use_bytes()
310 	spin_unlock(&block_rsv->lock);  in btrfs_block_rsv_use_bytes()
317 	spin_lock(&block_rsv->lock);  in btrfs_block_rsv_add_bytes()
318 	block_rsv->reserved += num_bytes;  in btrfs_block_rsv_add_bytes()
320 		block_rsv->size += num_bytes;  in btrfs_block_rsv_add_bytes()
321 	else if (block_rsv->reserved >= block_rsv->size)  in btrfs_block_rsv_add_bytes()
322 		block_rsv->full = true;  in btrfs_block_rsv_add_bytes()
323 	spin_unlock(&block_rsv->lock);  in btrfs_block_rsv_add_bytes()
328 	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;  in btrfs_update_global_block_rsv()
329 	struct btrfs_space_info *sinfo = block_rsv->space_info;  in btrfs_update_global_block_rsv()
331 	u64 num_bytes = btrfs_root_used(&fs_info->tree_root->root_item);  in btrfs_update_global_block_rsv()
335 	 * The global block rsv is based on the size of the extent tree, the  in btrfs_update_global_block_rsv()
342 	read_lock(&fs_info->global_root_lock);  in btrfs_update_global_block_rsv()
343 	rbtree_postorder_for_each_entry_safe(root, tmp, &fs_info->global_root_tree,  in btrfs_update_global_block_rsv()
345 		if (root->root_key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||  in btrfs_update_global_block_rsv()
346 		    root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID ||  in btrfs_update_global_block_rsv()
347 		    root->root_key.objectid == BTRFS_FREE_SPACE_TREE_OBJECTID) {  in btrfs_update_global_block_rsv()
348 			num_bytes += btrfs_root_used(&root->root_item);  in btrfs_update_global_block_rsv()
352 	read_unlock(&fs_info->global_root_lock);  in btrfs_update_global_block_rsv()
355 		num_bytes += btrfs_root_used(&fs_info->block_group_root->root_item);  in btrfs_update_global_block_rsv()
360 		num_bytes += btrfs_root_used(&fs_info->stripe_root->root_item);  in btrfs_update_global_block_rsv()
380 	spin_lock(&sinfo->lock);  in btrfs_update_global_block_rsv()
381 	spin_lock(&block_rsv->lock);  in btrfs_update_global_block_rsv()
383 	block_rsv->size = min_t(u64, num_bytes, SZ_512M);  in btrfs_update_global_block_rsv()
385 	if (block_rsv->reserved < block_rsv->size) {  in btrfs_update_global_block_rsv()
386 		num_bytes = block_rsv->size - block_rsv->reserved;  in btrfs_update_global_block_rsv()
389 		block_rsv->reserved = block_rsv->size;  in btrfs_update_global_block_rsv()
390 	} else if (block_rsv->reserved > block_rsv->size) {  in btrfs_update_global_block_rsv()
391 		num_bytes = block_rsv->reserved - block_rsv->size;  in btrfs_update_global_block_rsv()
393 						      -num_bytes);  in btrfs_update_global_block_rsv()
394 		block_rsv->reserved = block_rsv->size;  in btrfs_update_global_block_rsv()
398 	block_rsv->full = (block_rsv->reserved == block_rsv->size);  in btrfs_update_global_block_rsv()
400 	if (block_rsv->size >= sinfo->total_bytes)  in btrfs_update_global_block_rsv()
401 		sinfo->force_alloc = CHUNK_ALLOC_FORCE;  in btrfs_update_global_block_rsv()
402 	spin_unlock(&block_rsv->lock);  in btrfs_update_global_block_rsv()
403 	spin_unlock(&sinfo->lock);  in btrfs_update_global_block_rsv()
408 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_init_root_block_rsv()
410 	switch (root->root_key.objectid) {  in btrfs_init_root_block_rsv()
416 		root->block_rsv = &fs_info->delayed_refs_rsv;  in btrfs_init_root_block_rsv()
421 		root->block_rsv = &fs_info->global_block_rsv;  in btrfs_init_root_block_rsv()
424 		root->block_rsv = &fs_info->chunk_block_rsv;  in btrfs_init_root_block_rsv()
427 		root->block_rsv = NULL;  in btrfs_init_root_block_rsv()
437 	fs_info->chunk_block_rsv.space_info = space_info;  in btrfs_init_global_block_rsv()
440 	fs_info->global_block_rsv.space_info = space_info;  in btrfs_init_global_block_rsv()
441 	fs_info->trans_block_rsv.space_info = space_info;  in btrfs_init_global_block_rsv()
442 	fs_info->empty_block_rsv.space_info = space_info;  in btrfs_init_global_block_rsv()
443 	fs_info->delayed_block_rsv.space_info = space_info;  in btrfs_init_global_block_rsv()
444 	fs_info->delayed_refs_rsv.space_info = space_info;  in btrfs_init_global_block_rsv()
451 	btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1,  in btrfs_release_global_block_rsv()
453 	WARN_ON(fs_info->trans_block_rsv.size > 0);  in btrfs_release_global_block_rsv()
454 	WARN_ON(fs_info->trans_block_rsv.reserved > 0);  in btrfs_release_global_block_rsv()
455 	WARN_ON(fs_info->chunk_block_rsv.size > 0);  in btrfs_release_global_block_rsv()
456 	WARN_ON(fs_info->chunk_block_rsv.reserved > 0);  in btrfs_release_global_block_rsv()
457 	WARN_ON(fs_info->delayed_block_rsv.size > 0);  in btrfs_release_global_block_rsv()
458 	WARN_ON(fs_info->delayed_block_rsv.reserved > 0);  in btrfs_release_global_block_rsv()
459 	WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);  in btrfs_release_global_block_rsv()
460 	WARN_ON(fs_info->delayed_refs_rsv.size > 0);  in btrfs_release_global_block_rsv()
467 	struct btrfs_fs_info *fs_info = root->fs_info;  in get_block_rsv()
470 	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||  in get_block_rsv()
471 	    (root == fs_info->uuid_root) ||  in get_block_rsv()
472 	    (trans->adding_csums &&  in get_block_rsv()
473 	     root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID))  in get_block_rsv()
474 		block_rsv = trans->block_rsv;  in get_block_rsv()
477 		block_rsv = root->block_rsv;  in get_block_rsv()
480 		block_rsv = &fs_info->empty_block_rsv;  in get_block_rsv()
489 	struct btrfs_fs_info *fs_info = root->fs_info;  in btrfs_use_block_rsv()
491 	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;  in btrfs_use_block_rsv()
504 	if (block_rsv->failfast)  in btrfs_use_block_rsv()
507 	if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {  in btrfs_use_block_rsv()
517 	if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&  in btrfs_use_block_rsv()
525 				block_rsv->type, ret);  in btrfs_use_block_rsv()
528 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,  in btrfs_use_block_rsv()
537 	if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&  in btrfs_use_block_rsv()
538 	    block_rsv->space_info == global_rsv->space_info) {  in btrfs_use_block_rsv()
550 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info, blocksize,  in btrfs_use_block_rsv()
568 	spin_lock(&rsv->lock);  in btrfs_check_trunc_cache_free_space()
569 	if (rsv->reserved < needed_bytes)  in btrfs_check_trunc_cache_free_space()
570 		ret = -ENOSPC;  in btrfs_check_trunc_cache_free_space()
573 	spin_unlock(&rsv->lock);  in btrfs_check_trunc_cache_free_space()