fs/btrfs/space-info.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "misc.h"
   4 #include "ctree.h"
   5 #include "space-info.h"
   6 #include "sysfs.h"
   7 #include "volumes.h"
   8 #include "free-space-cache.h"
   9 #include "ordered-data.h"
  10 #include "transaction.h"
  11 #include "block-group.h"
  12
  13 u64 btrfs_space_info_used(struct btrfs_space_info *s_info,
  14                           bool may_use_included)
  15 {
  16         ASSERT(s_info);
  17         return s_info->bytes_used + s_info->bytes_reserved +
  18                 s_info->bytes_pinned + s_info->bytes_readonly +
  19                 (may_use_included ? s_info->bytes_may_use : 0);
  20 }
  21
  22 /*
  23  * after adding space to the filesystem, we need to clear the full flags
  24  * on all the space infos.
  25  */
  26 void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
  27 {
  28         struct list_head *head = &info->space_info;
  29         struct btrfs_space_info *found;
  30
  31         rcu_read_lock();
  32         list_for_each_entry_rcu(found, head, list)
  33                 found->full = 0;
  34         rcu_read_unlock();
  35 }
  36
  37 static int create_space_info(struct btrfs_fs_info *info, u64 flags)
  38 {
  39
  40         struct btrfs_space_info *space_info;
  41         int i;
  42         int ret;
  43
  44         space_info = kzalloc(sizeof(*space_info), GFP_NOFS);
  45         if (!space_info)
  46                 return -ENOMEM;
  47
  48         ret = percpu_counter_init(&space_info->total_bytes_pinned, 0,
  49                                  GFP_KERNEL);
  50         if (ret) {
  51                 kfree(space_info);
  52                 return ret;
  53         }
  54
  55         for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
  56                 INIT_LIST_HEAD(&space_info->block_groups[i]);
  57         init_rwsem(&space_info->groups_sem);
  58         spin_lock_init(&space_info->lock);
  59         space_info->flags = flags & BTRFS_BLOCK_GROUP_TYPE_MASK;
  60         space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
  61         init_waitqueue_head(&space_info->wait);
  62         INIT_LIST_HEAD(&space_info->ro_bgs);
  63         INIT_LIST_HEAD(&space_info->tickets);
  64         INIT_LIST_HEAD(&space_info->priority_tickets);
  65
  66         ret = btrfs_sysfs_add_space_info_type(info, space_info);
  67         if (ret)
  68                 return ret;
  69
  70         list_add_rcu(&space_info->list, &info->space_info);
  71         if (flags & BTRFS_BLOCK_GROUP_DATA)
  72                 info->data_sinfo = space_info;
  73
  74         return ret;
  75 }
  76
  77 int btrfs_init_space_info(struct btrfs_fs_info *fs_info)
  78 {
  79         struct btrfs_super_block *disk_super;
  80         u64 features;
  81         u64 flags;
  82         int mixed = 0;
  83         int ret;
  84
  85         disk_super = fs_info->super_copy;
  86         if (!btrfs_super_root(disk_super))
  87                 return -EINVAL;
  88
  89         features = btrfs_super_incompat_flags(disk_super);
  90         if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
  91                 mixed = 1;
  92
  93         flags = BTRFS_BLOCK_GROUP_SYSTEM;
  94         ret = create_space_info(fs_info, flags);
  95         if (ret)
  96                 goto out;
  97
  98         if (mixed) {
  99                 flags = BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA;
 100                 ret = create_space_info(fs_info, flags);
 101         } else {
 102                 flags = BTRFS_BLOCK_GROUP_METADATA;
 103                 ret = create_space_info(fs_info, flags);
 104                 if (ret)
 105                         goto out;
 106
 107                 flags = BTRFS_BLOCK_GROUP_DATA;
 108                 ret = create_space_info(fs_info, flags);
 109         }
 110 out:
 111         return ret;
 112 }
 113
 114 void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags,
 115                              u64 total_bytes, u64 bytes_used,
 116                              u64 bytes_readonly,
 117                              struct btrfs_space_info **space_info)
 118 {
 119         struct btrfs_space_info *found;
 120         int factor;
 121
 122         factor = btrfs_bg_type_to_factor(flags);
 123
 124         found = btrfs_find_space_info(info, flags);
 125         ASSERT(found);
 126         spin_lock(&found->lock);
 127         found->total_bytes += total_bytes;
 128         found->disk_total += total_bytes * factor;
 129         found->bytes_used += bytes_used;
 130         found->disk_used += bytes_used * factor;
 131         found->bytes_readonly += bytes_readonly;
 132         if (total_bytes > 0)
 133                 found->full = 0;
 134         btrfs_try_granting_tickets(info, found);
 135         spin_unlock(&found->lock);
 136         *space_info = found;
 137 }
 138
 139 struct btrfs_space_info *btrfs_find_space_info(struct btrfs_fs_info *info,
 140                                                u64 flags)
 141 {
 142         struct list_head *head = &info->space_info;
 143         struct btrfs_space_info *found;
 144
 145         flags &= BTRFS_BLOCK_GROUP_TYPE_MASK;
 146
 147         rcu_read_lock();
 148         list_for_each_entry_rcu(found, head, list) {
 149                 if (found->flags & flags) {
 150                         rcu_read_unlock();
 151                         return found;
 152                 }
 153         }
 154         rcu_read_unlock();
 155         return NULL;
 156 }
 157
 158 static inline u64 calc_global_rsv_need_space(struct btrfs_block_rsv *global)
 159 {
 160         return (global->size << 1);
 161 }
 162
 163 int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
 164                          struct btrfs_space_info *space_info, u64 bytes,
 165                          enum btrfs_reserve_flush_enum flush)
 166 {
 167         u64 profile;
 168         u64 avail;
 169         u64 used;
 170         int factor;
 171
 172         /* Don't overcommit when in mixed mode. */
 173         if (space_info->flags & BTRFS_BLOCK_GROUP_DATA)
 174                 return 0;
 175
 176         if (space_info->flags & BTRFS_BLOCK_GROUP_SYSTEM)
 177                 profile = btrfs_system_alloc_profile(fs_info);
 178         else
 179                 profile = btrfs_metadata_alloc_profile(fs_info);
 180
 181         used = btrfs_space_info_used(space_info, true);
 182         avail = atomic64_read(&fs_info->free_chunk_space);
 183
 184         /*
 185          * If we have dup, raid1 or raid10 then only half of the free
 186          * space is actually usable.  For raid56, the space info used
 187          * doesn't include the parity drive, so we don't have to
 188          * change the math
 189          */
 190         factor = btrfs_bg_type_to_factor(profile);
 191         avail = div_u64(avail, factor);
 192
 193         /*
 194          * If we aren't flushing all things, let us overcommit up to
 195          * 1/2th of the space. If we can flush, don't let us overcommit
 196          * too much, let it overcommit up to 1/8 of the space.
 197          */
 198         if (flush == BTRFS_RESERVE_FLUSH_ALL)
 199                 avail >>= 3;
 200         else
 201                 avail >>= 1;
 202
 203         if (used + bytes < space_info->total_bytes + avail)
 204                 return 1;
 205         return 0;
 206 }
 207
 208 /*
 209  * This is for space we already have accounted in space_info->bytes_may_use, so
 210  * basically when we're returning space from block_rsv's.
 211  */
 212 void btrfs_try_granting_tickets(struct btrfs_fs_info *fs_info,
 213                                 struct btrfs_space_info *space_info)
 214 {
 215         struct list_head *head;
 216         enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_NO_FLUSH;
 217
 218         lockdep_assert_held(&space_info->lock);
 219
 220         head = &space_info->priority_tickets;
 221 again:
 222         while (!list_empty(head)) {
 223                 struct reserve_ticket *ticket;
 224                 u64 used = btrfs_space_info_used(space_info, true);
 225
 226                 ticket = list_first_entry(head, struct reserve_ticket, list);
 227
 228                 /* Check and see if our ticket can be satisified now. */
 229                 if ((used + ticket->bytes <= space_info->total_bytes) ||
 230                     btrfs_can_overcommit(fs_info, space_info, ticket->bytes,
 231                                          flush)) {
 232                         btrfs_space_info_update_bytes_may_use(fs_info,
 233                                                               space_info,
 234                                                               ticket->bytes);
 235                         list_del_init(&ticket->list);
 236                         ticket->bytes = 0;
 237                         space_info->tickets_id++;
 238                         wake_up(&ticket->wait);
 239                 } else {
 240                         break;
 241                 }
 242         }
 243
 244         if (head == &space_info->priority_tickets) {
 245                 head = &space_info->tickets;
 246                 flush = BTRFS_RESERVE_FLUSH_ALL;
 247                 goto again;
 248         }
 249 }
 250
 251 #define DUMP_BLOCK_RSV(fs_info, rsv_name)                               \
 252 do {                                                                    \
 253         struct btrfs_block_rsv *__rsv = &(fs_info)->rsv_name;           \
 254         spin_lock(&__rsv->lock);                                        \
 255         btrfs_info(fs_info, #rsv_name ": size %llu reserved %llu",      \
 256                    __rsv->size, __rsv->reserved);                       \
 257         spin_unlock(&__rsv->lock);                                      \
 258 } while (0)
 259
 260 static void __btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
 261                                     struct btrfs_space_info *info)
 262 {
 263         lockdep_assert_held(&info->lock);
 264
 265         /* The free space could be negative in case of overcommit */
 266         btrfs_info(fs_info, "space_info %llu has %lld free, is %sfull",
 267                    info->flags,
 268                    (s64)(info->total_bytes - btrfs_space_info_used(info, true)),
 269                    info->full ? "" : "not ");
 270         btrfs_info(fs_info,
 271                 "space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu",
 272                 info->total_bytes, info->bytes_used, info->bytes_pinned,
 273                 info->bytes_reserved, info->bytes_may_use,
 274                 info->bytes_readonly);
 275
 276         DUMP_BLOCK_RSV(fs_info, global_block_rsv);
 277         DUMP_BLOCK_RSV(fs_info, trans_block_rsv);
 278         DUMP_BLOCK_RSV(fs_info, chunk_block_rsv);
 279         DUMP_BLOCK_RSV(fs_info, delayed_block_rsv);
 280         DUMP_BLOCK_RSV(fs_info, delayed_refs_rsv);
 281
 282 }
 283
 284 void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
 285                            struct btrfs_space_info *info, u64 bytes,
 286                            int dump_block_groups)
 287 {
 288         struct btrfs_block_group_cache *cache;
 289         int index = 0;
 290
 291         spin_lock(&info->lock);
 292         __btrfs_dump_space_info(fs_info, info);
 293         spin_unlock(&info->lock);
 294
 295         if (!dump_block_groups)
 296                 return;
 297
 298         down_read(&info->groups_sem);
 299 again:
 300         list_for_each_entry(cache, &info->block_groups[index], list) {
 301                 spin_lock(&cache->lock);
 302                 btrfs_info(fs_info,
 303                         "block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %s",
 304                         cache->key.objectid, cache->key.offset,
 305                         btrfs_block_group_used(&cache->item), cache->pinned,
 306                         cache->reserved, cache->ro ? "[readonly]" : "");
 307                 spin_unlock(&cache->lock);
 308                 btrfs_dump_free_space(cache, bytes);
 309         }
 310         if (++index < BTRFS_NR_RAID_TYPES)
 311                 goto again;
 312         up_read(&info->groups_sem);
 313 }
 314
 315 static void btrfs_writeback_inodes_sb_nr(struct btrfs_fs_info *fs_info,
 316                                          unsigned long nr_pages, int nr_items)
 317 {
 318         struct super_block *sb = fs_info->sb;
 319
 320         if (down_read_trylock(&sb->s_umount)) {
 321                 writeback_inodes_sb_nr(sb, nr_pages, WB_REASON_FS_FREE_SPACE);
 322                 up_read(&sb->s_umount);
 323         } else {
 324                 /*
 325                  * We needn't worry the filesystem going from r/w to r/o though
 326                  * we don't acquire ->s_umount mutex, because the filesystem
 327                  * should guarantee the delalloc inodes list be empty after
 328                  * the filesystem is readonly(all dirty pages are written to
 329                  * the disk).
 330                  */
 331                 btrfs_start_delalloc_roots(fs_info, nr_items);
 332                 if (!current->journal_info)
 333                         btrfs_wait_ordered_roots(fs_info, nr_items, 0, (u64)-1);
 334         }
 335 }
 336
 337 static inline u64 calc_reclaim_items_nr(struct btrfs_fs_info *fs_info,
 338                                         u64 to_reclaim)
 339 {
 340         u64 bytes;
 341         u64 nr;
 342
 343         bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
 344         nr = div64_u64(to_reclaim, bytes);
 345         if (!nr)
 346                 nr = 1;
 347         return nr;
 348 }
 349
 350 #define EXTENT_SIZE_PER_ITEM    SZ_256K
 351
 352 /*
 353  * shrink metadata reservation for delalloc
 354  */
 355 static void shrink_delalloc(struct btrfs_fs_info *fs_info, u64 to_reclaim,
 356                             u64 orig, bool wait_ordered)
 357 {
 358         struct btrfs_space_info *space_info;
 359         struct btrfs_trans_handle *trans;
 360         u64 delalloc_bytes;
 361         u64 dio_bytes;
 362         u64 async_pages;
 363         u64 items;
 364         long time_left;
 365         unsigned long nr_pages;
 366         int loops;
 367
 368         /* Calc the number of the pages we need flush for space reservation */
 369         items = calc_reclaim_items_nr(fs_info, to_reclaim);
 370         to_reclaim = items * EXTENT_SIZE_PER_ITEM;
 371
 372         trans = (struct btrfs_trans_handle *)current->journal_info;
 373         space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
 374
 375         delalloc_bytes = percpu_counter_sum_positive(
 376                                                 &fs_info->delalloc_bytes);
 377         dio_bytes = percpu_counter_sum_positive(&fs_info->dio_bytes);
 378         if (delalloc_bytes == 0 && dio_bytes == 0) {
 379                 if (trans)
 380                         return;
 381                 if (wait_ordered)
 382                         btrfs_wait_ordered_roots(fs_info, items, 0, (u64)-1);
 383                 return;
 384         }
 385
 386         /*
 387          * If we are doing more ordered than delalloc we need to just wait on
 388          * ordered extents, otherwise we'll waste time trying to flush delalloc
 389          * that likely won't give us the space back we need.
 390          */
 391         if (dio_bytes > delalloc_bytes)
 392                 wait_ordered = true;
 393
 394         loops = 0;
 395         while ((delalloc_bytes || dio_bytes) && loops < 3) {
 396                 nr_pages = min(delalloc_bytes, to_reclaim) >> PAGE_SHIFT;
 397
 398                 /*
 399                  * Triggers inode writeback for up to nr_pages. This will invoke
 400                  * ->writepages callback and trigger delalloc filling
 401                  *  (btrfs_run_delalloc_range()).
 402                  */
 403                 btrfs_writeback_inodes_sb_nr(fs_info, nr_pages, items);
 404
 405                 /*
 406                  * We need to wait for the compressed pages to start before
 407                  * we continue.
 408                  */
 409                 async_pages = atomic_read(&fs_info->async_delalloc_pages);
 410                 if (!async_pages)
 411                         goto skip_async;
 412
 413                 /*
 414                  * Calculate how many compressed pages we want to be written
 415                  * before we continue. I.e if there are more async pages than we
 416                  * require wait_event will wait until nr_pages are written.
 417                  */
 418                 if (async_pages <= nr_pages)
 419                         async_pages = 0;
 420                 else
 421                         async_pages -= nr_pages;
 422
 423                 wait_event(fs_info->async_submit_wait,
 424                            atomic_read(&fs_info->async_delalloc_pages) <=
 425                            (int)async_pages);
 426 skip_async:
 427                 spin_lock(&space_info->lock);
 428                 if (list_empty(&space_info->tickets) &&
 429                     list_empty(&space_info->priority_tickets)) {
 430                         spin_unlock(&space_info->lock);
 431                         break;
 432                 }
 433                 spin_unlock(&space_info->lock);
 434
 435                 loops++;
 436                 if (wait_ordered && !trans) {
 437                         btrfs_wait_ordered_roots(fs_info, items, 0, (u64)-1);
 438                 } else {
 439                         time_left = schedule_timeout_killable(1);
 440                         if (time_left)
 441                                 break;
 442                 }
 443                 delalloc_bytes = percpu_counter_sum_positive(
 444                                                 &fs_info->delalloc_bytes);
 445                 dio_bytes = percpu_counter_sum_positive(&fs_info->dio_bytes);
 446         }
 447 }
 448
 449 /**
 450  * maybe_commit_transaction - possibly commit the transaction if its ok to
 451  * @root - the root we're allocating for
 452  * @bytes - the number of bytes we want to reserve
 453  * @force - force the commit
 454  *
 455  * This will check to make sure that committing the transaction will actually
 456  * get us somewhere and then commit the transaction if it does.  Otherwise it
 457  * will return -ENOSPC.
 458  */
 459 static int may_commit_transaction(struct btrfs_fs_info *fs_info,
 460                                   struct btrfs_space_info *space_info)
 461 {
 462         struct reserve_ticket *ticket = NULL;
 463         struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_block_rsv;
 464         struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
 465         struct btrfs_block_rsv *trans_rsv = &fs_info->trans_block_rsv;
 466         struct btrfs_trans_handle *trans;
 467         u64 bytes_needed;
 468         u64 reclaim_bytes = 0;
 469         u64 cur_free_bytes = 0;
 470
 471         trans = (struct btrfs_trans_handle *)current->journal_info;
 472         if (trans)
 473                 return -EAGAIN;
 474
 475         spin_lock(&space_info->lock);
 476         cur_free_bytes = btrfs_space_info_used(space_info, true);
 477         if (cur_free_bytes < space_info->total_bytes)
 478                 cur_free_bytes = space_info->total_bytes - cur_free_bytes;
 479         else
 480                 cur_free_bytes = 0;
 481
 482         if (!list_empty(&space_info->priority_tickets))
 483                 ticket = list_first_entry(&space_info->priority_tickets,
 484                                           struct reserve_ticket, list);
 485         else if (!list_empty(&space_info->tickets))
 486                 ticket = list_first_entry(&space_info->tickets,
 487                                           struct reserve_ticket, list);
 488         bytes_needed = (ticket) ? ticket->bytes : 0;
 489
 490         if (bytes_needed > cur_free_bytes)
 491                 bytes_needed -= cur_free_bytes;
 492         else
 493                 bytes_needed = 0;
 494         spin_unlock(&space_info->lock);
 495
 496         if (!bytes_needed)
 497                 return 0;
 498
 499         trans = btrfs_join_transaction(fs_info->extent_root);
 500         if (IS_ERR(trans))
 501                 return PTR_ERR(trans);
 502
 503         /*
 504          * See if there is enough pinned space to make this reservation, or if
 505          * we have block groups that are going to be freed, allowing us to
 506          * possibly do a chunk allocation the next loop through.
 507          */
 508         if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags) ||
 509             __percpu_counter_compare(&space_info->total_bytes_pinned,
 510                                      bytes_needed,
 511                                      BTRFS_TOTAL_BYTES_PINNED_BATCH) >= 0)
 512                 goto commit;
 513
 514         /*
 515          * See if there is some space in the delayed insertion reservation for
 516          * this reservation.
 517          */
 518         if (space_info != delayed_rsv->space_info)
 519                 goto enospc;
 520
 521         spin_lock(&delayed_rsv->lock);
 522         reclaim_bytes += delayed_rsv->reserved;
 523         spin_unlock(&delayed_rsv->lock);
 524
 525         spin_lock(&delayed_refs_rsv->lock);
 526         reclaim_bytes += delayed_refs_rsv->reserved;
 527         spin_unlock(&delayed_refs_rsv->lock);
 528
 529         spin_lock(&trans_rsv->lock);
 530         reclaim_bytes += trans_rsv->reserved;
 531         spin_unlock(&trans_rsv->lock);
 532
 533         if (reclaim_bytes >= bytes_needed)
 534                 goto commit;
 535         bytes_needed -= reclaim_bytes;
 536
 537         if (__percpu_counter_compare(&space_info->total_bytes_pinned,
 538                                    bytes_needed,
 539                                    BTRFS_TOTAL_BYTES_PINNED_BATCH) < 0)
 540                 goto enospc;
 541
 542 commit:
 543         return btrfs_commit_transaction(trans);
 544 enospc:
 545         btrfs_end_transaction(trans);
 546         return -ENOSPC;
 547 }
 548
 549 /*
 550  * Try to flush some data based on policy set by @state. This is only advisory
 551  * and may fail for various reasons. The caller is supposed to examine the
 552  * state of @space_info to detect the outcome.
 553  */
 554 static void flush_space(struct btrfs_fs_info *fs_info,
 555                        struct btrfs_space_info *space_info, u64 num_bytes,
 556                        int state)
 557 {
 558         struct btrfs_root *root = fs_info->extent_root;
 559         struct btrfs_trans_handle *trans;
 560         int nr;
 561         int ret = 0;
 562
 563         switch (state) {
 564         case FLUSH_DELAYED_ITEMS_NR:
 565         case FLUSH_DELAYED_ITEMS:
 566                 if (state == FLUSH_DELAYED_ITEMS_NR)
 567                         nr = calc_reclaim_items_nr(fs_info, num_bytes) * 2;
 568                 else
 569                         nr = -1;
 570
 571                 trans = btrfs_join_transaction(root);
 572                 if (IS_ERR(trans)) {
 573                         ret = PTR_ERR(trans);
 574                         break;
 575                 }
 576                 ret = btrfs_run_delayed_items_nr(trans, nr);
 577                 btrfs_end_transaction(trans);
 578                 break;
 579         case FLUSH_DELALLOC:
 580         case FLUSH_DELALLOC_WAIT:
 581                 shrink_delalloc(fs_info, num_bytes * 2, num_bytes,
 582                                 state == FLUSH_DELALLOC_WAIT);
 583                 break;
 584         case FLUSH_DELAYED_REFS_NR:
 585         case FLUSH_DELAYED_REFS:
 586                 trans = btrfs_join_transaction(root);
 587                 if (IS_ERR(trans)) {
 588                         ret = PTR_ERR(trans);
 589                         break;
 590                 }
 591                 if (state == FLUSH_DELAYED_REFS_NR)
 592                         nr = calc_reclaim_items_nr(fs_info, num_bytes);
 593                 else
 594                         nr = 0;
 595                 btrfs_run_delayed_refs(trans, nr);
 596                 btrfs_end_transaction(trans);
 597                 break;
 598         case ALLOC_CHUNK:
 599         case ALLOC_CHUNK_FORCE:
 600                 trans = btrfs_join_transaction(root);
 601                 if (IS_ERR(trans)) {
 602                         ret = PTR_ERR(trans);
 603                         break;
 604                 }
 605                 ret = btrfs_chunk_alloc(trans,
 606                                 btrfs_metadata_alloc_profile(fs_info),
 607                                 (state == ALLOC_CHUNK) ? CHUNK_ALLOC_NO_FORCE :
 608                                         CHUNK_ALLOC_FORCE);
 609                 btrfs_end_transaction(trans);
 610                 if (ret > 0 || ret == -ENOSPC)
 611                         ret = 0;
 612                 break;
 613         case RUN_DELAYED_IPUTS:
 614                 /*
 615                  * If we have pending delayed iputs then we could free up a
 616                  * bunch of pinned space, so make sure we run the iputs before
 617                  * we do our pinned bytes check below.
 618                  */
 619                 btrfs_run_delayed_iputs(fs_info);
 620                 btrfs_wait_on_delayed_iputs(fs_info);
 621                 break;
 622         case COMMIT_TRANS:
 623                 ret = may_commit_transaction(fs_info, space_info);
 624                 break;
 625         default:
 626                 ret = -ENOSPC;
 627                 break;
 628         }
 629
 630         trace_btrfs_flush_space(fs_info, space_info->flags, num_bytes, state,
 631                                 ret);
 632         return;
 633 }
 634
 635 static inline u64
 636 btrfs_calc_reclaim_metadata_size(struct btrfs_fs_info *fs_info,
 637                                  struct btrfs_space_info *space_info)
 638 {
 639         struct reserve_ticket *ticket;
 640         u64 used;
 641         u64 expected;
 642         u64 to_reclaim = 0;
 643
 644         list_for_each_entry(ticket, &space_info->tickets, list)
 645                 to_reclaim += ticket->bytes;
 646         list_for_each_entry(ticket, &space_info->priority_tickets, list)
 647                 to_reclaim += ticket->bytes;
 648         if (to_reclaim)
 649                 return to_reclaim;
 650
 651         to_reclaim = min_t(u64, num_online_cpus() * SZ_1M, SZ_16M);
 652         if (btrfs_can_overcommit(fs_info, space_info, to_reclaim,
 653                                  BTRFS_RESERVE_FLUSH_ALL))
 654                 return 0;
 655
 656         used = btrfs_space_info_used(space_info, true);
 657
 658         if (btrfs_can_overcommit(fs_info, space_info, SZ_1M,
 659                                  BTRFS_RESERVE_FLUSH_ALL))
 660                 expected = div_factor_fine(space_info->total_bytes, 95);
 661         else
 662                 expected = div_factor_fine(space_info->total_bytes, 90);
 663
 664         if (used > expected)
 665                 to_reclaim = used - expected;
 666         else
 667                 to_reclaim = 0;
 668         to_reclaim = min(to_reclaim, space_info->bytes_may_use +
 669                                      space_info->bytes_reserved);
 670         return to_reclaim;
 671 }
 672
 673 static inline int need_do_async_reclaim(struct btrfs_fs_info *fs_info,
 674                                         struct btrfs_space_info *space_info,
 675                                         u64 used)
 676 {
 677         u64 thresh = div_factor_fine(space_info->total_bytes, 98);
 678
 679         /* If we're just plain full then async reclaim just slows us down. */
 680         if ((space_info->bytes_used + space_info->bytes_reserved) >= thresh)
 681                 return 0;
 682
 683         if (!btrfs_calc_reclaim_metadata_size(fs_info, space_info))
 684                 return 0;
 685
 686         return (used >= thresh && !btrfs_fs_closing(fs_info) &&
 687                 !test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state));
 688 }
 689
 690 static bool steal_from_global_rsv(struct btrfs_fs_info *fs_info,
 691                                   struct btrfs_space_info *space_info,
 692                                   struct reserve_ticket *ticket)
 693 {
 694         struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
 695         u64 min_bytes;
 696
 697         if (global_rsv->space_info != space_info)
 698                 return false;
 699
 700         spin_lock(&global_rsv->lock);
 701         min_bytes = div_factor(global_rsv->size, 5);
 702         if (global_rsv->reserved < min_bytes + ticket->bytes) {
 703                 spin_unlock(&global_rsv->lock);
 704                 return false;
 705         }
 706         global_rsv->reserved -= ticket->bytes;
 707         ticket->bytes = 0;
 708         list_del_init(&ticket->list);
 709         wake_up(&ticket->wait);
 710         space_info->tickets_id++;
 711         if (global_rsv->reserved < global_rsv->size)
 712                 global_rsv->full = 0;
 713         spin_unlock(&global_rsv->lock);
 714
 715         return true;
 716 }
 717
 718 /*
 719  * maybe_fail_all_tickets - we've exhausted our flushing, start failing tickets
 720  * @fs_info - fs_info for this fs
 721  * @space_info - the space info we were flushing
 722  *
 723  * We call this when we've exhausted our flushing ability and haven't made
 724  * progress in satisfying tickets.  The reservation code handles tickets in
 725  * order, so if there is a large ticket first and then smaller ones we could
 726  * very well satisfy the smaller tickets.  This will attempt to wake up any
 727  * tickets in the list to catch this case.
 728  *
 729  * This function returns true if it was able to make progress by clearing out
 730  * other tickets, or if it stumbles across a ticket that was smaller than the
 731  * first ticket.
 732  */
 733 static bool maybe_fail_all_tickets(struct btrfs_fs_info *fs_info,
 734                                    struct btrfs_space_info *space_info)
 735 {
 736         struct reserve_ticket *ticket;
 737         u64 tickets_id = space_info->tickets_id;
 738         u64 first_ticket_bytes = 0;
 739
 740         if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
 741                 btrfs_info(fs_info, "cannot satisfy tickets, dumping space info");
 742                 __btrfs_dump_space_info(fs_info, space_info);
 743         }
 744
 745         while (!list_empty(&space_info->tickets) &&
 746                tickets_id == space_info->tickets_id) {
 747                 ticket = list_first_entry(&space_info->tickets,
 748                                           struct reserve_ticket, list);
 749
 750                 if (ticket->steal &&
 751                     steal_from_global_rsv(fs_info, space_info, ticket))
 752                         return true;
 753
 754                 /*
 755                  * may_commit_transaction will avoid committing the transaction
 756                  * if it doesn't feel like the space reclaimed by the commit
 757                  * would result in the ticket succeeding.  However if we have a
 758                  * smaller ticket in the queue it may be small enough to be
 759                  * satisified by committing the transaction, so if any
 760                  * subsequent ticket is smaller than the first ticket go ahead
 761                  * and send us back for another loop through the enospc flushing
 762                  * code.
 763                  */
 764                 if (first_ticket_bytes == 0)
 765                         first_ticket_bytes = ticket->bytes;
 766                 else if (first_ticket_bytes > ticket->bytes)
 767                         return true;
 768
 769                 if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))
 770                         btrfs_info(fs_info, "failing ticket with %llu bytes",
 771                                    ticket->bytes);
 772
 773                 list_del_init(&ticket->list);
 774                 ticket->error = -ENOSPC;
 775                 wake_up(&ticket->wait);
 776
 777                 /*
 778                  * We're just throwing tickets away, so more flushing may not
 779                  * trip over btrfs_try_granting_tickets, so we need to call it
 780                  * here to see if we can make progress with the next ticket in
 781                  * the list.
 782                  */
 783                 btrfs_try_granting_tickets(fs_info, space_info);
 784         }
 785         return (tickets_id != space_info->tickets_id);
 786 }
 787
 788 /*
 789  * This is for normal flushers, we can wait all goddamned day if we want to.  We
 790  * will loop and continuously try to flush as long as we are making progress.
 791  * We count progress as clearing off tickets each time we have to loop.
 792  */
 793 static void btrfs_async_reclaim_metadata_space(struct work_struct *work)
 794 {
 795         struct btrfs_fs_info *fs_info;
 796         struct btrfs_space_info *space_info;
 797         u64 to_reclaim;
 798         int flush_state;
 799         int commit_cycles = 0;
 800         u64 last_tickets_id;
 801
 802         fs_info = container_of(work, struct btrfs_fs_info, async_reclaim_work);
 803         space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
 804
 805         spin_lock(&space_info->lock);
 806         to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
 807         if (!to_reclaim) {
 808                 space_info->flush = 0;
 809                 spin_unlock(&space_info->lock);
 810                 return;
 811         }
 812         last_tickets_id = space_info->tickets_id;
 813         spin_unlock(&space_info->lock);
 814
 815         flush_state = FLUSH_DELAYED_ITEMS_NR;
 816         do {
 817                 flush_space(fs_info, space_info, to_reclaim, flush_state);
 818                 spin_lock(&space_info->lock);
 819                 if (list_empty(&space_info->tickets)) {
 820                         space_info->flush = 0;
 821                         spin_unlock(&space_info->lock);
 822                         return;
 823                 }
 824                 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info,
 825                                                               space_info);
 826                 if (last_tickets_id == space_info->tickets_id) {
 827                         flush_state++;
 828                 } else {
 829                         last_tickets_id = space_info->tickets_id;
 830                         flush_state = FLUSH_DELAYED_ITEMS_NR;
 831                         if (commit_cycles)
 832                                 commit_cycles--;
 833                 }
 834
 835                 /*
 836                  * We don't want to force a chunk allocation until we've tried
 837                  * pretty hard to reclaim space.  Think of the case where we
 838                  * freed up a bunch of space and so have a lot of pinned space
 839                  * to reclaim.  We would rather use that than possibly create a
 840                  * underutilized metadata chunk.  So if this is our first run
 841                  * through the flushing state machine skip ALLOC_CHUNK_FORCE and
 842                  * commit the transaction.  If nothing has changed the next go
 843                  * around then we can force a chunk allocation.
 844                  */
 845                 if (flush_state == ALLOC_CHUNK_FORCE && !commit_cycles)
 846                         flush_state++;
 847
 848                 if (flush_state > COMMIT_TRANS) {
 849                         commit_cycles++;
 850                         if (commit_cycles > 2) {
 851                                 if (maybe_fail_all_tickets(fs_info, space_info)) {
 852                                         flush_state = FLUSH_DELAYED_ITEMS_NR;
 853                                         commit_cycles--;
 854                                 } else {
 855                                         space_info->flush = 0;
 856                                 }
 857                         } else {
 858                                 flush_state = FLUSH_DELAYED_ITEMS_NR;
 859                         }
 860                 }
 861                 spin_unlock(&space_info->lock);
 862         } while (flush_state <= COMMIT_TRANS);
 863 }
 864
 865 void btrfs_init_async_reclaim_work(struct work_struct *work)
 866 {
 867         INIT_WORK(work, btrfs_async_reclaim_metadata_space);
 868 }
 869
 870 static const enum btrfs_flush_state priority_flush_states[] = {
 871         FLUSH_DELAYED_ITEMS_NR,
 872         FLUSH_DELAYED_ITEMS,
 873         ALLOC_CHUNK,
 874 };
 875
 876 static const enum btrfs_flush_state evict_flush_states[] = {
 877         FLUSH_DELAYED_ITEMS_NR,
 878         FLUSH_DELAYED_ITEMS,
 879         FLUSH_DELAYED_REFS_NR,
 880         FLUSH_DELAYED_REFS,
 881         FLUSH_DELALLOC,
 882         FLUSH_DELALLOC_WAIT,
 883         ALLOC_CHUNK,
 884         COMMIT_TRANS,
 885 };
 886
 887 static void priority_reclaim_metadata_space(struct btrfs_fs_info *fs_info,
 888                                 struct btrfs_space_info *space_info,
 889                                 struct reserve_ticket *ticket,
 890                                 const enum btrfs_flush_state *states,
 891                                 int states_nr)
 892 {
 893         u64 to_reclaim;
 894         int flush_state;
 895
 896         spin_lock(&space_info->lock);
 897         to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
 898         if (!to_reclaim) {
 899                 spin_unlock(&space_info->lock);
 900                 return;
 901         }
 902         spin_unlock(&space_info->lock);
 903
 904         flush_state = 0;
 905         do {
 906                 flush_space(fs_info, space_info, to_reclaim, states[flush_state]);
 907                 flush_state++;
 908                 spin_lock(&space_info->lock);
 909                 if (ticket->bytes == 0) {
 910                         spin_unlock(&space_info->lock);
 911                         return;
 912                 }
 913                 spin_unlock(&space_info->lock);
 914         } while (flush_state < states_nr);
 915 }
 916
 917 static void wait_reserve_ticket(struct btrfs_fs_info *fs_info,
 918                                 struct btrfs_space_info *space_info,
 919                                 struct reserve_ticket *ticket)
 920
 921 {
 922         DEFINE_WAIT(wait);
 923         int ret = 0;
 924
 925         spin_lock(&space_info->lock);
 926         while (ticket->bytes > 0 && ticket->error == 0) {
 927                 ret = prepare_to_wait_event(&ticket->wait, &wait, TASK_KILLABLE);
 928                 if (ret) {
 929                         /*
 930                          * Delete us from the list. After we unlock the space
 931                          * info, we don't want the async reclaim job to reserve
 932                          * space for this ticket. If that would happen, then the
 933                          * ticket's task would not known that space was reserved
 934                          * despite getting an error, resulting in a space leak
 935                          * (bytes_may_use counter of our space_info).
 936                          */
 937                         list_del_init(&ticket->list);
 938                         ticket->error = -EINTR;
 939                         break;
 940                 }
 941                 spin_unlock(&space_info->lock);
 942
 943                 schedule();
 944
 945                 finish_wait(&ticket->wait, &wait);
 946                 spin_lock(&space_info->lock);
 947         }
 948         spin_unlock(&space_info->lock);
 949 }
 950
 951 /**
 952  * handle_reserve_ticket - do the appropriate flushing and waiting for a ticket
 953  * @fs_info - the fs
 954  * @space_info - the space_info for the reservation
 955  * @ticket - the ticket for the reservation
 956  * @flush - how much we can flush
 957  *
 958  * This does the work of figuring out how to flush for the ticket, waiting for
 959  * the reservation, and returning the appropriate error if there is one.
 960  */
 961 static int handle_reserve_ticket(struct btrfs_fs_info *fs_info,
 962                                  struct btrfs_space_info *space_info,
 963                                  struct reserve_ticket *ticket,
 964                                  enum btrfs_reserve_flush_enum flush)
 965 {
 966         int ret;
 967
 968         switch (flush) {
 969         case BTRFS_RESERVE_FLUSH_ALL:
 970         case BTRFS_RESERVE_FLUSH_ALL_STEAL:
 971                 wait_reserve_ticket(fs_info, space_info, ticket);
 972                 break;
 973         case BTRFS_RESERVE_FLUSH_LIMIT:
 974                 priority_reclaim_metadata_space(fs_info, space_info, ticket,
 975                                                 priority_flush_states,
 976                                                 ARRAY_SIZE(priority_flush_states));
 977                 break;
 978         case BTRFS_RESERVE_FLUSH_EVICT:
 979                 priority_reclaim_metadata_space(fs_info, space_info, ticket,
 980                                                 evict_flush_states,
 981                                                 ARRAY_SIZE(evict_flush_states));
 982                 break;
 983         default:
 984                 ASSERT(0);
 985                 break;
 986         }
 987
 988         spin_lock(&space_info->lock);
 989         ret = ticket->error;
 990         if (ticket->bytes || ticket->error) {
 991                 /*
 992                  * Need to delete here for priority tickets. For regular tickets
 993                  * either the async reclaim job deletes the ticket from the list
 994                  * or we delete it ourselves at wait_reserve_ticket().
 995                  */
 996                 list_del_init(&ticket->list);
 997                 if (!ret)
 998                         ret = -ENOSPC;
 999         }
1000         spin_unlock(&space_info->lock);
1001         ASSERT(list_empty(&ticket->list));
1002         /*
1003          * Check that we can't have an error set if the reservation succeeded,
1004          * as that would confuse tasks and lead them to error out without
1005          * releasing reserved space (if an error happens the expectation is that
1006          * space wasn't reserved at all).
1007          */
1008         ASSERT(!(ticket->bytes == 0 && ticket->error));
1009         return ret;
1010 }
1011
1012 /**
1013  * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
1014  * @root - the root we're allocating for
1015  * @space_info - the space info we want to allocate from
1016  * @orig_bytes - the number of bytes we want
1017  * @flush - whether or not we can flush to make our reservation
1018  *
1019  * This will reserve orig_bytes number of bytes from the space info associated
1020  * with the block_rsv.  If there is not enough space it will make an attempt to
1021  * flush out space to make room.  It will do this by flushing delalloc if
1022  * possible or committing the transaction.  If flush is 0 then no attempts to
1023  * regain reservations will be made and this will fail if there is not enough
1024  * space already.
1025  */
1026 static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info,
1027                                     struct btrfs_space_info *space_info,
1028                                     u64 orig_bytes,
1029                                     enum btrfs_reserve_flush_enum flush)
1030 {
1031         struct reserve_ticket ticket;
1032         u64 used;
1033         int ret = 0;
1034         bool pending_tickets;
1035
1036         ASSERT(orig_bytes);
1037         ASSERT(!current->journal_info || flush != BTRFS_RESERVE_FLUSH_ALL);
1038
1039         spin_lock(&space_info->lock);
1040         ret = -ENOSPC;
1041         used = btrfs_space_info_used(space_info, true);
1042         pending_tickets = !list_empty(&space_info->tickets) ||
1043                 !list_empty(&space_info->priority_tickets);
1044
1045         /*
1046          * Carry on if we have enough space (short-circuit) OR call
1047          * can_overcommit() to ensure we can overcommit to continue.
1048          */
1049         if (!pending_tickets &&
1050             ((used + orig_bytes <= space_info->total_bytes) ||
1051              btrfs_can_overcommit(fs_info, space_info, orig_bytes, flush))) {
1052                 btrfs_space_info_update_bytes_may_use(fs_info, space_info,
1053                                                       orig_bytes);
1054                 ret = 0;
1055         }
1056
1057         /*
1058          * If we couldn't make a reservation then setup our reservation ticket
1059          * and kick the async worker if it's not already running.
1060          *
1061          * If we are a priority flusher then we just need to add our ticket to
1062          * the list and we will do our own flushing further down.
1063          */
1064         if (ret && flush != BTRFS_RESERVE_NO_FLUSH) {
1065                 ticket.bytes = orig_bytes;
1066                 ticket.error = 0;
1067                 init_waitqueue_head(&ticket.wait);
1068                 ticket.steal = (flush == BTRFS_RESERVE_FLUSH_ALL_STEAL);
1069                 if (flush == BTRFS_RESERVE_FLUSH_ALL ||
1070                     flush == BTRFS_RESERVE_FLUSH_ALL_STEAL) {
1071                         list_add_tail(&ticket.list, &space_info->tickets);
1072                         if (!space_info->flush) {
1073                                 space_info->flush = 1;
1074                                 trace_btrfs_trigger_flush(fs_info,
1075                                                           space_info->flags,
1076                                                           orig_bytes, flush,
1077                                                           "enospc");
1078                                 queue_work(system_unbound_wq,
1079                                            &fs_info->async_reclaim_work);
1080                         }
1081                 } else {
1082                         list_add_tail(&ticket.list,
1083                                       &space_info->priority_tickets);
1084                 }
1085         } else if (!ret && space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {
1086                 used += orig_bytes;
1087                 /*
1088                  * We will do the space reservation dance during log replay,
1089                  * which means we won't have fs_info->fs_root set, so don't do
1090                  * the async reclaim as we will panic.
1091                  */
1092                 if (!test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags) &&
1093                     need_do_async_reclaim(fs_info, space_info, used) &&
1094                     !work_busy(&fs_info->async_reclaim_work)) {
1095                         trace_btrfs_trigger_flush(fs_info, space_info->flags,
1096                                                   orig_bytes, flush, "preempt");
1097                         queue_work(system_unbound_wq,
1098                                    &fs_info->async_reclaim_work);
1099                 }
1100         }
1101         spin_unlock(&space_info->lock);
1102         if (!ret || flush == BTRFS_RESERVE_NO_FLUSH)
1103                 return ret;
1104
1105         return handle_reserve_ticket(fs_info, space_info, &ticket, flush);
1106 }
1107
1108 /**
1109  * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
1110  * @root - the root we're allocating for
1111  * @block_rsv - the block_rsv we're allocating for
1112  * @orig_bytes - the number of bytes we want
1113  * @flush - whether or not we can flush to make our reservation
1114  *
1115  * This will reserve orig_bytes number of bytes from the space info associated
1116  * with the block_rsv.  If there is not enough space it will make an attempt to
1117  * flush out space to make room.  It will do this by flushing delalloc if
1118  * possible or committing the transaction.  If flush is 0 then no attempts to
1119  * regain reservations will be made and this will fail if there is not enough
1120  * space already.
1121  */
1122 int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
1123                                  struct btrfs_block_rsv *block_rsv,
1124                                  u64 orig_bytes,
1125                                  enum btrfs_reserve_flush_enum flush)
1126 {
1127         struct btrfs_fs_info *fs_info = root->fs_info;
1128         struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
1129         int ret;
1130
1131         ret = __reserve_metadata_bytes(fs_info, block_rsv->space_info,
1132                                        orig_bytes, flush);
1133         if (ret == -ENOSPC &&
1134             unlikely(root->orphan_cleanup_state == ORPHAN_CLEANUP_STARTED)) {
1135                 if (block_rsv != global_rsv &&
1136                     !btrfs_block_rsv_use_bytes(global_rsv, orig_bytes))
1137                         ret = 0;
1138         }
1139         if (ret == -ENOSPC) {
1140                 trace_btrfs_space_reservation(fs_info, "space_info:enospc",
1141                                               block_rsv->space_info->flags,
1142                                               orig_bytes, 1);
1143
1144                 if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))
1145                         btrfs_dump_space_info(fs_info, block_rsv->space_info,
1146                                               orig_bytes, 0);
1147         }
1148         return ret;
1149 }