Commit 7deea563 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'block-6.15-20250424' of git://git.kernel.dk/linux 

Pull block fixes from Jens Axboe:

 - Fix autoloading of drivers from stat*(2)

 - Fix losing read-ahead setting one suspend/resume, when a device is
   re-probed.

 - Fix race between setting the block size and page cache updates.
   Includes a helper that a coming XFS fix will use as well.

 - ublk cancelation fixes.

 - ublk selftest additions and fixes.

 - NVMe pull via Christoph:
      - fix an out-of-bounds access in nvmet_enable_port (Richard
        Weinberger)

* tag 'block-6.15-20250424' of git://git.kernel.dk/linux:
  ublk: fix race between io_uring_cmd_complete_in_task and ublk_cancel_cmd
  ublk: call ublk_dispatch_req() for handling UBLK_U_IO_NEED_GET_DATA
  block: don't autoload drivers on blk-cgroup configuration
  block: don't autoload drivers on stat
  block: remove the backing_inode variable in bdev_statx
  block: move blkdev_{get,put} _no_open prototypes out of blkdev.h
  block: never reduce ra_pages in blk_apply_bdi_limits
  selftests: ublk: common: fix _get_disk_dev_t for pre-9.0 coreutils
  selftests: ublk: remove useless 'delay_us' from 'struct dev_ctx'
  selftests: ublk: fix recover test
  block: hoist block size validation code to a separate function
  block: fix race between set_blocksize and read paths
  nvmet: fix out-of-bounds access in nvmet_enable_port
parents 0537fbb6 f40139fd

block/bdev.c

+51 −16
Original line number Diff line number Diff line
@@ -152,27 +152,65 @@ static void set_init_blocksize(struct block_device *bdev) 
				    get_order(bsize));

}



int set_blocksize(struct file *file, int size)

/**

 * bdev_validate_blocksize - check that this block size is acceptable

 * @bdev:	blockdevice to check

 * @block_size:	block size to check

 *

 * For block device users that do not use buffer heads or the block device

 * page cache, make sure that this block size can be used with the device.

 *

 * Return: On success zero is returned, negative error code on failure.

 */

int bdev_validate_blocksize(struct block_device *bdev, int block_size)

{

	struct inode *inode = file->f_mapping->host;

	struct block_device *bdev = I_BDEV(inode);



	if (blk_validate_block_size(size))

	if (blk_validate_block_size(block_size))

		return -EINVAL;



	/* Size cannot be smaller than the size supported by the device */

	if (size < bdev_logical_block_size(bdev))

	if (block_size < bdev_logical_block_size(bdev))

		return -EINVAL;



	return 0;

}

EXPORT_SYMBOL_GPL(bdev_validate_blocksize);



int set_blocksize(struct file *file, int size)

{

	struct inode *inode = file->f_mapping->host;

	struct block_device *bdev = I_BDEV(inode);

	int ret;



	ret = bdev_validate_blocksize(bdev, size);

	if (ret)

		return ret;



	if (!file->private_data)

		return -EINVAL;



	/* Don't change the size if it is same as current */

	if (inode->i_blkbits != blksize_bits(size)) {

		/*

		 * 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.  Take the inode and

		 * invalidation locks to avoid racing with

		 * read/write/fallocate.

		 */

		inode_lock(inode);

		filemap_invalidate_lock(inode->i_mapping);



		sync_blockdev(bdev);

		kill_bdev(bdev);



		inode->i_blkbits = blksize_bits(size);

		mapping_set_folio_min_order(inode->i_mapping, get_order(size));

		kill_bdev(bdev);

		filemap_invalidate_unlock(inode->i_mapping);

		inode_unlock(inode);

	}

	return 0;

}
@@ -777,13 +815,13 @@ static void blkdev_put_part(struct block_device *part) 
	blkdev_put_whole(whole);

}



struct block_device *blkdev_get_no_open(dev_t dev)

struct block_device *blkdev_get_no_open(dev_t dev, bool autoload)

{

	struct block_device *bdev;

	struct inode *inode;



	inode = ilookup(blockdev_superblock, dev);

	if (!inode && IS_ENABLED(CONFIG_BLOCK_LEGACY_AUTOLOAD)) {

	if (!inode && autoload && IS_ENABLED(CONFIG_BLOCK_LEGACY_AUTOLOAD)) {

		blk_request_module(dev);

		inode = ilookup(blockdev_superblock, dev);

		if (inode)
@@ -1005,7 +1043,7 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder, 
	if (ret)

		return ERR_PTR(ret);



	bdev = blkdev_get_no_open(dev);

	bdev = blkdev_get_no_open(dev, true);

	if (!bdev)

		return ERR_PTR(-ENXIO);
@@ -1274,18 +1312,15 @@ void sync_bdevs(bool wait) 
 */

void bdev_statx(const struct path *path, struct kstat *stat, u32 request_mask)

{

	struct inode *backing_inode;

	struct block_device *bdev;



	backing_inode = d_backing_inode(path->dentry);



	/*

	 * Note that backing_inode is the inode of a block device node file,

	 * not the block device's internal inode.  Therefore it is *not* valid

	 * to use I_BDEV() here; the block device has to be looked up by i_rdev

	 * Note that d_backing_inode() returns the block device node inode, not

	 * the block device's internal inode.  Therefore it is *not* valid to

	 * use I_BDEV() here; the block device has to be looked up by i_rdev

	 * instead.

	 */

	bdev = blkdev_get_no_open(backing_inode->i_rdev);

	bdev = blkdev_get_no_open(d_backing_inode(path->dentry)->i_rdev, false);

	if (!bdev)

		return;

block/blk-cgroup.c

+1 −1
Original line number Diff line number Diff line
@@ -797,7 +797,7 @@ int blkg_conf_open_bdev(struct blkg_conf_ctx *ctx) 
		return -EINVAL;

	input = skip_spaces(input);



	bdev = blkdev_get_no_open(MKDEV(major, minor));

	bdev = blkdev_get_no_open(MKDEV(major, minor), false);

	if (!bdev)

		return -ENODEV;

	if (bdev_is_partition(bdev)) {

block/blk-settings.c

+7 −1
Original line number Diff line number Diff line
@@ -61,8 +61,14 @@ void blk_apply_bdi_limits(struct backing_dev_info *bdi, 
	/*

	 * For read-ahead of large files to be effective, we need to read ahead

	 * at least twice the optimal I/O size.

	 *

	 * There is no hardware limitation for the read-ahead size and the user

	 * might have increased the read-ahead size through sysfs, so don't ever

	 * decrease it.

	 */

	bdi->ra_pages = max(lim->io_opt * 2 / PAGE_SIZE, VM_READAHEAD_PAGES);

	bdi->ra_pages = max3(bdi->ra_pages,

				lim->io_opt * 2 / PAGE_SIZE,

				VM_READAHEAD_PAGES);

	bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT;

}

block/blk-zoned.c

+4 −1
Original line number Diff line number Diff line
@@ -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/blk.h

+3 −0
Original line number Diff line number Diff line
@@ -94,6 +94,9 @@ static inline void blk_wait_io(struct completion *done) 
		wait_for_completion_io(done);

}



struct block_device *blkdev_get_no_open(dev_t dev, bool autoload);

void blkdev_put_no_open(struct block_device *bdev);



#define BIO_INLINE_VECS 4

struct bio_vec *bvec_alloc(mempool_t *pool, unsigned short *nr_vecs,

		gfp_t gfp_mask);