Commit 11a299a7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-6.12/block-20240925' of git://git.kernel.dk/linux 

Pull more block updates from Jens Axboe:

 - Improve blk-integrity segment counting and merging (Keith)

 - NVMe pull request via Keith:
      - Multipath fixes (Hannes)
      - Sysfs attribute list NULL terminate fix (Shin'ichiro)
      - Remove problematic read-back (Keith)

 - Fix for a regression with the IO scheduler switching freezing from
   6.11 (Damien)

 - Use a raw spinlock for sbitmap, as it may get called from preempt
   disabled context (Ming)

 - Cleanup for bd_claiming waiting, using var_waitqueue() rather than
   the bit waitqueues, as that more accurately describes that it does
   (Neil)

 - Various cleanups (Kanchan, Qiu-ji, David)

* tag 'for-6.12/block-20240925' of git://git.kernel.dk/linux:
  nvme: remove CC register read-back during enabling
  nvme: null terminate nvme_tls_attrs
  nvme-multipath: avoid hang on inaccessible namespaces
  nvme-multipath: system fails to create generic nvme device
  lib/sbitmap: define swap_lock as raw_spinlock_t
  block: Remove unused blk_limits_io_{min,opt}
  drbd: Fix atomicity violation in drbd_uuid_set_bm()
  block: Fix elv_iosched_local_module handling of "none" scheduler
  block: remove bogus union
  block: change wait on bd_claiming to use a var_waitqueue
  blk-integrity: improved sg segment mapping
  block: unexport blk_rq_count_integrity_sg
  nvme-rdma: use request to get integrity segments
  scsi: use request to get integrity segments
  block: provide a request helper for user integrity segments
  blk-integrity: consider entire bio list for merging
  blk-integrity: properly account for segments
  blk-mq: set the nr_integrity_segments from bio
  blk-mq: unconditional nr_integrity_segments
parents fe293938 a0455533

block/bdev.c

+2 −2
Original line number Diff line number Diff line
@@ -555,7 +555,7 @@ int bd_prepare_to_claim(struct block_device *bdev, void *holder, 


	/* if claiming is already in progress, wait for it to finish */

	if (whole->bd_claiming) {

		wait_queue_head_t *wq = bit_waitqueue(&whole->bd_claiming, 0);

		wait_queue_head_t *wq = __var_waitqueue(&whole->bd_claiming);

		DEFINE_WAIT(wait);



		prepare_to_wait(wq, &wait, TASK_UNINTERRUPTIBLE);
@@ -578,7 +578,7 @@ static void bd_clear_claiming(struct block_device *whole, void *holder) 
	/* tell others that we're done */

	BUG_ON(whole->bd_claiming != holder);

	whole->bd_claiming = NULL;

	wake_up_bit(&whole->bd_claiming, 0);

	wake_up_var(&whole->bd_claiming);

}



/**

block/bio-integrity.c

+0 −1
Original line number Diff line number Diff line
@@ -367,7 +367,6 @@ int bio_integrity_map_user(struct bio *bio, void __user *ubuf, ssize_t bytes, 
		kfree(bvec);

	return ret;

}

EXPORT_SYMBOL_GPL(bio_integrity_map_user);



/**

 * bio_integrity_prep - Prepare bio for integrity I/O

block/blk-integrity.c

+25 −11
Original line number Diff line number Diff line
@@ -53,7 +53,6 @@ int blk_rq_count_integrity_sg(struct request_queue *q, struct bio *bio) 


	return segments;

}

EXPORT_SYMBOL(blk_rq_count_integrity_sg);



/**

 * blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
@@ -63,19 +62,20 @@ EXPORT_SYMBOL(blk_rq_count_integrity_sg); 
 *

 * Description: Map the integrity vectors in request into a

 * scatterlist.  The scatterlist must be big enough to hold all

 * elements.  I.e. sized using blk_rq_count_integrity_sg().

 * elements.  I.e. sized using blk_rq_count_integrity_sg() or

 * rq->nr_integrity_segments.

 */

int blk_rq_map_integrity_sg(struct request_queue *q, struct bio *bio,

			    struct scatterlist *sglist)

int blk_rq_map_integrity_sg(struct request *rq, struct scatterlist *sglist)

{

	struct bio_vec iv, ivprv = { NULL };

	struct request_queue *q = rq->q;

	struct scatterlist *sg = NULL;

	struct bio *bio = rq->bio;

	unsigned int segments = 0;

	struct bvec_iter iter;

	int prev = 0;



	bio_for_each_integrity_vec(iv, bio, iter) {



		if (prev) {

			if (!biovec_phys_mergeable(q, &ivprv, &iv))

				goto new_segment;
@@ -103,10 +103,30 @@ int blk_rq_map_integrity_sg(struct request_queue *q, struct bio *bio, 
	if (sg)

		sg_mark_end(sg);



	/*

	 * Something must have been wrong if the figured number of segment

	 * is bigger than number of req's physical integrity segments

	 */

	BUG_ON(segments > rq->nr_integrity_segments);

	BUG_ON(segments > queue_max_integrity_segments(q));

	return segments;

}

EXPORT_SYMBOL(blk_rq_map_integrity_sg);



int blk_rq_integrity_map_user(struct request *rq, void __user *ubuf,

			      ssize_t bytes, u32 seed)

{

	int ret = bio_integrity_map_user(rq->bio, ubuf, bytes, seed);



	if (ret)

		return ret;



	rq->nr_integrity_segments = blk_rq_count_integrity_sg(rq->q, rq->bio);

	rq->cmd_flags |= REQ_INTEGRITY;

	return 0;

}

EXPORT_SYMBOL_GPL(blk_rq_integrity_map_user);



bool blk_integrity_merge_rq(struct request_queue *q, struct request *req,

			    struct request *next)

{
@@ -134,7 +154,6 @@ bool blk_integrity_merge_bio(struct request_queue *q, struct request *req, 
			     struct bio *bio)

{

	int nr_integrity_segs;

	struct bio *next = bio->bi_next;



	if (blk_integrity_rq(req) == 0 && bio_integrity(bio) == NULL)

		return true;
@@ -145,16 +164,11 @@ bool blk_integrity_merge_bio(struct request_queue *q, struct request *req, 
	if (bio_integrity(req->bio)->bip_flags != bio_integrity(bio)->bip_flags)

		return false;



	bio->bi_next = NULL;

	nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);

	bio->bi_next = next;



	if (req->nr_integrity_segments + nr_integrity_segs >

	    q->limits.max_integrity_segments)

		return false;



	req->nr_integrity_segments += nr_integrity_segs;



	return true;

}

block/blk-merge.c

+4 −0
Original line number Diff line number Diff line
@@ -639,6 +639,9 @@ static inline int ll_new_hw_segment(struct request *req, struct bio *bio, 
	 * counters.

	 */

	req->nr_phys_segments += nr_phys_segs;

	if (bio_integrity(bio))

		req->nr_integrity_segments += blk_rq_count_integrity_sg(req->q,

									bio);

	return 1;



no_merge:
@@ -731,6 +734,7 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req, 


	/* Merge is OK... */

	req->nr_phys_segments = total_phys_segments;

	req->nr_integrity_segments += next->nr_integrity_segments;

	return 1;

}

block/blk-mq.c

+3 −2
Original line number Diff line number Diff line
@@ -376,9 +376,7 @@ static struct request *blk_mq_rq_ctx_init(struct blk_mq_alloc_data *data, 
	rq->io_start_time_ns = 0;

	rq->stats_sectors = 0;

	rq->nr_phys_segments = 0;

#if defined(CONFIG_BLK_DEV_INTEGRITY)

	rq->nr_integrity_segments = 0;

#endif

	rq->end_io = NULL;

	rq->end_io_data = NULL;
@@ -2546,6 +2544,9 @@ static void blk_mq_bio_to_request(struct request *rq, struct bio *bio, 
	rq->__sector = bio->bi_iter.bi_sector;

	rq->write_hint = bio->bi_write_hint;

	blk_rq_bio_prep(rq, bio, nr_segs);

	if (bio_integrity(bio))

		rq->nr_integrity_segments = blk_rq_count_integrity_sg(rq->q,

								      bio);



	/* This can't fail, since GFP_NOIO includes __GFP_DIRECT_RECLAIM. */

	err = blk_crypto_rq_bio_prep(rq, bio, GFP_NOIO);