Lines Matching +full:i +full:- +full:cache +full:- +full:block +full:- +full:size
1 // SPDX-License-Identifier: GPL-2.0
7 #include "block-group.h"
8 #include "space-info.h"
9 #include "disk-io.h"
10 #include "free-space-cache.h"
11 #include "free-space-tree.h"
14 #include "ref-verify.h"
16 #include "tree-log.h"
17 #include "delalloc-space.h"
23 #include "extent-tree.h"
28 struct btrfs_fs_info *fs_info = block_group->fs_info; in btrfs_should_fragment_free_space()
31 block_group->flags & BTRFS_BLOCK_GROUP_METADATA) || in btrfs_should_fragment_free_space()
33 block_group->flags & BTRFS_BLOCK_GROUP_DATA); in btrfs_should_fragment_free_space()
40 if (!btrfs_is_zoned(block_group->fs_info)) in has_unwritten_metadata()
43 if (block_group->flags & BTRFS_BLOCK_GROUP_DATA) in has_unwritten_metadata()
46 return block_group->start + block_group->alloc_offset > in has_unwritten_metadata()
47 block_group->meta_write_pointer; in has_unwritten_metadata()
58 const struct btrfs_balance_control *bctl = fs_info->balance_ctl; in get_restripe_target()
65 bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) { in get_restripe_target()
66 target = BTRFS_BLOCK_GROUP_DATA | bctl->data.target; in get_restripe_target()
68 bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) { in get_restripe_target()
69 target = BTRFS_BLOCK_GROUP_SYSTEM | bctl->sys.target; in get_restripe_target()
71 bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) { in get_restripe_target()
72 target = BTRFS_BLOCK_GROUP_METADATA | bctl->meta.target; in get_restripe_target()
87 u64 num_devices = fs_info->fs_devices->rw_devices; in btrfs_reduce_alloc_profile()
96 spin_lock(&fs_info->balance_lock); in btrfs_reduce_alloc_profile()
99 spin_unlock(&fs_info->balance_lock); in btrfs_reduce_alloc_profile()
102 spin_unlock(&fs_info->balance_lock); in btrfs_reduce_alloc_profile()
111 /* Select the highest-redundancy RAID level. */ in btrfs_reduce_alloc_profile()
141 seq = read_seqbegin(&fs_info->profiles_lock); in btrfs_get_alloc_profile()
144 flags |= fs_info->avail_data_alloc_bits; in btrfs_get_alloc_profile()
146 flags |= fs_info->avail_system_alloc_bits; in btrfs_get_alloc_profile()
148 flags |= fs_info->avail_metadata_alloc_bits; in btrfs_get_alloc_profile()
149 } while (read_seqretry(&fs_info->profiles_lock, seq)); in btrfs_get_alloc_profile()
154 void btrfs_get_block_group(struct btrfs_block_group *cache) in btrfs_get_block_group() argument
156 refcount_inc(&cache->refs); in btrfs_get_block_group()
159 void btrfs_put_block_group(struct btrfs_block_group *cache) in btrfs_put_block_group() argument
161 if (refcount_dec_and_test(&cache->refs)) { in btrfs_put_block_group()
162 WARN_ON(cache->pinned > 0); in btrfs_put_block_group()
170 if (!(cache->flags & BTRFS_BLOCK_GROUP_METADATA) || in btrfs_put_block_group()
171 !BTRFS_FS_LOG_CLEANUP_ERROR(cache->fs_info)) in btrfs_put_block_group()
172 WARN_ON(cache->reserved > 0); in btrfs_put_block_group()
179 if (WARN_ON(!list_empty(&cache->discard_list))) in btrfs_put_block_group()
180 btrfs_discard_cancel_work(&cache->fs_info->discard_ctl, in btrfs_put_block_group()
181 cache); in btrfs_put_block_group()
183 kfree(cache->free_space_ctl); in btrfs_put_block_group()
184 btrfs_free_chunk_map(cache->physical_map); in btrfs_put_block_group()
185 kfree(cache); in btrfs_put_block_group()
197 if (new_bg->start < exist_bg->start) in btrfs_bg_start_cmp()
198 return -1; in btrfs_bg_start_cmp()
199 if (new_bg->start > exist_bg->start) in btrfs_bg_start_cmp()
205 * This adds the block group to the fs_info rb tree for the block group cache
209 struct btrfs_fs_info *fs_info = block_group->fs_info; in btrfs_add_block_group_cache()
213 ASSERT(block_group->length != 0); in btrfs_add_block_group_cache()
215 write_lock(&fs_info->block_group_cache_lock); in btrfs_add_block_group_cache()
217 exist = rb_find_add_cached(&block_group->cache_node, in btrfs_add_block_group_cache()
218 &fs_info->block_group_cache_tree, btrfs_bg_start_cmp); in btrfs_add_block_group_cache()
220 ret = -EEXIST; in btrfs_add_block_group_cache()
221 write_unlock(&fs_info->block_group_cache_lock); in btrfs_add_block_group_cache()
227 * This will return the block group at or after bytenr if contains is 0, else
228 * it will return the block group that contains the bytenr
233 struct btrfs_block_group *cache, *ret = NULL; in block_group_cache_tree_search() local
237 read_lock(&info->block_group_cache_lock); in block_group_cache_tree_search()
238 n = info->block_group_cache_tree.rb_root.rb_node; in block_group_cache_tree_search()
241 cache = rb_entry(n, struct btrfs_block_group, cache_node); in block_group_cache_tree_search()
242 end = cache->start + cache->length - 1; in block_group_cache_tree_search()
243 start = cache->start; in block_group_cache_tree_search()
246 if (!contains && (!ret || start < ret->start)) in block_group_cache_tree_search()
247 ret = cache; in block_group_cache_tree_search()
248 n = n->rb_left; in block_group_cache_tree_search()
251 ret = cache; in block_group_cache_tree_search()
254 n = n->rb_right; in block_group_cache_tree_search()
256 ret = cache; in block_group_cache_tree_search()
262 read_unlock(&info->block_group_cache_lock); in block_group_cache_tree_search()
268 * Return the block group that starts at or after bytenr
277 * Return the block group that contains the given bytenr
286 struct btrfs_block_group *cache) in btrfs_next_block_group() argument
288 struct btrfs_fs_info *fs_info = cache->fs_info; in btrfs_next_block_group()
291 read_lock(&fs_info->block_group_cache_lock); in btrfs_next_block_group()
293 /* If our block group was removed, we need a full search. */ in btrfs_next_block_group()
294 if (RB_EMPTY_NODE(&cache->cache_node)) { in btrfs_next_block_group()
295 const u64 next_bytenr = cache->start + cache->length; in btrfs_next_block_group()
297 read_unlock(&fs_info->block_group_cache_lock); in btrfs_next_block_group()
298 btrfs_put_block_group(cache); in btrfs_next_block_group()
301 node = rb_next(&cache->cache_node); in btrfs_next_block_group()
302 btrfs_put_block_group(cache); in btrfs_next_block_group()
304 cache = rb_entry(node, struct btrfs_block_group, cache_node); in btrfs_next_block_group()
305 btrfs_get_block_group(cache); in btrfs_next_block_group()
307 cache = NULL; in btrfs_next_block_group()
308 read_unlock(&fs_info->block_group_cache_lock); in btrfs_next_block_group()
309 return cache; in btrfs_next_block_group()
319 * number of NOCOW writers in the block group that contains the extent, as long
320 * as the block group exists and it's currently not in read-only mode.
322 * Returns: A non-NULL block group pointer if we can do a NOCOW write, the caller
337 spin_lock(&bg->lock); in btrfs_inc_nocow_writers()
338 if (bg->ro) in btrfs_inc_nocow_writers()
341 atomic_inc(&bg->nocow_writers); in btrfs_inc_nocow_writers()
342 spin_unlock(&bg->lock); in btrfs_inc_nocow_writers()
349 /* No put on block group, done by btrfs_dec_nocow_writers(). */ in btrfs_inc_nocow_writers()
354 * Decrement the number of NOCOW writers in a block group.
357 * and on the block group returned by that call. Typically this is called after
361 * After this call, the caller should not use the block group anymore. It it wants
366 if (atomic_dec_and_test(&bg->nocow_writers)) in btrfs_dec_nocow_writers()
367 wake_up_var(&bg->nocow_writers); in btrfs_dec_nocow_writers()
375 wait_var_event(&bg->nocow_writers, !atomic_read(&bg->nocow_writers)); in btrfs_wait_nocow_writers()
385 if (atomic_dec_and_test(&bg->reservations)) in btrfs_dec_block_group_reservations()
386 wake_up_var(&bg->reservations); in btrfs_dec_block_group_reservations()
392 struct btrfs_space_info *space_info = bg->space_info; in btrfs_wait_block_group_reservations()
394 ASSERT(bg->ro); in btrfs_wait_block_group_reservations()
396 if (!(bg->flags & BTRFS_BLOCK_GROUP_DATA)) in btrfs_wait_block_group_reservations()
400 * Our block group is read only but before we set it to read only, in btrfs_wait_block_group_reservations()
405 * block group's reservations counter is incremented while a read lock in btrfs_wait_block_group_reservations()
409 down_write(&space_info->groups_sem); in btrfs_wait_block_group_reservations()
410 up_write(&space_info->groups_sem); in btrfs_wait_block_group_reservations()
412 wait_var_event(&bg->reservations, !atomic_read(&bg->reservations)); in btrfs_wait_block_group_reservations()
416 struct btrfs_block_group *cache) in btrfs_get_caching_control() argument
420 spin_lock(&cache->lock); in btrfs_get_caching_control()
421 if (!cache->caching_ctl) { in btrfs_get_caching_control()
422 spin_unlock(&cache->lock); in btrfs_get_caching_control()
426 ctl = cache->caching_ctl; in btrfs_get_caching_control()
427 refcount_inc(&ctl->count); in btrfs_get_caching_control()
428 spin_unlock(&cache->lock); in btrfs_get_caching_control()
434 if (refcount_dec_and_test(&ctl->count)) in btrfs_put_caching_control()
439 * When we wait for progress in the block group caching, its because our
444 * up, and then it will check the block group free space numbers for our min
446 * a free extent of a given size, but this is a good start.
448 * Callers of this must check if cache->cached == BTRFS_CACHE_ERROR before using
449 * any of the information in this block group.
451 void btrfs_wait_block_group_cache_progress(struct btrfs_block_group *cache, in btrfs_wait_block_group_cache_progress() argument
457 caching_ctl = btrfs_get_caching_control(cache); in btrfs_wait_block_group_cache_progress()
462 * We've already failed to allocate from this block group, so even if in btrfs_wait_block_group_cache_progress()
463 * there's enough space in the block group it isn't contiguous enough to in btrfs_wait_block_group_cache_progress()
467 progress = atomic_read(&caching_ctl->progress); in btrfs_wait_block_group_cache_progress()
469 wait_event(caching_ctl->wait, btrfs_block_group_done(cache) || in btrfs_wait_block_group_cache_progress()
470 (progress != atomic_read(&caching_ctl->progress) && in btrfs_wait_block_group_cache_progress()
471 (cache->free_space_ctl->free_space >= num_bytes))); in btrfs_wait_block_group_cache_progress()
476 static int btrfs_caching_ctl_wait_done(struct btrfs_block_group *cache, in btrfs_caching_ctl_wait_done() argument
479 wait_event(caching_ctl->wait, btrfs_block_group_done(cache)); in btrfs_caching_ctl_wait_done()
480 return cache->cached == BTRFS_CACHE_ERROR ? -EIO : 0; in btrfs_caching_ctl_wait_done()
483 static int btrfs_wait_block_group_cache_done(struct btrfs_block_group *cache) in btrfs_wait_block_group_cache_done() argument
488 caching_ctl = btrfs_get_caching_control(cache); in btrfs_wait_block_group_cache_done()
490 return (cache->cached == BTRFS_CACHE_ERROR) ? -EIO : 0; in btrfs_wait_block_group_cache_done()
491 ret = btrfs_caching_ctl_wait_done(cache, caching_ctl); in btrfs_wait_block_group_cache_done()
499 struct btrfs_fs_info *fs_info = block_group->fs_info; in fragment_free_space()
500 u64 start = block_group->start; in fragment_free_space()
501 u64 len = block_group->length; in fragment_free_space()
502 u64 chunk = block_group->flags & BTRFS_BLOCK_GROUP_METADATA ? in fragment_free_space()
503 fs_info->nodesize : fs_info->sectorsize; in fragment_free_space()
512 len -= step; in fragment_free_space()
518 * Add a free space range to the in memory free space cache of a block group.
519 * This checks if the range contains super block locations and any such
520 * locations are not added to the free space cache.
522 * @block_group: The target block group.
526 * added to the block group's free space cache.
533 struct btrfs_fs_info *info = block_group->fs_info; in btrfs_add_new_free_space()
534 u64 extent_start, extent_end, size; in btrfs_add_new_free_space() local
541 if (!btrfs_find_first_extent_bit(&info->excluded_extents, start, in btrfs_add_new_free_space()
549 size = extent_start - start; in btrfs_add_new_free_space()
551 start, size); in btrfs_add_new_free_space()
555 *total_added_ret += size; in btrfs_add_new_free_space()
563 size = end - start; in btrfs_add_new_free_space()
565 size); in btrfs_add_new_free_space()
569 *total_added_ret += size; in btrfs_add_new_free_space()
576 * Get an arbitrary extent item index / max_index through the block group
578 * @block_group the block group to sample from
579 * @index: the integral step through the block group to grab from
583 * Pre-conditions on indices:
595 struct btrfs_fs_info *fs_info = block_group->fs_info; in sample_block_group_extent_item()
598 u64 search_end = block_group->start + block_group->length; in sample_block_group_extent_item()
606 lockdep_assert_held(&caching_ctl->mutex); in sample_block_group_extent_item()
607 lockdep_assert_held_read(&fs_info->commit_root_sem); in sample_block_group_extent_item()
611 return -ENOMEM; in sample_block_group_extent_item()
613 extent_root = btrfs_extent_root(fs_info, max_t(u64, block_group->start, in sample_block_group_extent_item()
616 path->skip_locking = 1; in sample_block_group_extent_item()
617 path->search_commit_root = 1; in sample_block_group_extent_item()
618 path->reada = READA_FORWARD; in sample_block_group_extent_item()
620 search_offset = index * div_u64(block_group->length, max_index); in sample_block_group_extent_item()
621 search_key.objectid = block_group->start + search_offset; in sample_block_group_extent_item()
626 /* Success; sampled an extent item in the block group */ in sample_block_group_extent_item()
627 if (found_key->type == BTRFS_EXTENT_ITEM_KEY && in sample_block_group_extent_item()
628 found_key->objectid >= block_group->start && in sample_block_group_extent_item()
629 found_key->objectid + found_key->offset <= search_end) in sample_block_group_extent_item()
633 if (found_key->objectid >= search_end) { in sample_block_group_extent_item()
639 lockdep_assert_held(&caching_ctl->mutex); in sample_block_group_extent_item()
640 lockdep_assert_held_read(&fs_info->commit_root_sem); in sample_block_group_extent_item()
645 * Best effort attempt to compute a block group's size class while caching it.
647 * @block_group: the block group we are caching
649 * We cannot infer the size class while adding free space extents, because that
654 * them at even steps through the block group and pick the smallest size class
655 * we see. Since size class is best effort, and not guaranteed in general,
660 * If we are caching in a block group from disk, then there are three major cases
662 * 1. the block group is well behaved and all extents in it are the same size
664 * 2. the block group is mostly one size class with rare exceptions for last
666 * 3. the block group was populated before size classes and can have a totally
667 * arbitrary mix of size classes.
669 * In case 1, looking at any extent in the block group will yield the correct
670 * result. For the mixed cases, taking the minimum size class seems like a good
671 * approximation, since gaps from frees will be usable to the size class. For
681 struct btrfs_fs_info *fs_info = block_group->fs_info; in load_block_group_size_class()
683 int i; in load_block_group_size_class() local
684 u64 min_size = block_group->length; in load_block_group_size_class()
691 lockdep_assert_held(&caching_ctl->mutex); in load_block_group_size_class()
692 lockdep_assert_held_read(&fs_info->commit_root_sem); in load_block_group_size_class()
693 for (i = 0; i < 5; ++i) { in load_block_group_size_class()
694 ret = sample_block_group_extent_item(caching_ctl, block_group, i, 5, &key); in load_block_group_size_class()
703 spin_lock(&block_group->lock); in load_block_group_size_class()
704 block_group->size_class = size_class; in load_block_group_size_class()
705 spin_unlock(&block_group->lock); in load_block_group_size_class()
713 struct btrfs_block_group *block_group = caching_ctl->block_group; in load_extent_tree_free()
714 struct btrfs_fs_info *fs_info = block_group->fs_info; in load_extent_tree_free()
727 return -ENOMEM; in load_extent_tree_free()
729 last = max_t(u64, block_group->start, BTRFS_SUPER_INFO_OFFSET); in load_extent_tree_free()
735 * allocate from this block group until we've had a chance to fragment in load_extent_tree_free()
745 * root, since its read-only in load_extent_tree_free()
747 path->skip_locking = 1; in load_extent_tree_free()
748 path->search_commit_root = 1; in load_extent_tree_free()
749 path->reada = READA_FORWARD; in load_extent_tree_free()
760 leaf = path->nodes[0]; in load_extent_tree_free()
765 last = (u64)-1; in load_extent_tree_free()
769 if (path->slots[0] < nritems) { in load_extent_tree_free()
770 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); in load_extent_tree_free()
777 rwsem_is_contended(&fs_info->commit_root_sem)) { in load_extent_tree_free()
779 up_read(&fs_info->commit_root_sem); in load_extent_tree_free()
780 mutex_unlock(&caching_ctl->mutex); in load_extent_tree_free()
782 mutex_lock(&caching_ctl->mutex); in load_extent_tree_free()
783 down_read(&fs_info->commit_root_sem); in load_extent_tree_free()
792 leaf = path->nodes[0]; in load_extent_tree_free()
805 if (key.objectid < block_group->start) { in load_extent_tree_free()
806 path->slots[0]++; in load_extent_tree_free()
810 if (key.objectid >= block_group->start + block_group->length) in load_extent_tree_free()
824 fs_info->nodesize; in load_extent_tree_free()
831 atomic_inc(&caching_ctl->progress); in load_extent_tree_free()
832 wake_up(&caching_ctl->wait); in load_extent_tree_free()
836 path->slots[0]++; in load_extent_tree_free()
840 block_group->start + block_group->length, in load_extent_tree_free()
848 btrfs_clear_extent_bit(&bg->fs_info->excluded_extents, bg->start, in btrfs_free_excluded_extents()
849 bg->start + bg->length - 1, EXTENT_DIRTY, NULL); in btrfs_free_excluded_extents()
860 block_group = caching_ctl->block_group; in caching_thread()
861 fs_info = block_group->fs_info; in caching_thread()
863 mutex_lock(&caching_ctl->mutex); in caching_thread()
864 down_read(&fs_info->commit_root_sem); in caching_thread()
875 * We failed to load the space cache, set ourselves to in caching_thread()
878 spin_lock(&block_group->lock); in caching_thread()
879 block_group->cached = BTRFS_CACHE_STARTED; in caching_thread()
880 spin_unlock(&block_group->lock); in caching_thread()
881 wake_up(&caching_ctl->wait); in caching_thread()
886 * can't actually cache from the free space tree as our commit root and in caching_thread()
892 !(test_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags))) in caching_thread()
897 spin_lock(&block_group->lock); in caching_thread()
898 block_group->caching_ctl = NULL; in caching_thread()
899 block_group->cached = ret ? BTRFS_CACHE_ERROR : BTRFS_CACHE_FINISHED; in caching_thread()
900 spin_unlock(&block_group->lock); in caching_thread()
906 spin_lock(&block_group->space_info->lock); in caching_thread()
907 spin_lock(&block_group->lock); in caching_thread()
908 bytes_used = block_group->length - block_group->used; in caching_thread()
909 block_group->space_info->bytes_used += bytes_used >> 1; in caching_thread()
910 spin_unlock(&block_group->lock); in caching_thread()
911 spin_unlock(&block_group->space_info->lock); in caching_thread()
916 up_read(&fs_info->commit_root_sem); in caching_thread()
918 mutex_unlock(&caching_ctl->mutex); in caching_thread()
920 wake_up(&caching_ctl->wait); in caching_thread()
926 int btrfs_cache_block_group(struct btrfs_block_group *cache, bool wait) in btrfs_cache_block_group() argument
928 struct btrfs_fs_info *fs_info = cache->fs_info; in btrfs_cache_block_group()
932 /* Allocator for zoned filesystems does not use the cache at all */ in btrfs_cache_block_group()
938 return -ENOMEM; in btrfs_cache_block_group()
940 INIT_LIST_HEAD(&caching_ctl->list); in btrfs_cache_block_group()
941 mutex_init(&caching_ctl->mutex); in btrfs_cache_block_group()
942 init_waitqueue_head(&caching_ctl->wait); in btrfs_cache_block_group()
943 caching_ctl->block_group = cache; in btrfs_cache_block_group()
944 refcount_set(&caching_ctl->count, 2); in btrfs_cache_block_group()
945 atomic_set(&caching_ctl->progress, 0); in btrfs_cache_block_group()
946 btrfs_init_work(&caching_ctl->work, caching_thread, NULL); in btrfs_cache_block_group()
948 spin_lock(&cache->lock); in btrfs_cache_block_group()
949 if (cache->cached != BTRFS_CACHE_NO) { in btrfs_cache_block_group()
952 caching_ctl = cache->caching_ctl; in btrfs_cache_block_group()
954 refcount_inc(&caching_ctl->count); in btrfs_cache_block_group()
955 spin_unlock(&cache->lock); in btrfs_cache_block_group()
958 WARN_ON(cache->caching_ctl); in btrfs_cache_block_group()
959 cache->caching_ctl = caching_ctl; in btrfs_cache_block_group()
960 cache->cached = BTRFS_CACHE_STARTED; in btrfs_cache_block_group()
961 spin_unlock(&cache->lock); in btrfs_cache_block_group()
963 write_lock(&fs_info->block_group_cache_lock); in btrfs_cache_block_group()
964 refcount_inc(&caching_ctl->count); in btrfs_cache_block_group()
965 list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups); in btrfs_cache_block_group()
966 write_unlock(&fs_info->block_group_cache_lock); in btrfs_cache_block_group()
968 btrfs_get_block_group(cache); in btrfs_cache_block_group()
970 btrfs_queue_work(fs_info->caching_workers, &caching_ctl->work); in btrfs_cache_block_group()
973 ret = btrfs_caching_ctl_wait_done(cache, caching_ctl); in btrfs_cache_block_group()
985 write_seqlock(&fs_info->profiles_lock); in clear_avail_alloc_bits()
987 fs_info->avail_data_alloc_bits &= ~extra_flags; in clear_avail_alloc_bits()
989 fs_info->avail_metadata_alloc_bits &= ~extra_flags; in clear_avail_alloc_bits()
991 fs_info->avail_system_alloc_bits &= ~extra_flags; in clear_avail_alloc_bits()
992 write_sequnlock(&fs_info->profiles_lock); in clear_avail_alloc_bits()
998 * - RAID56 - in case there's neither RAID5 nor RAID6 profile block group
1001 * - RAID1C34 - same as above for RAID1C3 and RAID1C4 block groups
1011 struct list_head *head = &fs_info->space_info; in clear_incompat_bg_bits()
1015 down_read(&sinfo->groups_sem); in clear_incompat_bg_bits()
1016 if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID5])) in clear_incompat_bg_bits()
1018 if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID6])) in clear_incompat_bg_bits()
1020 if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID1C3])) in clear_incompat_bg_bits()
1022 if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID1C4])) in clear_incompat_bg_bits()
1024 up_read(&sinfo->groups_sem); in clear_incompat_bg_bits()
1036 return fs_info->block_group_root; in btrfs_block_group_root()
1044 struct btrfs_fs_info *fs_info = trans->fs_info; in remove_block_group_item()
1050 key.objectid = block_group->start; in remove_block_group_item()
1052 key.offset = block_group->length; in remove_block_group_item()
1054 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); in remove_block_group_item()
1056 ret = -ENOENT; in remove_block_group_item()
1067 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_remove_block_group()
1080 block_group = btrfs_lookup_block_group(fs_info, map->start); in btrfs_remove_block_group()
1082 return -ENOENT; in btrfs_remove_block_group()
1084 BUG_ON(!block_group->ro); in btrfs_remove_block_group()
1088 * Free the reserved super bytes from this block group before in btrfs_remove_block_group()
1092 btrfs_free_ref_tree_range(fs_info, block_group->start, in btrfs_remove_block_group()
1093 block_group->length); in btrfs_remove_block_group()
1095 index = btrfs_bg_flags_to_raid_index(block_group->flags); in btrfs_remove_block_group()
1096 factor = btrfs_bg_type_to_factor(block_group->flags); in btrfs_remove_block_group()
1098 /* make sure this block group isn't part of an allocation cluster */ in btrfs_remove_block_group()
1099 cluster = &fs_info->data_alloc_cluster; in btrfs_remove_block_group()
1100 spin_lock(&cluster->refill_lock); in btrfs_remove_block_group()
1102 spin_unlock(&cluster->refill_lock); in btrfs_remove_block_group()
1105 * make sure this block group isn't part of a metadata in btrfs_remove_block_group()
1108 cluster = &fs_info->meta_alloc_cluster; in btrfs_remove_block_group()
1109 spin_lock(&cluster->refill_lock); in btrfs_remove_block_group()
1111 spin_unlock(&cluster->refill_lock); in btrfs_remove_block_group()
1118 ret = -ENOMEM; in btrfs_remove_block_group()
1128 mutex_lock(&trans->transaction->cache_write_mutex); in btrfs_remove_block_group()
1130 * Make sure our free space cache IO is done before removing the in btrfs_remove_block_group()
1133 spin_lock(&trans->transaction->dirty_bgs_lock); in btrfs_remove_block_group()
1134 if (!list_empty(&block_group->io_list)) { in btrfs_remove_block_group()
1135 list_del_init(&block_group->io_list); in btrfs_remove_block_group()
1137 WARN_ON(!IS_ERR(inode) && inode != block_group->io_ctl.inode); in btrfs_remove_block_group()
1139 spin_unlock(&trans->transaction->dirty_bgs_lock); in btrfs_remove_block_group()
1142 spin_lock(&trans->transaction->dirty_bgs_lock); in btrfs_remove_block_group()
1145 if (!list_empty(&block_group->dirty_list)) { in btrfs_remove_block_group()
1146 list_del_init(&block_group->dirty_list); in btrfs_remove_block_group()
1150 spin_unlock(&trans->transaction->dirty_bgs_lock); in btrfs_remove_block_group()
1151 mutex_unlock(&trans->transaction->cache_write_mutex); in btrfs_remove_block_group()
1157 write_lock(&fs_info->block_group_cache_lock); in btrfs_remove_block_group()
1158 rb_erase_cached(&block_group->cache_node, in btrfs_remove_block_group()
1159 &fs_info->block_group_cache_tree); in btrfs_remove_block_group()
1160 RB_CLEAR_NODE(&block_group->cache_node); in btrfs_remove_block_group()
1162 /* Once for the block groups rbtree */ in btrfs_remove_block_group()
1165 write_unlock(&fs_info->block_group_cache_lock); in btrfs_remove_block_group()
1167 down_write(&block_group->space_info->groups_sem); in btrfs_remove_block_group()
1172 list_del_init(&block_group->list); in btrfs_remove_block_group()
1173 if (list_empty(&block_group->space_info->block_groups[index])) { in btrfs_remove_block_group()
1174 kobj = block_group->space_info->block_group_kobjs[index]; in btrfs_remove_block_group()
1175 block_group->space_info->block_group_kobjs[index] = NULL; in btrfs_remove_block_group()
1176 clear_avail_alloc_bits(fs_info, block_group->flags); in btrfs_remove_block_group()
1178 up_write(&block_group->space_info->groups_sem); in btrfs_remove_block_group()
1179 clear_incompat_bg_bits(fs_info, block_group->flags); in btrfs_remove_block_group()
1185 if (block_group->cached == BTRFS_CACHE_STARTED) in btrfs_remove_block_group()
1188 write_lock(&fs_info->block_group_cache_lock); in btrfs_remove_block_group()
1193 list_for_each_entry(ctl, &fs_info->caching_block_groups, list) { in btrfs_remove_block_group()
1194 if (ctl->block_group == block_group) { in btrfs_remove_block_group()
1196 refcount_inc(&caching_ctl->count); in btrfs_remove_block_group()
1202 list_del_init(&caching_ctl->list); in btrfs_remove_block_group()
1203 write_unlock(&fs_info->block_group_cache_lock); in btrfs_remove_block_group()
1211 spin_lock(&trans->transaction->dirty_bgs_lock); in btrfs_remove_block_group()
1212 WARN_ON(!list_empty(&block_group->dirty_list)); in btrfs_remove_block_group()
1213 WARN_ON(!list_empty(&block_group->io_list)); in btrfs_remove_block_group()
1214 spin_unlock(&trans->transaction->dirty_bgs_lock); in btrfs_remove_block_group()
1218 spin_lock(&block_group->space_info->lock); in btrfs_remove_block_group()
1219 list_del_init(&block_group->ro_list); in btrfs_remove_block_group()
1222 WARN_ON(block_group->space_info->total_bytes in btrfs_remove_block_group()
1223 < block_group->length); in btrfs_remove_block_group()
1224 WARN_ON(block_group->space_info->bytes_readonly in btrfs_remove_block_group()
1225 < block_group->length - block_group->zone_unusable); in btrfs_remove_block_group()
1226 WARN_ON(block_group->space_info->bytes_zone_unusable in btrfs_remove_block_group()
1227 < block_group->zone_unusable); in btrfs_remove_block_group()
1228 WARN_ON(block_group->space_info->disk_total in btrfs_remove_block_group()
1229 < block_group->length * factor); in btrfs_remove_block_group()
1231 block_group->space_info->total_bytes -= block_group->length; in btrfs_remove_block_group()
1232 block_group->space_info->bytes_readonly -= in btrfs_remove_block_group()
1233 (block_group->length - block_group->zone_unusable); in btrfs_remove_block_group()
1234 btrfs_space_info_update_bytes_zone_unusable(block_group->space_info, in btrfs_remove_block_group()
1235 -block_group->zone_unusable); in btrfs_remove_block_group()
1236 block_group->space_info->disk_total -= block_group->length * factor; in btrfs_remove_block_group()
1238 spin_unlock(&block_group->space_info->lock); in btrfs_remove_block_group()
1241 * Remove the free space for the block group from the free space tree in btrfs_remove_block_group()
1242 * and the block group's item from the extent tree before marking the in btrfs_remove_block_group()
1243 * block group as removed. This is to prevent races with tasks that in btrfs_remove_block_group()
1244 * freeze and unfreeze a block group, this task and another task in btrfs_remove_block_group()
1245 * allocating a new block group - the unfreeze task ends up removing in btrfs_remove_block_group()
1246 * the block group's extent map before the task calling this function in btrfs_remove_block_group()
1247 * deletes the block group item from the extent tree, allowing for in btrfs_remove_block_group()
1248 * another task to attempt to create another block group with the same in btrfs_remove_block_group()
1249 * item key (and failing with -EEXIST and a transaction abort). in btrfs_remove_block_group()
1259 spin_lock(&block_group->lock); in btrfs_remove_block_group()
1261 * Hitting this WARN means we removed a block group with an unwritten in btrfs_remove_block_group()
1266 "block group %llu is removed before metadata write out", in btrfs_remove_block_group()
1267 block_group->start); in btrfs_remove_block_group()
1269 set_bit(BLOCK_GROUP_FLAG_REMOVED, &block_group->runtime_flags); in btrfs_remove_block_group()
1272 * At this point trimming or scrub can't start on this block group, in btrfs_remove_block_group()
1273 * because we removed the block group from the rbtree in btrfs_remove_block_group()
1274 * fs_info->block_group_cache_tree so no one can't find it anymore and in btrfs_remove_block_group()
1275 * even if someone already got this block group before we removed it in btrfs_remove_block_group()
1276 * from the rbtree, they have already incremented block_group->frozen - in btrfs_remove_block_group()
1281 * And we must not remove the chunk map from the fs_info->mapping_tree in btrfs_remove_block_group()
1283 * ranges from being reused for a new block group. This is needed to in btrfs_remove_block_group()
1289 * allowing for new block groups to be created that can reuse the same in btrfs_remove_block_group()
1293 * is mounted with -odiscard. The same protections must remain in btrfs_remove_block_group()
1297 remove_map = (atomic_read(&block_group->frozen) == 0); in btrfs_remove_block_group()
1298 spin_unlock(&block_group->lock); in btrfs_remove_block_group()
1321 ASSERT(map->start == chunk_offset); in btrfs_start_trans_remove_block_group()
1325 * to remove a block group (done at btrfs_remove_chunk() and at in btrfs_start_trans_remove_block_group()
1330 * 1 unit for deleting the block group item (located in the extent in btrfs_start_trans_remove_block_group()
1337 * In order to remove a block group we also need to reserve units in the in btrfs_start_trans_remove_block_group()
1342 num_items = 3 + map->num_stripes; in btrfs_start_trans_remove_block_group()
1349 * Mark block group @cache read-only, so later write won't happen to block
1350 * group @cache.
1352 * If @force is not set, this function will only mark the block group readonly
1353 * if we have enough free space (1M) in other metadata/system block groups.
1354 * If @force is not set, this function will mark the block group readonly
1357 * NOTE: This function doesn't care if other block groups can contain all the
1358 * data in this block group. That check should be done by relocation routine,
1361 static int inc_block_group_ro(struct btrfs_block_group *cache, bool force) in inc_block_group_ro() argument
1363 struct btrfs_space_info *sinfo = cache->space_info; in inc_block_group_ro()
1365 int ret = -ENOSPC; in inc_block_group_ro()
1367 spin_lock(&sinfo->lock); in inc_block_group_ro()
1368 spin_lock(&cache->lock); in inc_block_group_ro()
1370 if (cache->swap_extents) { in inc_block_group_ro()
1371 ret = -ETXTBSY; in inc_block_group_ro()
1375 if (cache->ro) { in inc_block_group_ro()
1376 cache->ro++; in inc_block_group_ro()
1381 num_bytes = cache->length - cache->reserved - cache->pinned - in inc_block_group_ro()
1382 cache->bytes_super - cache->zone_unusable - cache->used; in inc_block_group_ro()
1390 } else if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA) { in inc_block_group_ro()
1397 if (sinfo_used + num_bytes <= sinfo->total_bytes) in inc_block_group_ro()
1404 * leeway to allow us to mark this block group as read only. in inc_block_group_ro()
1406 if (btrfs_can_overcommit(cache->fs_info, sinfo, num_bytes, in inc_block_group_ro()
1412 sinfo->bytes_readonly += num_bytes; in inc_block_group_ro()
1413 if (btrfs_is_zoned(cache->fs_info)) { in inc_block_group_ro()
1415 sinfo->bytes_readonly += cache->zone_unusable; in inc_block_group_ro()
1416 btrfs_space_info_update_bytes_zone_unusable(sinfo, -cache->zone_unusable); in inc_block_group_ro()
1417 cache->zone_unusable = 0; in inc_block_group_ro()
1419 cache->ro++; in inc_block_group_ro()
1420 list_add_tail(&cache->ro_list, &sinfo->ro_bgs); in inc_block_group_ro()
1423 spin_unlock(&cache->lock); in inc_block_group_ro()
1424 spin_unlock(&sinfo->lock); in inc_block_group_ro()
1425 if (ret == -ENOSPC && btrfs_test_opt(cache->fs_info, ENOSPC_DEBUG)) { in inc_block_group_ro()
1426 btrfs_info(cache->fs_info, in inc_block_group_ro()
1427 "unable to make block group %llu ro", cache->start); in inc_block_group_ro()
1428 btrfs_dump_space_info(cache->fs_info, cache->space_info, 0, false); in inc_block_group_ro()
1436 struct btrfs_fs_info *fs_info = trans->fs_info; in clean_pinned_extents()
1438 const u64 start = bg->start; in clean_pinned_extents()
1439 const u64 end = start + bg->length - 1; in clean_pinned_extents()
1442 spin_lock(&fs_info->trans_lock); in clean_pinned_extents()
1443 if (!list_is_first(&trans->transaction->list, &fs_info->trans_list)) { in clean_pinned_extents()
1444 prev_trans = list_prev_entry(trans->transaction, list); in clean_pinned_extents()
1445 refcount_inc(&prev_trans->use_count); in clean_pinned_extents()
1447 spin_unlock(&fs_info->trans_lock); in clean_pinned_extents()
1453 * transaction N - 1, and have seen a range belonging to the block in clean_pinned_extents()
1454 * group in pinned_extents before we were able to clear the whole block in clean_pinned_extents()
1456 * the block group after we unpinned it from pinned_extents and removed in clean_pinned_extents()
1459 mutex_lock(&fs_info->unused_bg_unpin_mutex); in clean_pinned_extents()
1461 ret = btrfs_clear_extent_bit(&prev_trans->pinned_extents, start, end, in clean_pinned_extents()
1467 ret = btrfs_clear_extent_bit(&trans->transaction->pinned_extents, start, end, in clean_pinned_extents()
1470 mutex_unlock(&fs_info->unused_bg_unpin_mutex); in clean_pinned_extents()
1490 struct btrfs_fs_info *fs_info = bg->fs_info; in btrfs_link_bg_list()
1493 spin_lock(&fs_info->unused_bgs_lock); in btrfs_link_bg_list()
1494 if (list_empty(&bg->bg_list)) { in btrfs_link_bg_list()
1496 list_add_tail(&bg->bg_list, list); in btrfs_link_bg_list()
1499 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_link_bg_list()
1516 if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags)) in btrfs_delete_unused_bgs()
1526 if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) in btrfs_delete_unused_bgs()
1529 spin_lock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1530 while (!list_empty(&fs_info->unused_bgs)) { in btrfs_delete_unused_bgs()
1534 block_group = list_first_entry(&fs_info->unused_bgs, in btrfs_delete_unused_bgs()
1537 list_del_init(&block_group->bg_list); in btrfs_delete_unused_bgs()
1539 space_info = block_group->space_info; in btrfs_delete_unused_bgs()
1545 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1547 btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); in btrfs_delete_unused_bgs()
1550 down_write(&space_info->groups_sem); in btrfs_delete_unused_bgs()
1553 * Async discard moves the final block group discard to be prior in btrfs_delete_unused_bgs()
1560 up_write(&space_info->groups_sem); in btrfs_delete_unused_bgs()
1562 btrfs_discard_queue_work(&fs_info->discard_ctl, in btrfs_delete_unused_bgs()
1567 spin_lock(&space_info->lock); in btrfs_delete_unused_bgs()
1568 spin_lock(&block_group->lock); in btrfs_delete_unused_bgs()
1569 if (btrfs_is_block_group_used(block_group) || block_group->ro || in btrfs_delete_unused_bgs()
1570 list_is_singular(&block_group->list)) { in btrfs_delete_unused_bgs()
1573 * outstanding allocations in this block group. We do in btrfs_delete_unused_bgs()
1575 * this block group. in btrfs_delete_unused_bgs()
1577 * Also bail out if this is the only block group for its in btrfs_delete_unused_bgs()
1579 * information from fs_info->avail_*_alloc_bits and the in btrfs_delete_unused_bgs()
1580 * next block group of this type would be created with a in btrfs_delete_unused_bgs()
1582 * fs_info->avail_*_alloc_bits would be 0. in btrfs_delete_unused_bgs()
1585 spin_unlock(&block_group->lock); in btrfs_delete_unused_bgs()
1586 spin_unlock(&space_info->lock); in btrfs_delete_unused_bgs()
1587 up_write(&space_info->groups_sem); in btrfs_delete_unused_bgs()
1592 * The block group may be unused but there may be space reserved in btrfs_delete_unused_bgs()
1593 * accounting with the existence of that block group, that is, in btrfs_delete_unused_bgs()
1594 * space_info->bytes_may_use was incremented by a task but no in btrfs_delete_unused_bgs()
1595 * space was yet allocated from the block group by the task. in btrfs_delete_unused_bgs()
1602 * So check if the total space of the space_info minus the size in btrfs_delete_unused_bgs()
1603 * of this block group is less than the used space of the in btrfs_delete_unused_bgs()
1604 * space_info - if that's the case, then it means we have tasks in btrfs_delete_unused_bgs()
1605 * that might be relying on the block group in order to allocate in btrfs_delete_unused_bgs()
1606 * extents, and add back the block group to the unused list when in btrfs_delete_unused_bgs()
1608 * needing to allocate extents from the block group. in btrfs_delete_unused_bgs()
1611 if ((space_info->total_bytes - block_group->length < used && in btrfs_delete_unused_bgs()
1612 block_group->zone_unusable < block_group->length) || in btrfs_delete_unused_bgs()
1617 * fs_info->unused_bgs list. in btrfs_delete_unused_bgs()
1622 spin_unlock(&block_group->lock); in btrfs_delete_unused_bgs()
1623 spin_unlock(&space_info->lock); in btrfs_delete_unused_bgs()
1624 up_write(&space_info->groups_sem); in btrfs_delete_unused_bgs()
1628 spin_unlock(&block_group->lock); in btrfs_delete_unused_bgs()
1629 spin_unlock(&space_info->lock); in btrfs_delete_unused_bgs()
1633 up_write(&space_info->groups_sem); in btrfs_delete_unused_bgs()
1642 if (ret == -EAGAIN) { in btrfs_delete_unused_bgs()
1654 block_group->start); in btrfs_delete_unused_bgs()
1662 * We could have pending pinned extents for this block group, in btrfs_delete_unused_bgs()
1677 spin_lock(&fs_info->discard_ctl.lock); in btrfs_delete_unused_bgs()
1678 if (!list_empty(&block_group->discard_list)) { in btrfs_delete_unused_bgs()
1679 spin_unlock(&fs_info->discard_ctl.lock); in btrfs_delete_unused_bgs()
1681 btrfs_discard_queue_work(&fs_info->discard_ctl, in btrfs_delete_unused_bgs()
1685 spin_unlock(&fs_info->discard_ctl.lock); in btrfs_delete_unused_bgs()
1688 spin_lock(&space_info->lock); in btrfs_delete_unused_bgs()
1689 spin_lock(&block_group->lock); in btrfs_delete_unused_bgs()
1691 btrfs_space_info_update_bytes_pinned(space_info, -block_group->pinned); in btrfs_delete_unused_bgs()
1692 space_info->bytes_readonly += block_group->pinned; in btrfs_delete_unused_bgs()
1693 block_group->pinned = 0; in btrfs_delete_unused_bgs()
1695 spin_unlock(&block_group->lock); in btrfs_delete_unused_bgs()
1696 spin_unlock(&space_info->lock); in btrfs_delete_unused_bgs()
1699 * The normal path here is an unused block group is passed here, in btrfs_delete_unused_bgs()
1702 * before coming down the unused block group path as trimming in btrfs_delete_unused_bgs()
1710 * need to reset sequential-required zones. in btrfs_delete_unused_bgs()
1723 ret = btrfs_remove_chunk(trans, block_group->start); in btrfs_delete_unused_bgs()
1732 * If we're not mounted with -odiscard, we can just forget in btrfs_delete_unused_bgs()
1733 * about this block group. Otherwise we'll need to wait in btrfs_delete_unused_bgs()
1737 spin_lock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1740 * fs_info->unused_bgs, so use a list_move operation in btrfs_delete_unused_bgs()
1741 * to add the block group to the deleted_bgs list. in btrfs_delete_unused_bgs()
1743 list_move(&block_group->bg_list, in btrfs_delete_unused_bgs()
1744 &trans->transaction->deleted_bgs); in btrfs_delete_unused_bgs()
1745 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1752 spin_lock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1754 list_splice_tail(&retry_list, &fs_info->unused_bgs); in btrfs_delete_unused_bgs()
1755 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1756 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_delete_unused_bgs()
1761 spin_lock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1762 list_splice_tail(&retry_list, &fs_info->unused_bgs); in btrfs_delete_unused_bgs()
1763 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_delete_unused_bgs()
1764 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_delete_unused_bgs()
1771 struct btrfs_fs_info *fs_info = bg->fs_info; in btrfs_mark_bg_unused()
1773 spin_lock(&fs_info->unused_bgs_lock); in btrfs_mark_bg_unused()
1774 if (list_empty(&bg->bg_list)) { in btrfs_mark_bg_unused()
1777 list_add_tail(&bg->bg_list, &fs_info->unused_bgs); in btrfs_mark_bg_unused()
1778 } else if (!test_bit(BLOCK_GROUP_FLAG_NEW, &bg->runtime_flags)) { in btrfs_mark_bg_unused()
1779 /* Pull out the block group from the reclaim_bgs list. */ in btrfs_mark_bg_unused()
1781 list_move_tail(&bg->bg_list, &fs_info->unused_bgs); in btrfs_mark_bg_unused()
1783 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_mark_bg_unused()
1787 * We want block groups with a low number of used bytes to be in the beginning
1799 * Some other task may be updating the ->used field concurrently, but it in reclaim_bgs_cmp()
1801 * as sorting the list of block groups to reclaim is not critical and an in reclaim_bgs_cmp()
1805 return data_race(bg1->used > bg2->used); in reclaim_bgs_cmp()
1817 const int thresh_pct = btrfs_calc_reclaim_threshold(bg->space_info); in should_reclaim_block_group()
1818 u64 thresh_bytes = mult_perc(bg->length, thresh_pct); in should_reclaim_block_group()
1819 const u64 new_val = bg->used; in should_reclaim_block_group()
1827 * brand new block group and we don't want to relocate new block groups. in should_reclaim_block_group()
1844 if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags)) in btrfs_reclaim_bgs_work()
1853 sb_start_write(fs_info->sb); in btrfs_reclaim_bgs_work()
1856 sb_end_write(fs_info->sb); in btrfs_reclaim_bgs_work()
1864 if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) { in btrfs_reclaim_bgs_work()
1866 sb_end_write(fs_info->sb); in btrfs_reclaim_bgs_work()
1870 spin_lock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs_work()
1873 * The block groups might still be in use and reachable via bg_list, in btrfs_reclaim_bgs_work()
1876 list_sort(NULL, &fs_info->reclaim_bgs, reclaim_bgs_cmp); in btrfs_reclaim_bgs_work()
1877 while (!list_empty(&fs_info->reclaim_bgs)) { in btrfs_reclaim_bgs_work()
1882 bg = list_first_entry(&fs_info->reclaim_bgs, in btrfs_reclaim_bgs_work()
1885 list_del_init(&bg->bg_list); in btrfs_reclaim_bgs_work()
1887 space_info = bg->space_info; in btrfs_reclaim_bgs_work()
1888 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs_work()
1891 down_write(&space_info->groups_sem); in btrfs_reclaim_bgs_work()
1893 spin_lock(&space_info->lock); in btrfs_reclaim_bgs_work()
1894 spin_lock(&bg->lock); in btrfs_reclaim_bgs_work()
1895 if (bg->reserved || bg->pinned || bg->ro) { in btrfs_reclaim_bgs_work()
1898 * outstanding allocations in this block group. We do in btrfs_reclaim_bgs_work()
1900 * this block group. in btrfs_reclaim_bgs_work()
1902 spin_unlock(&bg->lock); in btrfs_reclaim_bgs_work()
1903 spin_unlock(&space_info->lock); in btrfs_reclaim_bgs_work()
1904 up_write(&space_info->groups_sem); in btrfs_reclaim_bgs_work()
1907 if (bg->used == 0) { in btrfs_reclaim_bgs_work()
1909 * It is possible that we trigger relocation on a block in btrfs_reclaim_bgs_work()
1915 * for the non-existent extents and running some extra in btrfs_reclaim_bgs_work()
1917 * other mechanisms for dealing with empty block groups. in btrfs_reclaim_bgs_work()
1921 spin_unlock(&bg->lock); in btrfs_reclaim_bgs_work()
1922 spin_unlock(&space_info->lock); in btrfs_reclaim_bgs_work()
1923 up_write(&space_info->groups_sem); in btrfs_reclaim_bgs_work()
1928 * The block group might no longer meet the reclaim condition by in btrfs_reclaim_bgs_work()
1937 if (!should_reclaim_block_group(bg, bg->length)) { in btrfs_reclaim_bgs_work()
1938 spin_unlock(&bg->lock); in btrfs_reclaim_bgs_work()
1939 spin_unlock(&space_info->lock); in btrfs_reclaim_bgs_work()
1940 up_write(&space_info->groups_sem); in btrfs_reclaim_bgs_work()
1944 spin_unlock(&bg->lock); in btrfs_reclaim_bgs_work()
1945 spin_unlock(&space_info->lock); in btrfs_reclaim_bgs_work()
1948 * Get out fast, in case we're read-only or unmounting the in btrfs_reclaim_bgs_work()
1949 * filesystem. It is OK to drop block groups from the list even in btrfs_reclaim_bgs_work()
1950 * for the read-only case. As we did sb_start_write(), in btrfs_reclaim_bgs_work()
1951 * "mount -o remount,ro" won't happen and read-only filesystem in btrfs_reclaim_bgs_work()
1952 * means it is forced read-only due to a fatal error. So, it in btrfs_reclaim_bgs_work()
1953 * never gets back to read-write to let us reclaim again. in btrfs_reclaim_bgs_work()
1956 up_write(&space_info->groups_sem); in btrfs_reclaim_bgs_work()
1961 up_write(&space_info->groups_sem); in btrfs_reclaim_bgs_work()
1967 * "used" and "reserved" counters. We have set the block group in btrfs_reclaim_bgs_work()
1970 * not yet been done - btrfs_update_block_group() was not yet in btrfs_reclaim_bgs_work()
1972 * size from the "reserved" counter to the "used" counter - this in btrfs_reclaim_bgs_work()
1978 * it does the actual work to move extents out of the block in btrfs_reclaim_bgs_work()
1982 spin_lock(&bg->lock); in btrfs_reclaim_bgs_work()
1983 used = bg->used; in btrfs_reclaim_bgs_work()
1984 reserved = bg->reserved; in btrfs_reclaim_bgs_work()
1985 spin_unlock(&bg->lock); in btrfs_reclaim_bgs_work()
1988 ret = btrfs_relocate_chunk(fs_info, bg->start, false); in btrfs_reclaim_bgs_work()
1992 bg->start); in btrfs_reclaim_bgs_work()
1995 spin_lock(&space_info->lock); in btrfs_reclaim_bgs_work()
1996 space_info->reclaim_errors++; in btrfs_reclaim_bgs_work()
1997 if (READ_ONCE(space_info->periodic_reclaim)) in btrfs_reclaim_bgs_work()
1998 space_info->periodic_reclaim_ready = false; in btrfs_reclaim_bgs_work()
1999 spin_unlock(&space_info->lock); in btrfs_reclaim_bgs_work()
2001 spin_lock(&space_info->lock); in btrfs_reclaim_bgs_work()
2002 space_info->reclaim_count++; in btrfs_reclaim_bgs_work()
2003 space_info->reclaim_bytes += used; in btrfs_reclaim_bgs_work()
2004 space_info->reclaim_bytes += reserved; in btrfs_reclaim_bgs_work()
2005 spin_unlock(&space_info->lock); in btrfs_reclaim_bgs_work()
2008 if (ret && !READ_ONCE(space_info->periodic_reclaim)) in btrfs_reclaim_bgs_work()
2012 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_reclaim_bgs_work()
2014 * Reclaiming all the block groups in the list can take really in btrfs_reclaim_bgs_work()
2015 * long. Prioritize cleaning up unused block groups. in btrfs_reclaim_bgs_work()
2022 if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) in btrfs_reclaim_bgs_work()
2024 spin_lock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs_work()
2026 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs_work()
2027 mutex_unlock(&fs_info->reclaim_bgs_lock); in btrfs_reclaim_bgs_work()
2029 spin_lock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs_work()
2030 list_splice_tail(&retry_list, &fs_info->reclaim_bgs); in btrfs_reclaim_bgs_work()
2031 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs_work()
2033 sb_end_write(fs_info->sb); in btrfs_reclaim_bgs_work()
2039 spin_lock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs()
2040 if (!list_empty(&fs_info->reclaim_bgs)) in btrfs_reclaim_bgs()
2041 queue_work(system_dfl_wq, &fs_info->reclaim_bgs_work); in btrfs_reclaim_bgs()
2042 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_reclaim_bgs()
2047 struct btrfs_fs_info *fs_info = bg->fs_info; in btrfs_mark_bg_to_reclaim()
2049 if (btrfs_link_bg_list(bg, &fs_info->reclaim_bgs)) in btrfs_mark_bg_to_reclaim()
2063 slot = path->slots[0]; in read_bg_from_eb()
2064 leaf = path->nodes[0]; in read_bg_from_eb()
2066 map = btrfs_find_chunk_map(fs_info, key->objectid, key->offset); in read_bg_from_eb()
2070 key->objectid, key->offset); in read_bg_from_eb()
2071 return -ENOENT; in read_bg_from_eb()
2074 if (unlikely(map->start != key->objectid || map->chunk_len != key->offset)) { in read_bg_from_eb()
2076 "block group %llu len %llu mismatch with chunk %llu len %llu", in read_bg_from_eb()
2077 key->objectid, key->offset, map->start, map->chunk_len); in read_bg_from_eb()
2078 ret = -EUCLEAN; in read_bg_from_eb()
2087 if (unlikely(flags != (map->type & BTRFS_BLOCK_GROUP_TYPE_MASK))) { in read_bg_from_eb()
2089 "block group %llu len %llu type flags 0x%llx mismatch with chunk type flags 0x%llx", in read_bg_from_eb()
2090 key->objectid, key->offset, flags, in read_bg_from_eb()
2091 (BTRFS_BLOCK_GROUP_TYPE_MASK & map->type)); in read_bg_from_eb()
2092 ret = -EUCLEAN; in read_bg_from_eb()
2109 if (found_key.objectid >= key->objectid && in find_first_block_group()
2122 write_seqlock(&fs_info->profiles_lock); in set_avail_alloc_bits()
2124 fs_info->avail_data_alloc_bits |= extra_flags; in set_avail_alloc_bits()
2126 fs_info->avail_metadata_alloc_bits |= extra_flags; in set_avail_alloc_bits()
2128 fs_info->avail_system_alloc_bits |= extra_flags; in set_avail_alloc_bits()
2129 write_sequnlock(&fs_info->profiles_lock); in set_avail_alloc_bits()
2136 * @chunk_start: logical address of block group
2140 * @stripe_len: size of IO stripe for the given block group
2143 * Used primarily to exclude those portions of a block group that contain super
2144 * block copies.
2154 int i, nr = 0; in btrfs_rmap_block() local
2159 return -EIO; in btrfs_rmap_block()
2161 data_stripe_length = map->stripe_size; in btrfs_rmap_block()
2163 chunk_start = map->start; in btrfs_rmap_block()
2166 if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) in btrfs_rmap_block()
2169 buf = kcalloc(map->num_stripes, sizeof(u64), GFP_NOFS); in btrfs_rmap_block()
2171 ret = -ENOMEM; in btrfs_rmap_block()
2175 for (i = 0; i < map->num_stripes; i++) { in btrfs_rmap_block()
2181 if (!in_range(physical, map->stripes[i].physical, in btrfs_rmap_block()
2185 stripe_nr = (physical - map->stripes[i].physical) >> in btrfs_rmap_block()
2187 offset = (physical - map->stripes[i].physical) & in btrfs_rmap_block()
2190 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | in btrfs_rmap_block()
2192 stripe_nr = div_u64(stripe_nr * map->num_stripes + i, in btrfs_rmap_block()
2193 map->sub_stripes); in btrfs_rmap_block()
2197 * instead of map->stripe_len in btrfs_rmap_block()
2221 static int exclude_super_stripes(struct btrfs_block_group *cache) in exclude_super_stripes() argument
2223 struct btrfs_fs_info *fs_info = cache->fs_info; in exclude_super_stripes()
2228 int i, nr, ret; in exclude_super_stripes() local
2230 if (cache->start < BTRFS_SUPER_INFO_OFFSET) { in exclude_super_stripes()
2231 stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->start; in exclude_super_stripes()
2232 cache->bytes_super += stripe_len; in exclude_super_stripes()
2233 ret = btrfs_set_extent_bit(&fs_info->excluded_extents, cache->start, in exclude_super_stripes()
2234 cache->start + stripe_len - 1, in exclude_super_stripes()
2240 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { in exclude_super_stripes()
2241 bytenr = btrfs_sb_offset(i); in exclude_super_stripes()
2242 ret = btrfs_rmap_block(fs_info, cache->start, in exclude_super_stripes()
2251 "zoned: block group %llu must not contain super block", in exclude_super_stripes()
2252 cache->start); in exclude_super_stripes()
2253 return -EUCLEAN; in exclude_super_stripes()
2256 while (nr--) { in exclude_super_stripes()
2258 cache->start + cache->length - logical[nr]); in exclude_super_stripes()
2260 cache->bytes_super += len; in exclude_super_stripes()
2261 ret = btrfs_set_extent_bit(&fs_info->excluded_extents, in exclude_super_stripes()
2262 logical[nr], logical[nr] + len - 1, in exclude_super_stripes()
2278 struct btrfs_block_group *cache; in btrfs_create_block_group_cache() local
2280 cache = kzalloc(sizeof(*cache), GFP_NOFS); in btrfs_create_block_group_cache()
2281 if (!cache) in btrfs_create_block_group_cache()
2284 cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl), in btrfs_create_block_group_cache()
2286 if (!cache->free_space_ctl) { in btrfs_create_block_group_cache()
2287 kfree(cache); in btrfs_create_block_group_cache()
2291 cache->start = start; in btrfs_create_block_group_cache()
2293 cache->fs_info = fs_info; in btrfs_create_block_group_cache()
2294 cache->full_stripe_len = btrfs_full_stripe_len(fs_info, start); in btrfs_create_block_group_cache()
2296 cache->discard_index = BTRFS_DISCARD_INDEX_UNUSED; in btrfs_create_block_group_cache()
2298 refcount_set(&cache->refs, 1); in btrfs_create_block_group_cache()
2299 spin_lock_init(&cache->lock); in btrfs_create_block_group_cache()
2300 init_rwsem(&cache->data_rwsem); in btrfs_create_block_group_cache()
2301 INIT_LIST_HEAD(&cache->list); in btrfs_create_block_group_cache()
2302 INIT_LIST_HEAD(&cache->cluster_list); in btrfs_create_block_group_cache()
2303 INIT_LIST_HEAD(&cache->bg_list); in btrfs_create_block_group_cache()
2304 INIT_LIST_HEAD(&cache->ro_list); in btrfs_create_block_group_cache()
2305 INIT_LIST_HEAD(&cache->discard_list); in btrfs_create_block_group_cache()
2306 INIT_LIST_HEAD(&cache->dirty_list); in btrfs_create_block_group_cache()
2307 INIT_LIST_HEAD(&cache->io_list); in btrfs_create_block_group_cache()
2308 INIT_LIST_HEAD(&cache->active_bg_list); in btrfs_create_block_group_cache()
2309 btrfs_init_free_space_ctl(cache, cache->free_space_ctl); in btrfs_create_block_group_cache()
2310 atomic_set(&cache->frozen, 0); in btrfs_create_block_group_cache()
2311 mutex_init(&cache->free_space_lock); in btrfs_create_block_group_cache()
2313 return cache; in btrfs_create_block_group_cache()
2317 * Iterate all chunks and verify that each of them has the corresponding block
2338 bg = btrfs_lookup_block_group(fs_info, map->start); in check_chunk_block_group_mappings()
2341 "chunk start=%llu len=%llu doesn't have corresponding block group", in check_chunk_block_group_mappings()
2342 map->start, map->chunk_len); in check_chunk_block_group_mappings()
2343 ret = -EUCLEAN; in check_chunk_block_group_mappings()
2347 if (unlikely(bg->start != map->start || bg->length != map->chunk_len || in check_chunk_block_group_mappings()
2348 (bg->flags & BTRFS_BLOCK_GROUP_TYPE_MASK) != in check_chunk_block_group_mappings()
2349 (map->type & BTRFS_BLOCK_GROUP_TYPE_MASK))) { in check_chunk_block_group_mappings()
2351 "chunk start=%llu len=%llu flags=0x%llx doesn't match block group start=%llu len=%llu flags=0x%llx", in check_chunk_block_group_mappings()
2352 map->start, map->chunk_len, in check_chunk_block_group_mappings()
2353 map->type & BTRFS_BLOCK_GROUP_TYPE_MASK, in check_chunk_block_group_mappings()
2354 bg->start, bg->length, in check_chunk_block_group_mappings()
2355 bg->flags & BTRFS_BLOCK_GROUP_TYPE_MASK); in check_chunk_block_group_mappings()
2356 ret = -EUCLEAN; in check_chunk_block_group_mappings()
2361 start = map->start + map->chunk_len; in check_chunk_block_group_mappings()
2373 struct btrfs_block_group *cache; in read_one_block_group() local
2377 ASSERT(key->type == BTRFS_BLOCK_GROUP_ITEM_KEY); in read_one_block_group()
2379 cache = btrfs_create_block_group_cache(info, key->objectid); in read_one_block_group()
2380 if (!cache) in read_one_block_group()
2381 return -ENOMEM; in read_one_block_group()
2383 cache->length = key->offset; in read_one_block_group()
2384 cache->used = btrfs_stack_block_group_used(bgi); in read_one_block_group()
2385 cache->commit_used = cache->used; in read_one_block_group()
2386 cache->flags = btrfs_stack_block_group_flags(bgi); in read_one_block_group()
2387 cache->global_root_id = btrfs_stack_block_group_chunk_objectid(bgi); in read_one_block_group()
2388 cache->space_info = btrfs_find_space_info(info, cache->flags); in read_one_block_group()
2390 btrfs_set_free_space_tree_thresholds(cache); in read_one_block_group()
2394 * When we mount with old space cache, we need to in read_one_block_group()
2398 * truncate the old free space cache inode and in read_one_block_group()
2401 * the new space cache info onto disk. in read_one_block_group()
2404 cache->disk_cache_state = BTRFS_DC_CLEAR; in read_one_block_group()
2406 if (!mixed && ((cache->flags & BTRFS_BLOCK_GROUP_METADATA) && in read_one_block_group()
2407 (cache->flags & BTRFS_BLOCK_GROUP_DATA))) { in read_one_block_group()
2409 "bg %llu is a mixed block group but filesystem hasn't enabled mixed block groups", in read_one_block_group()
2410 cache->start); in read_one_block_group()
2411 ret = -EINVAL; in read_one_block_group()
2415 ret = btrfs_load_block_group_zone_info(cache, false); in read_one_block_group()
2418 cache->start); in read_one_block_group()
2427 ret = exclude_super_stripes(cache); in read_one_block_group()
2430 btrfs_free_excluded_extents(cache); in read_one_block_group()
2436 * free space for a block group. So, we don't need any caching work. in read_one_block_group()
2447 btrfs_calc_zone_unusable(cache); in read_one_block_group()
2449 btrfs_free_excluded_extents(cache); in read_one_block_group()
2450 } else if (cache->length == cache->used) { in read_one_block_group()
2451 cache->cached = BTRFS_CACHE_FINISHED; in read_one_block_group()
2452 btrfs_free_excluded_extents(cache); in read_one_block_group()
2453 } else if (cache->used == 0) { in read_one_block_group()
2454 cache->cached = BTRFS_CACHE_FINISHED; in read_one_block_group()
2455 ret = btrfs_add_new_free_space(cache, cache->start, in read_one_block_group()
2456 cache->start + cache->length, NULL); in read_one_block_group()
2457 btrfs_free_excluded_extents(cache); in read_one_block_group()
2462 ret = btrfs_add_block_group_cache(cache); in read_one_block_group()
2464 btrfs_remove_free_space_cache(cache); in read_one_block_group()
2468 trace_btrfs_add_block_group(info, cache, 0); in read_one_block_group()
2469 btrfs_add_bg_to_space_info(info, cache); in read_one_block_group()
2471 set_avail_alloc_bits(info, cache->flags); in read_one_block_group()
2472 if (btrfs_chunk_writeable(info, cache->start)) { in read_one_block_group()
2473 if (cache->used == 0) { in read_one_block_group()
2474 ASSERT(list_empty(&cache->bg_list)); in read_one_block_group()
2476 btrfs_discard_queue_work(&info->discard_ctl, cache); in read_one_block_group()
2478 btrfs_mark_bg_unused(cache); in read_one_block_group()
2481 inc_block_group_ro(cache, 1); in read_one_block_group()
2486 btrfs_put_block_group(cache); in read_one_block_group()
2495 for (node = rb_first_cached(&fs_info->mapping_tree); node; node = rb_next(node)) { in fill_dummy_bgs()
2500 bg = btrfs_create_block_group_cache(fs_info, map->start); in fill_dummy_bgs()
2502 ret = -ENOMEM; in fill_dummy_bgs()
2506 /* Fill dummy cache as FULL */ in fill_dummy_bgs()
2507 bg->length = map->chunk_len; in fill_dummy_bgs()
2508 bg->flags = map->type; in fill_dummy_bgs()
2509 bg->cached = BTRFS_CACHE_FINISHED; in fill_dummy_bgs()
2510 bg->used = map->chunk_len; in fill_dummy_bgs()
2511 bg->flags = map->type; in fill_dummy_bgs()
2512 bg->space_info = btrfs_find_space_info(fs_info, bg->flags); in fill_dummy_bgs()
2515 * We may have some valid block group cache added already, in in fill_dummy_bgs()
2518 if (ret == -EEXIST) { in fill_dummy_bgs()
2532 set_avail_alloc_bits(fs_info, bg->flags); in fill_dummy_bgs()
2544 struct btrfs_block_group *cache; in btrfs_read_block_groups() local
2552 * unsupported RO options. The fs can never be mounted read-write, so no in btrfs_read_block_groups()
2553 * need to waste time searching block group items. in btrfs_read_block_groups()
2558 if (!root || (btrfs_super_compat_ro_flags(info->super_copy) & in btrfs_read_block_groups()
2567 return -ENOMEM; in btrfs_read_block_groups()
2569 cache_gen = btrfs_super_cache_generation(info->super_copy); in btrfs_read_block_groups()
2571 btrfs_super_generation(info->super_copy) != cache_gen) in btrfs_read_block_groups()
2587 leaf = path->nodes[0]; in btrfs_read_block_groups()
2588 slot = path->slots[0]; in btrfs_read_block_groups()
2603 list_for_each_entry(space_info, &info->space_info, list) { in btrfs_read_block_groups()
2604 int i; in btrfs_read_block_groups() local
2606 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { in btrfs_read_block_groups()
2607 if (list_empty(&space_info->block_groups[i])) in btrfs_read_block_groups()
2609 cache = list_first_entry(&space_info->block_groups[i], in btrfs_read_block_groups()
2612 btrfs_sysfs_add_block_group_type(cache); in btrfs_read_block_groups()
2615 if (!(btrfs_get_alloc_profile(info, space_info->flags) & in btrfs_read_block_groups()
2622 * Avoid allocating from un-mirrored block group if there are in btrfs_read_block_groups()
2623 * mirrored block groups. in btrfs_read_block_groups()
2625 list_for_each_entry(cache, in btrfs_read_block_groups()
2626 &space_info->block_groups[BTRFS_RAID_RAID0], in btrfs_read_block_groups()
2628 inc_block_group_ro(cache, 1); in btrfs_read_block_groups()
2629 list_for_each_entry(cache, in btrfs_read_block_groups()
2630 &space_info->block_groups[BTRFS_RAID_SINGLE], in btrfs_read_block_groups()
2632 inc_block_group_ro(cache, 1); in btrfs_read_block_groups()
2642 * Try to fill the tree using dummy block groups so that the user can in btrfs_read_block_groups()
2660 struct btrfs_fs_info *fs_info = trans->fs_info; in insert_block_group_item()
2667 spin_lock(&block_group->lock); in insert_block_group_item()
2668 btrfs_set_stack_block_group_used(&bgi, block_group->used); in insert_block_group_item()
2670 block_group->global_root_id); in insert_block_group_item()
2671 btrfs_set_stack_block_group_flags(&bgi, block_group->flags); in insert_block_group_item()
2672 old_commit_used = block_group->commit_used; in insert_block_group_item()
2673 block_group->commit_used = block_group->used; in insert_block_group_item()
2674 key.objectid = block_group->start; in insert_block_group_item()
2676 key.offset = block_group->length; in insert_block_group_item()
2677 spin_unlock(&block_group->lock); in insert_block_group_item()
2681 spin_lock(&block_group->lock); in insert_block_group_item()
2682 block_group->commit_used = old_commit_used; in insert_block_group_item()
2683 spin_unlock(&block_group->lock); in insert_block_group_item()
2693 struct btrfs_fs_info *fs_info = device->fs_info; in insert_dev_extent()
2694 struct btrfs_root *root = fs_info->dev_root; in insert_dev_extent()
2701 WARN_ON(!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)); in insert_dev_extent()
2702 WARN_ON(test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); in insert_dev_extent()
2705 return -ENOMEM; in insert_dev_extent()
2707 key.objectid = device->devid; in insert_dev_extent()
2714 leaf = path->nodes[0]; in insert_dev_extent()
2715 extent = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent); in insert_dev_extent()
2734 struct btrfs_fs_info *fs_info = trans->fs_info; in insert_dev_extents()
2738 int i; in insert_dev_extents() local
2750 * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the in insert_dev_extents()
2754 mutex_lock(&fs_info->fs_devices->device_list_mutex); in insert_dev_extents()
2755 for (i = 0; i < map->num_stripes; i++) { in insert_dev_extents()
2756 device = map->stripes[i].dev; in insert_dev_extents()
2757 dev_offset = map->stripes[i].physical; in insert_dev_extents()
2760 map->stripe_size); in insert_dev_extents()
2764 mutex_unlock(&fs_info->fs_devices->device_list_mutex); in insert_dev_extents()
2779 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_create_pending_block_groups()
2783 while (!list_empty(&trans->new_bgs)) { in btrfs_create_pending_block_groups()
2786 block_group = list_first_entry(&trans->new_bgs, in btrfs_create_pending_block_groups()
2792 index = btrfs_bg_flags_to_raid_index(block_group->flags); in btrfs_create_pending_block_groups()
2798 &block_group->runtime_flags)) { in btrfs_create_pending_block_groups()
2799 mutex_lock(&fs_info->chunk_mutex); in btrfs_create_pending_block_groups()
2801 mutex_unlock(&fs_info->chunk_mutex); in btrfs_create_pending_block_groups()
2805 ret = insert_dev_extents(trans, block_group->start, in btrfs_create_pending_block_groups()
2806 block_group->length); in btrfs_create_pending_block_groups()
2817 if (block_group->space_info->block_group_kobjs[index] == NULL) in btrfs_create_pending_block_groups()
2824 spin_lock(&fs_info->unused_bgs_lock); in btrfs_create_pending_block_groups()
2825 list_del_init(&block_group->bg_list); in btrfs_create_pending_block_groups()
2826 clear_bit(BLOCK_GROUP_FLAG_NEW, &block_group->runtime_flags); in btrfs_create_pending_block_groups()
2828 spin_unlock(&fs_info->unused_bgs_lock); in btrfs_create_pending_block_groups()
2831 * If the block group is still unused, add it to the list of in btrfs_create_pending_block_groups()
2832 * unused block groups. The block group may have been created in in btrfs_create_pending_block_groups()
2836 * so the block group may become unused for a long time. For in btrfs_create_pending_block_groups()
2845 * uncompressed data size, because the compression is only done in btrfs_create_pending_block_groups()
2848 * size because the data may be incompressible in the worst case. in btrfs_create_pending_block_groups()
2853 spin_lock(&block_group->lock); in btrfs_create_pending_block_groups()
2855 spin_unlock(&block_group->lock); in btrfs_create_pending_block_groups()
2865 * For extent tree v2 we use the block_group_item->chunk_offset to point at our
2877 if (btrfs_super_total_bytes(fs_info->super_copy) <= (SZ_1G * 10ULL)) in calculate_global_root_id()
2881 div64_u64_rem(offset, fs_info->nr_global_roots, &index); in calculate_global_root_id()
2887 u64 type, u64 chunk_offset, u64 size) in btrfs_make_block_group() argument
2889 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_make_block_group()
2890 struct btrfs_block_group *cache; in btrfs_make_block_group() local
2895 cache = btrfs_create_block_group_cache(fs_info, chunk_offset); in btrfs_make_block_group()
2896 if (!cache) in btrfs_make_block_group()
2897 return ERR_PTR(-ENOMEM); in btrfs_make_block_group()
2900 * Mark it as new before adding it to the rbtree of block groups or any in btrfs_make_block_group()
2904 set_bit(BLOCK_GROUP_FLAG_NEW, &cache->runtime_flags); in btrfs_make_block_group()
2906 cache->length = size; in btrfs_make_block_group()
2907 btrfs_set_free_space_tree_thresholds(cache); in btrfs_make_block_group()
2908 cache->flags = type; in btrfs_make_block_group()
2909 cache->cached = BTRFS_CACHE_FINISHED; in btrfs_make_block_group()
2910 cache->global_root_id = calculate_global_root_id(fs_info, cache->start); in btrfs_make_block_group()
2913 set_bit(BLOCK_GROUP_FLAG_NEEDS_FREE_SPACE, &cache->runtime_flags); in btrfs_make_block_group()
2915 ret = btrfs_load_block_group_zone_info(cache, true); in btrfs_make_block_group()
2917 btrfs_put_block_group(cache); in btrfs_make_block_group()
2921 ret = exclude_super_stripes(cache); in btrfs_make_block_group()
2924 btrfs_free_excluded_extents(cache); in btrfs_make_block_group()
2925 btrfs_put_block_group(cache); in btrfs_make_block_group()
2929 ret = btrfs_add_new_free_space(cache, chunk_offset, chunk_offset + size, NULL); in btrfs_make_block_group()
2930 btrfs_free_excluded_extents(cache); in btrfs_make_block_group()
2932 btrfs_put_block_group(cache); in btrfs_make_block_group()
2938 * assigned to our block group. We want our bg to be added to the rbtree in btrfs_make_block_group()
2939 * with its ->space_info set. in btrfs_make_block_group()
2941 cache->space_info = space_info; in btrfs_make_block_group()
2942 ASSERT(cache->space_info); in btrfs_make_block_group()
2944 ret = btrfs_add_block_group_cache(cache); in btrfs_make_block_group()
2946 btrfs_remove_free_space_cache(cache); in btrfs_make_block_group()
2947 btrfs_put_block_group(cache); in btrfs_make_block_group()
2952 * Now that our block group has its ->space_info set and is inserted in in btrfs_make_block_group()
2955 trace_btrfs_add_block_group(fs_info, cache, 1); in btrfs_make_block_group()
2956 btrfs_add_bg_to_space_info(fs_info, cache); in btrfs_make_block_group()
2960 if (btrfs_should_fragment_free_space(cache)) { in btrfs_make_block_group()
2961 cache->space_info->bytes_used += size >> 1; in btrfs_make_block_group()
2962 fragment_free_space(cache); in btrfs_make_block_group()
2966 btrfs_link_bg_list(cache, &trans->new_bgs); in btrfs_make_block_group()
2970 return cache; in btrfs_make_block_group()
2974 * Mark one block group RO, can be called several times for the same block
2977 * @cache: the destination block group
2978 * @do_chunk_alloc: whether need to do chunk pre-allocation, this is to
2980 * block group RO.
2982 int btrfs_inc_block_group_ro(struct btrfs_block_group *cache, in btrfs_inc_block_group_ro() argument
2985 struct btrfs_fs_info *fs_info = cache->fs_info; in btrfs_inc_block_group_ro()
2986 struct btrfs_space_info *space_info = cache->space_info; in btrfs_inc_block_group_ro()
2994 * This can only happen when we are doing read-only scrub on read-only in btrfs_inc_block_group_ro()
2996 * In that case we should not start a new transaction on read-only fs. in btrfs_inc_block_group_ro()
2999 if (sb_rdonly(fs_info->sb)) { in btrfs_inc_block_group_ro()
3000 mutex_lock(&fs_info->ro_block_group_mutex); in btrfs_inc_block_group_ro()
3001 ret = inc_block_group_ro(cache, 0); in btrfs_inc_block_group_ro()
3002 mutex_unlock(&fs_info->ro_block_group_mutex); in btrfs_inc_block_group_ro()
3014 * We're not allowed to set block groups readonly after the dirty in btrfs_inc_block_group_ro()
3015 * block group cache has started writing. If it already started, in btrfs_inc_block_group_ro()
3018 mutex_lock(&fs_info->ro_block_group_mutex); in btrfs_inc_block_group_ro()
3019 if (test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &trans->transaction->flags)) { in btrfs_inc_block_group_ro()
3020 u64 transid = trans->transid; in btrfs_inc_block_group_ro()
3022 mutex_unlock(&fs_info->ro_block_group_mutex); in btrfs_inc_block_group_ro()
3035 * corresponding block group with the new raid level. in btrfs_inc_block_group_ro()
3037 alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags); in btrfs_inc_block_group_ro()
3038 if (alloc_flags != cache->flags) { in btrfs_inc_block_group_ro()
3045 if (ret == -ENOSPC) in btrfs_inc_block_group_ro()
3052 ret = inc_block_group_ro(cache, 0); in btrfs_inc_block_group_ro()
3055 if (ret == -ETXTBSY) in btrfs_inc_block_group_ro()
3061 * we still want to try our best to mark the block group read-only. in btrfs_inc_block_group_ro()
3063 if (!do_chunk_alloc && ret == -ENOSPC && in btrfs_inc_block_group_ro()
3064 (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM)) in btrfs_inc_block_group_ro()
3067 alloc_flags = btrfs_get_alloc_profile(fs_info, space_info->flags); in btrfs_inc_block_group_ro()
3079 ret = inc_block_group_ro(cache, 0); in btrfs_inc_block_group_ro()
3080 if (ret == -ETXTBSY) in btrfs_inc_block_group_ro()
3083 if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) { in btrfs_inc_block_group_ro()
3084 alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags); in btrfs_inc_block_group_ro()
3085 mutex_lock(&fs_info->chunk_mutex); in btrfs_inc_block_group_ro()
3087 mutex_unlock(&fs_info->chunk_mutex); in btrfs_inc_block_group_ro()
3090 mutex_unlock(&fs_info->ro_block_group_mutex); in btrfs_inc_block_group_ro()
3096 void btrfs_dec_block_group_ro(struct btrfs_block_group *cache) in btrfs_dec_block_group_ro() argument
3098 struct btrfs_space_info *sinfo = cache->space_info; in btrfs_dec_block_group_ro()
3101 BUG_ON(!cache->ro); in btrfs_dec_block_group_ro()
3103 spin_lock(&sinfo->lock); in btrfs_dec_block_group_ro()
3104 spin_lock(&cache->lock); in btrfs_dec_block_group_ro()
3105 if (!--cache->ro) { in btrfs_dec_block_group_ro()
3106 if (btrfs_is_zoned(cache->fs_info)) { in btrfs_dec_block_group_ro()
3108 cache->zone_unusable = in btrfs_dec_block_group_ro()
3109 (cache->alloc_offset - cache->used - cache->pinned - in btrfs_dec_block_group_ro()
3110 cache->reserved) + in btrfs_dec_block_group_ro()
3111 (cache->length - cache->zone_capacity); in btrfs_dec_block_group_ro()
3112 btrfs_space_info_update_bytes_zone_unusable(sinfo, cache->zone_unusable); in btrfs_dec_block_group_ro()
3113 sinfo->bytes_readonly -= cache->zone_unusable; in btrfs_dec_block_group_ro()
3115 num_bytes = cache->length - cache->reserved - in btrfs_dec_block_group_ro()
3116 cache->pinned - cache->bytes_super - in btrfs_dec_block_group_ro()
3117 cache->zone_unusable - cache->used; in btrfs_dec_block_group_ro()
3118 sinfo->bytes_readonly -= num_bytes; in btrfs_dec_block_group_ro()
3119 list_del_init(&cache->ro_list); in btrfs_dec_block_group_ro()
3121 spin_unlock(&cache->lock); in btrfs_dec_block_group_ro()
3122 spin_unlock(&sinfo->lock); in btrfs_dec_block_group_ro()
3127 struct btrfs_block_group *cache) in update_block_group_item() argument
3129 struct btrfs_fs_info *fs_info = trans->fs_info; in update_block_group_item()
3140 * Block group items update can be triggered out of commit transaction in update_block_group_item()
3142 * We cannot use cache->used directly outside of the spin lock, as it in update_block_group_item()
3145 spin_lock(&cache->lock); in update_block_group_item()
3146 old_commit_used = cache->commit_used; in update_block_group_item()
3147 used = cache->used; in update_block_group_item()
3149 if (cache->commit_used == used) { in update_block_group_item()
3150 spin_unlock(&cache->lock); in update_block_group_item()
3153 cache->commit_used = used; in update_block_group_item()
3154 spin_unlock(&cache->lock); in update_block_group_item()
3156 key.objectid = cache->start; in update_block_group_item()
3158 key.offset = cache->length; in update_block_group_item()
3163 ret = -ENOENT; in update_block_group_item()
3167 leaf = path->nodes[0]; in update_block_group_item()
3168 bi = btrfs_item_ptr_offset(leaf, path->slots[0]); in update_block_group_item()
3171 cache->global_root_id); in update_block_group_item()
3172 btrfs_set_stack_block_group_flags(&bgi, cache->flags); in update_block_group_item()
3177 * We didn't update the block group item, need to revert commit_used in update_block_group_item()
3178 * unless the block group item didn't exist yet - this is to prevent a in update_block_group_item()
3179 * race with a concurrent insertion of the block group item, with in update_block_group_item()
3182 * insertion set it to a value greater than 0 - if the block group later in update_block_group_item()
3185 if (ret < 0 && ret != -ENOENT) { in update_block_group_item()
3186 spin_lock(&cache->lock); in update_block_group_item()
3187 cache->commit_used = old_commit_used; in update_block_group_item()
3188 spin_unlock(&cache->lock); in update_block_group_item()
3198 struct btrfs_fs_info *fs_info = block_group->fs_info; in cache_save_setup()
3211 * If this block group is smaller than 100 megs don't bother caching the in cache_save_setup()
3212 * block group. in cache_save_setup()
3214 if (block_group->length < (100 * SZ_1M)) { in cache_save_setup()
3215 spin_lock(&block_group->lock); in cache_save_setup()
3216 block_group->disk_cache_state = BTRFS_DC_WRITTEN; in cache_save_setup()
3217 spin_unlock(&block_group->lock); in cache_save_setup()
3225 if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) { in cache_save_setup()
3235 if (block_group->ro) in cache_save_setup()
3246 * from here on out we know not to trust this cache when we load up next in cache_save_setup()
3249 BTRFS_I(inode)->generation = 0; in cache_save_setup()
3254 * super cache generation to 0 so we know to invalidate the in cache_save_setup()
3255 * cache, but then we'd have to keep track of the block groups in cache_save_setup()
3256 * that fail this way so we know we _have_ to reset this cache in cache_save_setup()
3257 * before the next commit or risk reading stale cache. So to in cache_save_setup()
3268 if (block_group->cache_generation == trans->transid && in cache_save_setup()
3276 &fs_info->global_block_rsv); in cache_save_setup()
3285 spin_lock(&block_group->lock); in cache_save_setup()
3286 if (block_group->cached != BTRFS_CACHE_FINISHED || in cache_save_setup()
3295 spin_unlock(&block_group->lock); in cache_save_setup()
3298 spin_unlock(&block_group->lock); in cache_save_setup()
3301 * We hit an ENOSPC when setting up the cache in this transaction, just in cache_save_setup()
3302 * skip doing the setup, we've already cleared the cache so we're safe. in cache_save_setup()
3304 if (test_bit(BTRFS_TRANS_CACHE_ENOSPC, &trans->transaction->flags)) { in cache_save_setup()
3305 ret = -ENOSPC; in cache_save_setup()
3310 * Try to preallocate enough space based on how big the block group is. in cache_save_setup()
3313 * cache. in cache_save_setup()
3315 cache_size = div_u64(block_group->length, SZ_256M); in cache_save_setup()
3320 cache_size *= fs_info->sectorsize; in cache_save_setup()
3331 * Our cache requires contiguous chunks so that we don't modify a bunch in cache_save_setup()
3332 * of metadata or split extents when writing the cache out, which means in cache_save_setup()
3335 * other block groups for this transaction, maybe we'll unpin enough in cache_save_setup()
3340 else if (ret == -ENOSPC) in cache_save_setup()
3341 set_bit(BTRFS_TRANS_CACHE_ENOSPC, &trans->transaction->flags); in cache_save_setup()
3348 spin_lock(&block_group->lock); in cache_save_setup()
3350 block_group->cache_generation = trans->transid; in cache_save_setup()
3351 block_group->disk_cache_state = dcs; in cache_save_setup()
3352 spin_unlock(&block_group->lock); in cache_save_setup()
3360 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_setup_space_cache()
3361 struct btrfs_block_group *cache, *tmp; in btrfs_setup_space_cache() local
3362 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_setup_space_cache()
3365 if (list_empty(&cur_trans->dirty_bgs) || in btrfs_setup_space_cache()
3371 return -ENOMEM; in btrfs_setup_space_cache()
3373 /* Could add new block groups, use _safe just in case */ in btrfs_setup_space_cache()
3374 list_for_each_entry_safe(cache, tmp, &cur_trans->dirty_bgs, in btrfs_setup_space_cache()
3376 if (cache->disk_cache_state == BTRFS_DC_CLEAR) in btrfs_setup_space_cache()
3377 cache_save_setup(cache, trans, path); in btrfs_setup_space_cache()
3384 * Transaction commit does final block group cache writeback during a critical
3386 * order for the cache to actually match the block group, but can introduce a
3389 * So, btrfs_start_dirty_block_groups is here to kick off block group cache IO.
3390 * There's a chance we'll have to redo some of it if the block group changes
3392 * getting rid of the easy block groups while we're still allowing others to
3397 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_start_dirty_block_groups()
3398 struct btrfs_block_group *cache; in btrfs_start_dirty_block_groups() local
3399 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_start_dirty_block_groups()
3404 struct list_head *io = &cur_trans->io_bgs; in btrfs_start_dirty_block_groups()
3407 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3408 if (list_empty(&cur_trans->dirty_bgs)) { in btrfs_start_dirty_block_groups()
3409 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3412 list_splice_init(&cur_trans->dirty_bgs, &dirty); in btrfs_start_dirty_block_groups()
3413 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3416 /* Make sure all the block groups on our dirty list actually exist */ in btrfs_start_dirty_block_groups()
3422 ret = -ENOMEM; in btrfs_start_dirty_block_groups()
3429 * removal of empty block groups deleting this block group while we are in btrfs_start_dirty_block_groups()
3430 * writing out the cache in btrfs_start_dirty_block_groups()
3432 mutex_lock(&trans->transaction->cache_write_mutex); in btrfs_start_dirty_block_groups()
3436 cache = list_first_entry(&dirty, struct btrfs_block_group, in btrfs_start_dirty_block_groups()
3439 * This can happen if something re-dirties a block group that in btrfs_start_dirty_block_groups()
3443 if (!list_empty(&cache->io_list)) { in btrfs_start_dirty_block_groups()
3444 list_del_init(&cache->io_list); in btrfs_start_dirty_block_groups()
3445 btrfs_wait_cache_io(trans, cache, path); in btrfs_start_dirty_block_groups()
3446 btrfs_put_block_group(cache); in btrfs_start_dirty_block_groups()
3451 * btrfs_wait_cache_io uses the cache->dirty_list to decide if in btrfs_start_dirty_block_groups()
3458 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3459 list_del_init(&cache->dirty_list); in btrfs_start_dirty_block_groups()
3460 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3464 cache_save_setup(cache, trans, path); in btrfs_start_dirty_block_groups()
3466 if (cache->disk_cache_state == BTRFS_DC_SETUP) { in btrfs_start_dirty_block_groups()
3467 cache->io_ctl.inode = NULL; in btrfs_start_dirty_block_groups()
3468 ret = btrfs_write_out_cache(trans, cache, path); in btrfs_start_dirty_block_groups()
3469 if (ret == 0 && cache->io_ctl.inode) { in btrfs_start_dirty_block_groups()
3477 list_add_tail(&cache->io_list, io); in btrfs_start_dirty_block_groups()
3480 * If we failed to write the cache, the in btrfs_start_dirty_block_groups()
3487 ret = update_block_group_item(trans, path, cache); in btrfs_start_dirty_block_groups()
3489 * Our block group might still be attached to the list in btrfs_start_dirty_block_groups()
3490 * of new block groups in the transaction handle of some in btrfs_start_dirty_block_groups()
3491 * other task (struct btrfs_trans_handle->new_bgs). This in btrfs_start_dirty_block_groups()
3492 * means its block group item isn't yet in the extent in btrfs_start_dirty_block_groups()
3497 if (ret == -ENOENT) { in btrfs_start_dirty_block_groups()
3499 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3500 if (list_empty(&cache->dirty_list)) { in btrfs_start_dirty_block_groups()
3501 list_add_tail(&cache->dirty_list, in btrfs_start_dirty_block_groups()
3502 &cur_trans->dirty_bgs); in btrfs_start_dirty_block_groups()
3503 btrfs_get_block_group(cache); in btrfs_start_dirty_block_groups()
3506 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3512 /* If it's not on the io list, we need to put the block group */ in btrfs_start_dirty_block_groups()
3514 btrfs_put_block_group(cache); in btrfs_start_dirty_block_groups()
3519 * us from writing caches for block groups that are going to be in btrfs_start_dirty_block_groups()
3522 mutex_unlock(&trans->transaction->cache_write_mutex); in btrfs_start_dirty_block_groups()
3525 mutex_lock(&trans->transaction->cache_write_mutex); in btrfs_start_dirty_block_groups()
3527 mutex_unlock(&trans->transaction->cache_write_mutex); in btrfs_start_dirty_block_groups()
3537 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3538 list_splice_init(&cur_trans->dirty_bgs, &dirty); in btrfs_start_dirty_block_groups()
3540 * dirty_bgs_lock protects us from concurrent block group in btrfs_start_dirty_block_groups()
3544 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3547 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3551 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3552 list_splice_init(&dirty, &cur_trans->dirty_bgs); in btrfs_start_dirty_block_groups()
3553 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_start_dirty_block_groups()
3562 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_write_dirty_block_groups()
3563 struct btrfs_block_group *cache; in btrfs_write_dirty_block_groups() local
3564 struct btrfs_transaction *cur_trans = trans->transaction; in btrfs_write_dirty_block_groups()
3568 struct list_head *io = &cur_trans->io_bgs; in btrfs_write_dirty_block_groups()
3572 return -ENOMEM; in btrfs_write_dirty_block_groups()
3577 * transaction's list of dirty block groups. These tasks correspond to in btrfs_write_dirty_block_groups()
3579 * space cache, which run inode.c:btrfs_finish_ordered_io(), and can in btrfs_write_dirty_block_groups()
3580 * allocate new block groups as a result of COWing nodes of the root in btrfs_write_dirty_block_groups()
3589 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_write_dirty_block_groups()
3590 while (!list_empty(&cur_trans->dirty_bgs)) { in btrfs_write_dirty_block_groups()
3591 cache = list_first_entry(&cur_trans->dirty_bgs, in btrfs_write_dirty_block_groups()
3596 * This can happen if cache_save_setup re-dirties a block group in btrfs_write_dirty_block_groups()
3600 if (!list_empty(&cache->io_list)) { in btrfs_write_dirty_block_groups()
3601 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_write_dirty_block_groups()
3602 list_del_init(&cache->io_list); in btrfs_write_dirty_block_groups()
3603 btrfs_wait_cache_io(trans, cache, path); in btrfs_write_dirty_block_groups()
3604 btrfs_put_block_group(cache); in btrfs_write_dirty_block_groups()
3605 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_write_dirty_block_groups()
3612 list_del_init(&cache->dirty_list); in btrfs_write_dirty_block_groups()
3613 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_write_dirty_block_groups()
3616 cache_save_setup(cache, trans, path); in btrfs_write_dirty_block_groups()
3621 if (!ret && cache->disk_cache_state == BTRFS_DC_SETUP) { in btrfs_write_dirty_block_groups()
3622 cache->io_ctl.inode = NULL; in btrfs_write_dirty_block_groups()
3623 ret = btrfs_write_out_cache(trans, cache, path); in btrfs_write_dirty_block_groups()
3624 if (ret == 0 && cache->io_ctl.inode) { in btrfs_write_dirty_block_groups()
3626 list_add_tail(&cache->io_list, io); in btrfs_write_dirty_block_groups()
3629 * If we failed to write the cache, the in btrfs_write_dirty_block_groups()
3636 ret = update_block_group_item(trans, path, cache); in btrfs_write_dirty_block_groups()
3639 * created a new block group while updating a free space in btrfs_write_dirty_block_groups()
3640 * cache's inode (at inode.c:btrfs_finish_ordered_io()) in btrfs_write_dirty_block_groups()
3642 * which case the new block group is still attached to in btrfs_write_dirty_block_groups()
3644 * finished yet (no block group item in the extent tree in btrfs_write_dirty_block_groups()
3650 if (ret == -ENOENT) { in btrfs_write_dirty_block_groups()
3651 wait_event(cur_trans->writer_wait, in btrfs_write_dirty_block_groups()
3652 atomic_read(&cur_trans->num_writers) == 1); in btrfs_write_dirty_block_groups()
3653 ret = update_block_group_item(trans, path, cache); in btrfs_write_dirty_block_groups()
3661 /* If its not on the io list, we need to put the block group */ in btrfs_write_dirty_block_groups()
3663 btrfs_put_block_group(cache); in btrfs_write_dirty_block_groups()
3665 spin_lock(&cur_trans->dirty_bgs_lock); in btrfs_write_dirty_block_groups()
3667 spin_unlock(&cur_trans->dirty_bgs_lock); in btrfs_write_dirty_block_groups()
3674 cache = list_first_entry(io, struct btrfs_block_group, in btrfs_write_dirty_block_groups()
3676 list_del_init(&cache->io_list); in btrfs_write_dirty_block_groups()
3677 btrfs_wait_cache_io(trans, cache, path); in btrfs_write_dirty_block_groups()
3678 btrfs_put_block_group(cache); in btrfs_write_dirty_block_groups()
3687 struct btrfs_fs_info *info = trans->fs_info; in btrfs_update_block_group()
3689 struct btrfs_block_group *cache; in btrfs_update_block_group() local
3695 /* Block accounting for super block */ in btrfs_update_block_group()
3696 spin_lock(&info->delalloc_root_lock); in btrfs_update_block_group()
3697 old_val = btrfs_super_bytes_used(info->super_copy); in btrfs_update_block_group()
3701 old_val -= num_bytes; in btrfs_update_block_group()
3702 btrfs_set_super_bytes_used(info->super_copy, old_val); in btrfs_update_block_group()
3703 spin_unlock(&info->delalloc_root_lock); in btrfs_update_block_group()
3705 cache = btrfs_lookup_block_group(info, bytenr); in btrfs_update_block_group()
3706 if (!cache) in btrfs_update_block_group()
3707 return -ENOENT; in btrfs_update_block_group()
3709 /* An extent can not span multiple block groups. */ in btrfs_update_block_group()
3710 ASSERT(bytenr + num_bytes <= cache->start + cache->length); in btrfs_update_block_group()
3712 space_info = cache->space_info; in btrfs_update_block_group()
3713 factor = btrfs_bg_type_to_factor(cache->flags); in btrfs_update_block_group()
3716 * If this block group has free space cache written out, we need to make in btrfs_update_block_group()
3718 * the unpinning stage to actually add the space back to the block group, in btrfs_update_block_group()
3721 if (!alloc && !btrfs_block_group_done(cache)) in btrfs_update_block_group()
3722 btrfs_cache_block_group(cache, true); in btrfs_update_block_group()
3724 spin_lock(&space_info->lock); in btrfs_update_block_group()
3725 spin_lock(&cache->lock); in btrfs_update_block_group()
3728 cache->disk_cache_state < BTRFS_DC_CLEAR) in btrfs_update_block_group()
3729 cache->disk_cache_state = BTRFS_DC_CLEAR; in btrfs_update_block_group()
3731 old_val = cache->used; in btrfs_update_block_group()
3734 cache->used = old_val; in btrfs_update_block_group()
3735 cache->reserved -= num_bytes; in btrfs_update_block_group()
3736 cache->reclaim_mark = 0; in btrfs_update_block_group()
3737 space_info->bytes_reserved -= num_bytes; in btrfs_update_block_group()
3738 space_info->bytes_used += num_bytes; in btrfs_update_block_group()
3739 space_info->disk_used += num_bytes * factor; in btrfs_update_block_group()
3740 if (READ_ONCE(space_info->periodic_reclaim)) in btrfs_update_block_group()
3741 btrfs_space_info_update_reclaimable(space_info, -num_bytes); in btrfs_update_block_group()
3742 spin_unlock(&cache->lock); in btrfs_update_block_group()
3743 spin_unlock(&space_info->lock); in btrfs_update_block_group()
3745 old_val -= num_bytes; in btrfs_update_block_group()
3746 cache->used = old_val; in btrfs_update_block_group()
3747 cache->pinned += num_bytes; in btrfs_update_block_group()
3749 space_info->bytes_used -= num_bytes; in btrfs_update_block_group()
3750 space_info->disk_used -= num_bytes * factor; in btrfs_update_block_group()
3751 if (READ_ONCE(space_info->periodic_reclaim)) in btrfs_update_block_group()
3754 reclaim = should_reclaim_block_group(cache, num_bytes); in btrfs_update_block_group()
3756 spin_unlock(&cache->lock); in btrfs_update_block_group()
3757 spin_unlock(&space_info->lock); in btrfs_update_block_group()
3759 btrfs_set_extent_bit(&trans->transaction->pinned_extents, bytenr, in btrfs_update_block_group()
3760 bytenr + num_bytes - 1, EXTENT_DIRTY, NULL); in btrfs_update_block_group()
3763 spin_lock(&trans->transaction->dirty_bgs_lock); in btrfs_update_block_group()
3764 if (list_empty(&cache->dirty_list)) { in btrfs_update_block_group()
3765 list_add_tail(&cache->dirty_list, &trans->transaction->dirty_bgs); in btrfs_update_block_group()
3767 btrfs_get_block_group(cache); in btrfs_update_block_group()
3769 spin_unlock(&trans->transaction->dirty_bgs_lock); in btrfs_update_block_group()
3772 * No longer have used bytes in this block group, queue it for deletion. in btrfs_update_block_group()
3773 * We do this after adding the block group to the dirty list to avoid in btrfs_update_block_group()
3774 * races between cleaner kthread and space cache writeout. in btrfs_update_block_group()
3778 btrfs_mark_bg_unused(cache); in btrfs_update_block_group()
3780 btrfs_mark_bg_to_reclaim(cache); in btrfs_update_block_group()
3783 btrfs_put_block_group(cache); in btrfs_update_block_group()
3785 /* Modified block groups are accounted for in the delayed_refs_rsv. */ in btrfs_update_block_group()
3795 * @cache: The cache we are manipulating
3802 * reservation and the block group has become read only we cannot make the
3803 * reservation and return -EAGAIN, otherwise this function always succeeds.
3805 int btrfs_add_reserved_bytes(struct btrfs_block_group *cache, in btrfs_add_reserved_bytes() argument
3809 struct btrfs_space_info *space_info = cache->space_info; in btrfs_add_reserved_bytes()
3813 spin_lock(&space_info->lock); in btrfs_add_reserved_bytes()
3814 spin_lock(&cache->lock); in btrfs_add_reserved_bytes()
3815 if (cache->ro) { in btrfs_add_reserved_bytes()
3816 ret = -EAGAIN; in btrfs_add_reserved_bytes()
3820 if (btrfs_block_group_should_use_size_class(cache)) { in btrfs_add_reserved_bytes()
3822 ret = btrfs_use_block_group_size_class(cache, size_class, force_wrong_size_class); in btrfs_add_reserved_bytes()
3826 cache->reserved += num_bytes; in btrfs_add_reserved_bytes()
3827 space_info->bytes_reserved += num_bytes; in btrfs_add_reserved_bytes()
3828 trace_btrfs_space_reservation(cache->fs_info, "space_info", in btrfs_add_reserved_bytes()
3829 space_info->flags, num_bytes, 1); in btrfs_add_reserved_bytes()
3830 btrfs_space_info_update_bytes_may_use(space_info, -ram_bytes); in btrfs_add_reserved_bytes()
3832 cache->delalloc_bytes += num_bytes; in btrfs_add_reserved_bytes()
3839 btrfs_try_granting_tickets(cache->fs_info, space_info); in btrfs_add_reserved_bytes()
3841 spin_unlock(&cache->lock); in btrfs_add_reserved_bytes()
3842 spin_unlock(&space_info->lock); in btrfs_add_reserved_bytes()
3849 * @cache: The cache we are manipulating.
3858 void btrfs_free_reserved_bytes(struct btrfs_block_group *cache, u64 num_bytes, in btrfs_free_reserved_bytes() argument
3861 struct btrfs_space_info *space_info = cache->space_info; in btrfs_free_reserved_bytes()
3863 spin_lock(&space_info->lock); in btrfs_free_reserved_bytes()
3864 spin_lock(&cache->lock); in btrfs_free_reserved_bytes()
3865 if (cache->ro) in btrfs_free_reserved_bytes()
3866 space_info->bytes_readonly += num_bytes; in btrfs_free_reserved_bytes()
3867 else if (btrfs_is_zoned(cache->fs_info)) in btrfs_free_reserved_bytes()
3868 space_info->bytes_zone_unusable += num_bytes; in btrfs_free_reserved_bytes()
3869 cache->reserved -= num_bytes; in btrfs_free_reserved_bytes()
3870 space_info->bytes_reserved -= num_bytes; in btrfs_free_reserved_bytes()
3871 space_info->max_extent_size = 0; in btrfs_free_reserved_bytes()
3874 cache->delalloc_bytes -= num_bytes; in btrfs_free_reserved_bytes()
3875 spin_unlock(&cache->lock); in btrfs_free_reserved_bytes()
3877 btrfs_try_granting_tickets(cache->fs_info, space_info); in btrfs_free_reserved_bytes()
3878 spin_unlock(&space_info->lock); in btrfs_free_reserved_bytes()
3883 struct list_head *head = &info->space_info; in force_metadata_allocation()
3887 if (found->flags & BTRFS_BLOCK_GROUP_METADATA) in force_metadata_allocation()
3888 found->force_alloc = CHUNK_ALLOC_FORCE; in force_metadata_allocation()
3903 * about 1% of the FS size. in should_alloc_chunk()
3906 thresh = btrfs_super_total_bytes(fs_info->super_copy); in should_alloc_chunk()
3909 if (sinfo->total_bytes - bytes_used < thresh) in should_alloc_chunk()
3913 if (bytes_used + SZ_2M < mult_perc(sinfo->total_bytes, 80)) in should_alloc_chunk()
3920 u64 alloc_flags = btrfs_get_alloc_profile(trans->fs_info, type); in btrfs_force_chunk_alloc()
3923 space_info = btrfs_find_space_info(trans->fs_info, type); in btrfs_force_chunk_alloc()
3926 return -EINVAL; in btrfs_force_chunk_alloc()
3943 * system block group if needed. in do_chunk_alloc()
3955 * Normally we are not expected to fail with -ENOSPC here, since we have in do_chunk_alloc()
3960 * existing system block groups have a profile which can not be used in do_chunk_alloc()
3967 * none of the block groups can be used for extent allocation since they in do_chunk_alloc()
3971 * block groups and check if they have a usable profile and enough space in do_chunk_alloc()
3972 * can be slow on very large filesystems, so we tolerate the -ENOSPC and in do_chunk_alloc()
3978 * block group to allocate from when we called check_system_chunk() in do_chunk_alloc()
3979 * above. However right after we called it, the only system block group in do_chunk_alloc()
3983 * handle and scrub uses the commit root to search for block groups; in do_chunk_alloc()
3985 * 3) We had one system block group with enough free space when we called in do_chunk_alloc()
3989 * block group (discard removes a free space entry, discards it, and in do_chunk_alloc()
3990 * then adds back the entry to the block group cache). in do_chunk_alloc()
3992 if (ret == -ENOSPC) { in do_chunk_alloc()
3993 const u64 sys_flags = btrfs_system_alloc_profile(trans->fs_info); in do_chunk_alloc()
3997 sys_space_info = btrfs_find_space_info(trans->fs_info, sys_flags); in do_chunk_alloc()
3999 ret = -EINVAL; in do_chunk_alloc()
4039 * 1) Phase 1 - through btrfs_chunk_alloc() we allocate device extents for
4040 * the chunk, the chunk mapping, create its block group and add the items
4041 * that belong in the chunk btree to it - more specifically, we need to
4044 * 2) Phase 2 - through btrfs_create_pending_block_groups(), we add the block
4050 * trigger chunk allocation and attempted to insert the new block group item
4061 * allocate a new block group (chunk) because the only one that had enough
4063 * device replace, block group reclaim thread, etc), so we can not use it
4068 * the filesystem was mounted in degraded mode, none of the existing block
4070 * profile (for e.g. mounting a 2 devices filesystem, where all block groups
4073 * example, it will trigger allocation of a new metadata block group with a
4079 * example, it does not find any free extent in any metadata block group,
4080 * therefore forced to try to allocate a new metadata block group.
4082 * meanwhile - this typically happens with tasks that don't reserve space
4091 * the only metadata block group that had free space (discard starts by
4092 * removing a free space entry from a block group, then does the discard
4094 * block group).
4097 * a seed device - we must create new metadata and system chunks without adding
4098 * any of the block group items to the chunk, extent and device btrees. If we
4100 * btrees, since all the chunks from the seed device are read-only.
4107 * superblock. This is easier to trigger if using a btree node/leaf size of 64K
4115 * btrfs_reserve_chunk_metadata() - the former is used when allocating a data or
4117 * a modification to the chunk btree - use cases for the later are adding,
4123 * holding fs_info->chunk_mutex. This is important to guarantee that while COWing
4129 * that mutex. The same logic applies to removing chunks - we must reserve system
4131 * while holding fs_info->chunk_mutex.
4138 * - return 1 if it successfully allocates a chunk,
4139 * - return errors including -ENOSPC otherwise.
4141 * - return 0 if it doesn't need to allocate a new chunk,
4142 * - return 1 if it successfully allocates a chunk,
4143 * - return errors including -ENOSPC otherwise.
4149 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_chunk_alloc()
4161 /* Don't re-enter if we're already allocating a chunk */ in btrfs_chunk_alloc()
4162 if (trans->allocating_chunk) in btrfs_chunk_alloc()
4163 return -ENOSPC; in btrfs_chunk_alloc()
4173 * lock on it and on its parent - if the COW operation triggers a system in btrfs_chunk_alloc()
4182 * here - this happens in the cases described above at do_chunk_alloc(). in btrfs_chunk_alloc()
4186 return -ENOSPC; in btrfs_chunk_alloc()
4189 spin_lock(&space_info->lock); in btrfs_chunk_alloc()
4190 if (force < space_info->force_alloc) in btrfs_chunk_alloc()
4191 force = space_info->force_alloc; in btrfs_chunk_alloc()
4193 if (space_info->full) { in btrfs_chunk_alloc()
4196 ret = -ENOSPC; in btrfs_chunk_alloc()
4199 spin_unlock(&space_info->lock); in btrfs_chunk_alloc()
4202 spin_unlock(&space_info->lock); in btrfs_chunk_alloc()
4204 } else if (space_info->chunk_alloc) { in btrfs_chunk_alloc()
4206 * Someone is already allocating, so we need to block in btrfs_chunk_alloc()
4213 spin_unlock(&space_info->lock); in btrfs_chunk_alloc()
4214 mutex_lock(&fs_info->chunk_mutex); in btrfs_chunk_alloc()
4215 mutex_unlock(&fs_info->chunk_mutex); in btrfs_chunk_alloc()
4218 space_info->chunk_alloc = 1; in btrfs_chunk_alloc()
4220 spin_unlock(&space_info->lock); in btrfs_chunk_alloc()
4226 mutex_lock(&fs_info->chunk_mutex); in btrfs_chunk_alloc()
4227 trans->allocating_chunk = true; in btrfs_chunk_alloc()
4241 if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) { in btrfs_chunk_alloc()
4242 fs_info->data_chunk_allocations++; in btrfs_chunk_alloc()
4243 if (!(fs_info->data_chunk_allocations % in btrfs_chunk_alloc()
4244 fs_info->metadata_ratio)) in btrfs_chunk_alloc()
4249 trans->allocating_chunk = false; in btrfs_chunk_alloc()
4255 * New block group is likely to be used soon. Try to activate in btrfs_chunk_alloc()
4264 spin_lock(&space_info->lock); in btrfs_chunk_alloc()
4266 if (ret == -ENOSPC) in btrfs_chunk_alloc()
4267 space_info->full = 1; in btrfs_chunk_alloc()
4272 space_info->max_extent_size = 0; in btrfs_chunk_alloc()
4275 space_info->force_alloc = CHUNK_ALLOC_NO_FORCE; in btrfs_chunk_alloc()
4277 space_info->chunk_alloc = 0; in btrfs_chunk_alloc()
4278 spin_unlock(&space_info->lock); in btrfs_chunk_alloc()
4279 mutex_unlock(&fs_info->chunk_mutex); in btrfs_chunk_alloc()
4290 num_dev = fs_info->fs_devices->rw_devices; in get_profile_num_devs()
4299 struct btrfs_fs_info *fs_info = trans->fs_info; in reserve_chunk_space()
4306 * atomic and race free space reservation in the chunk block reserve. in reserve_chunk_space()
4308 lockdep_assert_held(&fs_info->chunk_mutex); in reserve_chunk_space()
4311 spin_lock(&info->lock); in reserve_chunk_space()
4312 left = info->total_bytes - btrfs_space_info_used(info, true); in reserve_chunk_space()
4313 spin_unlock(&info->lock); in reserve_chunk_space()
4352 * the cases described at do_chunk_alloc() - the system in reserve_chunk_space()
4353 * block group we just created was just turned into RO in reserve_chunk_space()
4363 &fs_info->chunk_block_rsv, in reserve_chunk_space()
4366 trans->chunk_bytes_reserved += bytes; in reserve_chunk_space()
4372 * The caller must be holding fs_info->chunk_mutex.
4376 struct btrfs_fs_info *fs_info = trans->fs_info; in check_system_chunk()
4397 * block group allocation and removal, to avoid a deadlock with a concurrent
4398 * task that is allocating a metadata or data block group and therefore needs to
4406 struct btrfs_fs_info *fs_info = trans->fs_info; in btrfs_reserve_chunk_metadata()
4414 mutex_lock(&fs_info->chunk_mutex); in btrfs_reserve_chunk_metadata()
4416 mutex_unlock(&fs_info->chunk_mutex); in btrfs_reserve_chunk_metadata()
4426 spin_lock(&block_group->lock); in btrfs_put_block_group_cache()
4428 &block_group->runtime_flags)) { in btrfs_put_block_group_cache()
4429 struct btrfs_inode *inode = block_group->inode; in btrfs_put_block_group_cache()
4431 block_group->inode = NULL; in btrfs_put_block_group_cache()
4432 spin_unlock(&block_group->lock); in btrfs_put_block_group_cache()
4434 ASSERT(block_group->io_ctl.inode == NULL); in btrfs_put_block_group_cache()
4435 iput(&inode->vfs_inode); in btrfs_put_block_group_cache()
4437 spin_unlock(&block_group->lock); in btrfs_put_block_group_cache()
4445 struct btrfs_fs_info *info = space_info->fs_info; in check_removing_space_info()
4447 if (space_info->subgroup_id == BTRFS_SUB_GROUP_PRIMARY) { in check_removing_space_info()
4449 for (int i = 0; i < BTRFS_SPACE_INFO_SUB_GROUP_MAX; i++) { in check_removing_space_info() local
4450 if (space_info->sub_group[i]) { in check_removing_space_info()
4451 check_removing_space_info(space_info->sub_group[i]); in check_removing_space_info()
4452 kfree(space_info->sub_group[i]); in check_removing_space_info()
4453 space_info->sub_group[i] = NULL; in check_removing_space_info()
4462 if (WARN_ON(space_info->bytes_pinned > 0 || space_info->bytes_may_use > 0)) in check_removing_space_info()
4471 if (!(space_info->flags & BTRFS_BLOCK_GROUP_METADATA) || in check_removing_space_info()
4473 if (WARN_ON(space_info->bytes_reserved > 0)) in check_removing_space_info()
4477 WARN_ON(space_info->reclaim_size > 0); in check_removing_space_info()
4481 * Must be called only after stopping all workers, since we could have block
4483 * freed the block groups before stopping them.
4493 if (info->active_meta_bg) { in btrfs_free_block_groups()
4494 btrfs_put_block_group(info->active_meta_bg); in btrfs_free_block_groups()
4495 info->active_meta_bg = NULL; in btrfs_free_block_groups()
4497 if (info->active_system_bg) { in btrfs_free_block_groups()
4498 btrfs_put_block_group(info->active_system_bg); in btrfs_free_block_groups()
4499 info->active_system_bg = NULL; in btrfs_free_block_groups()
4503 write_lock(&info->block_group_cache_lock); in btrfs_free_block_groups()
4504 while (!list_empty(&info->caching_block_groups)) { in btrfs_free_block_groups()
4505 caching_ctl = list_first_entry(&info->caching_block_groups, in btrfs_free_block_groups()
4507 list_del(&caching_ctl->list); in btrfs_free_block_groups()
4510 write_unlock(&info->block_group_cache_lock); in btrfs_free_block_groups()
4512 spin_lock(&info->unused_bgs_lock); in btrfs_free_block_groups()
4513 while (!list_empty(&info->unused_bgs)) { in btrfs_free_block_groups()
4514 block_group = list_first_entry(&info->unused_bgs, in btrfs_free_block_groups()
4517 list_del_init(&block_group->bg_list); in btrfs_free_block_groups()
4521 while (!list_empty(&info->reclaim_bgs)) { in btrfs_free_block_groups()
4522 block_group = list_first_entry(&info->reclaim_bgs, in btrfs_free_block_groups()
4525 list_del_init(&block_group->bg_list); in btrfs_free_block_groups()
4528 spin_unlock(&info->unused_bgs_lock); in btrfs_free_block_groups()
4530 spin_lock(&info->zone_active_bgs_lock); in btrfs_free_block_groups()
4531 while (!list_empty(&info->zone_active_bgs)) { in btrfs_free_block_groups()
4532 block_group = list_first_entry(&info->zone_active_bgs, in btrfs_free_block_groups()
4535 list_del_init(&block_group->active_bg_list); in btrfs_free_block_groups()
4538 spin_unlock(&info->zone_active_bgs_lock); in btrfs_free_block_groups()
4540 write_lock(&info->block_group_cache_lock); in btrfs_free_block_groups()
4541 while ((n = rb_last(&info->block_group_cache_tree.rb_root)) != NULL) { in btrfs_free_block_groups()
4544 rb_erase_cached(&block_group->cache_node, in btrfs_free_block_groups()
4545 &info->block_group_cache_tree); in btrfs_free_block_groups()
4546 RB_CLEAR_NODE(&block_group->cache_node); in btrfs_free_block_groups()
4547 write_unlock(&info->block_group_cache_lock); in btrfs_free_block_groups()
4549 down_write(&block_group->space_info->groups_sem); in btrfs_free_block_groups()
4550 list_del(&block_group->list); in btrfs_free_block_groups()
4551 up_write(&block_group->space_info->groups_sem); in btrfs_free_block_groups()
4554 * We haven't cached this block group, which means we could in btrfs_free_block_groups()
4555 * possibly have excluded extents on this block group. in btrfs_free_block_groups()
4557 if (block_group->cached == BTRFS_CACHE_NO || in btrfs_free_block_groups()
4558 block_group->cached == BTRFS_CACHE_ERROR) in btrfs_free_block_groups()
4562 ASSERT(block_group->cached != BTRFS_CACHE_STARTED); in btrfs_free_block_groups()
4563 ASSERT(list_empty(&block_group->dirty_list)); in btrfs_free_block_groups()
4564 ASSERT(list_empty(&block_group->io_list)); in btrfs_free_block_groups()
4565 ASSERT(list_empty(&block_group->bg_list)); in btrfs_free_block_groups()
4566 ASSERT(refcount_read(&block_group->refs) == 1); in btrfs_free_block_groups()
4567 ASSERT(block_group->swap_extents == 0); in btrfs_free_block_groups()
4570 write_lock(&info->block_group_cache_lock); in btrfs_free_block_groups()
4572 write_unlock(&info->block_group_cache_lock); in btrfs_free_block_groups()
4576 while (!list_empty(&info->space_info)) { in btrfs_free_block_groups()
4577 space_info = list_first_entry(&info->space_info, in btrfs_free_block_groups()
4581 list_del(&space_info->list); in btrfs_free_block_groups()
4587 void btrfs_freeze_block_group(struct btrfs_block_group *cache) in btrfs_freeze_block_group() argument
4589 atomic_inc(&cache->frozen); in btrfs_freeze_block_group()
4594 struct btrfs_fs_info *fs_info = block_group->fs_info; in btrfs_unfreeze_block_group()
4597 spin_lock(&block_group->lock); in btrfs_unfreeze_block_group()
4598 cleanup = (atomic_dec_and_test(&block_group->frozen) && in btrfs_unfreeze_block_group()
4599 test_bit(BLOCK_GROUP_FLAG_REMOVED, &block_group->runtime_flags)); in btrfs_unfreeze_block_group()
4600 spin_unlock(&block_group->lock); in btrfs_unfreeze_block_group()
4605 map = btrfs_find_chunk_map(fs_info, block_group->start, 1); in btrfs_unfreeze_block_group()
4616 * tasks trimming this block group have left 1 entry each one. in btrfs_unfreeze_block_group()
4627 spin_lock(&bg->lock); in btrfs_inc_block_group_swap_extents()
4628 if (bg->ro) in btrfs_inc_block_group_swap_extents()
4631 bg->swap_extents++; in btrfs_inc_block_group_swap_extents()
4632 spin_unlock(&bg->lock); in btrfs_inc_block_group_swap_extents()
4639 spin_lock(&bg->lock); in btrfs_dec_block_group_swap_extents()
4640 ASSERT(!bg->ro); in btrfs_dec_block_group_swap_extents()
4641 ASSERT(bg->swap_extents >= amount); in btrfs_dec_block_group_swap_extents()
4642 bg->swap_extents -= amount; in btrfs_dec_block_group_swap_extents()
4643 spin_unlock(&bg->lock); in btrfs_dec_block_group_swap_extents()
4646 enum btrfs_block_group_size_class btrfs_calc_block_group_size_class(u64 size) in btrfs_calc_block_group_size_class() argument
4648 if (size <= SZ_128K) in btrfs_calc_block_group_size_class()
4650 if (size <= SZ_8M) in btrfs_calc_block_group_size_class()
4656 * Handle a block group allocating an extent in a size class
4658 * @bg: The block group we allocated in.
4659 * @size_class: The size class of the allocation.
4661 * mismatched size classes.
4663 * Returns: 0 if the size class was valid for this block_group, -EAGAIN in the
4664 * case of a race that leads to the wrong size class without
4667 * find_free_extent will skip block groups with a mismatched size class until
4669 * force_wrong_size_class. However, if a block group is newly allocated and
4670 * doesn't yet have a size class, then it is possible for two allocations of
4680 /* The new allocation is in the right size class, do nothing */ in btrfs_use_block_group_size_class()
4681 if (bg->size_class == size_class) in btrfs_use_block_group_size_class()
4684 * The new allocation is in a mismatched size class. in btrfs_use_block_group_size_class()
4693 if (bg->size_class != BTRFS_BG_SZ_NONE) { in btrfs_use_block_group_size_class()
4696 return -EAGAIN; in btrfs_use_block_group_size_class()
4699 * The happy new block group case: the new allocation is the first in btrfs_use_block_group_size_class()
4702 bg->size_class = size_class; in btrfs_use_block_group_size_class()
4709 if (btrfs_is_zoned(bg->fs_info)) in btrfs_block_group_should_use_size_class()