1 // SPDX-License-Identifier: GPL-2.0
6 #include "space-info.h"
7 #include "transaction.h"
8 #include "block-group.h"
10 static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
11 struct btrfs_block_rsv *block_rsv,
12 struct btrfs_block_rsv *dest, u64 num_bytes,
13 u64 *qgroup_to_release_ret)
15 struct btrfs_space_info *space_info = block_rsv->space_info;
16 u64 qgroup_to_release = 0;
19 spin_lock(&block_rsv->lock);
20 if (num_bytes == (u64)-1) {
21 num_bytes = block_rsv->size;
22 qgroup_to_release = block_rsv->qgroup_rsv_size;
24 block_rsv->size -= num_bytes;
25 if (block_rsv->reserved >= block_rsv->size) {
26 num_bytes = block_rsv->reserved - block_rsv->size;
27 block_rsv->reserved = block_rsv->size;
32 if (qgroup_to_release_ret &&
33 block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {
34 qgroup_to_release = block_rsv->qgroup_rsv_reserved -
35 block_rsv->qgroup_rsv_size;
36 block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;
38 qgroup_to_release = 0;
40 spin_unlock(&block_rsv->lock);
45 spin_lock(&dest->lock);
49 bytes_to_add = dest->size - dest->reserved;
50 bytes_to_add = min(num_bytes, bytes_to_add);
51 dest->reserved += bytes_to_add;
52 if (dest->reserved >= dest->size)
54 num_bytes -= bytes_to_add;
56 spin_unlock(&dest->lock);
59 btrfs_space_info_free_bytes_may_use(fs_info,
63 if (qgroup_to_release_ret)
64 *qgroup_to_release_ret = qgroup_to_release;
68 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,
69 struct btrfs_block_rsv *dst, u64 num_bytes,
74 ret = btrfs_block_rsv_use_bytes(src, num_bytes);
78 btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);
82 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)
84 memset(rsv, 0, sizeof(*rsv));
85 spin_lock_init(&rsv->lock);
89 void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
90 struct btrfs_block_rsv *rsv,
93 btrfs_init_block_rsv(rsv, type);
94 rsv->space_info = btrfs_find_space_info(fs_info,
95 BTRFS_BLOCK_GROUP_METADATA);
98 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
101 struct btrfs_block_rsv *block_rsv;
103 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
107 btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);
111 void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
112 struct btrfs_block_rsv *rsv)
116 btrfs_block_rsv_release(fs_info, rsv, (u64)-1);
120 int btrfs_block_rsv_add(struct btrfs_root *root,
121 struct btrfs_block_rsv *block_rsv, u64 num_bytes,
122 enum btrfs_reserve_flush_enum flush)
129 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
131 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);
136 int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor)
144 spin_lock(&block_rsv->lock);
145 num_bytes = div_factor(block_rsv->size, min_factor);
146 if (block_rsv->reserved >= num_bytes)
148 spin_unlock(&block_rsv->lock);
153 int btrfs_block_rsv_refill(struct btrfs_root *root,
154 struct btrfs_block_rsv *block_rsv, u64 min_reserved,
155 enum btrfs_reserve_flush_enum flush)
163 spin_lock(&block_rsv->lock);
164 num_bytes = min_reserved;
165 if (block_rsv->reserved >= num_bytes)
168 num_bytes -= block_rsv->reserved;
169 spin_unlock(&block_rsv->lock);
174 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
176 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
183 u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
184 struct btrfs_block_rsv *block_rsv,
185 u64 num_bytes, u64 *qgroup_to_release)
187 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
188 struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
189 struct btrfs_block_rsv *target = NULL;
192 * If we are the delayed_rsv then push to the global rsv, otherwise dump
193 * into the delayed rsv if it is not full.
195 if (block_rsv == delayed_rsv)
197 else if (block_rsv != global_rsv && !delayed_rsv->full)
198 target = delayed_rsv;
200 if (target && block_rsv->space_info != target->space_info)
203 return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
207 int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes)
211 spin_lock(&block_rsv->lock);
212 if (block_rsv->reserved >= num_bytes) {
213 block_rsv->reserved -= num_bytes;
214 if (block_rsv->reserved < block_rsv->size)
218 spin_unlock(&block_rsv->lock);
222 void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
223 u64 num_bytes, bool update_size)
225 spin_lock(&block_rsv->lock);
226 block_rsv->reserved += num_bytes;
228 block_rsv->size += num_bytes;
229 else if (block_rsv->reserved >= block_rsv->size)
231 spin_unlock(&block_rsv->lock);
234 int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
235 struct btrfs_block_rsv *dest, u64 num_bytes,
238 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
241 if (global_rsv->space_info != dest->space_info)
244 spin_lock(&global_rsv->lock);
245 min_bytes = div_factor(global_rsv->size, min_factor);
246 if (global_rsv->reserved < min_bytes + num_bytes) {
247 spin_unlock(&global_rsv->lock);
250 global_rsv->reserved -= num_bytes;
251 if (global_rsv->reserved < global_rsv->size)
252 global_rsv->full = 0;
253 spin_unlock(&global_rsv->lock);
255 btrfs_block_rsv_add_bytes(dest, num_bytes, true);
259 void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)
261 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
262 struct btrfs_space_info *sinfo = block_rsv->space_info;
267 * The global block rsv is based on the size of the extent tree, the
268 * checksum tree and the root tree. If the fs is empty we want to set
269 * it to a minimal amount for safety.
271 num_bytes = btrfs_root_used(&fs_info->extent_root->root_item) +
272 btrfs_root_used(&fs_info->csum_root->root_item) +
273 btrfs_root_used(&fs_info->tree_root->root_item);
276 * We at a minimum are going to modify the csum root, the tree root, and
282 * But we also want to reserve enough space so we can do the fallback
283 * global reserve for an unlink, which is an additional 5 items (see the
284 * comment in __unlink_start_trans for what we're modifying.)
286 * But we also need space for the delayed ref updates from the unlink,
287 * so its 10, 5 for the actual operation, and 5 for the delayed ref
292 num_bytes = max_t(u64, num_bytes,
293 btrfs_calc_insert_metadata_size(fs_info, min_items));
295 spin_lock(&sinfo->lock);
296 spin_lock(&block_rsv->lock);
298 block_rsv->size = min_t(u64, num_bytes, SZ_512M);
300 if (block_rsv->reserved < block_rsv->size) {
301 num_bytes = block_rsv->size - block_rsv->reserved;
302 block_rsv->reserved += num_bytes;
303 btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
305 } else if (block_rsv->reserved > block_rsv->size) {
306 num_bytes = block_rsv->reserved - block_rsv->size;
307 btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
309 block_rsv->reserved = block_rsv->size;
310 btrfs_try_granting_tickets(fs_info, sinfo);
313 if (block_rsv->reserved == block_rsv->size)
318 if (block_rsv->size >= sinfo->total_bytes)
319 sinfo->force_alloc = CHUNK_ALLOC_FORCE;
320 spin_unlock(&block_rsv->lock);
321 spin_unlock(&sinfo->lock);
324 void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)
326 struct btrfs_space_info *space_info;
328 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
329 fs_info->chunk_block_rsv.space_info = space_info;
331 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
332 fs_info->global_block_rsv.space_info = space_info;
333 fs_info->trans_block_rsv.space_info = space_info;
334 fs_info->empty_block_rsv.space_info = space_info;
335 fs_info->delayed_block_rsv.space_info = space_info;
336 fs_info->delayed_refs_rsv.space_info = space_info;
338 fs_info->extent_root->block_rsv = &fs_info->delayed_refs_rsv;
339 fs_info->csum_root->block_rsv = &fs_info->delayed_refs_rsv;
340 fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
341 fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
342 if (fs_info->quota_root)
343 fs_info->quota_root->block_rsv = &fs_info->global_block_rsv;
344 fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
346 btrfs_update_global_block_rsv(fs_info);
349 void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)
351 btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1);
352 WARN_ON(fs_info->trans_block_rsv.size > 0);
353 WARN_ON(fs_info->trans_block_rsv.reserved > 0);
354 WARN_ON(fs_info->chunk_block_rsv.size > 0);
355 WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
356 WARN_ON(fs_info->delayed_block_rsv.size > 0);
357 WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
358 WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);
359 WARN_ON(fs_info->delayed_refs_rsv.size > 0);
362 static struct btrfs_block_rsv *get_block_rsv(
363 const struct btrfs_trans_handle *trans,
364 const struct btrfs_root *root)
366 struct btrfs_fs_info *fs_info = root->fs_info;
367 struct btrfs_block_rsv *block_rsv = NULL;
369 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
370 (root == fs_info->csum_root && trans->adding_csums) ||
371 (root == fs_info->uuid_root))
372 block_rsv = trans->block_rsv;
375 block_rsv = root->block_rsv;
378 block_rsv = &fs_info->empty_block_rsv;
383 struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans,
384 struct btrfs_root *root,
387 struct btrfs_fs_info *fs_info = root->fs_info;
388 struct btrfs_block_rsv *block_rsv;
389 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
391 bool global_updated = false;
393 block_rsv = get_block_rsv(trans, root);
395 if (unlikely(block_rsv->size == 0))
398 ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize);
402 if (block_rsv->failfast)
405 if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {
406 global_updated = true;
407 btrfs_update_global_block_rsv(fs_info);
412 * The global reserve still exists to save us from ourselves, so don't
413 * warn_on if we are short on our delayed refs reserve.
415 if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&
416 btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
417 static DEFINE_RATELIMIT_STATE(_rs,
418 DEFAULT_RATELIMIT_INTERVAL * 10,
419 /*DEFAULT_RATELIMIT_BURST*/ 1);
420 if (__ratelimit(&_rs))
422 "BTRFS: block rsv returned %d\n", ret);
425 ret = btrfs_reserve_metadata_bytes(root, block_rsv, blocksize,
426 BTRFS_RESERVE_NO_FLUSH);
430 * If we couldn't reserve metadata bytes try and use some from
431 * the global reserve if its space type is the same as the global
434 if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&
435 block_rsv->space_info == global_rsv->space_info) {
436 ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize);