openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

block: remove unnecessary argument from blk_execute_rq 

We can remove 'q' from blk_execute_rq as well after the previous change
in blk_execute_rq_nowait.

And more importantly it never really was needed to start with given
that we can trivial derive it from struct request.

Cc: linux-scsi@vger.kernel.org
Cc: virtualization@lists.linux-foundation.org
Cc: linux-ide@vger.kernel.org
Cc: linux-mmc@vger.kernel.org
Cc: linux-nvme@lists.infradead.org
Cc: linux-nfs@vger.kernel.org
Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # for mmc
Signed-off-by: Guoqing Jiang <guoqing.jiang@cloud.ionos.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Guoqing Jiang 2021-01-25 05:49:58 +01:00 committed by Jens Axboe
parent 8eeed0b554
commit 684da7628d
24 changed files with 33 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
block/blk-exec.c
View File

@ -74,8 +74,7 @@ EXPORT_SYMBOL_GPL(blk_execute_rq_nowait);
* Insert a fully prepared request at the back of the I/O scheduler queue * Insert a fully prepared request at the back of the I/O scheduler queue
* for execution and wait for completion. * for execution and wait for completion.
*/ */
void blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk, void blk_execute_rq(struct gendisk *bd_disk, struct request *rq, int at_head)
struct request *rq, int at_head)
{ {
DECLARE_COMPLETION_ONSTACK(wait); DECLARE_COMPLETION_ONSTACK(wait);
unsigned long hang_check; unsigned long hang_check;

2
block/bsg.c
View File

@ -183,7 +183,7 @@ static int bsg_sg_io(struct request_queue *q, fmode_t mode, void __user *uarg)
bio = rq->bio; bio = rq->bio;
blk_execute_rq(q, NULL, rq, !(hdr.flags & BSG_FLAG_Q_AT_TAIL)); blk_execute_rq(NULL, rq, !(hdr.flags & BSG_FLAG_Q_AT_TAIL));
ret = rq->q->bsg_dev.ops->complete_rq(rq, &hdr); ret = rq->q->bsg_dev.ops->complete_rq(rq, &hdr);
blk_rq_unmap_user(bio); blk_rq_unmap_user(bio);

6
block/scsi_ioctl.c
View File

@ -357,7 +357,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
* (if he doesn't check that is his problem). * (if he doesn't check that is his problem).
* N.B. a non-zero SCSI status is _not_ necessarily an error. * N.B. a non-zero SCSI status is _not_ necessarily an error.
*/ */
blk_execute_rq(q, bd_disk, rq, at_head); blk_execute_rq(bd_disk, rq, at_head);
hdr->duration = jiffies_to_msecs(jiffies - start_time); hdr->duration = jiffies_to_msecs(jiffies - start_time);
@ -493,7 +493,7 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
goto error; goto error;
} }
blk_execute_rq(q, disk, rq, 0); blk_execute_rq(disk, rq, 0);
err = req->result & 0xff; /* only 8 bit SCSI status */ err = req->result & 0xff; /* only 8 bit SCSI status */
if (err) { if (err) {
@ -532,7 +532,7 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
scsi_req(rq)->cmd[0] = cmd; scsi_req(rq)->cmd[0] = cmd;
scsi_req(rq)->cmd[4] = data; scsi_req(rq)->cmd[4] = data;
scsi_req(rq)->cmd_len = 6; scsi_req(rq)->cmd_len = 6;
blk_execute_rq(q, bd_disk, rq, 0); blk_execute_rq(bd_disk, rq, 0);
err = scsi_req(rq)->result ? -EIO : 0; err = scsi_req(rq)->result ? -EIO : 0;
blk_put_request(rq); blk_put_request(rq);

2
drivers/block/mtip32xx/mtip32xx.c
View File

@ -1015,7 +1015,7 @@ static int mtip_exec_internal_command(struct mtip_port *port,
rq->timeout = timeout; rq->timeout = timeout;
/* insert request and run queue */ /* insert request and run queue */
blk_execute_rq(rq->q, NULL, rq, true); blk_execute_rq(NULL, rq, true);
if (int_cmd->status) { if (int_cmd->status) {
dev_err(&dd->pdev->dev, "Internal command [%02X] failed %d\n", dev_err(&dd->pdev->dev, "Internal command [%02X] failed %d\n",

2
drivers/block/paride/pd.c
View File

@ -781,7 +781,7 @@ static int pd_special_command(struct pd_unit *disk,
req = blk_mq_rq_to_pdu(rq); req = blk_mq_rq_to_pdu(rq);
req->func = func; req->func = func;
blk_execute_rq(disk->gd->queue, disk->gd, rq, 0); blk_execute_rq(disk->gd, rq, 0);
blk_put_request(rq); blk_put_request(rq);
return 0; return 0;
} }

2
drivers/block/pktcdvd.c
View File

@ -722,7 +722,7 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
if (cgc->quiet) if (cgc->quiet)
rq->rq_flags |= RQF_QUIET; rq->rq_flags |= RQF_QUIET;
blk_execute_rq(rq->q, pd->bdev->bd_disk, rq, 0); blk_execute_rq(pd->bdev->bd_disk, rq, 0);
if (scsi_req(rq)->result) if (scsi_req(rq)->result)
ret = -EIO; ret = -EIO;
out: out:

2
drivers/block/virtio_blk.c
View File

@ -320,7 +320,7 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
if (err) if (err)
goto out; goto out;
blk_execute_rq(vblk->disk->queue, vblk->disk, req, false); blk_execute_rq(vblk->disk, req, false);
err = blk_status_to_errno(virtblk_result(blk_mq_rq_to_pdu(req))); err = blk_status_to_errno(virtblk_result(blk_mq_rq_to_pdu(req)));
out: out:
blk_put_request(req); blk_put_request(req);

2
drivers/cdrom/cdrom.c
View File

@ -2214,7 +2214,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
rq->timeout = 60 * HZ; rq->timeout = 60 * HZ;
bio = rq->bio; bio = rq->bio;
blk_execute_rq(q, cdi->disk, rq, 0); blk_execute_rq(cdi->disk, rq, 0);
if (scsi_req(rq)->result) { if (scsi_req(rq)->result) {
struct scsi_sense_hdr sshdr; struct scsi_sense_hdr sshdr;

2
drivers/ide/ide-atapi.c
View File

@ -107,7 +107,7 @@ int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
memcpy(scsi_req(rq)->cmd, pc->c, 12); memcpy(scsi_req(rq)->cmd, pc->c, 12);
if (drive->media == ide_tape) if (drive->media == ide_tape)
scsi_req(rq)->cmd[13] = REQ_IDETAPE_PC1; scsi_req(rq)->cmd[13] = REQ_IDETAPE_PC1;
blk_execute_rq(drive->queue, disk, rq, 0); blk_execute_rq(disk, rq, 0);
error = scsi_req(rq)->result ? -EIO : 0; error = scsi_req(rq)->result ? -EIO : 0;
put_req: put_req:
blk_put_request(rq); blk_put_request(rq);

2
drivers/ide/ide-cd.c
View File

@ -467,7 +467,7 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
} }
} }
blk_execute_rq(drive->queue, info->disk, rq, 0); blk_execute_rq(info->disk, rq, 0);
error = scsi_req(rq)->result ? -EIO : 0; error = scsi_req(rq)->result ? -EIO : 0;
if (buffer) if (buffer)

2
drivers/ide/ide-cd_ioctl.c
View File

@ -299,7 +299,7 @@ int ide_cdrom_reset(struct cdrom_device_info *cdi)
rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0); rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
ide_req(rq)->type = ATA_PRIV_MISC; ide_req(rq)->type = ATA_PRIV_MISC;
rq->rq_flags = RQF_QUIET; rq->rq_flags = RQF_QUIET;
blk_execute_rq(drive->queue, cd->disk, rq, 0); blk_execute_rq(cd->disk, rq, 0);
ret = scsi_req(rq)->result ? -EIO : 0; ret = scsi_req(rq)->result ? -EIO : 0;
blk_put_request(rq); blk_put_request(rq);
/* /*

2
drivers/ide/ide-devsets.c
View File

@ -173,7 +173,7 @@ int ide_devset_execute(ide_drive_t *drive, const struct ide_devset *setting,
*(int *)&scsi_req(rq)->cmd[1] = arg; *(int *)&scsi_req(rq)->cmd[1] = arg;
ide_req(rq)->special = setting->set; ide_req(rq)->special = setting->set;
blk_execute_rq(q, NULL, rq, 0); blk_execute_rq(NULL, rq, 0);
ret = scsi_req(rq)->result; ret = scsi_req(rq)->result;
blk_put_request(rq); blk_put_request(rq);

2
drivers/ide/ide-disk.c
View File

@ -482,7 +482,7 @@ static int set_multcount(ide_drive_t *drive, int arg)
drive->mult_req = arg; drive->mult_req = arg;
drive->special_flags |= IDE_SFLAG_SET_MULTMODE; drive->special_flags |= IDE_SFLAG_SET_MULTMODE;
blk_execute_rq(drive->queue, NULL, rq, 0); blk_execute_rq(NULL, rq, 0);
blk_put_request(rq); blk_put_request(rq);
return (drive->mult_count == arg) ? 0 : -EIO; return (drive->mult_count == arg) ? 0 : -EIO;

4
drivers/ide/ide-ioctls.c
View File

@ -137,7 +137,7 @@ static int ide_cmd_ioctl(ide_drive_t *drive, void __user *argp)
rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0); rq = blk_get_request(drive->queue, REQ_OP_DRV_IN, 0);
ide_req(rq)->type = ATA_PRIV_TASKFILE; ide_req(rq)->type = ATA_PRIV_TASKFILE;
blk_execute_rq(drive->queue, NULL, rq, 0); blk_execute_rq(NULL, rq, 0);
err = scsi_req(rq)->result ? -EIO : 0; err = scsi_req(rq)->result ? -EIO : 0;
blk_put_request(rq); blk_put_request(rq);
@ -235,7 +235,7 @@ static int generic_drive_reset(ide_drive_t *drive)
ide_req(rq)->type = ATA_PRIV_MISC; ide_req(rq)->type = ATA_PRIV_MISC;
scsi_req(rq)->cmd_len = 1; scsi_req(rq)->cmd_len = 1;
scsi_req(rq)->cmd[0] = REQ_DRIVE_RESET; scsi_req(rq)->cmd[0] = REQ_DRIVE_RESET;
blk_execute_rq(drive->queue, NULL, rq, 1); blk_execute_rq(NULL, rq, 1);
ret = scsi_req(rq)->result; ret = scsi_req(rq)->result;
blk_put_request(rq); blk_put_request(rq);
return ret; return ret;

2
drivers/ide/ide-park.c
View File

@ -37,7 +37,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
scsi_req(rq)->cmd_len = 1; scsi_req(rq)->cmd_len = 1;
ide_req(rq)->type = ATA_PRIV_MISC; ide_req(rq)->type = ATA_PRIV_MISC;
ide_req(rq)->special = &timeout; ide_req(rq)->special = &timeout;
blk_execute_rq(q, NULL, rq, 1); blk_execute_rq(NULL, rq, 1);
rc = scsi_req(rq)->result ? -EIO : 0; rc = scsi_req(rq)->result ? -EIO : 0;
blk_put_request(rq); blk_put_request(rq);
if (rc) if (rc)

4
drivers/ide/ide-pm.c
View File

@ -27,7 +27,7 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
mesg.event = PM_EVENT_FREEZE; mesg.event = PM_EVENT_FREEZE;
rqpm.pm_state = mesg.event; rqpm.pm_state = mesg.event;
blk_execute_rq(drive->queue, NULL, rq, 0); blk_execute_rq(NULL, rq, 0);
ret = scsi_req(rq)->result ? -EIO : 0; ret = scsi_req(rq)->result ? -EIO : 0;
blk_put_request(rq); blk_put_request(rq);
@ -50,7 +50,7 @@ static int ide_pm_execute_rq(struct request *rq)
blk_mq_end_request(rq, BLK_STS_OK); blk_mq_end_request(rq, BLK_STS_OK);
return -ENXIO; return -ENXIO;
} }
blk_execute_rq(q, NULL, rq, true); blk_execute_rq(NULL, rq, true);
return scsi_req(rq)->result ? -EIO : 0; return scsi_req(rq)->result ? -EIO : 0;
} }

2
drivers/ide/ide-tape.c
View File

@ -868,7 +868,7 @@ static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
goto out_put; goto out_put;
} }
blk_execute_rq(drive->queue, tape->disk, rq, 0); blk_execute_rq(tape->disk, rq, 0);
/* calculate the number of transferred bytes and update buffer state */ /* calculate the number of transferred bytes and update buffer state */
size -= scsi_req(rq)->resid_len; size -= scsi_req(rq)->resid_len;

2
drivers/ide/ide-taskfile.c
View File

@ -443,7 +443,7 @@ int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
ide_req(rq)->special = cmd; ide_req(rq)->special = cmd;
cmd->rq = rq; cmd->rq = rq;
blk_execute_rq(drive->queue, NULL, rq, 0); blk_execute_rq(NULL, rq, 0);
error = scsi_req(rq)->result ? -EIO : 0; error = scsi_req(rq)->result ? -EIO : 0;
put_req: put_req:
blk_put_request(rq); blk_put_request(rq);

10
drivers/mmc/core/block.c
View File

@ -253,7 +253,7 @@ static ssize_t power_ro_lock_store(struct device *dev,
goto out_put; goto out_put;
} }
req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_BOOT_WP; req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_BOOT_WP;
blk_execute_rq(mq->queue, NULL, req, 0); blk_execute_rq(NULL, req, 0);
ret = req_to_mmc_queue_req(req)->drv_op_result; ret = req_to_mmc_queue_req(req)->drv_op_result;
blk_put_request(req); blk_put_request(req);
@ -629,7 +629,7 @@ static int mmc_blk_ioctl_cmd(struct mmc_blk_data *md,
rpmb ? MMC_DRV_OP_IOCTL_RPMB : MMC_DRV_OP_IOCTL; rpmb ? MMC_DRV_OP_IOCTL_RPMB : MMC_DRV_OP_IOCTL;
req_to_mmc_queue_req(req)->drv_op_data = idatas; req_to_mmc_queue_req(req)->drv_op_data = idatas;
req_to_mmc_queue_req(req)->ioc_count = 1; req_to_mmc_queue_req(req)->ioc_count = 1;
blk_execute_rq(mq->queue, NULL, req, 0); blk_execute_rq(NULL, req, 0);
ioc_err = req_to_mmc_queue_req(req)->drv_op_result; ioc_err = req_to_mmc_queue_req(req)->drv_op_result;
err = mmc_blk_ioctl_copy_to_user(ic_ptr, idata); err = mmc_blk_ioctl_copy_to_user(ic_ptr, idata);
blk_put_request(req); blk_put_request(req);
@ -698,7 +698,7 @@ static int mmc_blk_ioctl_multi_cmd(struct mmc_blk_data *md,
rpmb ? MMC_DRV_OP_IOCTL_RPMB : MMC_DRV_OP_IOCTL; rpmb ? MMC_DRV_OP_IOCTL_RPMB : MMC_DRV_OP_IOCTL;
req_to_mmc_queue_req(req)->drv_op_data = idata; req_to_mmc_queue_req(req)->drv_op_data = idata;
req_to_mmc_queue_req(req)->ioc_count = num_of_cmds; req_to_mmc_queue_req(req)->ioc_count = num_of_cmds;
blk_execute_rq(mq->queue, NULL, req, 0); blk_execute_rq(NULL, req, 0);
ioc_err = req_to_mmc_queue_req(req)->drv_op_result; ioc_err = req_to_mmc_queue_req(req)->drv_op_result;
/* copy to user if data and response */ /* copy to user if data and response */
@ -2722,7 +2722,7 @@ static int mmc_dbg_card_status_get(void *data, u64 *val)
if (IS_ERR(req)) if (IS_ERR(req))
return PTR_ERR(req); return PTR_ERR(req);
req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_GET_CARD_STATUS; req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_GET_CARD_STATUS;
blk_execute_rq(mq->queue, NULL, req, 0); blk_execute_rq(NULL, req, 0);
ret = req_to_mmc_queue_req(req)->drv_op_result; ret = req_to_mmc_queue_req(req)->drv_op_result;
if (ret >= 0) { if (ret >= 0) {
*val = ret; *val = ret;
@ -2761,7 +2761,7 @@ static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
} }
req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_GET_EXT_CSD; req_to_mmc_queue_req(req)->drv_op = MMC_DRV_OP_GET_EXT_CSD;
req_to_mmc_queue_req(req)->drv_op_data = &ext_csd; req_to_mmc_queue_req(req)->drv_op_data = &ext_csd;
blk_execute_rq(mq->queue, NULL, req, 0); blk_execute_rq(NULL, req, 0);
err = req_to_mmc_queue_req(req)->drv_op_result; err = req_to_mmc_queue_req(req)->drv_op_result;
blk_put_request(req); blk_put_request(req);
if (err) { if (err) {

4
drivers/nvme/host/core.c
View File

@ -964,7 +964,7 @@ int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
if (poll) if (poll)
nvme_execute_rq_polled(req->q, NULL, req, at_head); nvme_execute_rq_polled(req->q, NULL, req, at_head);
else else
blk_execute_rq(req->q, NULL, req, at_head); blk_execute_rq(NULL, req, at_head);
if (result) if (result)
*result = nvme_req(req)->result; *result = nvme_req(req)->result;
if (nvme_req(req)->flags & NVME_REQ_CANCELLED) if (nvme_req(req)->flags & NVME_REQ_CANCELLED)
@ -1101,7 +1101,7 @@ void nvme_execute_passthru_rq(struct request *rq)
u32 effects; u32 effects;
effects = nvme_passthru_start(ctrl, ns, cmd->common.opcode); effects = nvme_passthru_start(ctrl, ns, cmd->common.opcode);
blk_execute_rq(rq->q, disk, rq, 0); blk_execute_rq(disk, rq, 0);
nvme_passthru_end(ctrl, effects); nvme_passthru_end(ctrl, effects);
} }
EXPORT_SYMBOL_NS_GPL(nvme_execute_passthru_rq, NVME_TARGET_PASSTHRU); EXPORT_SYMBOL_NS_GPL(nvme_execute_passthru_rq, NVME_TARGET_PASSTHRU);

2
drivers/nvme/host/lightnvm.c
View File

@ -819,7 +819,7 @@ static int nvme_nvm_submit_user_cmd(struct request_queue *q,
bio->bi_bdev = ns->disk->part0; bio->bi_bdev = ns->disk->part0;
} }
blk_execute_rq(q, NULL, rq, 0); blk_execute_rq(NULL, rq, 0);
if (nvme_req(rq)->flags & NVME_REQ_CANCELLED) if (nvme_req(rq)->flags & NVME_REQ_CANCELLED)
ret = -EINTR; ret = -EINTR;

2
drivers/scsi/scsi_lib.c
View File

@ -269,7 +269,7 @@ int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
/* /*
* head injection *required* here otherwise quiesce won't work * head injection *required* here otherwise quiesce won't work
*/ */
blk_execute_rq(req->q, NULL, req, 1); blk_execute_rq(NULL, req, 1);
/* /*
* Some devices (USB mass-storage in particular) may transfer * Some devices (USB mass-storage in particular) may transfer

2
fs/nfsd/blocklayout.c
View File

@ -254,7 +254,7 @@ static int nfsd4_scsi_identify_device(struct block_device *bdev,
req->cmd[4] = bufflen & 0xff; req->cmd[4] = bufflen & 0xff;
req->cmd_len = COMMAND_SIZE(INQUIRY); req->cmd_len = COMMAND_SIZE(INQUIRY);
blk_execute_rq(rq->q, NULL, rq, 1); blk_execute_rq(NULL, rq, 1);
if (req->result) { if (req->result) {
pr_err("pNFS: INQUIRY 0x83 failed with: %x\n", pr_err("pNFS: INQUIRY 0x83 failed with: %x\n",
req->result); req->result);

3
include/linux/blkdev.h
View File

@ -948,8 +948,7 @@ extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, uns
extern int blk_rq_map_user_iov(struct request_queue *, struct request *, extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
struct rq_map_data *, const struct iov_iter *, struct rq_map_data *, const struct iov_iter *,
gfp_t); gfp_t);
extern void blk_execute_rq(struct request_queue *, struct gendisk *, extern void blk_execute_rq(struct gendisk *, struct request *, int);
struct request *, int);
extern void blk_execute_rq_nowait(struct gendisk *, extern void blk_execute_rq_nowait(struct gendisk *,
struct request *, int, rq_end_io_fn *); struct request *, int, rq_end_io_fn *);