505 lines · c
1// SPDX-License-Identifier: GPL-2.02 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 WORK14 *15 * There are two stages to data reservations, one for data and one for metadata16 * to handle the new extents and checksums generated by writing data.17 *18 *19 * DATA RESERVATION20 * The general flow of the data reservation is as follows21 *22 * -> Reserve23 * We call into btrfs_reserve_data_bytes() for the user request bytes that24 * they wish to write. We make this reservation and add it to25 * space_info->bytes_may_use. We set EXTENT_DELALLOC on the inode io_tree26 * for the range and carry on if this is buffered, or follow up trying to27 * make a real allocation if we are pre-allocating or doing O_DIRECT.28 *29 * -> Use30 * At writepages()/prealloc/O_DIRECT time we will call into31 * btrfs_reserve_extent() for some part or all of this range of bytes. We32 * will make the allocation and subtract space_info->bytes_may_use by the33 * original requested length and increase the space_info->bytes_reserved by34 * the allocated length. This distinction is important because compression35 * may allocate a smaller on disk extent than we previously reserved.36 *37 * -> Allocation38 * 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 delayed40 * ref is written the extent size is subtracted from41 * space_info->bytes_reserved and added to space_info->bytes_used.42 *43 * Error handling44 *45 * -> By the reservation maker46 * This is the simplest case, we haven't completed our operation and we know47 * how much we reserved, we can simply call48 * btrfs_free_reserved_data_space*() and it will be removed from49 * 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 clear53 * EXTENT_DELALLOC with the EXTENT_CLEAR_DATA_RESV bit, and the range will54 * be subtracted from space_info->bytes_may_use.55 *56 * METADATA RESERVATION57 * The general metadata reservation lifetimes are discussed elsewhere, this58 * will just focus on how it is used for delalloc space.59 *60 * We keep track of two things on a per inode bases61 *62 * ->outstanding_extents63 * This is the number of file extent items we'll need to handle all of the64 * outstanding DELALLOC space we have in this inode. We limit the maximum65 * size of an extent, so a large contiguous dirty area may require more than66 * one outstanding_extent, which is why count_max_extents() is used to67 * determine how many outstanding_extents get added.68 *69 * ->csum_bytes70 * This is essentially how many dirty bytes we have for this inode, so we71 * can calculate the number of checksum items we would have to add in order72 * to checksum our outstanding data.73 *74 * We keep a per-inode block_rsv in order to make it easier to keep track of75 * our reservation. We use btrfs_calculate_inode_block_rsv_size() to76 * calculate the current theoretical maximum reservation we would need for the77 * metadata for this inode. We call this and then adjust our reservation as78 * necessary, either by attempting to reserve more space, or freeing up excess79 * space.80 *81 * OUTSTANDING_EXTENTS HANDLING82 *83 * ->outstanding_extents is used for keeping track of how many extents we will84 * need to use for this inode, and it will fluctuate depending on where you are85 * in the life cycle of the dirty data. Consider the following normal case for86 * a completely clean inode, with a num_bytes < our maximum allowed extent size87 *88 * -> reserve89 * ->outstanding_extents += 1 (current value is 1)90 *91 * -> set_delalloc92 * ->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 the98 * duration of our operation, and then assume set_delalloc will update the99 * counter appropriately.100 *101 * -> add ordered extent102 * ->outstanding_extents += 1 (current value is 2)103 *104 * -> btrfs_clear_delalloc_extent105 * ->outstanding_extents -= 1 (current value is 1)106 *107 * -> finish_ordered_io/btrfs_remove_ordered_extent108 * ->outstanding_extents -= 1 (current value is 0)109 *110 * Each stage is responsible for their own accounting of the extent, thus111 * making error handling and cleanup easier.112 */113 114int btrfs_alloc_data_chunk_ondemand(const 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 129int 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 inode165 * Normally in a error case.166 *167 * This one will *NOT* use accurate qgroup reserved space API, just for case168 * which we can't sleep and is sure it won't affect qgroup reserved space.169 * Like clear_bit_hook().170 */171void 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 inode184 * Normally in a error case.185 *186 * This one will handle the per-inode data rsv map for accurate reserved187 * space framework.188 */189void 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, NULL);201}202 203/*204 * Release any excessive reservations for an inode.205 *206 * @inode: the inode we need to release from207 * @qgroup_free: free or convert qgroup meta. Unlike normal operation, qgroup208 * meta reservation needs to know if we are freeing qgroup209 * reservation or just converting it into per-trans. Normally210 * @qgroup_free is true for error handling, and false for normal211 * release.212 *213 * This is the same as btrfs_block_rsv_release, except that it handles the214 * tracepoint for the reservation.215 */216static 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 we225 * are releasing 0 bytes, and then we'll just get the reservation over226 * 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 else236 btrfs_qgroup_convert_reserved_meta(inode->root,237 qgroup_to_release);238}239 240static 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 unsigned outstanding_extents;247 248 lockdep_assert_held(&inode->lock);249 outstanding_extents = inode->outstanding_extents;250 251 /*252 * Insert size for the number of outstanding extents, 1 normal size for253 * updating the inode.254 */255 if (outstanding_extents) {256 reserve_size = btrfs_calc_insert_metadata_size(fs_info,257 outstanding_extents);258 reserve_size += btrfs_calc_metadata_size(fs_info, 1);259 }260 if (!(inode->flags & BTRFS_INODE_NODATASUM)) {261 u64 csum_leaves;262 263 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, inode->csum_bytes);264 reserve_size += btrfs_calc_insert_metadata_size(fs_info, csum_leaves);265 }266 /*267 * For qgroup rsv, the calculation is very simple:268 * account one nodesize for each outstanding extent269 *270 * This is overestimating in most cases.271 */272 qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize;273 274 spin_lock(&block_rsv->lock);275 block_rsv->size = reserve_size;276 block_rsv->qgroup_rsv_size = qgroup_rsv_size;277 spin_unlock(&block_rsv->lock);278}279 280static void calc_inode_reservations(struct btrfs_inode *inode,281 u64 num_bytes, u64 disk_num_bytes,282 u64 *meta_reserve, u64 *qgroup_reserve)283{284 struct btrfs_fs_info *fs_info = inode->root->fs_info;285 u64 nr_extents = count_max_extents(fs_info, num_bytes);286 u64 csum_leaves;287 u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);288 289 if (inode->flags & BTRFS_INODE_NODATASUM)290 csum_leaves = 0;291 else292 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, disk_num_bytes);293 294 *meta_reserve = btrfs_calc_insert_metadata_size(fs_info,295 nr_extents + csum_leaves);296 297 /*298 * finish_ordered_io has to update the inode, so add the space required299 * for an inode update.300 */301 *meta_reserve += inode_update;302 *qgroup_reserve = nr_extents * fs_info->nodesize;303}304 305int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes,306 u64 disk_num_bytes, bool noflush)307{308 struct btrfs_root *root = inode->root;309 struct btrfs_fs_info *fs_info = root->fs_info;310 struct btrfs_block_rsv *block_rsv = &inode->block_rsv;311 u64 meta_reserve, qgroup_reserve;312 unsigned nr_extents;313 enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL;314 int ret = 0;315 316 /*317 * If we are a free space inode we need to not flush since we will be in318 * the middle of a transaction commit. We also don't need the delalloc319 * mutex since we won't race with anybody. We need this mostly to make320 * lockdep shut its filthy mouth.321 *322 * If we have a transaction open (can happen if we call truncate_block323 * from truncate), then we need FLUSH_LIMIT so we don't deadlock.324 */325 if (noflush || btrfs_is_free_space_inode(inode)) {326 flush = BTRFS_RESERVE_NO_FLUSH;327 } else {328 if (current->journal_info)329 flush = BTRFS_RESERVE_FLUSH_LIMIT;330 }331 332 num_bytes = ALIGN(num_bytes, fs_info->sectorsize);333 disk_num_bytes = ALIGN(disk_num_bytes, fs_info->sectorsize);334 335 /*336 * We always want to do it this way, every other way is wrong and ends337 * in tears. Pre-reserving the amount we are going to add will always338 * be the right way, because otherwise if we have enough parallelism we339 * could end up with thousands of inodes all holding little bits of340 * reservations they were able to make previously and the only way to341 * reclaim that space is to ENOSPC out the operations and clear342 * everything out and try again, which is bad. This way we just343 * over-reserve slightly, and clean up the mess when we are done.344 */345 calc_inode_reservations(inode, num_bytes, disk_num_bytes,346 &meta_reserve, &qgroup_reserve);347 ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true,348 noflush);349 if (ret)350 return ret;351 ret = btrfs_reserve_metadata_bytes(fs_info, block_rsv->space_info,352 meta_reserve, flush);353 if (ret) {354 btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve);355 return ret;356 }357 358 /*359 * Now we need to update our outstanding extents and csum bytes _first_360 * and then add the reservation to the block_rsv. This keeps us from361 * racing with an ordered completion or some such that would think it362 * needs to free the reservation we just made.363 */364 nr_extents = count_max_extents(fs_info, num_bytes);365 spin_lock(&inode->lock);366 btrfs_mod_outstanding_extents(inode, nr_extents);367 if (!(inode->flags & BTRFS_INODE_NODATASUM))368 inode->csum_bytes += disk_num_bytes;369 btrfs_calculate_inode_block_rsv_size(fs_info, inode);370 spin_unlock(&inode->lock);371 372 /* Now we can safely add our space to our block rsv */373 btrfs_block_rsv_add_bytes(block_rsv, meta_reserve, false);374 trace_btrfs_space_reservation(root->fs_info, "delalloc",375 btrfs_ino(inode), meta_reserve, 1);376 377 spin_lock(&block_rsv->lock);378 block_rsv->qgroup_rsv_reserved += qgroup_reserve;379 spin_unlock(&block_rsv->lock);380 381 return 0;382}383 384/*385 * Release a metadata reservation for an inode.386 *387 * @inode: the inode to release the reservation for.388 * @num_bytes: the number of bytes we are releasing.389 * @qgroup_free: free qgroup reservation or convert it to per-trans reservation390 *391 * This will release the metadata reservation for an inode. This can be called392 * once we complete IO for a given set of bytes to release their metadata393 * reservations, or on error for the same reason.394 */395void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes,396 bool qgroup_free)397{398 struct btrfs_fs_info *fs_info = inode->root->fs_info;399 400 num_bytes = ALIGN(num_bytes, fs_info->sectorsize);401 spin_lock(&inode->lock);402 if (!(inode->flags & BTRFS_INODE_NODATASUM))403 inode->csum_bytes -= num_bytes;404 btrfs_calculate_inode_block_rsv_size(fs_info, inode);405 spin_unlock(&inode->lock);406 407 if (btrfs_is_testing(fs_info))408 return;409 410 btrfs_inode_rsv_release(inode, qgroup_free);411}412 413/*414 * Release our outstanding_extents for an inode.415 *416 * @inode: the inode to balance the reservation for.417 * @num_bytes: the number of bytes we originally reserved with418 *419 * When we reserve space we increase outstanding_extents for the extents we may420 * add. Once we've set the range as delalloc or created our ordered extents we421 * have outstanding_extents to track the real usage, so we use this to free our422 * temporarily tracked outstanding_extents. This _must_ be used in conjunction423 * with btrfs_delalloc_reserve_metadata.424 */425void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes)426{427 struct btrfs_fs_info *fs_info = inode->root->fs_info;428 unsigned num_extents;429 430 spin_lock(&inode->lock);431 num_extents = count_max_extents(fs_info, num_bytes);432 btrfs_mod_outstanding_extents(inode, -num_extents);433 btrfs_calculate_inode_block_rsv_size(fs_info, inode);434 spin_unlock(&inode->lock);435 436 if (btrfs_is_testing(fs_info))437 return;438 439 btrfs_inode_rsv_release(inode, true);440}441 442/*443 * Reserve data and metadata space for delalloc444 *445 * @inode: inode we're writing to446 * @start: start range we are writing to447 * @len: how long the range we are writing to448 * @reserved: mandatory parameter, record actually reserved qgroup ranges of449 * current reservation.450 *451 * This will do the following things452 *453 * - reserve space in data space info for num bytes and reserve precious454 * corresponding qgroup space455 * (Done in check_data_free_space)456 *457 * - reserve space for metadata space, based on the number of outstanding458 * extents and how much csums will be needed also reserve metadata space in a459 * per root over-reserve method.460 * - add to the inodes->delalloc_bytes461 * - add it to the fs_info's delalloc inodes list.462 * (Above 3 all done in delalloc_reserve_metadata)463 *464 * Return 0 for success465 * Return <0 for error(-ENOSPC or -EDQUOT)466 */467int btrfs_delalloc_reserve_space(struct btrfs_inode *inode,468 struct extent_changeset **reserved, u64 start, u64 len)469{470 int ret;471 472 ret = btrfs_check_data_free_space(inode, reserved, start, len, false);473 if (ret < 0)474 return ret;475 ret = btrfs_delalloc_reserve_metadata(inode, len, len, false);476 if (ret < 0) {477 btrfs_free_reserved_data_space(inode, *reserved, start, len);478 extent_changeset_free(*reserved);479 *reserved = NULL;480 }481 return ret;482}483 484/*485 * Release data and metadata space for delalloc486 *487 * @inode: inode we're releasing space for488 * @reserved: list of changed/reserved ranges489 * @start: start position of the space already reserved490 * @len: length of the space already reserved491 * @qgroup_free: should qgroup reserved-space also be freed492 *493 * Release the metadata space that was not used and will decrement494 * ->delalloc_bytes and remove it from the fs_info->delalloc_inodes list if495 * there are no delalloc bytes left. Also it will handle the qgroup reserved496 * space.497 */498void btrfs_delalloc_release_space(struct btrfs_inode *inode,499 struct extent_changeset *reserved,500 u64 start, u64 len, bool qgroup_free)501{502 btrfs_delalloc_release_metadata(inode, len, qgroup_free);503 btrfs_free_reserved_data_space(inode, reserved, start, len);504}505