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