delalloc-space.c

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