Commit 3145b6aa authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman Committed by openeuler-sync-bot
Browse files

Revert "scsi: core: Use scsi_cmd_to_rq() instead of scsi_cmnd.request" 

stable inclusion
from stable-v5.10.207
commit 2129297760278dc48649b9d50b4b646b36b5ff6d
category: bugfix
bugzilla: https://gitee.com/src-openeuler/kernel/issues/I8ZD3X
CVE: NA

Reference: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?h=v5.10.207&id=2129297760278dc48649b9d50b4b646b36b5ff6d

-------------------------

This reverts commit df83ca8e986d0285974dfa510973191547dcd173 which is
commit aa8e25e5 upstream.

As reported, a lot of scsi changes were made just to resolve a 2 line
patch, so let's revert them all and then manually fix up the 2 line
fixup so that things are simpler and potential abi changes are not an
issue.

Link: https://lore.kernel.org/r/ZZ042FejzwMM5vDW@duo.ucw.cz


Reported-by: default avatarPavel Machek <pavel@ucw.cz>
Cc: "Martin K. Petersen" <martin.petersen@oracle.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Ming Lei <ming.lei@redhat.com>
Cc: Bart Van Assche <bvanassche@acm.org>
Cc: Sasha Levin <sashal@kernel.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: default avatarLi Lingfeng <lilingfeng3@huawei.com>
(cherry picked from commit 5c141a15)
parent adfdfe14

drivers/scsi/scsi.c

+1 −1
Original line number Diff line number Diff line
@@ -197,7 +197,7 @@ void scsi_finish_command(struct scsi_cmnd *cmd) 
				"(result %x)\n", cmd->result));



	good_bytes = scsi_bufflen(cmd);

	if (!blk_rq_is_passthrough(scsi_cmd_to_rq(cmd))) {

	if (!blk_rq_is_passthrough(cmd->request)) {

		int old_good_bytes = good_bytes;

		drv = scsi_cmd_to_driver(cmd);

		if (drv->done)

drivers/scsi/scsi_error.c

+7 −8
Original line number Diff line number Diff line
@@ -230,7 +230,7 @@ scsi_abort_command(struct scsi_cmnd *scmd) 
 */

static void scsi_eh_reset(struct scsi_cmnd *scmd)

{

	if (!blk_rq_is_passthrough(scsi_cmd_to_rq(scmd))) {

	if (!blk_rq_is_passthrough(scmd->request)) {

		struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);

		if (sdrv->eh_reset)

			sdrv->eh_reset(scmd);
@@ -1167,7 +1167,7 @@ static int scsi_request_sense(struct scsi_cmnd *scmd) 


static int scsi_eh_action(struct scsi_cmnd *scmd, int rtn)

{

	if (!blk_rq_is_passthrough(scsi_cmd_to_rq(scmd))) {

	if (!blk_rq_is_passthrough(scmd->request)) {

		struct scsi_driver *sdrv = scsi_cmd_to_driver(scmd);

		if (sdrv->eh_action)

			rtn = sdrv->eh_action(scmd, rtn);
@@ -1733,24 +1733,22 @@ static void scsi_eh_offline_sdevs(struct list_head *work_q, 
 */

int scsi_noretry_cmd(struct scsi_cmnd *scmd)

{

	struct request *req = scsi_cmd_to_rq(scmd);



	switch (host_byte(scmd->result)) {

	case DID_OK:

		break;

	case DID_TIME_OUT:

		goto check_type;

	case DID_BUS_BUSY:

		return req->cmd_flags & REQ_FAILFAST_TRANSPORT;

		return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);

	case DID_PARITY:

		return req->cmd_flags & REQ_FAILFAST_DEV;

		return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);

	case DID_ERROR:

		if (msg_byte(scmd->result) == COMMAND_COMPLETE &&

		    status_byte(scmd->result) == RESERVATION_CONFLICT)

			return 0;

		fallthrough;

	case DID_SOFT_ERROR:

		return req->cmd_flags & REQ_FAILFAST_DRIVER;

		return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);

	}



	if (status_byte(scmd->result) != CHECK_CONDITION)
@@ -1761,7 +1759,8 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd) 
	 * assume caller has checked sense and determined

	 * the check condition was retryable.

	 */

	if (req->cmd_flags & REQ_FAILFAST_DEV || blk_rq_is_passthrough(req))

	if (scmd->request->cmd_flags & REQ_FAILFAST_DEV ||

	    blk_rq_is_passthrough(scmd->request))

		return 1;



	return 0;

drivers/scsi/scsi_lib.c

+13 −15
Original line number Diff line number Diff line
@@ -153,15 +153,13 @@ scsi_set_blocked(struct scsi_cmnd *cmd, int reason) 


static void scsi_mq_requeue_cmd(struct scsi_cmnd *cmd)

{

	struct request *rq = scsi_cmd_to_rq(cmd);



	if (rq->rq_flags & RQF_DONTPREP) {

		rq->rq_flags &= ~RQF_DONTPREP;

	if (cmd->request->rq_flags & RQF_DONTPREP) {

		cmd->request->rq_flags &= ~RQF_DONTPREP;

		scsi_mq_uninit_cmd(cmd);

	} else {

		WARN_ON_ONCE(true);

	}

	blk_mq_requeue_request(rq, true);

	blk_mq_requeue_request(cmd->request, true);

}



/**
@@ -200,7 +198,7 @@ static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, bool unbusy) 
	 */

	cmd->result = 0;



	blk_mq_requeue_request(scsi_cmd_to_rq(cmd), true);

	blk_mq_requeue_request(cmd->request, true);

}



/**
@@ -513,7 +511,7 @@ void scsi_run_host_queues(struct Scsi_Host *shost) 


static void scsi_uninit_cmd(struct scsi_cmnd *cmd)

{

	if (!blk_rq_is_passthrough(scsi_cmd_to_rq(cmd))) {

	if (!blk_rq_is_passthrough(cmd->request)) {

		struct scsi_driver *drv = scsi_cmd_to_driver(cmd);



		if (drv->uninit_command)
@@ -663,7 +661,7 @@ static void scsi_io_completion_reprep(struct scsi_cmnd *cmd, 


static bool scsi_cmd_runtime_exceeced(struct scsi_cmnd *cmd)

{

	struct request *req = scsi_cmd_to_rq(cmd);

	struct request *req = cmd->request;

	unsigned long wait_for;



	if (cmd->allowed == SCSI_CMD_RETRIES_NO_LIMIT)
@@ -682,7 +680,7 @@ static bool scsi_cmd_runtime_exceeced(struct scsi_cmnd *cmd) 
static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)

{

	struct request_queue *q = cmd->device->request_queue;

	struct request *req = scsi_cmd_to_rq(cmd);

	struct request *req = cmd->request;

	int level = 0;

	enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,

	      ACTION_DELAYED_RETRY} action;
@@ -854,7 +852,7 @@ static int scsi_io_completion_nz_result(struct scsi_cmnd *cmd, int result, 
{

	bool sense_valid;

	bool sense_current = true;	/* false implies "deferred sense" */

	struct request *req = scsi_cmd_to_rq(cmd);

	struct request *req = cmd->request;

	struct scsi_sense_hdr sshdr;



	sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
@@ -943,7 +941,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes) 
{

	int result = cmd->result;

	struct request_queue *q = cmd->device->request_queue;

	struct request *req = scsi_cmd_to_rq(cmd);

	struct request *req = cmd->request;

	blk_status_t blk_stat = BLK_STS_OK;



	if (unlikely(result))	/* a nz result may or may not be an error */
@@ -1011,7 +1009,7 @@ static inline bool scsi_cmd_needs_dma_drain(struct scsi_device *sdev, 
blk_status_t scsi_alloc_sgtables(struct scsi_cmnd *cmd)

{

	struct scsi_device *sdev = cmd->device;

	struct request *rq = scsi_cmd_to_rq(cmd);

	struct request *rq = cmd->request;

	unsigned short nr_segs = blk_rq_nr_phys_segments(rq);

	struct scatterlist *last_sg = NULL;

	blk_status_t ret;
@@ -1140,7 +1138,7 @@ void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd) 
{

	void *buf = cmd->sense_buffer;

	void *prot = cmd->prot_sdb;

	struct request *rq = scsi_cmd_to_rq(cmd);

	struct request *rq = blk_mq_rq_from_pdu(cmd);

	unsigned int flags = cmd->flags & SCMD_PRESERVED_FLAGS;

	unsigned long jiffies_at_alloc;

	int retries, to_clear;
@@ -1599,12 +1597,12 @@ static blk_status_t scsi_prepare_cmd(struct request *req) 


static void scsi_mq_done(struct scsi_cmnd *cmd)

{

	if (unlikely(blk_should_fake_timeout(scsi_cmd_to_rq(cmd)->q)))

	if (unlikely(blk_should_fake_timeout(cmd->request->q)))

		return;

	if (unlikely(test_and_set_bit(SCMD_STATE_COMPLETE, &cmd->state)))

		return;

	trace_scsi_dispatch_cmd_done(cmd);

	blk_mq_complete_request(scsi_cmd_to_rq(cmd));

	blk_mq_complete_request(cmd->request);

}



static void scsi_mq_put_budget(struct request_queue *q)

drivers/scsi/scsi_logging.c

+8 −10
Original line number Diff line number Diff line
@@ -28,9 +28,8 @@ static void scsi_log_release_buffer(char *bufptr) 


static inline const char *scmd_name(const struct scsi_cmnd *scmd)

{

	struct request *rq = scsi_cmd_to_rq((struct scsi_cmnd *)scmd);



	return rq->rq_disk ? rq->rq_disk->disk_name : NULL;

	return scmd->request->rq_disk ?

		scmd->request->rq_disk->disk_name : NULL;

}



static size_t sdev_format_header(char *logbuf, size_t logbuf_len,
@@ -92,7 +91,7 @@ void scmd_printk(const char *level, const struct scsi_cmnd *scmd, 
	if (!logbuf)

		return;

	off = sdev_format_header(logbuf, logbuf_len, scmd_name(scmd),

				 scsi_cmd_to_rq((struct scsi_cmnd *)scmd)->tag);

				 scmd->request->tag);

	if (off < logbuf_len) {

		va_start(args, fmt);

		off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args);
@@ -189,7 +188,7 @@ void scsi_print_command(struct scsi_cmnd *cmd) 
		return;



	off = sdev_format_header(logbuf, logbuf_len,

				 scmd_name(cmd), scsi_cmd_to_rq(cmd)->tag);

				 scmd_name(cmd), cmd->request->tag);

	if (off >= logbuf_len)

		goto out_printk;

	off += scnprintf(logbuf + off, logbuf_len - off, "CDB: ");
@@ -211,7 +210,7 @@ void scsi_print_command(struct scsi_cmnd *cmd) 


			off = sdev_format_header(logbuf, logbuf_len,

						 scmd_name(cmd),

						 scsi_cmd_to_rq(cmd)->tag);

						 cmd->request->tag);

			if (!WARN_ON(off > logbuf_len - 58)) {

				off += scnprintf(logbuf + off, logbuf_len - off,

						 "CDB[%02x]: ", k);
@@ -374,8 +373,7 @@ EXPORT_SYMBOL(__scsi_print_sense); 
/* Normalize and print sense buffer in SCSI command */

void scsi_print_sense(const struct scsi_cmnd *cmd)

{

	scsi_log_print_sense(cmd->device, scmd_name(cmd),

			     scsi_cmd_to_rq((struct scsi_cmnd *)cmd)->tag,

	scsi_log_print_sense(cmd->device, scmd_name(cmd), cmd->request->tag,

			     cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);

}

EXPORT_SYMBOL(scsi_print_sense);
@@ -394,8 +392,8 @@ void scsi_print_result(const struct scsi_cmnd *cmd, const char *msg, 
	if (!logbuf)

		return;



	off = sdev_format_header(logbuf, logbuf_len, scmd_name(cmd),

				 scsi_cmd_to_rq((struct scsi_cmnd *)cmd)->tag);

	off = sdev_format_header(logbuf, logbuf_len,

				 scmd_name(cmd), cmd->request->tag);



	if (off >= logbuf_len)

		goto out_printk;

include/scsi/scsi_cmnd.h

+3 −5
Original line number Diff line number Diff line
@@ -162,9 +162,7 @@ static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd) 
/* make sure not to use it with passthrough commands */

static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)

{

	struct request *rq = scsi_cmd_to_rq(cmd);



	return *(struct scsi_driver **)rq->rq_disk->private_data;

	return *(struct scsi_driver **)cmd->request->rq_disk->private_data;

}



extern void scsi_finish_command(struct scsi_cmnd *cmd);
@@ -228,14 +226,14 @@ static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd, 


static inline sector_t scsi_get_sector(struct scsi_cmnd *scmd)

{

	return blk_rq_pos(scsi_cmd_to_rq(scmd));

	return blk_rq_pos(scmd->request);

}



static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)

{

	unsigned int shift = ilog2(scmd->device->sector_size) - SECTOR_SHIFT;



	return blk_rq_pos(scsi_cmd_to_rq(scmd)) >> shift;

	return blk_rq_pos(scmd->request) >> shift;

}



/*