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