1550fa228SJosef Bacik // SPDX-License-Identifier: GPL-2.0
2550fa228SJosef Bacik
3784352feSDavid Sterba #include "misc.h"
4550fa228SJosef Bacik #include "ctree.h"
5550fa228SJosef Bacik #include "block-rsv.h"
6550fa228SJosef Bacik #include "space-info.h"
767f9c220SJosef Bacik #include "transaction.h"
89c343784SJosef Bacik #include "block-group.h"
929cbcf40SJosef Bacik #include "disk-io.h"
10fc97a410SJosef Bacik #include "fs.h"
1107e81dc9SJosef Bacik #include "accessors.h"
12550fa228SJosef Bacik
13734d8c15SJosef Bacik /*
14734d8c15SJosef Bacik * HOW DO BLOCK RESERVES WORK
15734d8c15SJosef Bacik *
16734d8c15SJosef Bacik * Think of block_rsv's as buckets for logically grouped metadata
17734d8c15SJosef Bacik * reservations. Each block_rsv has a ->size and a ->reserved. ->size is
18734d8c15SJosef Bacik * how large we want our block rsv to be, ->reserved is how much space is
19734d8c15SJosef Bacik * currently reserved for this block reserve.
20734d8c15SJosef Bacik *
21734d8c15SJosef Bacik * ->failfast exists for the truncate case, and is described below.
22734d8c15SJosef Bacik *
23734d8c15SJosef Bacik * NORMAL OPERATION
24734d8c15SJosef Bacik *
25734d8c15SJosef Bacik * -> Reserve
26734d8c15SJosef Bacik * Entrance: btrfs_block_rsv_add, btrfs_block_rsv_refill
27734d8c15SJosef Bacik *
28734d8c15SJosef Bacik * We call into btrfs_reserve_metadata_bytes() with our bytes, which is
29734d8c15SJosef Bacik * accounted for in space_info->bytes_may_use, and then add the bytes to
30734d8c15SJosef Bacik * ->reserved, and ->size in the case of btrfs_block_rsv_add.
31734d8c15SJosef Bacik *
32734d8c15SJosef Bacik * ->size is an over-estimation of how much we may use for a particular
33734d8c15SJosef Bacik * operation.
34734d8c15SJosef Bacik *
35734d8c15SJosef Bacik * -> Use
36734d8c15SJosef Bacik * Entrance: btrfs_use_block_rsv
37734d8c15SJosef Bacik *
38734d8c15SJosef Bacik * When we do a btrfs_alloc_tree_block() we call into btrfs_use_block_rsv()
39734d8c15SJosef Bacik * to determine the appropriate block_rsv to use, and then verify that
40734d8c15SJosef Bacik * ->reserved has enough space for our tree block allocation. Once
41734d8c15SJosef Bacik * successful we subtract fs_info->nodesize from ->reserved.
42734d8c15SJosef Bacik *
43734d8c15SJosef Bacik * -> Finish
44734d8c15SJosef Bacik * Entrance: btrfs_block_rsv_release
45734d8c15SJosef Bacik *
46734d8c15SJosef Bacik * We are finished with our operation, subtract our individual reservation
47734d8c15SJosef Bacik * from ->size, and then subtract ->size from ->reserved and free up the
48734d8c15SJosef Bacik * excess if there is any.
49734d8c15SJosef Bacik *
50734d8c15SJosef Bacik * There is some logic here to refill the delayed refs rsv or the global rsv
51734d8c15SJosef Bacik * as needed, otherwise the excess is subtracted from
52734d8c15SJosef Bacik * space_info->bytes_may_use.
53734d8c15SJosef Bacik *
54734d8c15SJosef Bacik * TYPES OF BLOCK RESERVES
55734d8c15SJosef Bacik *
56734d8c15SJosef Bacik * BLOCK_RSV_TRANS, BLOCK_RSV_DELOPS, BLOCK_RSV_CHUNK
57734d8c15SJosef Bacik * These behave normally, as described above, just within the confines of the
58734d8c15SJosef Bacik * lifetime of their particular operation (transaction for the whole trans
59734d8c15SJosef Bacik * handle lifetime, for example).
60734d8c15SJosef Bacik *
61734d8c15SJosef Bacik * BLOCK_RSV_GLOBAL
62734d8c15SJosef Bacik * It is impossible to properly account for all the space that may be required
63734d8c15SJosef Bacik * to make our extent tree updates. This block reserve acts as an overflow
64734d8c15SJosef Bacik * buffer in case our delayed refs reserve does not reserve enough space to
65734d8c15SJosef Bacik * update the extent tree.
66734d8c15SJosef Bacik *
67734d8c15SJosef Bacik * We can steal from this in some cases as well, notably on evict() or
68734d8c15SJosef Bacik * truncate() in order to help users recover from ENOSPC conditions.
69734d8c15SJosef Bacik *
70734d8c15SJosef Bacik * BLOCK_RSV_DELALLOC
71734d8c15SJosef Bacik * The individual item sizes are determined by the per-inode size
72734d8c15SJosef Bacik * calculations, which are described with the delalloc code. This is pretty
73734d8c15SJosef Bacik * straightforward, it's just the calculation of ->size encodes a lot of
74734d8c15SJosef Bacik * different items, and thus it gets used when updating inodes, inserting file
75734d8c15SJosef Bacik * extents, and inserting checksums.
76734d8c15SJosef Bacik *
77734d8c15SJosef Bacik * BLOCK_RSV_DELREFS
78734d8c15SJosef Bacik * We keep a running tally of how many delayed refs we have on the system.
79734d8c15SJosef Bacik * We assume each one of these delayed refs are going to use a full
80734d8c15SJosef Bacik * reservation. We use the transaction items and pre-reserve space for every
81734d8c15SJosef Bacik * operation, and use this reservation to refill any gap between ->size and
82734d8c15SJosef Bacik * ->reserved that may exist.
83734d8c15SJosef Bacik *
84734d8c15SJosef Bacik * From there it's straightforward, removing a delayed ref means we remove its
85734d8c15SJosef Bacik * count from ->size and free up reservations as necessary. Since this is
86734d8c15SJosef Bacik * the most dynamic block reserve in the system, we will try to refill this
87734d8c15SJosef Bacik * block reserve first with any excess returned by any other block reserve.
88734d8c15SJosef Bacik *
89734d8c15SJosef Bacik * BLOCK_RSV_EMPTY
90734d8c15SJosef Bacik * This is the fallback block reserve to make us try to reserve space if we
91734d8c15SJosef Bacik * don't have a specific bucket for this allocation. It is mostly used for
92734d8c15SJosef Bacik * updating the device tree and such, since that is a separate pool we're
93734d8c15SJosef Bacik * content to just reserve space from the space_info on demand.
94734d8c15SJosef Bacik *
95734d8c15SJosef Bacik * BLOCK_RSV_TEMP
96734d8c15SJosef Bacik * This is used by things like truncate and iput. We will temporarily
97734d8c15SJosef Bacik * allocate a block reserve, set it to some size, and then truncate bytes
98734d8c15SJosef Bacik * until we have no space left. With ->failfast set we'll simply return
99734d8c15SJosef Bacik * ENOSPC from btrfs_use_block_rsv() to signal that we need to unwind and try
100734d8c15SJosef Bacik * to make a new reservation. This is because these operations are
101734d8c15SJosef Bacik * unbounded, so we want to do as much work as we can, and then back off and
102734d8c15SJosef Bacik * re-reserve.
103734d8c15SJosef Bacik */
104734d8c15SJosef Bacik
block_rsv_release_bytes(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * block_rsv,struct btrfs_block_rsv * dest,u64 num_bytes,u64 * qgroup_to_release_ret)105550fa228SJosef Bacik static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
106550fa228SJosef Bacik struct btrfs_block_rsv *block_rsv,
107550fa228SJosef Bacik struct btrfs_block_rsv *dest, u64 num_bytes,
108550fa228SJosef Bacik u64 *qgroup_to_release_ret)
109550fa228SJosef Bacik {
110550fa228SJosef Bacik struct btrfs_space_info *space_info = block_rsv->space_info;
111550fa228SJosef Bacik u64 qgroup_to_release = 0;
112550fa228SJosef Bacik u64 ret;
113550fa228SJosef Bacik
114550fa228SJosef Bacik spin_lock(&block_rsv->lock);
115550fa228SJosef Bacik if (num_bytes == (u64)-1) {
116550fa228SJosef Bacik num_bytes = block_rsv->size;
117550fa228SJosef Bacik qgroup_to_release = block_rsv->qgroup_rsv_size;
118550fa228SJosef Bacik }
119550fa228SJosef Bacik block_rsv->size -= num_bytes;
120550fa228SJosef Bacik if (block_rsv->reserved >= block_rsv->size) {
121550fa228SJosef Bacik num_bytes = block_rsv->reserved - block_rsv->size;
122550fa228SJosef Bacik block_rsv->reserved = block_rsv->size;
123c70c2c5bSDavid Sterba block_rsv->full = true;
124550fa228SJosef Bacik } else {
125550fa228SJosef Bacik num_bytes = 0;
126550fa228SJosef Bacik }
127d246331bSJosef Bacik if (qgroup_to_release_ret &&
128d246331bSJosef Bacik block_rsv->qgroup_rsv_reserved >= block_rsv->qgroup_rsv_size) {
129550fa228SJosef Bacik qgroup_to_release = block_rsv->qgroup_rsv_reserved -
130550fa228SJosef Bacik block_rsv->qgroup_rsv_size;
131550fa228SJosef Bacik block_rsv->qgroup_rsv_reserved = block_rsv->qgroup_rsv_size;
132550fa228SJosef Bacik } else {
133550fa228SJosef Bacik qgroup_to_release = 0;
134550fa228SJosef Bacik }
135550fa228SJosef Bacik spin_unlock(&block_rsv->lock);
136550fa228SJosef Bacik
137550fa228SJosef Bacik ret = num_bytes;
138550fa228SJosef Bacik if (num_bytes > 0) {
139550fa228SJosef Bacik if (dest) {
140550fa228SJosef Bacik spin_lock(&dest->lock);
141550fa228SJosef Bacik if (!dest->full) {
142550fa228SJosef Bacik u64 bytes_to_add;
143550fa228SJosef Bacik
144550fa228SJosef Bacik bytes_to_add = dest->size - dest->reserved;
145550fa228SJosef Bacik bytes_to_add = min(num_bytes, bytes_to_add);
146550fa228SJosef Bacik dest->reserved += bytes_to_add;
147550fa228SJosef Bacik if (dest->reserved >= dest->size)
148c70c2c5bSDavid Sterba dest->full = true;
149550fa228SJosef Bacik num_bytes -= bytes_to_add;
150550fa228SJosef Bacik }
151550fa228SJosef Bacik spin_unlock(&dest->lock);
152550fa228SJosef Bacik }
153550fa228SJosef Bacik if (num_bytes)
154d05e4649SJosef Bacik btrfs_space_info_free_bytes_may_use(fs_info,
155d05e4649SJosef Bacik space_info,
156550fa228SJosef Bacik num_bytes);
157550fa228SJosef Bacik }
158550fa228SJosef Bacik if (qgroup_to_release_ret)
159550fa228SJosef Bacik *qgroup_to_release_ret = qgroup_to_release;
160550fa228SJosef Bacik return ret;
161550fa228SJosef Bacik }
162550fa228SJosef Bacik
btrfs_block_rsv_migrate(struct btrfs_block_rsv * src,struct btrfs_block_rsv * dst,u64 num_bytes,bool update_size)163550fa228SJosef Bacik int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src,
164550fa228SJosef Bacik struct btrfs_block_rsv *dst, u64 num_bytes,
165550fa228SJosef Bacik bool update_size)
166550fa228SJosef Bacik {
167550fa228SJosef Bacik int ret;
168550fa228SJosef Bacik
169550fa228SJosef Bacik ret = btrfs_block_rsv_use_bytes(src, num_bytes);
170550fa228SJosef Bacik if (ret)
171550fa228SJosef Bacik return ret;
172550fa228SJosef Bacik
173550fa228SJosef Bacik btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);
174550fa228SJosef Bacik return 0;
175550fa228SJosef Bacik }
176550fa228SJosef Bacik
btrfs_init_block_rsv(struct btrfs_block_rsv * rsv,enum btrfs_rsv_type type)1778bfc9b2cSDavid Sterba void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, enum btrfs_rsv_type type)
178550fa228SJosef Bacik {
179550fa228SJosef Bacik memset(rsv, 0, sizeof(*rsv));
180550fa228SJosef Bacik spin_lock_init(&rsv->lock);
181550fa228SJosef Bacik rsv->type = type;
182550fa228SJosef Bacik }
183550fa228SJosef Bacik
btrfs_init_metadata_block_rsv(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * rsv,enum btrfs_rsv_type type)184550fa228SJosef Bacik void btrfs_init_metadata_block_rsv(struct btrfs_fs_info *fs_info,
185550fa228SJosef Bacik struct btrfs_block_rsv *rsv,
1868bfc9b2cSDavid Sterba enum btrfs_rsv_type type)
187550fa228SJosef Bacik {
188550fa228SJosef Bacik btrfs_init_block_rsv(rsv, type);
189550fa228SJosef Bacik rsv->space_info = btrfs_find_space_info(fs_info,
190550fa228SJosef Bacik BTRFS_BLOCK_GROUP_METADATA);
191550fa228SJosef Bacik }
192550fa228SJosef Bacik
btrfs_alloc_block_rsv(struct btrfs_fs_info * fs_info,enum btrfs_rsv_type type)193550fa228SJosef Bacik struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_fs_info *fs_info,
1948bfc9b2cSDavid Sterba enum btrfs_rsv_type type)
195550fa228SJosef Bacik {
196550fa228SJosef Bacik struct btrfs_block_rsv *block_rsv;
197550fa228SJosef Bacik
198550fa228SJosef Bacik block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
199550fa228SJosef Bacik if (!block_rsv)
200550fa228SJosef Bacik return NULL;
201550fa228SJosef Bacik
202550fa228SJosef Bacik btrfs_init_metadata_block_rsv(fs_info, block_rsv, type);
203550fa228SJosef Bacik return block_rsv;
204550fa228SJosef Bacik }
205550fa228SJosef Bacik
btrfs_free_block_rsv(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * rsv)206550fa228SJosef Bacik void btrfs_free_block_rsv(struct btrfs_fs_info *fs_info,
207550fa228SJosef Bacik struct btrfs_block_rsv *rsv)
208550fa228SJosef Bacik {
209550fa228SJosef Bacik if (!rsv)
210550fa228SJosef Bacik return;
21163f018beSNikolay Borisov btrfs_block_rsv_release(fs_info, rsv, (u64)-1, NULL);
212550fa228SJosef Bacik kfree(rsv);
213550fa228SJosef Bacik }
214550fa228SJosef Bacik
btrfs_block_rsv_add(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * block_rsv,u64 num_bytes,enum btrfs_reserve_flush_enum flush)2159270501cSJosef Bacik int btrfs_block_rsv_add(struct btrfs_fs_info *fs_info,
216550fa228SJosef Bacik struct btrfs_block_rsv *block_rsv, u64 num_bytes,
217550fa228SJosef Bacik enum btrfs_reserve_flush_enum flush)
218550fa228SJosef Bacik {
219550fa228SJosef Bacik int ret;
220550fa228SJosef Bacik
221550fa228SJosef Bacik if (num_bytes == 0)
222550fa228SJosef Bacik return 0;
223550fa228SJosef Bacik
2249270501cSJosef Bacik ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
225550fa228SJosef Bacik if (!ret)
226550fa228SJosef Bacik btrfs_block_rsv_add_bytes(block_rsv, num_bytes, true);
227550fa228SJosef Bacik
228550fa228SJosef Bacik return ret;
229550fa228SJosef Bacik }
230550fa228SJosef Bacik
btrfs_block_rsv_check(struct btrfs_block_rsv * block_rsv,int min_percent)231428c8e03SDavid Sterba int btrfs_block_rsv_check(struct btrfs_block_rsv *block_rsv, int min_percent)
232550fa228SJosef Bacik {
233550fa228SJosef Bacik u64 num_bytes = 0;
234550fa228SJosef Bacik int ret = -ENOSPC;
235550fa228SJosef Bacik
236550fa228SJosef Bacik spin_lock(&block_rsv->lock);
237428c8e03SDavid Sterba num_bytes = mult_perc(block_rsv->size, min_percent);
238550fa228SJosef Bacik if (block_rsv->reserved >= num_bytes)
239550fa228SJosef Bacik ret = 0;
240550fa228SJosef Bacik spin_unlock(&block_rsv->lock);
241550fa228SJosef Bacik
242550fa228SJosef Bacik return ret;
243550fa228SJosef Bacik }
244550fa228SJosef Bacik
btrfs_block_rsv_refill(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * block_rsv,u64 num_bytes,enum btrfs_reserve_flush_enum flush)2459270501cSJosef Bacik int btrfs_block_rsv_refill(struct btrfs_fs_info *fs_info,
2464e8313e5SFilipe Manana struct btrfs_block_rsv *block_rsv, u64 num_bytes,
247550fa228SJosef Bacik enum btrfs_reserve_flush_enum flush)
248550fa228SJosef Bacik {
249550fa228SJosef Bacik int ret = -ENOSPC;
250550fa228SJosef Bacik
251550fa228SJosef Bacik if (!block_rsv)
252550fa228SJosef Bacik return 0;
253550fa228SJosef Bacik
254550fa228SJosef Bacik spin_lock(&block_rsv->lock);
255550fa228SJosef Bacik if (block_rsv->reserved >= num_bytes)
256550fa228SJosef Bacik ret = 0;
257550fa228SJosef Bacik else
258550fa228SJosef Bacik num_bytes -= block_rsv->reserved;
259550fa228SJosef Bacik spin_unlock(&block_rsv->lock);
260550fa228SJosef Bacik
261550fa228SJosef Bacik if (!ret)
262550fa228SJosef Bacik return 0;
263550fa228SJosef Bacik
2649270501cSJosef Bacik ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, num_bytes, flush);
265550fa228SJosef Bacik if (!ret) {
266550fa228SJosef Bacik btrfs_block_rsv_add_bytes(block_rsv, num_bytes, false);
267550fa228SJosef Bacik return 0;
268550fa228SJosef Bacik }
269550fa228SJosef Bacik
270550fa228SJosef Bacik return ret;
271550fa228SJosef Bacik }
272550fa228SJosef Bacik
btrfs_block_rsv_release(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * block_rsv,u64 num_bytes,u64 * qgroup_to_release)27363f018beSNikolay Borisov u64 btrfs_block_rsv_release(struct btrfs_fs_info *fs_info,
27463f018beSNikolay Borisov struct btrfs_block_rsv *block_rsv, u64 num_bytes,
27563f018beSNikolay Borisov u64 *qgroup_to_release)
276550fa228SJosef Bacik {
277550fa228SJosef Bacik struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
278550fa228SJosef Bacik struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_refs_rsv;
279550fa228SJosef Bacik struct btrfs_block_rsv *target = NULL;
280550fa228SJosef Bacik
281550fa228SJosef Bacik /*
282550fa228SJosef Bacik * If we are the delayed_rsv then push to the global rsv, otherwise dump
283550fa228SJosef Bacik * into the delayed rsv if it is not full.
284550fa228SJosef Bacik */
285550fa228SJosef Bacik if (block_rsv == delayed_rsv)
286550fa228SJosef Bacik target = global_rsv;
287748f553cSDavid Sterba else if (block_rsv != global_rsv && !btrfs_block_rsv_full(delayed_rsv))
288550fa228SJosef Bacik target = delayed_rsv;
289550fa228SJosef Bacik
290550fa228SJosef Bacik if (target && block_rsv->space_info != target->space_info)
291550fa228SJosef Bacik target = NULL;
292550fa228SJosef Bacik
293550fa228SJosef Bacik return block_rsv_release_bytes(fs_info, block_rsv, target, num_bytes,
294550fa228SJosef Bacik qgroup_to_release);
295550fa228SJosef Bacik }
296550fa228SJosef Bacik
btrfs_block_rsv_use_bytes(struct btrfs_block_rsv * block_rsv,u64 num_bytes)297550fa228SJosef Bacik int btrfs_block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv, u64 num_bytes)
298550fa228SJosef Bacik {
299550fa228SJosef Bacik int ret = -ENOSPC;
300550fa228SJosef Bacik
301550fa228SJosef Bacik spin_lock(&block_rsv->lock);
302550fa228SJosef Bacik if (block_rsv->reserved >= num_bytes) {
303550fa228SJosef Bacik block_rsv->reserved -= num_bytes;
304550fa228SJosef Bacik if (block_rsv->reserved < block_rsv->size)
305c70c2c5bSDavid Sterba block_rsv->full = false;
306550fa228SJosef Bacik ret = 0;
307550fa228SJosef Bacik }
308550fa228SJosef Bacik spin_unlock(&block_rsv->lock);
309550fa228SJosef Bacik return ret;
310550fa228SJosef Bacik }
311550fa228SJosef Bacik
btrfs_block_rsv_add_bytes(struct btrfs_block_rsv * block_rsv,u64 num_bytes,bool update_size)312550fa228SJosef Bacik void btrfs_block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
313550fa228SJosef Bacik u64 num_bytes, bool update_size)
314550fa228SJosef Bacik {
315550fa228SJosef Bacik spin_lock(&block_rsv->lock);
316550fa228SJosef Bacik block_rsv->reserved += num_bytes;
317550fa228SJosef Bacik if (update_size)
318550fa228SJosef Bacik block_rsv->size += num_bytes;
319550fa228SJosef Bacik else if (block_rsv->reserved >= block_rsv->size)
320c70c2c5bSDavid Sterba block_rsv->full = true;
321550fa228SJosef Bacik spin_unlock(&block_rsv->lock);
322550fa228SJosef Bacik }
323550fa228SJosef Bacik
btrfs_update_global_block_rsv(struct btrfs_fs_info * fs_info)32467f9c220SJosef Bacik void btrfs_update_global_block_rsv(struct btrfs_fs_info *fs_info)
32567f9c220SJosef Bacik {
32667f9c220SJosef Bacik struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
32767f9c220SJosef Bacik struct btrfs_space_info *sinfo = block_rsv->space_info;
3289506f953SJosef Bacik struct btrfs_root *root, *tmp;
3299506f953SJosef Bacik u64 num_bytes = btrfs_root_used(&fs_info->tree_root->root_item);
3309506f953SJosef Bacik unsigned int min_items = 1;
33167f9c220SJosef Bacik
33267f9c220SJosef Bacik /*
33367f9c220SJosef Bacik * The global block rsv is based on the size of the extent tree, the
33467f9c220SJosef Bacik * checksum tree and the root tree. If the fs is empty we want to set
33567f9c220SJosef Bacik * it to a minimal amount for safety.
3369506f953SJosef Bacik *
3379506f953SJosef Bacik * We also are going to need to modify the minimum of the tree root and
3389506f953SJosef Bacik * any global roots we could touch.
33967f9c220SJosef Bacik */
3409506f953SJosef Bacik read_lock(&fs_info->global_root_lock);
3419506f953SJosef Bacik rbtree_postorder_for_each_entry_safe(root, tmp, &fs_info->global_root_tree,
3429506f953SJosef Bacik rb_node) {
3439506f953SJosef Bacik if (root->root_key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
3449506f953SJosef Bacik root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID ||
3459506f953SJosef Bacik root->root_key.objectid == BTRFS_FREE_SPACE_TREE_OBJECTID) {
3469506f953SJosef Bacik num_bytes += btrfs_root_used(&root->root_item);
3479506f953SJosef Bacik min_items++;
3489506f953SJosef Bacik }
3499506f953SJosef Bacik }
3509506f953SJosef Bacik read_unlock(&fs_info->global_root_lock);
3513593ce30SJosef Bacik
3528dbfc14fSFilipe Manana if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {
3538dbfc14fSFilipe Manana num_bytes += btrfs_root_used(&fs_info->block_group_root->root_item);
3548dbfc14fSFilipe Manana min_items++;
3558dbfc14fSFilipe Manana }
3568dbfc14fSFilipe Manana
3573593ce30SJosef Bacik /*
3583593ce30SJosef Bacik * But we also want to reserve enough space so we can do the fallback
3595630e2bcSFilipe Manana * global reserve for an unlink, which is an additional
3605630e2bcSFilipe Manana * BTRFS_UNLINK_METADATA_UNITS items.
3613593ce30SJosef Bacik *
3623593ce30SJosef Bacik * But we also need space for the delayed ref updates from the unlink,
363f8f210dcSFilipe Manana * so add BTRFS_UNLINK_METADATA_UNITS units for delayed refs, one for
364f8f210dcSFilipe Manana * each unlink metadata item.
3653593ce30SJosef Bacik */
366f8f210dcSFilipe Manana min_items += BTRFS_UNLINK_METADATA_UNITS;
3673593ce30SJosef Bacik
3683593ce30SJosef Bacik num_bytes = max_t(u64, num_bytes,
369f8f210dcSFilipe Manana btrfs_calc_insert_metadata_size(fs_info, min_items) +
370f8f210dcSFilipe Manana btrfs_calc_delayed_ref_bytes(fs_info,
371f8f210dcSFilipe Manana BTRFS_UNLINK_METADATA_UNITS));
37267f9c220SJosef Bacik
37367f9c220SJosef Bacik spin_lock(&sinfo->lock);
37467f9c220SJosef Bacik spin_lock(&block_rsv->lock);
37567f9c220SJosef Bacik
37667f9c220SJosef Bacik block_rsv->size = min_t(u64, num_bytes, SZ_512M);
37767f9c220SJosef Bacik
37867f9c220SJosef Bacik if (block_rsv->reserved < block_rsv->size) {
379d792b0f1SJosef Bacik num_bytes = block_rsv->size - block_rsv->reserved;
38067f9c220SJosef Bacik btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
38167f9c220SJosef Bacik num_bytes);
382b82582d6SAnand Jain block_rsv->reserved = block_rsv->size;
38367f9c220SJosef Bacik } else if (block_rsv->reserved > block_rsv->size) {
38467f9c220SJosef Bacik num_bytes = block_rsv->reserved - block_rsv->size;
38567f9c220SJosef Bacik btrfs_space_info_update_bytes_may_use(fs_info, sinfo,
38667f9c220SJosef Bacik -num_bytes);
38767f9c220SJosef Bacik block_rsv->reserved = block_rsv->size;
388426551f6SJosef Bacik btrfs_try_granting_tickets(fs_info, sinfo);
38967f9c220SJosef Bacik }
39067f9c220SJosef Bacik
391c70c2c5bSDavid Sterba block_rsv->full = (block_rsv->reserved == block_rsv->size);
39267f9c220SJosef Bacik
3939c343784SJosef Bacik if (block_rsv->size >= sinfo->total_bytes)
3949c343784SJosef Bacik sinfo->force_alloc = CHUNK_ALLOC_FORCE;
39567f9c220SJosef Bacik spin_unlock(&block_rsv->lock);
39667f9c220SJosef Bacik spin_unlock(&sinfo->lock);
39767f9c220SJosef Bacik }
39867f9c220SJosef Bacik
btrfs_init_root_block_rsv(struct btrfs_root * root)3992e608bd1SJosef Bacik void btrfs_init_root_block_rsv(struct btrfs_root *root)
4002e608bd1SJosef Bacik {
4012e608bd1SJosef Bacik struct btrfs_fs_info *fs_info = root->fs_info;
4022e608bd1SJosef Bacik
4032e608bd1SJosef Bacik switch (root->root_key.objectid) {
4042e608bd1SJosef Bacik case BTRFS_CSUM_TREE_OBJECTID:
4052e608bd1SJosef Bacik case BTRFS_EXTENT_TREE_OBJECTID:
406c18e3235SJosef Bacik case BTRFS_FREE_SPACE_TREE_OBJECTID:
40714033b08SQu Wenruo case BTRFS_BLOCK_GROUP_TREE_OBJECTID:
4082e608bd1SJosef Bacik root->block_rsv = &fs_info->delayed_refs_rsv;
4092e608bd1SJosef Bacik break;
4102e608bd1SJosef Bacik case BTRFS_ROOT_TREE_OBJECTID:
4112e608bd1SJosef Bacik case BTRFS_DEV_TREE_OBJECTID:
4122e608bd1SJosef Bacik case BTRFS_QUOTA_TREE_OBJECTID:
4132e608bd1SJosef Bacik root->block_rsv = &fs_info->global_block_rsv;
4142e608bd1SJosef Bacik break;
4152e608bd1SJosef Bacik case BTRFS_CHUNK_TREE_OBJECTID:
4162e608bd1SJosef Bacik root->block_rsv = &fs_info->chunk_block_rsv;
4172e608bd1SJosef Bacik break;
4182e608bd1SJosef Bacik default:
4192e608bd1SJosef Bacik root->block_rsv = NULL;
4202e608bd1SJosef Bacik break;
4212e608bd1SJosef Bacik }
4222e608bd1SJosef Bacik }
4232e608bd1SJosef Bacik
btrfs_init_global_block_rsv(struct btrfs_fs_info * fs_info)42467f9c220SJosef Bacik void btrfs_init_global_block_rsv(struct btrfs_fs_info *fs_info)
42567f9c220SJosef Bacik {
42667f9c220SJosef Bacik struct btrfs_space_info *space_info;
42767f9c220SJosef Bacik
42867f9c220SJosef Bacik space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
42967f9c220SJosef Bacik fs_info->chunk_block_rsv.space_info = space_info;
43067f9c220SJosef Bacik
43167f9c220SJosef Bacik space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
43267f9c220SJosef Bacik fs_info->global_block_rsv.space_info = space_info;
43367f9c220SJosef Bacik fs_info->trans_block_rsv.space_info = space_info;
43467f9c220SJosef Bacik fs_info->empty_block_rsv.space_info = space_info;
43567f9c220SJosef Bacik fs_info->delayed_block_rsv.space_info = space_info;
43667f9c220SJosef Bacik fs_info->delayed_refs_rsv.space_info = space_info;
43767f9c220SJosef Bacik
43867f9c220SJosef Bacik btrfs_update_global_block_rsv(fs_info);
43967f9c220SJosef Bacik }
44067f9c220SJosef Bacik
btrfs_release_global_block_rsv(struct btrfs_fs_info * fs_info)44167f9c220SJosef Bacik void btrfs_release_global_block_rsv(struct btrfs_fs_info *fs_info)
44267f9c220SJosef Bacik {
44363f018beSNikolay Borisov btrfs_block_rsv_release(fs_info, &fs_info->global_block_rsv, (u64)-1,
44463f018beSNikolay Borisov NULL);
44567f9c220SJosef Bacik WARN_ON(fs_info->trans_block_rsv.size > 0);
44667f9c220SJosef Bacik WARN_ON(fs_info->trans_block_rsv.reserved > 0);
44767f9c220SJosef Bacik WARN_ON(fs_info->chunk_block_rsv.size > 0);
44867f9c220SJosef Bacik WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
44967f9c220SJosef Bacik WARN_ON(fs_info->delayed_block_rsv.size > 0);
45067f9c220SJosef Bacik WARN_ON(fs_info->delayed_block_rsv.reserved > 0);
45167f9c220SJosef Bacik WARN_ON(fs_info->delayed_refs_rsv.reserved > 0);
45267f9c220SJosef Bacik WARN_ON(fs_info->delayed_refs_rsv.size > 0);
45367f9c220SJosef Bacik }
45467f9c220SJosef Bacik
get_block_rsv(const struct btrfs_trans_handle * trans,const struct btrfs_root * root)45567f9c220SJosef Bacik static struct btrfs_block_rsv *get_block_rsv(
45667f9c220SJosef Bacik const struct btrfs_trans_handle *trans,
45767f9c220SJosef Bacik const struct btrfs_root *root)
45867f9c220SJosef Bacik {
45967f9c220SJosef Bacik struct btrfs_fs_info *fs_info = root->fs_info;
46067f9c220SJosef Bacik struct btrfs_block_rsv *block_rsv = NULL;
46167f9c220SJosef Bacik
46292a7cc42SQu Wenruo if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||
463fc28b25eSJosef Bacik (root == fs_info->uuid_root) ||
464fc28b25eSJosef Bacik (trans->adding_csums &&
465fc28b25eSJosef Bacik root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID))
46667f9c220SJosef Bacik block_rsv = trans->block_rsv;
46767f9c220SJosef Bacik
46867f9c220SJosef Bacik if (!block_rsv)
46967f9c220SJosef Bacik block_rsv = root->block_rsv;
47067f9c220SJosef Bacik
47167f9c220SJosef Bacik if (!block_rsv)
47267f9c220SJosef Bacik block_rsv = &fs_info->empty_block_rsv;
47367f9c220SJosef Bacik
47467f9c220SJosef Bacik return block_rsv;
47567f9c220SJosef Bacik }
47667f9c220SJosef Bacik
btrfs_use_block_rsv(struct btrfs_trans_handle * trans,struct btrfs_root * root,u32 blocksize)47767f9c220SJosef Bacik struct btrfs_block_rsv *btrfs_use_block_rsv(struct btrfs_trans_handle *trans,
47867f9c220SJosef Bacik struct btrfs_root *root,
47967f9c220SJosef Bacik u32 blocksize)
48067f9c220SJosef Bacik {
48167f9c220SJosef Bacik struct btrfs_fs_info *fs_info = root->fs_info;
48267f9c220SJosef Bacik struct btrfs_block_rsv *block_rsv;
48367f9c220SJosef Bacik struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
48467f9c220SJosef Bacik int ret;
48567f9c220SJosef Bacik bool global_updated = false;
48667f9c220SJosef Bacik
48767f9c220SJosef Bacik block_rsv = get_block_rsv(trans, root);
48867f9c220SJosef Bacik
489*f6d4d29aSFilipe Manana if (unlikely(btrfs_block_rsv_size(block_rsv) == 0))
49067f9c220SJosef Bacik goto try_reserve;
49167f9c220SJosef Bacik again:
49267f9c220SJosef Bacik ret = btrfs_block_rsv_use_bytes(block_rsv, blocksize);
49367f9c220SJosef Bacik if (!ret)
49467f9c220SJosef Bacik return block_rsv;
49567f9c220SJosef Bacik
49667f9c220SJosef Bacik if (block_rsv->failfast)
49767f9c220SJosef Bacik return ERR_PTR(ret);
49867f9c220SJosef Bacik
49967f9c220SJosef Bacik if (block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL && !global_updated) {
50067f9c220SJosef Bacik global_updated = true;
50167f9c220SJosef Bacik btrfs_update_global_block_rsv(fs_info);
50267f9c220SJosef Bacik goto again;
50367f9c220SJosef Bacik }
50467f9c220SJosef Bacik
50567f9c220SJosef Bacik /*
50667f9c220SJosef Bacik * The global reserve still exists to save us from ourselves, so don't
50767f9c220SJosef Bacik * warn_on if we are short on our delayed refs reserve.
50867f9c220SJosef Bacik */
50967f9c220SJosef Bacik if (block_rsv->type != BTRFS_BLOCK_RSV_DELREFS &&
51067f9c220SJosef Bacik btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
51167f9c220SJosef Bacik static DEFINE_RATELIMIT_STATE(_rs,
51267f9c220SJosef Bacik DEFAULT_RATELIMIT_INTERVAL * 10,
51367f9c220SJosef Bacik /*DEFAULT_RATELIMIT_BURST*/ 1);
51467f9c220SJosef Bacik if (__ratelimit(&_rs))
51567f9c220SJosef Bacik WARN(1, KERN_DEBUG
516e38fdb71SJosef Bacik "BTRFS: block rsv %d returned %d\n",
517e38fdb71SJosef Bacik block_rsv->type, ret);
51867f9c220SJosef Bacik }
51967f9c220SJosef Bacik try_reserve:
5209270501cSJosef Bacik ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, blocksize,
52167f9c220SJosef Bacik BTRFS_RESERVE_NO_FLUSH);
52267f9c220SJosef Bacik if (!ret)
52367f9c220SJosef Bacik return block_rsv;
52467f9c220SJosef Bacik /*
52567f9c220SJosef Bacik * If we couldn't reserve metadata bytes try and use some from
52667f9c220SJosef Bacik * the global reserve if its space type is the same as the global
52767f9c220SJosef Bacik * reservation.
52867f9c220SJosef Bacik */
52967f9c220SJosef Bacik if (block_rsv->type != BTRFS_BLOCK_RSV_GLOBAL &&
53067f9c220SJosef Bacik block_rsv->space_info == global_rsv->space_info) {
53167f9c220SJosef Bacik ret = btrfs_block_rsv_use_bytes(global_rsv, blocksize);
53267f9c220SJosef Bacik if (!ret)
53367f9c220SJosef Bacik return global_rsv;
53467f9c220SJosef Bacik }
535765c3fe9SJosef Bacik
536765c3fe9SJosef Bacik /*
537765c3fe9SJosef Bacik * All hope is lost, but of course our reservations are overly
538765c3fe9SJosef Bacik * pessimistic, so instead of possibly having an ENOSPC abort here, try
539765c3fe9SJosef Bacik * one last time to force a reservation if there's enough actual space
540765c3fe9SJosef Bacik * on disk to make the reservation.
541765c3fe9SJosef Bacik */
542765c3fe9SJosef Bacik ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, blocksize,
543765c3fe9SJosef Bacik BTRFS_RESERVE_FLUSH_EMERGENCY);
544765c3fe9SJosef Bacik if (!ret)
545765c3fe9SJosef Bacik return block_rsv;
546765c3fe9SJosef Bacik
54767f9c220SJosef Bacik return ERR_PTR(ret);
54867f9c220SJosef Bacik }
54954d687c1SJosef Bacik
btrfs_check_trunc_cache_free_space(struct btrfs_fs_info * fs_info,struct btrfs_block_rsv * rsv)55054d687c1SJosef Bacik int btrfs_check_trunc_cache_free_space(struct btrfs_fs_info *fs_info,
55154d687c1SJosef Bacik struct btrfs_block_rsv *rsv)
55254d687c1SJosef Bacik {
55354d687c1SJosef Bacik u64 needed_bytes;
55454d687c1SJosef Bacik int ret;
55554d687c1SJosef Bacik
55654d687c1SJosef Bacik /* 1 for slack space, 1 for updating the inode */
55754d687c1SJosef Bacik needed_bytes = btrfs_calc_insert_metadata_size(fs_info, 1) +
55854d687c1SJosef Bacik btrfs_calc_metadata_size(fs_info, 1);
55954d687c1SJosef Bacik
56054d687c1SJosef Bacik spin_lock(&rsv->lock);
56154d687c1SJosef Bacik if (rsv->reserved < needed_bytes)
56254d687c1SJosef Bacik ret = -ENOSPC;
56354d687c1SJosef Bacik else
56454d687c1SJosef Bacik ret = 0;
56554d687c1SJosef Bacik spin_unlock(&rsv->lock);
56654d687c1SJosef Bacik return ret;
56754d687c1SJosef Bacik }
568