Commit 71ae4262 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-5.16/passthrough-flag-2021-10-29' of git://git.kernel.dk/linux-block 

Pull QUEUE_FLAG_SCSI_PASSTHROUGH removal from Jens Axboe:
 "This contains a series leading to the removal of the
  QUEUE_FLAG_SCSI_PASSTHROUGH queue flag"

* tag 'for-5.16/passthrough-flag-2021-10-29' of git://git.kernel.dk/linux-block:
  block: remove blk_{get,put}_request
  block: remove QUEUE_FLAG_SCSI_PASSTHROUGH
  block: remove the initialize_rq_fn blk_mq_ops method
  scsi: add a scsi_alloc_request helper
  bsg-lib: initialize the bsg_job in bsg_transport_sg_io_fn
  nfsd/blocklayout: use ->get_unique_id instead of sending SCSI commands
  sd: implement ->get_unique_id
  block: add a ->get_unique_id method
parents 737f1cd8 0bf6d96c

block/blk-core.c

+0 −28
Original line number Diff line number Diff line
@@ -597,34 +597,6 @@ bool blk_get_queue(struct request_queue *q) 
}

EXPORT_SYMBOL(blk_get_queue);



/**

 * blk_get_request - allocate a request

 * @q: request queue to allocate a request for

 * @op: operation (REQ_OP_*) and REQ_* flags, e.g. REQ_SYNC.

 * @flags: BLK_MQ_REQ_* flags, e.g. BLK_MQ_REQ_NOWAIT.

 */

struct request *blk_get_request(struct request_queue *q, unsigned int op,

				blk_mq_req_flags_t flags)

{

	struct request *req;



	WARN_ON_ONCE(op & REQ_NOWAIT);

	WARN_ON_ONCE(flags & ~(BLK_MQ_REQ_NOWAIT | BLK_MQ_REQ_PM));



	req = blk_mq_alloc_request(q, op, flags);

	if (!IS_ERR(req) && q->mq_ops->initialize_rq_fn)

		q->mq_ops->initialize_rq_fn(req);



	return req;

}

EXPORT_SYMBOL(blk_get_request);



void blk_put_request(struct request *req)

{

	blk_mq_free_request(req);

}

EXPORT_SYMBOL(blk_put_request);



static void handle_bad_sector(struct bio *bio, sector_t maxsector)

{

	char b[BDEVNAME_SIZE];

block/blk-mq-debugfs.c

+0 −1
Original line number Diff line number Diff line
@@ -124,7 +124,6 @@ static const char *const blk_queue_flag_name[] = { 
	QUEUE_FLAG_NAME(STATS),

	QUEUE_FLAG_NAME(POLL_STATS),

	QUEUE_FLAG_NAME(REGISTERED),

	QUEUE_FLAG_NAME(SCSI_PASSTHROUGH),

	QUEUE_FLAG_NAME(QUIESCED),

	QUEUE_FLAG_NAME(PCI_P2PDMA),

	QUEUE_FLAG_NAME(ZONE_RESETALL),

block/bsg-lib.c

+13 −19
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ static int bsg_transport_sg_io_fn(struct request_queue *q, struct sg_io_v4 *hdr, 
	struct bsg_job *job;

	struct request *rq;

	struct bio *bio;

	void *reply;

	int ret;



	if (hdr->protocol != BSG_PROTOCOL_SCSI  ||
@@ -39,22 +40,28 @@ static int bsg_transport_sg_io_fn(struct request_queue *q, struct sg_io_v4 *hdr, 
	if (!capable(CAP_SYS_RAWIO))

		return -EPERM;



	rq = blk_get_request(q, hdr->dout_xfer_len ?

	rq = blk_mq_alloc_request(q, hdr->dout_xfer_len ?

			     REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);

	if (IS_ERR(rq))

		return PTR_ERR(rq);

	rq->timeout = timeout;



	job = blk_mq_rq_to_pdu(rq);

	reply = job->reply;

	memset(job, 0, sizeof(*job));

	job->reply = reply;

	job->reply_len = SCSI_SENSE_BUFFERSIZE;

	job->dd_data = job + 1;



	job->request_len = hdr->request_len;

	job->request = memdup_user(uptr64(hdr->request), hdr->request_len);

	if (IS_ERR(job->request)) {

		ret = PTR_ERR(job->request);

		goto out_put_request;

		goto out_free_rq;

	}



	if (hdr->dout_xfer_len && hdr->din_xfer_len) {

		job->bidi_rq = blk_get_request(rq->q, REQ_OP_DRV_IN, 0);

		job->bidi_rq = blk_mq_alloc_request(rq->q, REQ_OP_DRV_IN, 0);

		if (IS_ERR(job->bidi_rq)) {

			ret = PTR_ERR(job->bidi_rq);

			goto out_free_job_request;
@@ -134,11 +141,11 @@ static int bsg_transport_sg_io_fn(struct request_queue *q, struct sg_io_v4 *hdr, 
		blk_rq_unmap_user(job->bidi_bio);

out_free_bidi_rq:

	if (job->bidi_rq)

		blk_put_request(job->bidi_rq);

		blk_mq_free_request(job->bidi_rq);

out_free_job_request:

	kfree(job->request);

out_put_request:

	blk_put_request(rq);

out_free_rq:

	blk_mq_free_request(rq);

	return ret;

}
@@ -302,18 +309,6 @@ static int bsg_init_rq(struct blk_mq_tag_set *set, struct request *req, 
	return 0;

}



/* called right before the request is given to the request_queue user */

static void bsg_initialize_rq(struct request *req)

{

	struct bsg_job *job = blk_mq_rq_to_pdu(req);

	void *reply = job->reply;



	memset(job, 0, sizeof(*job));

	job->reply = reply;

	job->reply_len = SCSI_SENSE_BUFFERSIZE;

	job->dd_data = job + 1;

}



static void bsg_exit_rq(struct blk_mq_tag_set *set, struct request *req,

		       unsigned int hctx_idx)

{
@@ -350,7 +345,6 @@ static const struct blk_mq_ops bsg_mq_ops = { 
	.queue_rq		= bsg_queue_rq,

	.init_request		= bsg_init_rq,

	.exit_request		= bsg_exit_rq,

	.initialize_rq_fn	= bsg_initialize_rq,

	.complete		= bsg_complete,

	.timeout		= bsg_timeout,

};

drivers/block/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -281,8 +281,8 @@ config BLK_DEV_RAM_SIZE 
config CDROM_PKTCDVD

	tristate "Packet writing on CD/DVD media (DEPRECATED)"

	depends on !UML

	depends on SCSI

	select CDROM

	select SCSI_COMMON

	help

	  Note: This driver is deprecated and will be removed from the

	  kernel in the near future!

drivers/block/paride/pd.c

+2 −2
Original line number Diff line number Diff line
@@ -775,14 +775,14 @@ static int pd_special_command(struct pd_unit *disk, 
	struct request *rq;

	struct pd_req *req;



	rq = blk_get_request(disk->gd->queue, REQ_OP_DRV_IN, 0);

	rq = blk_mq_alloc_request(disk->gd->queue, REQ_OP_DRV_IN, 0);

	if (IS_ERR(rq))

		return PTR_ERR(rq);

	req = blk_mq_rq_to_pdu(rq);



	req->func = func;

	blk_execute_rq(disk->gd, rq, 0);

	blk_put_request(rq);

	blk_mq_free_request(rq);

	return 0;

}