btrfs: fix a lockdep_assert_locked() warning
cover btrfs: fix a lockdep_assert_locked() warning
Hello,
With discard=async we're hitting a lockdep_assert_locked() in generic/475 in our CI setup. This just popped up recently because before lockdep would get disabled before it got this far. This series fixes the problem, and then cleans up the cleanup functions to reduce the code and exported functions. Thanks,
Josef
Josef Bacik (2):
btrfs: call __btrfs_remove_free_space_cache_locked on cache load
failure
btrfs: remove use btrfs_remove_free_space_cache instead of variant
fs/btrfs/block-group.c | 2 +- fs/btrfs/free-space-cache.c | 53 ++++++++++++++----------------- fs/btrfs/free-space-cache.h | 1 - fs/btrfs/tests/btrfs-tests.c | 2 +- fs/btrfs/tests/free-space-tests.c | 22 ++++++------- 5 files changed, 37 insertions(+), 43 deletions(-)
Signature · 1 line
2.26.3
PATCH 1/2 btrfs: call __btrfs_remove_free_space_cache_locked on cache load failure
Now that lockdep is staying enabled through our entire CI runs I started seeing the following stack in generic/475
------------[ cut here ]------------ WARNING: CPU: 1 PID: 2171864 at fs/btrfs/discard.c:604 btrfs_discard_update_discardable+0x98/0xb0 CPU: 1 PID: 2171864 Comm: kworker/u4:0 Not tainted 5.19.0-rc8+ #789 Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.13.0-2.fc32 04/01/2014 Workqueue: btrfs-cache btrfs_work_helper RIP: 0010:btrfs_discard_update_discardable+0x98/0xb0 RSP: 0018:ffffb857c2f7bad0 EFLAGS: 00010246 RAX: 0000000000000000 RBX: ffff8c85c605c200 RCX: 0000000000000001 RDX: 0000000000000000 RSI: ffffffff86807c5b RDI: ffffffff868a831e RBP: ffff8c85c4c54000 R08: 0000000000000000 R09: 0000000000000000 R10: ffff8c85c66932f0 R11: 0000000000000001 R12: ffff8c85c3899010 R13: ffff8c85d5be4f40 R14: ffff8c85c4c54000 R15: ffff8c86114bfa80 FS: 0000000000000000(0000) GS:ffff8c863bd00000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007f2e7f168160 CR3: 000000010289a004 CR4: 0000000000370ee0 Call Trace: __btrfs_remove_free_space_cache+0x27/0x30 load_free_space_cache+0xad2/0xaf0 caching_thread+0x40b/0x650 ? lock_release+0x137/0x2d0 btrfs_work_helper+0xf2/0x3e0 ? lock_is_held_type+0xe2/0x140 process_one_work+0x271/0x590 ? process_one_work+0x590/0x590 worker_thread+0x52/0x3b0 ? process_one_work+0x590/0x590 kthread+0xf0/0x120 ? kthread_complete_and_exit+0x20/0x20 ret_from_fork+0x1f/0x30
This is the code
ctl = block_group->free_space_ctl;
discard_ctl = &block_group->fs_info->discard_ctl;
lockdep_assert_held(&ctl->tree_lock);We have a temporary free space ctl for loading the free space cache in order to avoid having allocations happening while we're loading the cache. When we hit an error we free it all up, however this also calls btrfs_discard_update_discardable, which requires block_group->free_space_ctl->tree_lock to be held. However this is our temporary ctl so this lock isn't held. Fix this by calling __btrfs_remove_free_space_cache_locked instead so that we only clean up the entries and do not mess with the discardable stats.
--- fs/btrfs/free-space-cache.c | 55 +++++++++++++++++++++++-------------- 1 file changed, 34 insertions(+), 21 deletions(-)
fs/btrfs/free-space-cache.c +34 -21
@@ -48,6 +48,25 @@ static void bitmap_clear_bits(struct btrfs_free_space_ctl *ctl, struct btrfs_free_space *info, u64 offset, u64 bytes, bool update_stats); +static void __btrfs_remove_free_space_cache_locked ( +struct btrfs_free_space_ctl *ctl) +{ +struct btrfs_free_space *info; +struct rb_node *node; + +while ((node =rb_last (&ctl->free_space_offset)) !=NULL ) { + info = rb_entry(node, struct btrfs_free_space, offset_index); +if (!info->bitmap) { +unlink_free_space (ctl, info, true); +kmem_cache_free (btrfs_free_space_cachep, info); + }else { +free_bitmap (ctl, info); + } + +cond_resched_lock (&ctl->tree_lock); + } +} +static struct inode *__lookup_free_space_inode (struct btrfs_root *root,struct btrfs_path *path,u64 offset)
@@ -878,7 +897,14 @@ static int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,return ret; free_cache:io_ctl_drop_pages (&io_ctl); -__btrfs_remove_free_space_cache (ctl); + +/* +* We need to call the _locked variant so we don't try to update the +* discard counters. +*/ +spin_lock (&ctl->tree_lock); +__btrfs_remove_free_space_cache_locked (ctl); +spin_unlock (&ctl->tree_lock); goto out; }
@@ -1014,7 +1040,13 @@ int load_free_space_cache(struct btrfs_block_group *block_group)if (ret ==0 ) ret =1 ; }else { -__btrfs_remove_free_space_cache (&tmp_ctl); +/* +* We need to call the _locked variant so we don't try to update +* the discard counters. +*/ +spin_lock (&ctl->tree_lock); +__btrfs_remove_free_space_cache_locked (&tmp_ctl); +spin_unlock (&ctl->tree_lock);btrfs_warn (fs_info,"block group %llu has wrong amount of free space" , block_group->start);
@@ -2978,25 +3010,6 @@ static void __btrfs_return_cluster_to_free_space(btrfs_put_block_group (block_group); } -static void __btrfs_remove_free_space_cache_locked ( -struct btrfs_free_space_ctl *ctl) -{ -struct btrfs_free_space *info; -struct rb_node *node; - -while ((node =rb_last (&ctl->free_space_offset)) !=NULL ) { - info = rb_entry(node, struct btrfs_free_space, offset_index); -if (!info->bitmap) { -unlink_free_space (ctl, info, true); -kmem_cache_free (btrfs_free_space_cachep, info); - }else { -free_bitmap (ctl, info); - } - -cond_resched_lock (&ctl->tree_lock); - } -} -void __btrfs_remove_free_space_cache (struct btrfs_free_space_ctl *ctl) {spin_lock (&ctl->tree_lock);
Signature · 1 line
2.26.3
PATCH 2/2 btrfs: remove use btrfs_remove_free_space_cache instead of variant
In reply to Josef BacikWe are calling __btrfs_remove_free_space_cache everywhere to cleanup the block group free space, however we can just use btrfs_remove_free_space_cache and pass in the block group in all of these places. Then we can remove __btrfs_remove_free_space_cache and rename __btrfs_remove_free_space_cache_locked to __btrfs_remove_free_space_cache.
--- fs/btrfs/block-group.c | 2 +- fs/btrfs/free-space-cache.c | 26 ++++---------------------- fs/btrfs/free-space-cache.h | 1 - fs/btrfs/tests/btrfs-tests.c | 2 +- fs/btrfs/tests/free-space-tests.c | 22 +++++++++++----------- 5 files changed, 17 insertions(+), 36 deletions(-)
fs/btrfs/block-group.c +1 -1
@@ -4132,7 +4132,7 @@ void btrfs_unfreeze_block_group(struct btrfs_block_group *block_group)* tasks trimming this block group have left 1 entry each one. * Free them if any. */ -__btrfs_remove_free_space_cache (block_group->free_space_ctl); +btrfs_remove_free_space_cache (block_group); } }
fs/btrfs/free-space-cache.c +4 -22
@@ -48,8 +48,7 @@ static void bitmap_clear_bits(struct btrfs_free_space_ctl *ctl, struct btrfs_free_space *info, u64 offset, u64 bytes, bool update_stats); -static void __btrfs_remove_free_space_cache_locked ( -struct btrfs_free_space_ctl *ctl) +static void __btrfs_remove_free_space_cache (struct btrfs_free_space_ctl *ctl) {struct btrfs_free_space *info;struct rb_node *node;
@@ -898,12 +897,8 @@ static int __load_free_space_cache(struct btrfs_root *root, struct inode *inode, free_cache:io_ctl_drop_pages (&io_ctl); -/* -* We need to call the _locked variant so we don't try to update the -* discard counters. -*/ spin_lock (&ctl->tree_lock); -__btrfs_remove_free_space_cache_locked (ctl); +__btrfs_remove_free_space_cache (ctl);spin_unlock (&ctl->tree_lock); goto out; }
@@ -1040,12 +1035,8 @@ int load_free_space_cache(struct btrfs_block_group *block_group)if (ret ==0 ) ret =1 ; }else { -/* -* We need to call the _locked variant so we don't try to update -* the discard counters. -*/ spin_lock (&ctl->tree_lock); -__btrfs_remove_free_space_cache_locked (&tmp_ctl); +__btrfs_remove_free_space_cache (&tmp_ctl);spin_unlock (&ctl->tree_lock); btrfs_warn(fs_info, "block group %llu has wrong amount of free space",
@@ -3010,15 +3001,6 @@ static void __btrfs_return_cluster_to_free_space(btrfs_put_block_group (block_group); } -void __btrfs_remove_free_space_cache (struct btrfs_free_space_ctl *ctl) -{ -spin_lock (&ctl->tree_lock); -__btrfs_remove_free_space_cache_locked (ctl); -if (ctl->block_group) -btrfs_discard_update_discardable (ctl->block_group); -spin_unlock (&ctl->tree_lock); -} -void btrfs_remove_free_space_cache (struct btrfs_block_group *block_group) {struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
@@ -3036,7 +3018,7 @@ void btrfs_remove_free_space_cache(struct btrfs_block_group *block_group)cond_resched_lock (&ctl->tree_lock); } -__btrfs_remove_free_space_cache_locked (ctl); +__btrfs_remove_free_space_cache (ctl);btrfs_discard_update_discardable (block_group);spin_unlock (&ctl->tree_lock);
fs/btrfs/free-space-cache.h +0 -1
@@ -113,7 +113,6 @@ int btrfs_add_free_space_async_trimmed(struct btrfs_block_group *block_group, u64 bytenr, u64 size);int btrfs_remove_free_space (struct btrfs_block_group *block_group,u64 bytenr,u64 size); -void __btrfs_remove_free_space_cache (struct btrfs_free_space_ctl *ctl);void btrfs_remove_free_space_cache (struct btrfs_block_group *block_group);bool btrfs_is_free_space_trimmed (struct btrfs_block_group *block_group); u64 btrfs_find_space_for_alloc(struct btrfs_block_group *block_group,
fs/btrfs/tests/btrfs-tests.c +1 -1
@@ -243,7 +243,7 @@ void btrfs_free_dummy_block_group(struct btrfs_block_group *cache) {if (!cache)return ; -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);kfree (cache->free_space_ctl);kfree (cache); }
fs/btrfs/tests/free-space-tests.c +11 -11
@@ -82,7 +82,7 @@ static int test_extents(struct btrfs_block_group *cache) }/* Cleanup */ -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);return 0 ; }
@@ -149,7 +149,7 @@ static int test_bitmaps(struct btrfs_block_group *cache, u32 sectorsize)return -1 ; } -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);return 0 ; }
@@ -230,7 +230,7 @@ static int test_bitmaps_and_extents(struct btrfs_block_group *cache,return -1 ; } -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);/* Now with the extent entry offset into the bitmap */ ret =test_add_free_space_entry (cache,SZ_4M ,SZ_4M ,1 );
@@ -266,7 +266,7 @@ static int test_bitmaps_and_extents(struct btrfs_block_group *cache,* [ bitmap ] * [ del ] */ -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache); ret =test_add_free_space_entry (cache, bitmap_offset +SZ_4M ,SZ_4M ,1 );if (ret) {test_err ("couldn't add bitmap %d" , ret);
@@ -291,7 +291,7 @@ static int test_bitmaps_and_extents(struct btrfs_block_group *cache,return -1 ; } -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);/* * This blew up before, we have part of the free space in a bitmap and
@@ -317,7 +317,7 @@ static int test_bitmaps_and_extents(struct btrfs_block_group *cache,return ret; } -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);return 0 ; }
@@ -629,7 +629,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group *cache,if (ret)return ret; -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);/* * Now test a similar scenario, but where our extent entry is located
@@ -819,7 +819,7 @@ test_steal_space_from_bitmap_to_extent(struct btrfs_block_group *cache,return ret; cache->free_space_ctl->op = orig_free_space_ops; -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);return 0 ; }
@@ -868,7 +868,7 @@ static int test_bytes_index(struct btrfs_block_group *cache, u32 sectorsize) }/* Now validate bitmaps do the correct thing. */ -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);for (i =0 ; i <2 ; i++) { offset = i *BITS_PER_BITMAP * sectorsize; bytes = (i +1 ) *SZ_1M ;
@@ -891,7 +891,7 @@ static int test_bytes_index(struct btrfs_block_group *cache, u32 sectorsize) }/* Now validate bitmaps with different ->max_extent_size. */ -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache); orig_free_space_ops = cache->free_space_ctl->op; cache->free_space_ctl->op = &test_free_space_ops;
@@ -998,7 +998,7 @@ static int test_bytes_index(struct btrfs_block_group *cache, u32 sectorsize) } cache->free_space_ctl->op = orig_free_space_ops; -__btrfs_remove_free_space_cache (cache->free_space_ctl); +btrfs_remove_free_space_cache (cache);return 0 ; }
Signature · 1 line
2.26.3
Re: [PATCH 1/2] btrfs: call __btrfs_remove_free_space_cache_locked on cache load failure
In reply to Josef Bacikfs/btrfs/free-space-cache.c static void bitmap_clear_bits(struct btrfs_free_space_ctl *ctl, · line 57
Quoted 7 lines · Josef Bacik
fs/btrfs/free-space-cache.c +7
-0+static void __btrfs_remove_free_space_cache_locked ( +struct btrfs_free_space_ctl *ctl) +{ +struct btrfs_free_space *info; +struct rb_node *node; + +while ((node =rb_last (&ctl->free_space_offset)) !=NULL ) {
Please use rbtree_postorder_for_each_entry_safe instead of the while/rb_next.
Quoted 11 lines
fs/btrfs/free-space-cache.c +11
-0+ info = rb_entry(node, struct btrfs_free_space, offset_index); +if (!info->bitmap) { +unlink_free_space (ctl, info, true); +kmem_cache_free (btrfs_free_space_cachep, info); + }else { +free_bitmap (ctl, info); + } + +cond_resched_lock (&ctl->tree_lock); + } +}
Quoted 8 lines · Josef Bacik
Hello,
With discard=async we're hitting a
lockdep_assert_locked()in generic/475 in our CI setup. This just popped up recently because before lockdep would get disabled before it got this far. This series fixes the problem, and then cleans up the cleanup functions to reduce the code and exported functions. Thanks,
Quoted 6 lines
Josef
Josef Bacik (2):
btrfs: call__btrfs_remove_free_space_cache_lockedon cache load
failure
btrfs: remove usebtrfs_remove_free_space_cacheinstead of variant
Moved from topic branch to misc-next, I haven't changed the loop iteration to the postorder macro, that can be done later.