btrfs: enhance BTRFS_ORDERED_* flags sanity checks
PATCH v2 1/2 btrfs: check type flags in alloc_ordered_extent()
In reply to Qu WenruoUnlike other flags used in btrfs, BTRFS_ORDERED_* macros are different as they can not be directly used as flags.
They are defined as bit numbers, thus they should be utilized with bit operations, not directly with logical operations.
Unfortunately sometimes I forgot this and can pass the incorrect flags to alloc_ordered_extent() and hit weird bugs.
Enhance the type checks in alloc_ordered_extent() by:
- Make sure there is one and only one bit set for exclusive type flags There are four exclusive type flags, REGULAR, NOCOW, PREALLOC and COMPRESSED.
So introduce a new macro, BTRFS_ORDERED_EXCLUSIVE_FLAGS, to cover above flags.
And add an ASSERT() to check one and only one of those exclusive flags can be set for alloc_ordered_extent().
- Re-order the type bit numbers to the end of the enum This is make it much harder to get a valid false negative.
E.g, with the old BTRFS_ORDERED_REGULAR starts at zero, we can have the following flags passing the weight check:
* BTRFS_ORDERED_NOCOW
Be treated as BTRFS_ORDERED_REGULAR (1 == 1UL << 0).
* BTRFS_ORDERED_PREALLOC
Be treated as BTRFS_ORDERED_NOCOW (2 == 1UL << 1).
* BTRFS_ORDERED_DIRECT
Be treated as BTRFS_ORDERED_PREALLOC (4 == 1UL << 2).
Now all those types starts at 8, passing any of those bit numbers as flags directly will not pass the ASSERT().
- Add a static assert to avoid overflow
To make sure all BTRFS_ORDERED_* flags can fit into an unsigned long.
--- fs/btrfs/ordered-data.c | 13 ++++++++++ fs/btrfs/ordered-data.h | 55 +++++++++++++++++++++++------------------ 2 files changed, 44 insertions(+), 24 deletions(-)
fs/btrfs/ordered-data.c +13 -0
@@ -156,6 +156,19 @@ static struct btrfs_ordered_extent *alloc_ordered_extent(const bool is_nocow = (flags & ((1U <<BTRFS_ORDERED_NOCOW ) | (1U <<BTRFS_ORDERED_PREALLOC ))); +/* Only one type flag can be set. */ +ASSERT (has_single_bit_set (flags &BTRFS_ORDERED_EXCLUSIVE_FLAGS )); + +/* DIRECT cannot be set with COMPRESSED nor ENCODED. */ +if (test_bit (BTRFS_ORDERED_DIRECT , &flags)) { +ASSERT (!test_bit (BTRFS_ORDERED_COMPRESSED , &flags)); +ASSERT (!test_bit (BTRFS_ORDERED_ENCODED , &flags)); + } + +/* ENCODED must be set with COMPRESSED. */ +if (test_bit (BTRFS_ORDERED_ENCODED , &flags)) +ASSERT (test_bit (BTRFS_ORDERED_COMPRESSED , &flags)); +/* * For a NOCOW write we can free the qgroup reserve right now. For a COW * one we transfer the reserved space from the inode's iotree into the
fs/btrfs/ordered-data.h +31 -24
76 lines not on this page · raw message
Signature · 1 line
2.53.0
v2 cover btrfs: enhance BTRFS_ORDERED_* flags sanity checks
[CHANGELOG]
v2:
- Minor grammar fixes
- Change the output message when overlapping OEs are found
- Use has_single_bit_set() to replace hweight*()
During my development of introduce a new DELAYED type, I incorrectly called something like:
oe = alloc_ordered_extent(.., BTRFS_ORDERED_DELAYED, ..);
That doesn't trigger any warning at runtime, but will cause unexpected bugs due to the fact that, BTRFS_ORDERED_* can not be directly used as a flag. They are only bit numbers, thus should be utilized with bit operations like "test_bit(BTRFS_ORDERED_DELAYED, ..)".
My stupid bug inspired me to enhance the @flags sanity checks in alloc_ordered_extent().
The first one is to make sure that my stupid bug can always be caught early.
The second one is to enhance the error message when a duplicated OE is found during insert_ordered_extent().
Qu Wenruo (2):
btrfs: check type flags in alloc_ordered_extent()
btrfs: output more info when duplicated ordered extent is found
fs/btrfs/ordered-data.c | 24 +++++++++++++++--- fs/btrfs/ordered-data.h | 55 +++++++++++++++++++++++------------------ 2 files changed, 52 insertions(+), 27 deletions(-)
Signature · 1 line
2.53.0
PATCH v2 2/2 btrfs: output more info when duplicated ordered extent is found
During development of a new feature, I triggered that btrfs_panic() inside insert_ordered_extent() and spent quite some unnecessary before noticing I'm passing incorrect flags when creating a new ordered extent.
Unfortunately the existing error message is not providing much help.
Enhance the output to provide file offset, num bytes and flags of both existing and new ordered extents.
--- fs/btrfs/ordered-data.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
fs/btrfs/ordered-data.c +8 -3
@@ -253,10 +253,15 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)spin_lock (&inode->ordered_tree_lock); node =tree_insert (&inode->ordered_tree, entry->file_offset, &entry->rb_node); -if (unlikely (node)) +if (unlikely (node)) { +struct btrfs_ordered_extent *exist = + rb_entry(node, struct btrfs_ordered_extent, rb_node); +btrfs_panic (fs_info, -EEXIST , -"inconsistency in ordered tree at offset %llu" , - entry->file_offset); +"overlapping ordered extents, existing oe file_offset %llu num_bytes %llu flags 0x%lx, new oe file_offset %llu num_bytes %llu flags 0x%lx" , + exist->file_offset, exist->num_bytes, exist->flags, + entry->file_offset, entry->num_bytes, entry->flags); + }spin_unlock (&inode->ordered_tree_lock);spin_lock (&root->ordered_extent_lock);
Signature · 1 line
2.53.0
Quoted 23 lines · Qu Wenruo
[CHANGELOG]
v2:
- Minor grammar fixes
- Change the output message when overlapping OEs are found
- Usehas_single_bit_set()to replace hweight*()During my development of introduce a new DELAYED type, I incorrectly called something like:
oe = alloc_ordered_extent(.., BTRFS_ORDERED_DELAYED, ..);That doesn't trigger any warning at runtime, but will cause unexpected bugs due to the fact that, BTRFS_ORDERED_* can not be directly used as a flag. They are only bit numbers, thus should be utilized with bit operations like "
test_bit(BTRFS_ORDERED_DELAYED, ..)".My stupid bug inspired me to enhance the @flags sanity checks in
alloc_ordered_extent().The first one is to make sure that my stupid bug can always be caught early.
Quoted 6 lines
The second one is to enhance the error message when a duplicated OE is found during
insert_ordered_extent().Qu Wenruo (2):
btrfs: check type flags inalloc_ordered_extent()
btrfs: output more info when duplicated ordered extent is found