1 | // SPDX-License-Identifier: GPL-2.0 |
2 | |
3 | #include "messages.h" |
4 | #include "ctree.h" |
5 | #include "delalloc-space.h" |
6 | #include "block-rsv.h" |
7 | #include "btrfs_inode.h" |
8 | #include "space-info.h" |
9 | #include "qgroup.h" |
10 | #include "fs.h" |
11 | |
12 | /* |
13 | * HOW DOES THIS WORK |
14 | * |
15 | * There are two stages to data reservations, one for data and one for metadata |
16 | * to handle the new extents and checksums generated by writing data. |
17 | * |
18 | * |
19 | * DATA RESERVATION |
20 | * The general flow of the data reservation is as follows |
21 | * |
22 | * -> Reserve |
23 | * We call into btrfs_reserve_data_bytes() for the user request bytes that |
24 | * they wish to write. We make this reservation and add it to |
25 | * space_info->bytes_may_use. We set EXTENT_DELALLOC on the inode io_tree |
26 | * for the range and carry on if this is buffered, or follow up trying to |
27 | * make a real allocation if we are pre-allocating or doing O_DIRECT. |
28 | * |
29 | * -> Use |
30 | * At writepages()/prealloc/O_DIRECT time we will call into |
31 | * btrfs_reserve_extent() for some part or all of this range of bytes. We |
32 | * will make the allocation and subtract space_info->bytes_may_use by the |
33 | * original requested length and increase the space_info->bytes_reserved by |
34 | * the allocated length. This distinction is important because compression |
35 | * may allocate a smaller on disk extent than we previously reserved. |
36 | * |
37 | * -> Allocation |
38 | * finish_ordered_io() will insert the new file extent item for this range, |
39 | * and then add a delayed ref update for the extent tree. Once that delayed |
40 | * ref is written the extent size is subtracted from |
41 | * space_info->bytes_reserved and added to space_info->bytes_used. |
42 | * |
43 | * Error handling |
44 | * |
45 | * -> By the reservation maker |
46 | * This is the simplest case, we haven't completed our operation and we know |
47 | * how much we reserved, we can simply call |
48 | * btrfs_free_reserved_data_space*() and it will be removed from |
49 | * space_info->bytes_may_use. |
50 | * |
51 | * -> After the reservation has been made, but before cow_file_range() |
52 | * This is specifically for the delalloc case. You must clear |
53 | * EXTENT_DELALLOC with the EXTENT_CLEAR_DATA_RESV bit, and the range will |
54 | * be subtracted from space_info->bytes_may_use. |
55 | * |
56 | * METADATA RESERVATION |
57 | * The general metadata reservation lifetimes are discussed elsewhere, this |
58 | * will just focus on how it is used for delalloc space. |
59 | * |
60 | * We keep track of two things on a per inode bases |
61 | * |
62 | * ->outstanding_extents |
63 | * This is the number of file extent items we'll need to handle all of the |
64 | * outstanding DELALLOC space we have in this inode. We limit the maximum |
65 | * size of an extent, so a large contiguous dirty area may require more than |
66 | * one outstanding_extent, which is why count_max_extents() is used to |
67 | * determine how many outstanding_extents get added. |
68 | * |
69 | * ->csum_bytes |
70 | * This is essentially how many dirty bytes we have for this inode, so we |
71 | * can calculate the number of checksum items we would have to add in order |
72 | * to checksum our outstanding data. |
73 | * |
74 | * We keep a per-inode block_rsv in order to make it easier to keep track of |
75 | * our reservation. We use btrfs_calculate_inode_block_rsv_size() to |
76 | * calculate the current theoretical maximum reservation we would need for the |
77 | * metadata for this inode. We call this and then adjust our reservation as |
78 | * necessary, either by attempting to reserve more space, or freeing up excess |
79 | * space. |
80 | * |
81 | * OUTSTANDING_EXTENTS HANDLING |
82 | * |
83 | * ->outstanding_extents is used for keeping track of how many extents we will |
84 | * need to use for this inode, and it will fluctuate depending on where you are |
85 | * in the life cycle of the dirty data. Consider the following normal case for |
86 | * a completely clean inode, with a num_bytes < our maximum allowed extent size |
87 | * |
88 | * -> reserve |
89 | * ->outstanding_extents += 1 (current value is 1) |
90 | * |
91 | * -> set_delalloc |
92 | * ->outstanding_extents += 1 (current value is 2) |
93 | * |
94 | * -> btrfs_delalloc_release_extents() |
95 | * ->outstanding_extents -= 1 (current value is 1) |
96 | * |
97 | * We must call this once we are done, as we hold our reservation for the |
98 | * duration of our operation, and then assume set_delalloc will update the |
99 | * counter appropriately. |
100 | * |
101 | * -> add ordered extent |
102 | * ->outstanding_extents += 1 (current value is 2) |
103 | * |
104 | * -> btrfs_clear_delalloc_extent |
105 | * ->outstanding_extents -= 1 (current value is 1) |
106 | * |
107 | * -> finish_ordered_io/btrfs_remove_ordered_extent |
108 | * ->outstanding_extents -= 1 (current value is 0) |
109 | * |
110 | * Each stage is responsible for their own accounting of the extent, thus |
111 | * making error handling and cleanup easier. |
112 | */ |
113 | |
114 | int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes) |
115 | { |
116 | struct btrfs_root *root = inode->root; |
117 | struct btrfs_fs_info *fs_info = root->fs_info; |
118 | enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_DATA; |
119 | |
120 | /* Make sure bytes are sectorsize aligned */ |
121 | bytes = ALIGN(bytes, fs_info->sectorsize); |
122 | |
123 | if (btrfs_is_free_space_inode(inode)) |
124 | flush = BTRFS_RESERVE_FLUSH_FREE_SPACE_INODE; |
125 | |
126 | return btrfs_reserve_data_bytes(fs_info, bytes, flush); |
127 | } |
128 | |
129 | int btrfs_check_data_free_space(struct btrfs_inode *inode, |
130 | struct extent_changeset **reserved, u64 start, |
131 | u64 len, bool noflush) |
132 | { |
133 | struct btrfs_fs_info *fs_info = inode->root->fs_info; |
134 | enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_DATA; |
135 | int ret; |
136 | |
137 | /* align the range */ |
138 | len = round_up(start + len, fs_info->sectorsize) - |
139 | round_down(start, fs_info->sectorsize); |
140 | start = round_down(start, fs_info->sectorsize); |
141 | |
142 | if (noflush) |
143 | flush = BTRFS_RESERVE_NO_FLUSH; |
144 | else if (btrfs_is_free_space_inode(inode)) |
145 | flush = BTRFS_RESERVE_FLUSH_FREE_SPACE_INODE; |
146 | |
147 | ret = btrfs_reserve_data_bytes(fs_info, bytes: len, flush); |
148 | if (ret < 0) |
149 | return ret; |
150 | |
151 | /* Use new btrfs_qgroup_reserve_data to reserve precious data space. */ |
152 | ret = btrfs_qgroup_reserve_data(inode, reserved, start, len); |
153 | if (ret < 0) { |
154 | btrfs_free_reserved_data_space_noquota(fs_info, len); |
155 | extent_changeset_free(changeset: *reserved); |
156 | *reserved = NULL; |
157 | } else { |
158 | ret = 0; |
159 | } |
160 | return ret; |
161 | } |
162 | |
163 | /* |
164 | * Called if we need to clear a data reservation for this inode |
165 | * Normally in a error case. |
166 | * |
167 | * This one will *NOT* use accurate qgroup reserved space API, just for case |
168 | * which we can't sleep and is sure it won't affect qgroup reserved space. |
169 | * Like clear_bit_hook(). |
170 | */ |
171 | void btrfs_free_reserved_data_space_noquota(struct btrfs_fs_info *fs_info, |
172 | u64 len) |
173 | { |
174 | struct btrfs_space_info *data_sinfo; |
175 | |
176 | ASSERT(IS_ALIGNED(len, fs_info->sectorsize)); |
177 | |
178 | data_sinfo = fs_info->data_sinfo; |
179 | btrfs_space_info_free_bytes_may_use(fs_info, space_info: data_sinfo, num_bytes: len); |
180 | } |
181 | |
182 | /* |
183 | * Called if we need to clear a data reservation for this inode |
184 | * Normally in a error case. |
185 | * |
186 | * This one will handle the per-inode data rsv map for accurate reserved |
187 | * space framework. |
188 | */ |
189 | void btrfs_free_reserved_data_space(struct btrfs_inode *inode, |
190 | struct extent_changeset *reserved, u64 start, u64 len) |
191 | { |
192 | struct btrfs_fs_info *fs_info = inode->root->fs_info; |
193 | |
194 | /* Make sure the range is aligned to sectorsize */ |
195 | len = round_up(start + len, fs_info->sectorsize) - |
196 | round_down(start, fs_info->sectorsize); |
197 | start = round_down(start, fs_info->sectorsize); |
198 | |
199 | btrfs_free_reserved_data_space_noquota(fs_info, len); |
200 | btrfs_qgroup_free_data(inode, reserved, start, len, NULL); |
201 | } |
202 | |
203 | /* |
204 | * Release any excessive reservations for an inode. |
205 | * |
206 | * @inode: the inode we need to release from |
207 | * @qgroup_free: free or convert qgroup meta. Unlike normal operation, qgroup |
208 | * meta reservation needs to know if we are freeing qgroup |
209 | * reservation or just converting it into per-trans. Normally |
210 | * @qgroup_free is true for error handling, and false for normal |
211 | * release. |
212 | * |
213 | * This is the same as btrfs_block_rsv_release, except that it handles the |
214 | * tracepoint for the reservation. |
215 | */ |
216 | static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free) |
217 | { |
218 | struct btrfs_fs_info *fs_info = inode->root->fs_info; |
219 | struct btrfs_block_rsv *block_rsv = &inode->block_rsv; |
220 | u64 released = 0; |
221 | u64 qgroup_to_release = 0; |
222 | |
223 | /* |
224 | * Since we statically set the block_rsv->size we just want to say we |
225 | * are releasing 0 bytes, and then we'll just get the reservation over |
226 | * the size free'd. |
227 | */ |
228 | released = btrfs_block_rsv_release(fs_info, block_rsv, num_bytes: 0, |
229 | qgroup_to_release: &qgroup_to_release); |
230 | if (released > 0) |
231 | trace_btrfs_space_reservation(fs_info, type: "delalloc" , |
232 | val: btrfs_ino(inode), bytes: released, reserve: 0); |
233 | if (qgroup_free) |
234 | btrfs_qgroup_free_meta_prealloc(root: inode->root, num_bytes: qgroup_to_release); |
235 | else |
236 | btrfs_qgroup_convert_reserved_meta(root: inode->root, |
237 | num_bytes: qgroup_to_release); |
238 | } |
239 | |
240 | static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info, |
241 | struct btrfs_inode *inode) |
242 | { |
243 | struct btrfs_block_rsv *block_rsv = &inode->block_rsv; |
244 | u64 reserve_size = 0; |
245 | u64 qgroup_rsv_size = 0; |
246 | unsigned outstanding_extents; |
247 | |
248 | lockdep_assert_held(&inode->lock); |
249 | outstanding_extents = inode->outstanding_extents; |
250 | |
251 | /* |
252 | * Insert size for the number of outstanding extents, 1 normal size for |
253 | * updating the inode. |
254 | */ |
255 | if (outstanding_extents) { |
256 | reserve_size = btrfs_calc_insert_metadata_size(fs_info, |
257 | num_items: outstanding_extents); |
258 | reserve_size += btrfs_calc_metadata_size(fs_info, num_items: 1); |
259 | } |
260 | if (!(inode->flags & BTRFS_INODE_NODATASUM)) { |
261 | u64 csum_leaves; |
262 | |
263 | csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, csum_bytes: inode->csum_bytes); |
264 | reserve_size += btrfs_calc_insert_metadata_size(fs_info, num_items: csum_leaves); |
265 | } |
266 | /* |
267 | * For qgroup rsv, the calculation is very simple: |
268 | * account one nodesize for each outstanding extent |
269 | * |
270 | * This is overestimating in most cases. |
271 | */ |
272 | qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize; |
273 | |
274 | spin_lock(lock: &block_rsv->lock); |
275 | block_rsv->size = reserve_size; |
276 | block_rsv->qgroup_rsv_size = qgroup_rsv_size; |
277 | spin_unlock(lock: &block_rsv->lock); |
278 | } |
279 | |
280 | static void calc_inode_reservations(struct btrfs_inode *inode, |
281 | u64 num_bytes, u64 disk_num_bytes, |
282 | u64 *meta_reserve, u64 *qgroup_reserve) |
283 | { |
284 | struct btrfs_fs_info *fs_info = inode->root->fs_info; |
285 | u64 nr_extents = count_max_extents(fs_info, size: num_bytes); |
286 | u64 csum_leaves; |
287 | u64 inode_update = btrfs_calc_metadata_size(fs_info, num_items: 1); |
288 | |
289 | if (inode->flags & BTRFS_INODE_NODATASUM) |
290 | csum_leaves = 0; |
291 | else |
292 | csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, csum_bytes: disk_num_bytes); |
293 | |
294 | *meta_reserve = btrfs_calc_insert_metadata_size(fs_info, |
295 | num_items: nr_extents + csum_leaves); |
296 | |
297 | /* |
298 | * finish_ordered_io has to update the inode, so add the space required |
299 | * for an inode update. |
300 | */ |
301 | *meta_reserve += inode_update; |
302 | *qgroup_reserve = nr_extents * fs_info->nodesize; |
303 | } |
304 | |
305 | int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes, |
306 | u64 disk_num_bytes, bool noflush) |
307 | { |
308 | struct btrfs_root *root = inode->root; |
309 | struct btrfs_fs_info *fs_info = root->fs_info; |
310 | struct btrfs_block_rsv *block_rsv = &inode->block_rsv; |
311 | u64 meta_reserve, qgroup_reserve; |
312 | unsigned nr_extents; |
313 | enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL; |
314 | int ret = 0; |
315 | |
316 | /* |
317 | * If we are a free space inode we need to not flush since we will be in |
318 | * the middle of a transaction commit. We also don't need the delalloc |
319 | * mutex since we won't race with anybody. We need this mostly to make |
320 | * lockdep shut its filthy mouth. |
321 | * |
322 | * If we have a transaction open (can happen if we call truncate_block |
323 | * from truncate), then we need FLUSH_LIMIT so we don't deadlock. |
324 | */ |
325 | if (noflush || btrfs_is_free_space_inode(inode)) { |
326 | flush = BTRFS_RESERVE_NO_FLUSH; |
327 | } else { |
328 | if (current->journal_info) |
329 | flush = BTRFS_RESERVE_FLUSH_LIMIT; |
330 | } |
331 | |
332 | num_bytes = ALIGN(num_bytes, fs_info->sectorsize); |
333 | disk_num_bytes = ALIGN(disk_num_bytes, fs_info->sectorsize); |
334 | |
335 | /* |
336 | * We always want to do it this way, every other way is wrong and ends |
337 | * in tears. Pre-reserving the amount we are going to add will always |
338 | * be the right way, because otherwise if we have enough parallelism we |
339 | * could end up with thousands of inodes all holding little bits of |
340 | * reservations they were able to make previously and the only way to |
341 | * reclaim that space is to ENOSPC out the operations and clear |
342 | * everything out and try again, which is bad. This way we just |
343 | * over-reserve slightly, and clean up the mess when we are done. |
344 | */ |
345 | calc_inode_reservations(inode, num_bytes, disk_num_bytes, |
346 | meta_reserve: &meta_reserve, qgroup_reserve: &qgroup_reserve); |
347 | ret = btrfs_qgroup_reserve_meta_prealloc(root, num_bytes: qgroup_reserve, enforce: true, |
348 | noflush); |
349 | if (ret) |
350 | return ret; |
351 | ret = btrfs_reserve_metadata_bytes(fs_info, space_info: block_rsv->space_info, |
352 | orig_bytes: meta_reserve, flush); |
353 | if (ret) { |
354 | btrfs_qgroup_free_meta_prealloc(root, num_bytes: qgroup_reserve); |
355 | return ret; |
356 | } |
357 | |
358 | /* |
359 | * Now we need to update our outstanding extents and csum bytes _first_ |
360 | * and then add the reservation to the block_rsv. This keeps us from |
361 | * racing with an ordered completion or some such that would think it |
362 | * needs to free the reservation we just made. |
363 | */ |
364 | nr_extents = count_max_extents(fs_info, size: num_bytes); |
365 | spin_lock(lock: &inode->lock); |
366 | btrfs_mod_outstanding_extents(inode, mod: nr_extents); |
367 | if (!(inode->flags & BTRFS_INODE_NODATASUM)) |
368 | inode->csum_bytes += disk_num_bytes; |
369 | btrfs_calculate_inode_block_rsv_size(fs_info, inode); |
370 | spin_unlock(lock: &inode->lock); |
371 | |
372 | /* Now we can safely add our space to our block rsv */ |
373 | btrfs_block_rsv_add_bytes(block_rsv, num_bytes: meta_reserve, update_size: false); |
374 | trace_btrfs_space_reservation(fs_info: root->fs_info, type: "delalloc" , |
375 | val: btrfs_ino(inode), bytes: meta_reserve, reserve: 1); |
376 | |
377 | spin_lock(lock: &block_rsv->lock); |
378 | block_rsv->qgroup_rsv_reserved += qgroup_reserve; |
379 | spin_unlock(lock: &block_rsv->lock); |
380 | |
381 | return 0; |
382 | } |
383 | |
384 | /* |
385 | * Release a metadata reservation for an inode. |
386 | * |
387 | * @inode: the inode to release the reservation for. |
388 | * @num_bytes: the number of bytes we are releasing. |
389 | * @qgroup_free: free qgroup reservation or convert it to per-trans reservation |
390 | * |
391 | * This will release the metadata reservation for an inode. This can be called |
392 | * once we complete IO for a given set of bytes to release their metadata |
393 | * reservations, or on error for the same reason. |
394 | */ |
395 | void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes, |
396 | bool qgroup_free) |
397 | { |
398 | struct btrfs_fs_info *fs_info = inode->root->fs_info; |
399 | |
400 | num_bytes = ALIGN(num_bytes, fs_info->sectorsize); |
401 | spin_lock(lock: &inode->lock); |
402 | if (!(inode->flags & BTRFS_INODE_NODATASUM)) |
403 | inode->csum_bytes -= num_bytes; |
404 | btrfs_calculate_inode_block_rsv_size(fs_info, inode); |
405 | spin_unlock(lock: &inode->lock); |
406 | |
407 | if (btrfs_is_testing(fs_info)) |
408 | return; |
409 | |
410 | btrfs_inode_rsv_release(inode, qgroup_free); |
411 | } |
412 | |
413 | /* |
414 | * Release our outstanding_extents for an inode. |
415 | * |
416 | * @inode: the inode to balance the reservation for. |
417 | * @num_bytes: the number of bytes we originally reserved with |
418 | * |
419 | * When we reserve space we increase outstanding_extents for the extents we may |
420 | * add. Once we've set the range as delalloc or created our ordered extents we |
421 | * have outstanding_extents to track the real usage, so we use this to free our |
422 | * temporarily tracked outstanding_extents. This _must_ be used in conjunction |
423 | * with btrfs_delalloc_reserve_metadata. |
424 | */ |
425 | void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes) |
426 | { |
427 | struct btrfs_fs_info *fs_info = inode->root->fs_info; |
428 | unsigned num_extents; |
429 | |
430 | spin_lock(lock: &inode->lock); |
431 | num_extents = count_max_extents(fs_info, size: num_bytes); |
432 | btrfs_mod_outstanding_extents(inode, mod: -num_extents); |
433 | btrfs_calculate_inode_block_rsv_size(fs_info, inode); |
434 | spin_unlock(lock: &inode->lock); |
435 | |
436 | if (btrfs_is_testing(fs_info)) |
437 | return; |
438 | |
439 | btrfs_inode_rsv_release(inode, qgroup_free: true); |
440 | } |
441 | |
442 | /* |
443 | * Reserve data and metadata space for delalloc |
444 | * |
445 | * @inode: inode we're writing to |
446 | * @start: start range we are writing to |
447 | * @len: how long the range we are writing to |
448 | * @reserved: mandatory parameter, record actually reserved qgroup ranges of |
449 | * current reservation. |
450 | * |
451 | * This will do the following things |
452 | * |
453 | * - reserve space in data space info for num bytes and reserve precious |
454 | * corresponding qgroup space |
455 | * (Done in check_data_free_space) |
456 | * |
457 | * - reserve space for metadata space, based on the number of outstanding |
458 | * extents and how much csums will be needed also reserve metadata space in a |
459 | * per root over-reserve method. |
460 | * - add to the inodes->delalloc_bytes |
461 | * - add it to the fs_info's delalloc inodes list. |
462 | * (Above 3 all done in delalloc_reserve_metadata) |
463 | * |
464 | * Return 0 for success |
465 | * Return <0 for error(-ENOSPC or -EDQUOT) |
466 | */ |
467 | int btrfs_delalloc_reserve_space(struct btrfs_inode *inode, |
468 | struct extent_changeset **reserved, u64 start, u64 len) |
469 | { |
470 | int ret; |
471 | |
472 | ret = btrfs_check_data_free_space(inode, reserved, start, len, noflush: false); |
473 | if (ret < 0) |
474 | return ret; |
475 | ret = btrfs_delalloc_reserve_metadata(inode, num_bytes: len, disk_num_bytes: len, noflush: false); |
476 | if (ret < 0) { |
477 | btrfs_free_reserved_data_space(inode, reserved: *reserved, start, len); |
478 | extent_changeset_free(changeset: *reserved); |
479 | *reserved = NULL; |
480 | } |
481 | return ret; |
482 | } |
483 | |
484 | /* |
485 | * Release data and metadata space for delalloc |
486 | * |
487 | * @inode: inode we're releasing space for |
488 | * @reserved: list of changed/reserved ranges |
489 | * @start: start position of the space already reserved |
490 | * @len: length of the space already reserved |
491 | * @qgroup_free: should qgroup reserved-space also be freed |
492 | * |
493 | * Release the metadata space that was not used and will decrement |
494 | * ->delalloc_bytes and remove it from the fs_info->delalloc_inodes list if |
495 | * there are no delalloc bytes left. Also it will handle the qgroup reserved |
496 | * space. |
497 | */ |
498 | void btrfs_delalloc_release_space(struct btrfs_inode *inode, |
499 | struct extent_changeset *reserved, |
500 | u64 start, u64 len, bool qgroup_free) |
501 | { |
502 | btrfs_delalloc_release_metadata(inode, num_bytes: len, qgroup_free); |
503 | btrfs_free_reserved_data_space(inode, reserved, start, len); |
504 | } |
505 | |