Commit f7c2ca25 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull block fixes from Jens Axboe:

 - MD pull via Yu:
      - fix raid10 missing discard IO accounting (Yu Kuai)
      - fix bitmap stats for bitmap file (Zheng Qixing)
      - fix oops while reading all member disks failed during
        check/repair (Meir Elisha)

 - NVMe pull via Christoph:
      - fix scan failure for non-ANA multipath controllers (Hannes
        Reinecke)
      - fix multipath sysfs links creation for some cases (Hannes
        Reinecke)
      - PCIe endpoint fixes (Damien Le Moal)
      - use NULL instead of 0 in the auth code (Damien Le Moal)

 - Various ublk fixes:
      - Slew of selftest additions
      - Improvements and fixes for IO cancelation
      - Tweak to Kconfig verbiage

 - Fix for page dirtying for blk integrity mapped pages

 - loop fixes:
      - buffered IO fix
      - uevent fixes
      - request priority inheritance fix

 - Various little fixes

* tag 'block-6.15-20250417' of git://git.kernel.dk/linux: (38 commits)
  selftests: ublk: add generic_06 for covering fault inject
  ublk: simplify aborting ublk request
  ublk: remove __ublk_quiesce_dev()
  ublk: improve detection and handling of ublk server exit
  ublk: move device reset into ublk_ch_release()
  ublk: rely on ->canceling for dealing with ublk_nosrv_dev_should_queue_io
  ublk: add ublk_force_abort_dev()
  ublk: properly serialize all FETCH_REQs
  selftests: ublk: move creating UBLK_TMP into _prep_test()
  selftests: ublk: add test_stress_05.sh
  selftests: ublk: support user recovery
  selftests: ublk: support target specific command line
  selftests: ublk: increase max nr_queues and queue depth
  selftests: ublk: set queue pthread's cpu affinity
  selftests: ublk: setup ring with IORING_SETUP_SINGLE_ISSUER/IORING_SETUP_DEFER_TASKRUN
  selftests: ublk: add two stress tests for zero copy feature
  selftests: ublk: run stress tests in parallel
  selftests: ublk: make sure _add_ublk_dev can return in sub-shell
  selftests: ublk: cleanup backfile automatically
  selftests: ublk: add io_uring uapi header
  ...
parents b1011b2b 81dd1feb

block/bio-integrity.c

+6 −11
Original line number Diff line number Diff line
@@ -66,17 +66,13 @@ struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio, 
}

EXPORT_SYMBOL(bio_integrity_alloc);



static void bio_integrity_unpin_bvec(struct bio_vec *bv, int nr_vecs,

				     bool dirty)

static void bio_integrity_unpin_bvec(struct bio_vec *bv, int nr_vecs)

{

	int i;



	for (i = 0; i < nr_vecs; i++) {

		if (dirty && !PageCompound(bv[i].bv_page))

			set_page_dirty_lock(bv[i].bv_page);

	for (i = 0; i < nr_vecs; i++)

		unpin_user_page(bv[i].bv_page);

}

}



static void bio_integrity_uncopy_user(struct bio_integrity_payload *bip)

{
@@ -91,7 +87,7 @@ static void bio_integrity_uncopy_user(struct bio_integrity_payload *bip) 
	ret = copy_to_iter(bvec_virt(bounce_bvec), bytes, &orig_iter);

	WARN_ON_ONCE(ret != bytes);



	bio_integrity_unpin_bvec(orig_bvecs, orig_nr_vecs, true);

	bio_integrity_unpin_bvec(orig_bvecs, orig_nr_vecs);

}



/**
@@ -111,8 +107,7 @@ void bio_integrity_unmap_user(struct bio *bio) 
		return;

	}



	bio_integrity_unpin_bvec(bip->bip_vec, bip->bip_max_vcnt,

			bio_data_dir(bio) == READ);

	bio_integrity_unpin_bvec(bip->bip_vec, bip->bip_max_vcnt);

}



/**
@@ -198,7 +193,7 @@ static int bio_integrity_copy_user(struct bio *bio, struct bio_vec *bvec, 
	}



	if (write)

		bio_integrity_unpin_bvec(bvec, nr_vecs, false);

		bio_integrity_unpin_bvec(bvec, nr_vecs);

	else

		memcpy(&bip->bip_vec[1], bvec, nr_vecs * sizeof(*bvec));
@@ -319,7 +314,7 @@ int bio_integrity_map_user(struct bio *bio, struct iov_iter *iter) 
	return 0;



release_pages:

	bio_integrity_unpin_bvec(bvec, nr_bvecs, false);

	bio_integrity_unpin_bvec(bvec, nr_bvecs);

free_bvec:

	if (bvec != stack_vec)

		kfree(bvec);

block/blk-sysfs.c

+2 −0
Original line number Diff line number Diff line
@@ -909,6 +909,8 @@ int blk_register_queue(struct gendisk *disk) 
out_debugfs_remove:

	blk_debugfs_remove(disk);

	mutex_unlock(&q->sysfs_lock);

	if (queue_is_mq(q))

		blk_mq_sysfs_unregister(disk);

out_put_queue_kobj:

	kobject_put(&disk->queue_kobj);

	return ret;

block/blk-throttle.h

+1 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

#ifndef BLK_THROTTLE_H

#define BLK_THROTTLE_H

drivers/block/Kconfig

+0 −6
Original line number Diff line number Diff line
@@ -388,12 +388,6 @@ config BLK_DEV_UBLK 
	  definition isn't finalized yet, and might change according to future

	  requirement, so mark is as experimental now.



	  Say Y if you want to get better performance because task_work_add()

	  can be used in IO path for replacing io_uring cmd, which will become

	  shared between IO tasks and ubq daemon, meantime task_work_add() can

	  can handle batch more effectively, but task_work_add() isn't exported

	  for module, so ublk has to be built to kernel.



config BLKDEV_UBLK_LEGACY_OPCODES

	bool "Support legacy command opcode"

	depends on BLK_DEV_UBLK

drivers/block/loop.c

+22 −99
Original line number Diff line number Diff line
@@ -211,72 +211,6 @@ static void loop_set_size(struct loop_device *lo, loff_t size) 
		kobject_uevent(&disk_to_dev(lo->lo_disk)->kobj, KOBJ_CHANGE);

}



static int lo_write_bvec(struct file *file, struct bio_vec *bvec, loff_t *ppos)

{

	struct iov_iter i;

	ssize_t bw;



	iov_iter_bvec(&i, ITER_SOURCE, bvec, 1, bvec->bv_len);



	bw = vfs_iter_write(file, &i, ppos, 0);



	if (likely(bw ==  bvec->bv_len))

		return 0;



	printk_ratelimited(KERN_ERR

		"loop: Write error at byte offset %llu, length %i.\n",

		(unsigned long long)*ppos, bvec->bv_len);

	if (bw >= 0)

		bw = -EIO;

	return bw;

}



static int lo_write_simple(struct loop_device *lo, struct request *rq,

		loff_t pos)

{

	struct bio_vec bvec;

	struct req_iterator iter;

	int ret = 0;



	rq_for_each_segment(bvec, rq, iter) {

		ret = lo_write_bvec(lo->lo_backing_file, &bvec, &pos);

		if (ret < 0)

			break;

		cond_resched();

	}



	return ret;

}



static int lo_read_simple(struct loop_device *lo, struct request *rq,

		loff_t pos)

{

	struct bio_vec bvec;

	struct req_iterator iter;

	struct iov_iter i;

	ssize_t len;



	rq_for_each_segment(bvec, rq, iter) {

		iov_iter_bvec(&i, ITER_DEST, &bvec, 1, bvec.bv_len);

		len = vfs_iter_read(lo->lo_backing_file, &i, &pos, 0);

		if (len < 0)

			return len;



		flush_dcache_page(bvec.bv_page);



		if (len != bvec.bv_len) {

			struct bio *bio;



			__rq_for_each_bio(bio, rq)

				zero_fill_bio(bio);

			break;

		}

		cond_resched();

	}



	return 0;

}



static void loop_clear_limits(struct loop_device *lo, int mode)

{

	struct queue_limits lim = queue_limits_start_update(lo->lo_queue);
@@ -342,7 +276,7 @@ static void lo_complete_rq(struct request *rq) 
	struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);

	blk_status_t ret = BLK_STS_OK;



	if (!cmd->use_aio || cmd->ret < 0 || cmd->ret == blk_rq_bytes(rq) ||

	if (cmd->ret < 0 || cmd->ret == blk_rq_bytes(rq) ||

	    req_op(rq) != REQ_OP_READ) {

		if (cmd->ret < 0)

			ret = errno_to_blk_status(cmd->ret);
@@ -358,14 +292,13 @@ static void lo_complete_rq(struct request *rq) 
		cmd->ret = 0;

		blk_mq_requeue_request(rq, true);

	} else {

		if (cmd->use_aio) {

		struct bio *bio = rq->bio;



		while (bio) {

			zero_fill_bio(bio);

			bio = bio->bi_next;

		}

		}



		ret = BLK_STS_IOERR;

end_io:

		blk_mq_end_request(rq, ret);
@@ -445,9 +378,14 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd, 


	cmd->iocb.ki_pos = pos;

	cmd->iocb.ki_filp = file;

	cmd->iocb.ki_ioprio = req_get_ioprio(rq);

	if (cmd->use_aio) {

		cmd->iocb.ki_complete = lo_rw_aio_complete;

		cmd->iocb.ki_flags = IOCB_DIRECT;

	cmd->iocb.ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);

	} else {

		cmd->iocb.ki_complete = NULL;

		cmd->iocb.ki_flags = 0;

	}



	if (rw == ITER_SOURCE)

		ret = file->f_op->write_iter(&cmd->iocb, &iter);
@@ -458,7 +396,7 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd, 


	if (ret != -EIOCBQUEUED)

		lo_rw_aio_complete(&cmd->iocb, ret);

	return 0;

	return -EIOCBQUEUED;

}



static int do_req_filebacked(struct loop_device *lo, struct request *rq)
@@ -466,15 +404,6 @@ static int do_req_filebacked(struct loop_device *lo, struct request *rq) 
	struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq);

	loff_t pos = ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset;



	/*

	 * lo_write_simple and lo_read_simple should have been covered

	 * by io submit style function like lo_rw_aio(), one blocker

	 * is that lo_read_simple() need to call flush_dcache_page after

	 * the page is written from kernel, and it isn't easy to handle

	 * this in io submit style function which submits all segments

	 * of the req at one time. And direct read IO doesn't need to

	 * run flush_dcache_page().

	 */

	switch (req_op(rq)) {

	case REQ_OP_FLUSH:

		return lo_req_flush(lo, rq);
@@ -490,15 +419,9 @@ static int do_req_filebacked(struct loop_device *lo, struct request *rq) 
	case REQ_OP_DISCARD:

		return lo_fallocate(lo, rq, pos, FALLOC_FL_PUNCH_HOLE);

	case REQ_OP_WRITE:

		if (cmd->use_aio)

		return lo_rw_aio(lo, cmd, pos, ITER_SOURCE);

		else

			return lo_write_simple(lo, rq, pos);

	case REQ_OP_READ:

		if (cmd->use_aio)

		return lo_rw_aio(lo, cmd, pos, ITER_DEST);

		else

			return lo_read_simple(lo, rq, pos);

	default:

		WARN_ON_ONCE(1);

		return -EIO;
@@ -662,19 +585,20 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, 
	 * dependency.

	 */

	fput(old_file);

	dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 0);

	if (partscan)

		loop_reread_partitions(lo);



	error = 0;

done:

	/* enable and uncork uevent now that we are done */

	dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 0);

	kobject_uevent(&disk_to_dev(lo->lo_disk)->kobj, KOBJ_CHANGE);

	return error;



out_err:

	loop_global_unlock(lo, is_loop);

out_putf:

	fput(file);

	dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 0);

	goto done;

}
@@ -1129,8 +1053,8 @@ static int loop_configure(struct loop_device *lo, blk_mode_t mode, 
	if (partscan)

		clear_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state);



	/* enable and uncork uevent now that we are done */

	dev_set_uevent_suppress(disk_to_dev(lo->lo_disk), 0);

	kobject_uevent(&disk_to_dev(lo->lo_disk)->kobj, KOBJ_CHANGE);



	loop_global_unlock(lo, is_loop);

	if (partscan)
@@ -1921,7 +1845,6 @@ static void loop_handle_cmd(struct loop_cmd *cmd) 
	struct loop_device *lo = rq->q->queuedata;

	int ret = 0;

	struct mem_cgroup *old_memcg = NULL;

	const bool use_aio = cmd->use_aio;



	if (write && (lo->lo_flags & LO_FLAGS_READ_ONLY)) {

		ret = -EIO;
@@ -1951,7 +1874,7 @@ static void loop_handle_cmd(struct loop_cmd *cmd) 
	}

 failed:

	/* complete non-aio request */

	if (!use_aio || ret) {

	if (ret != -EIOCBQUEUED) {

		if (ret == -EOPNOTSUPP)

			cmd->ret = ret;

		else