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 (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 
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,bool noflush)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, 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(*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  */
btrfs_free_reserved_data_space_noquota(struct btrfs_fs_info * fs_info,u64 len)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, data_sinfo, 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  */
btrfs_free_reserved_data_space(struct btrfs_inode * inode,struct extent_changeset * reserved,u64 start,u64 len)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);
201 }
202 
203 /**
204  * Release any excessive reservation
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  */
btrfs_inode_rsv_release(struct btrfs_inode * inode,bool qgroup_free)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, 0,
229 					   &qgroup_to_release);
230 	if (released > 0)
231 		trace_btrfs_space_reservation(fs_info, "delalloc",
232 					      btrfs_ino(inode), released, 0);
233 	if (qgroup_free)
234 		btrfs_qgroup_free_meta_prealloc(inode->root, qgroup_to_release);
235 	else
236 		btrfs_qgroup_convert_reserved_meta(inode->root,
237 						   qgroup_to_release);
238 }
239 
btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info * fs_info,struct btrfs_inode * inode)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 	u64 csum_leaves;
247 	unsigned outstanding_extents;
248 
249 	lockdep_assert_held(&inode->lock);
250 	outstanding_extents = inode->outstanding_extents;
251 
252 	/*
253 	 * Insert size for the number of outstanding extents, 1 normal size for
254 	 * updating the inode.
255 	 */
256 	if (outstanding_extents) {
257 		reserve_size = btrfs_calc_insert_metadata_size(fs_info,
258 						outstanding_extents);
259 		reserve_size += btrfs_calc_metadata_size(fs_info, 1);
260 	}
261 	csum_leaves = btrfs_csum_bytes_to_leaves(fs_info,
262 						 inode->csum_bytes);
263 	reserve_size += btrfs_calc_insert_metadata_size(fs_info,
264 							csum_leaves);
265 	/*
266 	 * For qgroup rsv, the calculation is very simple:
267 	 * account one nodesize for each outstanding extent
268 	 *
269 	 * This is overestimating in most cases.
270 	 */
271 	qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize;
272 
273 	spin_lock(&block_rsv->lock);
274 	block_rsv->size = reserve_size;
275 	block_rsv->qgroup_rsv_size = qgroup_rsv_size;
276 	spin_unlock(&block_rsv->lock);
277 }
278 
calc_inode_reservations(struct btrfs_fs_info * fs_info,u64 num_bytes,u64 disk_num_bytes,u64 * meta_reserve,u64 * qgroup_reserve)279 static void calc_inode_reservations(struct btrfs_fs_info *fs_info,
280 				    u64 num_bytes, u64 disk_num_bytes,
281 				    u64 *meta_reserve, u64 *qgroup_reserve)
282 {
283 	u64 nr_extents = count_max_extents(fs_info, num_bytes);
284 	u64 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, disk_num_bytes);
285 	u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);
286 
287 	*meta_reserve = btrfs_calc_insert_metadata_size(fs_info,
288 						nr_extents + csum_leaves);
289 
290 	/*
291 	 * finish_ordered_io has to update the inode, so add the space required
292 	 * for an inode update.
293 	 */
294 	*meta_reserve += inode_update;
295 	*qgroup_reserve = nr_extents * fs_info->nodesize;
296 }
297 
btrfs_delalloc_reserve_metadata(struct btrfs_inode * inode,u64 num_bytes,u64 disk_num_bytes,bool noflush)298 int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes,
299 				    u64 disk_num_bytes, bool noflush)
300 {
301 	struct btrfs_root *root = inode->root;
302 	struct btrfs_fs_info *fs_info = root->fs_info;
303 	struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
304 	u64 meta_reserve, qgroup_reserve;
305 	unsigned nr_extents;
306 	enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL;
307 	int ret = 0;
308 
309 	/*
310 	 * If we are a free space inode we need to not flush since we will be in
311 	 * the middle of a transaction commit.  We also don't need the delalloc
312 	 * mutex since we won't race with anybody.  We need this mostly to make
313 	 * lockdep shut its filthy mouth.
314 	 *
315 	 * If we have a transaction open (can happen if we call truncate_block
316 	 * from truncate), then we need FLUSH_LIMIT so we don't deadlock.
317 	 */
318 	if (noflush || btrfs_is_free_space_inode(inode)) {
319 		flush = BTRFS_RESERVE_NO_FLUSH;
320 	} else {
321 		if (current->journal_info)
322 			flush = BTRFS_RESERVE_FLUSH_LIMIT;
323 
324 		if (btrfs_transaction_in_commit(fs_info))
325 			schedule_timeout(1);
326 	}
327 
328 	num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
329 	disk_num_bytes = ALIGN(disk_num_bytes, fs_info->sectorsize);
330 
331 	/*
332 	 * We always want to do it this way, every other way is wrong and ends
333 	 * in tears.  Pre-reserving the amount we are going to add will always
334 	 * be the right way, because otherwise if we have enough parallelism we
335 	 * could end up with thousands of inodes all holding little bits of
336 	 * reservations they were able to make previously and the only way to
337 	 * reclaim that space is to ENOSPC out the operations and clear
338 	 * everything out and try again, which is bad.  This way we just
339 	 * over-reserve slightly, and clean up the mess when we are done.
340 	 */
341 	calc_inode_reservations(fs_info, num_bytes, disk_num_bytes,
342 				&meta_reserve, &qgroup_reserve);
343 	ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true,
344 						 noflush);
345 	if (ret)
346 		return ret;
347 	ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv, meta_reserve, flush);
348 	if (ret) {
349 		btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve);
350 		return ret;
351 	}
352 
353 	/*
354 	 * Now we need to update our outstanding extents and csum bytes _first_
355 	 * and then add the reservation to the block_rsv.  This keeps us from
356 	 * racing with an ordered completion or some such that would think it
357 	 * needs to free the reservation we just made.
358 	 */
359 	spin_lock(&inode->lock);
360 	nr_extents = count_max_extents(fs_info, num_bytes);
361 	btrfs_mod_outstanding_extents(inode, nr_extents);
362 	inode->csum_bytes += disk_num_bytes;
363 	btrfs_calculate_inode_block_rsv_size(fs_info, inode);
364 	spin_unlock(&inode->lock);
365 
366 	/* Now we can safely add our space to our block rsv */
367 	btrfs_block_rsv_add_bytes(block_rsv, meta_reserve, false);
368 	trace_btrfs_space_reservation(root->fs_info, "delalloc",
369 				      btrfs_ino(inode), meta_reserve, 1);
370 
371 	spin_lock(&block_rsv->lock);
372 	block_rsv->qgroup_rsv_reserved += qgroup_reserve;
373 	spin_unlock(&block_rsv->lock);
374 
375 	return 0;
376 }
377 
378 /**
379  * Release a metadata reservation for an inode
380  *
381  * @inode: the inode to release the reservation for.
382  * @num_bytes: the number of bytes we are releasing.
383  * @qgroup_free: free qgroup reservation or convert it to per-trans reservation
384  *
385  * This will release the metadata reservation for an inode.  This can be called
386  * once we complete IO for a given set of bytes to release their metadata
387  * reservations, or on error for the same reason.
388  */
btrfs_delalloc_release_metadata(struct btrfs_inode * inode,u64 num_bytes,bool qgroup_free)389 void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes,
390 				     bool qgroup_free)
391 {
392 	struct btrfs_fs_info *fs_info = inode->root->fs_info;
393 
394 	num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
395 	spin_lock(&inode->lock);
396 	inode->csum_bytes -= num_bytes;
397 	btrfs_calculate_inode_block_rsv_size(fs_info, inode);
398 	spin_unlock(&inode->lock);
399 
400 	if (btrfs_is_testing(fs_info))
401 		return;
402 
403 	btrfs_inode_rsv_release(inode, qgroup_free);
404 }
405 
406 /**
407  * btrfs_delalloc_release_extents - release our outstanding_extents
408  * @inode: the inode to balance the reservation for.
409  * @num_bytes: the number of bytes we originally reserved with
410  *
411  * When we reserve space we increase outstanding_extents for the extents we may
412  * add.  Once we've set the range as delalloc or created our ordered extents we
413  * have outstanding_extents to track the real usage, so we use this to free our
414  * temporarily tracked outstanding_extents.  This _must_ be used in conjunction
415  * with btrfs_delalloc_reserve_metadata.
416  */
btrfs_delalloc_release_extents(struct btrfs_inode * inode,u64 num_bytes)417 void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes)
418 {
419 	struct btrfs_fs_info *fs_info = inode->root->fs_info;
420 	unsigned num_extents;
421 
422 	spin_lock(&inode->lock);
423 	num_extents = count_max_extents(fs_info, num_bytes);
424 	btrfs_mod_outstanding_extents(inode, -num_extents);
425 	btrfs_calculate_inode_block_rsv_size(fs_info, inode);
426 	spin_unlock(&inode->lock);
427 
428 	if (btrfs_is_testing(fs_info))
429 		return;
430 
431 	btrfs_inode_rsv_release(inode, true);
432 }
433 
434 /**
435  * btrfs_delalloc_reserve_space - reserve data and metadata space for
436  * delalloc
437  * @inode: inode we're writing to
438  * @start: start range we are writing to
439  * @len: how long the range we are writing to
440  * @reserved: mandatory parameter, record actually reserved qgroup ranges of
441  * 	      current reservation.
442  *
443  * This will do the following things
444  *
445  * - reserve space in data space info for num bytes
446  *   and reserve precious corresponding qgroup space
447  *   (Done in check_data_free_space)
448  *
449  * - reserve space for metadata space, based on the number of outstanding
450  *   extents and how much csums will be needed
451  *   also reserve metadata space in a per root over-reserve method.
452  * - add to the inodes->delalloc_bytes
453  * - add it to the fs_info's delalloc inodes list.
454  *   (Above 3 all done in delalloc_reserve_metadata)
455  *
456  * Return 0 for success
457  * Return <0 for error(-ENOSPC or -EQUOT)
458  */
btrfs_delalloc_reserve_space(struct btrfs_inode * inode,struct extent_changeset ** reserved,u64 start,u64 len)459 int btrfs_delalloc_reserve_space(struct btrfs_inode *inode,
460 			struct extent_changeset **reserved, u64 start, u64 len)
461 {
462 	int ret;
463 
464 	ret = btrfs_check_data_free_space(inode, reserved, start, len, false);
465 	if (ret < 0)
466 		return ret;
467 	ret = btrfs_delalloc_reserve_metadata(inode, len, len, false);
468 	if (ret < 0) {
469 		btrfs_free_reserved_data_space(inode, *reserved, start, len);
470 		extent_changeset_free(*reserved);
471 		*reserved = NULL;
472 	}
473 	return ret;
474 }
475 
476 /**
477  * Release data and metadata space for delalloc
478  *
479  * @inode:       inode we're releasing space for
480  * @reserved:    list of changed/reserved ranges
481  * @start:       start position of the space already reserved
482  * @len:         length of the space already reserved
483  * @qgroup_free: should qgroup reserved-space also be freed
484  *
485  * This function will release the metadata space that was not used and will
486  * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes
487  * list if there are no delalloc bytes left.
488  * Also it will handle the qgroup reserved space.
489  */
btrfs_delalloc_release_space(struct btrfs_inode * inode,struct extent_changeset * reserved,u64 start,u64 len,bool qgroup_free)490 void btrfs_delalloc_release_space(struct btrfs_inode *inode,
491 				  struct extent_changeset *reserved,
492 				  u64 start, u64 len, bool qgroup_free)
493 {
494 	btrfs_delalloc_release_metadata(inode, len, qgroup_free);
495 	btrfs_free_reserved_data_space(inode, reserved, start, len);
496 }
497