1 // SPDX-License-Identifier: GPL-2.0
5 #include "space-info.h"
8 #include "free-space-cache.h"
9 #include "ordered-data.h"
10 #include "transaction.h"
11 #include "block-group.h"
13 u64 __pure btrfs_space_info_used(struct btrfs_space_info *s_info,
14 bool may_use_included)
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);
23 * after adding space to the filesystem, we need to clear the full flags
24 * on all the space infos.
26 void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
28 struct list_head *head = &info->space_info;
29 struct btrfs_space_info *found;
32 list_for_each_entry_rcu(found, head, list)
37 static int create_space_info(struct btrfs_fs_info *info, u64 flags)
40 struct btrfs_space_info *space_info;
44 space_info = kzalloc(sizeof(*space_info), GFP_NOFS);
48 ret = percpu_counter_init(&space_info->total_bytes_pinned, 0,
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_LIST_HEAD(&space_info->ro_bgs);
62 INIT_LIST_HEAD(&space_info->tickets);
63 INIT_LIST_HEAD(&space_info->priority_tickets);
65 ret = btrfs_sysfs_add_space_info_type(info, space_info);
69 list_add_rcu(&space_info->list, &info->space_info);
70 if (flags & BTRFS_BLOCK_GROUP_DATA)
71 info->data_sinfo = space_info;
76 int btrfs_init_space_info(struct btrfs_fs_info *fs_info)
78 struct btrfs_super_block *disk_super;
84 disk_super = fs_info->super_copy;
85 if (!btrfs_super_root(disk_super))
88 features = btrfs_super_incompat_flags(disk_super);
89 if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
92 flags = BTRFS_BLOCK_GROUP_SYSTEM;
93 ret = create_space_info(fs_info, flags);
98 flags = BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA;
99 ret = create_space_info(fs_info, flags);
101 flags = BTRFS_BLOCK_GROUP_METADATA;
102 ret = create_space_info(fs_info, flags);
106 flags = BTRFS_BLOCK_GROUP_DATA;
107 ret = create_space_info(fs_info, flags);
113 void btrfs_update_space_info(struct btrfs_fs_info *info, u64 flags,
114 u64 total_bytes, u64 bytes_used,
116 struct btrfs_space_info **space_info)
118 struct btrfs_space_info *found;
121 factor = btrfs_bg_type_to_factor(flags);
123 found = btrfs_find_space_info(info, flags);
125 spin_lock(&found->lock);
126 found->total_bytes += total_bytes;
127 found->disk_total += total_bytes * factor;
128 found->bytes_used += bytes_used;
129 found->disk_used += bytes_used * factor;
130 found->bytes_readonly += bytes_readonly;
133 btrfs_try_granting_tickets(info, found);
134 spin_unlock(&found->lock);
138 struct btrfs_space_info *btrfs_find_space_info(struct btrfs_fs_info *info,
141 struct list_head *head = &info->space_info;
142 struct btrfs_space_info *found;
144 flags &= BTRFS_BLOCK_GROUP_TYPE_MASK;
147 list_for_each_entry_rcu(found, head, list) {
148 if (found->flags & flags) {
157 static inline u64 calc_global_rsv_need_space(struct btrfs_block_rsv *global)
159 return (global->size << 1);
162 int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,
163 struct btrfs_space_info *space_info, u64 bytes,
164 enum btrfs_reserve_flush_enum flush)
171 /* Don't overcommit when in mixed mode. */
172 if (space_info->flags & BTRFS_BLOCK_GROUP_DATA)
175 if (space_info->flags & BTRFS_BLOCK_GROUP_SYSTEM)
176 profile = btrfs_system_alloc_profile(fs_info);
178 profile = btrfs_metadata_alloc_profile(fs_info);
180 used = btrfs_space_info_used(space_info, true);
181 avail = atomic64_read(&fs_info->free_chunk_space);
184 * If we have dup, raid1 or raid10 then only half of the free
185 * space is actually usable. For raid56, the space info used
186 * doesn't include the parity drive, so we don't have to
189 factor = btrfs_bg_type_to_factor(profile);
190 avail = div_u64(avail, factor);
193 * If we aren't flushing all things, let us overcommit up to
194 * 1/2th of the space. If we can flush, don't let us overcommit
195 * too much, let it overcommit up to 1/8 of the space.
197 if (flush == BTRFS_RESERVE_FLUSH_ALL)
202 if (used + bytes < space_info->total_bytes + avail)
208 * This is for space we already have accounted in space_info->bytes_may_use, so
209 * basically when we're returning space from block_rsv's.
211 void btrfs_try_granting_tickets(struct btrfs_fs_info *fs_info,
212 struct btrfs_space_info *space_info)
214 struct list_head *head;
215 enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_NO_FLUSH;
217 lockdep_assert_held(&space_info->lock);
219 head = &space_info->priority_tickets;
221 while (!list_empty(head)) {
222 struct reserve_ticket *ticket;
223 u64 used = btrfs_space_info_used(space_info, true);
225 ticket = list_first_entry(head, struct reserve_ticket, list);
227 /* Check and see if our ticket can be satisified now. */
228 if ((used + ticket->bytes <= space_info->total_bytes) ||
229 btrfs_can_overcommit(fs_info, space_info, ticket->bytes,
231 btrfs_space_info_update_bytes_may_use(fs_info,
234 list_del_init(&ticket->list);
236 space_info->tickets_id++;
237 wake_up(&ticket->wait);
243 if (head == &space_info->priority_tickets) {
244 head = &space_info->tickets;
245 flush = BTRFS_RESERVE_FLUSH_ALL;
250 #define DUMP_BLOCK_RSV(fs_info, rsv_name) \
252 struct btrfs_block_rsv *__rsv = &(fs_info)->rsv_name; \
253 spin_lock(&__rsv->lock); \
254 btrfs_info(fs_info, #rsv_name ": size %llu reserved %llu", \
255 __rsv->size, __rsv->reserved); \
256 spin_unlock(&__rsv->lock); \
259 static void __btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
260 struct btrfs_space_info *info)
262 lockdep_assert_held(&info->lock);
264 btrfs_info(fs_info, "space_info %llu has %llu free, is %sfull",
266 info->total_bytes - btrfs_space_info_used(info, true),
267 info->full ? "" : "not ");
269 "space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu",
270 info->total_bytes, info->bytes_used, info->bytes_pinned,
271 info->bytes_reserved, info->bytes_may_use,
272 info->bytes_readonly);
274 DUMP_BLOCK_RSV(fs_info, global_block_rsv);
275 DUMP_BLOCK_RSV(fs_info, trans_block_rsv);
276 DUMP_BLOCK_RSV(fs_info, chunk_block_rsv);
277 DUMP_BLOCK_RSV(fs_info, delayed_block_rsv);
278 DUMP_BLOCK_RSV(fs_info, delayed_refs_rsv);
282 void btrfs_dump_space_info(struct btrfs_fs_info *fs_info,
283 struct btrfs_space_info *info, u64 bytes,
284 int dump_block_groups)
286 struct btrfs_block_group *cache;
289 spin_lock(&info->lock);
290 __btrfs_dump_space_info(fs_info, info);
291 spin_unlock(&info->lock);
293 if (!dump_block_groups)
296 down_read(&info->groups_sem);
298 list_for_each_entry(cache, &info->block_groups[index], list) {
299 spin_lock(&cache->lock);
301 "block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %s",
302 cache->start, cache->length, cache->used, cache->pinned,
303 cache->reserved, cache->ro ? "[readonly]" : "");
304 btrfs_dump_free_space(cache, bytes);
305 spin_unlock(&cache->lock);
307 if (++index < BTRFS_NR_RAID_TYPES)
309 up_read(&info->groups_sem);
312 static void btrfs_writeback_inodes_sb_nr(struct btrfs_fs_info *fs_info,
313 unsigned long nr_pages, int nr_items)
315 struct super_block *sb = fs_info->sb;
317 if (down_read_trylock(&sb->s_umount)) {
318 writeback_inodes_sb_nr(sb, nr_pages, WB_REASON_FS_FREE_SPACE);
319 up_read(&sb->s_umount);
322 * We needn't worry the filesystem going from r/w to r/o though
323 * we don't acquire ->s_umount mutex, because the filesystem
324 * should guarantee the delalloc inodes list be empty after
325 * the filesystem is readonly(all dirty pages are written to
328 btrfs_start_delalloc_roots(fs_info, nr_items);
329 if (!current->journal_info)
330 btrfs_wait_ordered_roots(fs_info, nr_items, 0, (u64)-1);
334 static inline u64 calc_reclaim_items_nr(struct btrfs_fs_info *fs_info,
340 bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
341 nr = div64_u64(to_reclaim, bytes);
347 #define EXTENT_SIZE_PER_ITEM SZ_256K
350 * shrink metadata reservation for delalloc
352 static void shrink_delalloc(struct btrfs_fs_info *fs_info, u64 to_reclaim,
353 u64 orig, bool wait_ordered)
355 struct btrfs_space_info *space_info;
356 struct btrfs_trans_handle *trans;
362 unsigned long nr_pages;
365 /* Calc the number of the pages we need flush for space reservation */
366 items = calc_reclaim_items_nr(fs_info, to_reclaim);
367 to_reclaim = items * EXTENT_SIZE_PER_ITEM;
369 trans = (struct btrfs_trans_handle *)current->journal_info;
370 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
372 delalloc_bytes = percpu_counter_sum_positive(
373 &fs_info->delalloc_bytes);
374 dio_bytes = percpu_counter_sum_positive(&fs_info->dio_bytes);
375 if (delalloc_bytes == 0 && dio_bytes == 0) {
379 btrfs_wait_ordered_roots(fs_info, items, 0, (u64)-1);
384 * If we are doing more ordered than delalloc we need to just wait on
385 * ordered extents, otherwise we'll waste time trying to flush delalloc
386 * that likely won't give us the space back we need.
388 if (dio_bytes > delalloc_bytes)
392 while ((delalloc_bytes || dio_bytes) && loops < 3) {
393 nr_pages = min(delalloc_bytes, to_reclaim) >> PAGE_SHIFT;
396 * Triggers inode writeback for up to nr_pages. This will invoke
397 * ->writepages callback and trigger delalloc filling
398 * (btrfs_run_delalloc_range()).
400 btrfs_writeback_inodes_sb_nr(fs_info, nr_pages, items);
403 * We need to wait for the compressed pages to start before
406 async_pages = atomic_read(&fs_info->async_delalloc_pages);
411 * Calculate how many compressed pages we want to be written
412 * before we continue. I.e if there are more async pages than we
413 * require wait_event will wait until nr_pages are written.
415 if (async_pages <= nr_pages)
418 async_pages -= nr_pages;
420 wait_event(fs_info->async_submit_wait,
421 atomic_read(&fs_info->async_delalloc_pages) <=
424 spin_lock(&space_info->lock);
425 if (list_empty(&space_info->tickets) &&
426 list_empty(&space_info->priority_tickets)) {
427 spin_unlock(&space_info->lock);
430 spin_unlock(&space_info->lock);
433 if (wait_ordered && !trans) {
434 btrfs_wait_ordered_roots(fs_info, items, 0, (u64)-1);
436 time_left = schedule_timeout_killable(1);
440 delalloc_bytes = percpu_counter_sum_positive(
441 &fs_info->delalloc_bytes);
442 dio_bytes = percpu_counter_sum_positive(&fs_info->dio_bytes);
447 * maybe_commit_transaction - possibly commit the transaction if its ok to
448 * @root - the root we're allocating for
449 * @bytes - the number of bytes we want to reserve
450 * @force - force the commit
452 * This will check to make sure that committing the transaction will actually
453 * get us somewhere and then commit the transaction if it does. Otherwise it
454 * will return -ENOSPC.
456 static int may_commit_transaction(struct btrfs_fs_info *fs_info,
457 struct btrfs_space_info *space_info)
459 struct reserve_ticket *ticket = NULL;
460 struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_block_rsv;
461 struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
462 struct btrfs_trans_handle *trans;
464 u64 reclaim_bytes = 0;
465 u64 cur_free_bytes = 0;
467 trans = (struct btrfs_trans_handle *)current->journal_info;
471 spin_lock(&space_info->lock);
472 cur_free_bytes = btrfs_space_info_used(space_info, true);
473 if (cur_free_bytes < space_info->total_bytes)
474 cur_free_bytes = space_info->total_bytes - cur_free_bytes;
478 if (!list_empty(&space_info->priority_tickets))
479 ticket = list_first_entry(&space_info->priority_tickets,
480 struct reserve_ticket, list);
481 else if (!list_empty(&space_info->tickets))
482 ticket = list_first_entry(&space_info->tickets,
483 struct reserve_ticket, list);
484 bytes_needed = (ticket) ? ticket->bytes : 0;
486 if (bytes_needed > cur_free_bytes)
487 bytes_needed -= cur_free_bytes;
490 spin_unlock(&space_info->lock);
495 trans = btrfs_join_transaction(fs_info->extent_root);
497 return PTR_ERR(trans);
500 * See if there is enough pinned space to make this reservation, or if
501 * we have block groups that are going to be freed, allowing us to
502 * possibly do a chunk allocation the next loop through.
504 if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags) ||
505 __percpu_counter_compare(&space_info->total_bytes_pinned,
507 BTRFS_TOTAL_BYTES_PINNED_BATCH) >= 0)
511 * See if there is some space in the delayed insertion reservation for
514 if (space_info != delayed_rsv->space_info)
517 spin_lock(&delayed_rsv->lock);
518 reclaim_bytes += delayed_rsv->reserved;
519 spin_unlock(&delayed_rsv->lock);
521 spin_lock(&delayed_refs_rsv->lock);
522 reclaim_bytes += delayed_refs_rsv->reserved;
523 spin_unlock(&delayed_refs_rsv->lock);
524 if (reclaim_bytes >= bytes_needed)
526 bytes_needed -= reclaim_bytes;
528 if (__percpu_counter_compare(&space_info->total_bytes_pinned,
530 BTRFS_TOTAL_BYTES_PINNED_BATCH) < 0)
534 return btrfs_commit_transaction(trans);
536 btrfs_end_transaction(trans);
541 * Try to flush some data based on policy set by @state. This is only advisory
542 * and may fail for various reasons. The caller is supposed to examine the
543 * state of @space_info to detect the outcome.
545 static void flush_space(struct btrfs_fs_info *fs_info,
546 struct btrfs_space_info *space_info, u64 num_bytes,
549 struct btrfs_root *root = fs_info->extent_root;
550 struct btrfs_trans_handle *trans;
555 case FLUSH_DELAYED_ITEMS_NR:
556 case FLUSH_DELAYED_ITEMS:
557 if (state == FLUSH_DELAYED_ITEMS_NR)
558 nr = calc_reclaim_items_nr(fs_info, num_bytes) * 2;
562 trans = btrfs_join_transaction(root);
564 ret = PTR_ERR(trans);
567 ret = btrfs_run_delayed_items_nr(trans, nr);
568 btrfs_end_transaction(trans);
571 case FLUSH_DELALLOC_WAIT:
572 shrink_delalloc(fs_info, num_bytes * 2, num_bytes,
573 state == FLUSH_DELALLOC_WAIT);
575 case FLUSH_DELAYED_REFS_NR:
576 case FLUSH_DELAYED_REFS:
577 trans = btrfs_join_transaction(root);
579 ret = PTR_ERR(trans);
582 if (state == FLUSH_DELAYED_REFS_NR)
583 nr = calc_reclaim_items_nr(fs_info, num_bytes);
586 btrfs_run_delayed_refs(trans, nr);
587 btrfs_end_transaction(trans);
590 case ALLOC_CHUNK_FORCE:
591 trans = btrfs_join_transaction(root);
593 ret = PTR_ERR(trans);
596 ret = btrfs_chunk_alloc(trans,
597 btrfs_metadata_alloc_profile(fs_info),
598 (state == ALLOC_CHUNK) ? CHUNK_ALLOC_NO_FORCE :
600 btrfs_end_transaction(trans);
601 if (ret > 0 || ret == -ENOSPC)
604 case RUN_DELAYED_IPUTS:
606 * If we have pending delayed iputs then we could free up a
607 * bunch of pinned space, so make sure we run the iputs before
608 * we do our pinned bytes check below.
610 btrfs_run_delayed_iputs(fs_info);
611 btrfs_wait_on_delayed_iputs(fs_info);
614 ret = may_commit_transaction(fs_info, space_info);
621 trace_btrfs_flush_space(fs_info, space_info->flags, num_bytes, state,
627 btrfs_calc_reclaim_metadata_size(struct btrfs_fs_info *fs_info,
628 struct btrfs_space_info *space_info)
630 struct reserve_ticket *ticket;
635 list_for_each_entry(ticket, &space_info->tickets, list)
636 to_reclaim += ticket->bytes;
637 list_for_each_entry(ticket, &space_info->priority_tickets, list)
638 to_reclaim += ticket->bytes;
642 to_reclaim = min_t(u64, num_online_cpus() * SZ_1M, SZ_16M);
643 if (btrfs_can_overcommit(fs_info, space_info, to_reclaim,
644 BTRFS_RESERVE_FLUSH_ALL))
647 used = btrfs_space_info_used(space_info, true);
649 if (btrfs_can_overcommit(fs_info, space_info, SZ_1M,
650 BTRFS_RESERVE_FLUSH_ALL))
651 expected = div_factor_fine(space_info->total_bytes, 95);
653 expected = div_factor_fine(space_info->total_bytes, 90);
656 to_reclaim = used - expected;
659 to_reclaim = min(to_reclaim, space_info->bytes_may_use +
660 space_info->bytes_reserved);
664 static inline int need_do_async_reclaim(struct btrfs_fs_info *fs_info,
665 struct btrfs_space_info *space_info,
668 u64 thresh = div_factor_fine(space_info->total_bytes, 98);
670 /* If we're just plain full then async reclaim just slows us down. */
671 if ((space_info->bytes_used + space_info->bytes_reserved) >= thresh)
674 if (!btrfs_calc_reclaim_metadata_size(fs_info, space_info))
677 return (used >= thresh && !btrfs_fs_closing(fs_info) &&
678 !test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state));
682 * maybe_fail_all_tickets - we've exhausted our flushing, start failing tickets
683 * @fs_info - fs_info for this fs
684 * @space_info - the space info we were flushing
686 * We call this when we've exhausted our flushing ability and haven't made
687 * progress in satisfying tickets. The reservation code handles tickets in
688 * order, so if there is a large ticket first and then smaller ones we could
689 * very well satisfy the smaller tickets. This will attempt to wake up any
690 * tickets in the list to catch this case.
692 * This function returns true if it was able to make progress by clearing out
693 * other tickets, or if it stumbles across a ticket that was smaller than the
696 static bool maybe_fail_all_tickets(struct btrfs_fs_info *fs_info,
697 struct btrfs_space_info *space_info)
699 struct reserve_ticket *ticket;
700 u64 tickets_id = space_info->tickets_id;
701 u64 first_ticket_bytes = 0;
703 if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) {
704 btrfs_info(fs_info, "cannot satisfy tickets, dumping space info");
705 __btrfs_dump_space_info(fs_info, space_info);
708 while (!list_empty(&space_info->tickets) &&
709 tickets_id == space_info->tickets_id) {
710 ticket = list_first_entry(&space_info->tickets,
711 struct reserve_ticket, list);
714 * may_commit_transaction will avoid committing the transaction
715 * if it doesn't feel like the space reclaimed by the commit
716 * would result in the ticket succeeding. However if we have a
717 * smaller ticket in the queue it may be small enough to be
718 * satisified by committing the transaction, so if any
719 * subsequent ticket is smaller than the first ticket go ahead
720 * and send us back for another loop through the enospc flushing
723 if (first_ticket_bytes == 0)
724 first_ticket_bytes = ticket->bytes;
725 else if (first_ticket_bytes > ticket->bytes)
728 if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))
729 btrfs_info(fs_info, "failing ticket with %llu bytes",
732 list_del_init(&ticket->list);
733 ticket->error = -ENOSPC;
734 wake_up(&ticket->wait);
737 * We're just throwing tickets away, so more flushing may not
738 * trip over btrfs_try_granting_tickets, so we need to call it
739 * here to see if we can make progress with the next ticket in
742 btrfs_try_granting_tickets(fs_info, space_info);
744 return (tickets_id != space_info->tickets_id);
748 * This is for normal flushers, we can wait all goddamned day if we want to. We
749 * will loop and continuously try to flush as long as we are making progress.
750 * We count progress as clearing off tickets each time we have to loop.
752 static void btrfs_async_reclaim_metadata_space(struct work_struct *work)
754 struct btrfs_fs_info *fs_info;
755 struct btrfs_space_info *space_info;
758 int commit_cycles = 0;
761 fs_info = container_of(work, struct btrfs_fs_info, async_reclaim_work);
762 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
764 spin_lock(&space_info->lock);
765 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
767 space_info->flush = 0;
768 spin_unlock(&space_info->lock);
771 last_tickets_id = space_info->tickets_id;
772 spin_unlock(&space_info->lock);
774 flush_state = FLUSH_DELAYED_ITEMS_NR;
776 flush_space(fs_info, space_info, to_reclaim, flush_state);
777 spin_lock(&space_info->lock);
778 if (list_empty(&space_info->tickets)) {
779 space_info->flush = 0;
780 spin_unlock(&space_info->lock);
783 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info,
785 if (last_tickets_id == space_info->tickets_id) {
788 last_tickets_id = space_info->tickets_id;
789 flush_state = FLUSH_DELAYED_ITEMS_NR;
795 * We don't want to force a chunk allocation until we've tried
796 * pretty hard to reclaim space. Think of the case where we
797 * freed up a bunch of space and so have a lot of pinned space
798 * to reclaim. We would rather use that than possibly create a
799 * underutilized metadata chunk. So if this is our first run
800 * through the flushing state machine skip ALLOC_CHUNK_FORCE and
801 * commit the transaction. If nothing has changed the next go
802 * around then we can force a chunk allocation.
804 if (flush_state == ALLOC_CHUNK_FORCE && !commit_cycles)
807 if (flush_state > COMMIT_TRANS) {
809 if (commit_cycles > 2) {
810 if (maybe_fail_all_tickets(fs_info, space_info)) {
811 flush_state = FLUSH_DELAYED_ITEMS_NR;
814 space_info->flush = 0;
817 flush_state = FLUSH_DELAYED_ITEMS_NR;
820 spin_unlock(&space_info->lock);
821 } while (flush_state <= COMMIT_TRANS);
824 void btrfs_init_async_reclaim_work(struct work_struct *work)
826 INIT_WORK(work, btrfs_async_reclaim_metadata_space);
829 static const enum btrfs_flush_state priority_flush_states[] = {
830 FLUSH_DELAYED_ITEMS_NR,
835 static const enum btrfs_flush_state evict_flush_states[] = {
836 FLUSH_DELAYED_ITEMS_NR,
838 FLUSH_DELAYED_REFS_NR,
846 static void priority_reclaim_metadata_space(struct btrfs_fs_info *fs_info,
847 struct btrfs_space_info *space_info,
848 struct reserve_ticket *ticket,
849 const enum btrfs_flush_state *states,
855 spin_lock(&space_info->lock);
856 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
858 spin_unlock(&space_info->lock);
861 spin_unlock(&space_info->lock);
865 flush_space(fs_info, space_info, to_reclaim, states[flush_state]);
867 spin_lock(&space_info->lock);
868 if (ticket->bytes == 0) {
869 spin_unlock(&space_info->lock);
872 spin_unlock(&space_info->lock);
873 } while (flush_state < states_nr);
876 static void wait_reserve_ticket(struct btrfs_fs_info *fs_info,
877 struct btrfs_space_info *space_info,
878 struct reserve_ticket *ticket)
884 spin_lock(&space_info->lock);
885 while (ticket->bytes > 0 && ticket->error == 0) {
886 ret = prepare_to_wait_event(&ticket->wait, &wait, TASK_KILLABLE);
889 * Delete us from the list. After we unlock the space
890 * info, we don't want the async reclaim job to reserve
891 * space for this ticket. If that would happen, then the
892 * ticket's task would not known that space was reserved
893 * despite getting an error, resulting in a space leak
894 * (bytes_may_use counter of our space_info).
896 list_del_init(&ticket->list);
897 ticket->error = -EINTR;
900 spin_unlock(&space_info->lock);
904 finish_wait(&ticket->wait, &wait);
905 spin_lock(&space_info->lock);
907 spin_unlock(&space_info->lock);
911 * handle_reserve_ticket - do the appropriate flushing and waiting for a ticket
913 * @space_info - the space_info for the reservation
914 * @ticket - the ticket for the reservation
915 * @flush - how much we can flush
917 * This does the work of figuring out how to flush for the ticket, waiting for
918 * the reservation, and returning the appropriate error if there is one.
920 static int handle_reserve_ticket(struct btrfs_fs_info *fs_info,
921 struct btrfs_space_info *space_info,
922 struct reserve_ticket *ticket,
923 enum btrfs_reserve_flush_enum flush)
928 case BTRFS_RESERVE_FLUSH_ALL:
929 wait_reserve_ticket(fs_info, space_info, ticket);
931 case BTRFS_RESERVE_FLUSH_LIMIT:
932 priority_reclaim_metadata_space(fs_info, space_info, ticket,
933 priority_flush_states,
934 ARRAY_SIZE(priority_flush_states));
936 case BTRFS_RESERVE_FLUSH_EVICT:
937 priority_reclaim_metadata_space(fs_info, space_info, ticket,
939 ARRAY_SIZE(evict_flush_states));
946 spin_lock(&space_info->lock);
948 if (ticket->bytes || ticket->error) {
950 * Need to delete here for priority tickets. For regular tickets
951 * either the async reclaim job deletes the ticket from the list
952 * or we delete it ourselves at wait_reserve_ticket().
954 list_del_init(&ticket->list);
958 spin_unlock(&space_info->lock);
959 ASSERT(list_empty(&ticket->list));
961 * Check that we can't have an error set if the reservation succeeded,
962 * as that would confuse tasks and lead them to error out without
963 * releasing reserved space (if an error happens the expectation is that
964 * space wasn't reserved at all).
966 ASSERT(!(ticket->bytes == 0 && ticket->error));
971 * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
972 * @root - the root we're allocating for
973 * @space_info - the space info we want to allocate from
974 * @orig_bytes - the number of bytes we want
975 * @flush - whether or not we can flush to make our reservation
977 * This will reserve orig_bytes number of bytes from the space info associated
978 * with the block_rsv. If there is not enough space it will make an attempt to
979 * flush out space to make room. It will do this by flushing delalloc if
980 * possible or committing the transaction. If flush is 0 then no attempts to
981 * regain reservations will be made and this will fail if there is not enough
984 static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info,
985 struct btrfs_space_info *space_info,
987 enum btrfs_reserve_flush_enum flush)
989 struct reserve_ticket ticket;
992 bool pending_tickets;
995 ASSERT(!current->journal_info || flush != BTRFS_RESERVE_FLUSH_ALL);
997 spin_lock(&space_info->lock);
999 used = btrfs_space_info_used(space_info, true);
1000 pending_tickets = !list_empty(&space_info->tickets) ||
1001 !list_empty(&space_info->priority_tickets);
1004 * Carry on if we have enough space (short-circuit) OR call
1005 * can_overcommit() to ensure we can overcommit to continue.
1007 if (!pending_tickets &&
1008 ((used + orig_bytes <= space_info->total_bytes) ||
1009 btrfs_can_overcommit(fs_info, space_info, orig_bytes, flush))) {
1010 btrfs_space_info_update_bytes_may_use(fs_info, space_info,
1016 * If we couldn't make a reservation then setup our reservation ticket
1017 * and kick the async worker if it's not already running.
1019 * If we are a priority flusher then we just need to add our ticket to
1020 * the list and we will do our own flushing further down.
1022 if (ret && flush != BTRFS_RESERVE_NO_FLUSH) {
1023 ticket.bytes = orig_bytes;
1025 init_waitqueue_head(&ticket.wait);
1026 if (flush == BTRFS_RESERVE_FLUSH_ALL) {
1027 list_add_tail(&ticket.list, &space_info->tickets);
1028 if (!space_info->flush) {
1029 space_info->flush = 1;
1030 trace_btrfs_trigger_flush(fs_info,
1034 queue_work(system_unbound_wq,
1035 &fs_info->async_reclaim_work);
1038 list_add_tail(&ticket.list,
1039 &space_info->priority_tickets);
1041 } else if (!ret && space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {
1044 * We will do the space reservation dance during log replay,
1045 * which means we won't have fs_info->fs_root set, so don't do
1046 * the async reclaim as we will panic.
1048 if (!test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags) &&
1049 need_do_async_reclaim(fs_info, space_info, used) &&
1050 !work_busy(&fs_info->async_reclaim_work)) {
1051 trace_btrfs_trigger_flush(fs_info, space_info->flags,
1052 orig_bytes, flush, "preempt");
1053 queue_work(system_unbound_wq,
1054 &fs_info->async_reclaim_work);
1057 spin_unlock(&space_info->lock);
1058 if (!ret || flush == BTRFS_RESERVE_NO_FLUSH)
1061 return handle_reserve_ticket(fs_info, space_info, &ticket, flush);
1065 * reserve_metadata_bytes - try to reserve bytes from the block_rsv's space
1066 * @root - the root we're allocating for
1067 * @block_rsv - the block_rsv we're allocating for
1068 * @orig_bytes - the number of bytes we want
1069 * @flush - whether or not we can flush to make our reservation
1071 * This will reserve orig_bytes number of bytes from the space info associated
1072 * with the block_rsv. If there is not enough space it will make an attempt to
1073 * flush out space to make room. It will do this by flushing delalloc if
1074 * possible or committing the transaction. If flush is 0 then no attempts to
1075 * regain reservations will be made and this will fail if there is not enough
1078 int btrfs_reserve_metadata_bytes(struct btrfs_root *root,
1079 struct btrfs_block_rsv *block_rsv,
1081 enum btrfs_reserve_flush_enum flush)
1083 struct btrfs_fs_info *fs_info = root->fs_info;
1084 struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
1087 ret = __reserve_metadata_bytes(fs_info, block_rsv->space_info,
1089 if (ret == -ENOSPC &&
1090 unlikely(root->orphan_cleanup_state == ORPHAN_CLEANUP_STARTED)) {
1091 if (block_rsv != global_rsv &&
1092 !btrfs_block_rsv_use_bytes(global_rsv, orig_bytes))
1095 if (ret == -ENOSPC) {
1096 trace_btrfs_space_reservation(fs_info, "space_info:enospc",
1097 block_rsv->space_info->flags,
1100 if (btrfs_test_opt(fs_info, ENOSPC_DEBUG))
1101 btrfs_dump_space_info(fs_info, block_rsv->space_info,