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

Linus Torvalds committed 1 year ago

Commit 7deea562 parents 0537fbb f40139f14 files · +121 −47Browse files

Unified · Split

14 files

block/bdev.c +51 −16
block/blk-cgroup.c +1 −1
block/blk-settings.c +7 −1
block/blk-zoned.c +4 −1
block/blk.h +3 −0
block/fops.c +17 −1
block/ioctl.c +6 −0
drivers/block/ublk_drv.c +24 −17
drivers/nvme/target/core.c +3 −0
include/linux/blkdev.h +1 −4
tools/testing/selftests/ublk/kublk.c +1 −0
tools/testing/selftests/ublk/kublk.h +0 −3
tools/testing/selftests/ublk/test_common.sh +2 −2
tools/testing/selftests/ublk/test_generic_05.sh +1 −1

block/bdev.c+51−16

 				    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;
+	if (blk_validate_block_size(block_size))
-	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))
+	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;
 }
 	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)
 	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);
  */
 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,
+	 * Note that d_backing_inode() returns the block device node inode, not
-	 * not the block device's internal inode.  Therefore it is *not* valid
+	 * the block device's internal inode.  Therefore it is *not* valid to
-	 * to use I_BDEV() here; the block device has to be looked up by i_rdev
+	 * 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

@@ -797,7 +797,7 @@ int blkg_conf_open_bdev(struct blkg_conf_ctx *ctx) · 796 unmodified lines
797	return -EINVAL;	797	return -EINVAL;
798	input = skip_spaces(input);	798	input = skip_spaces(input);
799		799
800	bdev = blkdev_get_no_open(MKDEV(major, minor));	800	bdev = blkdev_get_no_open(MKDEV(major, minor), false);
801	if (!bdev)	801	if (!bdev)
802	return -ENODEV;	802	return -ENODEV;
803	if (bdev_is_partition(bdev)) {	803	if (bdev_is_partition(bdev)) {

block/blk-settings.c+7−1

 	/*
 	 * 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

 		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)
 	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

@@ -94,6 +94,9 @@ static inline void blk_wait_io(struct completion *done) · 93 unmodified lines
94	wait_for_completion_io(done);	94	wait_for_completion_io(done);
95	}	95	}
96		96
		97	struct block_device *blkdev_get_no_open(dev_t dev, bool autoload);
		98	void blkdev_put_no_open(struct block_device *bdev);
		99
97	#define BIO_INLINE_VECS 4	100	#define BIO_INLINE_VECS 4
98	struct bio_vec bvec_alloc(mempool_t pool, unsigned short *nr_vecs,	101	struct bio_vec bvec_alloc(mempool_t pool, unsigned short *nr_vecs,
99	gfp_t gfp_mask);	102	gfp_t gfp_mask);

block/fops.c+17−1

 	if (ret)
 		return ret;
-	bdev = blkdev_get_no_open(inode->i_rdev);
+	bdev = blkdev_get_no_open(inode->i_rdev, true);
 	if (!bdev)
 		return -ENXIO;
 			ret = direct_write_fallback(iocb, from, ret,
 					blkdev_buffered_write(iocb, from));
 	} else {
+		/*
+		 * Take i_rwsem and invalidate_lock to avoid racing with
+		 * set_blocksize changing i_blkbits/folio order and punching
+		 * out the pagecache.
+		 */
+		inode_lock_shared(bd_inode);
 		ret = blkdev_buffered_write(iocb, from);
+		inode_unlock_shared(bd_inode);
 	}
 	if (ret > 0)
 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;
 			goto reexpand;
 	}
+	/*
+	 * Take i_rwsem and invalidate_lock to avoid racing with set_blocksize
+	 * changing i_blkbits/folio order and punching out the pagecache.
+	 */
+	inode_lock_shared(bd_inode);
 	ret = filemap_read(iocb, to, ret);
+	inode_unlock_shared(bd_inode);
 reexpand:
 	if (unlikely(shorted))
 	if ((start | len) & (bdev_logical_block_size(bdev) - 1))
 		return -EINVAL;
+	inode_lock(inode);
 	filemap_invalidate_lock(inode->i_mapping);
 	/*
  fail:
 	filemap_invalidate_unlock(inode->i_mapping);
+	inode_unlock(inode);
 	return error;
 }

block/ioctl.c+6−0

 	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)
 	blk_finish_plug(&plug);
 fail:
 	filemap_invalidate_unlock(bdev->bd_mapping);
+	inode_unlock(bdev->bd_mapping->host);
 	return err;
 }
 	    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;
 }
 		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)
 fail:
 	filemap_invalidate_unlock(bdev->bd_mapping);
+	inode_unlock(bdev->bd_mapping->host);
 	return err;
 }

drivers/block/ublk_drv.c+24−17

 	ublk_put_disk(disk);
 }
-static void ublk_cancel_cmd(struct ublk_queue *ubq, struct ublk_io *io,
+static void ublk_cancel_cmd(struct ublk_queue *ubq, unsigned tag,
 		unsigned int issue_flags)
 {
+	struct ublk_io *io = &ubq->ios[tag];
+	struct ublk_device *ub = ubq->dev;
+	struct request *req;
 	bool done;
 	if (!(io->flags & UBLK_IO_FLAG_ACTIVE))
 		return;
+	/*
+	 * Don't try to cancel this command if the request is started for
+	 * avoiding race between io_uring_cmd_done() and
+	 * io_uring_cmd_complete_in_task().
+	 *
+	 * Either the started request will be aborted via __ublk_abort_rq(),
+	 * then this uring_cmd is canceled next time, or it will be done in
+	 * task work function ublk_dispatch_req() because io_uring guarantees
+	 * that ublk_dispatch_req() is always called
+	 */
+	req = blk_mq_tag_to_rq(ub->tag_set.tags[ubq->q_id], tag);
+	if (req && blk_mq_request_started(req))
+		return;
 	spin_lock(&ubq->cancel_lock);
 	done = !!(io->flags & UBLK_IO_FLAG_CANCELED);
 	if (!done)
 	struct ublk_uring_cmd_pdu *pdu = ublk_get_uring_cmd_pdu(cmd);
 	struct ublk_queue *ubq = pdu->ubq;
 	struct task_struct *task;
-	struct ublk_io *io;
 	if (WARN_ON_ONCE(!ubq))
 		return;
 	if (!ubq->canceling)
 		ublk_start_cancel(ubq);
-	io = &ubq->ios[pdu->tag];
+	WARN_ON_ONCE(ubq->ios[pdu->tag].cmd != cmd);
-	WARN_ON_ONCE(io->cmd != cmd);
+	ublk_cancel_cmd(ubq, pdu->tag, issue_flags);
-	ublk_cancel_cmd(ubq, io, issue_flags);
 }
 static inline bool ublk_queue_ready(struct ublk_queue *ubq)
 	int i;
 	for (i = 0; i < ubq->q_depth; i++)
-		ublk_cancel_cmd(ubq, &ubq->ios[i], IO_URING_F_UNLOCKED);
+		ublk_cancel_cmd(ubq, i, IO_URING_F_UNLOCKED);
 }
 /* Cancel all pending commands, must be called after del_gendisk() returns */
 	}
 }
-static void ublk_handle_need_get_data(struct ublk_device *ub, int q_id,
-		int tag)
-{
-	struct ublk_queue *ubq = ublk_get_queue(ub, q_id);
-	struct request *req = blk_mq_tag_to_rq(ub->tag_set.tags[q_id], tag);
-	ublk_queue_cmd(ubq, req);
-}
 static inline int ublk_check_cmd_op(u32 cmd_op)
 {
 	u32 ioc_type = _IOC_TYPE(cmd_op);
 		if (!(io->flags & UBLK_IO_FLAG_OWNED_BY_SRV))
 			goto out;
 		ublk_fill_io_cmd(io, cmd, ub_cmd->addr);
-		ublk_handle_need_get_data(ub, ub_cmd->q_id, ub_cmd->tag);
+		req = blk_mq_tag_to_rq(ub->tag_set.tags[ub_cmd->q_id], tag);
-		break;
+		ublk_dispatch_req(ubq, req, issue_flags);
+		return -EIOCBQUEUED;
 	default:
 		goto out;
 	}

drivers/nvme/target/core.c+3−0

@@ -324,6 +324,9 @@ int nvmet_enable_port(struct nvmet_port *port) · 323 unmodified lines
324		324
325	lockdep_assert_held(&nvmet_config_sem);	325	lockdep_assert_held(&nvmet_config_sem);
326		326
		327	if (port->disc_addr.trtype == NVMF_TRTYPE_MAX)
		328	return -EINVAL;
		329
327	ops = nvmet_transports[port->disc_addr.trtype];	330	ops = nvmet_transports[port->disc_addr.trtype];
328	if (!ops) {	331	if (!ops) {
329	up_write(&nvmet_config_sem);	332	up_write(&nvmet_config_sem);

include/linux/blkdev.h+1−4

 	return bio_end_io_acct_remapped(bio, start_time, bio->bi_bdev);
 }
+int bdev_validate_blocksize(struct block_device *bdev, int block_size);
 int set_blocksize(struct file *file, int size);
 int lookup_bdev(const char *pathname, dev_t *dev);
 		const struct blk_holder_ops *hops);
 void bd_abort_claiming(struct block_device *bdev, void *holder);
-/* just for blk-cgroup, don't use elsewhere */
-struct block_device *blkdev_get_no_open(dev_t dev);
-void blkdev_put_no_open(struct block_device *bdev);
 struct block_device *I_BDEV(struct inode *inode);
 struct block_device *file_bdev(struct file *bdev_file);
 bool disk_live(struct gendisk *disk);

tools/testing/selftests/ublk/kublk.c+1−0

@@ -1354,6 +1354,7 @@ int main(int argc, char *argv[]) · 1353 unmodified lines
1354	value = strtol(optarg, NULL, 10);	1354	value = strtol(optarg, NULL, 10);
1355	if (value)	1355	if (value)
1356	ctx.flags \|= UBLK_F_NEED_GET_DATA;	1356	ctx.flags \|= UBLK_F_NEED_GET_DATA;
		1357	break;
1357	case 0:	1358	case 0:
1358	if (!strcmp(longopts[option_idx].name, "debug_mask"))	1359	if (!strcmp(longopts[option_idx].name, "debug_mask"))
1359	ublk_dbg_mask = strtol(optarg, NULL, 16);	1360	ublk_dbg_mask = strtol(optarg, NULL, 16);

tools/testing/selftests/ublk/kublk.h+0−3

@@ -86,9 +86,6 @@ struct dev_ctx { · 85 unmodified lines
86	unsigned int fg:1;	86	unsigned int fg:1;
87	unsigned int recovery:1;	87	unsigned int recovery:1;
88		88
89	/* fault_inject */
90	long long delay_us;
91
92	int _evtfd;	89	int _evtfd;
93	int _shmid;	90	int _shmid;
94		91

tools/testing/selftests/ublk/test_common.sh+2−2

@@ -17,8 +17,8 @@ _get_disk_dev_t() { · 16 unmodified lines
17	local minor	17	local minor
18		18
19	dev=/dev/ublkb"${dev_id}"	19	dev=/dev/ublkb"${dev_id}"
20	major=$(stat -c '%Hr' "$dev")	20	major="0x"$(stat -c '%t' "$dev")
21	minor=$(stat -c '%Lr' "$dev")	21	minor="0x"$(stat -c '%T' "$dev")
22		22
23	echo $(( (major & 0xfff) << 20 \| (minor & 0xfffff) ))	23	echo $(( (major & 0xfff) << 20 \| (minor & 0xfffff) ))
24	}	24	}

tools/testing/selftests/ublk/test_generic_05.sh+1−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3		3
4	. "$(cd "$(dirname "$0")" && pwd)"/test_common.sh	4	. "$(cd "$(dirname "$0")" && pwd)"/test_common.sh
5		5
6	TID="generic_04"	6	TID="generic_05"
7	ERR_CODE=0	7	ERR_CODE=0
8		8
9	ublk_run_recover_test()	9	ublk_run_recover_test()

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code