Commit | Line | Data |
---|---|---|
86736342 JB |
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" | |
07730d87 | 10 | #include "block-group.h" |
86736342 | 11 | |
6f4ad559 JB |
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 | ||
86736342 JB |
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 | struct btrfs_space_info *data_sinfo = fs_info->data_sinfo; | |
119 | u64 used; | |
120 | int ret = 0; | |
121 | int need_commit = 2; | |
122 | int have_pinned_space; | |
123 | ||
124 | /* Make sure bytes are sectorsize aligned */ | |
125 | bytes = ALIGN(bytes, fs_info->sectorsize); | |
126 | ||
127 | if (btrfs_is_free_space_inode(inode)) { | |
128 | need_commit = 0; | |
129 | ASSERT(current->journal_info); | |
130 | } | |
131 | ||
132 | again: | |
133 | /* Make sure we have enough space to handle the data first */ | |
134 | spin_lock(&data_sinfo->lock); | |
135 | used = btrfs_space_info_used(data_sinfo, true); | |
136 | ||
137 | if (used + bytes > data_sinfo->total_bytes) { | |
138 | struct btrfs_trans_handle *trans; | |
139 | ||
140 | /* | |
141 | * If we don't have enough free bytes in this space then we need | |
142 | * to alloc a new chunk. | |
143 | */ | |
144 | if (!data_sinfo->full) { | |
145 | u64 alloc_target; | |
146 | ||
147 | data_sinfo->force_alloc = CHUNK_ALLOC_FORCE; | |
148 | spin_unlock(&data_sinfo->lock); | |
149 | ||
150 | alloc_target = btrfs_data_alloc_profile(fs_info); | |
151 | /* | |
152 | * It is ugly that we don't call nolock join | |
153 | * transaction for the free space inode case here. | |
154 | * But it is safe because we only do the data space | |
155 | * reservation for the free space cache in the | |
156 | * transaction context, the common join transaction | |
157 | * just increase the counter of the current transaction | |
158 | * handler, doesn't try to acquire the trans_lock of | |
159 | * the fs. | |
160 | */ | |
161 | trans = btrfs_join_transaction(root); | |
162 | if (IS_ERR(trans)) | |
163 | return PTR_ERR(trans); | |
164 | ||
165 | ret = btrfs_chunk_alloc(trans, alloc_target, | |
166 | CHUNK_ALLOC_NO_FORCE); | |
167 | btrfs_end_transaction(trans); | |
168 | if (ret < 0) { | |
169 | if (ret != -ENOSPC) | |
170 | return ret; | |
171 | else { | |
172 | have_pinned_space = 1; | |
173 | goto commit_trans; | |
174 | } | |
175 | } | |
176 | ||
177 | goto again; | |
178 | } | |
179 | ||
180 | /* | |
181 | * If we don't have enough pinned space to deal with this | |
182 | * allocation, and no removed chunk in current transaction, | |
183 | * don't bother committing the transaction. | |
184 | */ | |
185 | have_pinned_space = __percpu_counter_compare( | |
186 | &data_sinfo->total_bytes_pinned, | |
187 | used + bytes - data_sinfo->total_bytes, | |
188 | BTRFS_TOTAL_BYTES_PINNED_BATCH); | |
189 | spin_unlock(&data_sinfo->lock); | |
190 | ||
191 | /* Commit the current transaction and try again */ | |
192 | commit_trans: | |
193 | if (need_commit) { | |
194 | need_commit--; | |
195 | ||
196 | if (need_commit > 0) { | |
197 | btrfs_start_delalloc_roots(fs_info, -1); | |
198 | btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, | |
199 | (u64)-1); | |
200 | } | |
201 | ||
202 | trans = btrfs_join_transaction(root); | |
203 | if (IS_ERR(trans)) | |
204 | return PTR_ERR(trans); | |
205 | if (have_pinned_space >= 0 || | |
206 | test_bit(BTRFS_TRANS_HAVE_FREE_BGS, | |
207 | &trans->transaction->flags) || | |
208 | need_commit > 0) { | |
209 | ret = btrfs_commit_transaction(trans); | |
210 | if (ret) | |
211 | return ret; | |
212 | /* | |
213 | * The cleaner kthread might still be doing iput | |
214 | * operations. Wait for it to finish so that | |
215 | * more space is released. We don't need to | |
216 | * explicitly run the delayed iputs here because | |
217 | * the commit_transaction would have woken up | |
218 | * the cleaner. | |
219 | */ | |
220 | ret = btrfs_wait_on_delayed_iputs(fs_info); | |
221 | if (ret) | |
222 | return ret; | |
223 | goto again; | |
224 | } else { | |
225 | btrfs_end_transaction(trans); | |
226 | } | |
227 | } | |
228 | ||
229 | trace_btrfs_space_reservation(fs_info, | |
230 | "space_info:enospc", | |
231 | data_sinfo->flags, bytes, 1); | |
232 | return -ENOSPC; | |
233 | } | |
234 | btrfs_space_info_update_bytes_may_use(fs_info, data_sinfo, bytes); | |
86736342 JB |
235 | spin_unlock(&data_sinfo->lock); |
236 | ||
237 | return 0; | |
238 | } | |
239 | ||
240 | int btrfs_check_data_free_space(struct inode *inode, | |
241 | struct extent_changeset **reserved, u64 start, u64 len) | |
242 | { | |
243 | struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); | |
244 | int ret; | |
245 | ||
246 | /* align the range */ | |
247 | len = round_up(start + len, fs_info->sectorsize) - | |
248 | round_down(start, fs_info->sectorsize); | |
249 | start = round_down(start, fs_info->sectorsize); | |
250 | ||
251 | ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode), len); | |
252 | if (ret < 0) | |
253 | return ret; | |
254 | ||
255 | /* Use new btrfs_qgroup_reserve_data to reserve precious data space. */ | |
256 | ret = btrfs_qgroup_reserve_data(inode, reserved, start, len); | |
257 | if (ret < 0) | |
258 | btrfs_free_reserved_data_space_noquota(inode, start, len); | |
259 | else | |
260 | ret = 0; | |
261 | return ret; | |
262 | } | |
263 | ||
264 | /* | |
265 | * Called if we need to clear a data reservation for this inode | |
266 | * Normally in a error case. | |
267 | * | |
268 | * This one will *NOT* use accurate qgroup reserved space API, just for case | |
269 | * which we can't sleep and is sure it won't affect qgroup reserved space. | |
270 | * Like clear_bit_hook(). | |
271 | */ | |
272 | void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start, | |
273 | u64 len) | |
274 | { | |
275 | struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); | |
276 | struct btrfs_space_info *data_sinfo; | |
277 | ||
278 | /* Make sure the range is aligned to sectorsize */ | |
279 | len = round_up(start + len, fs_info->sectorsize) - | |
280 | round_down(start, fs_info->sectorsize); | |
281 | start = round_down(start, fs_info->sectorsize); | |
282 | ||
283 | data_sinfo = fs_info->data_sinfo; | |
284 | spin_lock(&data_sinfo->lock); | |
285 | btrfs_space_info_update_bytes_may_use(fs_info, data_sinfo, -len); | |
86736342 JB |
286 | spin_unlock(&data_sinfo->lock); |
287 | } | |
288 | ||
289 | /* | |
290 | * Called if we need to clear a data reservation for this inode | |
291 | * Normally in a error case. | |
292 | * | |
293 | * This one will handle the per-inode data rsv map for accurate reserved | |
294 | * space framework. | |
295 | */ | |
296 | void btrfs_free_reserved_data_space(struct inode *inode, | |
297 | struct extent_changeset *reserved, u64 start, u64 len) | |
298 | { | |
299 | struct btrfs_root *root = BTRFS_I(inode)->root; | |
300 | ||
301 | /* Make sure the range is aligned to sectorsize */ | |
302 | len = round_up(start + len, root->fs_info->sectorsize) - | |
303 | round_down(start, root->fs_info->sectorsize); | |
304 | start = round_down(start, root->fs_info->sectorsize); | |
305 | ||
306 | btrfs_free_reserved_data_space_noquota(inode, start, len); | |
307 | btrfs_qgroup_free_data(inode, reserved, start, len); | |
308 | } | |
309 | ||
310 | /** | |
311 | * btrfs_inode_rsv_release - release any excessive reservation. | |
312 | * @inode - the inode we need to release from. | |
313 | * @qgroup_free - free or convert qgroup meta. | |
314 | * Unlike normal operation, qgroup meta reservation needs to know if we are | |
315 | * freeing qgroup reservation or just converting it into per-trans. Normally | |
316 | * @qgroup_free is true for error handling, and false for normal release. | |
317 | * | |
318 | * This is the same as btrfs_block_rsv_release, except that it handles the | |
319 | * tracepoint for the reservation. | |
320 | */ | |
321 | static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free) | |
322 | { | |
323 | struct btrfs_fs_info *fs_info = inode->root->fs_info; | |
324 | struct btrfs_block_rsv *block_rsv = &inode->block_rsv; | |
325 | u64 released = 0; | |
326 | u64 qgroup_to_release = 0; | |
327 | ||
328 | /* | |
329 | * Since we statically set the block_rsv->size we just want to say we | |
330 | * are releasing 0 bytes, and then we'll just get the reservation over | |
331 | * the size free'd. | |
332 | */ | |
63f018be NB |
333 | released = btrfs_block_rsv_release(fs_info, block_rsv, 0, |
334 | &qgroup_to_release); | |
86736342 JB |
335 | if (released > 0) |
336 | trace_btrfs_space_reservation(fs_info, "delalloc", | |
337 | btrfs_ino(inode), released, 0); | |
338 | if (qgroup_free) | |
339 | btrfs_qgroup_free_meta_prealloc(inode->root, qgroup_to_release); | |
340 | else | |
341 | btrfs_qgroup_convert_reserved_meta(inode->root, | |
342 | qgroup_to_release); | |
343 | } | |
344 | ||
345 | static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info, | |
346 | struct btrfs_inode *inode) | |
347 | { | |
348 | struct btrfs_block_rsv *block_rsv = &inode->block_rsv; | |
349 | u64 reserve_size = 0; | |
350 | u64 qgroup_rsv_size = 0; | |
351 | u64 csum_leaves; | |
352 | unsigned outstanding_extents; | |
353 | ||
354 | lockdep_assert_held(&inode->lock); | |
355 | outstanding_extents = inode->outstanding_extents; | |
bcacf5f3 JB |
356 | |
357 | /* | |
358 | * Insert size for the number of outstanding extents, 1 normal size for | |
359 | * updating the inode. | |
360 | */ | |
361 | if (outstanding_extents) { | |
2bd36e7b | 362 | reserve_size = btrfs_calc_insert_metadata_size(fs_info, |
bcacf5f3 JB |
363 | outstanding_extents); |
364 | reserve_size += btrfs_calc_metadata_size(fs_info, 1); | |
365 | } | |
86736342 JB |
366 | csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, |
367 | inode->csum_bytes); | |
2bd36e7b JB |
368 | reserve_size += btrfs_calc_insert_metadata_size(fs_info, |
369 | csum_leaves); | |
86736342 JB |
370 | /* |
371 | * For qgroup rsv, the calculation is very simple: | |
372 | * account one nodesize for each outstanding extent | |
373 | * | |
374 | * This is overestimating in most cases. | |
375 | */ | |
376 | qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize; | |
377 | ||
378 | spin_lock(&block_rsv->lock); | |
379 | block_rsv->size = reserve_size; | |
380 | block_rsv->qgroup_rsv_size = qgroup_rsv_size; | |
381 | spin_unlock(&block_rsv->lock); | |
382 | } | |
383 | ||
384 | static void calc_inode_reservations(struct btrfs_fs_info *fs_info, | |
385 | u64 num_bytes, u64 *meta_reserve, | |
386 | u64 *qgroup_reserve) | |
387 | { | |
388 | u64 nr_extents = count_max_extents(num_bytes); | |
389 | u64 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, num_bytes); | |
bcacf5f3 | 390 | u64 inode_update = btrfs_calc_metadata_size(fs_info, 1); |
86736342 | 391 | |
2bd36e7b | 392 | *meta_reserve = btrfs_calc_insert_metadata_size(fs_info, |
bcacf5f3 JB |
393 | nr_extents + csum_leaves); |
394 | ||
395 | /* | |
396 | * finish_ordered_io has to update the inode, so add the space required | |
397 | * for an inode update. | |
398 | */ | |
399 | *meta_reserve += inode_update; | |
86736342 JB |
400 | *qgroup_reserve = nr_extents * fs_info->nodesize; |
401 | } | |
402 | ||
403 | int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes) | |
404 | { | |
405 | struct btrfs_root *root = inode->root; | |
406 | struct btrfs_fs_info *fs_info = root->fs_info; | |
407 | struct btrfs_block_rsv *block_rsv = &inode->block_rsv; | |
408 | u64 meta_reserve, qgroup_reserve; | |
409 | unsigned nr_extents; | |
410 | enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL; | |
411 | int ret = 0; | |
86736342 JB |
412 | |
413 | /* | |
414 | * If we are a free space inode we need to not flush since we will be in | |
415 | * the middle of a transaction commit. We also don't need the delalloc | |
416 | * mutex since we won't race with anybody. We need this mostly to make | |
417 | * lockdep shut its filthy mouth. | |
418 | * | |
419 | * If we have a transaction open (can happen if we call truncate_block | |
420 | * from truncate), then we need FLUSH_LIMIT so we don't deadlock. | |
421 | */ | |
422 | if (btrfs_is_free_space_inode(inode)) { | |
423 | flush = BTRFS_RESERVE_NO_FLUSH; | |
86736342 JB |
424 | } else { |
425 | if (current->journal_info) | |
426 | flush = BTRFS_RESERVE_FLUSH_LIMIT; | |
427 | ||
428 | if (btrfs_transaction_in_commit(fs_info)) | |
429 | schedule_timeout(1); | |
430 | } | |
431 | ||
86736342 JB |
432 | num_bytes = ALIGN(num_bytes, fs_info->sectorsize); |
433 | ||
434 | /* | |
435 | * We always want to do it this way, every other way is wrong and ends | |
436 | * in tears. Pre-reserving the amount we are going to add will always | |
437 | * be the right way, because otherwise if we have enough parallelism we | |
438 | * could end up with thousands of inodes all holding little bits of | |
439 | * reservations they were able to make previously and the only way to | |
440 | * reclaim that space is to ENOSPC out the operations and clear | |
441 | * everything out and try again, which is bad. This way we just | |
442 | * over-reserve slightly, and clean up the mess when we are done. | |
443 | */ | |
444 | calc_inode_reservations(fs_info, num_bytes, &meta_reserve, | |
445 | &qgroup_reserve); | |
446 | ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true); | |
447 | if (ret) | |
16ad3be1 | 448 | return ret; |
86736342 | 449 | ret = btrfs_reserve_metadata_bytes(root, block_rsv, meta_reserve, flush); |
16ad3be1 FM |
450 | if (ret) { |
451 | btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve); | |
452 | return ret; | |
453 | } | |
86736342 JB |
454 | |
455 | /* | |
456 | * Now we need to update our outstanding extents and csum bytes _first_ | |
457 | * and then add the reservation to the block_rsv. This keeps us from | |
458 | * racing with an ordered completion or some such that would think it | |
459 | * needs to free the reservation we just made. | |
460 | */ | |
461 | spin_lock(&inode->lock); | |
462 | nr_extents = count_max_extents(num_bytes); | |
463 | btrfs_mod_outstanding_extents(inode, nr_extents); | |
464 | inode->csum_bytes += num_bytes; | |
465 | btrfs_calculate_inode_block_rsv_size(fs_info, inode); | |
466 | spin_unlock(&inode->lock); | |
467 | ||
468 | /* Now we can safely add our space to our block rsv */ | |
469 | btrfs_block_rsv_add_bytes(block_rsv, meta_reserve, false); | |
470 | trace_btrfs_space_reservation(root->fs_info, "delalloc", | |
471 | btrfs_ino(inode), meta_reserve, 1); | |
472 | ||
473 | spin_lock(&block_rsv->lock); | |
474 | block_rsv->qgroup_rsv_reserved += qgroup_reserve; | |
475 | spin_unlock(&block_rsv->lock); | |
476 | ||
86736342 | 477 | return 0; |
86736342 JB |
478 | } |
479 | ||
480 | /** | |
481 | * btrfs_delalloc_release_metadata - release a metadata reservation for an inode | |
482 | * @inode: the inode to release the reservation for. | |
483 | * @num_bytes: the number of bytes we are releasing. | |
484 | * @qgroup_free: free qgroup reservation or convert it to per-trans reservation | |
485 | * | |
486 | * This will release the metadata reservation for an inode. This can be called | |
487 | * once we complete IO for a given set of bytes to release their metadata | |
488 | * reservations, or on error for the same reason. | |
489 | */ | |
490 | void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes, | |
491 | bool qgroup_free) | |
492 | { | |
493 | struct btrfs_fs_info *fs_info = inode->root->fs_info; | |
494 | ||
495 | num_bytes = ALIGN(num_bytes, fs_info->sectorsize); | |
496 | spin_lock(&inode->lock); | |
497 | inode->csum_bytes -= num_bytes; | |
498 | btrfs_calculate_inode_block_rsv_size(fs_info, inode); | |
499 | spin_unlock(&inode->lock); | |
500 | ||
501 | if (btrfs_is_testing(fs_info)) | |
502 | return; | |
503 | ||
504 | btrfs_inode_rsv_release(inode, qgroup_free); | |
505 | } | |
506 | ||
507 | /** | |
508 | * btrfs_delalloc_release_extents - release our outstanding_extents | |
509 | * @inode: the inode to balance the reservation for. | |
510 | * @num_bytes: the number of bytes we originally reserved with | |
86736342 JB |
511 | * |
512 | * When we reserve space we increase outstanding_extents for the extents we may | |
513 | * add. Once we've set the range as delalloc or created our ordered extents we | |
514 | * have outstanding_extents to track the real usage, so we use this to free our | |
515 | * temporarily tracked outstanding_extents. This _must_ be used in conjunction | |
516 | * with btrfs_delalloc_reserve_metadata. | |
517 | */ | |
8702ba93 | 518 | void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes) |
86736342 JB |
519 | { |
520 | struct btrfs_fs_info *fs_info = inode->root->fs_info; | |
521 | unsigned num_extents; | |
522 | ||
523 | spin_lock(&inode->lock); | |
524 | num_extents = count_max_extents(num_bytes); | |
525 | btrfs_mod_outstanding_extents(inode, -num_extents); | |
526 | btrfs_calculate_inode_block_rsv_size(fs_info, inode); | |
527 | spin_unlock(&inode->lock); | |
528 | ||
529 | if (btrfs_is_testing(fs_info)) | |
530 | return; | |
531 | ||
8702ba93 | 532 | btrfs_inode_rsv_release(inode, true); |
86736342 JB |
533 | } |
534 | ||
535 | /** | |
536 | * btrfs_delalloc_reserve_space - reserve data and metadata space for | |
537 | * delalloc | |
538 | * @inode: inode we're writing to | |
539 | * @start: start range we are writing to | |
540 | * @len: how long the range we are writing to | |
541 | * @reserved: mandatory parameter, record actually reserved qgroup ranges of | |
542 | * current reservation. | |
543 | * | |
544 | * This will do the following things | |
545 | * | |
546 | * - reserve space in data space info for num bytes | |
547 | * and reserve precious corresponding qgroup space | |
548 | * (Done in check_data_free_space) | |
549 | * | |
550 | * - reserve space for metadata space, based on the number of outstanding | |
551 | * extents and how much csums will be needed | |
552 | * also reserve metadata space in a per root over-reserve method. | |
553 | * - add to the inodes->delalloc_bytes | |
554 | * - add it to the fs_info's delalloc inodes list. | |
555 | * (Above 3 all done in delalloc_reserve_metadata) | |
556 | * | |
557 | * Return 0 for success | |
558 | * Return <0 for error(-ENOSPC or -EQUOT) | |
559 | */ | |
560 | int btrfs_delalloc_reserve_space(struct inode *inode, | |
561 | struct extent_changeset **reserved, u64 start, u64 len) | |
562 | { | |
563 | int ret; | |
564 | ||
565 | ret = btrfs_check_data_free_space(inode, reserved, start, len); | |
566 | if (ret < 0) | |
567 | return ret; | |
568 | ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), len); | |
569 | if (ret < 0) | |
570 | btrfs_free_reserved_data_space(inode, *reserved, start, len); | |
571 | return ret; | |
572 | } | |
573 | ||
574 | /** | |
575 | * btrfs_delalloc_release_space - release data and metadata space for delalloc | |
576 | * @inode: inode we're releasing space for | |
577 | * @start: start position of the space already reserved | |
578 | * @len: the len of the space already reserved | |
579 | * @release_bytes: the len of the space we consumed or didn't use | |
580 | * | |
581 | * This function will release the metadata space that was not used and will | |
582 | * decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes | |
583 | * list if there are no delalloc bytes left. | |
584 | * Also it will handle the qgroup reserved space. | |
585 | */ | |
586 | void btrfs_delalloc_release_space(struct inode *inode, | |
587 | struct extent_changeset *reserved, | |
588 | u64 start, u64 len, bool qgroup_free) | |
589 | { | |
590 | btrfs_delalloc_release_metadata(BTRFS_I(inode), len, qgroup_free); | |
591 | btrfs_free_reserved_data_space(inode, reserved, start, len); | |
592 | } |