1 // SPDX-License-Identifier: GPL-2.0
5 #include "space-info.h"
7 #include "transaction.h"
9 static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
10 struct btrfs_block_rsv *block_rsv,
11 struct btrfs_block_rsv *dest, u64 num_bytes,
12 u64 *qgroup_to_release_ret)
14 struct btrfs_space_info *space_info = block_rsv->space_info;
15 u64 qgroup_to_release = 0;
18 spin_lock(&block_rsv->lock);
19 if (num_bytes == (u64)-1) {
20 num_bytes = block_rsv->size;
21 qgroup_to_release = block_rsv->qgroup_rsv_size;
23 block_rsv->size -= num_bytes;
24 if (block_rsv->reserved >= block_rsv->size) {
25 num_bytes = block_rsv->reserved - block_rsv->size;
26 block_rsv->reserved = block_rsv->size;
31 if (block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {
32 qgroup_to_release = block_rsv->qgroup_rsv_reserved -
33 block_rsv->qgroup_rsv_size;
34 block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;
36 qgroup_to_release = 0;
38 spin_unlock(&block_rsv->lock);
43 spin_lock(&dest->lock);
47 bytes_to_add = dest->size - dest->reserved;
48 bytes_to_add = min(num_bytes, bytes_to_add);
49 dest->reserved += bytes_to_add;
50 if (dest->reserved >= dest->size)
52 num_bytes -= bytes_to_add;
54 spin_unlock(&dest->lock);
57 btrfs_space_info_add_old_bytes(fs_info, space_info,
60 if (qgroup_to_release_ret)
61 *qgroup_to_release_ret = qgroup_to_release;
65 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,
66 struct btrfs_block_rsv *dst, u64 num_bytes,
71 ret = btrfs_block_rsv_use_bytes(src, num_bytes);
75 btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);
79 void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)
81 memset(rsv, 0, sizeof(*rsv));
82 spin_lock_init(&rsv->lock);
86 void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
87 struct btrfs_block_rsv *rsv,
90 btrfs_init_block_rsv(rsv, type);
91 rsv->space_info = btrfs_find_space_info(fs_info,
92 BTRFS_BLOCK_GROUP_METADATA);
95 struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
98 struct btrfs_block_rsv *block_rsv;
100 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
104 btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);
108 void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
109 struct btrfs_block_rsv *rsv)
113 btrfs_block_rsv_release(fs_info, rsv, (u64)-1);
117 int btrfs_block_rsv_add(struct btrfs_root *root,
118 struct btrfs_block_rsv *block_rsv, u64 num_bytes,
119 enum btrfs_reserve_flush_enum flush)
126 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
128 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);
133 int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor)
141 spin_lock(&block_rsv->lock);
142 num_bytes = div_factor(block_rsv->size, min_factor);
143 if (block_rsv->reserved >= num_bytes)
145 spin_unlock(&block_rsv->lock);
150 int btrfs_block_rsv_refill(struct btrfs_root *root,
151 struct btrfs_block_rsv *block_rsv, u64 min_reserved,
152 enum btrfs_reserve_flush_enum flush)
160 spin_lock(&block_rsv->lock);
161 num_bytes = min_reserved;
162 if (block_rsv->reserved >= num_bytes)
165 num_bytes -= block_rsv->reserved;
166 spin_unlock(&block_rsv->lock);
171 ret = btrfs_reserve_metadata_bytes(root, block_rsv, num_bytes, flush);
173 btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
180 u64 __btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
181 struct btrfs_block_rsv *block_rsv,
182 u64 num_bytes, u64 *qgroup_to_release)
184 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
185 struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
186 struct btrfs_block_rsv *target = NULL;
189 * If we are the delayed_rsv then push to the global rsv, otherwise dump
190 * into the delayed rsv if it is not full.
192 if (block_rsv == delayed_rsv)
194 else if (block_rsv != global_rsv && !delayed_rsv->full)
195 target = delayed_rsv;
197 if (target && block_rsv->space_info != target->space_info)
200 return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
204 int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes)
208 spin_lock(&block_rsv->lock);
209 if (block_rsv->reserved >= num_bytes) {
210 block_rsv->reserved -= num_bytes;
211 if (block_rsv->reserved < block_rsv->size)
215 spin_unlock(&block_rsv->lock);
219 void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
220 u64 num_bytes, bool update_size)
222 spin_lock(&block_rsv->lock);
223 block_rsv->reserved += num_bytes;
225 block_rsv->size += num_bytes;
226 else if (block_rsv->reserved >= block_rsv->size)
228 spin_unlock(&block_rsv->lock);
231 int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info,
232 struct btrfs_block_rsv *dest, u64 num_bytes,
235 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
238 if (global_rsv->space_info != dest->space_info)
241 spin_lock(&global_rsv->lock);
242 min_bytes = div_factor(global_rsv->size, min_factor);
243 if (global_rsv->reserved < min_bytes + num_bytes) {
244 spin_unlock(&global_rsv->lock);
247 global_rsv->reserved -= num_bytes;
248 if (global_rsv->reserved < global_rsv->size)
249 global_rsv->full = 0;
250 spin_unlock(&global_rsv->lock);
252 btrfs_block_rsv_add_bytes(dest, num_bytes, true);
256 void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)
258 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
259 struct btrfs_space_info *sinfo = block_rsv->space_info;
263 * The global block rsv is based on the size of the extent tree, the
264 * checksum tree and the root tree. If the fs is empty we want to set
265 * it to a minimal amount for safety.
267 num_bytes = btrfs_root_used(&fs_info->extent_root->root_item) +
268 btrfs_root_used(&fs_info->csum_root->root_item) +
269 btrfs_root_used(&fs_info->tree_root->root_item);
270 num_bytes = max_t(u64, num_bytes, SZ_16M);
272 spin_lock(&sinfo->lock);
273 spin_lock(&block_rsv->lock);
275 block_rsv->size = min_t(u64, num_bytes, SZ_512M);
277 if (block_rsv->reserved < block_rsv->size) {
278 num_bytes = btrfs_space_info_used(sinfo, true);
279 if (sinfo->total_bytes > num_bytes) {
280 num_bytes = sinfo->total_bytes - num_bytes;
281 num_bytes = min(num_bytes,
282 block_rsv->size - block_rsv->reserved);
283 block_rsv->reserved += num_bytes;
284 btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
286 trace_btrfs_space_reservation(fs_info, "space_info",
287 sinfo->flags, num_bytes,
290 } else if (block_rsv->reserved > block_rsv->size) {
291 num_bytes = block_rsv->reserved - block_rsv->size;
292 btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
294 trace_btrfs_space_reservation(fs_info, "space_info",
295 sinfo->flags, num_bytes, 0);
296 block_rsv->reserved = block_rsv->size;
299 if (block_rsv->reserved == block_rsv->size)
304 spin_unlock(&block_rsv->lock);
305 spin_unlock(&sinfo->lock);
308 void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)
310 struct btrfs_space_info *space_info;
312 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
313 fs_info->chunk_block_rsv.space_info = space_info;
315 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
316 fs_info->global_block_rsv.space_info = space_info;
317 fs_info->trans_block_rsv.space_info = space_info;
318 fs_info->empty_block_rsv.space_info = space_info;
319 fs_info->delayed_block_rsv.space_info = space_info;
320 fs_info->delayed_refs_rsv.space_info = space_info;
322 fs_info->extent_root->block_rsv = &fs_info->delayed_refs_rsv;
323 fs_info->csum_root->block_rsv = &fs_info->delayed_refs_rsv;
324 fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
325 fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
326 if (fs_info->quota_root)
327 fs_info->quota_root->block_rsv = &fs_info->global_block_rsv;
328 fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
330 btrfs_update_global_block_rsv(fs_info);
333 void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)
335 btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1);
336 WARN_ON(fs_info->trans_block_rsv.size > 0);
337 WARN_ON(fs_info->trans_block_rsv.reserved > 0);
338 WARN_ON(fs_info->chunk_block_rsv.size > 0);
339 WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
340 WARN_ON(fs_info->delayed_block_rsv.size > 0);
341 WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
342 WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);
343 WARN_ON(fs_info->delayed_refs_rsv.size > 0);
346 static struct btrfs_block_rsv *get_block_rsv(
347 const struct btrfs_trans_handle *trans,
348 const struct btrfs_root *root)
350 struct btrfs_fs_info *fs_info = root->fs_info;
351 struct btrfs_block_rsv *block_rsv = NULL;
353 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
354 (root == fs_info->csum_root && trans->adding_csums) ||
355 (root == fs_info->uuid_root))
356 block_rsv = trans->block_rsv;
359 block_rsv = root->block_rsv;
362 block_rsv = &fs_info->empty_block_rsv;
367 struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans,
368 struct btrfs_root *root,
371 struct btrfs_fs_info *fs_info = root->fs_info;
372 struct btrfs_block_rsv *block_rsv;
373 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
375 bool global_updated = false;
377 block_rsv = get_block_rsv(trans, root);
379 if (unlikely(block_rsv->size == 0))
382 ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize);
386 if (block_rsv->failfast)
389 if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {
390 global_updated = true;
391 btrfs_update_global_block_rsv(fs_info);
396 * The global reserve still exists to save us from ourselves, so don't
397 * warn_on if we are short on our delayed refs reserve.
399 if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&
400 btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
401 static DEFINE_RATELIMIT_STATE(_rs,
402 DEFAULT_RATELIMIT_INTERVAL * 10,
403 /*DEFAULT_RATELIMIT_BURST*/ 1);
404 if (__ratelimit(&_rs))
406 "BTRFS: block rsv returned %d\n", ret);
409 ret = btrfs_reserve_metadata_bytes(root, block_rsv, blocksize,
410 BTRFS_RESERVE_NO_FLUSH);
414 * If we couldn't reserve metadata bytes try and use some from
415 * the global reserve if its space type is the same as the global
418 if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&
419 block_rsv->space_info == global_rsv->space_info) {
420 ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize);