1/2] block: fix race between set_blocksize and read paths
Subsystems (4)
RFC 1/1 1/2] block: fix race between set_blocksize and read paths
From: Darrick J. Wong <[email protected]>
With the new large sector size support, it's now the case that set_blocksize can change i_blksize and the folio order in a manner that conflicts with a concurrent reader and causes a kernel crash.
Specifically, let's say that udev-worker calls libblkid to detect the labels on a block device. The read call can create an order-0 folio to read the first 4096 bytes from the disk. But then udev is preempted.
Next, someone tries to mount an 8k-sectorsize filesystem from the same block device. The filesystem calls set_blksize, which sets i_blksize to 8192 and the minimum folio order to 1.
Now udev resumes, still holding the order-0 folio it allocated. It then tries to schedule a read bio and do_mpage_readahead tries to create bufferheads for the folio. Unfortunately, blocks_per_folio == 0 because the page size is 4096 but the blocksize is 8192 so no bufferheads are attached and the bh walk never sets bdev. We then submit the bio with a NULL block device and crash.
Therefore, truncate the page cache after flushing but before updating i_blksize. However, that's not enough -- we also need to lock out file IO and page faults during the update. Take both the i_rwsem and the invalidate_lock in exclusive mode for invalidations, and in shared mode for read/write operations.
I don't know if this is the correct fix, but xfs/259 found it.
--- block/bdev.c | 12 ++++++++++++ block/blk-zoned.c | 5 ++++- block/fops.c | 7 +++++++ block/ioctl.c | 6 ++++++ 4 files changed, 29 insertions(+), 1 deletion(-)
block/bdev.c +12 -0
@@ -169,11 +169,23 @@ int set_blocksize(struct file *file, int size)/* Don't change the size if it is same as current */ if (inode->i_blkbits !=blksize_bits (size)) { +/* Prevent concurrent IO operations */ +inode_lock (inode); +filemap_invalidate_lock (inode->i_mapping); + +/* +* Flush and truncate the pagecache before we reconfigure the +* mapping geometry because folio sizes are variable now. +*/ sync_blockdev (bdev); +kill_bdev (bdev); + inode->i_blkbits =blksize_bits (size);mapping_set_folio_order_range (inode->i_mapping,get_order (size),get_order (size));kill_bdev (bdev); +filemap_invalidate_unlock (inode->i_mapping); +inode_unlock (inode); }return 0 ; }
block/blk-zoned.c +4 -1
@@ -343,6 +343,7 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, blk_mode_t mode, op =REQ_OP_ZONE_RESET ;/* Invalidate the page cache, including dirty pages. */ +inode_lock (bdev->bd_mapping->host);filemap_invalidate_lock (bdev->bd_mapping); ret =blkdev_truncate_zone_range (bdev, mode, &zrange);if (ret)
@@ -364,8 +365,10 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, blk_mode_t mode, ret =blkdev_zone_mgmt (bdev, op, zrange.sector, zrange.nr_sectors); fail: -if (cmd ==BLKRESETZONE ) +if (cmd ==BLKRESETZONE ) {filemap_invalidate_unlock (bdev->bd_mapping); +inode_unlock (bdev->bd_mapping->host); + }return ret; }
block/fops.c +7 -0
@@ -746,7 +746,9 @@ static ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from) ret =direct_write_fallback (iocb, from, ret,blkdev_buffered_write (iocb, from)); }else { +inode_lock_shared (bd_inode); ret =blkdev_buffered_write (iocb, from); +inode_unlock_shared (bd_inode); }if (ret >0 )
@@ -757,6 +759,7 @@ static ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from)static ssize_t blkdev_read_iter (struct kiocb *iocb,struct iov_iter *to) { +struct inode *bd_inode =bdev_file_inode (iocb->ki_filp);struct block_device *bdev =I_BDEV (iocb->ki_filp->f_mapping->host);loff_t size =bdev_nr_bytes (bdev);loff_t pos = iocb->ki_pos;
@@ -793,7 +796,9 @@ static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to) goto reexpand; } +inode_lock_shared (bd_inode); ret =filemap_read (iocb, to, ret); +inode_unlock_shared (bd_inode); reexpand:if (unlikely (shorted))
@@ -836,6 +841,7 @@ static long blkdev_fallocate(struct file *file, int mode, loff_t start,if ((start | len) & (bdev_logical_block_size (bdev) -1 ))return -EINVAL ; +inode_lock (inode);filemap_invalidate_lock (inode->i_mapping);/*
@@ -868,6 +874,7 @@ static long blkdev_fallocate(struct file *file, int mode, loff_t start, fail:filemap_invalidate_unlock (inode->i_mapping); +inode_unlock (inode);return error; }
block/ioctl.c +6 -0
@@ -142,6 +142,7 @@ static int blk_ioctl_discard(struct block_device *bdev, blk_mode_t mode,if (err)return err; +inode_lock (bdev->bd_mapping->host);filemap_invalidate_lock (bdev->bd_mapping); err =truncate_bdev_range (bdev, mode, start, start + len -1 );if (err)
@@ -174,6 +175,7 @@ static int blk_ioctl_discard(struct block_device *bdev, blk_mode_t mode,blk_finish_plug (&plug); fail:filemap_invalidate_unlock (bdev->bd_mapping); +inode_unlock (bdev->bd_mapping->host);return err; }
@@ -199,12 +201,14 @@ static int blk_ioctl_secure_erase(struct block_device *bdev, blk_mode_t mode, end > bdev_nr_bytes(bdev))return -EINVAL ; +inode_lock (bdev->bd_mapping->host);filemap_invalidate_lock (bdev->bd_mapping); err =truncate_bdev_range (bdev, mode, start, end -1 );if (!err) err =blkdev_issue_secure_erase (bdev, start >>9 , len >>9 ,GFP_KERNEL );filemap_invalidate_unlock (bdev->bd_mapping); +inode_unlock (bdev->bd_mapping->host);return err; }
@@ -236,6 +240,7 @@ static int blk_ioctl_zeroout(struct block_device *bdev, blk_mode_t mode,return -EINVAL ;/* Invalidate the page cache, including dirty pages */ +inode_lock (bdev->bd_mapping->host);filemap_invalidate_lock (bdev->bd_mapping); err =truncate_bdev_range (bdev, mode, start, end);if (err)
@@ -246,6 +251,7 @@ static int blk_ioctl_zeroout(struct block_device *bdev, blk_mode_t mode, fail:filemap_invalidate_unlock (bdev->bd_mapping); +inode_unlock (bdev->bd_mapping->host);return err; }
[RF[CRAP] 2/2] xfs: stop using set_blocksize
From: Darrick J. Wong <[email protected]>
XFS has its own buffer cache for metadata that uses submit_bio, which means that it no longer uses the block device pagecache for anything. Create a more lightweight helper that runs the blocksize checks and flushes dirty data and use that instead. No more truncating the pagecache because why would XFS care? ;)
--- include/linux/blkdev.h | 1 + block/bdev.c | 23 +++++++++++++++++++++++ fs/xfs/xfs_buf.c | 9 ++++++--- 3 files changed, 30 insertions(+), 3 deletions(-)
include/linux/blkdev.h +1 -0
@@ -1618,6 +1618,7 @@ static inline void bio_end_io_acct(struct bio *bio, unsigned long start_time)return bio_end_io_acct_remapped (bio, start_time, bio->bi_bdev); } +int bdev_use_blocksize (struct file *file,int size);int set_blocksize (struct file *file,int size);int lookup_bdev (const char *pathname,dev_t *dev);
block/bdev.c +23 -0
@@ -152,6 +152,29 @@ static void set_init_blocksize(struct block_device *bdev) get_order(bsize), get_order(bsize)); } +/* +* For bdev filesystems that do not use buffer heads, check that this block +* size is acceptable and flush dirty pagecache to disk. +*/ +int bdev_use_blocksize (struct file *file,int size) +{ +struct inode *inode = file->f_mapping->host; +struct block_device *bdev =I_BDEV (inode); + +if (blk_validate_block_size (size)) +return -EINVAL ; + +/* Size cannot be smaller than the size supported by the device */ +if (size <bdev_logical_block_size (bdev)) +return -EINVAL ; + +if (!file->private_data) +return -EINVAL ; + +return sync_blockdev (bdev); +} +EXPORT_SYMBOL_GPL (bdev_use_blocksize); +int set_blocksize (struct file *file,int size) {struct inode *inode = file->f_mapping->host;
fs/xfs/xfs_buf.c +6 -3
@@ -1718,14 +1718,17 @@ xfs_setsize_buftarg(struct xfs_buftarg *btp, unsigned int sectorsize) { + int error; +/* Set up metadata sector size info */ btp->bt_meta_sectorsize = sectorsize; btp->bt_meta_sectormask = sectorsize -1 ; -if (set_blocksize (btp->bt_bdev_file, sectorsize)) { + error =bdev_use_blocksize (btp->bt_bdev_file, sectorsize); +if (error) {xfs_warn (btp->bt_mount, -"Cannot set_blocksize to %u on device %pg" , - sectorsize, btp->bt_bdev); +"Cannot use blocksize %u on device %pg, err %d" , + sectorsize, btp->bt_bdev, error);return -EINVAL ; }
Re: [RF[CRAP] 2/2] xfs: stop using set_blocksize
Quoted 4 lines · Darrick J. Wong
+/*
+ * For bdev filesystems that do not use buffer heads, check that this block
+ * size is acceptable and flush dirty pagecache to disk.
+ */
Can you turn this into a full fledged kerneldoc comment?
Quoted 4 lines
block/bdev.c +4
-0+int bdev_use_blocksize (struct file *file,int size) +{ +struct inode *inode = file->f_mapping->host; +struct block_device *bdev =I_BDEV (inode);
block/bdev.c static void set_init_blocksize(struct block_device *bdev) · line 172
Quoted 10 lines
block/bdev.c +10
-0+ +if (blk_validate_block_size (size)) +return -EINVAL ; + +/* Size cannot be smaller than the size supported by the device */ +if (size <bdev_logical_block_size (bdev)) +return -EINVAL ; + +if (!file->private_data) +return -EINVAL ;
This private_data check looks really confusing. Looking it up I see that it is directly copied from set_blocksize, but it could really use a comment. Or in fact be removed here and kept in set_blocksize
only as we don't care about an exclusive opener at all. Even there
a comment would be rather helpful, though.
block/bdev.c static void set_init_blocksize(struct block_device *bdev) · line 175
Quoted 3 lines
block/bdev.c +3
-0+ +return sync_blockdev (bdev); +}
I don't think we need sync_blockdev here as we don't touch the bdev page cache. Maybe XFS wants to still call it, but it feels wrong in a helper just validating the block size.
So maybe drop it, rename the helper to bdev_validate_block_size and use it in set_blocksize instead of duplicating the logic?
fs/xfs/xfs_buf.c xfs_setsize_buftarg( · line 1727
Quoted 1 line
fs/xfs/xfs_buf.c +1
-0+ error =bdev_use_blocksize (btp->bt_bdev_file, sectorsize);
.. and then split using it in XFS into a separate patch from adding the block layer helper.
Re: [RF[CRAP] 2/2] xfs: stop using set_blocksize
Quoted 7 lines · Christoph Hellwig
Quoted 4 lines · Darrick J. Wong
+/*
+ * For bdev filesystems that do not use buffer heads, check that this block
+ * size is acceptable and flush dirty pagecache to disk.
+ */Can you turn this into a full fledged kerneldoc comment?
Ok.
Quoted 12 lines
Quoted 12 lines
block/bdev.c +12
-0+int bdev_use_blocksize (struct file *file,int size) +{ +struct inode *inode = file->f_mapping->host; +struct block_device *bdev =I_BDEV (inode); + +if (blk_validate_block_size (size)) +return -EINVAL ; + +/* Size cannot be smaller than the size supported by the device */ +if (size <bdev_logical_block_size (bdev)) +return -EINVAL ; +
Quoted 8 lines
block/bdev.c static void set_init_blocksize(struct block_device *bdev) · line 172
Quoted 2 lines
block/bdev.c +2
-0+if (!file->private_data) +return -EINVAL ;This
private_datacheck looks really confusing. Looking it up I see that it is directly copied fromset_blocksize, but it could really use a comment. Or in fact be removed here and kept inset_blocksize
only as we don't care about an exclusive opener at all. Even there
a comment would be rather helpful, though.
When even is it null? I thought it would either be the holder or bdev_inode if not.
Quoted 10 lines
block/bdev.c static void set_init_blocksize(struct block_device *bdev) · line 175
Quoted 3 lines
block/bdev.c +3
-0+ +return sync_blockdev (bdev); +}I don't think we need
sync_blockdevhere as we don't touch the bdev page cache. Maybe XFS wants to still call it, but it feels wrong in a helper just validating the block size.So maybe drop it, rename the helper to
bdev_validate_block_sizeand use it inset_blocksizeinstead of duplicating the logic?
Ok. bdev_validate_block_size is a much better name for a tighter function...
Quoted 4 lines
fs/xfs/xfs_buf.c xfs_setsize_buftarg( · line 1727
Quoted 1 line
fs/xfs/xfs_buf.c +1
-0+ error =bdev_use_blocksize (btp->bt_bdev_file, sectorsize);.. and then split using it in XFS into a separate patch from adding the block layer helper.
...and xfs can call sync_blockdev directly from xfs_setsize_buftarg. I imagine we still want any dirty pagecache to get flushed before we start submitting our own read bios.
--D
Quoted 14 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
With the new large sector size support, it's now the case that
set_blocksizecan changei_blksizeand the folio order in a manner that conflicts with a concurrent reader and causes a kernel crash.Specifically, let's say that udev-worker calls libblkid to detect the labels on a block device. The read call can create an order-0 folio to read the first 4096 bytes from the disk. But then udev is preempted.
Next, someone tries to mount an 8k-sectorsize filesystem from the same block device. The filesystem calls
set_blksize, which setsi_blksizeto 8192 and the minimum folio order to 1.
Quoted 7 lines
Now udev resumes, still holding the order-0 folio it allocated. It then tries to schedule a read bio and
do_mpage_readaheadtries to create bufferheads for the folio. Unfortunately,blocks_per_folio== 0 because the page size is 4096 but the blocksize is 8192 so no bufferheads are attached and the bh walk never sets bdev. We then submit the bio with a NULL block device and crash.
Do we have a testcase for blktests or xfstests for this? The issue is subtle and some of the code in the patch looks easy to accidentally break again (not the fault of this patch primarily).
block/fops.c static ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 751
Quoted 4 lines
block/fops.c +2
-0}else { +inode_lock_shared (bd_inode); ret =blkdev_buffered_write (iocb, from); +inode_unlock_shared (bd_inode);
Does this need a comment why we take i_rwsem?
block/fops.c static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 801
Quoted 3 lines
block/fops.c +2
-0+inode_lock_shared (bd_inode); ret =filemap_read (iocb, to, ret); +inode_unlock_shared (bd_inode);
Same here. Especially as the protection is now heavier than for most file systems.
I also wonder if we need locking asserts in some of the write side functions that expect the shared inode lock and invalidate lock now?
Quoted 23 lines · Christoph Hellwig
Quoted 14 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
With the new large sector size support, it's now the case that
set_blocksizecan changei_blksizeand the folio order in a manner that conflicts with a concurrent reader and causes a kernel crash.Specifically, let's say that udev-worker calls libblkid to detect the labels on a block device. The read call can create an order-0 folio to read the first 4096 bytes from the disk. But then udev is preempted.
Next, someone tries to mount an 8k-sectorsize filesystem from the same block device. The filesystem calls
set_blksize, which setsi_blksizeto 8192 and the minimum folio order to 1.Quoted 7 lines
Now udev resumes, still holding the order-0 folio it allocated. It then tries to schedule a read bio and
do_mpage_readaheadtries to create bufferheads for the folio. Unfortunately,blocks_per_folio== 0 because the page size is 4096 but the blocksize is 8192 so no bufferheads are attached and the bh walk never sets bdev. We then submit the bio with a NULL block device and crash.
Quoted 3 lines
Do we have a testcase for blktests or xfstests for this? The issue is subtle and some of the code in the patch looks easy to accidentally break again (not the fault of this patch primarily).
It's the same patch as:
https://lore.kernel.org/linux-fsdevel/20250408175125.GL6266@frogsfrogsfrogs/
which is to say, xfs/032 with while true; do blkid; done running in the background to increase the chances of a collision.
Quoted 7 lines
block/fops.c static ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 751
Quoted 4 lines
block/fops.c +2
-0}else { +inode_lock_shared (bd_inode); ret =blkdev_buffered_write (iocb, from); +inode_unlock_shared (bd_inode);Does this need a comment why we take
i_rwsem?
Quoted 6 lines
block/fops.c static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 801
Quoted 3 lines
block/fops.c +2
-0+inode_lock_shared (bd_inode); ret =filemap_read (iocb, to, ret); +inode_unlock_shared (bd_inode);Same here. Especially as the protection is now heavier than for most file systems.
Yeah, somewhere we need a better comment. How about this for set_blocksize:
/*
* Flush and truncate the pagecache before we reconfigure the
* mapping geometry because folio sizes are variable now. If
* a reader has already allocated a folio whose size is smaller
* than the new min_order but invokes readahead after the new
* min_order becomes visible, readahead will think there are
* "zero" blocks per folio and crash.
*/
And then the read/write paths can say something simpler:
/* * Take i_rwsem and invalidate_lock to avoid racing with a * blocksize change punching out the pagecache. */
Quoted 2 lines
I also wonder if we need locking asserts in some of the write side functions that expect the shared inode lock and invalidate lock now?
Probably. Do you have specific places in mind?
--D
Quoted 5 lines · Darrick J. Wong
It's the same patch as:
https://lore.kernel.org/linux-fsdevel/20250408175125.GL6266@frogsfrogsfrogs/which is to say, xfs/032 with while true; do blkid; done running in the background to increase the chances of a collision.
I think the xfs-zoned CI actually hit this with 032 without any extra action the.
Quoted 9 lines
/*
* Flush and truncate the pagecache before we reconfigure the
* mapping geometry because folio sizes are variable now. If
* a reader has already allocated a folio whose size is smaller
* than the newmin_orderbut invokes readahead after the new
*min_orderbecomes visible, readahead will think there are
* "zero" blocks per folio and crash.
*/
Quoted 6 lines
And then the read/write paths can say something simpler:
/* * Take i_rwsem and invalidate_lock to avoid racing with a * blocksize change punching out the pagecache. */
Sounds reasonable.
Quoted 4 lines
Quoted 2 lines
I also wonder if we need locking asserts in some of the write side functions that expect the shared inode lock and invalidate lock now?
Probably. Do you have specific places in mind?
Looking at it more closely: no. We're only calling very low-level helpers, so this might not actually be feasible.
Quoted 9 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
It's the same patch as:
https://lore.kernel.org/linux-fsdevel/20250408175125.GL6266@frogsfrogsfrogs/which is to say, xfs/032 with while true; do blkid; done running in the background to increase the chances of a collision.
I think the xfs-zoned CI actually hit this with 032 without any extra action the.
I observed xfs/032 hanged using the kernel on linux-xfs/for-next branch with git hash 71700ac47ad8. Before the hang, kernel reported the messages below:
Oops: general protection fault, probably for non-canonical address 0xdffffc0000000001: 0000 [#1] SMP KASAN NOPTI KASAN: null-ptr-deref in range [0x0000000000000008-0x000000000000000f] CPU: 21 UID: 0 PID: 3187783 Comm: (udev-worker) Not tainted 6.15.0-rc1-kts-xfs-g71700ac47ad+ #1 PREEMPT(lazy) Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-3.fc41 04/01/2014 RIP: 0010:guard_bio_eod+0x52/0x5b0
The failure was recreated in stable manner. I applied this patch series, and confirmed the failure disappears. Good. (I needed to resolve conflicts, though)
This patch fixes block layer. So, IMO, it's the better to have a test case in blktests to confirm the fix. I created a blktests test case which recreates the failure using blockdev and fio commands. Will post it soon.
Quoted 20 lines · Shinichiro Kawasaki
Quoted 9 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
It's the same patch as:
https://lore.kernel.org/linux-fsdevel/20250408175125.GL6266@frogsfrogsfrogs/which is to say, xfs/032 with while true; do blkid; done running in the background to increase the chances of a collision.
I think the xfs-zoned CI actually hit this with 032 without any extra action the.
I observed xfs/032 hanged using the kernel on linux-xfs/for-next branch with git hash
71700ac47ad8. Before the hang, kernel reported the messages below:Oops: general protection fault, probably for non-canonical address 0xdffffc0000000001: 0000 [#1] SMP KASAN NOPTI KASAN: null-ptr-deref in range [0x0000000000000008-0x000000000000000f] CPU: 21 UID: 0 PID: 3187783 Comm: (udev-worker) Not tainted 6.15.0-rc1-kts-xfs-g71700ac47ad+ #1 PREEMPT(lazy) Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.3-3.fc41 04/01/2014 RIP: 0010:guard_bio_eod+0x52/0x5b0
Quoted 6 lines
The failure was recreated in stable manner. I applied this patch series, and confirmed the failure disappears. Good. (I needed to resolve conflicts, though)
This patch fixes block layer. So, IMO, it's the better to have a test case in blktests to confirm the fix. I created a blktests test case which recreates the failure using blockdev and fio commands. Will post it soon.
Ok. I'll post a non-rfcrap version of the series shortly. Thank you for writing a regression test! :)
--D