drivers: use req op accessor

The req operation REQ_OP is separated from the rq_flag_bits
definition. This converts the block layer drivers to
use req_op to get the op from the request struct.

Signed-off-by: Mike Christie <mchristi@redhat.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index e9f1701af7cb3a9965b6ce32ae73c932757e361f..b9b737cafd5f1836aaf16eb20e3d11154c3e0d88 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -544,7 +544,7 @@ static int do_req_filebacked(struct loop_device *lo, struct request *rq)
        if (op_is_write(req_op(rq))) {
                if (rq->cmd_flags & REQ_FLUSH)
                        ret = lo_req_flush(lo, rq);
-               else if (rq->cmd_flags & REQ_DISCARD)
+               else if (req_op(rq) == REQ_OP_DISCARD)
                        ret = lo_discard(lo, rq, pos);
                else if (lo->transfer)
                        ret = lo_write_transfer(lo, rq, pos);
@@ -1659,8 +1659,8 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx,
        if (lo->lo_state != Lo_bound)
                return -EIO;
 
-       if (lo->use_dio && !(cmd->rq->cmd_flags & (REQ_FLUSH |
-                                       REQ_DISCARD)))
+       if (lo->use_dio && (!(cmd->rq->cmd_flags & REQ_FLUSH) ||
+           req_op(cmd->rq) == REQ_OP_DISCARD))
                cmd->use_aio = true;
        else
                cmd->use_aio = false;

diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 6053e4659fa2f3d014ca125644992a3d676879e0..8e3e708cb9ee9e85fbf449bec55647541fb6b848 100644 (file)
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -3765,7 +3765,7 @@ static int mtip_submit_request(struct blk_mq_hw_ctx *hctx, struct request *rq)
                        return -ENODATA;
        }
 
-       if (rq->cmd_flags & REQ_DISCARD) {
+       if (req_op(rq) == REQ_OP_DISCARD) {
                int err;
 
                err = mtip_send_trim(dd, blk_rq_pos(rq), blk_rq_sectors(rq));

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 31e73a7a40f20eb6de0337c79aade131c4b70df4..6c2c28d124d0bdee954cae41a75a4afe10b777bd 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -282,7 +282,7 @@ static int nbd_send_req(struct nbd_device *nbd, struct request *req)
 
        if (req->cmd_type == REQ_TYPE_DRV_PRIV)
                type = NBD_CMD_DISC;
-       else if (req->cmd_flags & REQ_DISCARD)
+       else if (req_op(req) == REQ_OP_DISCARD)
                type = NBD_CMD_TRIM;
        else if (req->cmd_flags & REQ_FLUSH)
                type = NBD_CMD_FLUSH;

diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 81666a56415e2bc6f960a3f5ac2220108c2b7ed1..450662055d97338996720d4aa93efa0aefc16e65 100644 (file)
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -3286,9 +3286,9 @@ static void rbd_queue_workfn(struct work_struct *work)
                goto err;
        }
 
-       if (rq->cmd_flags & REQ_DISCARD)
+       if (req_op(rq) == REQ_OP_DISCARD)
                op_type = OBJ_OP_DISCARD;
-       else if (rq->cmd_flags & REQ_WRITE)
+       else if (req_op(rq) == REQ_OP_WRITE)
                op_type = OBJ_OP_WRITE;
        else
                op_type = OBJ_OP_READ;

diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 52963a26660aea99d8c48142dc01facacbd16aba..6fd160197b7a465d647c5dfe2d0849a6b341e6ad 100644 (file)
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -844,7 +844,8 @@ static int blkif_queue_request(struct request *req, struct blkfront_ring_info *r
        if (unlikely(rinfo->dev_info->connected != BLKIF_STATE_CONNECTED))
                return 1;
 
-       if (unlikely(req->cmd_flags & (REQ_DISCARD | REQ_SECURE)))
+       if (unlikely(req_op(req) == REQ_OP_DISCARD ||
+                    req->cmd_flags & REQ_SECURE))
                return blkif_queue_discard_req(req, rinfo);
        else
                return blkif_queue_rw_req(req, rinfo);
@@ -2054,8 +2055,9 @@ static int blkif_recover(struct blkfront_info *info)
                        /*
                         * Get the bios in the request so we can re-queue them.
                         */
-                       if (copy[i].request->cmd_flags &
-                           (REQ_FLUSH | REQ_FUA | REQ_DISCARD | REQ_SECURE)) {
+                       if (copy[i].request->cmd_flags & REQ_FLUSH ||
+                           req_op(copy[i].request) == REQ_OP_DISCARD ||
+                           copy[i].request->cmd_flags & (REQ_FUA | REQ_SECURE)) {
                                /*
                                 * Flush operations don't contain bios, so
                                 * we need to requeue the whole request

diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 2fb5350c54105000d57bf1672b101e3e40fdd9ca..f079d8d1d8569a43a035adebbba2a63ee8ca5379 100644 (file)
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -206,7 +206,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
        memcpy(rq->cmd, pc->c, 12);
 
        pc->rq = rq;
-       if (rq->cmd_flags & REQ_WRITE)
+       if (cmd == WRITE)
                pc->flags |= PC_FLAG_WRITING;
 
        pc->flags |= PC_FLAG_DMA_OK;

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 9204a2dfdd64d96176d716ca1abdbca914f002f4..f6b104c77b6d3d47e46d58f3bc34a4dea346cfef 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1322,7 +1322,7 @@ static void dm_done(struct request *clone, int error, bool mapped)
                        r = rq_end_io(tio->ti, clone, error, &tio->info);
        }
 
-       if (unlikely(r == -EREMOTEIO && (clone->cmd_flags & REQ_WRITE_SAME) &&
+       if (unlikely(r == -EREMOTEIO && (req_op(clone) == REQ_OP_WRITE_SAME) &&
                     !clone->q->limits.max_write_same_sectors))
                disable_write_same(tio->md);
 

diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index e62fde3ac431c111ec945d4aba9c877f6308d81d..201a8719f6c417473b3e9ee70752d8e6fb58645a 100644 (file)
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -1722,8 +1722,7 @@ static u8 mmc_blk_prep_packed_list(struct mmc_queue *mq, struct request *req)
                    !IS_ALIGNED(blk_rq_sectors(next), 8))
                        break;
 
-               if (next->cmd_flags & REQ_DISCARD ||
-                   next->cmd_flags & REQ_FLUSH)
+               if (req_op(next) == REQ_OP_DISCARD || next->cmd_flags & REQ_FLUSH)
                        break;
 
                if (rq_data_dir(cur) != rq_data_dir(next))
@@ -2164,7 +2163,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
        }
 
        mq->flags &= ~MMC_QUEUE_NEW_REQUEST;
-       if (cmd_flags & REQ_DISCARD) {
+       if (req && req_op(req) == REQ_OP_DISCARD) {
                /* complete ongoing async transfer before issuing discard */
                if (card->host->areq)
                        mmc_blk_issue_rw_rq(mq, NULL);
@@ -2188,7 +2187,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 
 out:
        if ((!req && !(mq->flags & MMC_QUEUE_NEW_REQUEST)) ||
-            (cmd_flags & MMC_REQ_SPECIAL_MASK))
+           mmc_req_is_special(req))
                /*
                 * Release host when there are no more requests
                 * and after special request(discard, flush) is done.

diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 6f4323c6d6536c8855ca2a8bef8f8087bb5d252e..c2d5f6f35145e7c7f56cb96b8d907c0102ceb752 100644 (file)
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -33,7 +33,7 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
        /*
         * We only like normal block requests and discards.
         */
-       if (req->cmd_type != REQ_TYPE_FS && !(req->cmd_flags & REQ_DISCARD)) {
+       if (req->cmd_type != REQ_TYPE_FS && req_op(req) != REQ_OP_DISCARD) {
                blk_dump_rq_flags(req, "MMC bad request");
                return BLKPREP_KILL;
        }
@@ -56,7 +56,6 @@ static int mmc_queue_thread(void *d)
        down(&mq->thread_sem);
        do {
                struct request *req = NULL;
-               unsigned int cmd_flags = 0;
 
                spin_lock_irq(q->queue_lock);
                set_current_state(TASK_INTERRUPTIBLE);
@@ -66,7 +65,6 @@ static int mmc_queue_thread(void *d)
 
                if (req || mq->mqrq_prev->req) {
                        set_current_state(TASK_RUNNING);
-                       cmd_flags = req ? req->cmd_flags : 0;
                        mq->issue_fn(mq, req);
                        cond_resched();
                        if (mq->flags & MMC_QUEUE_NEW_REQUEST) {
@@ -81,7 +79,7 @@ static int mmc_queue_thread(void *d)
                         * has been finished. Do not assign it to previous
                         * request.
                         */
-                       if (cmd_flags & MMC_REQ_SPECIAL_MASK)
+                       if (mmc_req_is_special(req))
                                mq->mqrq_cur->req = NULL;
 
                        mq->mqrq_prev->brq.mrq.data = NULL;

diff --git a/drivers/mmc/card/queue.h b/drivers/mmc/card/queue.h
index 36cddab57d776322c3912241f274e06620a77251..9fb26f20a44d4d5bc414e284c4a2ed456a49c3ef 100644 (file)
--- a/drivers/mmc/card/queue.h
+++ b/drivers/mmc/card/queue.h
@@ -1,7 +1,10 @@
 #ifndef MMC_QUEUE_H
 #define MMC_QUEUE_H
 
-#define MMC_REQ_SPECIAL_MASK   (REQ_DISCARD | REQ_FLUSH)
+static inline bool mmc_req_is_special(struct request *req)
+{
+       return req && (req->cmd_flags & REQ_FLUSH || req_op(req) == REQ_OP_DISCARD);
+}
 
 struct request;
 struct task_struct;

diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 74ae24364a8db33e4b76e027957951e18b44aec0..4eb9a5fb151ccd8623919caf1031e65c48765fe4 100644 (file)
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -94,7 +94,7 @@ static int do_blktrans_request(struct mtd_blktrans_ops *tr,
            get_capacity(req->rq_disk))
                return -EIO;
 
-       if (req->cmd_flags & REQ_DISCARD)
+       if (req_op(req) == REQ_OP_DISCARD)
                return tr->discard(dev, block, nsect);
 
        if (rq_data_dir(req) == READ) {

diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index 1a51584a382bf28dcf567a3fb039bc1a571cc144..089b8b8aad4f947876c969123d047a746ac8798c 100644 (file)
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -292,7 +292,7 @@ int nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
                memcpy(cmd, req->cmd, sizeof(*cmd));
        else if (req->cmd_flags & REQ_FLUSH)
                nvme_setup_flush(ns, cmd);
-       else if (req->cmd_flags & REQ_DISCARD)
+       else if (req_op(req) == REQ_OP_DISCARD)
                ret = nvme_setup_discard(ns, req, cmd);
        else
                nvme_setup_rw(ns, req, cmd);

diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index 1daa0482de0e70616c4c97c34ad1e572c2ece649..4d196d2d57da6ac4306fc5947c3cbb38b7e018ac 100644 (file)
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -177,7 +177,7 @@ static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector)
 
 static inline unsigned nvme_map_len(struct request *rq)
 {
-       if (rq->cmd_flags & REQ_DISCARD)
+       if (req_op(rq) == REQ_OP_DISCARD)
                return sizeof(struct nvme_dsm_range);
        else
                return blk_rq_bytes(rq);
@@ -185,7 +185,7 @@ static inline unsigned nvme_map_len(struct request *rq)
 
 static inline void nvme_cleanup_cmd(struct request *req)
 {
-       if (req->cmd_flags & REQ_DISCARD)
+       if (req_op(req) == REQ_OP_DISCARD)
                kfree(req->completion_data);
 }
 

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index f459dff30512efefabac12c33f18d34f5b46c541..c8dc2217d3860a640af76a05d7a76429a0f93819 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1012,7 +1012,8 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
        } else if (rq_data_dir(rq) == READ) {
                SCpnt->cmnd[0] = READ_6;
        } else {
-               scmd_printk(KERN_ERR, SCpnt, "Unknown command %llx\n", (unsigned long long) rq->cmd_flags);
+               scmd_printk(KERN_ERR, SCpnt, "Unknown command %d,%llx\n",
+                           req_op(rq), (unsigned long long) rq->cmd_flags);
                goto out;
        }
 
@@ -1137,21 +1138,27 @@ static int sd_init_command(struct scsi_cmnd *cmd)
 {
        struct request *rq = cmd->request;
 
-       if (rq->cmd_flags & REQ_DISCARD)
+       switch (req_op(rq)) {
+       case REQ_OP_DISCARD:
                return sd_setup_discard_cmnd(cmd);
-       else if (rq->cmd_flags & REQ_WRITE_SAME)
+       case REQ_OP_WRITE_SAME:
                return sd_setup_write_same_cmnd(cmd);
-       else if (rq->cmd_flags & REQ_FLUSH)
-               return sd_setup_flush_cmnd(cmd);
-       else
-               return sd_setup_read_write_cmnd(cmd);
+       case REQ_OP_READ:
+       case REQ_OP_WRITE:
+               if (rq->cmd_flags & REQ_FLUSH)
+                       return sd_setup_flush_cmnd(cmd);
+               else
+                       return sd_setup_read_write_cmnd(cmd);
+       default:
+               BUG();
+       }
 }
 
 static void sd_uninit_command(struct scsi_cmnd *SCpnt)
 {
        struct request *rq = SCpnt->request;
 
-       if (rq->cmd_flags & REQ_DISCARD)
+       if (req_op(rq) == REQ_OP_DISCARD)
                __free_page(rq->completion_data);
 
        if (SCpnt->cmnd != rq->cmd) {
@@ -1774,7 +1781,7 @@ static int sd_done(struct scsi_cmnd *SCpnt)
        unsigned char op = SCpnt->cmnd[0];
        unsigned char unmap = SCpnt->cmnd[1] & 8;
 
-       if (req->cmd_flags & REQ_DISCARD || req->cmd_flags & REQ_WRITE_SAME) {
+       if (req_op(req) == REQ_OP_DISCARD || req_op(req) == REQ_OP_WRITE_SAME) {
                if (!result) {
                        good_bytes = blk_rq_bytes(req);
                        scsi_set_resid(SCpnt, 0);