Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-06 19:11:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

scsi: core: Remove struct scsi_request

Browse Source 
Let submitters initialize the scmd->allowed field directly instead of
indirecting through struct scsi_request and remove the now superfluous
structure.

Link: https://lore.kernel.org/r/20220224175552.988286-8-hch@lst.de
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: John Garry <john.garry@huawei.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Christoph Hellwig 2022-02-24 18:55:51 +01:00 committed by Martin K. Petersen
parent dbb4c84d87
commit 6aded12b10
10 changed files with 10 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/scsi/scsi_debugfs.c
View File

@ -33,7 +33,7 @@ static int scsi_flags_show(struct seq_file *m, const unsigned long flags,
void scsi_show_rq(struct seq_file *m, struct request *rq) void scsi_show_rq(struct seq_file *m, struct request *rq)
{ {
struct scsi_cmnd *cmd = container_of(scsi_req(rq), typeof(*cmd), req); struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc); int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc);
int timeout_ms = jiffies_to_msecs(rq->timeout); int timeout_ms = jiffies_to_msecs(rq->timeout);
char buf[80] = "(?)"; char buf[80] = "(?)";

4
drivers/scsi/scsi_error.c
View File

@ -2023,12 +2023,10 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
{ {
struct scsi_cmnd *scmd; struct scsi_cmnd *scmd;
struct request *req; struct request *req;
struct scsi_request *rq;
req = scsi_alloc_request(sdev->request_queue, REQ_OP_DRV_IN, 0); req = scsi_alloc_request(sdev->request_queue, REQ_OP_DRV_IN, 0);
if (IS_ERR(req)) if (IS_ERR(req))
return; return;
rq = scsi_req(req);
scmd = blk_mq_rq_to_pdu(req); scmd = blk_mq_rq_to_pdu(req);
scmd->cmnd[0] = ALLOW_MEDIUM_REMOVAL; scmd->cmnd[0] = ALLOW_MEDIUM_REMOVAL;
@ -2041,7 +2039,7 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
req->rq_flags |= RQF_QUIET; req->rq_flags |= RQF_QUIET;
req->timeout = 10 * HZ; req->timeout = 10 * HZ;
rq->retries = 5; scmd->allowed = 5;
blk_execute_rq_nowait(req, true, eh_lock_door_done); blk_execute_rq_nowait(req, true, eh_lock_door_done);
} }

12
drivers/scsi/scsi_ioctl.c
View File

@ -411,7 +411,6 @@ static int sg_io(struct scsi_device *sdev, struct sg_io_hdr *hdr, fmode_t mode)
int writing = 0; int writing = 0;
int at_head = 0; int at_head = 0;
struct request *rq; struct request *rq;
struct scsi_request *req;
struct scsi_cmnd *scmd; struct scsi_cmnd *scmd;
struct bio *bio; struct bio *bio;
@ -440,7 +439,6 @@ static int sg_io(struct scsi_device *sdev, struct sg_io_hdr *hdr, fmode_t mode)
REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0); REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
if (IS_ERR(rq)) if (IS_ERR(rq))
return PTR_ERR(rq); return PTR_ERR(rq);
req = scsi_req(rq);
scmd = blk_mq_rq_to_pdu(rq); scmd = blk_mq_rq_to_pdu(rq);
if (hdr->cmd_len > sizeof(scmd->cmnd)) { if (hdr->cmd_len > sizeof(scmd->cmnd)) {
@ -475,7 +473,7 @@ static int sg_io(struct scsi_device *sdev, struct sg_io_hdr *hdr, fmode_t mode)
goto out_put_request; goto out_put_request;
bio = rq->bio; bio = rq->bio;
req->retries = 0; scmd->allowed = 0;
start_time = jiffies; start_time = jiffies;
@ -521,7 +519,6 @@ static int sg_scsi_ioctl(struct request_queue *q, fmode_t mode,
struct scsi_ioctl_command __user *sic) struct scsi_ioctl_command __user *sic)
{ {
struct request *rq; struct request *rq;
struct scsi_request *req;
int err; int err;
unsigned int in_len, out_len, bytes, opcode, cmdlen; unsigned int in_len, out_len, bytes, opcode, cmdlen;
struct scsi_cmnd *scmd; struct scsi_cmnd *scmd;
@ -555,7 +552,6 @@ static int sg_scsi_ioctl(struct request_queue *q, fmode_t mode,
err = PTR_ERR(rq); err = PTR_ERR(rq);
goto error_free_buffer; goto error_free_buffer;
} }
req = scsi_req(rq);
scmd = blk_mq_rq_to_pdu(rq); scmd = blk_mq_rq_to_pdu(rq);
cmdlen = COMMAND_SIZE(opcode); cmdlen = COMMAND_SIZE(opcode);
@ -576,13 +572,13 @@ static int sg_scsi_ioctl(struct request_queue *q, fmode_t mode,
goto error; goto error;
/* default. possible overridden later */ /* default. possible overridden later */
req->retries = 5; scmd->allowed = 5;
switch (opcode) { switch (opcode) {
case SEND_DIAGNOSTIC: case SEND_DIAGNOSTIC:
case FORMAT_UNIT: case FORMAT_UNIT:
rq->timeout = FORMAT_UNIT_TIMEOUT; rq->timeout = FORMAT_UNIT_TIMEOUT;
req->retries = 1; scmd->allowed = 1;
break; break;
case START_STOP: case START_STOP:
rq->timeout = START_STOP_TIMEOUT; rq->timeout = START_STOP_TIMEOUT;
@ -595,7 +591,7 @@ static int sg_scsi_ioctl(struct request_queue *q, fmode_t mode,
break; break;
case READ_DEFECT_DATA: case READ_DEFECT_DATA:
rq->timeout = READ_DEFECT_DATA_TIMEOUT; rq->timeout = READ_DEFECT_DATA_TIMEOUT;
req->retries = 1; scmd->allowed = 1;
break; break;
default: default:
rq->timeout = BLK_DEFAULT_SG_TIMEOUT; rq->timeout = BLK_DEFAULT_SG_TIMEOUT;

6
drivers/scsi/scsi_lib.c
View File

@ -213,7 +213,6 @@ int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
int *resid) int *resid)
{ {
struct request *req; struct request *req;
struct scsi_request *rq;
struct scsi_cmnd *scmd; struct scsi_cmnd *scmd;
int ret; int ret;
@ -224,8 +223,6 @@ int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
if (IS_ERR(req)) if (IS_ERR(req))
return PTR_ERR(req); return PTR_ERR(req);
rq = scsi_req(req);
if (bufflen) { if (bufflen) {
ret = blk_rq_map_kern(sdev->request_queue, req, ret = blk_rq_map_kern(sdev->request_queue, req,
buffer, bufflen, GFP_NOIO); buffer, bufflen, GFP_NOIO);
@ -235,7 +232,7 @@ int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
scmd = blk_mq_rq_to_pdu(req); scmd = blk_mq_rq_to_pdu(req);
scmd->cmd_len = COMMAND_SIZE(cmd[0]); scmd->cmd_len = COMMAND_SIZE(cmd[0]);
memcpy(scmd->cmnd, cmd, scmd->cmd_len); memcpy(scmd->cmnd, cmd, scmd->cmd_len);
rq->retries = retries; scmd->allowed = retries;
req->timeout = timeout; req->timeout = timeout;
req->cmd_flags |= flags; req->cmd_flags |= flags;
req->rq_flags |= rq_flags | RQF_QUIET; req->rq_flags |= rq_flags | RQF_QUIET;
@ -1189,7 +1186,6 @@ static blk_status_t scsi_setup_scsi_cmnd(struct scsi_device *sdev,
} }
cmd->transfersize = blk_rq_bytes(req); cmd->transfersize = blk_rq_bytes(req);
cmd->allowed = scsi_req(req)->retries;
return BLK_STS_OK; return BLK_STS_OK;
} }

4
drivers/scsi/sg.c
View File

@ -1725,7 +1725,6 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
{ {
int res; int res;
struct request *rq; struct request *rq;
struct scsi_request *req;
Sg_fd *sfp = srp->parentfp; Sg_fd *sfp = srp->parentfp;
sg_io_hdr_t *hp = &srp->header; sg_io_hdr_t *hp = &srp->header;
int dxfer_len = (int) hp->dxfer_len; int dxfer_len = (int) hp->dxfer_len;
@ -1758,7 +1757,6 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
if (IS_ERR(rq)) if (IS_ERR(rq))
return PTR_ERR(rq); return PTR_ERR(rq);
scmd = blk_mq_rq_to_pdu(rq); scmd = blk_mq_rq_to_pdu(rq);
req = scsi_req(rq);
if (hp->cmd_len > sizeof(scmd->cmnd)) { if (hp->cmd_len > sizeof(scmd->cmnd)) {
blk_mq_free_request(rq); blk_mq_free_request(rq);
@ -1770,7 +1768,7 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
srp->rq = rq; srp->rq = rq;
rq->end_io_data = srp; rq->end_io_data = srp;
req->retries = SG_DEFAULT_RETRIES; scmd->allowed = SG_DEFAULT_RETRIES;
if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE)) if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
return 0; return 0;

2
drivers/scsi/sr.c
View File

@ -965,7 +965,6 @@ static int sr_read_cdda_bpc(struct cdrom_device_info *cdi, void __user *ubuf,
{ {
struct gendisk *disk = cdi->disk; struct gendisk *disk = cdi->disk;
u32 len = nr * CD_FRAMESIZE_RAW; u32 len = nr * CD_FRAMESIZE_RAW;
struct scsi_request *req;
struct scsi_cmnd *scmd; struct scsi_cmnd *scmd;
struct request *rq; struct request *rq;
struct bio *bio; struct bio *bio;
@ -974,7 +973,6 @@ static int sr_read_cdda_bpc(struct cdrom_device_info *cdi, void __user *ubuf,
rq = scsi_alloc_request(disk->queue, REQ_OP_DRV_IN, 0); rq = scsi_alloc_request(disk->queue, REQ_OP_DRV_IN, 0);
if (IS_ERR(rq)) if (IS_ERR(rq))
return PTR_ERR(rq); return PTR_ERR(rq);
req = scsi_req(rq);
scmd = blk_mq_rq_to_pdu(rq); scmd = blk_mq_rq_to_pdu(rq);
ret = blk_rq_map_user(disk->queue, rq, NULL, ubuf, len, GFP_KERNEL); ret = blk_rq_map_user(disk->queue, rq, NULL, ubuf, len, GFP_KERNEL);

4
drivers/scsi/st.c
View File

@ -539,7 +539,6 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
int timeout, int retries) int timeout, int retries)
{ {
struct request *req; struct request *req;
struct scsi_request *rq;
struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data; struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
int err = 0; int err = 0;
struct scsi_tape *STp = SRpnt->stp; struct scsi_tape *STp = SRpnt->stp;
@ -551,7 +550,6 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
if (IS_ERR(req)) if (IS_ERR(req))
return PTR_ERR(req); return PTR_ERR(req);
scmd = blk_mq_rq_to_pdu(req); scmd = blk_mq_rq_to_pdu(req);
rq = scsi_req(req);
req->rq_flags |= RQF_QUIET; req->rq_flags |= RQF_QUIET;
mdata->null_mapped = 1; mdata->null_mapped = 1;
@ -580,7 +578,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
scmd->cmd_len = COMMAND_SIZE(cmd[0]); scmd->cmd_len = COMMAND_SIZE(cmd[0]);
memcpy(scmd->cmnd, cmd, scmd->cmd_len); memcpy(scmd->cmnd, cmd, scmd->cmd_len);
req->timeout = timeout; req->timeout = timeout;
rq->retries = retries; scmd->allowed = retries;
req->end_io_data = SRpnt; req->end_io_data = SRpnt;
blk_execute_rq_nowait(req, true, st_scsi_execute_end); blk_execute_rq_nowait(req, true, st_scsi_execute_end);

2
drivers/target/target_core_pscsi.c
View File

@ -993,7 +993,7 @@ pscsi_execute_cmd(struct se_cmd *cmd)
req->timeout = PS_TIMEOUT_DISK; req->timeout = PS_TIMEOUT_DISK;
else else
req->timeout = PS_TIMEOUT_OTHER; req->timeout = PS_TIMEOUT_OTHER;
scsi_req(req)->retries = PS_RETRY; scmd->allowed = PS_RETRY;
cmd->priv = scmd->cmnd; cmd->priv = scmd->cmnd;

1
include/scsi/scsi_cmnd.h
View File

@ -68,7 +68,6 @@ enum scsi_cmnd_submitter {
} __packed; } __packed;
struct scsi_cmnd { struct scsi_cmnd {
struct scsi_request req;
struct scsi_device *device; struct scsi_device *device;
struct list_head eh_entry; /* entry for the host eh_abort_list/eh_cmd_q */ struct list_head eh_entry; /* entry for the host eh_abort_list/eh_cmd_q */
struct delayed_work abort_work; struct delayed_work abort_work;

9
include/scsi/scsi_request.h
View File

@ -4,13 +4,4 @@
#include <linux/blk-mq.h> #include <linux/blk-mq.h>
struct scsi_request {
int retries;
};
static inline struct scsi_request *scsi_req(struct request *rq)
{
return blk_mq_rq_to_pdu(rq);
}
#endif /* _SCSI_SCSI_REQUEST_H */ #endif /* _SCSI_SCSI_REQUEST_H */