1 // SPDX-License-Identifier: GPL-2.0
2
3 #include "ctree.h"
4 #include "delalloc-space.h"
5 #include "block-rsv.h"
6 #include "btrfs_inode.h"
7 #include "space-info.h"
8 #include "transaction.h"
9 #include "qgroup.h"
10 #include "block-group.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 (currrent 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
btrfs_alloc_data_chunk_ondemand(struct btrfs_inode * inode,u64 bytes)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
btrfs_check_data_free_space(struct btrfs_inode * inode,struct extent_changeset ** reserved,u64 start,u64 len)129 int btrfs_check_data_free_space(struct btrfs_inode *inode,
130 struct extent_changeset **reserved, u64 start, u64 len)
131 {
132 struct btrfs_fs_info *fs_info = inode->root->fs_info;
133 int ret;
134
135 /* align the range */
136 len = round_up(start + len, fs_info->sectorsize) -
137 round_down(start, fs_info->sectorsize);
138 start = round_down(start, fs_info->sectorsize);
139
140 ret = btrfs_alloc_data_chunk_ondemand(inode, len);
141 if (ret < 0)
142 return ret;
143
144 /* Use new btrfs_qgroup_reserve_data to reserve precious data space. */
145 ret = btrfs_qgroup_reserve_data(inode, reserved, start, len);
146 if (ret < 0)
147 btrfs_free_reserved_data_space_noquota(fs_info, len);
148 else
149 ret = 0;
150 return ret;
151 }
152
153 /*
154 * Called if we need to clear a data reservation for this inode
155 * Normally in a error case.
156 *
157 * This one will *NOT* use accurate qgroup reserved space API, just for case
158 * which we can't sleep and is sure it won't affect qgroup reserved space.
159 * Like clear_bit_hook().
160 */
btrfs_free_reserved_data_space_noquota(struct btrfs_fs_info * fs_info,u64 len)161 void btrfs_free_reserved_data_space_noquota(struct btrfs_fs_info *fs_info,
162 u64 len)
163 {
164 struct btrfs_space_info *data_sinfo;
165
166 ASSERT(IS_ALIGNED(len, fs_info->sectorsize));
167
168 data_sinfo = fs_info->data_sinfo;
169 btrfs_space_info_free_bytes_may_use(fs_info, data_sinfo, len);
170 }
171
172 /*
173 * Called if we need to clear a data reservation for this inode
174 * Normally in a error case.
175 *
176 * This one will handle the per-inode data rsv map for accurate reserved
177 * space framework.
178 */
btrfs_free_reserved_data_space(struct btrfs_inode * inode,struct extent_changeset * reserved,u64 start,u64 len)179 void btrfs_free_reserved_data_space(struct btrfs_inode *inode,
180 struct extent_changeset *reserved, u64 start, u64 len)
181 {
182 struct btrfs_fs_info *fs_info = inode->root->fs_info;
183
184 /* Make sure the range is aligned to sectorsize */
185 len = round_up(start + len, fs_info->sectorsize) -
186 round_down(start, fs_info->sectorsize);
187 start = round_down(start, fs_info->sectorsize);
188
189 btrfs_free_reserved_data_space_noquota(fs_info, len);
190 btrfs_qgroup_free_data(inode, reserved, start, len);
191 }
192
193 /**
194 * btrfs_inode_rsv_release - release any excessive reservation.
195 * @inode - the inode we need to release from.
196 * @qgroup_free - free or convert qgroup meta.
197 * Unlike normal operation, qgroup meta reservation needs to know if we are
198 * freeing qgroup reservation or just converting it into per-trans. Normally
199 * @qgroup_free is true for error handling, and false for normal release.
200 *
201 * This is the same as btrfs_block_rsv_release, except that it handles the
202 * tracepoint for the reservation.
203 */
btrfs_inode_rsv_release(struct btrfs_inode * inode,bool qgroup_free)204 static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free)
205 {
206 struct btrfs_fs_info *fs_info = inode->root->fs_info;
207 struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
208 u64 released = 0;
209 u64 qgroup_to_release = 0;
210
211 /*
212 * Since we statically set the block_rsv->size we just want to say we
213 * are releasing 0 bytes, and then we'll just get the reservation over
214 * the size free'd.
215 */
216 released = btrfs_block_rsv_release(fs_info, block_rsv, 0,
217 &qgroup_to_release);
218 if (released > 0)
219 trace_btrfs_space_reservation(fs_info, "delalloc",
220 btrfs_ino(inode), released, 0);
221 if (qgroup_free)
222 btrfs_qgroup_free_meta_prealloc(inode->root, qgroup_to_release);
223 else
224 btrfs_qgroup_convert_reserved_meta(inode->root,
225 qgroup_to_release);
226 }
227
btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info * fs_info,struct btrfs_inode * inode)228 static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info,
229 struct btrfs_inode *inode)
230 {
231 struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
232 u64 reserve_size = 0;
233 u64 qgroup_rsv_size = 0;
234 u64 csum_leaves;
235 unsigned outstanding_extents;
236
237 lockdep_assert_held(&inode->lock);
238 outstanding_extents = inode->outstanding_extents;
239
240 /*
241 * Insert size for the number of outstanding extents, 1 normal size for
242 * updating the inode.
243 */
244 if (outstanding_extents) {
245 reserve_size = btrfs_calc_insert_metadata_size(fs_info,
246 outstanding_extents);
247 reserve_size += btrfs_calc_metadata_size(fs_info, 1);
248 }
249 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info,
250 inode->csum_bytes);
251 reserve_size += btrfs_calc_insert_metadata_size(fs_info,
252 csum_leaves);
253 /*
254 * For qgroup rsv, the calculation is very simple:
255 * account one nodesize for each outstanding extent
256 *
257 * This is overestimating in most cases.
258 */
259 qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize;
260
261 spin_lock(&block_rsv->lock);
262 block_rsv->size = reserve_size;
263 block_rsv->qgroup_rsv_size = qgroup_rsv_size;
264 spin_unlock(&block_rsv->lock);
265 }
266
calc_inode_reservations(struct btrfs_fs_info * fs_info,u64 num_bytes,u64 * meta_reserve,u64 * qgroup_reserve)267 static void calc_inode_reservations(struct btrfs_fs_info *fs_info,
268 u64 num_bytes, u64 *meta_reserve,
269 u64 *qgroup_reserve)
270 {
271 u64 nr_extents = count_max_extents(num_bytes);
272 u64 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, num_bytes);
273 u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);
274
275 *meta_reserve = btrfs_calc_insert_metadata_size(fs_info,
276 nr_extents + csum_leaves);
277
278 /*
279 * finish_ordered_io has to update the inode, so add the space required
280 * for an inode update.
281 */
282 *meta_reserve += inode_update;
283 *qgroup_reserve = nr_extents * fs_info->nodesize;
284 }
285
btrfs_delalloc_reserve_metadata(struct btrfs_inode * inode,u64 num_bytes)286 int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
287 {
288 struct btrfs_root *root = inode->root;
289 struct btrfs_fs_info *fs_info = root->fs_info;
290 struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
291 u64 meta_reserve, qgroup_reserve;
292 unsigned nr_extents;
293 enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL;
294 int ret = 0;
295
296 /*
297 * If we are a free space inode we need to not flush since we will be in
298 * the middle of a transaction commit. We also don't need the delalloc
299 * mutex since we won't race with anybody. We need this mostly to make
300 * lockdep shut its filthy mouth.
301 *
302 * If we have a transaction open (can happen if we call truncate_block
303 * from truncate), then we need FLUSH_LIMIT so we don't deadlock.
304 */
305 if (btrfs_is_free_space_inode(inode)) {
306 flush = BTRFS_RESERVE_NO_FLUSH;
307 } else {
308 if (current->journal_info)
309 flush = BTRFS_RESERVE_FLUSH_LIMIT;
310
311 if (btrfs_transaction_in_commit(fs_info))
312 schedule_timeout(1);
313 }
314
315 num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
316
317 /*
318 * We always want to do it this way, every other way is wrong and ends
319 * in tears. Pre-reserving the amount we are going to add will always
320 * be the right way, because otherwise if we have enough parallelism we
321 * could end up with thousands of inodes all holding little bits of
322 * reservations they were able to make previously and the only way to
323 * reclaim that space is to ENOSPC out the operations and clear
324 * everything out and try again, which is bad. This way we just
325 * over-reserve slightly, and clean up the mess when we are done.
326 */
327 calc_inode_reservations(fs_info, num_bytes, &meta_reserve,
328 &qgroup_reserve);
329 ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true);
330 if (ret)
331 return ret;
332 ret = btrfs_reserve_metadata_bytes(root, block_rsv, meta_reserve, flush);
333 if (ret) {
334 btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve);
335 return ret;
336 }
337
338 /*
339 * Now we need to update our outstanding extents and csum bytes _first_
340 * and then add the reservation to the block_rsv. This keeps us from
341 * racing with an ordered completion or some such that would think it
342 * needs to free the reservation we just made.
343 */
344 spin_lock(&inode->lock);
345 nr_extents = count_max_extents(num_bytes);
346 btrfs_mod_outstanding_extents(inode, nr_extents);
347 inode->csum_bytes += num_bytes;
348 btrfs_calculate_inode_block_rsv_size(fs_info, inode);
349 spin_unlock(&inode->lock);
350
351 /* Now we can safely add our space to our block rsv */
352 btrfs_block_rsv_add_bytes(block_rsv, meta_reserve, false);
353 trace_btrfs_space_reservation(root->fs_info, "delalloc",
354 btrfs_ino(inode), meta_reserve, 1);
355
356 spin_lock(&block_rsv->lock);
357 block_rsv->qgroup_rsv_reserved += qgroup_reserve;
358 spin_unlock(&block_rsv->lock);
359
360 return 0;
361 }
362
363 /**
364 * btrfs_delalloc_release_metadata - release a metadata reservation for an inode
365 * @inode: the inode to release the reservation for.
366 * @num_bytes: the number of bytes we are releasing.
367 * @qgroup_free: free qgroup reservation or convert it to per-trans reservation
368 *
369 * This will release the metadata reservation for an inode. This can be called
370 * once we complete IO for a given set of bytes to release their metadata
371 * reservations, or on error for the same reason.
372 */
btrfs_delalloc_release_metadata(struct btrfs_inode * inode,u64 num_bytes,bool qgroup_free)373 void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes,
374 bool qgroup_free)
375 {
376 struct btrfs_fs_info *fs_info = inode->root->fs_info;
377
378 num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
379 spin_lock(&inode->lock);
380 inode->csum_bytes -= num_bytes;
381 btrfs_calculate_inode_block_rsv_size(fs_info, inode);
382 spin_unlock(&inode->lock);
383
384 if (btrfs_is_testing(fs_info))
385 return;
386
387 btrfs_inode_rsv_release(inode, qgroup_free);
388 }
389
390 /**
391 * btrfs_delalloc_release_extents - release our outstanding_extents
392 * @inode: the inode to balance the reservation for.
393 * @num_bytes: the number of bytes we originally reserved with
394 *
395 * When we reserve space we increase outstanding_extents for the extents we may
396 * add. Once we've set the range as delalloc or created our ordered extents we
397 * have outstanding_extents to track the real usage, so we use this to free our
398 * temporarily tracked outstanding_extents. This _must_ be used in conjunction
399 * with btrfs_delalloc_reserve_metadata.
400 */
btrfs_delalloc_release_extents(struct btrfs_inode * inode,u64 num_bytes)401 void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes)
402 {
403 struct btrfs_fs_info *fs_info = inode->root->fs_info;
404 unsigned num_extents;
405
406 spin_lock(&inode->lock);
407 num_extents = count_max_extents(num_bytes);
408 btrfs_mod_outstanding_extents(inode, -num_extents);
409 btrfs_calculate_inode_block_rsv_size(fs_info, inode);
410 spin_unlock(&inode->lock);
411
412 if (btrfs_is_testing(fs_info))
413 return;
414
415 btrfs_inode_rsv_release(inode, true);
416 }
417
418 /**
419 * btrfs_delalloc_reserve_space - reserve data and metadata space for
420 * delalloc
421 * @inode: inode we're writing to
422 * @start: start range we are writing to
423 * @len: how long the range we are writing to
424 * @reserved: mandatory parameter, record actually reserved qgroup ranges of
425 * current reservation.
426 *
427 * This will do the following things
428 *
429 * - reserve space in data space info for num bytes
430 * and reserve precious corresponding qgroup space
431 * (Done in check_data_free_space)
432 *
433 * - reserve space for metadata space, based on the number of outstanding
434 * extents and how much csums will be needed
435 * also reserve metadata space in a per root over-reserve method.
436 * - add to the inodes->delalloc_bytes
437 * - add it to the fs_info's delalloc inodes list.
438 * (Above 3 all done in delalloc_reserve_metadata)
439 *
440 * Return 0 for success
441 * Return <0 for error(-ENOSPC or -EQUOT)
442 */
btrfs_delalloc_reserve_space(struct btrfs_inode * inode,struct extent_changeset ** reserved,u64 start,u64 len)443 int btrfs_delalloc_reserve_space(struct btrfs_inode *inode,
444 struct extent_changeset **reserved, u64 start, u64 len)
445 {
446 int ret;
447
448 ret = btrfs_check_data_free_space(inode, reserved, start, len);
449 if (ret < 0)
450 return ret;
451 ret = btrfs_delalloc_reserve_metadata(inode, len);
452 if (ret < 0)
453 btrfs_free_reserved_data_space(inode, *reserved, start, len);
454 return ret;
455 }
456
457 /**
458 * btrfs_delalloc_release_space - release data and metadata space for delalloc
459 * @inode: inode we're releasing space for
460 * @start: start position of the space already reserved
461 * @len: the len of the space already reserved
462 * @release_bytes: the len of the space we consumed or didn't use
463 *
464 * This function will release the metadata space that was not used and will
465 * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes
466 * list if there are no delalloc bytes left.
467 * Also it will handle the qgroup reserved space.
468 */
btrfs_delalloc_release_space(struct btrfs_inode * inode,struct extent_changeset * reserved,u64 start,u64 len,bool qgroup_free)469 void btrfs_delalloc_release_space(struct btrfs_inode *inode,
470 struct extent_changeset *reserved,
471 u64 start, u64 len, bool qgroup_free)
472 {
473 btrfs_delalloc_release_metadata(inode, len, qgroup_free);
474 btrfs_free_reserved_data_space(inode, reserved, start, len);
475 }
476