fs/btrfs/delalloc-space.c

   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
 116 int 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
 131 int 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  */
 173 void 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  */
 191 void 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  */
 218 static 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
 242 static 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
 282 static 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
 307 int 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  */
 397 void 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  */
 427 void 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  */
 469 int 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  */
 500 void 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 }