12e405ad8SJosef Bacik // SPDX-License-Identifier: GPL-2.0 22e405ad8SJosef Bacik 32ca0ec77SJohannes Thumshirn #include <linux/list_sort.h> 4784352feSDavid Sterba #include "misc.h" 52e405ad8SJosef Bacik #include "ctree.h" 62e405ad8SJosef Bacik #include "block-group.h" 73eeb3226SJosef Bacik #include "space-info.h" 89f21246dSJosef Bacik #include "disk-io.h" 99f21246dSJosef Bacik #include "free-space-cache.h" 109f21246dSJosef Bacik #include "free-space-tree.h" 11e3e0520bSJosef Bacik #include "volumes.h" 12e3e0520bSJosef Bacik #include "transaction.h" 13e3e0520bSJosef Bacik #include "ref-verify.h" 144358d963SJosef Bacik #include "sysfs.h" 154358d963SJosef Bacik #include "tree-log.h" 1677745c05SJosef Bacik #include "delalloc-space.h" 17b0643e59SDennis Zhou #include "discard.h" 1896a14336SNikolay Borisov #include "raid56.h" 1908e11a3dSNaohiro Aota #include "zoned.h" 202e405ad8SJosef Bacik 21878d7b67SJosef Bacik /* 22878d7b67SJosef Bacik * Return target flags in extended format or 0 if restripe for this chunk_type 23878d7b67SJosef Bacik * is not in progress 24878d7b67SJosef Bacik * 25878d7b67SJosef Bacik * Should be called with balance_lock held 26878d7b67SJosef Bacik */ 27e11c0406SJosef Bacik static u64 get_restripe_target(struct btrfs_fs_info *fs_info, u64 flags) 28878d7b67SJosef Bacik { 29878d7b67SJosef Bacik struct btrfs_balance_control *bctl = fs_info->balance_ctl; 30878d7b67SJosef Bacik u64 target = 0; 31878d7b67SJosef Bacik 32878d7b67SJosef Bacik if (!bctl) 33878d7b67SJosef Bacik return 0; 34878d7b67SJosef Bacik 35878d7b67SJosef Bacik if (flags & BTRFS_BLOCK_GROUP_DATA && 36878d7b67SJosef Bacik bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) { 37878d7b67SJosef Bacik target = BTRFS_BLOCK_GROUP_DATA | bctl->data.target; 38878d7b67SJosef Bacik } else if (flags & BTRFS_BLOCK_GROUP_SYSTEM && 39878d7b67SJosef Bacik bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) { 40878d7b67SJosef Bacik target = BTRFS_BLOCK_GROUP_SYSTEM | bctl->sys.target; 41878d7b67SJosef Bacik } else if (flags & BTRFS_BLOCK_GROUP_METADATA && 42878d7b67SJosef Bacik bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) { 43878d7b67SJosef Bacik target = BTRFS_BLOCK_GROUP_METADATA | bctl->meta.target; 44878d7b67SJosef Bacik } 45878d7b67SJosef Bacik 46878d7b67SJosef Bacik return target; 47878d7b67SJosef Bacik } 48878d7b67SJosef Bacik 49878d7b67SJosef Bacik /* 50878d7b67SJosef Bacik * @flags: available profiles in extended format (see ctree.h) 51878d7b67SJosef Bacik * 52878d7b67SJosef Bacik * Return reduced profile in chunk format. If profile changing is in progress 53878d7b67SJosef Bacik * (either running or paused) picks the target profile (if it's already 54878d7b67SJosef Bacik * available), otherwise falls back to plain reducing. 55878d7b67SJosef Bacik */ 56878d7b67SJosef Bacik static u64 btrfs_reduce_alloc_profile(struct btrfs_fs_info *fs_info, u64 flags) 57878d7b67SJosef Bacik { 58878d7b67SJosef Bacik u64 num_devices = fs_info->fs_devices->rw_devices; 59878d7b67SJosef Bacik u64 target; 60878d7b67SJosef Bacik u64 raid_type; 61878d7b67SJosef Bacik u64 allowed = 0; 62878d7b67SJosef Bacik 63878d7b67SJosef Bacik /* 64878d7b67SJosef Bacik * See if restripe for this chunk_type is in progress, if so try to 65878d7b67SJosef Bacik * reduce to the target profile 66878d7b67SJosef Bacik */ 67878d7b67SJosef Bacik spin_lock(&fs_info->balance_lock); 68e11c0406SJosef Bacik target = get_restripe_target(fs_info, flags); 69878d7b67SJosef Bacik if (target) { 70878d7b67SJosef Bacik spin_unlock(&fs_info->balance_lock); 71878d7b67SJosef Bacik return extended_to_chunk(target); 72878d7b67SJosef Bacik } 73878d7b67SJosef Bacik spin_unlock(&fs_info->balance_lock); 74878d7b67SJosef Bacik 75878d7b67SJosef Bacik /* First, mask out the RAID levels which aren't possible */ 76878d7b67SJosef Bacik for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) { 77878d7b67SJosef Bacik if (num_devices >= btrfs_raid_array[raid_type].devs_min) 78878d7b67SJosef Bacik allowed |= btrfs_raid_array[raid_type].bg_flag; 79878d7b67SJosef Bacik } 80878d7b67SJosef Bacik allowed &= flags; 81878d7b67SJosef Bacik 82878d7b67SJosef Bacik if (allowed & BTRFS_BLOCK_GROUP_RAID6) 83878d7b67SJosef Bacik allowed = BTRFS_BLOCK_GROUP_RAID6; 84878d7b67SJosef Bacik else if (allowed & BTRFS_BLOCK_GROUP_RAID5) 85878d7b67SJosef Bacik allowed = BTRFS_BLOCK_GROUP_RAID5; 86878d7b67SJosef Bacik else if (allowed & BTRFS_BLOCK_GROUP_RAID10) 87878d7b67SJosef Bacik allowed = BTRFS_BLOCK_GROUP_RAID10; 88878d7b67SJosef Bacik else if (allowed & BTRFS_BLOCK_GROUP_RAID1) 89878d7b67SJosef Bacik allowed = BTRFS_BLOCK_GROUP_RAID1; 90878d7b67SJosef Bacik else if (allowed & BTRFS_BLOCK_GROUP_RAID0) 91878d7b67SJosef Bacik allowed = BTRFS_BLOCK_GROUP_RAID0; 92878d7b67SJosef Bacik 93878d7b67SJosef Bacik flags &= ~BTRFS_BLOCK_GROUP_PROFILE_MASK; 94878d7b67SJosef Bacik 95878d7b67SJosef Bacik return extended_to_chunk(flags | allowed); 96878d7b67SJosef Bacik } 97878d7b67SJosef Bacik 98ef0a82daSJohannes Thumshirn u64 btrfs_get_alloc_profile(struct btrfs_fs_info *fs_info, u64 orig_flags) 99878d7b67SJosef Bacik { 100878d7b67SJosef Bacik unsigned seq; 101878d7b67SJosef Bacik u64 flags; 102878d7b67SJosef Bacik 103878d7b67SJosef Bacik do { 104878d7b67SJosef Bacik flags = orig_flags; 105878d7b67SJosef Bacik seq = read_seqbegin(&fs_info->profiles_lock); 106878d7b67SJosef Bacik 107878d7b67SJosef Bacik if (flags & BTRFS_BLOCK_GROUP_DATA) 108878d7b67SJosef Bacik flags |= fs_info->avail_data_alloc_bits; 109878d7b67SJosef Bacik else if (flags & BTRFS_BLOCK_GROUP_SYSTEM) 110878d7b67SJosef Bacik flags |= fs_info->avail_system_alloc_bits; 111878d7b67SJosef Bacik else if (flags & BTRFS_BLOCK_GROUP_METADATA) 112878d7b67SJosef Bacik flags |= fs_info->avail_metadata_alloc_bits; 113878d7b67SJosef Bacik } while (read_seqretry(&fs_info->profiles_lock, seq)); 114878d7b67SJosef Bacik 115878d7b67SJosef Bacik return btrfs_reduce_alloc_profile(fs_info, flags); 116878d7b67SJosef Bacik } 117878d7b67SJosef Bacik 11832da5386SDavid Sterba void btrfs_get_block_group(struct btrfs_block_group *cache) 1193cad1284SJosef Bacik { 12048aaeebeSJosef Bacik refcount_inc(&cache->refs); 1213cad1284SJosef Bacik } 1223cad1284SJosef Bacik 12332da5386SDavid Sterba void btrfs_put_block_group(struct btrfs_block_group *cache) 1243cad1284SJosef Bacik { 12548aaeebeSJosef Bacik if (refcount_dec_and_test(&cache->refs)) { 1263cad1284SJosef Bacik WARN_ON(cache->pinned > 0); 1273cad1284SJosef Bacik WARN_ON(cache->reserved > 0); 1283cad1284SJosef Bacik 1293cad1284SJosef Bacik /* 130b0643e59SDennis Zhou * A block_group shouldn't be on the discard_list anymore. 131b0643e59SDennis Zhou * Remove the block_group from the discard_list to prevent us 132b0643e59SDennis Zhou * from causing a panic due to NULL pointer dereference. 133b0643e59SDennis Zhou */ 134b0643e59SDennis Zhou if (WARN_ON(!list_empty(&cache->discard_list))) 135b0643e59SDennis Zhou btrfs_discard_cancel_work(&cache->fs_info->discard_ctl, 136b0643e59SDennis Zhou cache); 137b0643e59SDennis Zhou 138b0643e59SDennis Zhou /* 1393cad1284SJosef Bacik * If not empty, someone is still holding mutex of 1403cad1284SJosef Bacik * full_stripe_lock, which can only be released by caller. 1413cad1284SJosef Bacik * And it will definitely cause use-after-free when caller 1423cad1284SJosef Bacik * tries to release full stripe lock. 1433cad1284SJosef Bacik * 1443cad1284SJosef Bacik * No better way to resolve, but only to warn. 1453cad1284SJosef Bacik */ 1463cad1284SJosef Bacik WARN_ON(!RB_EMPTY_ROOT(&cache->full_stripe_locks_root.root)); 1473cad1284SJosef Bacik kfree(cache->free_space_ctl); 148dafc340dSNaohiro Aota kfree(cache->physical_map); 1493cad1284SJosef Bacik kfree(cache); 1503cad1284SJosef Bacik } 1513cad1284SJosef Bacik } 1523cad1284SJosef Bacik 1532e405ad8SJosef Bacik /* 1544358d963SJosef Bacik * This adds the block group to the fs_info rb tree for the block group cache 1554358d963SJosef Bacik */ 1564358d963SJosef Bacik static int btrfs_add_block_group_cache(struct btrfs_fs_info *info, 15732da5386SDavid Sterba struct btrfs_block_group *block_group) 1584358d963SJosef Bacik { 1594358d963SJosef Bacik struct rb_node **p; 1604358d963SJosef Bacik struct rb_node *parent = NULL; 16132da5386SDavid Sterba struct btrfs_block_group *cache; 1624358d963SJosef Bacik 1639afc6649SQu Wenruo ASSERT(block_group->length != 0); 1649afc6649SQu Wenruo 1654358d963SJosef Bacik spin_lock(&info->block_group_cache_lock); 1664358d963SJosef Bacik p = &info->block_group_cache_tree.rb_node; 1674358d963SJosef Bacik 1684358d963SJosef Bacik while (*p) { 1694358d963SJosef Bacik parent = *p; 17032da5386SDavid Sterba cache = rb_entry(parent, struct btrfs_block_group, cache_node); 171b3470b5dSDavid Sterba if (block_group->start < cache->start) { 1724358d963SJosef Bacik p = &(*p)->rb_left; 173b3470b5dSDavid Sterba } else if (block_group->start > cache->start) { 1744358d963SJosef Bacik p = &(*p)->rb_right; 1754358d963SJosef Bacik } else { 1764358d963SJosef Bacik spin_unlock(&info->block_group_cache_lock); 1774358d963SJosef Bacik return -EEXIST; 1784358d963SJosef Bacik } 1794358d963SJosef Bacik } 1804358d963SJosef Bacik 1814358d963SJosef Bacik rb_link_node(&block_group->cache_node, parent, p); 1824358d963SJosef Bacik rb_insert_color(&block_group->cache_node, 1834358d963SJosef Bacik &info->block_group_cache_tree); 1844358d963SJosef Bacik 185b3470b5dSDavid Sterba if (info->first_logical_byte > block_group->start) 186b3470b5dSDavid Sterba info->first_logical_byte = block_group->start; 1874358d963SJosef Bacik 1884358d963SJosef Bacik spin_unlock(&info->block_group_cache_lock); 1894358d963SJosef Bacik 1904358d963SJosef Bacik return 0; 1914358d963SJosef Bacik } 1924358d963SJosef Bacik 1934358d963SJosef Bacik /* 1942e405ad8SJosef Bacik * This will return the block group at or after bytenr if contains is 0, else 1952e405ad8SJosef Bacik * it will return the block group that contains the bytenr 1962e405ad8SJosef Bacik */ 19732da5386SDavid Sterba static struct btrfs_block_group *block_group_cache_tree_search( 1982e405ad8SJosef Bacik struct btrfs_fs_info *info, u64 bytenr, int contains) 1992e405ad8SJosef Bacik { 20032da5386SDavid Sterba struct btrfs_block_group *cache, *ret = NULL; 2012e405ad8SJosef Bacik struct rb_node *n; 2022e405ad8SJosef Bacik u64 end, start; 2032e405ad8SJosef Bacik 2042e405ad8SJosef Bacik spin_lock(&info->block_group_cache_lock); 2052e405ad8SJosef Bacik n = info->block_group_cache_tree.rb_node; 2062e405ad8SJosef Bacik 2072e405ad8SJosef Bacik while (n) { 20832da5386SDavid Sterba cache = rb_entry(n, struct btrfs_block_group, cache_node); 209b3470b5dSDavid Sterba end = cache->start + cache->length - 1; 210b3470b5dSDavid Sterba start = cache->start; 2112e405ad8SJosef Bacik 2122e405ad8SJosef Bacik if (bytenr < start) { 213b3470b5dSDavid Sterba if (!contains && (!ret || start < ret->start)) 2142e405ad8SJosef Bacik ret = cache; 2152e405ad8SJosef Bacik n = n->rb_left; 2162e405ad8SJosef Bacik } else if (bytenr > start) { 2172e405ad8SJosef Bacik if (contains && bytenr <= end) { 2182e405ad8SJosef Bacik ret = cache; 2192e405ad8SJosef Bacik break; 2202e405ad8SJosef Bacik } 2212e405ad8SJosef Bacik n = n->rb_right; 2222e405ad8SJosef Bacik } else { 2232e405ad8SJosef Bacik ret = cache; 2242e405ad8SJosef Bacik break; 2252e405ad8SJosef Bacik } 2262e405ad8SJosef Bacik } 2272e405ad8SJosef Bacik if (ret) { 2282e405ad8SJosef Bacik btrfs_get_block_group(ret); 229b3470b5dSDavid Sterba if (bytenr == 0 && info->first_logical_byte > ret->start) 230b3470b5dSDavid Sterba info->first_logical_byte = ret->start; 2312e405ad8SJosef Bacik } 2322e405ad8SJosef Bacik spin_unlock(&info->block_group_cache_lock); 2332e405ad8SJosef Bacik 2342e405ad8SJosef Bacik return ret; 2352e405ad8SJosef Bacik } 2362e405ad8SJosef Bacik 2372e405ad8SJosef Bacik /* 2382e405ad8SJosef Bacik * Return the block group that starts at or after bytenr 2392e405ad8SJosef Bacik */ 24032da5386SDavid Sterba struct btrfs_block_group *btrfs_lookup_first_block_group( 2412e405ad8SJosef Bacik struct btrfs_fs_info *info, u64 bytenr) 2422e405ad8SJosef Bacik { 2432e405ad8SJosef Bacik return block_group_cache_tree_search(info, bytenr, 0); 2442e405ad8SJosef Bacik } 2452e405ad8SJosef Bacik 2462e405ad8SJosef Bacik /* 2472e405ad8SJosef Bacik * Return the block group that contains the given bytenr 2482e405ad8SJosef Bacik */ 24932da5386SDavid Sterba struct btrfs_block_group *btrfs_lookup_block_group( 2502e405ad8SJosef Bacik struct btrfs_fs_info *info, u64 bytenr) 2512e405ad8SJosef Bacik { 2522e405ad8SJosef Bacik return block_group_cache_tree_search(info, bytenr, 1); 2532e405ad8SJosef Bacik } 2542e405ad8SJosef Bacik 25532da5386SDavid Sterba struct btrfs_block_group *btrfs_next_block_group( 25632da5386SDavid Sterba struct btrfs_block_group *cache) 2572e405ad8SJosef Bacik { 2582e405ad8SJosef Bacik struct btrfs_fs_info *fs_info = cache->fs_info; 2592e405ad8SJosef Bacik struct rb_node *node; 2602e405ad8SJosef Bacik 2612e405ad8SJosef Bacik spin_lock(&fs_info->block_group_cache_lock); 2622e405ad8SJosef Bacik 2632e405ad8SJosef Bacik /* If our block group was removed, we need a full search. */ 2642e405ad8SJosef Bacik if (RB_EMPTY_NODE(&cache->cache_node)) { 265b3470b5dSDavid Sterba const u64 next_bytenr = cache->start + cache->length; 2662e405ad8SJosef Bacik 2672e405ad8SJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 2682e405ad8SJosef Bacik btrfs_put_block_group(cache); 2692e405ad8SJosef Bacik cache = btrfs_lookup_first_block_group(fs_info, next_bytenr); return cache; 2702e405ad8SJosef Bacik } 2712e405ad8SJosef Bacik node = rb_next(&cache->cache_node); 2722e405ad8SJosef Bacik btrfs_put_block_group(cache); 2732e405ad8SJosef Bacik if (node) { 27432da5386SDavid Sterba cache = rb_entry(node, struct btrfs_block_group, cache_node); 2752e405ad8SJosef Bacik btrfs_get_block_group(cache); 2762e405ad8SJosef Bacik } else 2772e405ad8SJosef Bacik cache = NULL; 2782e405ad8SJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 2792e405ad8SJosef Bacik return cache; 2802e405ad8SJosef Bacik } 2813eeb3226SJosef Bacik 2823eeb3226SJosef Bacik bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr) 2833eeb3226SJosef Bacik { 28432da5386SDavid Sterba struct btrfs_block_group *bg; 2853eeb3226SJosef Bacik bool ret = true; 2863eeb3226SJosef Bacik 2873eeb3226SJosef Bacik bg = btrfs_lookup_block_group(fs_info, bytenr); 2883eeb3226SJosef Bacik if (!bg) 2893eeb3226SJosef Bacik return false; 2903eeb3226SJosef Bacik 2913eeb3226SJosef Bacik spin_lock(&bg->lock); 2923eeb3226SJosef Bacik if (bg->ro) 2933eeb3226SJosef Bacik ret = false; 2943eeb3226SJosef Bacik else 2953eeb3226SJosef Bacik atomic_inc(&bg->nocow_writers); 2963eeb3226SJosef Bacik spin_unlock(&bg->lock); 2973eeb3226SJosef Bacik 2983eeb3226SJosef Bacik /* No put on block group, done by btrfs_dec_nocow_writers */ 2993eeb3226SJosef Bacik if (!ret) 3003eeb3226SJosef Bacik btrfs_put_block_group(bg); 3013eeb3226SJosef Bacik 3023eeb3226SJosef Bacik return ret; 3033eeb3226SJosef Bacik } 3043eeb3226SJosef Bacik 3053eeb3226SJosef Bacik void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr) 3063eeb3226SJosef Bacik { 30732da5386SDavid Sterba struct btrfs_block_group *bg; 3083eeb3226SJosef Bacik 3093eeb3226SJosef Bacik bg = btrfs_lookup_block_group(fs_info, bytenr); 3103eeb3226SJosef Bacik ASSERT(bg); 3113eeb3226SJosef Bacik if (atomic_dec_and_test(&bg->nocow_writers)) 3123eeb3226SJosef Bacik wake_up_var(&bg->nocow_writers); 3133eeb3226SJosef Bacik /* 3143eeb3226SJosef Bacik * Once for our lookup and once for the lookup done by a previous call 3153eeb3226SJosef Bacik * to btrfs_inc_nocow_writers() 3163eeb3226SJosef Bacik */ 3173eeb3226SJosef Bacik btrfs_put_block_group(bg); 3183eeb3226SJosef Bacik btrfs_put_block_group(bg); 3193eeb3226SJosef Bacik } 3203eeb3226SJosef Bacik 32132da5386SDavid Sterba void btrfs_wait_nocow_writers(struct btrfs_block_group *bg) 3223eeb3226SJosef Bacik { 3233eeb3226SJosef Bacik wait_var_event(&bg->nocow_writers, !atomic_read(&bg->nocow_writers)); 3243eeb3226SJosef Bacik } 3253eeb3226SJosef Bacik 3263eeb3226SJosef Bacik void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info, 3273eeb3226SJosef Bacik const u64 start) 3283eeb3226SJosef Bacik { 32932da5386SDavid Sterba struct btrfs_block_group *bg; 3303eeb3226SJosef Bacik 3313eeb3226SJosef Bacik bg = btrfs_lookup_block_group(fs_info, start); 3323eeb3226SJosef Bacik ASSERT(bg); 3333eeb3226SJosef Bacik if (atomic_dec_and_test(&bg->reservations)) 3343eeb3226SJosef Bacik wake_up_var(&bg->reservations); 3353eeb3226SJosef Bacik btrfs_put_block_group(bg); 3363eeb3226SJosef Bacik } 3373eeb3226SJosef Bacik 33832da5386SDavid Sterba void btrfs_wait_block_group_reservations(struct btrfs_block_group *bg) 3393eeb3226SJosef Bacik { 3403eeb3226SJosef Bacik struct btrfs_space_info *space_info = bg->space_info; 3413eeb3226SJosef Bacik 3423eeb3226SJosef Bacik ASSERT(bg->ro); 3433eeb3226SJosef Bacik 3443eeb3226SJosef Bacik if (!(bg->flags & BTRFS_BLOCK_GROUP_DATA)) 3453eeb3226SJosef Bacik return; 3463eeb3226SJosef Bacik 3473eeb3226SJosef Bacik /* 3483eeb3226SJosef Bacik * Our block group is read only but before we set it to read only, 3493eeb3226SJosef Bacik * some task might have had allocated an extent from it already, but it 3503eeb3226SJosef Bacik * has not yet created a respective ordered extent (and added it to a 3513eeb3226SJosef Bacik * root's list of ordered extents). 3523eeb3226SJosef Bacik * Therefore wait for any task currently allocating extents, since the 3533eeb3226SJosef Bacik * block group's reservations counter is incremented while a read lock 3543eeb3226SJosef Bacik * on the groups' semaphore is held and decremented after releasing 3553eeb3226SJosef Bacik * the read access on that semaphore and creating the ordered extent. 3563eeb3226SJosef Bacik */ 3573eeb3226SJosef Bacik down_write(&space_info->groups_sem); 3583eeb3226SJosef Bacik up_write(&space_info->groups_sem); 3593eeb3226SJosef Bacik 3603eeb3226SJosef Bacik wait_var_event(&bg->reservations, !atomic_read(&bg->reservations)); 3613eeb3226SJosef Bacik } 3629f21246dSJosef Bacik 3639f21246dSJosef Bacik struct btrfs_caching_control *btrfs_get_caching_control( 36432da5386SDavid Sterba struct btrfs_block_group *cache) 3659f21246dSJosef Bacik { 3669f21246dSJosef Bacik struct btrfs_caching_control *ctl; 3679f21246dSJosef Bacik 3689f21246dSJosef Bacik spin_lock(&cache->lock); 3699f21246dSJosef Bacik if (!cache->caching_ctl) { 3709f21246dSJosef Bacik spin_unlock(&cache->lock); 3719f21246dSJosef Bacik return NULL; 3729f21246dSJosef Bacik } 3739f21246dSJosef Bacik 3749f21246dSJosef Bacik ctl = cache->caching_ctl; 3759f21246dSJosef Bacik refcount_inc(&ctl->count); 3769f21246dSJosef Bacik spin_unlock(&cache->lock); 3779f21246dSJosef Bacik return ctl; 3789f21246dSJosef Bacik } 3799f21246dSJosef Bacik 3809f21246dSJosef Bacik void btrfs_put_caching_control(struct btrfs_caching_control *ctl) 3819f21246dSJosef Bacik { 3829f21246dSJosef Bacik if (refcount_dec_and_test(&ctl->count)) 3839f21246dSJosef Bacik kfree(ctl); 3849f21246dSJosef Bacik } 3859f21246dSJosef Bacik 3869f21246dSJosef Bacik /* 3879f21246dSJosef Bacik * When we wait for progress in the block group caching, its because our 3889f21246dSJosef Bacik * allocation attempt failed at least once. So, we must sleep and let some 3899f21246dSJosef Bacik * progress happen before we try again. 3909f21246dSJosef Bacik * 3919f21246dSJosef Bacik * This function will sleep at least once waiting for new free space to show 3929f21246dSJosef Bacik * up, and then it will check the block group free space numbers for our min 3939f21246dSJosef Bacik * num_bytes. Another option is to have it go ahead and look in the rbtree for 3949f21246dSJosef Bacik * a free extent of a given size, but this is a good start. 3959f21246dSJosef Bacik * 3969f21246dSJosef Bacik * Callers of this must check if cache->cached == BTRFS_CACHE_ERROR before using 3979f21246dSJosef Bacik * any of the information in this block group. 3989f21246dSJosef Bacik */ 39932da5386SDavid Sterba void btrfs_wait_block_group_cache_progress(struct btrfs_block_group *cache, 4009f21246dSJosef Bacik u64 num_bytes) 4019f21246dSJosef Bacik { 4029f21246dSJosef Bacik struct btrfs_caching_control *caching_ctl; 4039f21246dSJosef Bacik 4049f21246dSJosef Bacik caching_ctl = btrfs_get_caching_control(cache); 4059f21246dSJosef Bacik if (!caching_ctl) 4069f21246dSJosef Bacik return; 4079f21246dSJosef Bacik 40832da5386SDavid Sterba wait_event(caching_ctl->wait, btrfs_block_group_done(cache) || 4099f21246dSJosef Bacik (cache->free_space_ctl->free_space >= num_bytes)); 4109f21246dSJosef Bacik 4119f21246dSJosef Bacik btrfs_put_caching_control(caching_ctl); 4129f21246dSJosef Bacik } 4139f21246dSJosef Bacik 41432da5386SDavid Sterba int btrfs_wait_block_group_cache_done(struct btrfs_block_group *cache) 4159f21246dSJosef Bacik { 4169f21246dSJosef Bacik struct btrfs_caching_control *caching_ctl; 4179f21246dSJosef Bacik int ret = 0; 4189f21246dSJosef Bacik 4199f21246dSJosef Bacik caching_ctl = btrfs_get_caching_control(cache); 4209f21246dSJosef Bacik if (!caching_ctl) 4219f21246dSJosef Bacik return (cache->cached == BTRFS_CACHE_ERROR) ? -EIO : 0; 4229f21246dSJosef Bacik 42332da5386SDavid Sterba wait_event(caching_ctl->wait, btrfs_block_group_done(cache)); 4249f21246dSJosef Bacik if (cache->cached == BTRFS_CACHE_ERROR) 4259f21246dSJosef Bacik ret = -EIO; 4269f21246dSJosef Bacik btrfs_put_caching_control(caching_ctl); 4279f21246dSJosef Bacik return ret; 4289f21246dSJosef Bacik } 4299f21246dSJosef Bacik 430e747853cSJosef Bacik static bool space_cache_v1_done(struct btrfs_block_group *cache) 431e747853cSJosef Bacik { 432e747853cSJosef Bacik bool ret; 433e747853cSJosef Bacik 434e747853cSJosef Bacik spin_lock(&cache->lock); 435e747853cSJosef Bacik ret = cache->cached != BTRFS_CACHE_FAST; 436e747853cSJosef Bacik spin_unlock(&cache->lock); 437e747853cSJosef Bacik 438e747853cSJosef Bacik return ret; 439e747853cSJosef Bacik } 440e747853cSJosef Bacik 441e747853cSJosef Bacik void btrfs_wait_space_cache_v1_finished(struct btrfs_block_group *cache, 442e747853cSJosef Bacik struct btrfs_caching_control *caching_ctl) 443e747853cSJosef Bacik { 444e747853cSJosef Bacik wait_event(caching_ctl->wait, space_cache_v1_done(cache)); 445e747853cSJosef Bacik } 446e747853cSJosef Bacik 4479f21246dSJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 44832da5386SDavid Sterba static void fragment_free_space(struct btrfs_block_group *block_group) 4499f21246dSJosef Bacik { 4509f21246dSJosef Bacik struct btrfs_fs_info *fs_info = block_group->fs_info; 451b3470b5dSDavid Sterba u64 start = block_group->start; 452b3470b5dSDavid Sterba u64 len = block_group->length; 4539f21246dSJosef Bacik u64 chunk = block_group->flags & BTRFS_BLOCK_GROUP_METADATA ? 4549f21246dSJosef Bacik fs_info->nodesize : fs_info->sectorsize; 4559f21246dSJosef Bacik u64 step = chunk << 1; 4569f21246dSJosef Bacik 4579f21246dSJosef Bacik while (len > chunk) { 4589f21246dSJosef Bacik btrfs_remove_free_space(block_group, start, chunk); 4599f21246dSJosef Bacik start += step; 4609f21246dSJosef Bacik if (len < step) 4619f21246dSJosef Bacik len = 0; 4629f21246dSJosef Bacik else 4639f21246dSJosef Bacik len -= step; 4649f21246dSJosef Bacik } 4659f21246dSJosef Bacik } 4669f21246dSJosef Bacik #endif 4679f21246dSJosef Bacik 4689f21246dSJosef Bacik /* 4699f21246dSJosef Bacik * This is only called by btrfs_cache_block_group, since we could have freed 4709f21246dSJosef Bacik * extents we need to check the pinned_extents for any extents that can't be 4719f21246dSJosef Bacik * used yet since their free space will be released as soon as the transaction 4729f21246dSJosef Bacik * commits. 4739f21246dSJosef Bacik */ 47432da5386SDavid Sterba u64 add_new_free_space(struct btrfs_block_group *block_group, u64 start, u64 end) 4759f21246dSJosef Bacik { 4769f21246dSJosef Bacik struct btrfs_fs_info *info = block_group->fs_info; 4779f21246dSJosef Bacik u64 extent_start, extent_end, size, total_added = 0; 4789f21246dSJosef Bacik int ret; 4799f21246dSJosef Bacik 4809f21246dSJosef Bacik while (start < end) { 481fe119a6eSNikolay Borisov ret = find_first_extent_bit(&info->excluded_extents, start, 4829f21246dSJosef Bacik &extent_start, &extent_end, 4839f21246dSJosef Bacik EXTENT_DIRTY | EXTENT_UPTODATE, 4849f21246dSJosef Bacik NULL); 4859f21246dSJosef Bacik if (ret) 4869f21246dSJosef Bacik break; 4879f21246dSJosef Bacik 4889f21246dSJosef Bacik if (extent_start <= start) { 4899f21246dSJosef Bacik start = extent_end + 1; 4909f21246dSJosef Bacik } else if (extent_start > start && extent_start < end) { 4919f21246dSJosef Bacik size = extent_start - start; 4929f21246dSJosef Bacik total_added += size; 493b0643e59SDennis Zhou ret = btrfs_add_free_space_async_trimmed(block_group, 494b0643e59SDennis Zhou start, size); 4959f21246dSJosef Bacik BUG_ON(ret); /* -ENOMEM or logic error */ 4969f21246dSJosef Bacik start = extent_end + 1; 4979f21246dSJosef Bacik } else { 4989f21246dSJosef Bacik break; 4999f21246dSJosef Bacik } 5009f21246dSJosef Bacik } 5019f21246dSJosef Bacik 5029f21246dSJosef Bacik if (start < end) { 5039f21246dSJosef Bacik size = end - start; 5049f21246dSJosef Bacik total_added += size; 505b0643e59SDennis Zhou ret = btrfs_add_free_space_async_trimmed(block_group, start, 506b0643e59SDennis Zhou size); 5079f21246dSJosef Bacik BUG_ON(ret); /* -ENOMEM or logic error */ 5089f21246dSJosef Bacik } 5099f21246dSJosef Bacik 5109f21246dSJosef Bacik return total_added; 5119f21246dSJosef Bacik } 5129f21246dSJosef Bacik 5139f21246dSJosef Bacik static int load_extent_tree_free(struct btrfs_caching_control *caching_ctl) 5149f21246dSJosef Bacik { 51532da5386SDavid Sterba struct btrfs_block_group *block_group = caching_ctl->block_group; 5169f21246dSJosef Bacik struct btrfs_fs_info *fs_info = block_group->fs_info; 51729cbcf40SJosef Bacik struct btrfs_root *extent_root; 5189f21246dSJosef Bacik struct btrfs_path *path; 5199f21246dSJosef Bacik struct extent_buffer *leaf; 5209f21246dSJosef Bacik struct btrfs_key key; 5219f21246dSJosef Bacik u64 total_found = 0; 5229f21246dSJosef Bacik u64 last = 0; 5239f21246dSJosef Bacik u32 nritems; 5249f21246dSJosef Bacik int ret; 5259f21246dSJosef Bacik bool wakeup = true; 5269f21246dSJosef Bacik 5279f21246dSJosef Bacik path = btrfs_alloc_path(); 5289f21246dSJosef Bacik if (!path) 5299f21246dSJosef Bacik return -ENOMEM; 5309f21246dSJosef Bacik 531b3470b5dSDavid Sterba last = max_t(u64, block_group->start, BTRFS_SUPER_INFO_OFFSET); 53229cbcf40SJosef Bacik extent_root = btrfs_extent_root(fs_info, last); 5339f21246dSJosef Bacik 5349f21246dSJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 5359f21246dSJosef Bacik /* 5369f21246dSJosef Bacik * If we're fragmenting we don't want to make anybody think we can 5379f21246dSJosef Bacik * allocate from this block group until we've had a chance to fragment 5389f21246dSJosef Bacik * the free space. 5399f21246dSJosef Bacik */ 5409f21246dSJosef Bacik if (btrfs_should_fragment_free_space(block_group)) 5419f21246dSJosef Bacik wakeup = false; 5429f21246dSJosef Bacik #endif 5439f21246dSJosef Bacik /* 5449f21246dSJosef Bacik * We don't want to deadlock with somebody trying to allocate a new 5459f21246dSJosef Bacik * extent for the extent root while also trying to search the extent 5469f21246dSJosef Bacik * root to add free space. So we skip locking and search the commit 5479f21246dSJosef Bacik * root, since its read-only 5489f21246dSJosef Bacik */ 5499f21246dSJosef Bacik path->skip_locking = 1; 5509f21246dSJosef Bacik path->search_commit_root = 1; 5519f21246dSJosef Bacik path->reada = READA_FORWARD; 5529f21246dSJosef Bacik 5539f21246dSJosef Bacik key.objectid = last; 5549f21246dSJosef Bacik key.offset = 0; 5559f21246dSJosef Bacik key.type = BTRFS_EXTENT_ITEM_KEY; 5569f21246dSJosef Bacik 5579f21246dSJosef Bacik next: 5589f21246dSJosef Bacik ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0); 5599f21246dSJosef Bacik if (ret < 0) 5609f21246dSJosef Bacik goto out; 5619f21246dSJosef Bacik 5629f21246dSJosef Bacik leaf = path->nodes[0]; 5639f21246dSJosef Bacik nritems = btrfs_header_nritems(leaf); 5649f21246dSJosef Bacik 5659f21246dSJosef Bacik while (1) { 5669f21246dSJosef Bacik if (btrfs_fs_closing(fs_info) > 1) { 5679f21246dSJosef Bacik last = (u64)-1; 5689f21246dSJosef Bacik break; 5699f21246dSJosef Bacik } 5709f21246dSJosef Bacik 5719f21246dSJosef Bacik if (path->slots[0] < nritems) { 5729f21246dSJosef Bacik btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 5739f21246dSJosef Bacik } else { 5749f21246dSJosef Bacik ret = btrfs_find_next_key(extent_root, path, &key, 0, 0); 5759f21246dSJosef Bacik if (ret) 5769f21246dSJosef Bacik break; 5779f21246dSJosef Bacik 5789f21246dSJosef Bacik if (need_resched() || 5799f21246dSJosef Bacik rwsem_is_contended(&fs_info->commit_root_sem)) { 5809f21246dSJosef Bacik if (wakeup) 5819f21246dSJosef Bacik caching_ctl->progress = last; 5829f21246dSJosef Bacik btrfs_release_path(path); 5839f21246dSJosef Bacik up_read(&fs_info->commit_root_sem); 5849f21246dSJosef Bacik mutex_unlock(&caching_ctl->mutex); 5859f21246dSJosef Bacik cond_resched(); 5869f21246dSJosef Bacik mutex_lock(&caching_ctl->mutex); 5879f21246dSJosef Bacik down_read(&fs_info->commit_root_sem); 5889f21246dSJosef Bacik goto next; 5899f21246dSJosef Bacik } 5909f21246dSJosef Bacik 5919f21246dSJosef Bacik ret = btrfs_next_leaf(extent_root, path); 5929f21246dSJosef Bacik if (ret < 0) 5939f21246dSJosef Bacik goto out; 5949f21246dSJosef Bacik if (ret) 5959f21246dSJosef Bacik break; 5969f21246dSJosef Bacik leaf = path->nodes[0]; 5979f21246dSJosef Bacik nritems = btrfs_header_nritems(leaf); 5989f21246dSJosef Bacik continue; 5999f21246dSJosef Bacik } 6009f21246dSJosef Bacik 6019f21246dSJosef Bacik if (key.objectid < last) { 6029f21246dSJosef Bacik key.objectid = last; 6039f21246dSJosef Bacik key.offset = 0; 6049f21246dSJosef Bacik key.type = BTRFS_EXTENT_ITEM_KEY; 6059f21246dSJosef Bacik 6069f21246dSJosef Bacik if (wakeup) 6079f21246dSJosef Bacik caching_ctl->progress = last; 6089f21246dSJosef Bacik btrfs_release_path(path); 6099f21246dSJosef Bacik goto next; 6109f21246dSJosef Bacik } 6119f21246dSJosef Bacik 612b3470b5dSDavid Sterba if (key.objectid < block_group->start) { 6139f21246dSJosef Bacik path->slots[0]++; 6149f21246dSJosef Bacik continue; 6159f21246dSJosef Bacik } 6169f21246dSJosef Bacik 617b3470b5dSDavid Sterba if (key.objectid >= block_group->start + block_group->length) 6189f21246dSJosef Bacik break; 6199f21246dSJosef Bacik 6209f21246dSJosef Bacik if (key.type == BTRFS_EXTENT_ITEM_KEY || 6219f21246dSJosef Bacik key.type == BTRFS_METADATA_ITEM_KEY) { 6229f21246dSJosef Bacik total_found += add_new_free_space(block_group, last, 6239f21246dSJosef Bacik key.objectid); 6249f21246dSJosef Bacik if (key.type == BTRFS_METADATA_ITEM_KEY) 6259f21246dSJosef Bacik last = key.objectid + 6269f21246dSJosef Bacik fs_info->nodesize; 6279f21246dSJosef Bacik else 6289f21246dSJosef Bacik last = key.objectid + key.offset; 6299f21246dSJosef Bacik 6309f21246dSJosef Bacik if (total_found > CACHING_CTL_WAKE_UP) { 6319f21246dSJosef Bacik total_found = 0; 6329f21246dSJosef Bacik if (wakeup) 6339f21246dSJosef Bacik wake_up(&caching_ctl->wait); 6349f21246dSJosef Bacik } 6359f21246dSJosef Bacik } 6369f21246dSJosef Bacik path->slots[0]++; 6379f21246dSJosef Bacik } 6389f21246dSJosef Bacik ret = 0; 6399f21246dSJosef Bacik 6409f21246dSJosef Bacik total_found += add_new_free_space(block_group, last, 641b3470b5dSDavid Sterba block_group->start + block_group->length); 6429f21246dSJosef Bacik caching_ctl->progress = (u64)-1; 6439f21246dSJosef Bacik 6449f21246dSJosef Bacik out: 6459f21246dSJosef Bacik btrfs_free_path(path); 6469f21246dSJosef Bacik return ret; 6479f21246dSJosef Bacik } 6489f21246dSJosef Bacik 6499f21246dSJosef Bacik static noinline void caching_thread(struct btrfs_work *work) 6509f21246dSJosef Bacik { 65132da5386SDavid Sterba struct btrfs_block_group *block_group; 6529f21246dSJosef Bacik struct btrfs_fs_info *fs_info; 6539f21246dSJosef Bacik struct btrfs_caching_control *caching_ctl; 6549f21246dSJosef Bacik int ret; 6559f21246dSJosef Bacik 6569f21246dSJosef Bacik caching_ctl = container_of(work, struct btrfs_caching_control, work); 6579f21246dSJosef Bacik block_group = caching_ctl->block_group; 6589f21246dSJosef Bacik fs_info = block_group->fs_info; 6599f21246dSJosef Bacik 6609f21246dSJosef Bacik mutex_lock(&caching_ctl->mutex); 6619f21246dSJosef Bacik down_read(&fs_info->commit_root_sem); 6629f21246dSJosef Bacik 663e747853cSJosef Bacik if (btrfs_test_opt(fs_info, SPACE_CACHE)) { 664e747853cSJosef Bacik ret = load_free_space_cache(block_group); 665e747853cSJosef Bacik if (ret == 1) { 666e747853cSJosef Bacik ret = 0; 667e747853cSJosef Bacik goto done; 668e747853cSJosef Bacik } 669e747853cSJosef Bacik 670e747853cSJosef Bacik /* 671e747853cSJosef Bacik * We failed to load the space cache, set ourselves to 672e747853cSJosef Bacik * CACHE_STARTED and carry on. 673e747853cSJosef Bacik */ 674e747853cSJosef Bacik spin_lock(&block_group->lock); 675e747853cSJosef Bacik block_group->cached = BTRFS_CACHE_STARTED; 676e747853cSJosef Bacik spin_unlock(&block_group->lock); 677e747853cSJosef Bacik wake_up(&caching_ctl->wait); 678e747853cSJosef Bacik } 679e747853cSJosef Bacik 6802f96e402SJosef Bacik /* 6812f96e402SJosef Bacik * If we are in the transaction that populated the free space tree we 6822f96e402SJosef Bacik * can't actually cache from the free space tree as our commit root and 6832f96e402SJosef Bacik * real root are the same, so we could change the contents of the blocks 6842f96e402SJosef Bacik * while caching. Instead do the slow caching in this case, and after 6852f96e402SJosef Bacik * the transaction has committed we will be safe. 6862f96e402SJosef Bacik */ 6872f96e402SJosef Bacik if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) && 6882f96e402SJosef Bacik !(test_bit(BTRFS_FS_FREE_SPACE_TREE_UNTRUSTED, &fs_info->flags))) 6899f21246dSJosef Bacik ret = load_free_space_tree(caching_ctl); 6909f21246dSJosef Bacik else 6919f21246dSJosef Bacik ret = load_extent_tree_free(caching_ctl); 692e747853cSJosef Bacik done: 6939f21246dSJosef Bacik spin_lock(&block_group->lock); 6949f21246dSJosef Bacik block_group->caching_ctl = NULL; 6959f21246dSJosef Bacik block_group->cached = ret ? BTRFS_CACHE_ERROR : BTRFS_CACHE_FINISHED; 6969f21246dSJosef Bacik spin_unlock(&block_group->lock); 6979f21246dSJosef Bacik 6989f21246dSJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 6999f21246dSJosef Bacik if (btrfs_should_fragment_free_space(block_group)) { 7009f21246dSJosef Bacik u64 bytes_used; 7019f21246dSJosef Bacik 7029f21246dSJosef Bacik spin_lock(&block_group->space_info->lock); 7039f21246dSJosef Bacik spin_lock(&block_group->lock); 704b3470b5dSDavid Sterba bytes_used = block_group->length - block_group->used; 7059f21246dSJosef Bacik block_group->space_info->bytes_used += bytes_used >> 1; 7069f21246dSJosef Bacik spin_unlock(&block_group->lock); 7079f21246dSJosef Bacik spin_unlock(&block_group->space_info->lock); 708e11c0406SJosef Bacik fragment_free_space(block_group); 7099f21246dSJosef Bacik } 7109f21246dSJosef Bacik #endif 7119f21246dSJosef Bacik 7129f21246dSJosef Bacik caching_ctl->progress = (u64)-1; 7139f21246dSJosef Bacik 7149f21246dSJosef Bacik up_read(&fs_info->commit_root_sem); 7159f21246dSJosef Bacik btrfs_free_excluded_extents(block_group); 7169f21246dSJosef Bacik mutex_unlock(&caching_ctl->mutex); 7179f21246dSJosef Bacik 7189f21246dSJosef Bacik wake_up(&caching_ctl->wait); 7199f21246dSJosef Bacik 7209f21246dSJosef Bacik btrfs_put_caching_control(caching_ctl); 7219f21246dSJosef Bacik btrfs_put_block_group(block_group); 7229f21246dSJosef Bacik } 7239f21246dSJosef Bacik 72432da5386SDavid Sterba int btrfs_cache_block_group(struct btrfs_block_group *cache, int load_cache_only) 7259f21246dSJosef Bacik { 7269f21246dSJosef Bacik DEFINE_WAIT(wait); 7279f21246dSJosef Bacik struct btrfs_fs_info *fs_info = cache->fs_info; 728e747853cSJosef Bacik struct btrfs_caching_control *caching_ctl = NULL; 7299f21246dSJosef Bacik int ret = 0; 7309f21246dSJosef Bacik 7312eda5708SNaohiro Aota /* Allocator for zoned filesystems does not use the cache at all */ 7322eda5708SNaohiro Aota if (btrfs_is_zoned(fs_info)) 7332eda5708SNaohiro Aota return 0; 7342eda5708SNaohiro Aota 7359f21246dSJosef Bacik caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS); 7369f21246dSJosef Bacik if (!caching_ctl) 7379f21246dSJosef Bacik return -ENOMEM; 7389f21246dSJosef Bacik 7399f21246dSJosef Bacik INIT_LIST_HEAD(&caching_ctl->list); 7409f21246dSJosef Bacik mutex_init(&caching_ctl->mutex); 7419f21246dSJosef Bacik init_waitqueue_head(&caching_ctl->wait); 7429f21246dSJosef Bacik caching_ctl->block_group = cache; 743b3470b5dSDavid Sterba caching_ctl->progress = cache->start; 744e747853cSJosef Bacik refcount_set(&caching_ctl->count, 2); 745a0cac0ecSOmar Sandoval btrfs_init_work(&caching_ctl->work, caching_thread, NULL, NULL); 7469f21246dSJosef Bacik 7479f21246dSJosef Bacik spin_lock(&cache->lock); 7489f21246dSJosef Bacik if (cache->cached != BTRFS_CACHE_NO) { 7499f21246dSJosef Bacik kfree(caching_ctl); 750e747853cSJosef Bacik 751e747853cSJosef Bacik caching_ctl = cache->caching_ctl; 752e747853cSJosef Bacik if (caching_ctl) 753e747853cSJosef Bacik refcount_inc(&caching_ctl->count); 754e747853cSJosef Bacik spin_unlock(&cache->lock); 755e747853cSJosef Bacik goto out; 7569f21246dSJosef Bacik } 7579f21246dSJosef Bacik WARN_ON(cache->caching_ctl); 7589f21246dSJosef Bacik cache->caching_ctl = caching_ctl; 759e747853cSJosef Bacik if (btrfs_test_opt(fs_info, SPACE_CACHE)) 7609f21246dSJosef Bacik cache->cached = BTRFS_CACHE_FAST; 761e747853cSJosef Bacik else 7629f21246dSJosef Bacik cache->cached = BTRFS_CACHE_STARTED; 7639f21246dSJosef Bacik cache->has_caching_ctl = 1; 7649f21246dSJosef Bacik spin_unlock(&cache->lock); 7659f21246dSJosef Bacik 766bbb86a37SJosef Bacik spin_lock(&fs_info->block_group_cache_lock); 7679f21246dSJosef Bacik refcount_inc(&caching_ctl->count); 7689f21246dSJosef Bacik list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups); 769bbb86a37SJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 7709f21246dSJosef Bacik 7719f21246dSJosef Bacik btrfs_get_block_group(cache); 7729f21246dSJosef Bacik 7739f21246dSJosef Bacik btrfs_queue_work(fs_info->caching_workers, &caching_ctl->work); 774e747853cSJosef Bacik out: 775e747853cSJosef Bacik if (load_cache_only && caching_ctl) 776e747853cSJosef Bacik btrfs_wait_space_cache_v1_finished(cache, caching_ctl); 777e747853cSJosef Bacik if (caching_ctl) 778e747853cSJosef Bacik btrfs_put_caching_control(caching_ctl); 7799f21246dSJosef Bacik 7809f21246dSJosef Bacik return ret; 7819f21246dSJosef Bacik } 782e3e0520bSJosef Bacik 783e3e0520bSJosef Bacik static void clear_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags) 784e3e0520bSJosef Bacik { 785e3e0520bSJosef Bacik u64 extra_flags = chunk_to_extended(flags) & 786e3e0520bSJosef Bacik BTRFS_EXTENDED_PROFILE_MASK; 787e3e0520bSJosef Bacik 788e3e0520bSJosef Bacik write_seqlock(&fs_info->profiles_lock); 789e3e0520bSJosef Bacik if (flags & BTRFS_BLOCK_GROUP_DATA) 790e3e0520bSJosef Bacik fs_info->avail_data_alloc_bits &= ~extra_flags; 791e3e0520bSJosef Bacik if (flags & BTRFS_BLOCK_GROUP_METADATA) 792e3e0520bSJosef Bacik fs_info->avail_metadata_alloc_bits &= ~extra_flags; 793e3e0520bSJosef Bacik if (flags & BTRFS_BLOCK_GROUP_SYSTEM) 794e3e0520bSJosef Bacik fs_info->avail_system_alloc_bits &= ~extra_flags; 795e3e0520bSJosef Bacik write_sequnlock(&fs_info->profiles_lock); 796e3e0520bSJosef Bacik } 797e3e0520bSJosef Bacik 798e3e0520bSJosef Bacik /* 799e3e0520bSJosef Bacik * Clear incompat bits for the following feature(s): 800e3e0520bSJosef Bacik * 801e3e0520bSJosef Bacik * - RAID56 - in case there's neither RAID5 nor RAID6 profile block group 802e3e0520bSJosef Bacik * in the whole filesystem 8039c907446SDavid Sterba * 8049c907446SDavid Sterba * - RAID1C34 - same as above for RAID1C3 and RAID1C4 block groups 805e3e0520bSJosef Bacik */ 806e3e0520bSJosef Bacik static void clear_incompat_bg_bits(struct btrfs_fs_info *fs_info, u64 flags) 807e3e0520bSJosef Bacik { 8089c907446SDavid Sterba bool found_raid56 = false; 8099c907446SDavid Sterba bool found_raid1c34 = false; 8109c907446SDavid Sterba 8119c907446SDavid Sterba if ((flags & BTRFS_BLOCK_GROUP_RAID56_MASK) || 8129c907446SDavid Sterba (flags & BTRFS_BLOCK_GROUP_RAID1C3) || 8139c907446SDavid Sterba (flags & BTRFS_BLOCK_GROUP_RAID1C4)) { 814e3e0520bSJosef Bacik struct list_head *head = &fs_info->space_info; 815e3e0520bSJosef Bacik struct btrfs_space_info *sinfo; 816e3e0520bSJosef Bacik 817e3e0520bSJosef Bacik list_for_each_entry_rcu(sinfo, head, list) { 818e3e0520bSJosef Bacik down_read(&sinfo->groups_sem); 819e3e0520bSJosef Bacik if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID5])) 8209c907446SDavid Sterba found_raid56 = true; 821e3e0520bSJosef Bacik if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID6])) 8229c907446SDavid Sterba found_raid56 = true; 8239c907446SDavid Sterba if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID1C3])) 8249c907446SDavid Sterba found_raid1c34 = true; 8259c907446SDavid Sterba if (!list_empty(&sinfo->block_groups[BTRFS_RAID_RAID1C4])) 8269c907446SDavid Sterba found_raid1c34 = true; 827e3e0520bSJosef Bacik up_read(&sinfo->groups_sem); 828e3e0520bSJosef Bacik } 829d8e6fd5cSFilipe Manana if (!found_raid56) 830e3e0520bSJosef Bacik btrfs_clear_fs_incompat(fs_info, RAID56); 831d8e6fd5cSFilipe Manana if (!found_raid1c34) 8329c907446SDavid Sterba btrfs_clear_fs_incompat(fs_info, RAID1C34); 833e3e0520bSJosef Bacik } 834e3e0520bSJosef Bacik } 835e3e0520bSJosef Bacik 8367357623aSQu Wenruo static int remove_block_group_item(struct btrfs_trans_handle *trans, 8377357623aSQu Wenruo struct btrfs_path *path, 8387357623aSQu Wenruo struct btrfs_block_group *block_group) 8397357623aSQu Wenruo { 8407357623aSQu Wenruo struct btrfs_fs_info *fs_info = trans->fs_info; 8417357623aSQu Wenruo struct btrfs_root *root; 8427357623aSQu Wenruo struct btrfs_key key; 8437357623aSQu Wenruo int ret; 8447357623aSQu Wenruo 845dfe8aec4SJosef Bacik root = btrfs_block_group_root(fs_info); 8467357623aSQu Wenruo key.objectid = block_group->start; 8477357623aSQu Wenruo key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; 8487357623aSQu Wenruo key.offset = block_group->length; 8497357623aSQu Wenruo 8507357623aSQu Wenruo ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 8517357623aSQu Wenruo if (ret > 0) 8527357623aSQu Wenruo ret = -ENOENT; 8537357623aSQu Wenruo if (ret < 0) 8547357623aSQu Wenruo return ret; 8557357623aSQu Wenruo 8567357623aSQu Wenruo ret = btrfs_del_item(trans, root, path); 8577357623aSQu Wenruo return ret; 8587357623aSQu Wenruo } 8597357623aSQu Wenruo 860e3e0520bSJosef Bacik int btrfs_remove_block_group(struct btrfs_trans_handle *trans, 861e3e0520bSJosef Bacik u64 group_start, struct extent_map *em) 862e3e0520bSJosef Bacik { 863e3e0520bSJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 864e3e0520bSJosef Bacik struct btrfs_path *path; 86532da5386SDavid Sterba struct btrfs_block_group *block_group; 866e3e0520bSJosef Bacik struct btrfs_free_cluster *cluster; 867e3e0520bSJosef Bacik struct inode *inode; 868e3e0520bSJosef Bacik struct kobject *kobj = NULL; 869e3e0520bSJosef Bacik int ret; 870e3e0520bSJosef Bacik int index; 871e3e0520bSJosef Bacik int factor; 872e3e0520bSJosef Bacik struct btrfs_caching_control *caching_ctl = NULL; 873e3e0520bSJosef Bacik bool remove_em; 874e3e0520bSJosef Bacik bool remove_rsv = false; 875e3e0520bSJosef Bacik 876e3e0520bSJosef Bacik block_group = btrfs_lookup_block_group(fs_info, group_start); 877e3e0520bSJosef Bacik BUG_ON(!block_group); 878e3e0520bSJosef Bacik BUG_ON(!block_group->ro); 879e3e0520bSJosef Bacik 880e3e0520bSJosef Bacik trace_btrfs_remove_block_group(block_group); 881e3e0520bSJosef Bacik /* 882e3e0520bSJosef Bacik * Free the reserved super bytes from this block group before 883e3e0520bSJosef Bacik * remove it. 884e3e0520bSJosef Bacik */ 885e3e0520bSJosef Bacik btrfs_free_excluded_extents(block_group); 886b3470b5dSDavid Sterba btrfs_free_ref_tree_range(fs_info, block_group->start, 887b3470b5dSDavid Sterba block_group->length); 888e3e0520bSJosef Bacik 889e3e0520bSJosef Bacik index = btrfs_bg_flags_to_raid_index(block_group->flags); 890e3e0520bSJosef Bacik factor = btrfs_bg_type_to_factor(block_group->flags); 891e3e0520bSJosef Bacik 892e3e0520bSJosef Bacik /* make sure this block group isn't part of an allocation cluster */ 893e3e0520bSJosef Bacik cluster = &fs_info->data_alloc_cluster; 894e3e0520bSJosef Bacik spin_lock(&cluster->refill_lock); 895e3e0520bSJosef Bacik btrfs_return_cluster_to_free_space(block_group, cluster); 896e3e0520bSJosef Bacik spin_unlock(&cluster->refill_lock); 897e3e0520bSJosef Bacik 898e3e0520bSJosef Bacik /* 899e3e0520bSJosef Bacik * make sure this block group isn't part of a metadata 900e3e0520bSJosef Bacik * allocation cluster 901e3e0520bSJosef Bacik */ 902e3e0520bSJosef Bacik cluster = &fs_info->meta_alloc_cluster; 903e3e0520bSJosef Bacik spin_lock(&cluster->refill_lock); 904e3e0520bSJosef Bacik btrfs_return_cluster_to_free_space(block_group, cluster); 905e3e0520bSJosef Bacik spin_unlock(&cluster->refill_lock); 906e3e0520bSJosef Bacik 90740ab3be1SNaohiro Aota btrfs_clear_treelog_bg(block_group); 908c2707a25SJohannes Thumshirn btrfs_clear_data_reloc_bg(block_group); 90940ab3be1SNaohiro Aota 910e3e0520bSJosef Bacik path = btrfs_alloc_path(); 911e3e0520bSJosef Bacik if (!path) { 912e3e0520bSJosef Bacik ret = -ENOMEM; 9139fecd132SFilipe Manana goto out; 914e3e0520bSJosef Bacik } 915e3e0520bSJosef Bacik 916e3e0520bSJosef Bacik /* 917e3e0520bSJosef Bacik * get the inode first so any iput calls done for the io_list 918e3e0520bSJosef Bacik * aren't the final iput (no unlinks allowed now) 919e3e0520bSJosef Bacik */ 920e3e0520bSJosef Bacik inode = lookup_free_space_inode(block_group, path); 921e3e0520bSJosef Bacik 922e3e0520bSJosef Bacik mutex_lock(&trans->transaction->cache_write_mutex); 923e3e0520bSJosef Bacik /* 924e3e0520bSJosef Bacik * Make sure our free space cache IO is done before removing the 925e3e0520bSJosef Bacik * free space inode 926e3e0520bSJosef Bacik */ 927e3e0520bSJosef Bacik spin_lock(&trans->transaction->dirty_bgs_lock); 928e3e0520bSJosef Bacik if (!list_empty(&block_group->io_list)) { 929e3e0520bSJosef Bacik list_del_init(&block_group->io_list); 930e3e0520bSJosef Bacik 931e3e0520bSJosef Bacik WARN_ON(!IS_ERR(inode) && inode != block_group->io_ctl.inode); 932e3e0520bSJosef Bacik 933e3e0520bSJosef Bacik spin_unlock(&trans->transaction->dirty_bgs_lock); 934e3e0520bSJosef Bacik btrfs_wait_cache_io(trans, block_group, path); 935e3e0520bSJosef Bacik btrfs_put_block_group(block_group); 936e3e0520bSJosef Bacik spin_lock(&trans->transaction->dirty_bgs_lock); 937e3e0520bSJosef Bacik } 938e3e0520bSJosef Bacik 939e3e0520bSJosef Bacik if (!list_empty(&block_group->dirty_list)) { 940e3e0520bSJosef Bacik list_del_init(&block_group->dirty_list); 941e3e0520bSJosef Bacik remove_rsv = true; 942e3e0520bSJosef Bacik btrfs_put_block_group(block_group); 943e3e0520bSJosef Bacik } 944e3e0520bSJosef Bacik spin_unlock(&trans->transaction->dirty_bgs_lock); 945e3e0520bSJosef Bacik mutex_unlock(&trans->transaction->cache_write_mutex); 946e3e0520bSJosef Bacik 94736b216c8SBoris Burkov ret = btrfs_remove_free_space_inode(trans, inode, block_group); 948e3e0520bSJosef Bacik if (ret) 9499fecd132SFilipe Manana goto out; 950e3e0520bSJosef Bacik 951e3e0520bSJosef Bacik spin_lock(&fs_info->block_group_cache_lock); 952e3e0520bSJosef Bacik rb_erase(&block_group->cache_node, 953e3e0520bSJosef Bacik &fs_info->block_group_cache_tree); 954e3e0520bSJosef Bacik RB_CLEAR_NODE(&block_group->cache_node); 955e3e0520bSJosef Bacik 9569fecd132SFilipe Manana /* Once for the block groups rbtree */ 9579fecd132SFilipe Manana btrfs_put_block_group(block_group); 9589fecd132SFilipe Manana 959b3470b5dSDavid Sterba if (fs_info->first_logical_byte == block_group->start) 960e3e0520bSJosef Bacik fs_info->first_logical_byte = (u64)-1; 961e3e0520bSJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 962e3e0520bSJosef Bacik 963e3e0520bSJosef Bacik down_write(&block_group->space_info->groups_sem); 964e3e0520bSJosef Bacik /* 965e3e0520bSJosef Bacik * we must use list_del_init so people can check to see if they 966e3e0520bSJosef Bacik * are still on the list after taking the semaphore 967e3e0520bSJosef Bacik */ 968e3e0520bSJosef Bacik list_del_init(&block_group->list); 969e3e0520bSJosef Bacik if (list_empty(&block_group->space_info->block_groups[index])) { 970e3e0520bSJosef Bacik kobj = block_group->space_info->block_group_kobjs[index]; 971e3e0520bSJosef Bacik block_group->space_info->block_group_kobjs[index] = NULL; 972e3e0520bSJosef Bacik clear_avail_alloc_bits(fs_info, block_group->flags); 973e3e0520bSJosef Bacik } 974e3e0520bSJosef Bacik up_write(&block_group->space_info->groups_sem); 975e3e0520bSJosef Bacik clear_incompat_bg_bits(fs_info, block_group->flags); 976e3e0520bSJosef Bacik if (kobj) { 977e3e0520bSJosef Bacik kobject_del(kobj); 978e3e0520bSJosef Bacik kobject_put(kobj); 979e3e0520bSJosef Bacik } 980e3e0520bSJosef Bacik 981e3e0520bSJosef Bacik if (block_group->has_caching_ctl) 982e3e0520bSJosef Bacik caching_ctl = btrfs_get_caching_control(block_group); 983e3e0520bSJosef Bacik if (block_group->cached == BTRFS_CACHE_STARTED) 984e3e0520bSJosef Bacik btrfs_wait_block_group_cache_done(block_group); 985e3e0520bSJosef Bacik if (block_group->has_caching_ctl) { 986bbb86a37SJosef Bacik spin_lock(&fs_info->block_group_cache_lock); 987e3e0520bSJosef Bacik if (!caching_ctl) { 988e3e0520bSJosef Bacik struct btrfs_caching_control *ctl; 989e3e0520bSJosef Bacik 990e3e0520bSJosef Bacik list_for_each_entry(ctl, 991e3e0520bSJosef Bacik &fs_info->caching_block_groups, list) 992e3e0520bSJosef Bacik if (ctl->block_group == block_group) { 993e3e0520bSJosef Bacik caching_ctl = ctl; 994e3e0520bSJosef Bacik refcount_inc(&caching_ctl->count); 995e3e0520bSJosef Bacik break; 996e3e0520bSJosef Bacik } 997e3e0520bSJosef Bacik } 998e3e0520bSJosef Bacik if (caching_ctl) 999e3e0520bSJosef Bacik list_del_init(&caching_ctl->list); 1000bbb86a37SJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 1001e3e0520bSJosef Bacik if (caching_ctl) { 1002e3e0520bSJosef Bacik /* Once for the caching bgs list and once for us. */ 1003e3e0520bSJosef Bacik btrfs_put_caching_control(caching_ctl); 1004e3e0520bSJosef Bacik btrfs_put_caching_control(caching_ctl); 1005e3e0520bSJosef Bacik } 1006e3e0520bSJosef Bacik } 1007e3e0520bSJosef Bacik 1008e3e0520bSJosef Bacik spin_lock(&trans->transaction->dirty_bgs_lock); 1009e3e0520bSJosef Bacik WARN_ON(!list_empty(&block_group->dirty_list)); 1010e3e0520bSJosef Bacik WARN_ON(!list_empty(&block_group->io_list)); 1011e3e0520bSJosef Bacik spin_unlock(&trans->transaction->dirty_bgs_lock); 1012e3e0520bSJosef Bacik 1013e3e0520bSJosef Bacik btrfs_remove_free_space_cache(block_group); 1014e3e0520bSJosef Bacik 1015e3e0520bSJosef Bacik spin_lock(&block_group->space_info->lock); 1016e3e0520bSJosef Bacik list_del_init(&block_group->ro_list); 1017e3e0520bSJosef Bacik 1018e3e0520bSJosef Bacik if (btrfs_test_opt(fs_info, ENOSPC_DEBUG)) { 1019e3e0520bSJosef Bacik WARN_ON(block_group->space_info->total_bytes 1020b3470b5dSDavid Sterba < block_group->length); 1021e3e0520bSJosef Bacik WARN_ON(block_group->space_info->bytes_readonly 1022169e0da9SNaohiro Aota < block_group->length - block_group->zone_unusable); 1023169e0da9SNaohiro Aota WARN_ON(block_group->space_info->bytes_zone_unusable 1024169e0da9SNaohiro Aota < block_group->zone_unusable); 1025e3e0520bSJosef Bacik WARN_ON(block_group->space_info->disk_total 1026b3470b5dSDavid Sterba < block_group->length * factor); 1027e3e0520bSJosef Bacik } 1028b3470b5dSDavid Sterba block_group->space_info->total_bytes -= block_group->length; 1029169e0da9SNaohiro Aota block_group->space_info->bytes_readonly -= 1030169e0da9SNaohiro Aota (block_group->length - block_group->zone_unusable); 1031169e0da9SNaohiro Aota block_group->space_info->bytes_zone_unusable -= 1032169e0da9SNaohiro Aota block_group->zone_unusable; 1033b3470b5dSDavid Sterba block_group->space_info->disk_total -= block_group->length * factor; 1034e3e0520bSJosef Bacik 1035e3e0520bSJosef Bacik spin_unlock(&block_group->space_info->lock); 1036e3e0520bSJosef Bacik 1037ffcb9d44SFilipe Manana /* 1038ffcb9d44SFilipe Manana * Remove the free space for the block group from the free space tree 1039ffcb9d44SFilipe Manana * and the block group's item from the extent tree before marking the 1040ffcb9d44SFilipe Manana * block group as removed. This is to prevent races with tasks that 1041ffcb9d44SFilipe Manana * freeze and unfreeze a block group, this task and another task 1042ffcb9d44SFilipe Manana * allocating a new block group - the unfreeze task ends up removing 1043ffcb9d44SFilipe Manana * the block group's extent map before the task calling this function 1044ffcb9d44SFilipe Manana * deletes the block group item from the extent tree, allowing for 1045ffcb9d44SFilipe Manana * another task to attempt to create another block group with the same 1046ffcb9d44SFilipe Manana * item key (and failing with -EEXIST and a transaction abort). 1047ffcb9d44SFilipe Manana */ 1048ffcb9d44SFilipe Manana ret = remove_block_group_free_space(trans, block_group); 1049ffcb9d44SFilipe Manana if (ret) 1050ffcb9d44SFilipe Manana goto out; 1051ffcb9d44SFilipe Manana 1052ffcb9d44SFilipe Manana ret = remove_block_group_item(trans, path, block_group); 1053ffcb9d44SFilipe Manana if (ret < 0) 1054ffcb9d44SFilipe Manana goto out; 1055ffcb9d44SFilipe Manana 1056e3e0520bSJosef Bacik spin_lock(&block_group->lock); 1057e3e0520bSJosef Bacik block_group->removed = 1; 1058e3e0520bSJosef Bacik /* 10596b7304afSFilipe Manana * At this point trimming or scrub can't start on this block group, 10606b7304afSFilipe Manana * because we removed the block group from the rbtree 10616b7304afSFilipe Manana * fs_info->block_group_cache_tree so no one can't find it anymore and 10626b7304afSFilipe Manana * even if someone already got this block group before we removed it 10636b7304afSFilipe Manana * from the rbtree, they have already incremented block_group->frozen - 10646b7304afSFilipe Manana * if they didn't, for the trimming case they won't find any free space 10656b7304afSFilipe Manana * entries because we already removed them all when we called 10666b7304afSFilipe Manana * btrfs_remove_free_space_cache(). 1067e3e0520bSJosef Bacik * 1068e3e0520bSJosef Bacik * And we must not remove the extent map from the fs_info->mapping_tree 1069e3e0520bSJosef Bacik * to prevent the same logical address range and physical device space 10706b7304afSFilipe Manana * ranges from being reused for a new block group. This is needed to 10716b7304afSFilipe Manana * avoid races with trimming and scrub. 10726b7304afSFilipe Manana * 10736b7304afSFilipe Manana * An fs trim operation (btrfs_trim_fs() / btrfs_ioctl_fitrim()) is 1074e3e0520bSJosef Bacik * completely transactionless, so while it is trimming a range the 1075e3e0520bSJosef Bacik * currently running transaction might finish and a new one start, 1076e3e0520bSJosef Bacik * allowing for new block groups to be created that can reuse the same 1077e3e0520bSJosef Bacik * physical device locations unless we take this special care. 1078e3e0520bSJosef Bacik * 1079e3e0520bSJosef Bacik * There may also be an implicit trim operation if the file system 1080e3e0520bSJosef Bacik * is mounted with -odiscard. The same protections must remain 1081e3e0520bSJosef Bacik * in place until the extents have been discarded completely when 1082e3e0520bSJosef Bacik * the transaction commit has completed. 1083e3e0520bSJosef Bacik */ 10846b7304afSFilipe Manana remove_em = (atomic_read(&block_group->frozen) == 0); 1085e3e0520bSJosef Bacik spin_unlock(&block_group->lock); 1086e3e0520bSJosef Bacik 1087e3e0520bSJosef Bacik if (remove_em) { 1088e3e0520bSJosef Bacik struct extent_map_tree *em_tree; 1089e3e0520bSJosef Bacik 1090e3e0520bSJosef Bacik em_tree = &fs_info->mapping_tree; 1091e3e0520bSJosef Bacik write_lock(&em_tree->lock); 1092e3e0520bSJosef Bacik remove_extent_mapping(em_tree, em); 1093e3e0520bSJosef Bacik write_unlock(&em_tree->lock); 1094e3e0520bSJosef Bacik /* once for the tree */ 1095e3e0520bSJosef Bacik free_extent_map(em); 1096e3e0520bSJosef Bacik } 1097f6033c5eSXiyu Yang 10989fecd132SFilipe Manana out: 1099f6033c5eSXiyu Yang /* Once for the lookup reference */ 1100f6033c5eSXiyu Yang btrfs_put_block_group(block_group); 1101e3e0520bSJosef Bacik if (remove_rsv) 1102e3e0520bSJosef Bacik btrfs_delayed_refs_rsv_release(fs_info, 1); 1103e3e0520bSJosef Bacik btrfs_free_path(path); 1104e3e0520bSJosef Bacik return ret; 1105e3e0520bSJosef Bacik } 1106e3e0520bSJosef Bacik 1107e3e0520bSJosef Bacik struct btrfs_trans_handle *btrfs_start_trans_remove_block_group( 1108e3e0520bSJosef Bacik struct btrfs_fs_info *fs_info, const u64 chunk_offset) 1109e3e0520bSJosef Bacik { 1110dfe8aec4SJosef Bacik struct btrfs_root *root = btrfs_block_group_root(fs_info); 1111e3e0520bSJosef Bacik struct extent_map_tree *em_tree = &fs_info->mapping_tree; 1112e3e0520bSJosef Bacik struct extent_map *em; 1113e3e0520bSJosef Bacik struct map_lookup *map; 1114e3e0520bSJosef Bacik unsigned int num_items; 1115e3e0520bSJosef Bacik 1116e3e0520bSJosef Bacik read_lock(&em_tree->lock); 1117e3e0520bSJosef Bacik em = lookup_extent_mapping(em_tree, chunk_offset, 1); 1118e3e0520bSJosef Bacik read_unlock(&em_tree->lock); 1119e3e0520bSJosef Bacik ASSERT(em && em->start == chunk_offset); 1120e3e0520bSJosef Bacik 1121e3e0520bSJosef Bacik /* 1122e3e0520bSJosef Bacik * We need to reserve 3 + N units from the metadata space info in order 1123e3e0520bSJosef Bacik * to remove a block group (done at btrfs_remove_chunk() and at 1124e3e0520bSJosef Bacik * btrfs_remove_block_group()), which are used for: 1125e3e0520bSJosef Bacik * 1126e3e0520bSJosef Bacik * 1 unit for adding the free space inode's orphan (located in the tree 1127e3e0520bSJosef Bacik * of tree roots). 1128e3e0520bSJosef Bacik * 1 unit for deleting the block group item (located in the extent 1129e3e0520bSJosef Bacik * tree). 1130e3e0520bSJosef Bacik * 1 unit for deleting the free space item (located in tree of tree 1131e3e0520bSJosef Bacik * roots). 1132e3e0520bSJosef Bacik * N units for deleting N device extent items corresponding to each 1133e3e0520bSJosef Bacik * stripe (located in the device tree). 1134e3e0520bSJosef Bacik * 1135e3e0520bSJosef Bacik * In order to remove a block group we also need to reserve units in the 1136e3e0520bSJosef Bacik * system space info in order to update the chunk tree (update one or 1137e3e0520bSJosef Bacik * more device items and remove one chunk item), but this is done at 1138e3e0520bSJosef Bacik * btrfs_remove_chunk() through a call to check_system_chunk(). 1139e3e0520bSJosef Bacik */ 1140e3e0520bSJosef Bacik map = em->map_lookup; 1141e3e0520bSJosef Bacik num_items = 3 + map->num_stripes; 1142e3e0520bSJosef Bacik free_extent_map(em); 1143e3e0520bSJosef Bacik 1144dfe8aec4SJosef Bacik return btrfs_start_transaction_fallback_global_rsv(root, num_items); 1145e3e0520bSJosef Bacik } 1146e3e0520bSJosef Bacik 1147e3e0520bSJosef Bacik /* 114826ce2095SJosef Bacik * Mark block group @cache read-only, so later write won't happen to block 114926ce2095SJosef Bacik * group @cache. 115026ce2095SJosef Bacik * 115126ce2095SJosef Bacik * If @force is not set, this function will only mark the block group readonly 115226ce2095SJosef Bacik * if we have enough free space (1M) in other metadata/system block groups. 115326ce2095SJosef Bacik * If @force is not set, this function will mark the block group readonly 115426ce2095SJosef Bacik * without checking free space. 115526ce2095SJosef Bacik * 115626ce2095SJosef Bacik * NOTE: This function doesn't care if other block groups can contain all the 115726ce2095SJosef Bacik * data in this block group. That check should be done by relocation routine, 115826ce2095SJosef Bacik * not this function. 115926ce2095SJosef Bacik */ 116032da5386SDavid Sterba static int inc_block_group_ro(struct btrfs_block_group *cache, int force) 116126ce2095SJosef Bacik { 116226ce2095SJosef Bacik struct btrfs_space_info *sinfo = cache->space_info; 116326ce2095SJosef Bacik u64 num_bytes; 116426ce2095SJosef Bacik int ret = -ENOSPC; 116526ce2095SJosef Bacik 116626ce2095SJosef Bacik spin_lock(&sinfo->lock); 116726ce2095SJosef Bacik spin_lock(&cache->lock); 116826ce2095SJosef Bacik 1169195a49eaSFilipe Manana if (cache->swap_extents) { 1170195a49eaSFilipe Manana ret = -ETXTBSY; 1171195a49eaSFilipe Manana goto out; 1172195a49eaSFilipe Manana } 1173195a49eaSFilipe Manana 117426ce2095SJosef Bacik if (cache->ro) { 117526ce2095SJosef Bacik cache->ro++; 117626ce2095SJosef Bacik ret = 0; 117726ce2095SJosef Bacik goto out; 117826ce2095SJosef Bacik } 117926ce2095SJosef Bacik 1180b3470b5dSDavid Sterba num_bytes = cache->length - cache->reserved - cache->pinned - 1181169e0da9SNaohiro Aota cache->bytes_super - cache->zone_unusable - cache->used; 118226ce2095SJosef Bacik 118326ce2095SJosef Bacik /* 1184a30a3d20SJosef Bacik * Data never overcommits, even in mixed mode, so do just the straight 1185a30a3d20SJosef Bacik * check of left over space in how much we have allocated. 1186a30a3d20SJosef Bacik */ 1187a30a3d20SJosef Bacik if (force) { 1188a30a3d20SJosef Bacik ret = 0; 1189a30a3d20SJosef Bacik } else if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA) { 1190a30a3d20SJosef Bacik u64 sinfo_used = btrfs_space_info_used(sinfo, true); 1191a30a3d20SJosef Bacik 1192a30a3d20SJosef Bacik /* 119326ce2095SJosef Bacik * Here we make sure if we mark this bg RO, we still have enough 1194f8935566SJosef Bacik * free space as buffer. 119526ce2095SJosef Bacik */ 1196a30a3d20SJosef Bacik if (sinfo_used + num_bytes <= sinfo->total_bytes) 1197a30a3d20SJosef Bacik ret = 0; 1198a30a3d20SJosef Bacik } else { 1199a30a3d20SJosef Bacik /* 1200a30a3d20SJosef Bacik * We overcommit metadata, so we need to do the 1201a30a3d20SJosef Bacik * btrfs_can_overcommit check here, and we need to pass in 1202a30a3d20SJosef Bacik * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of 1203a30a3d20SJosef Bacik * leeway to allow us to mark this block group as read only. 1204a30a3d20SJosef Bacik */ 1205a30a3d20SJosef Bacik if (btrfs_can_overcommit(cache->fs_info, sinfo, num_bytes, 1206a30a3d20SJosef Bacik BTRFS_RESERVE_NO_FLUSH)) 1207a30a3d20SJosef Bacik ret = 0; 1208a30a3d20SJosef Bacik } 1209a30a3d20SJosef Bacik 1210a30a3d20SJosef Bacik if (!ret) { 121126ce2095SJosef Bacik sinfo->bytes_readonly += num_bytes; 1212169e0da9SNaohiro Aota if (btrfs_is_zoned(cache->fs_info)) { 1213169e0da9SNaohiro Aota /* Migrate zone_unusable bytes to readonly */ 1214169e0da9SNaohiro Aota sinfo->bytes_readonly += cache->zone_unusable; 1215169e0da9SNaohiro Aota sinfo->bytes_zone_unusable -= cache->zone_unusable; 1216169e0da9SNaohiro Aota cache->zone_unusable = 0; 1217169e0da9SNaohiro Aota } 121826ce2095SJosef Bacik cache->ro++; 121926ce2095SJosef Bacik list_add_tail(&cache->ro_list, &sinfo->ro_bgs); 122026ce2095SJosef Bacik } 122126ce2095SJosef Bacik out: 122226ce2095SJosef Bacik spin_unlock(&cache->lock); 122326ce2095SJosef Bacik spin_unlock(&sinfo->lock); 122426ce2095SJosef Bacik if (ret == -ENOSPC && btrfs_test_opt(cache->fs_info, ENOSPC_DEBUG)) { 122526ce2095SJosef Bacik btrfs_info(cache->fs_info, 1226b3470b5dSDavid Sterba "unable to make block group %llu ro", cache->start); 122726ce2095SJosef Bacik btrfs_dump_space_info(cache->fs_info, cache->space_info, 0, 0); 122826ce2095SJosef Bacik } 122926ce2095SJosef Bacik return ret; 123026ce2095SJosef Bacik } 123126ce2095SJosef Bacik 1232fe119a6eSNikolay Borisov static bool clean_pinned_extents(struct btrfs_trans_handle *trans, 1233fe119a6eSNikolay Borisov struct btrfs_block_group *bg) 123445bb5d6aSNikolay Borisov { 123545bb5d6aSNikolay Borisov struct btrfs_fs_info *fs_info = bg->fs_info; 1236fe119a6eSNikolay Borisov struct btrfs_transaction *prev_trans = NULL; 123745bb5d6aSNikolay Borisov const u64 start = bg->start; 123845bb5d6aSNikolay Borisov const u64 end = start + bg->length - 1; 123945bb5d6aSNikolay Borisov int ret; 124045bb5d6aSNikolay Borisov 1241fe119a6eSNikolay Borisov spin_lock(&fs_info->trans_lock); 1242fe119a6eSNikolay Borisov if (trans->transaction->list.prev != &fs_info->trans_list) { 1243fe119a6eSNikolay Borisov prev_trans = list_last_entry(&trans->transaction->list, 1244fe119a6eSNikolay Borisov struct btrfs_transaction, list); 1245fe119a6eSNikolay Borisov refcount_inc(&prev_trans->use_count); 1246fe119a6eSNikolay Borisov } 1247fe119a6eSNikolay Borisov spin_unlock(&fs_info->trans_lock); 1248fe119a6eSNikolay Borisov 124945bb5d6aSNikolay Borisov /* 125045bb5d6aSNikolay Borisov * Hold the unused_bg_unpin_mutex lock to avoid racing with 125145bb5d6aSNikolay Borisov * btrfs_finish_extent_commit(). If we are at transaction N, another 125245bb5d6aSNikolay Borisov * task might be running finish_extent_commit() for the previous 125345bb5d6aSNikolay Borisov * transaction N - 1, and have seen a range belonging to the block 1254fe119a6eSNikolay Borisov * group in pinned_extents before we were able to clear the whole block 1255fe119a6eSNikolay Borisov * group range from pinned_extents. This means that task can lookup for 1256fe119a6eSNikolay Borisov * the block group after we unpinned it from pinned_extents and removed 1257fe119a6eSNikolay Borisov * it, leading to a BUG_ON() at unpin_extent_range(). 125845bb5d6aSNikolay Borisov */ 125945bb5d6aSNikolay Borisov mutex_lock(&fs_info->unused_bg_unpin_mutex); 1260fe119a6eSNikolay Borisov if (prev_trans) { 1261fe119a6eSNikolay Borisov ret = clear_extent_bits(&prev_trans->pinned_extents, start, end, 126245bb5d6aSNikolay Borisov EXTENT_DIRTY); 126345bb5d6aSNikolay Borisov if (ret) 1264534cf531SFilipe Manana goto out; 1265fe119a6eSNikolay Borisov } 126645bb5d6aSNikolay Borisov 1267fe119a6eSNikolay Borisov ret = clear_extent_bits(&trans->transaction->pinned_extents, start, end, 126845bb5d6aSNikolay Borisov EXTENT_DIRTY); 1269534cf531SFilipe Manana out: 127045bb5d6aSNikolay Borisov mutex_unlock(&fs_info->unused_bg_unpin_mutex); 12715150bf19SFilipe Manana if (prev_trans) 12725150bf19SFilipe Manana btrfs_put_transaction(prev_trans); 127345bb5d6aSNikolay Borisov 1274534cf531SFilipe Manana return ret == 0; 127545bb5d6aSNikolay Borisov } 127645bb5d6aSNikolay Borisov 127726ce2095SJosef Bacik /* 1278e3e0520bSJosef Bacik * Process the unused_bgs list and remove any that don't have any allocated 1279e3e0520bSJosef Bacik * space inside of them. 1280e3e0520bSJosef Bacik */ 1281e3e0520bSJosef Bacik void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info) 1282e3e0520bSJosef Bacik { 128332da5386SDavid Sterba struct btrfs_block_group *block_group; 1284e3e0520bSJosef Bacik struct btrfs_space_info *space_info; 1285e3e0520bSJosef Bacik struct btrfs_trans_handle *trans; 12866e80d4f8SDennis Zhou const bool async_trim_enabled = btrfs_test_opt(fs_info, DISCARD_ASYNC); 1287e3e0520bSJosef Bacik int ret = 0; 1288e3e0520bSJosef Bacik 1289e3e0520bSJosef Bacik if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags)) 1290e3e0520bSJosef Bacik return; 1291e3e0520bSJosef Bacik 1292ddfd08cbSJosef Bacik /* 1293ddfd08cbSJosef Bacik * Long running balances can keep us blocked here for eternity, so 1294ddfd08cbSJosef Bacik * simply skip deletion if we're unable to get the mutex. 1295ddfd08cbSJosef Bacik */ 1296f3372065SJohannes Thumshirn if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) 1297ddfd08cbSJosef Bacik return; 1298ddfd08cbSJosef Bacik 1299e3e0520bSJosef Bacik spin_lock(&fs_info->unused_bgs_lock); 1300e3e0520bSJosef Bacik while (!list_empty(&fs_info->unused_bgs)) { 1301e3e0520bSJosef Bacik int trimming; 1302e3e0520bSJosef Bacik 1303e3e0520bSJosef Bacik block_group = list_first_entry(&fs_info->unused_bgs, 130432da5386SDavid Sterba struct btrfs_block_group, 1305e3e0520bSJosef Bacik bg_list); 1306e3e0520bSJosef Bacik list_del_init(&block_group->bg_list); 1307e3e0520bSJosef Bacik 1308e3e0520bSJosef Bacik space_info = block_group->space_info; 1309e3e0520bSJosef Bacik 1310e3e0520bSJosef Bacik if (ret || btrfs_mixed_space_info(space_info)) { 1311e3e0520bSJosef Bacik btrfs_put_block_group(block_group); 1312e3e0520bSJosef Bacik continue; 1313e3e0520bSJosef Bacik } 1314e3e0520bSJosef Bacik spin_unlock(&fs_info->unused_bgs_lock); 1315e3e0520bSJosef Bacik 1316b0643e59SDennis Zhou btrfs_discard_cancel_work(&fs_info->discard_ctl, block_group); 1317b0643e59SDennis Zhou 1318e3e0520bSJosef Bacik /* Don't want to race with allocators so take the groups_sem */ 1319e3e0520bSJosef Bacik down_write(&space_info->groups_sem); 13206e80d4f8SDennis Zhou 13216e80d4f8SDennis Zhou /* 13226e80d4f8SDennis Zhou * Async discard moves the final block group discard to be prior 13236e80d4f8SDennis Zhou * to the unused_bgs code path. Therefore, if it's not fully 13246e80d4f8SDennis Zhou * trimmed, punt it back to the async discard lists. 13256e80d4f8SDennis Zhou */ 13266e80d4f8SDennis Zhou if (btrfs_test_opt(fs_info, DISCARD_ASYNC) && 13276e80d4f8SDennis Zhou !btrfs_is_free_space_trimmed(block_group)) { 13286e80d4f8SDennis Zhou trace_btrfs_skip_unused_block_group(block_group); 13296e80d4f8SDennis Zhou up_write(&space_info->groups_sem); 13306e80d4f8SDennis Zhou /* Requeue if we failed because of async discard */ 13316e80d4f8SDennis Zhou btrfs_discard_queue_work(&fs_info->discard_ctl, 13326e80d4f8SDennis Zhou block_group); 13336e80d4f8SDennis Zhou goto next; 13346e80d4f8SDennis Zhou } 13356e80d4f8SDennis Zhou 1336e3e0520bSJosef Bacik spin_lock(&block_group->lock); 1337e3e0520bSJosef Bacik if (block_group->reserved || block_group->pinned || 1338bf38be65SDavid Sterba block_group->used || block_group->ro || 1339e3e0520bSJosef Bacik list_is_singular(&block_group->list)) { 1340e3e0520bSJosef Bacik /* 1341e3e0520bSJosef Bacik * We want to bail if we made new allocations or have 1342e3e0520bSJosef Bacik * outstanding allocations in this block group. We do 1343e3e0520bSJosef Bacik * the ro check in case balance is currently acting on 1344e3e0520bSJosef Bacik * this block group. 1345e3e0520bSJosef Bacik */ 1346e3e0520bSJosef Bacik trace_btrfs_skip_unused_block_group(block_group); 1347e3e0520bSJosef Bacik spin_unlock(&block_group->lock); 1348e3e0520bSJosef Bacik up_write(&space_info->groups_sem); 1349e3e0520bSJosef Bacik goto next; 1350e3e0520bSJosef Bacik } 1351e3e0520bSJosef Bacik spin_unlock(&block_group->lock); 1352e3e0520bSJosef Bacik 1353e3e0520bSJosef Bacik /* We don't want to force the issue, only flip if it's ok. */ 1354e11c0406SJosef Bacik ret = inc_block_group_ro(block_group, 0); 1355e3e0520bSJosef Bacik up_write(&space_info->groups_sem); 1356e3e0520bSJosef Bacik if (ret < 0) { 1357e3e0520bSJosef Bacik ret = 0; 1358e3e0520bSJosef Bacik goto next; 1359e3e0520bSJosef Bacik } 1360e3e0520bSJosef Bacik 1361e3e0520bSJosef Bacik /* 1362e3e0520bSJosef Bacik * Want to do this before we do anything else so we can recover 1363e3e0520bSJosef Bacik * properly if we fail to join the transaction. 1364e3e0520bSJosef Bacik */ 1365e3e0520bSJosef Bacik trans = btrfs_start_trans_remove_block_group(fs_info, 1366b3470b5dSDavid Sterba block_group->start); 1367e3e0520bSJosef Bacik if (IS_ERR(trans)) { 1368e3e0520bSJosef Bacik btrfs_dec_block_group_ro(block_group); 1369e3e0520bSJosef Bacik ret = PTR_ERR(trans); 1370e3e0520bSJosef Bacik goto next; 1371e3e0520bSJosef Bacik } 1372e3e0520bSJosef Bacik 1373e3e0520bSJosef Bacik /* 1374e3e0520bSJosef Bacik * We could have pending pinned extents for this block group, 1375e3e0520bSJosef Bacik * just delete them, we don't care about them anymore. 1376e3e0520bSJosef Bacik */ 1377534cf531SFilipe Manana if (!clean_pinned_extents(trans, block_group)) { 1378534cf531SFilipe Manana btrfs_dec_block_group_ro(block_group); 1379e3e0520bSJosef Bacik goto end_trans; 1380534cf531SFilipe Manana } 1381e3e0520bSJosef Bacik 1382b0643e59SDennis Zhou /* 1383b0643e59SDennis Zhou * At this point, the block_group is read only and should fail 1384b0643e59SDennis Zhou * new allocations. However, btrfs_finish_extent_commit() can 1385b0643e59SDennis Zhou * cause this block_group to be placed back on the discard 1386b0643e59SDennis Zhou * lists because now the block_group isn't fully discarded. 1387b0643e59SDennis Zhou * Bail here and try again later after discarding everything. 1388b0643e59SDennis Zhou */ 1389b0643e59SDennis Zhou spin_lock(&fs_info->discard_ctl.lock); 1390b0643e59SDennis Zhou if (!list_empty(&block_group->discard_list)) { 1391b0643e59SDennis Zhou spin_unlock(&fs_info->discard_ctl.lock); 1392b0643e59SDennis Zhou btrfs_dec_block_group_ro(block_group); 1393b0643e59SDennis Zhou btrfs_discard_queue_work(&fs_info->discard_ctl, 1394b0643e59SDennis Zhou block_group); 1395b0643e59SDennis Zhou goto end_trans; 1396b0643e59SDennis Zhou } 1397b0643e59SDennis Zhou spin_unlock(&fs_info->discard_ctl.lock); 1398b0643e59SDennis Zhou 1399e3e0520bSJosef Bacik /* Reset pinned so btrfs_put_block_group doesn't complain */ 1400e3e0520bSJosef Bacik spin_lock(&space_info->lock); 1401e3e0520bSJosef Bacik spin_lock(&block_group->lock); 1402e3e0520bSJosef Bacik 1403e3e0520bSJosef Bacik btrfs_space_info_update_bytes_pinned(fs_info, space_info, 1404e3e0520bSJosef Bacik -block_group->pinned); 1405e3e0520bSJosef Bacik space_info->bytes_readonly += block_group->pinned; 1406e3e0520bSJosef Bacik block_group->pinned = 0; 1407e3e0520bSJosef Bacik 1408e3e0520bSJosef Bacik spin_unlock(&block_group->lock); 1409e3e0520bSJosef Bacik spin_unlock(&space_info->lock); 1410e3e0520bSJosef Bacik 14116e80d4f8SDennis Zhou /* 14126e80d4f8SDennis Zhou * The normal path here is an unused block group is passed here, 14136e80d4f8SDennis Zhou * then trimming is handled in the transaction commit path. 14146e80d4f8SDennis Zhou * Async discard interposes before this to do the trimming 14156e80d4f8SDennis Zhou * before coming down the unused block group path as trimming 14166e80d4f8SDennis Zhou * will no longer be done later in the transaction commit path. 14176e80d4f8SDennis Zhou */ 14186e80d4f8SDennis Zhou if (!async_trim_enabled && btrfs_test_opt(fs_info, DISCARD_ASYNC)) 14196e80d4f8SDennis Zhou goto flip_async; 14206e80d4f8SDennis Zhou 1421dcba6e48SNaohiro Aota /* 1422dcba6e48SNaohiro Aota * DISCARD can flip during remount. On zoned filesystems, we 1423dcba6e48SNaohiro Aota * need to reset sequential-required zones. 1424dcba6e48SNaohiro Aota */ 1425dcba6e48SNaohiro Aota trimming = btrfs_test_opt(fs_info, DISCARD_SYNC) || 1426dcba6e48SNaohiro Aota btrfs_is_zoned(fs_info); 1427e3e0520bSJosef Bacik 1428e3e0520bSJosef Bacik /* Implicit trim during transaction commit. */ 1429e3e0520bSJosef Bacik if (trimming) 14306b7304afSFilipe Manana btrfs_freeze_block_group(block_group); 1431e3e0520bSJosef Bacik 1432e3e0520bSJosef Bacik /* 1433e3e0520bSJosef Bacik * Btrfs_remove_chunk will abort the transaction if things go 1434e3e0520bSJosef Bacik * horribly wrong. 1435e3e0520bSJosef Bacik */ 1436b3470b5dSDavid Sterba ret = btrfs_remove_chunk(trans, block_group->start); 1437e3e0520bSJosef Bacik 1438e3e0520bSJosef Bacik if (ret) { 1439e3e0520bSJosef Bacik if (trimming) 14406b7304afSFilipe Manana btrfs_unfreeze_block_group(block_group); 1441e3e0520bSJosef Bacik goto end_trans; 1442e3e0520bSJosef Bacik } 1443e3e0520bSJosef Bacik 1444e3e0520bSJosef Bacik /* 1445e3e0520bSJosef Bacik * If we're not mounted with -odiscard, we can just forget 1446e3e0520bSJosef Bacik * about this block group. Otherwise we'll need to wait 1447e3e0520bSJosef Bacik * until transaction commit to do the actual discard. 1448e3e0520bSJosef Bacik */ 1449e3e0520bSJosef Bacik if (trimming) { 1450e3e0520bSJosef Bacik spin_lock(&fs_info->unused_bgs_lock); 1451e3e0520bSJosef Bacik /* 1452e3e0520bSJosef Bacik * A concurrent scrub might have added us to the list 1453e3e0520bSJosef Bacik * fs_info->unused_bgs, so use a list_move operation 1454e3e0520bSJosef Bacik * to add the block group to the deleted_bgs list. 1455e3e0520bSJosef Bacik */ 1456e3e0520bSJosef Bacik list_move(&block_group->bg_list, 1457e3e0520bSJosef Bacik &trans->transaction->deleted_bgs); 1458e3e0520bSJosef Bacik spin_unlock(&fs_info->unused_bgs_lock); 1459e3e0520bSJosef Bacik btrfs_get_block_group(block_group); 1460e3e0520bSJosef Bacik } 1461e3e0520bSJosef Bacik end_trans: 1462e3e0520bSJosef Bacik btrfs_end_transaction(trans); 1463e3e0520bSJosef Bacik next: 1464e3e0520bSJosef Bacik btrfs_put_block_group(block_group); 1465e3e0520bSJosef Bacik spin_lock(&fs_info->unused_bgs_lock); 1466e3e0520bSJosef Bacik } 1467e3e0520bSJosef Bacik spin_unlock(&fs_info->unused_bgs_lock); 1468f3372065SJohannes Thumshirn mutex_unlock(&fs_info->reclaim_bgs_lock); 14696e80d4f8SDennis Zhou return; 14706e80d4f8SDennis Zhou 14716e80d4f8SDennis Zhou flip_async: 14726e80d4f8SDennis Zhou btrfs_end_transaction(trans); 1473f3372065SJohannes Thumshirn mutex_unlock(&fs_info->reclaim_bgs_lock); 14746e80d4f8SDennis Zhou btrfs_put_block_group(block_group); 14756e80d4f8SDennis Zhou btrfs_discard_punt_unused_bgs_list(fs_info); 1476e3e0520bSJosef Bacik } 1477e3e0520bSJosef Bacik 147832da5386SDavid Sterba void btrfs_mark_bg_unused(struct btrfs_block_group *bg) 1479e3e0520bSJosef Bacik { 1480e3e0520bSJosef Bacik struct btrfs_fs_info *fs_info = bg->fs_info; 1481e3e0520bSJosef Bacik 1482e3e0520bSJosef Bacik spin_lock(&fs_info->unused_bgs_lock); 1483e3e0520bSJosef Bacik if (list_empty(&bg->bg_list)) { 1484e3e0520bSJosef Bacik btrfs_get_block_group(bg); 1485e3e0520bSJosef Bacik trace_btrfs_add_unused_block_group(bg); 1486e3e0520bSJosef Bacik list_add_tail(&bg->bg_list, &fs_info->unused_bgs); 1487e3e0520bSJosef Bacik } 1488e3e0520bSJosef Bacik spin_unlock(&fs_info->unused_bgs_lock); 1489e3e0520bSJosef Bacik } 14904358d963SJosef Bacik 14912ca0ec77SJohannes Thumshirn /* 14922ca0ec77SJohannes Thumshirn * We want block groups with a low number of used bytes to be in the beginning 14932ca0ec77SJohannes Thumshirn * of the list, so they will get reclaimed first. 14942ca0ec77SJohannes Thumshirn */ 14952ca0ec77SJohannes Thumshirn static int reclaim_bgs_cmp(void *unused, const struct list_head *a, 14962ca0ec77SJohannes Thumshirn const struct list_head *b) 14972ca0ec77SJohannes Thumshirn { 14982ca0ec77SJohannes Thumshirn const struct btrfs_block_group *bg1, *bg2; 14992ca0ec77SJohannes Thumshirn 15002ca0ec77SJohannes Thumshirn bg1 = list_entry(a, struct btrfs_block_group, bg_list); 15012ca0ec77SJohannes Thumshirn bg2 = list_entry(b, struct btrfs_block_group, bg_list); 15022ca0ec77SJohannes Thumshirn 15032ca0ec77SJohannes Thumshirn return bg1->used > bg2->used; 15042ca0ec77SJohannes Thumshirn } 15052ca0ec77SJohannes Thumshirn 150618bb8bbfSJohannes Thumshirn void btrfs_reclaim_bgs_work(struct work_struct *work) 150718bb8bbfSJohannes Thumshirn { 150818bb8bbfSJohannes Thumshirn struct btrfs_fs_info *fs_info = 150918bb8bbfSJohannes Thumshirn container_of(work, struct btrfs_fs_info, reclaim_bgs_work); 151018bb8bbfSJohannes Thumshirn struct btrfs_block_group *bg; 151118bb8bbfSJohannes Thumshirn struct btrfs_space_info *space_info; 151218bb8bbfSJohannes Thumshirn 151318bb8bbfSJohannes Thumshirn if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags)) 151418bb8bbfSJohannes Thumshirn return; 151518bb8bbfSJohannes Thumshirn 151618bb8bbfSJohannes Thumshirn if (!btrfs_exclop_start(fs_info, BTRFS_EXCLOP_BALANCE)) 151718bb8bbfSJohannes Thumshirn return; 151818bb8bbfSJohannes Thumshirn 15199cc0b837SJohannes Thumshirn /* 15209cc0b837SJohannes Thumshirn * Long running balances can keep us blocked here for eternity, so 15219cc0b837SJohannes Thumshirn * simply skip reclaim if we're unable to get the mutex. 15229cc0b837SJohannes Thumshirn */ 15239cc0b837SJohannes Thumshirn if (!mutex_trylock(&fs_info->reclaim_bgs_lock)) { 15249cc0b837SJohannes Thumshirn btrfs_exclop_finish(fs_info); 15259cc0b837SJohannes Thumshirn return; 15269cc0b837SJohannes Thumshirn } 15279cc0b837SJohannes Thumshirn 152818bb8bbfSJohannes Thumshirn spin_lock(&fs_info->unused_bgs_lock); 15292ca0ec77SJohannes Thumshirn /* 15302ca0ec77SJohannes Thumshirn * Sort happens under lock because we can't simply splice it and sort. 15312ca0ec77SJohannes Thumshirn * The block groups might still be in use and reachable via bg_list, 15322ca0ec77SJohannes Thumshirn * and their presence in the reclaim_bgs list must be preserved. 15332ca0ec77SJohannes Thumshirn */ 15342ca0ec77SJohannes Thumshirn list_sort(NULL, &fs_info->reclaim_bgs, reclaim_bgs_cmp); 153518bb8bbfSJohannes Thumshirn while (!list_empty(&fs_info->reclaim_bgs)) { 15365f93e776SJohannes Thumshirn u64 zone_unusable; 15371cea5cf0SFilipe Manana int ret = 0; 15381cea5cf0SFilipe Manana 153918bb8bbfSJohannes Thumshirn bg = list_first_entry(&fs_info->reclaim_bgs, 154018bb8bbfSJohannes Thumshirn struct btrfs_block_group, 154118bb8bbfSJohannes Thumshirn bg_list); 154218bb8bbfSJohannes Thumshirn list_del_init(&bg->bg_list); 154318bb8bbfSJohannes Thumshirn 154418bb8bbfSJohannes Thumshirn space_info = bg->space_info; 154518bb8bbfSJohannes Thumshirn spin_unlock(&fs_info->unused_bgs_lock); 154618bb8bbfSJohannes Thumshirn 154718bb8bbfSJohannes Thumshirn /* Don't race with allocators so take the groups_sem */ 154818bb8bbfSJohannes Thumshirn down_write(&space_info->groups_sem); 154918bb8bbfSJohannes Thumshirn 155018bb8bbfSJohannes Thumshirn spin_lock(&bg->lock); 155118bb8bbfSJohannes Thumshirn if (bg->reserved || bg->pinned || bg->ro) { 155218bb8bbfSJohannes Thumshirn /* 155318bb8bbfSJohannes Thumshirn * We want to bail if we made new allocations or have 155418bb8bbfSJohannes Thumshirn * outstanding allocations in this block group. We do 155518bb8bbfSJohannes Thumshirn * the ro check in case balance is currently acting on 155618bb8bbfSJohannes Thumshirn * this block group. 155718bb8bbfSJohannes Thumshirn */ 155818bb8bbfSJohannes Thumshirn spin_unlock(&bg->lock); 155918bb8bbfSJohannes Thumshirn up_write(&space_info->groups_sem); 156018bb8bbfSJohannes Thumshirn goto next; 156118bb8bbfSJohannes Thumshirn } 156218bb8bbfSJohannes Thumshirn spin_unlock(&bg->lock); 156318bb8bbfSJohannes Thumshirn 156418bb8bbfSJohannes Thumshirn /* Get out fast, in case we're unmounting the filesystem */ 156518bb8bbfSJohannes Thumshirn if (btrfs_fs_closing(fs_info)) { 156618bb8bbfSJohannes Thumshirn up_write(&space_info->groups_sem); 156718bb8bbfSJohannes Thumshirn goto next; 156818bb8bbfSJohannes Thumshirn } 156918bb8bbfSJohannes Thumshirn 15705f93e776SJohannes Thumshirn /* 15715f93e776SJohannes Thumshirn * Cache the zone_unusable value before turning the block group 15725f93e776SJohannes Thumshirn * to read only. As soon as the blog group is read only it's 15735f93e776SJohannes Thumshirn * zone_unusable value gets moved to the block group's read-only 15745f93e776SJohannes Thumshirn * bytes and isn't available for calculations anymore. 15755f93e776SJohannes Thumshirn */ 15765f93e776SJohannes Thumshirn zone_unusable = bg->zone_unusable; 157718bb8bbfSJohannes Thumshirn ret = inc_block_group_ro(bg, 0); 157818bb8bbfSJohannes Thumshirn up_write(&space_info->groups_sem); 157918bb8bbfSJohannes Thumshirn if (ret < 0) 158018bb8bbfSJohannes Thumshirn goto next; 158118bb8bbfSJohannes Thumshirn 15825f93e776SJohannes Thumshirn btrfs_info(fs_info, 15835f93e776SJohannes Thumshirn "reclaiming chunk %llu with %llu%% used %llu%% unusable", 15845f93e776SJohannes Thumshirn bg->start, div_u64(bg->used * 100, bg->length), 15855f93e776SJohannes Thumshirn div64_u64(zone_unusable * 100, bg->length)); 158618bb8bbfSJohannes Thumshirn trace_btrfs_reclaim_block_group(bg); 158718bb8bbfSJohannes Thumshirn ret = btrfs_relocate_chunk(fs_info, bg->start); 1588*d96b3424SFilipe Manana if (ret) 158918bb8bbfSJohannes Thumshirn btrfs_err(fs_info, "error relocating chunk %llu", 159018bb8bbfSJohannes Thumshirn bg->start); 159118bb8bbfSJohannes Thumshirn 159218bb8bbfSJohannes Thumshirn next: 15931cea5cf0SFilipe Manana btrfs_put_block_group(bg); 1594*d96b3424SFilipe Manana spin_lock(&fs_info->unused_bgs_lock); 159518bb8bbfSJohannes Thumshirn } 159618bb8bbfSJohannes Thumshirn spin_unlock(&fs_info->unused_bgs_lock); 159718bb8bbfSJohannes Thumshirn mutex_unlock(&fs_info->reclaim_bgs_lock); 159818bb8bbfSJohannes Thumshirn btrfs_exclop_finish(fs_info); 159918bb8bbfSJohannes Thumshirn } 160018bb8bbfSJohannes Thumshirn 160118bb8bbfSJohannes Thumshirn void btrfs_reclaim_bgs(struct btrfs_fs_info *fs_info) 160218bb8bbfSJohannes Thumshirn { 160318bb8bbfSJohannes Thumshirn spin_lock(&fs_info->unused_bgs_lock); 160418bb8bbfSJohannes Thumshirn if (!list_empty(&fs_info->reclaim_bgs)) 160518bb8bbfSJohannes Thumshirn queue_work(system_unbound_wq, &fs_info->reclaim_bgs_work); 160618bb8bbfSJohannes Thumshirn spin_unlock(&fs_info->unused_bgs_lock); 160718bb8bbfSJohannes Thumshirn } 160818bb8bbfSJohannes Thumshirn 160918bb8bbfSJohannes Thumshirn void btrfs_mark_bg_to_reclaim(struct btrfs_block_group *bg) 161018bb8bbfSJohannes Thumshirn { 161118bb8bbfSJohannes Thumshirn struct btrfs_fs_info *fs_info = bg->fs_info; 161218bb8bbfSJohannes Thumshirn 161318bb8bbfSJohannes Thumshirn spin_lock(&fs_info->unused_bgs_lock); 161418bb8bbfSJohannes Thumshirn if (list_empty(&bg->bg_list)) { 161518bb8bbfSJohannes Thumshirn btrfs_get_block_group(bg); 161618bb8bbfSJohannes Thumshirn trace_btrfs_add_reclaim_block_group(bg); 161718bb8bbfSJohannes Thumshirn list_add_tail(&bg->bg_list, &fs_info->reclaim_bgs); 161818bb8bbfSJohannes Thumshirn } 161918bb8bbfSJohannes Thumshirn spin_unlock(&fs_info->unused_bgs_lock); 162018bb8bbfSJohannes Thumshirn } 162118bb8bbfSJohannes Thumshirn 1622e3ba67a1SJohannes Thumshirn static int read_bg_from_eb(struct btrfs_fs_info *fs_info, struct btrfs_key *key, 1623e3ba67a1SJohannes Thumshirn struct btrfs_path *path) 1624e3ba67a1SJohannes Thumshirn { 1625e3ba67a1SJohannes Thumshirn struct extent_map_tree *em_tree; 1626e3ba67a1SJohannes Thumshirn struct extent_map *em; 1627e3ba67a1SJohannes Thumshirn struct btrfs_block_group_item bg; 1628e3ba67a1SJohannes Thumshirn struct extent_buffer *leaf; 1629e3ba67a1SJohannes Thumshirn int slot; 1630e3ba67a1SJohannes Thumshirn u64 flags; 1631e3ba67a1SJohannes Thumshirn int ret = 0; 1632e3ba67a1SJohannes Thumshirn 1633e3ba67a1SJohannes Thumshirn slot = path->slots[0]; 1634e3ba67a1SJohannes Thumshirn leaf = path->nodes[0]; 1635e3ba67a1SJohannes Thumshirn 1636e3ba67a1SJohannes Thumshirn em_tree = &fs_info->mapping_tree; 1637e3ba67a1SJohannes Thumshirn read_lock(&em_tree->lock); 1638e3ba67a1SJohannes Thumshirn em = lookup_extent_mapping(em_tree, key->objectid, key->offset); 1639e3ba67a1SJohannes Thumshirn read_unlock(&em_tree->lock); 1640e3ba67a1SJohannes Thumshirn if (!em) { 1641e3ba67a1SJohannes Thumshirn btrfs_err(fs_info, 1642e3ba67a1SJohannes Thumshirn "logical %llu len %llu found bg but no related chunk", 1643e3ba67a1SJohannes Thumshirn key->objectid, key->offset); 1644e3ba67a1SJohannes Thumshirn return -ENOENT; 1645e3ba67a1SJohannes Thumshirn } 1646e3ba67a1SJohannes Thumshirn 1647e3ba67a1SJohannes Thumshirn if (em->start != key->objectid || em->len != key->offset) { 1648e3ba67a1SJohannes Thumshirn btrfs_err(fs_info, 1649e3ba67a1SJohannes Thumshirn "block group %llu len %llu mismatch with chunk %llu len %llu", 1650e3ba67a1SJohannes Thumshirn key->objectid, key->offset, em->start, em->len); 1651e3ba67a1SJohannes Thumshirn ret = -EUCLEAN; 1652e3ba67a1SJohannes Thumshirn goto out_free_em; 1653e3ba67a1SJohannes Thumshirn } 1654e3ba67a1SJohannes Thumshirn 1655e3ba67a1SJohannes Thumshirn read_extent_buffer(leaf, &bg, btrfs_item_ptr_offset(leaf, slot), 1656e3ba67a1SJohannes Thumshirn sizeof(bg)); 1657e3ba67a1SJohannes Thumshirn flags = btrfs_stack_block_group_flags(&bg) & 1658e3ba67a1SJohannes Thumshirn BTRFS_BLOCK_GROUP_TYPE_MASK; 1659e3ba67a1SJohannes Thumshirn 1660e3ba67a1SJohannes Thumshirn if (flags != (em->map_lookup->type & BTRFS_BLOCK_GROUP_TYPE_MASK)) { 1661e3ba67a1SJohannes Thumshirn btrfs_err(fs_info, 1662e3ba67a1SJohannes Thumshirn "block group %llu len %llu type flags 0x%llx mismatch with chunk type flags 0x%llx", 1663e3ba67a1SJohannes Thumshirn key->objectid, key->offset, flags, 1664e3ba67a1SJohannes Thumshirn (BTRFS_BLOCK_GROUP_TYPE_MASK & em->map_lookup->type)); 1665e3ba67a1SJohannes Thumshirn ret = -EUCLEAN; 1666e3ba67a1SJohannes Thumshirn } 1667e3ba67a1SJohannes Thumshirn 1668e3ba67a1SJohannes Thumshirn out_free_em: 1669e3ba67a1SJohannes Thumshirn free_extent_map(em); 1670e3ba67a1SJohannes Thumshirn return ret; 1671e3ba67a1SJohannes Thumshirn } 1672e3ba67a1SJohannes Thumshirn 16734358d963SJosef Bacik static int find_first_block_group(struct btrfs_fs_info *fs_info, 16744358d963SJosef Bacik struct btrfs_path *path, 16754358d963SJosef Bacik struct btrfs_key *key) 16764358d963SJosef Bacik { 1677dfe8aec4SJosef Bacik struct btrfs_root *root = btrfs_block_group_root(fs_info); 1678e3ba67a1SJohannes Thumshirn int ret; 16794358d963SJosef Bacik struct btrfs_key found_key; 16804358d963SJosef Bacik struct extent_buffer *leaf; 16814358d963SJosef Bacik int slot; 16824358d963SJosef Bacik 16834358d963SJosef Bacik ret = btrfs_search_slot(NULL, root, key, path, 0, 0); 16844358d963SJosef Bacik if (ret < 0) 1685e3ba67a1SJohannes Thumshirn return ret; 16864358d963SJosef Bacik 16874358d963SJosef Bacik while (1) { 16884358d963SJosef Bacik slot = path->slots[0]; 16894358d963SJosef Bacik leaf = path->nodes[0]; 16904358d963SJosef Bacik if (slot >= btrfs_header_nritems(leaf)) { 16914358d963SJosef Bacik ret = btrfs_next_leaf(root, path); 16924358d963SJosef Bacik if (ret == 0) 16934358d963SJosef Bacik continue; 16944358d963SJosef Bacik if (ret < 0) 16954358d963SJosef Bacik goto out; 16964358d963SJosef Bacik break; 16974358d963SJosef Bacik } 16984358d963SJosef Bacik btrfs_item_key_to_cpu(leaf, &found_key, slot); 16994358d963SJosef Bacik 17004358d963SJosef Bacik if (found_key.objectid >= key->objectid && 17014358d963SJosef Bacik found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) { 1702e3ba67a1SJohannes Thumshirn ret = read_bg_from_eb(fs_info, &found_key, path); 1703e3ba67a1SJohannes Thumshirn break; 1704e3ba67a1SJohannes Thumshirn } 17054358d963SJosef Bacik 17064358d963SJosef Bacik path->slots[0]++; 17074358d963SJosef Bacik } 17084358d963SJosef Bacik out: 17094358d963SJosef Bacik return ret; 17104358d963SJosef Bacik } 17114358d963SJosef Bacik 17124358d963SJosef Bacik static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags) 17134358d963SJosef Bacik { 17144358d963SJosef Bacik u64 extra_flags = chunk_to_extended(flags) & 17154358d963SJosef Bacik BTRFS_EXTENDED_PROFILE_MASK; 17164358d963SJosef Bacik 17174358d963SJosef Bacik write_seqlock(&fs_info->profiles_lock); 17184358d963SJosef Bacik if (flags & BTRFS_BLOCK_GROUP_DATA) 17194358d963SJosef Bacik fs_info->avail_data_alloc_bits |= extra_flags; 17204358d963SJosef Bacik if (flags & BTRFS_BLOCK_GROUP_METADATA) 17214358d963SJosef Bacik fs_info->avail_metadata_alloc_bits |= extra_flags; 17224358d963SJosef Bacik if (flags & BTRFS_BLOCK_GROUP_SYSTEM) 17234358d963SJosef Bacik fs_info->avail_system_alloc_bits |= extra_flags; 17244358d963SJosef Bacik write_sequnlock(&fs_info->profiles_lock); 17254358d963SJosef Bacik } 17264358d963SJosef Bacik 172796a14336SNikolay Borisov /** 17289ee9b979SNikolay Borisov * Map a physical disk address to a list of logical addresses 17299ee9b979SNikolay Borisov * 17309ee9b979SNikolay Borisov * @fs_info: the filesystem 173196a14336SNikolay Borisov * @chunk_start: logical address of block group 1732138082f3SNaohiro Aota * @bdev: physical device to resolve, can be NULL to indicate any device 173396a14336SNikolay Borisov * @physical: physical address to map to logical addresses 173496a14336SNikolay Borisov * @logical: return array of logical addresses which map to @physical 173596a14336SNikolay Borisov * @naddrs: length of @logical 173696a14336SNikolay Borisov * @stripe_len: size of IO stripe for the given block group 173796a14336SNikolay Borisov * 173896a14336SNikolay Borisov * Maps a particular @physical disk address to a list of @logical addresses. 173996a14336SNikolay Borisov * Used primarily to exclude those portions of a block group that contain super 174096a14336SNikolay Borisov * block copies. 174196a14336SNikolay Borisov */ 174296a14336SNikolay Borisov int btrfs_rmap_block(struct btrfs_fs_info *fs_info, u64 chunk_start, 1743138082f3SNaohiro Aota struct block_device *bdev, u64 physical, u64 **logical, 1744138082f3SNaohiro Aota int *naddrs, int *stripe_len) 174596a14336SNikolay Borisov { 174696a14336SNikolay Borisov struct extent_map *em; 174796a14336SNikolay Borisov struct map_lookup *map; 174896a14336SNikolay Borisov u64 *buf; 174996a14336SNikolay Borisov u64 bytenr; 17501776ad17SNikolay Borisov u64 data_stripe_length; 17511776ad17SNikolay Borisov u64 io_stripe_size; 17521776ad17SNikolay Borisov int i, nr = 0; 17531776ad17SNikolay Borisov int ret = 0; 175496a14336SNikolay Borisov 175596a14336SNikolay Borisov em = btrfs_get_chunk_map(fs_info, chunk_start, 1); 175696a14336SNikolay Borisov if (IS_ERR(em)) 175796a14336SNikolay Borisov return -EIO; 175896a14336SNikolay Borisov 175996a14336SNikolay Borisov map = em->map_lookup; 17609e22b925SNikolay Borisov data_stripe_length = em->orig_block_len; 17611776ad17SNikolay Borisov io_stripe_size = map->stripe_len; 1762138082f3SNaohiro Aota chunk_start = em->start; 176396a14336SNikolay Borisov 17649e22b925SNikolay Borisov /* For RAID5/6 adjust to a full IO stripe length */ 17659e22b925SNikolay Borisov if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) 17661776ad17SNikolay Borisov io_stripe_size = map->stripe_len * nr_data_stripes(map); 176796a14336SNikolay Borisov 176896a14336SNikolay Borisov buf = kcalloc(map->num_stripes, sizeof(u64), GFP_NOFS); 17691776ad17SNikolay Borisov if (!buf) { 17701776ad17SNikolay Borisov ret = -ENOMEM; 17711776ad17SNikolay Borisov goto out; 17721776ad17SNikolay Borisov } 177396a14336SNikolay Borisov 177496a14336SNikolay Borisov for (i = 0; i < map->num_stripes; i++) { 17751776ad17SNikolay Borisov bool already_inserted = false; 17761776ad17SNikolay Borisov u64 stripe_nr; 1777138082f3SNaohiro Aota u64 offset; 17781776ad17SNikolay Borisov int j; 17791776ad17SNikolay Borisov 17801776ad17SNikolay Borisov if (!in_range(physical, map->stripes[i].physical, 17811776ad17SNikolay Borisov data_stripe_length)) 178296a14336SNikolay Borisov continue; 178396a14336SNikolay Borisov 1784138082f3SNaohiro Aota if (bdev && map->stripes[i].dev->bdev != bdev) 1785138082f3SNaohiro Aota continue; 1786138082f3SNaohiro Aota 178796a14336SNikolay Borisov stripe_nr = physical - map->stripes[i].physical; 1788138082f3SNaohiro Aota stripe_nr = div64_u64_rem(stripe_nr, map->stripe_len, &offset); 178996a14336SNikolay Borisov 179096a14336SNikolay Borisov if (map->type & BTRFS_BLOCK_GROUP_RAID10) { 179196a14336SNikolay Borisov stripe_nr = stripe_nr * map->num_stripes + i; 179296a14336SNikolay Borisov stripe_nr = div_u64(stripe_nr, map->sub_stripes); 179396a14336SNikolay Borisov } else if (map->type & BTRFS_BLOCK_GROUP_RAID0) { 179496a14336SNikolay Borisov stripe_nr = stripe_nr * map->num_stripes + i; 179596a14336SNikolay Borisov } 179696a14336SNikolay Borisov /* 179796a14336SNikolay Borisov * The remaining case would be for RAID56, multiply by 179896a14336SNikolay Borisov * nr_data_stripes(). Alternatively, just use rmap_len below 179996a14336SNikolay Borisov * instead of map->stripe_len 180096a14336SNikolay Borisov */ 180196a14336SNikolay Borisov 1802138082f3SNaohiro Aota bytenr = chunk_start + stripe_nr * io_stripe_size + offset; 18031776ad17SNikolay Borisov 18041776ad17SNikolay Borisov /* Ensure we don't add duplicate addresses */ 180596a14336SNikolay Borisov for (j = 0; j < nr; j++) { 18061776ad17SNikolay Borisov if (buf[j] == bytenr) { 18071776ad17SNikolay Borisov already_inserted = true; 180896a14336SNikolay Borisov break; 180996a14336SNikolay Borisov } 181096a14336SNikolay Borisov } 18111776ad17SNikolay Borisov 18121776ad17SNikolay Borisov if (!already_inserted) 18131776ad17SNikolay Borisov buf[nr++] = bytenr; 181496a14336SNikolay Borisov } 181596a14336SNikolay Borisov 181696a14336SNikolay Borisov *logical = buf; 181796a14336SNikolay Borisov *naddrs = nr; 18181776ad17SNikolay Borisov *stripe_len = io_stripe_size; 18191776ad17SNikolay Borisov out: 182096a14336SNikolay Borisov free_extent_map(em); 18211776ad17SNikolay Borisov return ret; 182296a14336SNikolay Borisov } 182396a14336SNikolay Borisov 182432da5386SDavid Sterba static int exclude_super_stripes(struct btrfs_block_group *cache) 18254358d963SJosef Bacik { 18264358d963SJosef Bacik struct btrfs_fs_info *fs_info = cache->fs_info; 182712659251SNaohiro Aota const bool zoned = btrfs_is_zoned(fs_info); 18284358d963SJosef Bacik u64 bytenr; 18294358d963SJosef Bacik u64 *logical; 18304358d963SJosef Bacik int stripe_len; 18314358d963SJosef Bacik int i, nr, ret; 18324358d963SJosef Bacik 1833b3470b5dSDavid Sterba if (cache->start < BTRFS_SUPER_INFO_OFFSET) { 1834b3470b5dSDavid Sterba stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->start; 18354358d963SJosef Bacik cache->bytes_super += stripe_len; 1836b3470b5dSDavid Sterba ret = btrfs_add_excluded_extent(fs_info, cache->start, 18374358d963SJosef Bacik stripe_len); 18384358d963SJosef Bacik if (ret) 18394358d963SJosef Bacik return ret; 18404358d963SJosef Bacik } 18414358d963SJosef Bacik 18424358d963SJosef Bacik for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { 18434358d963SJosef Bacik bytenr = btrfs_sb_offset(i); 1844138082f3SNaohiro Aota ret = btrfs_rmap_block(fs_info, cache->start, NULL, 18454358d963SJosef Bacik bytenr, &logical, &nr, &stripe_len); 18464358d963SJosef Bacik if (ret) 18474358d963SJosef Bacik return ret; 18484358d963SJosef Bacik 184912659251SNaohiro Aota /* Shouldn't have super stripes in sequential zones */ 185012659251SNaohiro Aota if (zoned && nr) { 185112659251SNaohiro Aota btrfs_err(fs_info, 185212659251SNaohiro Aota "zoned: block group %llu must not contain super block", 185312659251SNaohiro Aota cache->start); 185412659251SNaohiro Aota return -EUCLEAN; 185512659251SNaohiro Aota } 185612659251SNaohiro Aota 18574358d963SJosef Bacik while (nr--) { 185896f9b0f2SNikolay Borisov u64 len = min_t(u64, stripe_len, 185996f9b0f2SNikolay Borisov cache->start + cache->length - logical[nr]); 18604358d963SJosef Bacik 18614358d963SJosef Bacik cache->bytes_super += len; 186296f9b0f2SNikolay Borisov ret = btrfs_add_excluded_extent(fs_info, logical[nr], 186396f9b0f2SNikolay Borisov len); 18644358d963SJosef Bacik if (ret) { 18654358d963SJosef Bacik kfree(logical); 18664358d963SJosef Bacik return ret; 18674358d963SJosef Bacik } 18684358d963SJosef Bacik } 18694358d963SJosef Bacik 18704358d963SJosef Bacik kfree(logical); 18714358d963SJosef Bacik } 18724358d963SJosef Bacik return 0; 18734358d963SJosef Bacik } 18744358d963SJosef Bacik 187532da5386SDavid Sterba static void link_block_group(struct btrfs_block_group *cache) 18764358d963SJosef Bacik { 18774358d963SJosef Bacik struct btrfs_space_info *space_info = cache->space_info; 18784358d963SJosef Bacik int index = btrfs_bg_flags_to_raid_index(cache->flags); 18794358d963SJosef Bacik 18804358d963SJosef Bacik down_write(&space_info->groups_sem); 18814358d963SJosef Bacik list_add_tail(&cache->list, &space_info->block_groups[index]); 18824358d963SJosef Bacik up_write(&space_info->groups_sem); 18834358d963SJosef Bacik } 18844358d963SJosef Bacik 188532da5386SDavid Sterba static struct btrfs_block_group *btrfs_create_block_group_cache( 18869afc6649SQu Wenruo struct btrfs_fs_info *fs_info, u64 start) 18874358d963SJosef Bacik { 188832da5386SDavid Sterba struct btrfs_block_group *cache; 18894358d963SJosef Bacik 18904358d963SJosef Bacik cache = kzalloc(sizeof(*cache), GFP_NOFS); 18914358d963SJosef Bacik if (!cache) 18924358d963SJosef Bacik return NULL; 18934358d963SJosef Bacik 18944358d963SJosef Bacik cache->free_space_ctl = kzalloc(sizeof(*cache->free_space_ctl), 18954358d963SJosef Bacik GFP_NOFS); 18964358d963SJosef Bacik if (!cache->free_space_ctl) { 18974358d963SJosef Bacik kfree(cache); 18984358d963SJosef Bacik return NULL; 18994358d963SJosef Bacik } 19004358d963SJosef Bacik 1901b3470b5dSDavid Sterba cache->start = start; 19024358d963SJosef Bacik 19034358d963SJosef Bacik cache->fs_info = fs_info; 19044358d963SJosef Bacik cache->full_stripe_len = btrfs_full_stripe_len(fs_info, start); 19054358d963SJosef Bacik 19066e80d4f8SDennis Zhou cache->discard_index = BTRFS_DISCARD_INDEX_UNUSED; 19076e80d4f8SDennis Zhou 190848aaeebeSJosef Bacik refcount_set(&cache->refs, 1); 19094358d963SJosef Bacik spin_lock_init(&cache->lock); 19104358d963SJosef Bacik init_rwsem(&cache->data_rwsem); 19114358d963SJosef Bacik INIT_LIST_HEAD(&cache->list); 19124358d963SJosef Bacik INIT_LIST_HEAD(&cache->cluster_list); 19134358d963SJosef Bacik INIT_LIST_HEAD(&cache->bg_list); 19144358d963SJosef Bacik INIT_LIST_HEAD(&cache->ro_list); 1915b0643e59SDennis Zhou INIT_LIST_HEAD(&cache->discard_list); 19164358d963SJosef Bacik INIT_LIST_HEAD(&cache->dirty_list); 19174358d963SJosef Bacik INIT_LIST_HEAD(&cache->io_list); 1918afba2bc0SNaohiro Aota INIT_LIST_HEAD(&cache->active_bg_list); 1919cd79909bSJosef Bacik btrfs_init_free_space_ctl(cache, cache->free_space_ctl); 19206b7304afSFilipe Manana atomic_set(&cache->frozen, 0); 19214358d963SJosef Bacik mutex_init(&cache->free_space_lock); 19224358d963SJosef Bacik btrfs_init_full_stripe_locks_tree(&cache->full_stripe_locks_root); 19234358d963SJosef Bacik 19244358d963SJosef Bacik return cache; 19254358d963SJosef Bacik } 19264358d963SJosef Bacik 19274358d963SJosef Bacik /* 19284358d963SJosef Bacik * Iterate all chunks and verify that each of them has the corresponding block 19294358d963SJosef Bacik * group 19304358d963SJosef Bacik */ 19314358d963SJosef Bacik static int check_chunk_block_group_mappings(struct btrfs_fs_info *fs_info) 19324358d963SJosef Bacik { 19334358d963SJosef Bacik struct extent_map_tree *map_tree = &fs_info->mapping_tree; 19344358d963SJosef Bacik struct extent_map *em; 193532da5386SDavid Sterba struct btrfs_block_group *bg; 19364358d963SJosef Bacik u64 start = 0; 19374358d963SJosef Bacik int ret = 0; 19384358d963SJosef Bacik 19394358d963SJosef Bacik while (1) { 19404358d963SJosef Bacik read_lock(&map_tree->lock); 19414358d963SJosef Bacik /* 19424358d963SJosef Bacik * lookup_extent_mapping will return the first extent map 19434358d963SJosef Bacik * intersecting the range, so setting @len to 1 is enough to 19444358d963SJosef Bacik * get the first chunk. 19454358d963SJosef Bacik */ 19464358d963SJosef Bacik em = lookup_extent_mapping(map_tree, start, 1); 19474358d963SJosef Bacik read_unlock(&map_tree->lock); 19484358d963SJosef Bacik if (!em) 19494358d963SJosef Bacik break; 19504358d963SJosef Bacik 19514358d963SJosef Bacik bg = btrfs_lookup_block_group(fs_info, em->start); 19524358d963SJosef Bacik if (!bg) { 19534358d963SJosef Bacik btrfs_err(fs_info, 19544358d963SJosef Bacik "chunk start=%llu len=%llu doesn't have corresponding block group", 19554358d963SJosef Bacik em->start, em->len); 19564358d963SJosef Bacik ret = -EUCLEAN; 19574358d963SJosef Bacik free_extent_map(em); 19584358d963SJosef Bacik break; 19594358d963SJosef Bacik } 1960b3470b5dSDavid Sterba if (bg->start != em->start || bg->length != em->len || 19614358d963SJosef Bacik (bg->flags & BTRFS_BLOCK_GROUP_TYPE_MASK) != 19624358d963SJosef Bacik (em->map_lookup->type & BTRFS_BLOCK_GROUP_TYPE_MASK)) { 19634358d963SJosef Bacik btrfs_err(fs_info, 19644358d963SJosef Bacik "chunk start=%llu len=%llu flags=0x%llx doesn't match block group start=%llu len=%llu flags=0x%llx", 19654358d963SJosef Bacik em->start, em->len, 19664358d963SJosef Bacik em->map_lookup->type & BTRFS_BLOCK_GROUP_TYPE_MASK, 1967b3470b5dSDavid Sterba bg->start, bg->length, 19684358d963SJosef Bacik bg->flags & BTRFS_BLOCK_GROUP_TYPE_MASK); 19694358d963SJosef Bacik ret = -EUCLEAN; 19704358d963SJosef Bacik free_extent_map(em); 19714358d963SJosef Bacik btrfs_put_block_group(bg); 19724358d963SJosef Bacik break; 19734358d963SJosef Bacik } 19744358d963SJosef Bacik start = em->start + em->len; 19754358d963SJosef Bacik free_extent_map(em); 19764358d963SJosef Bacik btrfs_put_block_group(bg); 19774358d963SJosef Bacik } 19784358d963SJosef Bacik return ret; 19794358d963SJosef Bacik } 19804358d963SJosef Bacik 1981ffb9e0f0SQu Wenruo static int read_one_block_group(struct btrfs_fs_info *info, 19824afd2fe8SJohannes Thumshirn struct btrfs_block_group_item *bgi, 1983d49a2ddbSQu Wenruo const struct btrfs_key *key, 1984ffb9e0f0SQu Wenruo int need_clear) 1985ffb9e0f0SQu Wenruo { 198632da5386SDavid Sterba struct btrfs_block_group *cache; 1987ffb9e0f0SQu Wenruo struct btrfs_space_info *space_info; 1988ffb9e0f0SQu Wenruo const bool mixed = btrfs_fs_incompat(info, MIXED_GROUPS); 1989ffb9e0f0SQu Wenruo int ret; 1990ffb9e0f0SQu Wenruo 1991d49a2ddbSQu Wenruo ASSERT(key->type == BTRFS_BLOCK_GROUP_ITEM_KEY); 1992ffb9e0f0SQu Wenruo 19939afc6649SQu Wenruo cache = btrfs_create_block_group_cache(info, key->objectid); 1994ffb9e0f0SQu Wenruo if (!cache) 1995ffb9e0f0SQu Wenruo return -ENOMEM; 1996ffb9e0f0SQu Wenruo 19974afd2fe8SJohannes Thumshirn cache->length = key->offset; 19984afd2fe8SJohannes Thumshirn cache->used = btrfs_stack_block_group_used(bgi); 19994afd2fe8SJohannes Thumshirn cache->flags = btrfs_stack_block_group_flags(bgi); 20009afc6649SQu Wenruo 2001e3e39c72SMarcos Paulo de Souza set_free_space_tree_thresholds(cache); 2002e3e39c72SMarcos Paulo de Souza 2003ffb9e0f0SQu Wenruo if (need_clear) { 2004ffb9e0f0SQu Wenruo /* 2005ffb9e0f0SQu Wenruo * When we mount with old space cache, we need to 2006ffb9e0f0SQu Wenruo * set BTRFS_DC_CLEAR and set dirty flag. 2007ffb9e0f0SQu Wenruo * 2008ffb9e0f0SQu Wenruo * a) Setting 'BTRFS_DC_CLEAR' makes sure that we 2009ffb9e0f0SQu Wenruo * truncate the old free space cache inode and 2010ffb9e0f0SQu Wenruo * setup a new one. 2011ffb9e0f0SQu Wenruo * b) Setting 'dirty flag' makes sure that we flush 2012ffb9e0f0SQu Wenruo * the new space cache info onto disk. 2013ffb9e0f0SQu Wenruo */ 2014ffb9e0f0SQu Wenruo if (btrfs_test_opt(info, SPACE_CACHE)) 2015ffb9e0f0SQu Wenruo cache->disk_cache_state = BTRFS_DC_CLEAR; 2016ffb9e0f0SQu Wenruo } 2017ffb9e0f0SQu Wenruo if (!mixed && ((cache->flags & BTRFS_BLOCK_GROUP_METADATA) && 2018ffb9e0f0SQu Wenruo (cache->flags & BTRFS_BLOCK_GROUP_DATA))) { 2019ffb9e0f0SQu Wenruo btrfs_err(info, 2020ffb9e0f0SQu Wenruo "bg %llu is a mixed block group but filesystem hasn't enabled mixed block groups", 2021ffb9e0f0SQu Wenruo cache->start); 2022ffb9e0f0SQu Wenruo ret = -EINVAL; 2023ffb9e0f0SQu Wenruo goto error; 2024ffb9e0f0SQu Wenruo } 2025ffb9e0f0SQu Wenruo 2026a94794d5SNaohiro Aota ret = btrfs_load_block_group_zone_info(cache, false); 202708e11a3dSNaohiro Aota if (ret) { 202808e11a3dSNaohiro Aota btrfs_err(info, "zoned: failed to load zone info of bg %llu", 202908e11a3dSNaohiro Aota cache->start); 203008e11a3dSNaohiro Aota goto error; 203108e11a3dSNaohiro Aota } 203208e11a3dSNaohiro Aota 2033ffb9e0f0SQu Wenruo /* 2034ffb9e0f0SQu Wenruo * We need to exclude the super stripes now so that the space info has 2035ffb9e0f0SQu Wenruo * super bytes accounted for, otherwise we'll think we have more space 2036ffb9e0f0SQu Wenruo * than we actually do. 2037ffb9e0f0SQu Wenruo */ 2038ffb9e0f0SQu Wenruo ret = exclude_super_stripes(cache); 2039ffb9e0f0SQu Wenruo if (ret) { 2040ffb9e0f0SQu Wenruo /* We may have excluded something, so call this just in case. */ 2041ffb9e0f0SQu Wenruo btrfs_free_excluded_extents(cache); 2042ffb9e0f0SQu Wenruo goto error; 2043ffb9e0f0SQu Wenruo } 2044ffb9e0f0SQu Wenruo 2045ffb9e0f0SQu Wenruo /* 2046169e0da9SNaohiro Aota * For zoned filesystem, space after the allocation offset is the only 2047169e0da9SNaohiro Aota * free space for a block group. So, we don't need any caching work. 2048169e0da9SNaohiro Aota * btrfs_calc_zone_unusable() will set the amount of free space and 2049169e0da9SNaohiro Aota * zone_unusable space. 2050169e0da9SNaohiro Aota * 2051169e0da9SNaohiro Aota * For regular filesystem, check for two cases, either we are full, and 2052169e0da9SNaohiro Aota * therefore don't need to bother with the caching work since we won't 2053169e0da9SNaohiro Aota * find any space, or we are empty, and we can just add all the space 2054169e0da9SNaohiro Aota * in and be done with it. This saves us _a_lot_ of time, particularly 2055169e0da9SNaohiro Aota * in the full case. 2056ffb9e0f0SQu Wenruo */ 2057169e0da9SNaohiro Aota if (btrfs_is_zoned(info)) { 2058169e0da9SNaohiro Aota btrfs_calc_zone_unusable(cache); 2059c46c4247SNaohiro Aota /* Should not have any excluded extents. Just in case, though. */ 2060c46c4247SNaohiro Aota btrfs_free_excluded_extents(cache); 2061169e0da9SNaohiro Aota } else if (cache->length == cache->used) { 2062ffb9e0f0SQu Wenruo cache->last_byte_to_unpin = (u64)-1; 2063ffb9e0f0SQu Wenruo cache->cached = BTRFS_CACHE_FINISHED; 2064ffb9e0f0SQu Wenruo btrfs_free_excluded_extents(cache); 2065ffb9e0f0SQu Wenruo } else if (cache->used == 0) { 2066ffb9e0f0SQu Wenruo cache->last_byte_to_unpin = (u64)-1; 2067ffb9e0f0SQu Wenruo cache->cached = BTRFS_CACHE_FINISHED; 20689afc6649SQu Wenruo add_new_free_space(cache, cache->start, 20699afc6649SQu Wenruo cache->start + cache->length); 2070ffb9e0f0SQu Wenruo btrfs_free_excluded_extents(cache); 2071ffb9e0f0SQu Wenruo } 2072ffb9e0f0SQu Wenruo 2073ffb9e0f0SQu Wenruo ret = btrfs_add_block_group_cache(info, cache); 2074ffb9e0f0SQu Wenruo if (ret) { 2075ffb9e0f0SQu Wenruo btrfs_remove_free_space_cache(cache); 2076ffb9e0f0SQu Wenruo goto error; 2077ffb9e0f0SQu Wenruo } 2078ffb9e0f0SQu Wenruo trace_btrfs_add_block_group(info, cache, 0); 20799afc6649SQu Wenruo btrfs_update_space_info(info, cache->flags, cache->length, 2080169e0da9SNaohiro Aota cache->used, cache->bytes_super, 2081169e0da9SNaohiro Aota cache->zone_unusable, &space_info); 2082ffb9e0f0SQu Wenruo 2083ffb9e0f0SQu Wenruo cache->space_info = space_info; 2084ffb9e0f0SQu Wenruo 2085ffb9e0f0SQu Wenruo link_block_group(cache); 2086ffb9e0f0SQu Wenruo 2087ffb9e0f0SQu Wenruo set_avail_alloc_bits(info, cache->flags); 2088a09f23c3SAnand Jain if (btrfs_chunk_writeable(info, cache->start)) { 2089a09f23c3SAnand Jain if (cache->used == 0) { 2090ffb9e0f0SQu Wenruo ASSERT(list_empty(&cache->bg_list)); 20916e80d4f8SDennis Zhou if (btrfs_test_opt(info, DISCARD_ASYNC)) 20926e80d4f8SDennis Zhou btrfs_discard_queue_work(&info->discard_ctl, cache); 20936e80d4f8SDennis Zhou else 2094ffb9e0f0SQu Wenruo btrfs_mark_bg_unused(cache); 2095ffb9e0f0SQu Wenruo } 2096a09f23c3SAnand Jain } else { 2097a09f23c3SAnand Jain inc_block_group_ro(cache, 1); 2098a09f23c3SAnand Jain } 2099a09f23c3SAnand Jain 2100ffb9e0f0SQu Wenruo return 0; 2101ffb9e0f0SQu Wenruo error: 2102ffb9e0f0SQu Wenruo btrfs_put_block_group(cache); 2103ffb9e0f0SQu Wenruo return ret; 2104ffb9e0f0SQu Wenruo } 2105ffb9e0f0SQu Wenruo 210642437a63SJosef Bacik static int fill_dummy_bgs(struct btrfs_fs_info *fs_info) 210742437a63SJosef Bacik { 210842437a63SJosef Bacik struct extent_map_tree *em_tree = &fs_info->mapping_tree; 210942437a63SJosef Bacik struct btrfs_space_info *space_info; 211042437a63SJosef Bacik struct rb_node *node; 211142437a63SJosef Bacik int ret = 0; 211242437a63SJosef Bacik 211342437a63SJosef Bacik for (node = rb_first_cached(&em_tree->map); node; node = rb_next(node)) { 211442437a63SJosef Bacik struct extent_map *em; 211542437a63SJosef Bacik struct map_lookup *map; 211642437a63SJosef Bacik struct btrfs_block_group *bg; 211742437a63SJosef Bacik 211842437a63SJosef Bacik em = rb_entry(node, struct extent_map, rb_node); 211942437a63SJosef Bacik map = em->map_lookup; 212042437a63SJosef Bacik bg = btrfs_create_block_group_cache(fs_info, em->start); 212142437a63SJosef Bacik if (!bg) { 212242437a63SJosef Bacik ret = -ENOMEM; 212342437a63SJosef Bacik break; 212442437a63SJosef Bacik } 212542437a63SJosef Bacik 212642437a63SJosef Bacik /* Fill dummy cache as FULL */ 212742437a63SJosef Bacik bg->length = em->len; 212842437a63SJosef Bacik bg->flags = map->type; 212942437a63SJosef Bacik bg->last_byte_to_unpin = (u64)-1; 213042437a63SJosef Bacik bg->cached = BTRFS_CACHE_FINISHED; 213142437a63SJosef Bacik bg->used = em->len; 213242437a63SJosef Bacik bg->flags = map->type; 213342437a63SJosef Bacik ret = btrfs_add_block_group_cache(fs_info, bg); 21342b29726cSQu Wenruo /* 21352b29726cSQu Wenruo * We may have some valid block group cache added already, in 21362b29726cSQu Wenruo * that case we skip to the next one. 21372b29726cSQu Wenruo */ 21382b29726cSQu Wenruo if (ret == -EEXIST) { 21392b29726cSQu Wenruo ret = 0; 21402b29726cSQu Wenruo btrfs_put_block_group(bg); 21412b29726cSQu Wenruo continue; 21422b29726cSQu Wenruo } 21432b29726cSQu Wenruo 214442437a63SJosef Bacik if (ret) { 214542437a63SJosef Bacik btrfs_remove_free_space_cache(bg); 214642437a63SJosef Bacik btrfs_put_block_group(bg); 214742437a63SJosef Bacik break; 214842437a63SJosef Bacik } 21492b29726cSQu Wenruo 215042437a63SJosef Bacik btrfs_update_space_info(fs_info, bg->flags, em->len, em->len, 2151169e0da9SNaohiro Aota 0, 0, &space_info); 215242437a63SJosef Bacik bg->space_info = space_info; 215342437a63SJosef Bacik link_block_group(bg); 215442437a63SJosef Bacik 215542437a63SJosef Bacik set_avail_alloc_bits(fs_info, bg->flags); 215642437a63SJosef Bacik } 215742437a63SJosef Bacik if (!ret) 215842437a63SJosef Bacik btrfs_init_global_block_rsv(fs_info); 215942437a63SJosef Bacik return ret; 216042437a63SJosef Bacik } 216142437a63SJosef Bacik 21624358d963SJosef Bacik int btrfs_read_block_groups(struct btrfs_fs_info *info) 21634358d963SJosef Bacik { 2164dfe8aec4SJosef Bacik struct btrfs_root *root = btrfs_block_group_root(info); 21654358d963SJosef Bacik struct btrfs_path *path; 21664358d963SJosef Bacik int ret; 216732da5386SDavid Sterba struct btrfs_block_group *cache; 21684358d963SJosef Bacik struct btrfs_space_info *space_info; 21694358d963SJosef Bacik struct btrfs_key key; 21704358d963SJosef Bacik int need_clear = 0; 21714358d963SJosef Bacik u64 cache_gen; 21724358d963SJosef Bacik 2173dfe8aec4SJosef Bacik if (!root) 217442437a63SJosef Bacik return fill_dummy_bgs(info); 217542437a63SJosef Bacik 21764358d963SJosef Bacik key.objectid = 0; 21774358d963SJosef Bacik key.offset = 0; 21784358d963SJosef Bacik key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; 21794358d963SJosef Bacik path = btrfs_alloc_path(); 21804358d963SJosef Bacik if (!path) 21814358d963SJosef Bacik return -ENOMEM; 21824358d963SJosef Bacik 21834358d963SJosef Bacik cache_gen = btrfs_super_cache_generation(info->super_copy); 21844358d963SJosef Bacik if (btrfs_test_opt(info, SPACE_CACHE) && 21854358d963SJosef Bacik btrfs_super_generation(info->super_copy) != cache_gen) 21864358d963SJosef Bacik need_clear = 1; 21874358d963SJosef Bacik if (btrfs_test_opt(info, CLEAR_CACHE)) 21884358d963SJosef Bacik need_clear = 1; 21894358d963SJosef Bacik 21904358d963SJosef Bacik while (1) { 21914afd2fe8SJohannes Thumshirn struct btrfs_block_group_item bgi; 21924afd2fe8SJohannes Thumshirn struct extent_buffer *leaf; 21934afd2fe8SJohannes Thumshirn int slot; 21944afd2fe8SJohannes Thumshirn 21954358d963SJosef Bacik ret = find_first_block_group(info, path, &key); 21964358d963SJosef Bacik if (ret > 0) 21974358d963SJosef Bacik break; 21984358d963SJosef Bacik if (ret != 0) 21994358d963SJosef Bacik goto error; 22004358d963SJosef Bacik 22014afd2fe8SJohannes Thumshirn leaf = path->nodes[0]; 22024afd2fe8SJohannes Thumshirn slot = path->slots[0]; 22034afd2fe8SJohannes Thumshirn 22044afd2fe8SJohannes Thumshirn read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot), 22054afd2fe8SJohannes Thumshirn sizeof(bgi)); 22064afd2fe8SJohannes Thumshirn 22074afd2fe8SJohannes Thumshirn btrfs_item_key_to_cpu(leaf, &key, slot); 22084afd2fe8SJohannes Thumshirn btrfs_release_path(path); 22094afd2fe8SJohannes Thumshirn ret = read_one_block_group(info, &bgi, &key, need_clear); 2210ffb9e0f0SQu Wenruo if (ret < 0) 22114358d963SJosef Bacik goto error; 2212ffb9e0f0SQu Wenruo key.objectid += key.offset; 2213ffb9e0f0SQu Wenruo key.offset = 0; 22144358d963SJosef Bacik } 22157837fa88SJosef Bacik btrfs_release_path(path); 22164358d963SJosef Bacik 221772804905SJosef Bacik list_for_each_entry(space_info, &info->space_info, list) { 221849ea112dSJosef Bacik int i; 221949ea112dSJosef Bacik 222049ea112dSJosef Bacik for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 222149ea112dSJosef Bacik if (list_empty(&space_info->block_groups[i])) 222249ea112dSJosef Bacik continue; 222349ea112dSJosef Bacik cache = list_first_entry(&space_info->block_groups[i], 222449ea112dSJosef Bacik struct btrfs_block_group, 222549ea112dSJosef Bacik list); 222649ea112dSJosef Bacik btrfs_sysfs_add_block_group_type(cache); 222749ea112dSJosef Bacik } 222849ea112dSJosef Bacik 22294358d963SJosef Bacik if (!(btrfs_get_alloc_profile(info, space_info->flags) & 22304358d963SJosef Bacik (BTRFS_BLOCK_GROUP_RAID10 | 22314358d963SJosef Bacik BTRFS_BLOCK_GROUP_RAID1_MASK | 22324358d963SJosef Bacik BTRFS_BLOCK_GROUP_RAID56_MASK | 22334358d963SJosef Bacik BTRFS_BLOCK_GROUP_DUP))) 22344358d963SJosef Bacik continue; 22354358d963SJosef Bacik /* 22364358d963SJosef Bacik * Avoid allocating from un-mirrored block group if there are 22374358d963SJosef Bacik * mirrored block groups. 22384358d963SJosef Bacik */ 22394358d963SJosef Bacik list_for_each_entry(cache, 22404358d963SJosef Bacik &space_info->block_groups[BTRFS_RAID_RAID0], 22414358d963SJosef Bacik list) 2242e11c0406SJosef Bacik inc_block_group_ro(cache, 1); 22434358d963SJosef Bacik list_for_each_entry(cache, 22444358d963SJosef Bacik &space_info->block_groups[BTRFS_RAID_SINGLE], 22454358d963SJosef Bacik list) 2246e11c0406SJosef Bacik inc_block_group_ro(cache, 1); 22474358d963SJosef Bacik } 22484358d963SJosef Bacik 22494358d963SJosef Bacik btrfs_init_global_block_rsv(info); 22504358d963SJosef Bacik ret = check_chunk_block_group_mappings(info); 22514358d963SJosef Bacik error: 22524358d963SJosef Bacik btrfs_free_path(path); 22532b29726cSQu Wenruo /* 22542b29726cSQu Wenruo * We've hit some error while reading the extent tree, and have 22552b29726cSQu Wenruo * rescue=ibadroots mount option. 22562b29726cSQu Wenruo * Try to fill the tree using dummy block groups so that the user can 22572b29726cSQu Wenruo * continue to mount and grab their data. 22582b29726cSQu Wenruo */ 22592b29726cSQu Wenruo if (ret && btrfs_test_opt(info, IGNOREBADROOTS)) 22602b29726cSQu Wenruo ret = fill_dummy_bgs(info); 22614358d963SJosef Bacik return ret; 22624358d963SJosef Bacik } 22634358d963SJosef Bacik 226479bd3712SFilipe Manana /* 226579bd3712SFilipe Manana * This function, insert_block_group_item(), belongs to the phase 2 of chunk 226679bd3712SFilipe Manana * allocation. 226779bd3712SFilipe Manana * 226879bd3712SFilipe Manana * See the comment at btrfs_chunk_alloc() for details about the chunk allocation 226979bd3712SFilipe Manana * phases. 227079bd3712SFilipe Manana */ 227197f4728aSQu Wenruo static int insert_block_group_item(struct btrfs_trans_handle *trans, 227297f4728aSQu Wenruo struct btrfs_block_group *block_group) 227397f4728aSQu Wenruo { 227497f4728aSQu Wenruo struct btrfs_fs_info *fs_info = trans->fs_info; 227597f4728aSQu Wenruo struct btrfs_block_group_item bgi; 2276dfe8aec4SJosef Bacik struct btrfs_root *root = btrfs_block_group_root(fs_info); 227797f4728aSQu Wenruo struct btrfs_key key; 227897f4728aSQu Wenruo 227997f4728aSQu Wenruo spin_lock(&block_group->lock); 228097f4728aSQu Wenruo btrfs_set_stack_block_group_used(&bgi, block_group->used); 228197f4728aSQu Wenruo btrfs_set_stack_block_group_chunk_objectid(&bgi, 228297f4728aSQu Wenruo BTRFS_FIRST_CHUNK_TREE_OBJECTID); 228397f4728aSQu Wenruo btrfs_set_stack_block_group_flags(&bgi, block_group->flags); 228497f4728aSQu Wenruo key.objectid = block_group->start; 228597f4728aSQu Wenruo key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; 228697f4728aSQu Wenruo key.offset = block_group->length; 228797f4728aSQu Wenruo spin_unlock(&block_group->lock); 228897f4728aSQu Wenruo 228997f4728aSQu Wenruo return btrfs_insert_item(trans, root, &key, &bgi, sizeof(bgi)); 229097f4728aSQu Wenruo } 229197f4728aSQu Wenruo 22922eadb9e7SNikolay Borisov static int insert_dev_extent(struct btrfs_trans_handle *trans, 22932eadb9e7SNikolay Borisov struct btrfs_device *device, u64 chunk_offset, 22942eadb9e7SNikolay Borisov u64 start, u64 num_bytes) 22952eadb9e7SNikolay Borisov { 22962eadb9e7SNikolay Borisov struct btrfs_fs_info *fs_info = device->fs_info; 22972eadb9e7SNikolay Borisov struct btrfs_root *root = fs_info->dev_root; 22982eadb9e7SNikolay Borisov struct btrfs_path *path; 22992eadb9e7SNikolay Borisov struct btrfs_dev_extent *extent; 23002eadb9e7SNikolay Borisov struct extent_buffer *leaf; 23012eadb9e7SNikolay Borisov struct btrfs_key key; 23022eadb9e7SNikolay Borisov int ret; 23032eadb9e7SNikolay Borisov 23042eadb9e7SNikolay Borisov WARN_ON(!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state)); 23052eadb9e7SNikolay Borisov WARN_ON(test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state)); 23062eadb9e7SNikolay Borisov path = btrfs_alloc_path(); 23072eadb9e7SNikolay Borisov if (!path) 23082eadb9e7SNikolay Borisov return -ENOMEM; 23092eadb9e7SNikolay Borisov 23102eadb9e7SNikolay Borisov key.objectid = device->devid; 23112eadb9e7SNikolay Borisov key.type = BTRFS_DEV_EXTENT_KEY; 23122eadb9e7SNikolay Borisov key.offset = start; 23132eadb9e7SNikolay Borisov ret = btrfs_insert_empty_item(trans, root, path, &key, sizeof(*extent)); 23142eadb9e7SNikolay Borisov if (ret) 23152eadb9e7SNikolay Borisov goto out; 23162eadb9e7SNikolay Borisov 23172eadb9e7SNikolay Borisov leaf = path->nodes[0]; 23182eadb9e7SNikolay Borisov extent = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent); 23192eadb9e7SNikolay Borisov btrfs_set_dev_extent_chunk_tree(leaf, extent, BTRFS_CHUNK_TREE_OBJECTID); 23202eadb9e7SNikolay Borisov btrfs_set_dev_extent_chunk_objectid(leaf, extent, 23212eadb9e7SNikolay Borisov BTRFS_FIRST_CHUNK_TREE_OBJECTID); 23222eadb9e7SNikolay Borisov btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset); 23232eadb9e7SNikolay Borisov 23242eadb9e7SNikolay Borisov btrfs_set_dev_extent_length(leaf, extent, num_bytes); 23252eadb9e7SNikolay Borisov btrfs_mark_buffer_dirty(leaf); 23262eadb9e7SNikolay Borisov out: 23272eadb9e7SNikolay Borisov btrfs_free_path(path); 23282eadb9e7SNikolay Borisov return ret; 23292eadb9e7SNikolay Borisov } 23302eadb9e7SNikolay Borisov 23312eadb9e7SNikolay Borisov /* 23322eadb9e7SNikolay Borisov * This function belongs to phase 2. 23332eadb9e7SNikolay Borisov * 23342eadb9e7SNikolay Borisov * See the comment at btrfs_chunk_alloc() for details about the chunk allocation 23352eadb9e7SNikolay Borisov * phases. 23362eadb9e7SNikolay Borisov */ 23372eadb9e7SNikolay Borisov static int insert_dev_extents(struct btrfs_trans_handle *trans, 23382eadb9e7SNikolay Borisov u64 chunk_offset, u64 chunk_size) 23392eadb9e7SNikolay Borisov { 23402eadb9e7SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 23412eadb9e7SNikolay Borisov struct btrfs_device *device; 23422eadb9e7SNikolay Borisov struct extent_map *em; 23432eadb9e7SNikolay Borisov struct map_lookup *map; 23442eadb9e7SNikolay Borisov u64 dev_offset; 23452eadb9e7SNikolay Borisov u64 stripe_size; 23462eadb9e7SNikolay Borisov int i; 23472eadb9e7SNikolay Borisov int ret = 0; 23482eadb9e7SNikolay Borisov 23492eadb9e7SNikolay Borisov em = btrfs_get_chunk_map(fs_info, chunk_offset, chunk_size); 23502eadb9e7SNikolay Borisov if (IS_ERR(em)) 23512eadb9e7SNikolay Borisov return PTR_ERR(em); 23522eadb9e7SNikolay Borisov 23532eadb9e7SNikolay Borisov map = em->map_lookup; 23542eadb9e7SNikolay Borisov stripe_size = em->orig_block_len; 23552eadb9e7SNikolay Borisov 23562eadb9e7SNikolay Borisov /* 23572eadb9e7SNikolay Borisov * Take the device list mutex to prevent races with the final phase of 23582eadb9e7SNikolay Borisov * a device replace operation that replaces the device object associated 23592eadb9e7SNikolay Borisov * with the map's stripes, because the device object's id can change 23602eadb9e7SNikolay Borisov * at any time during that final phase of the device replace operation 23612eadb9e7SNikolay Borisov * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the 23622eadb9e7SNikolay Borisov * replaced device and then see it with an ID of BTRFS_DEV_REPLACE_DEVID, 23632eadb9e7SNikolay Borisov * resulting in persisting a device extent item with such ID. 23642eadb9e7SNikolay Borisov */ 23652eadb9e7SNikolay Borisov mutex_lock(&fs_info->fs_devices->device_list_mutex); 23662eadb9e7SNikolay Borisov for (i = 0; i < map->num_stripes; i++) { 23672eadb9e7SNikolay Borisov device = map->stripes[i].dev; 23682eadb9e7SNikolay Borisov dev_offset = map->stripes[i].physical; 23692eadb9e7SNikolay Borisov 23702eadb9e7SNikolay Borisov ret = insert_dev_extent(trans, device, chunk_offset, dev_offset, 23712eadb9e7SNikolay Borisov stripe_size); 23722eadb9e7SNikolay Borisov if (ret) 23732eadb9e7SNikolay Borisov break; 23742eadb9e7SNikolay Borisov } 23752eadb9e7SNikolay Borisov mutex_unlock(&fs_info->fs_devices->device_list_mutex); 23762eadb9e7SNikolay Borisov 23772eadb9e7SNikolay Borisov free_extent_map(em); 23782eadb9e7SNikolay Borisov return ret; 23792eadb9e7SNikolay Borisov } 23802eadb9e7SNikolay Borisov 238179bd3712SFilipe Manana /* 238279bd3712SFilipe Manana * This function, btrfs_create_pending_block_groups(), belongs to the phase 2 of 238379bd3712SFilipe Manana * chunk allocation. 238479bd3712SFilipe Manana * 238579bd3712SFilipe Manana * See the comment at btrfs_chunk_alloc() for details about the chunk allocation 238679bd3712SFilipe Manana * phases. 238779bd3712SFilipe Manana */ 23884358d963SJosef Bacik void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans) 23894358d963SJosef Bacik { 23904358d963SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 239132da5386SDavid Sterba struct btrfs_block_group *block_group; 23924358d963SJosef Bacik int ret = 0; 23934358d963SJosef Bacik 23944358d963SJosef Bacik while (!list_empty(&trans->new_bgs)) { 239549ea112dSJosef Bacik int index; 239649ea112dSJosef Bacik 23974358d963SJosef Bacik block_group = list_first_entry(&trans->new_bgs, 239832da5386SDavid Sterba struct btrfs_block_group, 23994358d963SJosef Bacik bg_list); 24004358d963SJosef Bacik if (ret) 24014358d963SJosef Bacik goto next; 24024358d963SJosef Bacik 240349ea112dSJosef Bacik index = btrfs_bg_flags_to_raid_index(block_group->flags); 240449ea112dSJosef Bacik 240597f4728aSQu Wenruo ret = insert_block_group_item(trans, block_group); 24064358d963SJosef Bacik if (ret) 24074358d963SJosef Bacik btrfs_abort_transaction(trans, ret); 240879bd3712SFilipe Manana if (!block_group->chunk_item_inserted) { 240979bd3712SFilipe Manana mutex_lock(&fs_info->chunk_mutex); 241079bd3712SFilipe Manana ret = btrfs_chunk_alloc_add_chunk_item(trans, block_group); 241179bd3712SFilipe Manana mutex_unlock(&fs_info->chunk_mutex); 241279bd3712SFilipe Manana if (ret) 241379bd3712SFilipe Manana btrfs_abort_transaction(trans, ret); 241479bd3712SFilipe Manana } 24152eadb9e7SNikolay Borisov ret = insert_dev_extents(trans, block_group->start, 241697f4728aSQu Wenruo block_group->length); 24174358d963SJosef Bacik if (ret) 24184358d963SJosef Bacik btrfs_abort_transaction(trans, ret); 24194358d963SJosef Bacik add_block_group_free_space(trans, block_group); 242049ea112dSJosef Bacik 242149ea112dSJosef Bacik /* 242249ea112dSJosef Bacik * If we restriped during balance, we may have added a new raid 242349ea112dSJosef Bacik * type, so now add the sysfs entries when it is safe to do so. 242449ea112dSJosef Bacik * We don't have to worry about locking here as it's handled in 242549ea112dSJosef Bacik * btrfs_sysfs_add_block_group_type. 242649ea112dSJosef Bacik */ 242749ea112dSJosef Bacik if (block_group->space_info->block_group_kobjs[index] == NULL) 242849ea112dSJosef Bacik btrfs_sysfs_add_block_group_type(block_group); 242949ea112dSJosef Bacik 24304358d963SJosef Bacik /* Already aborted the transaction if it failed. */ 24314358d963SJosef Bacik next: 24324358d963SJosef Bacik btrfs_delayed_refs_rsv_release(fs_info, 1); 24334358d963SJosef Bacik list_del_init(&block_group->bg_list); 24344358d963SJosef Bacik } 24354358d963SJosef Bacik btrfs_trans_release_chunk_metadata(trans); 24364358d963SJosef Bacik } 24374358d963SJosef Bacik 243879bd3712SFilipe Manana struct btrfs_block_group *btrfs_make_block_group(struct btrfs_trans_handle *trans, 243979bd3712SFilipe Manana u64 bytes_used, u64 type, 244079bd3712SFilipe Manana u64 chunk_offset, u64 size) 24414358d963SJosef Bacik { 24424358d963SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 244332da5386SDavid Sterba struct btrfs_block_group *cache; 24444358d963SJosef Bacik int ret; 24454358d963SJosef Bacik 24464358d963SJosef Bacik btrfs_set_log_full_commit(trans); 24474358d963SJosef Bacik 24489afc6649SQu Wenruo cache = btrfs_create_block_group_cache(fs_info, chunk_offset); 24494358d963SJosef Bacik if (!cache) 245079bd3712SFilipe Manana return ERR_PTR(-ENOMEM); 24514358d963SJosef Bacik 24529afc6649SQu Wenruo cache->length = size; 2453e3e39c72SMarcos Paulo de Souza set_free_space_tree_thresholds(cache); 2454bf38be65SDavid Sterba cache->used = bytes_used; 24554358d963SJosef Bacik cache->flags = type; 24564358d963SJosef Bacik cache->last_byte_to_unpin = (u64)-1; 24574358d963SJosef Bacik cache->cached = BTRFS_CACHE_FINISHED; 2458997e3e2eSBoris Burkov if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) 24594358d963SJosef Bacik cache->needs_free_space = 1; 246008e11a3dSNaohiro Aota 2461a94794d5SNaohiro Aota ret = btrfs_load_block_group_zone_info(cache, true); 246208e11a3dSNaohiro Aota if (ret) { 246308e11a3dSNaohiro Aota btrfs_put_block_group(cache); 246479bd3712SFilipe Manana return ERR_PTR(ret); 246508e11a3dSNaohiro Aota } 246608e11a3dSNaohiro Aota 2467eb66a010SNaohiro Aota /* 2468eb66a010SNaohiro Aota * New block group is likely to be used soon. Try to activate it now. 2469eb66a010SNaohiro Aota * Failure is OK for now. 2470eb66a010SNaohiro Aota */ 2471eb66a010SNaohiro Aota btrfs_zone_activate(cache); 2472eb66a010SNaohiro Aota 24734358d963SJosef Bacik ret = exclude_super_stripes(cache); 24744358d963SJosef Bacik if (ret) { 24754358d963SJosef Bacik /* We may have excluded something, so call this just in case */ 24764358d963SJosef Bacik btrfs_free_excluded_extents(cache); 24774358d963SJosef Bacik btrfs_put_block_group(cache); 247879bd3712SFilipe Manana return ERR_PTR(ret); 24794358d963SJosef Bacik } 24804358d963SJosef Bacik 24814358d963SJosef Bacik add_new_free_space(cache, chunk_offset, chunk_offset + size); 24824358d963SJosef Bacik 24834358d963SJosef Bacik btrfs_free_excluded_extents(cache); 24844358d963SJosef Bacik 24854358d963SJosef Bacik #ifdef CONFIG_BTRFS_DEBUG 24864358d963SJosef Bacik if (btrfs_should_fragment_free_space(cache)) { 24874358d963SJosef Bacik u64 new_bytes_used = size - bytes_used; 24884358d963SJosef Bacik 24894358d963SJosef Bacik bytes_used += new_bytes_used >> 1; 2490e11c0406SJosef Bacik fragment_free_space(cache); 24914358d963SJosef Bacik } 24924358d963SJosef Bacik #endif 24934358d963SJosef Bacik /* 24944358d963SJosef Bacik * Ensure the corresponding space_info object is created and 24954358d963SJosef Bacik * assigned to our block group. We want our bg to be added to the rbtree 24964358d963SJosef Bacik * with its ->space_info set. 24974358d963SJosef Bacik */ 24984358d963SJosef Bacik cache->space_info = btrfs_find_space_info(fs_info, cache->flags); 24994358d963SJosef Bacik ASSERT(cache->space_info); 25004358d963SJosef Bacik 25014358d963SJosef Bacik ret = btrfs_add_block_group_cache(fs_info, cache); 25024358d963SJosef Bacik if (ret) { 25034358d963SJosef Bacik btrfs_remove_free_space_cache(cache); 25044358d963SJosef Bacik btrfs_put_block_group(cache); 250579bd3712SFilipe Manana return ERR_PTR(ret); 25064358d963SJosef Bacik } 25074358d963SJosef Bacik 25084358d963SJosef Bacik /* 25094358d963SJosef Bacik * Now that our block group has its ->space_info set and is inserted in 25104358d963SJosef Bacik * the rbtree, update the space info's counters. 25114358d963SJosef Bacik */ 25124358d963SJosef Bacik trace_btrfs_add_block_group(fs_info, cache, 1); 25134358d963SJosef Bacik btrfs_update_space_info(fs_info, cache->flags, size, bytes_used, 251498173255SNaohiro Aota cache->bytes_super, cache->zone_unusable, 251598173255SNaohiro Aota &cache->space_info); 25164358d963SJosef Bacik btrfs_update_global_block_rsv(fs_info); 25174358d963SJosef Bacik 25184358d963SJosef Bacik link_block_group(cache); 25194358d963SJosef Bacik 25204358d963SJosef Bacik list_add_tail(&cache->bg_list, &trans->new_bgs); 25214358d963SJosef Bacik trans->delayed_ref_updates++; 25224358d963SJosef Bacik btrfs_update_delayed_refs_rsv(trans); 25234358d963SJosef Bacik 25244358d963SJosef Bacik set_avail_alloc_bits(fs_info, type); 252579bd3712SFilipe Manana return cache; 25264358d963SJosef Bacik } 252726ce2095SJosef Bacik 2528b12de528SQu Wenruo /* 2529b12de528SQu Wenruo * Mark one block group RO, can be called several times for the same block 2530b12de528SQu Wenruo * group. 2531b12de528SQu Wenruo * 2532b12de528SQu Wenruo * @cache: the destination block group 2533b12de528SQu Wenruo * @do_chunk_alloc: whether need to do chunk pre-allocation, this is to 2534b12de528SQu Wenruo * ensure we still have some free space after marking this 2535b12de528SQu Wenruo * block group RO. 2536b12de528SQu Wenruo */ 2537b12de528SQu Wenruo int btrfs_inc_block_group_ro(struct btrfs_block_group *cache, 2538b12de528SQu Wenruo bool do_chunk_alloc) 253926ce2095SJosef Bacik { 254026ce2095SJosef Bacik struct btrfs_fs_info *fs_info = cache->fs_info; 254126ce2095SJosef Bacik struct btrfs_trans_handle *trans; 2542dfe8aec4SJosef Bacik struct btrfs_root *root = btrfs_block_group_root(fs_info); 254326ce2095SJosef Bacik u64 alloc_flags; 254426ce2095SJosef Bacik int ret; 2545b6e9f16cSNikolay Borisov bool dirty_bg_running; 254626ce2095SJosef Bacik 2547b6e9f16cSNikolay Borisov do { 2548dfe8aec4SJosef Bacik trans = btrfs_join_transaction(root); 254926ce2095SJosef Bacik if (IS_ERR(trans)) 255026ce2095SJosef Bacik return PTR_ERR(trans); 255126ce2095SJosef Bacik 2552b6e9f16cSNikolay Borisov dirty_bg_running = false; 2553b6e9f16cSNikolay Borisov 255426ce2095SJosef Bacik /* 2555b6e9f16cSNikolay Borisov * We're not allowed to set block groups readonly after the dirty 2556b6e9f16cSNikolay Borisov * block group cache has started writing. If it already started, 2557b6e9f16cSNikolay Borisov * back off and let this transaction commit. 255826ce2095SJosef Bacik */ 255926ce2095SJosef Bacik mutex_lock(&fs_info->ro_block_group_mutex); 256026ce2095SJosef Bacik if (test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &trans->transaction->flags)) { 256126ce2095SJosef Bacik u64 transid = trans->transid; 256226ce2095SJosef Bacik 256326ce2095SJosef Bacik mutex_unlock(&fs_info->ro_block_group_mutex); 256426ce2095SJosef Bacik btrfs_end_transaction(trans); 256526ce2095SJosef Bacik 256626ce2095SJosef Bacik ret = btrfs_wait_for_commit(fs_info, transid); 256726ce2095SJosef Bacik if (ret) 256826ce2095SJosef Bacik return ret; 2569b6e9f16cSNikolay Borisov dirty_bg_running = true; 257026ce2095SJosef Bacik } 2571b6e9f16cSNikolay Borisov } while (dirty_bg_running); 257226ce2095SJosef Bacik 2573b12de528SQu Wenruo if (do_chunk_alloc) { 257426ce2095SJosef Bacik /* 2575b12de528SQu Wenruo * If we are changing raid levels, try to allocate a 2576b12de528SQu Wenruo * corresponding block group with the new raid level. 257726ce2095SJosef Bacik */ 2578349e120eSJosef Bacik alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags); 257926ce2095SJosef Bacik if (alloc_flags != cache->flags) { 2580b12de528SQu Wenruo ret = btrfs_chunk_alloc(trans, alloc_flags, 2581b12de528SQu Wenruo CHUNK_ALLOC_FORCE); 258226ce2095SJosef Bacik /* 258326ce2095SJosef Bacik * ENOSPC is allowed here, we may have enough space 2584b12de528SQu Wenruo * already allocated at the new raid level to carry on 258526ce2095SJosef Bacik */ 258626ce2095SJosef Bacik if (ret == -ENOSPC) 258726ce2095SJosef Bacik ret = 0; 258826ce2095SJosef Bacik if (ret < 0) 258926ce2095SJosef Bacik goto out; 259026ce2095SJosef Bacik } 2591b12de528SQu Wenruo } 259226ce2095SJosef Bacik 2593a7a63accSJosef Bacik ret = inc_block_group_ro(cache, 0); 2594195a49eaSFilipe Manana if (!do_chunk_alloc || ret == -ETXTBSY) 2595b12de528SQu Wenruo goto unlock_out; 259626ce2095SJosef Bacik if (!ret) 259726ce2095SJosef Bacik goto out; 259826ce2095SJosef Bacik alloc_flags = btrfs_get_alloc_profile(fs_info, cache->space_info->flags); 259926ce2095SJosef Bacik ret = btrfs_chunk_alloc(trans, alloc_flags, CHUNK_ALLOC_FORCE); 260026ce2095SJosef Bacik if (ret < 0) 260126ce2095SJosef Bacik goto out; 2602e11c0406SJosef Bacik ret = inc_block_group_ro(cache, 0); 2603195a49eaSFilipe Manana if (ret == -ETXTBSY) 2604195a49eaSFilipe Manana goto unlock_out; 260526ce2095SJosef Bacik out: 260626ce2095SJosef Bacik if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) { 2607349e120eSJosef Bacik alloc_flags = btrfs_get_alloc_profile(fs_info, cache->flags); 260826ce2095SJosef Bacik mutex_lock(&fs_info->chunk_mutex); 260926ce2095SJosef Bacik check_system_chunk(trans, alloc_flags); 261026ce2095SJosef Bacik mutex_unlock(&fs_info->chunk_mutex); 261126ce2095SJosef Bacik } 2612b12de528SQu Wenruo unlock_out: 261326ce2095SJosef Bacik mutex_unlock(&fs_info->ro_block_group_mutex); 261426ce2095SJosef Bacik 261526ce2095SJosef Bacik btrfs_end_transaction(trans); 261626ce2095SJosef Bacik return ret; 261726ce2095SJosef Bacik } 261826ce2095SJosef Bacik 261932da5386SDavid Sterba void btrfs_dec_block_group_ro(struct btrfs_block_group *cache) 262026ce2095SJosef Bacik { 262126ce2095SJosef Bacik struct btrfs_space_info *sinfo = cache->space_info; 262226ce2095SJosef Bacik u64 num_bytes; 262326ce2095SJosef Bacik 262426ce2095SJosef Bacik BUG_ON(!cache->ro); 262526ce2095SJosef Bacik 262626ce2095SJosef Bacik spin_lock(&sinfo->lock); 262726ce2095SJosef Bacik spin_lock(&cache->lock); 262826ce2095SJosef Bacik if (!--cache->ro) { 2629169e0da9SNaohiro Aota if (btrfs_is_zoned(cache->fs_info)) { 2630169e0da9SNaohiro Aota /* Migrate zone_unusable bytes back */ 263198173255SNaohiro Aota cache->zone_unusable = 263298173255SNaohiro Aota (cache->alloc_offset - cache->used) + 263398173255SNaohiro Aota (cache->length - cache->zone_capacity); 2634169e0da9SNaohiro Aota sinfo->bytes_zone_unusable += cache->zone_unusable; 2635169e0da9SNaohiro Aota sinfo->bytes_readonly -= cache->zone_unusable; 2636169e0da9SNaohiro Aota } 2637f9f28e5bSNaohiro Aota num_bytes = cache->length - cache->reserved - 2638f9f28e5bSNaohiro Aota cache->pinned - cache->bytes_super - 2639f9f28e5bSNaohiro Aota cache->zone_unusable - cache->used; 2640f9f28e5bSNaohiro Aota sinfo->bytes_readonly -= num_bytes; 264126ce2095SJosef Bacik list_del_init(&cache->ro_list); 264226ce2095SJosef Bacik } 264326ce2095SJosef Bacik spin_unlock(&cache->lock); 264426ce2095SJosef Bacik spin_unlock(&sinfo->lock); 264526ce2095SJosef Bacik } 264677745c05SJosef Bacik 26473be4d8efSQu Wenruo static int update_block_group_item(struct btrfs_trans_handle *trans, 264877745c05SJosef Bacik struct btrfs_path *path, 264932da5386SDavid Sterba struct btrfs_block_group *cache) 265077745c05SJosef Bacik { 265177745c05SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 265277745c05SJosef Bacik int ret; 2653dfe8aec4SJosef Bacik struct btrfs_root *root = btrfs_block_group_root(fs_info); 265477745c05SJosef Bacik unsigned long bi; 265577745c05SJosef Bacik struct extent_buffer *leaf; 2656bf38be65SDavid Sterba struct btrfs_block_group_item bgi; 2657b3470b5dSDavid Sterba struct btrfs_key key; 265877745c05SJosef Bacik 2659b3470b5dSDavid Sterba key.objectid = cache->start; 2660b3470b5dSDavid Sterba key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; 2661b3470b5dSDavid Sterba key.offset = cache->length; 2662b3470b5dSDavid Sterba 26633be4d8efSQu Wenruo ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 266477745c05SJosef Bacik if (ret) { 266577745c05SJosef Bacik if (ret > 0) 266677745c05SJosef Bacik ret = -ENOENT; 266777745c05SJosef Bacik goto fail; 266877745c05SJosef Bacik } 266977745c05SJosef Bacik 267077745c05SJosef Bacik leaf = path->nodes[0]; 267177745c05SJosef Bacik bi = btrfs_item_ptr_offset(leaf, path->slots[0]); 2672de0dc456SDavid Sterba btrfs_set_stack_block_group_used(&bgi, cache->used); 2673de0dc456SDavid Sterba btrfs_set_stack_block_group_chunk_objectid(&bgi, 26743d976388SDavid Sterba BTRFS_FIRST_CHUNK_TREE_OBJECTID); 2675de0dc456SDavid Sterba btrfs_set_stack_block_group_flags(&bgi, cache->flags); 2676bf38be65SDavid Sterba write_extent_buffer(leaf, &bgi, bi, sizeof(bgi)); 267777745c05SJosef Bacik btrfs_mark_buffer_dirty(leaf); 267877745c05SJosef Bacik fail: 267977745c05SJosef Bacik btrfs_release_path(path); 268077745c05SJosef Bacik return ret; 268177745c05SJosef Bacik 268277745c05SJosef Bacik } 268377745c05SJosef Bacik 268432da5386SDavid Sterba static int cache_save_setup(struct btrfs_block_group *block_group, 268577745c05SJosef Bacik struct btrfs_trans_handle *trans, 268677745c05SJosef Bacik struct btrfs_path *path) 268777745c05SJosef Bacik { 268877745c05SJosef Bacik struct btrfs_fs_info *fs_info = block_group->fs_info; 268977745c05SJosef Bacik struct btrfs_root *root = fs_info->tree_root; 269077745c05SJosef Bacik struct inode *inode = NULL; 269177745c05SJosef Bacik struct extent_changeset *data_reserved = NULL; 269277745c05SJosef Bacik u64 alloc_hint = 0; 269377745c05SJosef Bacik int dcs = BTRFS_DC_ERROR; 26940044ae11SQu Wenruo u64 cache_size = 0; 269577745c05SJosef Bacik int retries = 0; 269677745c05SJosef Bacik int ret = 0; 269777745c05SJosef Bacik 2698af456a2cSBoris Burkov if (!btrfs_test_opt(fs_info, SPACE_CACHE)) 2699af456a2cSBoris Burkov return 0; 2700af456a2cSBoris Burkov 270177745c05SJosef Bacik /* 270277745c05SJosef Bacik * If this block group is smaller than 100 megs don't bother caching the 270377745c05SJosef Bacik * block group. 270477745c05SJosef Bacik */ 2705b3470b5dSDavid Sterba if (block_group->length < (100 * SZ_1M)) { 270677745c05SJosef Bacik spin_lock(&block_group->lock); 270777745c05SJosef Bacik block_group->disk_cache_state = BTRFS_DC_WRITTEN; 270877745c05SJosef Bacik spin_unlock(&block_group->lock); 270977745c05SJosef Bacik return 0; 271077745c05SJosef Bacik } 271177745c05SJosef Bacik 2712bf31f87fSDavid Sterba if (TRANS_ABORTED(trans)) 271377745c05SJosef Bacik return 0; 271477745c05SJosef Bacik again: 271577745c05SJosef Bacik inode = lookup_free_space_inode(block_group, path); 271677745c05SJosef Bacik if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) { 271777745c05SJosef Bacik ret = PTR_ERR(inode); 271877745c05SJosef Bacik btrfs_release_path(path); 271977745c05SJosef Bacik goto out; 272077745c05SJosef Bacik } 272177745c05SJosef Bacik 272277745c05SJosef Bacik if (IS_ERR(inode)) { 272377745c05SJosef Bacik BUG_ON(retries); 272477745c05SJosef Bacik retries++; 272577745c05SJosef Bacik 272677745c05SJosef Bacik if (block_group->ro) 272777745c05SJosef Bacik goto out_free; 272877745c05SJosef Bacik 272977745c05SJosef Bacik ret = create_free_space_inode(trans, block_group, path); 273077745c05SJosef Bacik if (ret) 273177745c05SJosef Bacik goto out_free; 273277745c05SJosef Bacik goto again; 273377745c05SJosef Bacik } 273477745c05SJosef Bacik 273577745c05SJosef Bacik /* 273677745c05SJosef Bacik * We want to set the generation to 0, that way if anything goes wrong 273777745c05SJosef Bacik * from here on out we know not to trust this cache when we load up next 273877745c05SJosef Bacik * time. 273977745c05SJosef Bacik */ 274077745c05SJosef Bacik BTRFS_I(inode)->generation = 0; 27419a56fcd1SNikolay Borisov ret = btrfs_update_inode(trans, root, BTRFS_I(inode)); 274277745c05SJosef Bacik if (ret) { 274377745c05SJosef Bacik /* 274477745c05SJosef Bacik * So theoretically we could recover from this, simply set the 274577745c05SJosef Bacik * super cache generation to 0 so we know to invalidate the 274677745c05SJosef Bacik * cache, but then we'd have to keep track of the block groups 274777745c05SJosef Bacik * that fail this way so we know we _have_ to reset this cache 274877745c05SJosef Bacik * before the next commit or risk reading stale cache. So to 274977745c05SJosef Bacik * limit our exposure to horrible edge cases lets just abort the 275077745c05SJosef Bacik * transaction, this only happens in really bad situations 275177745c05SJosef Bacik * anyway. 275277745c05SJosef Bacik */ 275377745c05SJosef Bacik btrfs_abort_transaction(trans, ret); 275477745c05SJosef Bacik goto out_put; 275577745c05SJosef Bacik } 275677745c05SJosef Bacik WARN_ON(ret); 275777745c05SJosef Bacik 275877745c05SJosef Bacik /* We've already setup this transaction, go ahead and exit */ 275977745c05SJosef Bacik if (block_group->cache_generation == trans->transid && 276077745c05SJosef Bacik i_size_read(inode)) { 276177745c05SJosef Bacik dcs = BTRFS_DC_SETUP; 276277745c05SJosef Bacik goto out_put; 276377745c05SJosef Bacik } 276477745c05SJosef Bacik 276577745c05SJosef Bacik if (i_size_read(inode) > 0) { 276677745c05SJosef Bacik ret = btrfs_check_trunc_cache_free_space(fs_info, 276777745c05SJosef Bacik &fs_info->global_block_rsv); 276877745c05SJosef Bacik if (ret) 276977745c05SJosef Bacik goto out_put; 277077745c05SJosef Bacik 277177745c05SJosef Bacik ret = btrfs_truncate_free_space_cache(trans, NULL, inode); 277277745c05SJosef Bacik if (ret) 277377745c05SJosef Bacik goto out_put; 277477745c05SJosef Bacik } 277577745c05SJosef Bacik 277677745c05SJosef Bacik spin_lock(&block_group->lock); 277777745c05SJosef Bacik if (block_group->cached != BTRFS_CACHE_FINISHED || 277877745c05SJosef Bacik !btrfs_test_opt(fs_info, SPACE_CACHE)) { 277977745c05SJosef Bacik /* 278077745c05SJosef Bacik * don't bother trying to write stuff out _if_ 278177745c05SJosef Bacik * a) we're not cached, 278277745c05SJosef Bacik * b) we're with nospace_cache mount option, 278377745c05SJosef Bacik * c) we're with v2 space_cache (FREE_SPACE_TREE). 278477745c05SJosef Bacik */ 278577745c05SJosef Bacik dcs = BTRFS_DC_WRITTEN; 278677745c05SJosef Bacik spin_unlock(&block_group->lock); 278777745c05SJosef Bacik goto out_put; 278877745c05SJosef Bacik } 278977745c05SJosef Bacik spin_unlock(&block_group->lock); 279077745c05SJosef Bacik 279177745c05SJosef Bacik /* 279277745c05SJosef Bacik * We hit an ENOSPC when setting up the cache in this transaction, just 279377745c05SJosef Bacik * skip doing the setup, we've already cleared the cache so we're safe. 279477745c05SJosef Bacik */ 279577745c05SJosef Bacik if (test_bit(BTRFS_TRANS_CACHE_ENOSPC, &trans->transaction->flags)) { 279677745c05SJosef Bacik ret = -ENOSPC; 279777745c05SJosef Bacik goto out_put; 279877745c05SJosef Bacik } 279977745c05SJosef Bacik 280077745c05SJosef Bacik /* 280177745c05SJosef Bacik * Try to preallocate enough space based on how big the block group is. 280277745c05SJosef Bacik * Keep in mind this has to include any pinned space which could end up 280377745c05SJosef Bacik * taking up quite a bit since it's not folded into the other space 280477745c05SJosef Bacik * cache. 280577745c05SJosef Bacik */ 28060044ae11SQu Wenruo cache_size = div_u64(block_group->length, SZ_256M); 28070044ae11SQu Wenruo if (!cache_size) 28080044ae11SQu Wenruo cache_size = 1; 280977745c05SJosef Bacik 28100044ae11SQu Wenruo cache_size *= 16; 28110044ae11SQu Wenruo cache_size *= fs_info->sectorsize; 281277745c05SJosef Bacik 281336ea6f3eSNikolay Borisov ret = btrfs_check_data_free_space(BTRFS_I(inode), &data_reserved, 0, 28140044ae11SQu Wenruo cache_size); 281577745c05SJosef Bacik if (ret) 281677745c05SJosef Bacik goto out_put; 281777745c05SJosef Bacik 28180044ae11SQu Wenruo ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, cache_size, 28190044ae11SQu Wenruo cache_size, cache_size, 282077745c05SJosef Bacik &alloc_hint); 282177745c05SJosef Bacik /* 282277745c05SJosef Bacik * Our cache requires contiguous chunks so that we don't modify a bunch 282377745c05SJosef Bacik * of metadata or split extents when writing the cache out, which means 282477745c05SJosef Bacik * we can enospc if we are heavily fragmented in addition to just normal 282577745c05SJosef Bacik * out of space conditions. So if we hit this just skip setting up any 282677745c05SJosef Bacik * other block groups for this transaction, maybe we'll unpin enough 282777745c05SJosef Bacik * space the next time around. 282877745c05SJosef Bacik */ 282977745c05SJosef Bacik if (!ret) 283077745c05SJosef Bacik dcs = BTRFS_DC_SETUP; 283177745c05SJosef Bacik else if (ret == -ENOSPC) 283277745c05SJosef Bacik set_bit(BTRFS_TRANS_CACHE_ENOSPC, &trans->transaction->flags); 283377745c05SJosef Bacik 283477745c05SJosef Bacik out_put: 283577745c05SJosef Bacik iput(inode); 283677745c05SJosef Bacik out_free: 283777745c05SJosef Bacik btrfs_release_path(path); 283877745c05SJosef Bacik out: 283977745c05SJosef Bacik spin_lock(&block_group->lock); 284077745c05SJosef Bacik if (!ret && dcs == BTRFS_DC_SETUP) 284177745c05SJosef Bacik block_group->cache_generation = trans->transid; 284277745c05SJosef Bacik block_group->disk_cache_state = dcs; 284377745c05SJosef Bacik spin_unlock(&block_group->lock); 284477745c05SJosef Bacik 284577745c05SJosef Bacik extent_changeset_free(data_reserved); 284677745c05SJosef Bacik return ret; 284777745c05SJosef Bacik } 284877745c05SJosef Bacik 284977745c05SJosef Bacik int btrfs_setup_space_cache(struct btrfs_trans_handle *trans) 285077745c05SJosef Bacik { 285177745c05SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 285232da5386SDavid Sterba struct btrfs_block_group *cache, *tmp; 285377745c05SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 285477745c05SJosef Bacik struct btrfs_path *path; 285577745c05SJosef Bacik 285677745c05SJosef Bacik if (list_empty(&cur_trans->dirty_bgs) || 285777745c05SJosef Bacik !btrfs_test_opt(fs_info, SPACE_CACHE)) 285877745c05SJosef Bacik return 0; 285977745c05SJosef Bacik 286077745c05SJosef Bacik path = btrfs_alloc_path(); 286177745c05SJosef Bacik if (!path) 286277745c05SJosef Bacik return -ENOMEM; 286377745c05SJosef Bacik 286477745c05SJosef Bacik /* Could add new block groups, use _safe just in case */ 286577745c05SJosef Bacik list_for_each_entry_safe(cache, tmp, &cur_trans->dirty_bgs, 286677745c05SJosef Bacik dirty_list) { 286777745c05SJosef Bacik if (cache->disk_cache_state == BTRFS_DC_CLEAR) 286877745c05SJosef Bacik cache_save_setup(cache, trans, path); 286977745c05SJosef Bacik } 287077745c05SJosef Bacik 287177745c05SJosef Bacik btrfs_free_path(path); 287277745c05SJosef Bacik return 0; 287377745c05SJosef Bacik } 287477745c05SJosef Bacik 287577745c05SJosef Bacik /* 287677745c05SJosef Bacik * Transaction commit does final block group cache writeback during a critical 287777745c05SJosef Bacik * section where nothing is allowed to change the FS. This is required in 287877745c05SJosef Bacik * order for the cache to actually match the block group, but can introduce a 287977745c05SJosef Bacik * lot of latency into the commit. 288077745c05SJosef Bacik * 288177745c05SJosef Bacik * So, btrfs_start_dirty_block_groups is here to kick off block group cache IO. 288277745c05SJosef Bacik * There's a chance we'll have to redo some of it if the block group changes 288377745c05SJosef Bacik * again during the commit, but it greatly reduces the commit latency by 288477745c05SJosef Bacik * getting rid of the easy block groups while we're still allowing others to 288577745c05SJosef Bacik * join the commit. 288677745c05SJosef Bacik */ 288777745c05SJosef Bacik int btrfs_start_dirty_block_groups(struct btrfs_trans_handle *trans) 288877745c05SJosef Bacik { 288977745c05SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 289032da5386SDavid Sterba struct btrfs_block_group *cache; 289177745c05SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 289277745c05SJosef Bacik int ret = 0; 289377745c05SJosef Bacik int should_put; 289477745c05SJosef Bacik struct btrfs_path *path = NULL; 289577745c05SJosef Bacik LIST_HEAD(dirty); 289677745c05SJosef Bacik struct list_head *io = &cur_trans->io_bgs; 289777745c05SJosef Bacik int num_started = 0; 289877745c05SJosef Bacik int loops = 0; 289977745c05SJosef Bacik 290077745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 290177745c05SJosef Bacik if (list_empty(&cur_trans->dirty_bgs)) { 290277745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 290377745c05SJosef Bacik return 0; 290477745c05SJosef Bacik } 290577745c05SJosef Bacik list_splice_init(&cur_trans->dirty_bgs, &dirty); 290677745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 290777745c05SJosef Bacik 290877745c05SJosef Bacik again: 290977745c05SJosef Bacik /* Make sure all the block groups on our dirty list actually exist */ 291077745c05SJosef Bacik btrfs_create_pending_block_groups(trans); 291177745c05SJosef Bacik 291277745c05SJosef Bacik if (!path) { 291377745c05SJosef Bacik path = btrfs_alloc_path(); 2914938fcbfbSJosef Bacik if (!path) { 2915938fcbfbSJosef Bacik ret = -ENOMEM; 2916938fcbfbSJosef Bacik goto out; 2917938fcbfbSJosef Bacik } 291877745c05SJosef Bacik } 291977745c05SJosef Bacik 292077745c05SJosef Bacik /* 292177745c05SJosef Bacik * cache_write_mutex is here only to save us from balance or automatic 292277745c05SJosef Bacik * removal of empty block groups deleting this block group while we are 292377745c05SJosef Bacik * writing out the cache 292477745c05SJosef Bacik */ 292577745c05SJosef Bacik mutex_lock(&trans->transaction->cache_write_mutex); 292677745c05SJosef Bacik while (!list_empty(&dirty)) { 292777745c05SJosef Bacik bool drop_reserve = true; 292877745c05SJosef Bacik 292932da5386SDavid Sterba cache = list_first_entry(&dirty, struct btrfs_block_group, 293077745c05SJosef Bacik dirty_list); 293177745c05SJosef Bacik /* 293277745c05SJosef Bacik * This can happen if something re-dirties a block group that 293377745c05SJosef Bacik * is already under IO. Just wait for it to finish and then do 293477745c05SJosef Bacik * it all again 293577745c05SJosef Bacik */ 293677745c05SJosef Bacik if (!list_empty(&cache->io_list)) { 293777745c05SJosef Bacik list_del_init(&cache->io_list); 293877745c05SJosef Bacik btrfs_wait_cache_io(trans, cache, path); 293977745c05SJosef Bacik btrfs_put_block_group(cache); 294077745c05SJosef Bacik } 294177745c05SJosef Bacik 294277745c05SJosef Bacik 294377745c05SJosef Bacik /* 294477745c05SJosef Bacik * btrfs_wait_cache_io uses the cache->dirty_list to decide if 294577745c05SJosef Bacik * it should update the cache_state. Don't delete until after 294677745c05SJosef Bacik * we wait. 294777745c05SJosef Bacik * 294877745c05SJosef Bacik * Since we're not running in the commit critical section 294977745c05SJosef Bacik * we need the dirty_bgs_lock to protect from update_block_group 295077745c05SJosef Bacik */ 295177745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 295277745c05SJosef Bacik list_del_init(&cache->dirty_list); 295377745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 295477745c05SJosef Bacik 295577745c05SJosef Bacik should_put = 1; 295677745c05SJosef Bacik 295777745c05SJosef Bacik cache_save_setup(cache, trans, path); 295877745c05SJosef Bacik 295977745c05SJosef Bacik if (cache->disk_cache_state == BTRFS_DC_SETUP) { 296077745c05SJosef Bacik cache->io_ctl.inode = NULL; 296177745c05SJosef Bacik ret = btrfs_write_out_cache(trans, cache, path); 296277745c05SJosef Bacik if (ret == 0 && cache->io_ctl.inode) { 296377745c05SJosef Bacik num_started++; 296477745c05SJosef Bacik should_put = 0; 296577745c05SJosef Bacik 296677745c05SJosef Bacik /* 296777745c05SJosef Bacik * The cache_write_mutex is protecting the 296877745c05SJosef Bacik * io_list, also refer to the definition of 296977745c05SJosef Bacik * btrfs_transaction::io_bgs for more details 297077745c05SJosef Bacik */ 297177745c05SJosef Bacik list_add_tail(&cache->io_list, io); 297277745c05SJosef Bacik } else { 297377745c05SJosef Bacik /* 297477745c05SJosef Bacik * If we failed to write the cache, the 297577745c05SJosef Bacik * generation will be bad and life goes on 297677745c05SJosef Bacik */ 297777745c05SJosef Bacik ret = 0; 297877745c05SJosef Bacik } 297977745c05SJosef Bacik } 298077745c05SJosef Bacik if (!ret) { 29813be4d8efSQu Wenruo ret = update_block_group_item(trans, path, cache); 298277745c05SJosef Bacik /* 298377745c05SJosef Bacik * Our block group might still be attached to the list 298477745c05SJosef Bacik * of new block groups in the transaction handle of some 298577745c05SJosef Bacik * other task (struct btrfs_trans_handle->new_bgs). This 298677745c05SJosef Bacik * means its block group item isn't yet in the extent 298777745c05SJosef Bacik * tree. If this happens ignore the error, as we will 298877745c05SJosef Bacik * try again later in the critical section of the 298977745c05SJosef Bacik * transaction commit. 299077745c05SJosef Bacik */ 299177745c05SJosef Bacik if (ret == -ENOENT) { 299277745c05SJosef Bacik ret = 0; 299377745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 299477745c05SJosef Bacik if (list_empty(&cache->dirty_list)) { 299577745c05SJosef Bacik list_add_tail(&cache->dirty_list, 299677745c05SJosef Bacik &cur_trans->dirty_bgs); 299777745c05SJosef Bacik btrfs_get_block_group(cache); 299877745c05SJosef Bacik drop_reserve = false; 299977745c05SJosef Bacik } 300077745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 300177745c05SJosef Bacik } else if (ret) { 300277745c05SJosef Bacik btrfs_abort_transaction(trans, ret); 300377745c05SJosef Bacik } 300477745c05SJosef Bacik } 300577745c05SJosef Bacik 300677745c05SJosef Bacik /* If it's not on the io list, we need to put the block group */ 300777745c05SJosef Bacik if (should_put) 300877745c05SJosef Bacik btrfs_put_block_group(cache); 300977745c05SJosef Bacik if (drop_reserve) 301077745c05SJosef Bacik btrfs_delayed_refs_rsv_release(fs_info, 1); 301177745c05SJosef Bacik /* 301277745c05SJosef Bacik * Avoid blocking other tasks for too long. It might even save 301377745c05SJosef Bacik * us from writing caches for block groups that are going to be 301477745c05SJosef Bacik * removed. 301577745c05SJosef Bacik */ 301677745c05SJosef Bacik mutex_unlock(&trans->transaction->cache_write_mutex); 3017938fcbfbSJosef Bacik if (ret) 3018938fcbfbSJosef Bacik goto out; 301977745c05SJosef Bacik mutex_lock(&trans->transaction->cache_write_mutex); 302077745c05SJosef Bacik } 302177745c05SJosef Bacik mutex_unlock(&trans->transaction->cache_write_mutex); 302277745c05SJosef Bacik 302377745c05SJosef Bacik /* 302477745c05SJosef Bacik * Go through delayed refs for all the stuff we've just kicked off 302577745c05SJosef Bacik * and then loop back (just once) 302677745c05SJosef Bacik */ 302734d1eb0eSJosef Bacik if (!ret) 302877745c05SJosef Bacik ret = btrfs_run_delayed_refs(trans, 0); 302977745c05SJosef Bacik if (!ret && loops == 0) { 303077745c05SJosef Bacik loops++; 303177745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 303277745c05SJosef Bacik list_splice_init(&cur_trans->dirty_bgs, &dirty); 303377745c05SJosef Bacik /* 303477745c05SJosef Bacik * dirty_bgs_lock protects us from concurrent block group 303577745c05SJosef Bacik * deletes too (not just cache_write_mutex). 303677745c05SJosef Bacik */ 303777745c05SJosef Bacik if (!list_empty(&dirty)) { 303877745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 303977745c05SJosef Bacik goto again; 304077745c05SJosef Bacik } 304177745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 3042938fcbfbSJosef Bacik } 3043938fcbfbSJosef Bacik out: 3044938fcbfbSJosef Bacik if (ret < 0) { 3045938fcbfbSJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 3046938fcbfbSJosef Bacik list_splice_init(&dirty, &cur_trans->dirty_bgs); 3047938fcbfbSJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 304877745c05SJosef Bacik btrfs_cleanup_dirty_bgs(cur_trans, fs_info); 304977745c05SJosef Bacik } 305077745c05SJosef Bacik 305177745c05SJosef Bacik btrfs_free_path(path); 305277745c05SJosef Bacik return ret; 305377745c05SJosef Bacik } 305477745c05SJosef Bacik 305577745c05SJosef Bacik int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans) 305677745c05SJosef Bacik { 305777745c05SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 305832da5386SDavid Sterba struct btrfs_block_group *cache; 305977745c05SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 306077745c05SJosef Bacik int ret = 0; 306177745c05SJosef Bacik int should_put; 306277745c05SJosef Bacik struct btrfs_path *path; 306377745c05SJosef Bacik struct list_head *io = &cur_trans->io_bgs; 306477745c05SJosef Bacik int num_started = 0; 306577745c05SJosef Bacik 306677745c05SJosef Bacik path = btrfs_alloc_path(); 306777745c05SJosef Bacik if (!path) 306877745c05SJosef Bacik return -ENOMEM; 306977745c05SJosef Bacik 307077745c05SJosef Bacik /* 307177745c05SJosef Bacik * Even though we are in the critical section of the transaction commit, 307277745c05SJosef Bacik * we can still have concurrent tasks adding elements to this 307377745c05SJosef Bacik * transaction's list of dirty block groups. These tasks correspond to 307477745c05SJosef Bacik * endio free space workers started when writeback finishes for a 307577745c05SJosef Bacik * space cache, which run inode.c:btrfs_finish_ordered_io(), and can 307677745c05SJosef Bacik * allocate new block groups as a result of COWing nodes of the root 307777745c05SJosef Bacik * tree when updating the free space inode. The writeback for the space 307877745c05SJosef Bacik * caches is triggered by an earlier call to 307977745c05SJosef Bacik * btrfs_start_dirty_block_groups() and iterations of the following 308077745c05SJosef Bacik * loop. 308177745c05SJosef Bacik * Also we want to do the cache_save_setup first and then run the 308277745c05SJosef Bacik * delayed refs to make sure we have the best chance at doing this all 308377745c05SJosef Bacik * in one shot. 308477745c05SJosef Bacik */ 308577745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 308677745c05SJosef Bacik while (!list_empty(&cur_trans->dirty_bgs)) { 308777745c05SJosef Bacik cache = list_first_entry(&cur_trans->dirty_bgs, 308832da5386SDavid Sterba struct btrfs_block_group, 308977745c05SJosef Bacik dirty_list); 309077745c05SJosef Bacik 309177745c05SJosef Bacik /* 309277745c05SJosef Bacik * This can happen if cache_save_setup re-dirties a block group 309377745c05SJosef Bacik * that is already under IO. Just wait for it to finish and 309477745c05SJosef Bacik * then do it all again 309577745c05SJosef Bacik */ 309677745c05SJosef Bacik if (!list_empty(&cache->io_list)) { 309777745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 309877745c05SJosef Bacik list_del_init(&cache->io_list); 309977745c05SJosef Bacik btrfs_wait_cache_io(trans, cache, path); 310077745c05SJosef Bacik btrfs_put_block_group(cache); 310177745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 310277745c05SJosef Bacik } 310377745c05SJosef Bacik 310477745c05SJosef Bacik /* 310577745c05SJosef Bacik * Don't remove from the dirty list until after we've waited on 310677745c05SJosef Bacik * any pending IO 310777745c05SJosef Bacik */ 310877745c05SJosef Bacik list_del_init(&cache->dirty_list); 310977745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 311077745c05SJosef Bacik should_put = 1; 311177745c05SJosef Bacik 311277745c05SJosef Bacik cache_save_setup(cache, trans, path); 311377745c05SJosef Bacik 311477745c05SJosef Bacik if (!ret) 311577745c05SJosef Bacik ret = btrfs_run_delayed_refs(trans, 311677745c05SJosef Bacik (unsigned long) -1); 311777745c05SJosef Bacik 311877745c05SJosef Bacik if (!ret && cache->disk_cache_state == BTRFS_DC_SETUP) { 311977745c05SJosef Bacik cache->io_ctl.inode = NULL; 312077745c05SJosef Bacik ret = btrfs_write_out_cache(trans, cache, path); 312177745c05SJosef Bacik if (ret == 0 && cache->io_ctl.inode) { 312277745c05SJosef Bacik num_started++; 312377745c05SJosef Bacik should_put = 0; 312477745c05SJosef Bacik list_add_tail(&cache->io_list, io); 312577745c05SJosef Bacik } else { 312677745c05SJosef Bacik /* 312777745c05SJosef Bacik * If we failed to write the cache, the 312877745c05SJosef Bacik * generation will be bad and life goes on 312977745c05SJosef Bacik */ 313077745c05SJosef Bacik ret = 0; 313177745c05SJosef Bacik } 313277745c05SJosef Bacik } 313377745c05SJosef Bacik if (!ret) { 31343be4d8efSQu Wenruo ret = update_block_group_item(trans, path, cache); 313577745c05SJosef Bacik /* 313677745c05SJosef Bacik * One of the free space endio workers might have 313777745c05SJosef Bacik * created a new block group while updating a free space 313877745c05SJosef Bacik * cache's inode (at inode.c:btrfs_finish_ordered_io()) 313977745c05SJosef Bacik * and hasn't released its transaction handle yet, in 314077745c05SJosef Bacik * which case the new block group is still attached to 314177745c05SJosef Bacik * its transaction handle and its creation has not 314277745c05SJosef Bacik * finished yet (no block group item in the extent tree 314377745c05SJosef Bacik * yet, etc). If this is the case, wait for all free 314477745c05SJosef Bacik * space endio workers to finish and retry. This is a 3145260db43cSRandy Dunlap * very rare case so no need for a more efficient and 314677745c05SJosef Bacik * complex approach. 314777745c05SJosef Bacik */ 314877745c05SJosef Bacik if (ret == -ENOENT) { 314977745c05SJosef Bacik wait_event(cur_trans->writer_wait, 315077745c05SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 31513be4d8efSQu Wenruo ret = update_block_group_item(trans, path, cache); 315277745c05SJosef Bacik } 315377745c05SJosef Bacik if (ret) 315477745c05SJosef Bacik btrfs_abort_transaction(trans, ret); 315577745c05SJosef Bacik } 315677745c05SJosef Bacik 315777745c05SJosef Bacik /* If its not on the io list, we need to put the block group */ 315877745c05SJosef Bacik if (should_put) 315977745c05SJosef Bacik btrfs_put_block_group(cache); 316077745c05SJosef Bacik btrfs_delayed_refs_rsv_release(fs_info, 1); 316177745c05SJosef Bacik spin_lock(&cur_trans->dirty_bgs_lock); 316277745c05SJosef Bacik } 316377745c05SJosef Bacik spin_unlock(&cur_trans->dirty_bgs_lock); 316477745c05SJosef Bacik 316577745c05SJosef Bacik /* 316677745c05SJosef Bacik * Refer to the definition of io_bgs member for details why it's safe 316777745c05SJosef Bacik * to use it without any locking 316877745c05SJosef Bacik */ 316977745c05SJosef Bacik while (!list_empty(io)) { 317032da5386SDavid Sterba cache = list_first_entry(io, struct btrfs_block_group, 317177745c05SJosef Bacik io_list); 317277745c05SJosef Bacik list_del_init(&cache->io_list); 317377745c05SJosef Bacik btrfs_wait_cache_io(trans, cache, path); 317477745c05SJosef Bacik btrfs_put_block_group(cache); 317577745c05SJosef Bacik } 317677745c05SJosef Bacik 317777745c05SJosef Bacik btrfs_free_path(path); 317877745c05SJosef Bacik return ret; 317977745c05SJosef Bacik } 3180606d1bf1SJosef Bacik 3181606d1bf1SJosef Bacik int btrfs_update_block_group(struct btrfs_trans_handle *trans, 318211b66fa6SAnand Jain u64 bytenr, u64 num_bytes, bool alloc) 3183606d1bf1SJosef Bacik { 3184606d1bf1SJosef Bacik struct btrfs_fs_info *info = trans->fs_info; 318532da5386SDavid Sterba struct btrfs_block_group *cache = NULL; 3186606d1bf1SJosef Bacik u64 total = num_bytes; 3187606d1bf1SJosef Bacik u64 old_val; 3188606d1bf1SJosef Bacik u64 byte_in_group; 3189606d1bf1SJosef Bacik int factor; 3190606d1bf1SJosef Bacik int ret = 0; 3191606d1bf1SJosef Bacik 3192606d1bf1SJosef Bacik /* Block accounting for super block */ 3193606d1bf1SJosef Bacik spin_lock(&info->delalloc_root_lock); 3194606d1bf1SJosef Bacik old_val = btrfs_super_bytes_used(info->super_copy); 3195606d1bf1SJosef Bacik if (alloc) 3196606d1bf1SJosef Bacik old_val += num_bytes; 3197606d1bf1SJosef Bacik else 3198606d1bf1SJosef Bacik old_val -= num_bytes; 3199606d1bf1SJosef Bacik btrfs_set_super_bytes_used(info->super_copy, old_val); 3200606d1bf1SJosef Bacik spin_unlock(&info->delalloc_root_lock); 3201606d1bf1SJosef Bacik 3202606d1bf1SJosef Bacik while (total) { 3203606d1bf1SJosef Bacik cache = btrfs_lookup_block_group(info, bytenr); 3204606d1bf1SJosef Bacik if (!cache) { 3205606d1bf1SJosef Bacik ret = -ENOENT; 3206606d1bf1SJosef Bacik break; 3207606d1bf1SJosef Bacik } 3208606d1bf1SJosef Bacik factor = btrfs_bg_type_to_factor(cache->flags); 3209606d1bf1SJosef Bacik 3210606d1bf1SJosef Bacik /* 3211606d1bf1SJosef Bacik * If this block group has free space cache written out, we 3212606d1bf1SJosef Bacik * need to make sure to load it if we are removing space. This 3213606d1bf1SJosef Bacik * is because we need the unpinning stage to actually add the 3214606d1bf1SJosef Bacik * space back to the block group, otherwise we will leak space. 3215606d1bf1SJosef Bacik */ 321632da5386SDavid Sterba if (!alloc && !btrfs_block_group_done(cache)) 3217606d1bf1SJosef Bacik btrfs_cache_block_group(cache, 1); 3218606d1bf1SJosef Bacik 3219b3470b5dSDavid Sterba byte_in_group = bytenr - cache->start; 3220b3470b5dSDavid Sterba WARN_ON(byte_in_group > cache->length); 3221606d1bf1SJosef Bacik 3222606d1bf1SJosef Bacik spin_lock(&cache->space_info->lock); 3223606d1bf1SJosef Bacik spin_lock(&cache->lock); 3224606d1bf1SJosef Bacik 3225606d1bf1SJosef Bacik if (btrfs_test_opt(info, SPACE_CACHE) && 3226606d1bf1SJosef Bacik cache->disk_cache_state < BTRFS_DC_CLEAR) 3227606d1bf1SJosef Bacik cache->disk_cache_state = BTRFS_DC_CLEAR; 3228606d1bf1SJosef Bacik 3229bf38be65SDavid Sterba old_val = cache->used; 3230b3470b5dSDavid Sterba num_bytes = min(total, cache->length - byte_in_group); 3231606d1bf1SJosef Bacik if (alloc) { 3232606d1bf1SJosef Bacik old_val += num_bytes; 3233bf38be65SDavid Sterba cache->used = old_val; 3234606d1bf1SJosef Bacik cache->reserved -= num_bytes; 3235606d1bf1SJosef Bacik cache->space_info->bytes_reserved -= num_bytes; 3236606d1bf1SJosef Bacik cache->space_info->bytes_used += num_bytes; 3237606d1bf1SJosef Bacik cache->space_info->disk_used += num_bytes * factor; 3238606d1bf1SJosef Bacik spin_unlock(&cache->lock); 3239606d1bf1SJosef Bacik spin_unlock(&cache->space_info->lock); 3240606d1bf1SJosef Bacik } else { 3241606d1bf1SJosef Bacik old_val -= num_bytes; 3242bf38be65SDavid Sterba cache->used = old_val; 3243606d1bf1SJosef Bacik cache->pinned += num_bytes; 3244606d1bf1SJosef Bacik btrfs_space_info_update_bytes_pinned(info, 3245606d1bf1SJosef Bacik cache->space_info, num_bytes); 3246606d1bf1SJosef Bacik cache->space_info->bytes_used -= num_bytes; 3247606d1bf1SJosef Bacik cache->space_info->disk_used -= num_bytes * factor; 3248606d1bf1SJosef Bacik spin_unlock(&cache->lock); 3249606d1bf1SJosef Bacik spin_unlock(&cache->space_info->lock); 3250606d1bf1SJosef Bacik 3251fe119a6eSNikolay Borisov set_extent_dirty(&trans->transaction->pinned_extents, 3252606d1bf1SJosef Bacik bytenr, bytenr + num_bytes - 1, 3253606d1bf1SJosef Bacik GFP_NOFS | __GFP_NOFAIL); 3254606d1bf1SJosef Bacik } 3255606d1bf1SJosef Bacik 3256606d1bf1SJosef Bacik spin_lock(&trans->transaction->dirty_bgs_lock); 3257606d1bf1SJosef Bacik if (list_empty(&cache->dirty_list)) { 3258606d1bf1SJosef Bacik list_add_tail(&cache->dirty_list, 3259606d1bf1SJosef Bacik &trans->transaction->dirty_bgs); 3260606d1bf1SJosef Bacik trans->delayed_ref_updates++; 3261606d1bf1SJosef Bacik btrfs_get_block_group(cache); 3262606d1bf1SJosef Bacik } 3263606d1bf1SJosef Bacik spin_unlock(&trans->transaction->dirty_bgs_lock); 3264606d1bf1SJosef Bacik 3265606d1bf1SJosef Bacik /* 3266606d1bf1SJosef Bacik * No longer have used bytes in this block group, queue it for 3267606d1bf1SJosef Bacik * deletion. We do this after adding the block group to the 3268606d1bf1SJosef Bacik * dirty list to avoid races between cleaner kthread and space 3269606d1bf1SJosef Bacik * cache writeout. 3270606d1bf1SJosef Bacik */ 32716e80d4f8SDennis Zhou if (!alloc && old_val == 0) { 32726e80d4f8SDennis Zhou if (!btrfs_test_opt(info, DISCARD_ASYNC)) 3273606d1bf1SJosef Bacik btrfs_mark_bg_unused(cache); 32746e80d4f8SDennis Zhou } 3275606d1bf1SJosef Bacik 3276606d1bf1SJosef Bacik btrfs_put_block_group(cache); 3277606d1bf1SJosef Bacik total -= num_bytes; 3278606d1bf1SJosef Bacik bytenr += num_bytes; 3279606d1bf1SJosef Bacik } 3280606d1bf1SJosef Bacik 3281606d1bf1SJosef Bacik /* Modified block groups are accounted for in the delayed_refs_rsv. */ 3282606d1bf1SJosef Bacik btrfs_update_delayed_refs_rsv(trans); 3283606d1bf1SJosef Bacik return ret; 3284606d1bf1SJosef Bacik } 3285606d1bf1SJosef Bacik 3286606d1bf1SJosef Bacik /** 3287606d1bf1SJosef Bacik * btrfs_add_reserved_bytes - update the block_group and space info counters 3288606d1bf1SJosef Bacik * @cache: The cache we are manipulating 3289606d1bf1SJosef Bacik * @ram_bytes: The number of bytes of file content, and will be same to 3290606d1bf1SJosef Bacik * @num_bytes except for the compress path. 3291606d1bf1SJosef Bacik * @num_bytes: The number of bytes in question 3292606d1bf1SJosef Bacik * @delalloc: The blocks are allocated for the delalloc write 3293606d1bf1SJosef Bacik * 3294606d1bf1SJosef Bacik * This is called by the allocator when it reserves space. If this is a 3295606d1bf1SJosef Bacik * reservation and the block group has become read only we cannot make the 3296606d1bf1SJosef Bacik * reservation and return -EAGAIN, otherwise this function always succeeds. 3297606d1bf1SJosef Bacik */ 329832da5386SDavid Sterba int btrfs_add_reserved_bytes(struct btrfs_block_group *cache, 3299606d1bf1SJosef Bacik u64 ram_bytes, u64 num_bytes, int delalloc) 3300606d1bf1SJosef Bacik { 3301606d1bf1SJosef Bacik struct btrfs_space_info *space_info = cache->space_info; 3302606d1bf1SJosef Bacik int ret = 0; 3303606d1bf1SJosef Bacik 3304606d1bf1SJosef Bacik spin_lock(&space_info->lock); 3305606d1bf1SJosef Bacik spin_lock(&cache->lock); 3306606d1bf1SJosef Bacik if (cache->ro) { 3307606d1bf1SJosef Bacik ret = -EAGAIN; 3308606d1bf1SJosef Bacik } else { 3309606d1bf1SJosef Bacik cache->reserved += num_bytes; 3310606d1bf1SJosef Bacik space_info->bytes_reserved += num_bytes; 3311a43c3835SJosef Bacik trace_btrfs_space_reservation(cache->fs_info, "space_info", 3312a43c3835SJosef Bacik space_info->flags, num_bytes, 1); 3313606d1bf1SJosef Bacik btrfs_space_info_update_bytes_may_use(cache->fs_info, 3314606d1bf1SJosef Bacik space_info, -ram_bytes); 3315606d1bf1SJosef Bacik if (delalloc) 3316606d1bf1SJosef Bacik cache->delalloc_bytes += num_bytes; 331799ffb43eSJosef Bacik 331899ffb43eSJosef Bacik /* 331999ffb43eSJosef Bacik * Compression can use less space than we reserved, so wake 332099ffb43eSJosef Bacik * tickets if that happens 332199ffb43eSJosef Bacik */ 332299ffb43eSJosef Bacik if (num_bytes < ram_bytes) 332399ffb43eSJosef Bacik btrfs_try_granting_tickets(cache->fs_info, space_info); 3324606d1bf1SJosef Bacik } 3325606d1bf1SJosef Bacik spin_unlock(&cache->lock); 3326606d1bf1SJosef Bacik spin_unlock(&space_info->lock); 3327606d1bf1SJosef Bacik return ret; 3328606d1bf1SJosef Bacik } 3329606d1bf1SJosef Bacik 3330606d1bf1SJosef Bacik /** 3331606d1bf1SJosef Bacik * btrfs_free_reserved_bytes - update the block_group and space info counters 3332606d1bf1SJosef Bacik * @cache: The cache we are manipulating 3333606d1bf1SJosef Bacik * @num_bytes: The number of bytes in question 3334606d1bf1SJosef Bacik * @delalloc: The blocks are allocated for the delalloc write 3335606d1bf1SJosef Bacik * 3336606d1bf1SJosef Bacik * This is called by somebody who is freeing space that was never actually used 3337606d1bf1SJosef Bacik * on disk. For example if you reserve some space for a new leaf in transaction 3338606d1bf1SJosef Bacik * A and before transaction A commits you free that leaf, you call this with 3339606d1bf1SJosef Bacik * reserve set to 0 in order to clear the reservation. 3340606d1bf1SJosef Bacik */ 334132da5386SDavid Sterba void btrfs_free_reserved_bytes(struct btrfs_block_group *cache, 3342606d1bf1SJosef Bacik u64 num_bytes, int delalloc) 3343606d1bf1SJosef Bacik { 3344606d1bf1SJosef Bacik struct btrfs_space_info *space_info = cache->space_info; 3345606d1bf1SJosef Bacik 3346606d1bf1SJosef Bacik spin_lock(&space_info->lock); 3347606d1bf1SJosef Bacik spin_lock(&cache->lock); 3348606d1bf1SJosef Bacik if (cache->ro) 3349606d1bf1SJosef Bacik space_info->bytes_readonly += num_bytes; 3350606d1bf1SJosef Bacik cache->reserved -= num_bytes; 3351606d1bf1SJosef Bacik space_info->bytes_reserved -= num_bytes; 3352606d1bf1SJosef Bacik space_info->max_extent_size = 0; 3353606d1bf1SJosef Bacik 3354606d1bf1SJosef Bacik if (delalloc) 3355606d1bf1SJosef Bacik cache->delalloc_bytes -= num_bytes; 3356606d1bf1SJosef Bacik spin_unlock(&cache->lock); 33573308234aSJosef Bacik 33583308234aSJosef Bacik btrfs_try_granting_tickets(cache->fs_info, space_info); 3359606d1bf1SJosef Bacik spin_unlock(&space_info->lock); 3360606d1bf1SJosef Bacik } 336107730d87SJosef Bacik 336207730d87SJosef Bacik static void force_metadata_allocation(struct btrfs_fs_info *info) 336307730d87SJosef Bacik { 336407730d87SJosef Bacik struct list_head *head = &info->space_info; 336507730d87SJosef Bacik struct btrfs_space_info *found; 336607730d87SJosef Bacik 336772804905SJosef Bacik list_for_each_entry(found, head, list) { 336807730d87SJosef Bacik if (found->flags & BTRFS_BLOCK_GROUP_METADATA) 336907730d87SJosef Bacik found->force_alloc = CHUNK_ALLOC_FORCE; 337007730d87SJosef Bacik } 337107730d87SJosef Bacik } 337207730d87SJosef Bacik 337307730d87SJosef Bacik static int should_alloc_chunk(struct btrfs_fs_info *fs_info, 337407730d87SJosef Bacik struct btrfs_space_info *sinfo, int force) 337507730d87SJosef Bacik { 337607730d87SJosef Bacik u64 bytes_used = btrfs_space_info_used(sinfo, false); 337707730d87SJosef Bacik u64 thresh; 337807730d87SJosef Bacik 337907730d87SJosef Bacik if (force == CHUNK_ALLOC_FORCE) 338007730d87SJosef Bacik return 1; 338107730d87SJosef Bacik 338207730d87SJosef Bacik /* 338307730d87SJosef Bacik * in limited mode, we want to have some free space up to 338407730d87SJosef Bacik * about 1% of the FS size. 338507730d87SJosef Bacik */ 338607730d87SJosef Bacik if (force == CHUNK_ALLOC_LIMITED) { 338707730d87SJosef Bacik thresh = btrfs_super_total_bytes(fs_info->super_copy); 338807730d87SJosef Bacik thresh = max_t(u64, SZ_64M, div_factor_fine(thresh, 1)); 338907730d87SJosef Bacik 339007730d87SJosef Bacik if (sinfo->total_bytes - bytes_used < thresh) 339107730d87SJosef Bacik return 1; 339207730d87SJosef Bacik } 339307730d87SJosef Bacik 339407730d87SJosef Bacik if (bytes_used + SZ_2M < div_factor(sinfo->total_bytes, 8)) 339507730d87SJosef Bacik return 0; 339607730d87SJosef Bacik return 1; 339707730d87SJosef Bacik } 339807730d87SJosef Bacik 339907730d87SJosef Bacik int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type) 340007730d87SJosef Bacik { 340107730d87SJosef Bacik u64 alloc_flags = btrfs_get_alloc_profile(trans->fs_info, type); 340207730d87SJosef Bacik 340307730d87SJosef Bacik return btrfs_chunk_alloc(trans, alloc_flags, CHUNK_ALLOC_FORCE); 340407730d87SJosef Bacik } 340507730d87SJosef Bacik 340679bd3712SFilipe Manana static int do_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags) 340779bd3712SFilipe Manana { 340879bd3712SFilipe Manana struct btrfs_block_group *bg; 340979bd3712SFilipe Manana int ret; 341079bd3712SFilipe Manana 341107730d87SJosef Bacik /* 341279bd3712SFilipe Manana * Check if we have enough space in the system space info because we 341379bd3712SFilipe Manana * will need to update device items in the chunk btree and insert a new 341479bd3712SFilipe Manana * chunk item in the chunk btree as well. This will allocate a new 341579bd3712SFilipe Manana * system block group if needed. 341679bd3712SFilipe Manana */ 341779bd3712SFilipe Manana check_system_chunk(trans, flags); 341879bd3712SFilipe Manana 3419f6f39f7aSNikolay Borisov bg = btrfs_create_chunk(trans, flags); 342079bd3712SFilipe Manana if (IS_ERR(bg)) { 342179bd3712SFilipe Manana ret = PTR_ERR(bg); 342279bd3712SFilipe Manana goto out; 342379bd3712SFilipe Manana } 342479bd3712SFilipe Manana 342579bd3712SFilipe Manana ret = btrfs_chunk_alloc_add_chunk_item(trans, bg); 342679bd3712SFilipe Manana /* 342779bd3712SFilipe Manana * Normally we are not expected to fail with -ENOSPC here, since we have 342879bd3712SFilipe Manana * previously reserved space in the system space_info and allocated one 3429ecd84d54SFilipe Manana * new system chunk if necessary. However there are three exceptions: 343079bd3712SFilipe Manana * 343179bd3712SFilipe Manana * 1) We may have enough free space in the system space_info but all the 343279bd3712SFilipe Manana * existing system block groups have a profile which can not be used 343379bd3712SFilipe Manana * for extent allocation. 343479bd3712SFilipe Manana * 343579bd3712SFilipe Manana * This happens when mounting in degraded mode. For example we have a 343679bd3712SFilipe Manana * RAID1 filesystem with 2 devices, lose one device and mount the fs 343779bd3712SFilipe Manana * using the other device in degraded mode. If we then allocate a chunk, 343879bd3712SFilipe Manana * we may have enough free space in the existing system space_info, but 343979bd3712SFilipe Manana * none of the block groups can be used for extent allocation since they 344079bd3712SFilipe Manana * have a RAID1 profile, and because we are in degraded mode with a 344179bd3712SFilipe Manana * single device, we are forced to allocate a new system chunk with a 344279bd3712SFilipe Manana * SINGLE profile. Making check_system_chunk() iterate over all system 344379bd3712SFilipe Manana * block groups and check if they have a usable profile and enough space 344479bd3712SFilipe Manana * can be slow on very large filesystems, so we tolerate the -ENOSPC and 344579bd3712SFilipe Manana * try again after forcing allocation of a new system chunk. Like this 344679bd3712SFilipe Manana * we avoid paying the cost of that search in normal circumstances, when 344779bd3712SFilipe Manana * we were not mounted in degraded mode; 344879bd3712SFilipe Manana * 344979bd3712SFilipe Manana * 2) We had enough free space info the system space_info, and one suitable 345079bd3712SFilipe Manana * block group to allocate from when we called check_system_chunk() 345179bd3712SFilipe Manana * above. However right after we called it, the only system block group 345279bd3712SFilipe Manana * with enough free space got turned into RO mode by a running scrub, 345379bd3712SFilipe Manana * and in this case we have to allocate a new one and retry. We only 345479bd3712SFilipe Manana * need do this allocate and retry once, since we have a transaction 3455ecd84d54SFilipe Manana * handle and scrub uses the commit root to search for block groups; 3456ecd84d54SFilipe Manana * 3457ecd84d54SFilipe Manana * 3) We had one system block group with enough free space when we called 3458ecd84d54SFilipe Manana * check_system_chunk(), but after that, right before we tried to 3459ecd84d54SFilipe Manana * allocate the last extent buffer we needed, a discard operation came 3460ecd84d54SFilipe Manana * in and it temporarily removed the last free space entry from the 3461ecd84d54SFilipe Manana * block group (discard removes a free space entry, discards it, and 3462ecd84d54SFilipe Manana * then adds back the entry to the block group cache). 346379bd3712SFilipe Manana */ 346479bd3712SFilipe Manana if (ret == -ENOSPC) { 346579bd3712SFilipe Manana const u64 sys_flags = btrfs_system_alloc_profile(trans->fs_info); 346679bd3712SFilipe Manana struct btrfs_block_group *sys_bg; 346779bd3712SFilipe Manana 3468f6f39f7aSNikolay Borisov sys_bg = btrfs_create_chunk(trans, sys_flags); 346979bd3712SFilipe Manana if (IS_ERR(sys_bg)) { 347079bd3712SFilipe Manana ret = PTR_ERR(sys_bg); 347179bd3712SFilipe Manana btrfs_abort_transaction(trans, ret); 347279bd3712SFilipe Manana goto out; 347379bd3712SFilipe Manana } 347479bd3712SFilipe Manana 347579bd3712SFilipe Manana ret = btrfs_chunk_alloc_add_chunk_item(trans, sys_bg); 347679bd3712SFilipe Manana if (ret) { 347779bd3712SFilipe Manana btrfs_abort_transaction(trans, ret); 347879bd3712SFilipe Manana goto out; 347979bd3712SFilipe Manana } 348079bd3712SFilipe Manana 348179bd3712SFilipe Manana ret = btrfs_chunk_alloc_add_chunk_item(trans, bg); 348279bd3712SFilipe Manana if (ret) { 348379bd3712SFilipe Manana btrfs_abort_transaction(trans, ret); 348479bd3712SFilipe Manana goto out; 348579bd3712SFilipe Manana } 348679bd3712SFilipe Manana } else if (ret) { 348779bd3712SFilipe Manana btrfs_abort_transaction(trans, ret); 348879bd3712SFilipe Manana goto out; 348979bd3712SFilipe Manana } 349079bd3712SFilipe Manana out: 349179bd3712SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 349279bd3712SFilipe Manana 349379bd3712SFilipe Manana return ret; 349479bd3712SFilipe Manana } 349579bd3712SFilipe Manana 349679bd3712SFilipe Manana /* 349779bd3712SFilipe Manana * Chunk allocation is done in 2 phases: 349879bd3712SFilipe Manana * 349979bd3712SFilipe Manana * 1) Phase 1 - through btrfs_chunk_alloc() we allocate device extents for 350079bd3712SFilipe Manana * the chunk, the chunk mapping, create its block group and add the items 350179bd3712SFilipe Manana * that belong in the chunk btree to it - more specifically, we need to 350279bd3712SFilipe Manana * update device items in the chunk btree and add a new chunk item to it. 350379bd3712SFilipe Manana * 350479bd3712SFilipe Manana * 2) Phase 2 - through btrfs_create_pending_block_groups(), we add the block 350579bd3712SFilipe Manana * group item to the extent btree and the device extent items to the devices 350679bd3712SFilipe Manana * btree. 350779bd3712SFilipe Manana * 350879bd3712SFilipe Manana * This is done to prevent deadlocks. For example when COWing a node from the 350979bd3712SFilipe Manana * extent btree we are holding a write lock on the node's parent and if we 351079bd3712SFilipe Manana * trigger chunk allocation and attempted to insert the new block group item 351179bd3712SFilipe Manana * in the extent btree right way, we could deadlock because the path for the 351279bd3712SFilipe Manana * insertion can include that parent node. At first glance it seems impossible 351379bd3712SFilipe Manana * to trigger chunk allocation after starting a transaction since tasks should 351479bd3712SFilipe Manana * reserve enough transaction units (metadata space), however while that is true 351579bd3712SFilipe Manana * most of the time, chunk allocation may still be triggered for several reasons: 351679bd3712SFilipe Manana * 351779bd3712SFilipe Manana * 1) When reserving metadata, we check if there is enough free space in the 351879bd3712SFilipe Manana * metadata space_info and therefore don't trigger allocation of a new chunk. 351979bd3712SFilipe Manana * However later when the task actually tries to COW an extent buffer from 352079bd3712SFilipe Manana * the extent btree or from the device btree for example, it is forced to 352179bd3712SFilipe Manana * allocate a new block group (chunk) because the only one that had enough 352279bd3712SFilipe Manana * free space was just turned to RO mode by a running scrub for example (or 352379bd3712SFilipe Manana * device replace, block group reclaim thread, etc), so we can not use it 352479bd3712SFilipe Manana * for allocating an extent and end up being forced to allocate a new one; 352579bd3712SFilipe Manana * 352679bd3712SFilipe Manana * 2) Because we only check that the metadata space_info has enough free bytes, 352779bd3712SFilipe Manana * we end up not allocating a new metadata chunk in that case. However if 352879bd3712SFilipe Manana * the filesystem was mounted in degraded mode, none of the existing block 352979bd3712SFilipe Manana * groups might be suitable for extent allocation due to their incompatible 353079bd3712SFilipe Manana * profile (for e.g. mounting a 2 devices filesystem, where all block groups 353179bd3712SFilipe Manana * use a RAID1 profile, in degraded mode using a single device). In this case 353279bd3712SFilipe Manana * when the task attempts to COW some extent buffer of the extent btree for 353379bd3712SFilipe Manana * example, it will trigger allocation of a new metadata block group with a 353479bd3712SFilipe Manana * suitable profile (SINGLE profile in the example of the degraded mount of 353579bd3712SFilipe Manana * the RAID1 filesystem); 353679bd3712SFilipe Manana * 353779bd3712SFilipe Manana * 3) The task has reserved enough transaction units / metadata space, but when 353879bd3712SFilipe Manana * it attempts to COW an extent buffer from the extent or device btree for 353979bd3712SFilipe Manana * example, it does not find any free extent in any metadata block group, 354079bd3712SFilipe Manana * therefore forced to try to allocate a new metadata block group. 354179bd3712SFilipe Manana * This is because some other task allocated all available extents in the 354279bd3712SFilipe Manana * meanwhile - this typically happens with tasks that don't reserve space 354379bd3712SFilipe Manana * properly, either intentionally or as a bug. One example where this is 354479bd3712SFilipe Manana * done intentionally is fsync, as it does not reserve any transaction units 354579bd3712SFilipe Manana * and ends up allocating a variable number of metadata extents for log 3546ecd84d54SFilipe Manana * tree extent buffers; 3547ecd84d54SFilipe Manana * 3548ecd84d54SFilipe Manana * 4) The task has reserved enough transaction units / metadata space, but right 3549ecd84d54SFilipe Manana * before it tries to allocate the last extent buffer it needs, a discard 3550ecd84d54SFilipe Manana * operation comes in and, temporarily, removes the last free space entry from 3551ecd84d54SFilipe Manana * the only metadata block group that had free space (discard starts by 3552ecd84d54SFilipe Manana * removing a free space entry from a block group, then does the discard 3553ecd84d54SFilipe Manana * operation and, once it's done, it adds back the free space entry to the 3554ecd84d54SFilipe Manana * block group). 355579bd3712SFilipe Manana * 355679bd3712SFilipe Manana * We also need this 2 phases setup when adding a device to a filesystem with 355779bd3712SFilipe Manana * a seed device - we must create new metadata and system chunks without adding 355879bd3712SFilipe Manana * any of the block group items to the chunk, extent and device btrees. If we 355979bd3712SFilipe Manana * did not do it this way, we would get ENOSPC when attempting to update those 356079bd3712SFilipe Manana * btrees, since all the chunks from the seed device are read-only. 356179bd3712SFilipe Manana * 356279bd3712SFilipe Manana * Phase 1 does the updates and insertions to the chunk btree because if we had 356379bd3712SFilipe Manana * it done in phase 2 and have a thundering herd of tasks allocating chunks in 356479bd3712SFilipe Manana * parallel, we risk having too many system chunks allocated by many tasks if 356579bd3712SFilipe Manana * many tasks reach phase 1 without the previous ones completing phase 2. In the 356679bd3712SFilipe Manana * extreme case this leads to exhaustion of the system chunk array in the 356779bd3712SFilipe Manana * superblock. This is easier to trigger if using a btree node/leaf size of 64K 356879bd3712SFilipe Manana * and with RAID filesystems (so we have more device items in the chunk btree). 356979bd3712SFilipe Manana * This has happened before and commit eafa4fd0ad0607 ("btrfs: fix exhaustion of 357079bd3712SFilipe Manana * the system chunk array due to concurrent allocations") provides more details. 357179bd3712SFilipe Manana * 35722bb2e00eSFilipe Manana * Allocation of system chunks does not happen through this function. A task that 35732bb2e00eSFilipe Manana * needs to update the chunk btree (the only btree that uses system chunks), must 35742bb2e00eSFilipe Manana * preallocate chunk space by calling either check_system_chunk() or 35752bb2e00eSFilipe Manana * btrfs_reserve_chunk_metadata() - the former is used when allocating a data or 35762bb2e00eSFilipe Manana * metadata chunk or when removing a chunk, while the later is used before doing 35772bb2e00eSFilipe Manana * a modification to the chunk btree - use cases for the later are adding, 35782bb2e00eSFilipe Manana * removing and resizing a device as well as relocation of a system chunk. 35792bb2e00eSFilipe Manana * See the comment below for more details. 358079bd3712SFilipe Manana * 358179bd3712SFilipe Manana * The reservation of system space, done through check_system_chunk(), as well 358279bd3712SFilipe Manana * as all the updates and insertions into the chunk btree must be done while 358379bd3712SFilipe Manana * holding fs_info->chunk_mutex. This is important to guarantee that while COWing 358479bd3712SFilipe Manana * an extent buffer from the chunks btree we never trigger allocation of a new 358579bd3712SFilipe Manana * system chunk, which would result in a deadlock (trying to lock twice an 358679bd3712SFilipe Manana * extent buffer of the chunk btree, first time before triggering the chunk 358779bd3712SFilipe Manana * allocation and the second time during chunk allocation while attempting to 358879bd3712SFilipe Manana * update the chunks btree). The system chunk array is also updated while holding 358979bd3712SFilipe Manana * that mutex. The same logic applies to removing chunks - we must reserve system 359079bd3712SFilipe Manana * space, update the chunk btree and the system chunk array in the superblock 359179bd3712SFilipe Manana * while holding fs_info->chunk_mutex. 359279bd3712SFilipe Manana * 359379bd3712SFilipe Manana * This function, btrfs_chunk_alloc(), belongs to phase 1. 359479bd3712SFilipe Manana * 359579bd3712SFilipe Manana * If @force is CHUNK_ALLOC_FORCE: 359607730d87SJosef Bacik * - return 1 if it successfully allocates a chunk, 359707730d87SJosef Bacik * - return errors including -ENOSPC otherwise. 359879bd3712SFilipe Manana * If @force is NOT CHUNK_ALLOC_FORCE: 359907730d87SJosef Bacik * - return 0 if it doesn't need to allocate a new chunk, 360007730d87SJosef Bacik * - return 1 if it successfully allocates a chunk, 360107730d87SJosef Bacik * - return errors including -ENOSPC otherwise. 360207730d87SJosef Bacik */ 360307730d87SJosef Bacik int btrfs_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags, 360407730d87SJosef Bacik enum btrfs_chunk_alloc_enum force) 360507730d87SJosef Bacik { 360607730d87SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 360707730d87SJosef Bacik struct btrfs_space_info *space_info; 360807730d87SJosef Bacik bool wait_for_alloc = false; 360907730d87SJosef Bacik bool should_alloc = false; 361007730d87SJosef Bacik int ret = 0; 361107730d87SJosef Bacik 361207730d87SJosef Bacik /* Don't re-enter if we're already allocating a chunk */ 361307730d87SJosef Bacik if (trans->allocating_chunk) 361407730d87SJosef Bacik return -ENOSPC; 361579bd3712SFilipe Manana /* 36162bb2e00eSFilipe Manana * Allocation of system chunks can not happen through this path, as we 36172bb2e00eSFilipe Manana * could end up in a deadlock if we are allocating a data or metadata 36182bb2e00eSFilipe Manana * chunk and there is another task modifying the chunk btree. 36192bb2e00eSFilipe Manana * 36202bb2e00eSFilipe Manana * This is because while we are holding the chunk mutex, we will attempt 36212bb2e00eSFilipe Manana * to add the new chunk item to the chunk btree or update an existing 36222bb2e00eSFilipe Manana * device item in the chunk btree, while the other task that is modifying 36232bb2e00eSFilipe Manana * the chunk btree is attempting to COW an extent buffer while holding a 36242bb2e00eSFilipe Manana * lock on it and on its parent - if the COW operation triggers a system 36252bb2e00eSFilipe Manana * chunk allocation, then we can deadlock because we are holding the 36262bb2e00eSFilipe Manana * chunk mutex and we may need to access that extent buffer or its parent 36272bb2e00eSFilipe Manana * in order to add the chunk item or update a device item. 36282bb2e00eSFilipe Manana * 36292bb2e00eSFilipe Manana * Tasks that want to modify the chunk tree should reserve system space 36302bb2e00eSFilipe Manana * before updating the chunk btree, by calling either 36312bb2e00eSFilipe Manana * btrfs_reserve_chunk_metadata() or check_system_chunk(). 36322bb2e00eSFilipe Manana * It's possible that after a task reserves the space, it still ends up 36332bb2e00eSFilipe Manana * here - this happens in the cases described above at do_chunk_alloc(). 36342bb2e00eSFilipe Manana * The task will have to either retry or fail. 363579bd3712SFilipe Manana */ 36362bb2e00eSFilipe Manana if (flags & BTRFS_BLOCK_GROUP_SYSTEM) 363779bd3712SFilipe Manana return -ENOSPC; 363807730d87SJosef Bacik 363907730d87SJosef Bacik space_info = btrfs_find_space_info(fs_info, flags); 364007730d87SJosef Bacik ASSERT(space_info); 364107730d87SJosef Bacik 364207730d87SJosef Bacik do { 364307730d87SJosef Bacik spin_lock(&space_info->lock); 364407730d87SJosef Bacik if (force < space_info->force_alloc) 364507730d87SJosef Bacik force = space_info->force_alloc; 364607730d87SJosef Bacik should_alloc = should_alloc_chunk(fs_info, space_info, force); 364707730d87SJosef Bacik if (space_info->full) { 364807730d87SJosef Bacik /* No more free physical space */ 364907730d87SJosef Bacik if (should_alloc) 365007730d87SJosef Bacik ret = -ENOSPC; 365107730d87SJosef Bacik else 365207730d87SJosef Bacik ret = 0; 365307730d87SJosef Bacik spin_unlock(&space_info->lock); 365407730d87SJosef Bacik return ret; 365507730d87SJosef Bacik } else if (!should_alloc) { 365607730d87SJosef Bacik spin_unlock(&space_info->lock); 365707730d87SJosef Bacik return 0; 365807730d87SJosef Bacik } else if (space_info->chunk_alloc) { 365907730d87SJosef Bacik /* 366007730d87SJosef Bacik * Someone is already allocating, so we need to block 366107730d87SJosef Bacik * until this someone is finished and then loop to 366207730d87SJosef Bacik * recheck if we should continue with our allocation 366307730d87SJosef Bacik * attempt. 366407730d87SJosef Bacik */ 366507730d87SJosef Bacik wait_for_alloc = true; 366607730d87SJosef Bacik spin_unlock(&space_info->lock); 366707730d87SJosef Bacik mutex_lock(&fs_info->chunk_mutex); 366807730d87SJosef Bacik mutex_unlock(&fs_info->chunk_mutex); 366907730d87SJosef Bacik } else { 367007730d87SJosef Bacik /* Proceed with allocation */ 367107730d87SJosef Bacik space_info->chunk_alloc = 1; 367207730d87SJosef Bacik wait_for_alloc = false; 367307730d87SJosef Bacik spin_unlock(&space_info->lock); 367407730d87SJosef Bacik } 367507730d87SJosef Bacik 367607730d87SJosef Bacik cond_resched(); 367707730d87SJosef Bacik } while (wait_for_alloc); 367807730d87SJosef Bacik 367907730d87SJosef Bacik mutex_lock(&fs_info->chunk_mutex); 368007730d87SJosef Bacik trans->allocating_chunk = true; 368107730d87SJosef Bacik 368207730d87SJosef Bacik /* 368307730d87SJosef Bacik * If we have mixed data/metadata chunks we want to make sure we keep 368407730d87SJosef Bacik * allocating mixed chunks instead of individual chunks. 368507730d87SJosef Bacik */ 368607730d87SJosef Bacik if (btrfs_mixed_space_info(space_info)) 368707730d87SJosef Bacik flags |= (BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA); 368807730d87SJosef Bacik 368907730d87SJosef Bacik /* 369007730d87SJosef Bacik * if we're doing a data chunk, go ahead and make sure that 369107730d87SJosef Bacik * we keep a reasonable number of metadata chunks allocated in the 369207730d87SJosef Bacik * FS as well. 369307730d87SJosef Bacik */ 369407730d87SJosef Bacik if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) { 369507730d87SJosef Bacik fs_info->data_chunk_allocations++; 369607730d87SJosef Bacik if (!(fs_info->data_chunk_allocations % 369707730d87SJosef Bacik fs_info->metadata_ratio)) 369807730d87SJosef Bacik force_metadata_allocation(fs_info); 369907730d87SJosef Bacik } 370007730d87SJosef Bacik 370179bd3712SFilipe Manana ret = do_chunk_alloc(trans, flags); 370207730d87SJosef Bacik trans->allocating_chunk = false; 370307730d87SJosef Bacik 370407730d87SJosef Bacik spin_lock(&space_info->lock); 370507730d87SJosef Bacik if (ret < 0) { 370607730d87SJosef Bacik if (ret == -ENOSPC) 370707730d87SJosef Bacik space_info->full = 1; 370807730d87SJosef Bacik else 370907730d87SJosef Bacik goto out; 371007730d87SJosef Bacik } else { 371107730d87SJosef Bacik ret = 1; 371207730d87SJosef Bacik space_info->max_extent_size = 0; 371307730d87SJosef Bacik } 371407730d87SJosef Bacik 371507730d87SJosef Bacik space_info->force_alloc = CHUNK_ALLOC_NO_FORCE; 371607730d87SJosef Bacik out: 371707730d87SJosef Bacik space_info->chunk_alloc = 0; 371807730d87SJosef Bacik spin_unlock(&space_info->lock); 371907730d87SJosef Bacik mutex_unlock(&fs_info->chunk_mutex); 372007730d87SJosef Bacik 372107730d87SJosef Bacik return ret; 372207730d87SJosef Bacik } 372307730d87SJosef Bacik 372407730d87SJosef Bacik static u64 get_profile_num_devs(struct btrfs_fs_info *fs_info, u64 type) 372507730d87SJosef Bacik { 372607730d87SJosef Bacik u64 num_dev; 372707730d87SJosef Bacik 372807730d87SJosef Bacik num_dev = btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)].devs_max; 372907730d87SJosef Bacik if (!num_dev) 373007730d87SJosef Bacik num_dev = fs_info->fs_devices->rw_devices; 373107730d87SJosef Bacik 373207730d87SJosef Bacik return num_dev; 373307730d87SJosef Bacik } 373407730d87SJosef Bacik 37352bb2e00eSFilipe Manana static void reserve_chunk_space(struct btrfs_trans_handle *trans, 37362bb2e00eSFilipe Manana u64 bytes, 37372bb2e00eSFilipe Manana u64 type) 373807730d87SJosef Bacik { 373907730d87SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 374007730d87SJosef Bacik struct btrfs_space_info *info; 374107730d87SJosef Bacik u64 left; 374207730d87SJosef Bacik int ret = 0; 374307730d87SJosef Bacik 374407730d87SJosef Bacik /* 374507730d87SJosef Bacik * Needed because we can end up allocating a system chunk and for an 374607730d87SJosef Bacik * atomic and race free space reservation in the chunk block reserve. 374707730d87SJosef Bacik */ 374807730d87SJosef Bacik lockdep_assert_held(&fs_info->chunk_mutex); 374907730d87SJosef Bacik 375007730d87SJosef Bacik info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM); 375107730d87SJosef Bacik spin_lock(&info->lock); 375207730d87SJosef Bacik left = info->total_bytes - btrfs_space_info_used(info, true); 375307730d87SJosef Bacik spin_unlock(&info->lock); 375407730d87SJosef Bacik 37552bb2e00eSFilipe Manana if (left < bytes && btrfs_test_opt(fs_info, ENOSPC_DEBUG)) { 375607730d87SJosef Bacik btrfs_info(fs_info, "left=%llu, need=%llu, flags=%llu", 37572bb2e00eSFilipe Manana left, bytes, type); 375807730d87SJosef Bacik btrfs_dump_space_info(fs_info, info, 0, 0); 375907730d87SJosef Bacik } 376007730d87SJosef Bacik 37612bb2e00eSFilipe Manana if (left < bytes) { 376207730d87SJosef Bacik u64 flags = btrfs_system_alloc_profile(fs_info); 376379bd3712SFilipe Manana struct btrfs_block_group *bg; 376407730d87SJosef Bacik 376507730d87SJosef Bacik /* 376607730d87SJosef Bacik * Ignore failure to create system chunk. We might end up not 376707730d87SJosef Bacik * needing it, as we might not need to COW all nodes/leafs from 376807730d87SJosef Bacik * the paths we visit in the chunk tree (they were already COWed 376907730d87SJosef Bacik * or created in the current transaction for example). 377007730d87SJosef Bacik */ 3771f6f39f7aSNikolay Borisov bg = btrfs_create_chunk(trans, flags); 377279bd3712SFilipe Manana if (IS_ERR(bg)) { 377379bd3712SFilipe Manana ret = PTR_ERR(bg); 37742bb2e00eSFilipe Manana } else { 377579bd3712SFilipe Manana /* 377679bd3712SFilipe Manana * If we fail to add the chunk item here, we end up 377779bd3712SFilipe Manana * trying again at phase 2 of chunk allocation, at 377879bd3712SFilipe Manana * btrfs_create_pending_block_groups(). So ignore 37792bb2e00eSFilipe Manana * any error here. An ENOSPC here could happen, due to 37802bb2e00eSFilipe Manana * the cases described at do_chunk_alloc() - the system 37812bb2e00eSFilipe Manana * block group we just created was just turned into RO 37822bb2e00eSFilipe Manana * mode by a scrub for example, or a running discard 37832bb2e00eSFilipe Manana * temporarily removed its free space entries, etc. 378479bd3712SFilipe Manana */ 378579bd3712SFilipe Manana btrfs_chunk_alloc_add_chunk_item(trans, bg); 378679bd3712SFilipe Manana } 378707730d87SJosef Bacik } 378807730d87SJosef Bacik 378907730d87SJosef Bacik if (!ret) { 37909270501cSJosef Bacik ret = btrfs_block_rsv_add(fs_info, 379107730d87SJosef Bacik &fs_info->chunk_block_rsv, 37922bb2e00eSFilipe Manana bytes, BTRFS_RESERVE_NO_FLUSH); 37931cb3db1cSFilipe Manana if (!ret) 37942bb2e00eSFilipe Manana trans->chunk_bytes_reserved += bytes; 379507730d87SJosef Bacik } 379607730d87SJosef Bacik } 379707730d87SJosef Bacik 37982bb2e00eSFilipe Manana /* 37992bb2e00eSFilipe Manana * Reserve space in the system space for allocating or removing a chunk. 38002bb2e00eSFilipe Manana * The caller must be holding fs_info->chunk_mutex. 38012bb2e00eSFilipe Manana */ 38022bb2e00eSFilipe Manana void check_system_chunk(struct btrfs_trans_handle *trans, u64 type) 38032bb2e00eSFilipe Manana { 38042bb2e00eSFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 38052bb2e00eSFilipe Manana const u64 num_devs = get_profile_num_devs(fs_info, type); 38062bb2e00eSFilipe Manana u64 bytes; 38072bb2e00eSFilipe Manana 38082bb2e00eSFilipe Manana /* num_devs device items to update and 1 chunk item to add or remove. */ 38092bb2e00eSFilipe Manana bytes = btrfs_calc_metadata_size(fs_info, num_devs) + 38102bb2e00eSFilipe Manana btrfs_calc_insert_metadata_size(fs_info, 1); 38112bb2e00eSFilipe Manana 38122bb2e00eSFilipe Manana reserve_chunk_space(trans, bytes, type); 38132bb2e00eSFilipe Manana } 38142bb2e00eSFilipe Manana 38152bb2e00eSFilipe Manana /* 38162bb2e00eSFilipe Manana * Reserve space in the system space, if needed, for doing a modification to the 38172bb2e00eSFilipe Manana * chunk btree. 38182bb2e00eSFilipe Manana * 38192bb2e00eSFilipe Manana * @trans: A transaction handle. 38202bb2e00eSFilipe Manana * @is_item_insertion: Indicate if the modification is for inserting a new item 38212bb2e00eSFilipe Manana * in the chunk btree or if it's for the deletion or update 38222bb2e00eSFilipe Manana * of an existing item. 38232bb2e00eSFilipe Manana * 38242bb2e00eSFilipe Manana * This is used in a context where we need to update the chunk btree outside 38252bb2e00eSFilipe Manana * block group allocation and removal, to avoid a deadlock with a concurrent 38262bb2e00eSFilipe Manana * task that is allocating a metadata or data block group and therefore needs to 38272bb2e00eSFilipe Manana * update the chunk btree while holding the chunk mutex. After the update to the 38282bb2e00eSFilipe Manana * chunk btree is done, btrfs_trans_release_chunk_metadata() should be called. 38292bb2e00eSFilipe Manana * 38302bb2e00eSFilipe Manana */ 38312bb2e00eSFilipe Manana void btrfs_reserve_chunk_metadata(struct btrfs_trans_handle *trans, 38322bb2e00eSFilipe Manana bool is_item_insertion) 38332bb2e00eSFilipe Manana { 38342bb2e00eSFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 38352bb2e00eSFilipe Manana u64 bytes; 38362bb2e00eSFilipe Manana 38372bb2e00eSFilipe Manana if (is_item_insertion) 38382bb2e00eSFilipe Manana bytes = btrfs_calc_insert_metadata_size(fs_info, 1); 38392bb2e00eSFilipe Manana else 38402bb2e00eSFilipe Manana bytes = btrfs_calc_metadata_size(fs_info, 1); 38412bb2e00eSFilipe Manana 38422bb2e00eSFilipe Manana mutex_lock(&fs_info->chunk_mutex); 38432bb2e00eSFilipe Manana reserve_chunk_space(trans, bytes, BTRFS_BLOCK_GROUP_SYSTEM); 38442bb2e00eSFilipe Manana mutex_unlock(&fs_info->chunk_mutex); 38452bb2e00eSFilipe Manana } 38462bb2e00eSFilipe Manana 38473e43c279SJosef Bacik void btrfs_put_block_group_cache(struct btrfs_fs_info *info) 38483e43c279SJosef Bacik { 384932da5386SDavid Sterba struct btrfs_block_group *block_group; 38503e43c279SJosef Bacik u64 last = 0; 38513e43c279SJosef Bacik 38523e43c279SJosef Bacik while (1) { 38533e43c279SJosef Bacik struct inode *inode; 38543e43c279SJosef Bacik 38553e43c279SJosef Bacik block_group = btrfs_lookup_first_block_group(info, last); 38563e43c279SJosef Bacik while (block_group) { 38573e43c279SJosef Bacik btrfs_wait_block_group_cache_done(block_group); 38583e43c279SJosef Bacik spin_lock(&block_group->lock); 38593e43c279SJosef Bacik if (block_group->iref) 38603e43c279SJosef Bacik break; 38613e43c279SJosef Bacik spin_unlock(&block_group->lock); 38623e43c279SJosef Bacik block_group = btrfs_next_block_group(block_group); 38633e43c279SJosef Bacik } 38643e43c279SJosef Bacik if (!block_group) { 38653e43c279SJosef Bacik if (last == 0) 38663e43c279SJosef Bacik break; 38673e43c279SJosef Bacik last = 0; 38683e43c279SJosef Bacik continue; 38693e43c279SJosef Bacik } 38703e43c279SJosef Bacik 38713e43c279SJosef Bacik inode = block_group->inode; 38723e43c279SJosef Bacik block_group->iref = 0; 38733e43c279SJosef Bacik block_group->inode = NULL; 38743e43c279SJosef Bacik spin_unlock(&block_group->lock); 38753e43c279SJosef Bacik ASSERT(block_group->io_ctl.inode == NULL); 38763e43c279SJosef Bacik iput(inode); 3877b3470b5dSDavid Sterba last = block_group->start + block_group->length; 38783e43c279SJosef Bacik btrfs_put_block_group(block_group); 38793e43c279SJosef Bacik } 38803e43c279SJosef Bacik } 38813e43c279SJosef Bacik 38823e43c279SJosef Bacik /* 38833e43c279SJosef Bacik * Must be called only after stopping all workers, since we could have block 38843e43c279SJosef Bacik * group caching kthreads running, and therefore they could race with us if we 38853e43c279SJosef Bacik * freed the block groups before stopping them. 38863e43c279SJosef Bacik */ 38873e43c279SJosef Bacik int btrfs_free_block_groups(struct btrfs_fs_info *info) 38883e43c279SJosef Bacik { 388932da5386SDavid Sterba struct btrfs_block_group *block_group; 38903e43c279SJosef Bacik struct btrfs_space_info *space_info; 38913e43c279SJosef Bacik struct btrfs_caching_control *caching_ctl; 38923e43c279SJosef Bacik struct rb_node *n; 38933e43c279SJosef Bacik 3894bbb86a37SJosef Bacik spin_lock(&info->block_group_cache_lock); 38953e43c279SJosef Bacik while (!list_empty(&info->caching_block_groups)) { 38963e43c279SJosef Bacik caching_ctl = list_entry(info->caching_block_groups.next, 38973e43c279SJosef Bacik struct btrfs_caching_control, list); 38983e43c279SJosef Bacik list_del(&caching_ctl->list); 38993e43c279SJosef Bacik btrfs_put_caching_control(caching_ctl); 39003e43c279SJosef Bacik } 3901bbb86a37SJosef Bacik spin_unlock(&info->block_group_cache_lock); 39023e43c279SJosef Bacik 39033e43c279SJosef Bacik spin_lock(&info->unused_bgs_lock); 39043e43c279SJosef Bacik while (!list_empty(&info->unused_bgs)) { 39053e43c279SJosef Bacik block_group = list_first_entry(&info->unused_bgs, 390632da5386SDavid Sterba struct btrfs_block_group, 39073e43c279SJosef Bacik bg_list); 39083e43c279SJosef Bacik list_del_init(&block_group->bg_list); 39093e43c279SJosef Bacik btrfs_put_block_group(block_group); 39103e43c279SJosef Bacik } 39113e43c279SJosef Bacik 391218bb8bbfSJohannes Thumshirn while (!list_empty(&info->reclaim_bgs)) { 391318bb8bbfSJohannes Thumshirn block_group = list_first_entry(&info->reclaim_bgs, 391418bb8bbfSJohannes Thumshirn struct btrfs_block_group, 391518bb8bbfSJohannes Thumshirn bg_list); 391618bb8bbfSJohannes Thumshirn list_del_init(&block_group->bg_list); 391718bb8bbfSJohannes Thumshirn btrfs_put_block_group(block_group); 391818bb8bbfSJohannes Thumshirn } 391918bb8bbfSJohannes Thumshirn spin_unlock(&info->unused_bgs_lock); 392018bb8bbfSJohannes Thumshirn 3921afba2bc0SNaohiro Aota spin_lock(&info->zone_active_bgs_lock); 3922afba2bc0SNaohiro Aota while (!list_empty(&info->zone_active_bgs)) { 3923afba2bc0SNaohiro Aota block_group = list_first_entry(&info->zone_active_bgs, 3924afba2bc0SNaohiro Aota struct btrfs_block_group, 3925afba2bc0SNaohiro Aota active_bg_list); 3926afba2bc0SNaohiro Aota list_del_init(&block_group->active_bg_list); 3927afba2bc0SNaohiro Aota btrfs_put_block_group(block_group); 3928afba2bc0SNaohiro Aota } 3929afba2bc0SNaohiro Aota spin_unlock(&info->zone_active_bgs_lock); 3930afba2bc0SNaohiro Aota 39313e43c279SJosef Bacik spin_lock(&info->block_group_cache_lock); 39323e43c279SJosef Bacik while ((n = rb_last(&info->block_group_cache_tree)) != NULL) { 393332da5386SDavid Sterba block_group = rb_entry(n, struct btrfs_block_group, 39343e43c279SJosef Bacik cache_node); 39353e43c279SJosef Bacik rb_erase(&block_group->cache_node, 39363e43c279SJosef Bacik &info->block_group_cache_tree); 39373e43c279SJosef Bacik RB_CLEAR_NODE(&block_group->cache_node); 39383e43c279SJosef Bacik spin_unlock(&info->block_group_cache_lock); 39393e43c279SJosef Bacik 39403e43c279SJosef Bacik down_write(&block_group->space_info->groups_sem); 39413e43c279SJosef Bacik list_del(&block_group->list); 39423e43c279SJosef Bacik up_write(&block_group->space_info->groups_sem); 39433e43c279SJosef Bacik 39443e43c279SJosef Bacik /* 39453e43c279SJosef Bacik * We haven't cached this block group, which means we could 39463e43c279SJosef Bacik * possibly have excluded extents on this block group. 39473e43c279SJosef Bacik */ 39483e43c279SJosef Bacik if (block_group->cached == BTRFS_CACHE_NO || 39493e43c279SJosef Bacik block_group->cached == BTRFS_CACHE_ERROR) 39503e43c279SJosef Bacik btrfs_free_excluded_extents(block_group); 39513e43c279SJosef Bacik 39523e43c279SJosef Bacik btrfs_remove_free_space_cache(block_group); 39533e43c279SJosef Bacik ASSERT(block_group->cached != BTRFS_CACHE_STARTED); 39543e43c279SJosef Bacik ASSERT(list_empty(&block_group->dirty_list)); 39553e43c279SJosef Bacik ASSERT(list_empty(&block_group->io_list)); 39563e43c279SJosef Bacik ASSERT(list_empty(&block_group->bg_list)); 395748aaeebeSJosef Bacik ASSERT(refcount_read(&block_group->refs) == 1); 3958195a49eaSFilipe Manana ASSERT(block_group->swap_extents == 0); 39593e43c279SJosef Bacik btrfs_put_block_group(block_group); 39603e43c279SJosef Bacik 39613e43c279SJosef Bacik spin_lock(&info->block_group_cache_lock); 39623e43c279SJosef Bacik } 39633e43c279SJosef Bacik spin_unlock(&info->block_group_cache_lock); 39643e43c279SJosef Bacik 39653e43c279SJosef Bacik btrfs_release_global_block_rsv(info); 39663e43c279SJosef Bacik 39673e43c279SJosef Bacik while (!list_empty(&info->space_info)) { 39683e43c279SJosef Bacik space_info = list_entry(info->space_info.next, 39693e43c279SJosef Bacik struct btrfs_space_info, 39703e43c279SJosef Bacik list); 39713e43c279SJosef Bacik 39723e43c279SJosef Bacik /* 39733e43c279SJosef Bacik * Do not hide this behind enospc_debug, this is actually 39743e43c279SJosef Bacik * important and indicates a real bug if this happens. 39753e43c279SJosef Bacik */ 39763e43c279SJosef Bacik if (WARN_ON(space_info->bytes_pinned > 0 || 39773e43c279SJosef Bacik space_info->bytes_reserved > 0 || 39783e43c279SJosef Bacik space_info->bytes_may_use > 0)) 39793e43c279SJosef Bacik btrfs_dump_space_info(info, space_info, 0, 0); 3980d611add4SFilipe Manana WARN_ON(space_info->reclaim_size > 0); 39813e43c279SJosef Bacik list_del(&space_info->list); 39823e43c279SJosef Bacik btrfs_sysfs_remove_space_info(space_info); 39833e43c279SJosef Bacik } 39843e43c279SJosef Bacik return 0; 39853e43c279SJosef Bacik } 3986684b752bSFilipe Manana 3987684b752bSFilipe Manana void btrfs_freeze_block_group(struct btrfs_block_group *cache) 3988684b752bSFilipe Manana { 3989684b752bSFilipe Manana atomic_inc(&cache->frozen); 3990684b752bSFilipe Manana } 3991684b752bSFilipe Manana 3992684b752bSFilipe Manana void btrfs_unfreeze_block_group(struct btrfs_block_group *block_group) 3993684b752bSFilipe Manana { 3994684b752bSFilipe Manana struct btrfs_fs_info *fs_info = block_group->fs_info; 3995684b752bSFilipe Manana struct extent_map_tree *em_tree; 3996684b752bSFilipe Manana struct extent_map *em; 3997684b752bSFilipe Manana bool cleanup; 3998684b752bSFilipe Manana 3999684b752bSFilipe Manana spin_lock(&block_group->lock); 4000684b752bSFilipe Manana cleanup = (atomic_dec_and_test(&block_group->frozen) && 4001684b752bSFilipe Manana block_group->removed); 4002684b752bSFilipe Manana spin_unlock(&block_group->lock); 4003684b752bSFilipe Manana 4004684b752bSFilipe Manana if (cleanup) { 4005684b752bSFilipe Manana em_tree = &fs_info->mapping_tree; 4006684b752bSFilipe Manana write_lock(&em_tree->lock); 4007684b752bSFilipe Manana em = lookup_extent_mapping(em_tree, block_group->start, 4008684b752bSFilipe Manana 1); 4009684b752bSFilipe Manana BUG_ON(!em); /* logic error, can't happen */ 4010684b752bSFilipe Manana remove_extent_mapping(em_tree, em); 4011684b752bSFilipe Manana write_unlock(&em_tree->lock); 4012684b752bSFilipe Manana 4013684b752bSFilipe Manana /* once for us and once for the tree */ 4014684b752bSFilipe Manana free_extent_map(em); 4015684b752bSFilipe Manana free_extent_map(em); 4016684b752bSFilipe Manana 4017684b752bSFilipe Manana /* 4018684b752bSFilipe Manana * We may have left one free space entry and other possible 4019684b752bSFilipe Manana * tasks trimming this block group have left 1 entry each one. 4020684b752bSFilipe Manana * Free them if any. 4021684b752bSFilipe Manana */ 4022684b752bSFilipe Manana __btrfs_remove_free_space_cache(block_group->free_space_ctl); 4023684b752bSFilipe Manana } 4024684b752bSFilipe Manana } 4025195a49eaSFilipe Manana 4026195a49eaSFilipe Manana bool btrfs_inc_block_group_swap_extents(struct btrfs_block_group *bg) 4027195a49eaSFilipe Manana { 4028195a49eaSFilipe Manana bool ret = true; 4029195a49eaSFilipe Manana 4030195a49eaSFilipe Manana spin_lock(&bg->lock); 4031195a49eaSFilipe Manana if (bg->ro) 4032195a49eaSFilipe Manana ret = false; 4033195a49eaSFilipe Manana else 4034195a49eaSFilipe Manana bg->swap_extents++; 4035195a49eaSFilipe Manana spin_unlock(&bg->lock); 4036195a49eaSFilipe Manana 4037195a49eaSFilipe Manana return ret; 4038195a49eaSFilipe Manana } 4039195a49eaSFilipe Manana 4040195a49eaSFilipe Manana void btrfs_dec_block_group_swap_extents(struct btrfs_block_group *bg, int amount) 4041195a49eaSFilipe Manana { 4042195a49eaSFilipe Manana spin_lock(&bg->lock); 4043195a49eaSFilipe Manana ASSERT(!bg->ro); 4044195a49eaSFilipe Manana ASSERT(bg->swap_extents >= amount); 4045195a49eaSFilipe Manana bg->swap_extents -= amount; 4046195a49eaSFilipe Manana spin_unlock(&bg->lock); 4047195a49eaSFilipe Manana } 4048