Linux Audio

Check our new training course

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