nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests 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
repo.diff.show_diff_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 */