fs/btrfs/delalloc-space.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "ctree.h"
   4 #include "delalloc-space.h"
   5 #include "block-rsv.h"
   6 #include "btrfs_inode.h"
   7 #include "space-info.h"
   8 #include "transaction.h"
   9 #include "qgroup.h"
  10 #include "block-group.h"
  11
  12 /*
  13  * HOW DOES THIS WORK
  14  *
  15  * There are two stages to data reservations, one for data and one for metadata
  16  * to handle the new extents and checksums generated by writing data.
  17  *
  18  *
  19  * DATA RESERVATION
  20  *   The general flow of the data reservation is as follows
  21  *
  22  *   -> Reserve
  23  *     We call into btrfs_reserve_data_bytes() for the user request bytes that
  24  *     they wish to write.  We make this reservation and add it to
  25  *     space_info->bytes_may_use.  We set EXTENT_DELALLOC on the inode io_tree
  26  *     for the range and carry on if this is buffered, or follow up trying to
  27  *     make a real allocation if we are pre-allocating or doing O_DIRECT.
  28  *
  29  *   -> Use
  30  *     At writepages()/prealloc/O_DIRECT time we will call into
  31  *     btrfs_reserve_extent() for some part or all of this range of bytes.  We
  32  *     will make the allocation and subtract space_info->bytes_may_use by the
  33  *     original requested length and increase the space_info->bytes_reserved by
  34  *     the allocated length.  This distinction is important because compression
  35  *     may allocate a smaller on disk extent than we previously reserved.
  36  *
  37  *   -> Allocation
  38  *     finish_ordered_io() will insert the new file extent item for this range,
  39  *     and then add a delayed ref update for the extent tree.  Once that delayed
  40  *     ref is written the extent size is subtracted from
  41  *     space_info->bytes_reserved and added to space_info->bytes_used.
  42  *
  43  *   Error handling
  44  *
  45  *   -> By the reservation maker
  46  *     This is the simplest case, we haven't completed our operation and we know
  47  *     how much we reserved, we can simply call
  48  *     btrfs_free_reserved_data_space*() and it will be removed from
  49  *     space_info->bytes_may_use.
  50  *
  51  *   -> After the reservation has been made, but before cow_file_range()
  52  *     This is specifically for the delalloc case.  You must clear
  53  *     EXTENT_DELALLOC with the EXTENT_CLEAR_DATA_RESV bit, and the range will
  54  *     be subtracted from space_info->bytes_may_use.
  55  *
  56  * METADATA RESERVATION
  57  *   The general metadata reservation lifetimes are discussed elsewhere, this
  58  *   will just focus on how it is used for delalloc space.
  59  *
  60  *   We keep track of two things on a per inode bases
  61  *
  62  *   ->outstanding_extents
  63  *     This is the number of file extent items we'll need to handle all of the
  64  *     outstanding DELALLOC space we have in this inode.  We limit the maximum
  65  *     size of an extent, so a large contiguous dirty area may require more than
  66  *     one outstanding_extent, which is why count_max_extents() is used to
  67  *     determine how many outstanding_extents get added.
  68  *
  69  *   ->csum_bytes
  70  *     This is essentially how many dirty bytes we have for this inode, so we
  71  *     can calculate the number of checksum items we would have to add in order
  72  *     to checksum our outstanding data.
  73  *
  74  *   We keep a per-inode block_rsv in order to make it easier to keep track of
  75  *   our reservation.  We use btrfs_calculate_inode_block_rsv_size() to
  76  *   calculate the current theoretical maximum reservation we would need for the
  77  *   metadata for this inode.  We call this and then adjust our reservation as
  78  *   necessary, either by attempting to reserve more space, or freeing up excess
  79  *   space.
  80  *
  81  * OUTSTANDING_EXTENTS HANDLING
  82  *
  83  *  ->outstanding_extents is used for keeping track of how many extents we will
  84  *  need to use for this inode, and it will fluctuate depending on where you are
  85  *  in the life cycle of the dirty data.  Consider the following normal case for
  86  *  a completely clean inode, with a num_bytes < our maximum allowed extent size
  87  *
  88  *  -> reserve
  89  *    ->outstanding_extents += 1 (current value is 1)
  90  *
  91  *  -> set_delalloc
  92  *    ->outstanding_extents += 1 (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
 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);
 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);
 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          */
 333         released = btrfs_block_rsv_release(fs_info, block_rsv, 0,
 334                                            &qgroup_to_release);
 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;
 356
 357         /*
 358          * Insert size for the number of outstanding extents, 1 normal size for
 359          * updating the inode.
 360          */
 361         if (outstanding_extents) {
 362                 reserve_size = btrfs_calc_insert_metadata_size(fs_info,
 363                                                 outstanding_extents);
 364                 reserve_size += btrfs_calc_metadata_size(fs_info, 1);
 365         }
 366         csum_leaves = btrfs_csum_bytes_to_leaves(fs_info,
 367                                                  inode->csum_bytes);
 368         reserve_size += btrfs_calc_insert_metadata_size(fs_info,
 369                                                         csum_leaves);
 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);
 390         u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);
 391
 392         *meta_reserve = btrfs_calc_insert_metadata_size(fs_info,
 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;
 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;
 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;
 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
 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)
 448                 return ret;
 449         ret = btrfs_reserve_metadata_bytes(root, block_rsv, meta_reserve, flush);
 450         if (ret) {
 451                 btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve);
 452                 return ret;
 453         }
 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
 477         return 0;
 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
 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  */
 518 void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes)
 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
 532         btrfs_inode_rsv_release(inode, true);
 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 }