block: remove REQ_OP_SCSI_{IN,OUT}

With the legacy IDE driver gone drivers now use either REQ_OP_DRV_*
or REQ_OP_SCSI_*, so unify the two concepts of passthrough requests
into a single one.

Reviewed-by: Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/block/blk-core.c b/block/blk-core.c
index 514838ccab2d4f071a0d6f5dce343a9d6fa69594..3eea8d79556561b2b8a457ce56161ccb9cf89c78 100644 (file)
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -142,8 +142,6 @@ static const char *const blk_op_name[] = {
        REQ_OP_NAME(ZONE_APPEND),
        REQ_OP_NAME(WRITE_SAME),
        REQ_OP_NAME(WRITE_ZEROES),
-       REQ_OP_NAME(SCSI_IN),
-       REQ_OP_NAME(SCSI_OUT),
        REQ_OP_NAME(DRV_IN),
        REQ_OP_NAME(DRV_OUT),
 };

diff --git a/block/bsg-lib.c b/block/bsg-lib.c
index 330fede77271de536d5d4f275ff951cb3c391f55..57b082bc90171b7a18420331e951b9a3e6c9c8ea 100644 (file)
--- a/block/bsg-lib.c
+++ b/block/bsg-lib.c
@@ -45,7 +45,7 @@ static int bsg_transport_fill_hdr(struct request *rq, struct sg_io_v4 *hdr,
                return PTR_ERR(job->request);
 
        if (hdr->dout_xfer_len && hdr->din_xfer_len) {
-               job->bidi_rq = blk_get_request(rq->q, REQ_OP_SCSI_IN, 0);
+               job->bidi_rq = blk_get_request(rq->q, REQ_OP_DRV_IN, 0);
                if (IS_ERR(job->bidi_rq)) {
                        ret = PTR_ERR(job->bidi_rq);
                        goto out;

diff --git a/block/bsg.c b/block/bsg.c
index bd10922d5cbb428b29068e898927e500bd615cf0..323e45878362f5354214a83032485d1ff389a529 100644 (file)
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -152,7 +152,7 @@ static int bsg_sg_io(struct request_queue *q, fmode_t mode, void __user *uarg)
                return ret;
 
        rq = blk_get_request(q, hdr.dout_xfer_len ?
-                       REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+                       REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(rq))
                return PTR_ERR(rq);
 

diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index 1b3fe99b83a6399dc093074d8b97b3bb2b3caf68..41ca95bfe607288e9210d617dd5a7a496c2ec995 100644 (file)
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -311,7 +311,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
                at_head = 1;
 
        ret = -ENOMEM;
-       rq = blk_get_request(q, writing ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+       rq = blk_get_request(q, writing ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(rq))
                return PTR_ERR(rq);
        req = scsi_req(rq);
@@ -433,7 +433,7 @@ int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
 
        }
 
-       rq = blk_get_request(q, in_len ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+       rq = blk_get_request(q, in_len ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(rq)) {
                err = PTR_ERR(rq);
                goto error_free_buffer;
@@ -521,7 +521,7 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
        struct request *rq;
        int err;
 
-       rq = blk_get_request(q, REQ_OP_SCSI_OUT, 0);
+       rq = blk_get_request(q, REQ_OP_DRV_OUT, 0);
        if (IS_ERR(rq))
                return PTR_ERR(rq);
        rq->timeout = BLK_DEFAULT_SG_TIMEOUT;

diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index f69b5c69c2a6c1bcd8c76fbc6a794662daca05c3..538446b652de114e9f41c79a6ca13d76edc5f71f 100644 (file)
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -704,7 +704,7 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
        int ret = 0;
 
        rq = blk_get_request(q, (cgc->data_direction == CGC_DATA_WRITE) ?
-                            REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+                            REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(rq))
                return PTR_ERR(rq);
 

diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 90ad34c6ef8e0ace63df5a1d4faa8d3f91186356..feb827eefd1add4cc56340fa64e83fecbe9d314b 100644 (file)
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -2186,7 +2186,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
 
                len = nr * CD_FRAMESIZE_RAW;
 
-               rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
+               rq = blk_get_request(q, REQ_OP_DRV_IN, 0);
                if (IS_ERR(rq)) {
                        ret = PTR_ERR(rq);
                        break;

diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index d8fafe77dbbed7771449c15d07216ec10b2c0dcd..03a2ff547b22936bbde31394f31481969e20b830 100644 (file)
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -2011,7 +2011,7 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
        struct request *req;
        struct scsi_request *rq;
 
-       req = blk_get_request(sdev->request_queue, REQ_OP_SCSI_IN, 0);
+       req = blk_get_request(sdev->request_queue, REQ_OP_DRV_IN, 0);
        if (IS_ERR(req))
                return;
        rq = scsi_req(req);

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 532304d42f00ecb92fd4af228941631739f7acf2..6cc7dad923cb56f7459bcda94774411ffacf50b6 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -215,7 +215,7 @@ int __scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
 
        req = blk_get_request(sdev->request_queue,
                        data_direction == DMA_TO_DEVICE ?
-                       REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN,
+                       REQ_OP_DRV_OUT : REQ_OP_DRV_IN,
                        rq_flags & RQF_PM ? BLK_MQ_REQ_PM : 0);
        if (IS_ERR(req))
                return ret;
@@ -540,7 +540,7 @@ static bool scsi_end_request(struct request *req, blk_status_t error,
        if (blk_queue_add_random(q))
                add_disk_randomness(req->rq_disk);
 
-       if (!blk_rq_is_scsi(req)) {
+       if (!blk_rq_is_passthrough(req)) {
                WARN_ON_ONCE(!(cmd->flags & SCMD_INITIALIZED));
                cmd->flags &= ~SCMD_INITIALIZED;
        }
@@ -1115,7 +1115,7 @@ void scsi_init_command(struct scsi_device *dev, struct scsi_cmnd *cmd)
        bool in_flight;
        int budget_token = cmd->budget_token;
 
-       if (!blk_rq_is_scsi(rq) && !(flags & SCMD_INITIALIZED)) {
+       if (!blk_rq_is_passthrough(rq) && !(flags & SCMD_INITIALIZED)) {
                flags |= SCMD_INITIALIZED;
                scsi_initialize_rq(rq);
        }
@@ -1556,7 +1556,7 @@ static blk_status_t scsi_prepare_cmd(struct request *req)
         * Special handling for passthrough commands, which don't go to the ULP
         * at all:
         */
-       if (blk_rq_is_scsi(req))
+       if (blk_rq_is_passthrough(req))
                return scsi_setup_scsi_cmnd(sdev, req);
 
        if (sdev->handler && sdev->handler->prep_fn) {

diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index def7ec3bbaf948dba4289800bd6943c7695352e9..f84fa550dd1541cceb15074d146e2eea9e3a61f5 100644 (file)
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1756,7 +1756,7 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
         * not expect an EWOULDBLOCK from this condition.
         */
        rq = blk_get_request(q, hp->dxfer_direction == SG_DXFER_TO_DEV ?
-                       REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+                       REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(rq)) {
                kfree(long_cmdp);
                return PTR_ERR(rq);

diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 3b1afe1d5b2708993d99f200d3a9a110acd765b9..86c951c654a82473d045bea50993d4f62c70ecc5 100644 (file)
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -549,7 +549,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 
        req = blk_get_request(SRpnt->stp->device->request_queue,
                        data_direction == DMA_TO_DEVICE ?
-                       REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+                       REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(req))
                return DRIVER_ERROR << 24;
        rq = scsi_req(req);

diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index f2a11414366d7c3b7c329d79942b72c4c87635a6..4531cf47d24e7cf97e526e4c1b770f40f23f5f7c 100644 (file)
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -982,7 +982,7 @@ pscsi_execute_cmd(struct se_cmd *cmd)
 
        req = blk_get_request(pdv->pdv_sd->request_queue,
                        cmd->data_direction == DMA_TO_DEVICE ?
-                       REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
+                       REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
        if (IS_ERR(req)) {
                pr_err("PSCSI: blk_get_request() failed\n");
                ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;

diff --git a/fs/nfsd/blocklayout.c b/fs/nfsd/blocklayout.c
index 1058659a8d31af5014c8ce2ea9bedb276b67346f..c99dee99a3c157a54a2defe562f15afafd2870d0 100644 (file)
--- a/fs/nfsd/blocklayout.c
+++ b/fs/nfsd/blocklayout.c
@@ -236,7 +236,7 @@ again:
        if (!buf)
                return -ENOMEM;
 
-       rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
+       rq = blk_get_request(q, REQ_OP_DRV_IN, 0);
        if (IS_ERR(rq)) {
                error = -ENOMEM;
                goto out_free_buf;

diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index fd3860d18d7ed7da0fd9508a49c6f87d5f85cefb..db61f7df18235611e6619ac98f6ede693e04d2e3 100644 (file)
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -350,9 +350,6 @@ enum req_opf {
        /* reset all the zone present on the device */
        REQ_OP_ZONE_RESET_ALL   = 17,
 
-       /* SCSI passthrough using struct scsi_request */
-       REQ_OP_SCSI_IN          = 32,
-       REQ_OP_SCSI_OUT         = 33,
        /* Driver private requests */
        REQ_OP_DRV_IN           = 34,
        REQ_OP_DRV_OUT          = 35,

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index d66d0da7252991ab731130d395e18b6bd36710ec..d199e51524eba6ea357eb161f6e88c791ad638a8 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -240,42 +240,15 @@ struct request {
        void *end_io_data;
 };
 
-static inline bool blk_op_is_scsi(unsigned int op)
-{
-       return op == REQ_OP_SCSI_IN || op == REQ_OP_SCSI_OUT;
-}
-
-static inline bool blk_op_is_private(unsigned int op)
+static inline bool blk_op_is_passthrough(unsigned int op)
 {
+       op &= REQ_OP_MASK;
        return op == REQ_OP_DRV_IN || op == REQ_OP_DRV_OUT;
 }
 
-static inline bool blk_rq_is_scsi(struct request *rq)
-{
-       return blk_op_is_scsi(req_op(rq));
-}
-
-static inline bool blk_rq_is_private(struct request *rq)
-{
-       return blk_op_is_private(req_op(rq));
-}
-
 static inline bool blk_rq_is_passthrough(struct request *rq)
 {
-       return blk_rq_is_scsi(rq) || blk_rq_is_private(rq);
-}
-
-static inline bool bio_is_passthrough(struct bio *bio)
-{
-       unsigned op = bio_op(bio);
-
-       return blk_op_is_scsi(op) || blk_op_is_private(op);
-}
-
-static inline bool blk_op_is_passthrough(unsigned int op)
-{
-       return (blk_op_is_scsi(op & REQ_OP_MASK) ||
-                       blk_op_is_private(op & REQ_OP_MASK));
+       return blk_op_is_passthrough(req_op(rq));
 }
 
 static inline unsigned short req_get_ioprio(struct request *req)