Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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" |
Josef Bacik | 07730d8 | 2019-06-20 15:38:04 -0400 | [diff] [blame] | 10 | #include "block-group.h" |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 11 | |
Josef Bacik | 6f4ad55 | 2020-02-04 13:18:55 -0500 | [diff] [blame] | 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 | |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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); |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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); |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 | */ |
Nikolay Borisov | 63f018b | 2020-03-10 10:59:31 +0200 | [diff] [blame] | 333 | released = btrfs_block_rsv_release(fs_info, block_rsv, 0, |
| 334 | &qgroup_to_release); |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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; |
Josef Bacik | bcacf5f3 | 2019-08-22 15:14:34 -0400 | [diff] [blame] | 356 | |
| 357 | /* |
| 358 | * Insert size for the number of outstanding extents, 1 normal size for |
| 359 | * updating the inode. |
| 360 | */ |
| 361 | if (outstanding_extents) { |
Josef Bacik | 2bd36e7 | 2019-08-22 15:14:33 -0400 | [diff] [blame] | 362 | reserve_size = btrfs_calc_insert_metadata_size(fs_info, |
Josef Bacik | bcacf5f3 | 2019-08-22 15:14:34 -0400 | [diff] [blame] | 363 | outstanding_extents); |
| 364 | reserve_size += btrfs_calc_metadata_size(fs_info, 1); |
| 365 | } |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 366 | csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, |
| 367 | inode->csum_bytes); |
Josef Bacik | 2bd36e7 | 2019-08-22 15:14:33 -0400 | [diff] [blame] | 368 | reserve_size += btrfs_calc_insert_metadata_size(fs_info, |
| 369 | csum_leaves); |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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); |
Josef Bacik | bcacf5f3 | 2019-08-22 15:14:34 -0400 | [diff] [blame] | 390 | u64 inode_update = btrfs_calc_metadata_size(fs_info, 1); |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 391 | |
Josef Bacik | 2bd36e7 | 2019-08-22 15:14:33 -0400 | [diff] [blame] | 392 | *meta_reserve = btrfs_calc_insert_metadata_size(fs_info, |
Josef Bacik | bcacf5f3 | 2019-08-22 15:14:34 -0400 | [diff] [blame] | 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; |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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; |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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; |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 | |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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) |
Filipe Manana | 16ad3be | 2019-10-25 10:52:42 +0100 | [diff] [blame] | 448 | return ret; |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 449 | ret = btrfs_reserve_metadata_bytes(root, block_rsv, meta_reserve, flush); |
Filipe Manana | 16ad3be | 2019-10-25 10:52:42 +0100 | [diff] [blame] | 450 | if (ret) { |
| 451 | btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve); |
| 452 | return ret; |
| 453 | } |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 | |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 477 | return 0; |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 | */ |
Qu Wenruo | 8702ba9 | 2019-10-14 14:34:51 +0800 | [diff] [blame] | 518 | void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes) |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 | |
Qu Wenruo | 8702ba9 | 2019-10-14 14:34:51 +0800 | [diff] [blame] | 532 | btrfs_inode_rsv_release(inode, true); |
Josef Bacik | 8673634 | 2019-06-19 15:12:00 -0400 | [diff] [blame] | 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 | } |