block-rsv.c

  1// SPDX-License-Identifier: GPL-2.0
  2
  3#include "misc.h"
  4#include "ctree.h"
  5#include "block-rsv.h"
  6#include "space-info.h"
  7#include "transaction.h"
  8#include "block-group.h"
  9#include "fs.h"
 10#include "accessors.h"
 11
 12/*
 13 * HOW DO BLOCK RESERVES WORK
 14 *
 15 *   Think of block_rsv's as buckets for logically grouped metadata
 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
 18 *   currently reserved for this block reserve.
 19 *
 20 *   ->failfast exists for the truncate case, and is described below.
 21 *
 22 * NORMAL OPERATION
 23 *
 24 *   -> Reserve
 25 *     Entrance: btrfs_block_rsv_add, btrfs_block_rsv_refill
 26 *
 27 *     We call into btrfs_reserve_metadata_bytes() with our bytes, which is
 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.
 30 *
 31 *     ->size is an over-estimation of how much we may use for a particular
 32 *     operation.
 33 *
 34 *   -> Use
 35 *     Entrance: btrfs_use_block_rsv
 36 *
 37 *     When we do a btrfs_alloc_tree_block() we call into btrfs_use_block_rsv()
 38 *     to determine the appropriate block_rsv to use, and then verify that
 39 *     ->reserved has enough space for our tree block allocation.  Once
 40 *     successful we subtract fs_info->nodesize from ->reserved.
 41 *
 42 *   -> Finish
 43 *     Entrance: btrfs_block_rsv_release
 44 *
 45 *     We are finished with our operation, subtract our individual reservation
 46 *     from ->size, and then subtract ->size from ->reserved and free up the
 47 *     excess if there is any.
 48 *
 49 *     There is some logic here to refill the delayed refs rsv or the global rsv
 50 *     as needed, otherwise the excess is subtracted from
 51 *     space_info->bytes_may_use.
 52 *
 53 * TYPES OF BLOCK RESERVES
 54 *
 55 * BLOCK_RSV_TRANS, BLOCK_RSV_DELOPS, BLOCK_RSV_CHUNK
 56 *   These behave normally, as described above, just within the confines of the
 57 *   lifetime of their particular operation (transaction for the whole trans
 58 *   handle lifetime, for example).
 59 *
 60 * BLOCK_RSV_GLOBAL
 61 *   It is impossible to properly account for all the space that may be required
 62 *   to make our extent tree updates.  This block reserve acts as an overflow
 63 *   buffer in case our delayed refs reserve does not reserve enough space to
 64 *   update the extent tree.
 65 *
 66 *   We can steal from this in some cases as well, notably on evict() or
 67 *   truncate() in order to help users recover from ENOSPC conditions.
 68 *
 69 * BLOCK_RSV_DELALLOC
 70 *   The individual item sizes are determined by the per-inode size
 71 *   calculations, which are described with the delalloc code.  This is pretty
 72 *   straightforward, it's just the calculation of ->size encodes a lot of
 73 *   different items, and thus it gets used when updating inodes, inserting file
 74 *   extents, and inserting checksums.
 75 *
 76 * BLOCK_RSV_DELREFS
 77 *   We keep a running tally of how many delayed refs we have on the system.
 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.
 82 *
 83 *   From there it's straightforward, removing a delayed ref means we remove its
 84 *   count from ->size and free up reservations as necessary.  Since this is
 85 *   the most dynamic block reserve in the system, we will try to refill this
 86 *   block reserve first with any excess returned by any other block reserve.
 87 *
 88 * BLOCK_RSV_EMPTY
 89 *   This is the fallback block reserve to make us try to reserve space if we
 90 *   don't have a specific bucket for this allocation.  It is mostly used for
 91 *   updating the device tree and such, since that is a separate pool we're
 92 *   content to just reserve space from the space_info on demand.
 93 *
 94 * BLOCK_RSV_TEMP
 95 *   This is used by things like truncate and iput.  We will temporarily
 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
 98 *   ENOSPC from btrfs_use_block_rsv() to signal that we need to unwind and try
 99 *   to make a new reservation.  This is because these operations are
100 *   unbounded, so we want to do as much work as we can, and then back off and
101 *   re-reserve.
102 */
103
104static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
105				    struct btrfs_block_rsv *block_rsv,
106				    struct btrfs_block_rsv *dest, u64 num_bytes,
107				    u64 *qgroup_to_release_ret)
108{
109	struct btrfs_space_info *space_info = block_rsv->space_info;
110	u64 qgroup_to_release = 0;
111	u64 ret;
112
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;
117	}
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;
123	} else {
124		num_bytes = 0;
125	}
126	if (qgroup_to_release_ret &&
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;
131	} else {
132		qgroup_to_release = 0;
133	}
134	spin_unlock(&block_rsv->lock);
135
136	ret = num_bytes;
137	if (num_bytes > 0) {
138		if (dest) {
139			spin_lock(&dest->lock);
140			if (!dest->full) {
141				u64 bytes_to_add;
142
143				bytes_to_add = dest->size - dest->reserved;
144				bytes_to_add = min(num_bytes, bytes_to_add);
145				dest->reserved += bytes_to_add;
146				if (dest->reserved >= dest->size)
147					dest->full = true;
148				num_bytes -= bytes_to_add;
149			}
150			spin_unlock(&dest->lock);
151		}
152		if (num_bytes)
153			btrfs_space_info_free_bytes_may_use(space_info, num_bytes);
154	}
155	if (qgroup_to_release_ret)
156		*qgroup_to_release_ret = qgroup_to_release;
157	return ret;
158}
159
160int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,
161			    struct btrfs_block_rsv *dst, u64 num_bytes,
162			    bool update_size)
163{
164	int ret;
165
166	ret = btrfs_block_rsv_use_bytes(src, num_bytes);
167	if (ret)
168		return ret;
169
170	btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);
171	return 0;
172}
173
174void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, enum btrfs_rsv_type type)
175{
176	memset(rsv, 0, sizeof(*rsv));
177	spin_lock_init(&rsv->lock);
178	rsv->type = type;
179}
180
181void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
182				   struct btrfs_block_rsv *rsv,
183				   enum btrfs_rsv_type type)
184{
185	btrfs_init_block_rsv(rsv, type);
186	rsv->space_info = btrfs_find_space_info(fs_info,
187					    BTRFS_BLOCK_GROUP_METADATA);
188}
189
190struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
191					      enum btrfs_rsv_type type)
192{
193	struct btrfs_block_rsv *block_rsv;
194
195	block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
196	if (!block_rsv)
197		return NULL;
198
199	btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);
200	return block_rsv;
201}
202
203void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
204			  struct btrfs_block_rsv *rsv)
205{
206	if (!rsv)
207		return;
208	btrfs_block_rsv_release(fs_info, rsv, (u64)-1, NULL);
209	kfree(rsv);
210}
211
212int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info,
213			struct btrfs_block_rsv *block_rsv, u64 num_bytes,
214			enum btrfs_reserve_flush_enum flush)
215{
216	int ret;
217
218	if (num_bytes == 0)
219		return 0;
220
221	ret = btrfs_reserve_metadata_bytes(block_rsv->space_info, num_bytes, flush);
222	if (!ret)
223		btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);
224
225	return ret;
226}
227
228int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_percent)
229{
230	u64 num_bytes = 0;
231	int ret = -ENOSPC;
232
233	spin_lock(&block_rsv->lock);
234	num_bytes = mult_perc(block_rsv->size, min_percent);
235	if (block_rsv->reserved >= num_bytes)
236		ret = 0;
237	spin_unlock(&block_rsv->lock);
238
239	return ret;
240}
241
242int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info,
243			   struct btrfs_block_rsv *block_rsv, u64 num_bytes,
244			   enum btrfs_reserve_flush_enum flush)
245{
246	int ret = -ENOSPC;
247
248	if (!block_rsv)
249		return 0;
250
251	spin_lock(&block_rsv->lock);
252	if (block_rsv->reserved >= num_bytes)
253		ret = 0;
254	else
255		num_bytes -= block_rsv->reserved;
256	spin_unlock(&block_rsv->lock);
257
258	if (!ret)
259		return 0;
260
261	ret = btrfs_reserve_metadata_bytes(block_rsv->space_info, num_bytes, flush);
262	if (!ret) {
263		btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
264		return 0;
265	}
266
267	return ret;
268}
269
270u64 btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
271			    struct btrfs_block_rsv *block_rsv, u64 num_bytes,
272			    u64 *qgroup_to_release)
273{
274	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
275	struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
276	struct btrfs_block_rsv *target = NULL;
277
278	/*
279	 * If we are a delayed refs block reserve then push to the global
280	 * reserve, otherwise dump into the global delayed refs reserve if it is
281	 * not full.
282	 */
283	if (block_rsv->type == BTRFS_BLOCK_RSV_DELREFS)
284		target = global_rsv;
285	else if (block_rsv != global_rsv && !btrfs_block_rsv_full(delayed_rsv))
286		target = delayed_rsv;
287
288	if (target && block_rsv->space_info != target->space_info)
289		target = NULL;
290
291	return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
292				       qgroup_to_release);
293}
294
295int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes)
296{
297	int ret = -ENOSPC;
298
299	spin_lock(&block_rsv->lock);
300	if (block_rsv->reserved >= num_bytes) {
301		block_rsv->reserved -= num_bytes;
302		if (block_rsv->reserved < block_rsv->size)
303			block_rsv->full = false;
304		ret = 0;
305	}
306	spin_unlock(&block_rsv->lock);
307	return ret;
308}
309
310void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
311			       u64 num_bytes, bool update_size)
312{
313	spin_lock(&block_rsv->lock);
314	block_rsv->reserved += num_bytes;
315	if (update_size)
316		block_rsv->size += num_bytes;
317	else if (block_rsv->reserved >= block_rsv->size)
318		block_rsv->full = true;
319	spin_unlock(&block_rsv->lock);
320}
321
322void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)
323{
324	struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
325	struct btrfs_space_info *sinfo = block_rsv->space_info;
326	struct btrfs_root *root, *tmp;
327	u64 num_bytes = btrfs_root_used(&fs_info->tree_root->root_item);
328	unsigned int min_items = 1;
329
330	/*
331	 * The global block rsv is based on the size of the extent tree, the
332	 * checksum tree and the root tree.  If the fs is empty we want to set
333	 * it to a minimal amount for safety.
334	 *
335	 * We also are going to need to modify the minimum of the tree root and
336	 * any global roots we could touch.
337	 */
338	read_lock(&fs_info->global_root_lock);
339	rbtree_postorder_for_each_entry_safe(root, tmp, &fs_info->global_root_tree,
340					     rb_node) {
341		if (btrfs_root_id(root) == BTRFS_EXTENT_TREE_OBJECTID ||
342		    btrfs_root_id(root) == BTRFS_CSUM_TREE_OBJECTID ||
343		    btrfs_root_id(root) == BTRFS_FREE_SPACE_TREE_OBJECTID) {
344			num_bytes += btrfs_root_used(&root->root_item);
345			min_items++;
346		}
347	}
348	read_unlock(&fs_info->global_root_lock);
349
350	if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {
351		num_bytes += btrfs_root_used(&fs_info->block_group_root->root_item);
352		min_items++;
353	}
354
355	if (btrfs_fs_incompat(fs_info, RAID_STRIPE_TREE)) {
356		num_bytes += btrfs_root_used(&fs_info->stripe_root->root_item);
357		min_items++;
358	}
359
360	/*
361	 * But we also want to reserve enough space so we can do the fallback
362	 * global reserve for an unlink, which is an additional
363	 * BTRFS_UNLINK_METADATA_UNITS items.
364	 *
365	 * But we also need space for the delayed ref updates from the unlink,
366	 * so add BTRFS_UNLINK_METADATA_UNITS units for delayed refs, one for
367	 * each unlink metadata item.
368	 */
369	min_items += BTRFS_UNLINK_METADATA_UNITS;
370
371	num_bytes = max_t(u64, num_bytes,
372			  btrfs_calc_insert_metadata_size(fs_info, min_items) +
373			  btrfs_calc_delayed_ref_bytes(fs_info,
374					       BTRFS_UNLINK_METADATA_UNITS));
375
376	spin_lock(&sinfo->lock);
377	spin_lock(&block_rsv->lock);
378
379	block_rsv->size = min_t(u64, num_bytes, SZ_512M);
380
381	if (block_rsv->reserved < block_rsv->size) {
382		num_bytes = block_rsv->size - block_rsv->reserved;
383		btrfs_space_info_update_bytes_may_use(sinfo, num_bytes);
384		block_rsv->reserved = block_rsv->size;
385	} else if (block_rsv->reserved > block_rsv->size) {
386		num_bytes = block_rsv->reserved - block_rsv->size;
387		btrfs_space_info_update_bytes_may_use(sinfo, -num_bytes);
388		block_rsv->reserved = block_rsv->size;
389		btrfs_try_granting_tickets(sinfo);
390	}
391
392	block_rsv->full = (block_rsv->reserved == block_rsv->size);
393
394	if (block_rsv->size >= sinfo->total_bytes)
395		sinfo->force_alloc = CHUNK_ALLOC_FORCE;
396	spin_unlock(&block_rsv->lock);
397	spin_unlock(&sinfo->lock);
398}
399
400void btrfs_init_root_block_rsv(struct btrfs_root *root)
401{
402	struct btrfs_fs_info *fs_info = root->fs_info;
403
404	switch (btrfs_root_id(root)) {
405	case BTRFS_CSUM_TREE_OBJECTID:
406	case BTRFS_EXTENT_TREE_OBJECTID:
407	case BTRFS_FREE_SPACE_TREE_OBJECTID:
408	case BTRFS_BLOCK_GROUP_TREE_OBJECTID:
409	case BTRFS_RAID_STRIPE_TREE_OBJECTID:
410		root->block_rsv = &fs_info->delayed_refs_rsv;
411		break;
412	case BTRFS_ROOT_TREE_OBJECTID:
413	case BTRFS_DEV_TREE_OBJECTID:
414	case BTRFS_QUOTA_TREE_OBJECTID:
415		root->block_rsv = &fs_info->global_block_rsv;
416		break;
417	case BTRFS_CHUNK_TREE_OBJECTID:
418		root->block_rsv = &fs_info->chunk_block_rsv;
419		break;
420	case BTRFS_TREE_LOG_OBJECTID:
421		root->block_rsv = &fs_info->treelog_rsv;
422		break;
423	default:
424		root->block_rsv = NULL;
425		break;
426	}
427}
428
429void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)
430{
431	struct btrfs_space_info *space_info;
432
433	space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
434	fs_info->chunk_block_rsv.space_info = space_info;
435
436	space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
437	fs_info->global_block_rsv.space_info = space_info;
438	fs_info->trans_block_rsv.space_info = space_info;
439	fs_info->empty_block_rsv.space_info = space_info;
440	fs_info->delayed_block_rsv.space_info = space_info;
441	fs_info->delayed_refs_rsv.space_info = space_info;
442
443	/* The treelog_rsv uses a dedicated space_info on the zoned mode. */
444	if (!btrfs_is_zoned(fs_info)) {
445		fs_info->treelog_rsv.space_info = space_info;
446	} else {
447		ASSERT(space_info->sub_group[0]->subgroup_id == BTRFS_SUB_GROUP_TREELOG);
448		fs_info->treelog_rsv.space_info = space_info->sub_group[0];
449	}
450
451	btrfs_update_global_block_rsv(fs_info);
452}
453
454void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)
455{
456	btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1,
457				NULL);
458	WARN_ON(fs_info->trans_block_rsv.size > 0);
459	WARN_ON(fs_info->trans_block_rsv.reserved > 0);
460	WARN_ON(fs_info->chunk_block_rsv.size > 0);
461	WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
462	WARN_ON(fs_info->delayed_block_rsv.size > 0);
463	WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
464	WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);
465	WARN_ON(fs_info->delayed_refs_rsv.size > 0);
466}
467
468static struct btrfs_block_rsv *get_block_rsv(
469					const struct btrfs_trans_handle *trans,
470					const struct btrfs_root *root)
471{
472	struct btrfs_fs_info *fs_info = root->fs_info;
473	struct btrfs_block_rsv *block_rsv = NULL;
474
475	if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||
476	    (root == fs_info->uuid_root) ||
477	    (trans->adding_csums && btrfs_root_id(root) == BTRFS_CSUM_TREE_OBJECTID))
478		block_rsv = trans->block_rsv;
479
480	if (!block_rsv)
481		block_rsv = root->block_rsv;
482
483	if (!block_rsv)
484		block_rsv = &fs_info->empty_block_rsv;
485
486	return block_rsv;
487}
488
489struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans,
490					    struct btrfs_root *root,
491					    u32 blocksize)
492{
493	struct btrfs_fs_info *fs_info = root->fs_info;
494	struct btrfs_block_rsv *block_rsv;
495	struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
496	int ret;
497	bool global_updated = false;
498
499	block_rsv = get_block_rsv(trans, root);
500
501	if (unlikely(btrfs_block_rsv_size(block_rsv) == 0))
502		goto try_reserve;
503again:
504	ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize);
505	if (!ret)
506		return block_rsv;
507
508	if (block_rsv->failfast)
509		return ERR_PTR(ret);
510
511	if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {
512		global_updated = true;
513		btrfs_update_global_block_rsv(fs_info);
514		goto again;
515	}
516
517	/*
518	 * The global reserve still exists to save us from ourselves, so don't
519	 * warn_on if we are short on our delayed refs reserve.
520	 */
521	if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&
522	    btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
523		static DEFINE_RATELIMIT_STATE(_rs,
524				DEFAULT_RATELIMIT_INTERVAL * 10,
525				/*DEFAULT_RATELIMIT_BURST*/ 1);
526		if (__ratelimit(&_rs))
527			WARN(1, KERN_DEBUG
528				"BTRFS: block rsv %d returned %d\n",
529				block_rsv->type, ret);
530	}
531try_reserve:
532	ret = btrfs_reserve_metadata_bytes(block_rsv->space_info, blocksize,
533					   BTRFS_RESERVE_NO_FLUSH);
534	if (!ret)
535		return block_rsv;
536	/*
537	 * If we couldn't reserve metadata bytes try and use some from
538	 * the global reserve if its space type is the same as the global
539	 * reservation.
540	 */
541	if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&
542	    block_rsv->space_info == global_rsv->space_info) {
543		ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize);
544		if (!ret)
545			return global_rsv;
546	}
547
548	/*
549	 * All hope is lost, but of course our reservations are overly
550	 * pessimistic, so instead of possibly having an ENOSPC abort here, try
551	 * one last time to force a reservation if there's enough actual space
552	 * on disk to make the reservation.
553	 */
554	ret = btrfs_reserve_metadata_bytes(block_rsv->space_info, blocksize,
555					   BTRFS_RESERVE_FLUSH_EMERGENCY);
556	if (!ret)
557		return block_rsv;
558
559	return ERR_PTR(ret);
560}
561
562int btrfs_check_trunc_cache_free_space(const struct btrfs_fs_info *fs_info,
563				       struct btrfs_block_rsv *rsv)
564{
565	u64 needed_bytes;
566	int ret;
567
568	/* 1 for slack space, 1 for updating the inode */
569	needed_bytes = btrfs_calc_insert_metadata_size(fs_info, 1) +
570		btrfs_calc_metadata_size(fs_info, 1);
571
572	spin_lock(&rsv->lock);
573	if (rsv->reserved < needed_bytes)
574		ret = -ENOSPC;
575	else
576		ret = 0;
577	spin_unlock(&rsv->lock);
578	return ret;
579}