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" |
9c343784 | 8 | #include "block-group.h" |
29cbcf40 | 9 | #include "disk-io.h" |
fc97a410 | 10 | #include "fs.h" |
07e81dc9 | 11 | #include "accessors.h" |
550fa228 | 12 | |
734d8c15 JB |
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 | ||
550fa228 JB |
105 | 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 | struct btrfs_space_info *space_info = block_rsv->space_info; | |
111 | u64 qgroup_to_release = 0; | |
112 | u64 ret; | |
113 | ||
114 | spin_lock(&block_rsv->lock); | |
115 | if (num_bytes == (u64)-1) { | |
116 | num_bytes = block_rsv->size; | |
117 | qgroup_to_release = block_rsv->qgroup_rsv_size; | |
118 | } | |
119 | block_rsv->size -= num_bytes; | |
120 | if (block_rsv->reserved >= block_rsv->size) { | |
121 | num_bytes = block_rsv->reserved - block_rsv->size; | |
122 | block_rsv->reserved = block_rsv->size; | |
c70c2c5b | 123 | block_rsv->full = true; |
550fa228 JB |
124 | } else { |
125 | num_bytes = 0; | |
126 | } | |
127 | if (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) | |
c70c2c5b | 147 | dest->full = true; |
550fa228 JB |
148 | num_bytes -= bytes_to_add; |
149 | } | |
150 | spin_unlock(&dest->lock); | |
151 | } | |
152 | if (num_bytes) | |
d05e4649 JB |
153 | btrfs_space_info_free_bytes_may_use(fs_info, |
154 | space_info, | |
155 | num_bytes); | |
550fa228 JB |
156 | } |
157 | if (qgroup_to_release_ret) | |
158 | *qgroup_to_release_ret = qgroup_to_release; | |
159 | return ret; | |
160 | } | |
161 | ||
162 | int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src, | |
163 | struct btrfs_block_rsv *dst, u64 num_bytes, | |
164 | bool update_size) | |
165 | { | |
166 | int ret; | |
167 | ||
168 | ret = btrfs_block_rsv_use_bytes(src, num_bytes); | |
169 | if (ret) | |
170 | return ret; | |
171 | ||
172 | btrfs_block_rsv_add_bytes(dst, num_bytes, update_size); | |
173 | return 0; | |
174 | } | |
175 | ||
8bfc9b2c | 176 | void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, enum btrfs_rsv_type type) |
550fa228 JB |
177 | { |
178 | memset(rsv, 0, sizeof(*rsv)); | |
179 | spin_lock_init(&rsv->lock); | |
180 | rsv->type = type; | |
181 | } | |
182 | ||
183 | void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info, | |
184 | struct btrfs_block_rsv *rsv, | |
8bfc9b2c | 185 | enum btrfs_rsv_type type) |
550fa228 JB |
186 | { |
187 | btrfs_init_block_rsv(rsv, type); | |
188 | rsv->space_info = btrfs_find_space_info(fs_info, | |
189 | BTRFS_BLOCK_GROUP_METADATA); | |
190 | } | |
191 | ||
192 | struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info, | |
8bfc9b2c | 193 | enum btrfs_rsv_type type) |
550fa228 JB |
194 | { |
195 | struct btrfs_block_rsv *block_rsv; | |
196 | ||
197 | block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS); | |
198 | if (!block_rsv) | |
199 | return NULL; | |
200 | ||
201 | btrfs_init_metadata_block_rsv(fs_info, block_rsv, type); | |
202 | return block_rsv; | |
203 | } | |
204 | ||
205 | void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info, | |
206 | struct btrfs_block_rsv *rsv) | |
207 | { | |
208 | if (!rsv) | |
209 | return; | |
63f018be | 210 | btrfs_block_rsv_release(fs_info, rsv, (u64)-1, NULL); |
550fa228 JB |
211 | kfree(rsv); |
212 | } | |
213 | ||
9270501c | 214 | int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info, |
550fa228 JB |
215 | struct btrfs_block_rsv *block_rsv, u64 num_bytes, |
216 | enum btrfs_reserve_flush_enum flush) | |
217 | { | |
218 | int ret; | |
219 | ||
220 | if (num_bytes == 0) | |
221 | return 0; | |
222 | ||
9270501c | 223 | ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush); |
550fa228 JB |
224 | if (!ret) |
225 | btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true); | |
226 | ||
227 | return ret; | |
228 | } | |
229 | ||
230 | int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_factor) | |
231 | { | |
232 | u64 num_bytes = 0; | |
233 | int ret = -ENOSPC; | |
234 | ||
235 | if (!block_rsv) | |
236 | return 0; | |
237 | ||
238 | spin_lock(&block_rsv->lock); | |
239 | num_bytes = div_factor(block_rsv->size, min_factor); | |
240 | if (block_rsv->reserved >= num_bytes) | |
241 | ret = 0; | |
242 | spin_unlock(&block_rsv->lock); | |
243 | ||
244 | return ret; | |
245 | } | |
246 | ||
9270501c | 247 | int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info, |
550fa228 JB |
248 | struct btrfs_block_rsv *block_rsv, u64 min_reserved, |
249 | enum btrfs_reserve_flush_enum flush) | |
250 | { | |
251 | u64 num_bytes = 0; | |
252 | int ret = -ENOSPC; | |
253 | ||
254 | if (!block_rsv) | |
255 | return 0; | |
256 | ||
257 | spin_lock(&block_rsv->lock); | |
258 | num_bytes = min_reserved; | |
259 | if (block_rsv->reserved >= num_bytes) | |
260 | ret = 0; | |
261 | else | |
262 | num_bytes -= block_rsv->reserved; | |
263 | spin_unlock(&block_rsv->lock); | |
264 | ||
265 | if (!ret) | |
266 | return 0; | |
267 | ||
9270501c | 268 | ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush); |
550fa228 JB |
269 | if (!ret) { |
270 | btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false); | |
271 | return 0; | |
272 | } | |
273 | ||
274 | return ret; | |
275 | } | |
276 | ||
63f018be NB |
277 | u64 btrfs_block_rsv_release(struct btrfs_fs_info *fs_info, |
278 | struct btrfs_block_rsv *block_rsv, u64 num_bytes, | |
279 | u64 *qgroup_to_release) | |
550fa228 JB |
280 | { |
281 | struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; | |
282 | struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv; | |
283 | struct btrfs_block_rsv *target = NULL; | |
284 | ||
285 | /* | |
286 | * If we are the delayed_rsv then push to the global rsv, otherwise dump | |
287 | * into the delayed rsv if it is not full. | |
288 | */ | |
289 | if (block_rsv == delayed_rsv) | |
290 | target = global_rsv; | |
748f553c | 291 | else if (block_rsv != global_rsv && !btrfs_block_rsv_full(delayed_rsv)) |
550fa228 JB |
292 | target = delayed_rsv; |
293 | ||
294 | if (target && block_rsv->space_info != target->space_info) | |
295 | target = NULL; | |
296 | ||
297 | return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes, | |
298 | qgroup_to_release); | |
299 | } | |
300 | ||
301 | int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes) | |
302 | { | |
303 | int ret = -ENOSPC; | |
304 | ||
305 | spin_lock(&block_rsv->lock); | |
306 | if (block_rsv->reserved >= num_bytes) { | |
307 | block_rsv->reserved -= num_bytes; | |
308 | if (block_rsv->reserved < block_rsv->size) | |
c70c2c5b | 309 | block_rsv->full = false; |
550fa228 JB |
310 | ret = 0; |
311 | } | |
312 | spin_unlock(&block_rsv->lock); | |
313 | return ret; | |
314 | } | |
315 | ||
316 | void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv, | |
317 | u64 num_bytes, bool update_size) | |
318 | { | |
319 | spin_lock(&block_rsv->lock); | |
320 | block_rsv->reserved += num_bytes; | |
321 | if (update_size) | |
322 | block_rsv->size += num_bytes; | |
323 | else if (block_rsv->reserved >= block_rsv->size) | |
c70c2c5b | 324 | block_rsv->full = true; |
550fa228 JB |
325 | spin_unlock(&block_rsv->lock); |
326 | } | |
327 | ||
328 | int btrfs_cond_migrate_bytes(struct btrfs_fs_info *fs_info, | |
329 | struct btrfs_block_rsv *dest, u64 num_bytes, | |
330 | int min_factor) | |
331 | { | |
332 | struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; | |
333 | u64 min_bytes; | |
334 | ||
335 | if (global_rsv->space_info != dest->space_info) | |
336 | return -ENOSPC; | |
337 | ||
338 | spin_lock(&global_rsv->lock); | |
339 | min_bytes = div_factor(global_rsv->size, min_factor); | |
340 | if (global_rsv->reserved < min_bytes + num_bytes) { | |
341 | spin_unlock(&global_rsv->lock); | |
342 | return -ENOSPC; | |
343 | } | |
344 | global_rsv->reserved -= num_bytes; | |
345 | if (global_rsv->reserved < global_rsv->size) | |
c70c2c5b | 346 | global_rsv->full = false; |
550fa228 JB |
347 | spin_unlock(&global_rsv->lock); |
348 | ||
349 | btrfs_block_rsv_add_bytes(dest, num_bytes, true); | |
350 | return 0; | |
351 | } | |
67f9c220 JB |
352 | |
353 | void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info) | |
354 | { | |
355 | struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; | |
356 | struct btrfs_space_info *sinfo = block_rsv->space_info; | |
9506f953 JB |
357 | struct btrfs_root *root, *tmp; |
358 | u64 num_bytes = btrfs_root_used(&fs_info->tree_root->root_item); | |
359 | unsigned int min_items = 1; | |
67f9c220 JB |
360 | |
361 | /* | |
362 | * The global block rsv is based on the size of the extent tree, the | |
363 | * checksum tree and the root tree. If the fs is empty we want to set | |
364 | * it to a minimal amount for safety. | |
9506f953 JB |
365 | * |
366 | * We also are going to need to modify the minimum of the tree root and | |
367 | * any global roots we could touch. | |
67f9c220 | 368 | */ |
9506f953 JB |
369 | read_lock(&fs_info->global_root_lock); |
370 | rbtree_postorder_for_each_entry_safe(root, tmp, &fs_info->global_root_tree, | |
371 | rb_node) { | |
372 | if (root->root_key.objectid == BTRFS_EXTENT_TREE_OBJECTID || | |
373 | root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID || | |
374 | root->root_key.objectid == BTRFS_FREE_SPACE_TREE_OBJECTID) { | |
375 | num_bytes += btrfs_root_used(&root->root_item); | |
376 | min_items++; | |
377 | } | |
378 | } | |
379 | read_unlock(&fs_info->global_root_lock); | |
3593ce30 JB |
380 | |
381 | /* | |
382 | * But we also want to reserve enough space so we can do the fallback | |
383 | * global reserve for an unlink, which is an additional 5 items (see the | |
384 | * comment in __unlink_start_trans for what we're modifying.) | |
385 | * | |
386 | * But we also need space for the delayed ref updates from the unlink, | |
387 | * so its 10, 5 for the actual operation, and 5 for the delayed ref | |
388 | * updates. | |
389 | */ | |
390 | min_items += 10; | |
391 | ||
392 | num_bytes = max_t(u64, num_bytes, | |
393 | btrfs_calc_insert_metadata_size(fs_info, min_items)); | |
67f9c220 JB |
394 | |
395 | spin_lock(&sinfo->lock); | |
396 | spin_lock(&block_rsv->lock); | |
397 | ||
398 | block_rsv->size = min_t(u64, num_bytes, SZ_512M); | |
399 | ||
400 | if (block_rsv->reserved < block_rsv->size) { | |
d792b0f1 | 401 | num_bytes = block_rsv->size - block_rsv->reserved; |
d792b0f1 JB |
402 | btrfs_space_info_update_bytes_may_use(fs_info, sinfo, |
403 | num_bytes); | |
b82582d6 | 404 | block_rsv->reserved = block_rsv->size; |
67f9c220 JB |
405 | } else if (block_rsv->reserved > block_rsv->size) { |
406 | num_bytes = block_rsv->reserved - block_rsv->size; | |
407 | btrfs_space_info_update_bytes_may_use(fs_info, sinfo, | |
408 | -num_bytes); | |
67f9c220 | 409 | block_rsv->reserved = block_rsv->size; |
426551f6 | 410 | btrfs_try_granting_tickets(fs_info, sinfo); |
67f9c220 JB |
411 | } |
412 | ||
c70c2c5b | 413 | block_rsv->full = (block_rsv->reserved == block_rsv->size); |
67f9c220 | 414 | |
9c343784 JB |
415 | if (block_rsv->size >= sinfo->total_bytes) |
416 | sinfo->force_alloc = CHUNK_ALLOC_FORCE; | |
67f9c220 JB |
417 | spin_unlock(&block_rsv->lock); |
418 | spin_unlock(&sinfo->lock); | |
419 | } | |
420 | ||
2e608bd1 JB |
421 | void btrfs_init_root_block_rsv(struct btrfs_root *root) |
422 | { | |
423 | struct btrfs_fs_info *fs_info = root->fs_info; | |
424 | ||
425 | switch (root->root_key.objectid) { | |
426 | case BTRFS_CSUM_TREE_OBJECTID: | |
427 | case BTRFS_EXTENT_TREE_OBJECTID: | |
c18e3235 | 428 | case BTRFS_FREE_SPACE_TREE_OBJECTID: |
14033b08 | 429 | case BTRFS_BLOCK_GROUP_TREE_OBJECTID: |
2e608bd1 JB |
430 | root->block_rsv = &fs_info->delayed_refs_rsv; |
431 | break; | |
432 | case BTRFS_ROOT_TREE_OBJECTID: | |
433 | case BTRFS_DEV_TREE_OBJECTID: | |
434 | case BTRFS_QUOTA_TREE_OBJECTID: | |
435 | root->block_rsv = &fs_info->global_block_rsv; | |
436 | break; | |
437 | case BTRFS_CHUNK_TREE_OBJECTID: | |
438 | root->block_rsv = &fs_info->chunk_block_rsv; | |
439 | break; | |
440 | default: | |
441 | root->block_rsv = NULL; | |
442 | break; | |
443 | } | |
444 | } | |
445 | ||
67f9c220 JB |
446 | void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info) |
447 | { | |
448 | struct btrfs_space_info *space_info; | |
449 | ||
450 | space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM); | |
451 | fs_info->chunk_block_rsv.space_info = space_info; | |
452 | ||
453 | space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA); | |
454 | fs_info->global_block_rsv.space_info = space_info; | |
455 | fs_info->trans_block_rsv.space_info = space_info; | |
456 | fs_info->empty_block_rsv.space_info = space_info; | |
457 | fs_info->delayed_block_rsv.space_info = space_info; | |
458 | fs_info->delayed_refs_rsv.space_info = space_info; | |
459 | ||
67f9c220 JB |
460 | btrfs_update_global_block_rsv(fs_info); |
461 | } | |
462 | ||
463 | void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info) | |
464 | { | |
63f018be NB |
465 | btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1, |
466 | NULL); | |
67f9c220 JB |
467 | WARN_ON(fs_info->trans_block_rsv.size > 0); |
468 | WARN_ON(fs_info->trans_block_rsv.reserved > 0); | |
469 | WARN_ON(fs_info->chunk_block_rsv.size > 0); | |
470 | WARN_ON(fs_info->chunk_block_rsv.reserved > 0); | |
471 | WARN_ON(fs_info->delayed_block_rsv.size > 0); | |
472 | WARN_ON(fs_info->delayed_block_rsv.reserved > 0); | |
473 | WARN_ON(fs_info->delayed_refs_rsv.reserved > 0); | |
474 | WARN_ON(fs_info->delayed_refs_rsv.size > 0); | |
475 | } | |
476 | ||
477 | static struct btrfs_block_rsv *get_block_rsv( | |
478 | const struct btrfs_trans_handle *trans, | |
479 | const struct btrfs_root *root) | |
480 | { | |
481 | struct btrfs_fs_info *fs_info = root->fs_info; | |
482 | struct btrfs_block_rsv *block_rsv = NULL; | |
483 | ||
92a7cc42 | 484 | if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || |
fc28b25e JB |
485 | (root == fs_info->uuid_root) || |
486 | (trans->adding_csums && | |
487 | root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID)) | |
67f9c220 JB |
488 | block_rsv = trans->block_rsv; |
489 | ||
490 | if (!block_rsv) | |
491 | block_rsv = root->block_rsv; | |
492 | ||
493 | if (!block_rsv) | |
494 | block_rsv = &fs_info->empty_block_rsv; | |
495 | ||
496 | return block_rsv; | |
497 | } | |
498 | ||
499 | struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans, | |
500 | struct btrfs_root *root, | |
501 | u32 blocksize) | |
502 | { | |
503 | struct btrfs_fs_info *fs_info = root->fs_info; | |
504 | struct btrfs_block_rsv *block_rsv; | |
505 | struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; | |
506 | int ret; | |
507 | bool global_updated = false; | |
508 | ||
509 | block_rsv = get_block_rsv(trans, root); | |
510 | ||
511 | if (unlikely(block_rsv->size == 0)) | |
512 | goto try_reserve; | |
513 | again: | |
514 | ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize); | |
515 | if (!ret) | |
516 | return block_rsv; | |
517 | ||
518 | if (block_rsv->failfast) | |
519 | return ERR_PTR(ret); | |
520 | ||
521 | if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) { | |
522 | global_updated = true; | |
523 | btrfs_update_global_block_rsv(fs_info); | |
524 | goto again; | |
525 | } | |
526 | ||
527 | /* | |
528 | * The global reserve still exists to save us from ourselves, so don't | |
529 | * warn_on if we are short on our delayed refs reserve. | |
530 | */ | |
531 | if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS && | |
532 | btrfs_test_opt(fs_info, ENOSPC_DEBUG)) { | |
533 | static DEFINE_RATELIMIT_STATE(_rs, | |
534 | DEFAULT_RATELIMIT_INTERVAL * 10, | |
535 | /*DEFAULT_RATELIMIT_BURST*/ 1); | |
536 | if (__ratelimit(&_rs)) | |
537 | WARN(1, KERN_DEBUG | |
e38fdb71 JB |
538 | "BTRFS: block rsv %d returned %d\n", |
539 | block_rsv->type, ret); | |
67f9c220 JB |
540 | } |
541 | try_reserve: | |
9270501c | 542 | ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, blocksize, |
67f9c220 JB |
543 | BTRFS_RESERVE_NO_FLUSH); |
544 | if (!ret) | |
545 | return block_rsv; | |
546 | /* | |
547 | * If we couldn't reserve metadata bytes try and use some from | |
548 | * the global reserve if its space type is the same as the global | |
549 | * reservation. | |
550 | */ | |
551 | if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL && | |
552 | block_rsv->space_info == global_rsv->space_info) { | |
553 | ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize); | |
554 | if (!ret) | |
555 | return global_rsv; | |
556 | } | |
765c3fe9 JB |
557 | |
558 | /* | |
559 | * All hope is lost, but of course our reservations are overly | |
560 | * pessimistic, so instead of possibly having an ENOSPC abort here, try | |
561 | * one last time to force a reservation if there's enough actual space | |
562 | * on disk to make the reservation. | |
563 | */ | |
564 | ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, blocksize, | |
565 | BTRFS_RESERVE_FLUSH_EMERGENCY); | |
566 | if (!ret) | |
567 | return block_rsv; | |
568 | ||
67f9c220 JB |
569 | return ERR_PTR(ret); |
570 | } |