36 files changed, 168 insertions, 131 deletions
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index a54273d2c3c..a5c08b082ed 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1111,7 +1111,7 @@ static void ata_scsi_sdev_config(struct scsi_device *sdev)
 */
 static int atapi_drain_needed(struct request *rq)
 {
-        if (likely(!blk_pc_request(rq)))
+        if (likely(rq->cmd_type != REQ_TYPE_BLOCK_PC))
                return 0;
        if (!blk_rq_bytes(rq) || (rq->cmd_flags & REQ_RW))
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 10a0268a1f9..11b377762b8 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -1783,7 +1783,7 @@ static void cciss_softirq_done(struct request *rq)
 #endif                          /* CCISS_DEBUG */
        /* set the residual count for pc requests */
-        if (blk_pc_request(rq))
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
                rq->resid_len = cmd->err_info->ResidualCnt;
        blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);
@@ -2983,7 +2983,7 @@ static inline int evaluate_target_status(ctlr_info_t *h,
        driver_byte = DRIVER_OK;
        msg_byte = cmd->err_info->CommandStatus; /* correct?  seems too device specific */
-        if (blk_pc_request(cmd->rq))
+        if (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC)
                host_byte = DID_PASSTHROUGH;
        else
                host_byte = DID_OK;
@@ -2992,7 +2992,7 @@ static inline int evaluate_target_status(ctlr_info_t *h,
                host_byte, driver_byte);
        if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
-                if (!blk_pc_request(cmd->rq))
+                if (cmd->rq->cmd_type != REQ_TYPE_BLOCK_PC)
                        printk(KERN_WARNING "cciss: cmd %p "
                               "has SCSI Status 0x%x\n",
                               cmd, cmd->err_info->ScsiStatus);
@@ -3002,15 +3002,17 @@ static inline int evaluate_target_status(ctlr_info_t *h,
        /* check the sense key */
        sense_key = 0xf & cmd->err_info->SenseInfo[2];
        /* no status or recovered error */
-        if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
+        if (((sense_key == 0x0) || (sense_key == 0x1)) &&
+            (cmd->rq->cmd_type != REQ_TYPE_BLOCK_PC))
                error_value = 0;
        if (check_for_unit_attention(h, cmd)) {
-                *retry_cmd = !blk_pc_request(cmd->rq);
+                *retry_cmd = !(cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC);
                return 0;
        }
-        if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
+        /* Not SG_IO or similar? */
+        if (cmd->rq->cmd_type != REQ_TYPE_BLOCK_PC) {
                if (error_value != 0)
                        printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
                               " sense key = 0x%x\n", cmd, sense_key);
@@ -3052,7 +3054,7 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                rq->errors = evaluate_target_status(h, cmd, &retry_cmd);
                break;
        case CMD_DATA_UNDERRUN:
-                if (blk_fs_request(cmd->rq)) {
+                if (cmd->rq->cmd_type == REQ_TYPE_FS) {
                        printk(KERN_WARNING "cciss: cmd %p has"
                               " completed with data underrun "
                               "reported\n", cmd);
@@ -3060,7 +3062,7 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                }
                break;
        case CMD_DATA_OVERRUN:
-                if (blk_fs_request(cmd->rq))
+                if (cmd->rq->cmd_type == REQ_TYPE_FS)
                        printk(KERN_WARNING "cciss: cmd %p has"
                               " completed with data overrun "
                               "reported\n", cmd);
@@ -3070,42 +3072,48 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                       "reported invalid\n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
                break;
        case CMD_PROTOCOL_ERR:
                printk(KERN_WARNING "cciss: cmd %p has "
                       "protocol error \n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
                break;
        case CMD_HARDWARE_ERR:
                printk(KERN_WARNING "cciss: cmd %p had "
                       " hardware error\n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
                break;
        case CMD_CONNECTION_LOST:
                printk(KERN_WARNING "cciss: cmd %p had "
                       "connection lost\n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
                break;
        case CMD_ABORTED:
                printk(KERN_WARNING "cciss: cmd %p was "
                       "aborted\n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ABORT);
                break;
        case CMD_ABORT_FAILED:
                printk(KERN_WARNING "cciss: cmd %p reports "
                       "abort failed\n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
                break;
        case CMD_UNSOLICITED_ABORT:
                printk(KERN_WARNING "cciss%d: unsolicited "
@@ -3121,13 +3129,15 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                               "many times\n", h->ctlr, cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ABORT);
                break;
        case CMD_TIMEOUT:
                printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
                break;
        default:
                printk(KERN_WARNING "cciss: cmd %p returned "
@@ -3135,7 +3145,8 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                       cmd->err_info->CommandStatus);
                rq->errors = make_status_bytes(SAM_STAT_GOOD,
                        cmd->err_info->CommandStatus, DRIVER_OK,
-                        blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
+                        (cmd->rq->cmd_type == REQ_TYPE_BLOCK_PC) ?
+                                DID_PASSTHROUGH : DID_ERROR);
        }
 after_error_processing:
@@ -3294,7 +3305,7 @@ static void do_cciss_request(struct request_queue *q)
                c->Header.SGList = h->max_cmd_sgentries;
        set_performant_mode(h, c);
-        if (likely(blk_fs_request(creq))) {
+        if (likely(creq->cmd_type == REQ_TYPE_FS)) {
                if(h->cciss_read == CCISS_READ_10) {
                        c->Request.CDB[1] = 0;
                        c->Request.CDB[2] = (start_blk >> 24) & 0xff; /* MSB */
@@ -3324,7 +3335,7 @@ static void do_cciss_request(struct request_queue *q)
                        c->Request.CDB[13]= blk_rq_sectors(creq) & 0xff;
                        c->Request.CDB[14] = c->Request.CDB[15] = 0;
                }
-        } else if (blk_pc_request(creq)) {
+        } else if (creq->cmd_type == REQ_TYPE_BLOCK_PC) {
                c->Request.CDBLen = creq->cmd_len;
                memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
        } else {
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index 81c78b3ce2d..30ec6b37424 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -627,7 +627,7 @@ repeat:
                req_data_dir(req) == READ ? "read" : "writ",
                cyl, head, sec, nsect, req->buffer);
 #endif
-        if (blk_fs_request(req)) {
+        if (req->cmd_type == REQ_TYPE_FS) {
                switch (rq_data_dir(req)) {
                case READ:
                        hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_READ,
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index 28db925dbda..b82c5ce5e9d 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -670,7 +670,7 @@ static void mg_request_poll(struct request_queue *q)
                                break;
                }
-                if (unlikely(!blk_fs_request(host->req))) {
+                if (unlikely(host->req->cmd_type != REQ_TYPE_FS)) {
                        mg_end_request_cur(host, -EIO);
                        continue;
                }
@@ -756,7 +756,7 @@ static void mg_request(struct request_queue *q)
                        continue;
                }
-                if (unlikely(!blk_fs_request(req))) {
+                if (unlikely(req->cmd_type != REQ_TYPE_FS)) {
                        mg_end_request_cur(host, -EIO);
                        continue;
                }
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 218d091f3c5..2e74e7d475c 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -448,7 +448,7 @@ static void nbd_clear_que(struct nbd_device *lo)
 static void nbd_handle_req(struct nbd_device *lo, struct request *req)
 {
-        if (!blk_fs_request(req))
+        if (req->cmd_type != REQ_TYPE_FS)
                goto error_out;
        nbd_cmd(req) = NBD_CMD_READ;
diff --git a/drivers/block/osdblk.c b/drivers/block/osdblk.c
index 6cd8b705b11..819002ba343 100644
--- a/drivers/block/osdblk.c
+++ b/drivers/block/osdblk.c
@@ -310,7 +310,8 @@ static void osdblk_rq_fn(struct request_queue *q)
                        break;
                /* filter out block requests we don't understand */
-                if (!blk_fs_request(rq) && !blk_barrier_rq(rq)) {
+                if (rq->cmd_type != REQ_TYPE_FS &&
+                    !(rq->cmd_flags & REQ_HARDBARRIER)) {
                        blk_end_request_all(rq, 0);
                        continue;
                }
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index c1e5cd029b2..4e8b9bff3ab 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -439,7 +439,7 @@ static char *pd_buf;		/* buffer for request in progress */
 static enum action do_pd_io_start(void)
 {
-        if (blk_special_request(pd_req)) {
+        if (pd_req->cmd_type == REQ_TYPE_SPECIAL) {
                phase = pd_special;
                return pd_special();
        }
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 3b419e3fffa..5f208c0bf15 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -196,7 +196,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
        while ((req = blk_fetch_request(q))) {
-                if (blk_fs_request(req)) {
+                if (req->cmd_type == REQ_TYPE_FS) {
                        if (ps3disk_submit_request_sg(dev, req))
                                break;
                } else if (req->cmd_type == REQ_TYPE_LINUX_BLOCK &&
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 0536b5b29ad..034b34440ff 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -648,7 +648,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
                return 0;
        }
-        if (lun->changed && !blk_pc_request(rq)) {
+        if (lun->changed && rq->cmd_type != REQ_TYPE_BLOCK_PC)
                blk_start_request(rq);
                ub_end_rq(rq, SAM_STAT_CHECK_CONDITION);
                return 0;
@@ -684,7 +684,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
        }
        urq->nsg = n_elem;
-        if (blk_pc_request(rq)) {
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                ub_cmd_build_packet(sc, lun, cmd, urq);
        } else {
                ub_cmd_build_block(sc, lun, cmd, urq);
@@ -781,7 +781,7 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        rq = urq->rq;
        if (cmd->error == 0) {
-                if (blk_pc_request(rq)) {
+                if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                        if (cmd->act_len >= rq->resid_len)
                                rq->resid_len = 0;
                        else
@@ -795,7 +795,7 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                        }
                }
        } else {
-                if (blk_pc_request(rq)) {
+                if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                        /* UB_SENSE_SIZE is smaller than SCSI_SENSE_BUFFERSIZE */
                        memcpy(rq->sense, sc->top_sense, UB_SENSE_SIZE);
                        rq->sense_len = UB_SENSE_SIZE;
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index 788d93882ab..5663d3c284c 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -361,7 +361,7 @@ static void do_viodasd_request(struct request_queue *q)
                if (req == NULL)
                        return;
                /* check that request contains a valid command */
-                if (!blk_fs_request(req)) {
+                if (req->cmd_type != REQ_TYPE_FS) {
                        viodasd_end_request(req, -EIO, blk_rq_sectors(req));
                        continue;
                }
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 258bc2ae288..774144334ec 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -65,13 +65,16 @@ static void blk_done(struct virtqueue *vq)
                        break;
                }
-                if (blk_pc_request(vbr->req)) {
+                switch (vbr->req->cmd_type) {
+                case REQ_TYPE_BLOCK_PC:
                        vbr->req->resid_len = vbr->in_hdr.residual;
                        vbr->req->sense_len = vbr->in_hdr.sense_len;
                        vbr->req->errors = vbr->in_hdr.errors;
-                }
+                        break;
-                if (blk_special_request(vbr->req))
+                case REQ_TYPE_SPECIAL:
                        vbr->req->errors = (error != 0);
+                        break;
+                }
                __blk_end_request_all(vbr->req, error);
                list_del(&vbr->list);
@@ -123,7 +126,7 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
                BUG();
        }
-        if (blk_barrier_rq(vbr->req))
+        if (vbr->req->cmd_flags & REQ_HARDBARRIER)
                vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
        sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
@@ -134,12 +137,12 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
         * block, and before the normal inhdr we put the sense data and the
         * inhdr with additional status information before the normal inhdr.
         */
-        if (blk_pc_request(vbr->req))
+        if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC)
                sg_set_buf(&vblk->sg[out++], vbr->req->cmd, vbr->req->cmd_len);
        num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
-        if (blk_pc_request(vbr->req)) {
+        if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC) {
                sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, 96);
                sg_set_buf(&vblk->sg[num + out + in++], &vbr->in_hdr,
                           sizeof(vbr->in_hdr));
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 18a80ff57ce..4dc29837609 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -322,7 +322,7 @@ static void do_xd_request (struct request_queue * q)
                int res = -EIO;
                int retry;
-                if (!blk_fs_request(req))
+                if (req->cmd_type != REQ_TYPE_FS) {
                        goto done;
                if (block + count > get_capacity(req->rq_disk))
                        goto done;
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 82ed403147c..495533e6654 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -238,7 +238,7 @@ static int blkif_queue_request(struct request *req)
        ring_req->operation = rq_data_dir(req) ?
                BLKIF_OP_WRITE : BLKIF_OP_READ;
-        if (blk_barrier_rq(req))
+        if (req->cmd_flags & REQ_HARDBARRIER)
                ring_req->operation = BLKIF_OP_WRITE_BARRIER;
        ring_req->nr_segments = blk_rq_map_sg(req->q, req, info->sg);
@@ -309,7 +309,7 @@ static void do_blkif_request(struct request_queue *rq)
                blk_start_request(req);
-                if (!blk_fs_request(req)) {
+                if (req->cmd_type != REQ_TYPE_FS) {
                        __blk_end_request_all(req, -EIO);
                        continue;
                }
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index a7b83c0a7eb..ac278ac908d 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -465,7 +465,7 @@ struct request *ace_get_next_request(struct request_queue * q)
        struct request *req;
        while ((req = blk_peek_request(q)) != NULL) {
-                if (blk_fs_request(req))
+                if (req->cmd_type == REQ_TYPE_FS)
                        break;
                blk_start_request(req);
                __blk_end_request_all(req, -EIO);
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index 03c71f7698c..7c05ddc63ae 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -643,7 +643,7 @@ static void gdrom_request(struct request_queue *rq)
        struct request *req;
        while ((req = blk_fetch_request(rq)) != NULL) {
-                if (!blk_fs_request(req)) {
+                if (req->cmd_type != REQ_TYPE_FS) {
                        printk(KERN_DEBUG "GDROM: Non-fs request ignored\n");
                        __blk_end_request_all(req, -EIO);
                        continue;
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 451cd7071b1..14e42016876 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -298,7 +298,7 @@ static void do_viocd_request(struct request_queue *q)
        struct request *req;
        while ((rwreq == 0) && ((req = blk_fetch_request(q)) != NULL)) {
-                if (!blk_fs_request(req))
+                if (req->cmd_type != REQ_TYPE_FS)
                        __blk_end_request_all(req, -EIO);
                else if (send_request(req) < 0) {
                        printk(VIOCD_KERN_WARNING
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index f9daffd7d0e..3117a894d20 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -190,7 +190,7 @@ void ide_prep_sense(ide_drive_t *drive, struct request *rq)
        BUG_ON(sense_len > sizeof(*sense));
-        if (blk_sense_request(rq) || drive->sense_rq_armed)
+        if (rq->cmd_type == REQ_TYPE_SENSE || drive->sense_rq_armed)
                return;
        memset(sense, 0, sizeof(*sense));
@@ -307,13 +307,16 @@ EXPORT_SYMBOL_GPL(ide_cd_expiry);
 int ide_cd_get_xferlen(struct request *rq)
 {
-        if (blk_fs_request(rq))
+        switch (rq->cmd_type)
+        case REQ_TYPE_FS:
                return 32768;
-        else if (blk_sense_request(rq) || blk_pc_request(rq) ||
+        case REQ_TYPE_SENSE:
-                         rq->cmd_type == REQ_TYPE_ATA_PC)
+        case REQ_TYPE_BLOCK_PC:
+        case REQ_TYPE_ATA_PC:
                return blk_rq_bytes(rq);
-        else
+        default:
                return 0;
+        }
 }
 EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
@@ -474,12 +477,12 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                if (uptodate == 0)
                        drive->failed_pc = NULL;
-                if (blk_special_request(rq)) {
+                if (rq->cmd_type == REQ_TYPE_SPECIAL)
                        rq->errors = 0;
                        error = 0;
                } else {
-                        if (blk_fs_request(rq) == 0 && uptodate <= 0) {
+                        if (req->cmd_type != REQ_TYPE_FS && uptodate <= 0) {
                                if (rq->errors == 0)
                                        rq->errors = -EIO;
                        }
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 64207df8da8..26a3688de46 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -176,7 +176,7 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
                        if (!sense->valid)
                                break;
                        if (failed_command == NULL ||
-                                        !blk_fs_request(failed_command))
+                            failed_command->cmd_type != REQ_TYPE_FS)
                                break;
                        sector = (sense->information[0] << 24) |
                                 (sense->information[1] << 16) |
@@ -292,7 +292,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
                                  "stat 0x%x",
                                  rq->cmd[0], rq->cmd_type, err, stat);
-        if (blk_sense_request(rq)) {
+        if (rq->cmd_type == REQ_TYPE_SENSE) {
                /*
                 * We got an error trying to get sense info from the drive
                 * (probably while trying to recover from a former error).
@@ -303,7 +303,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
        }
        /* if we have an error, pass CHECK_CONDITION as the SCSI status byte */
-        if (blk_pc_request(rq) && !rq->errors)
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC && !rq->errors)
                rq->errors = SAM_STAT_CHECK_CONDITION;
        if (blk_noretry_request(rq))
@@ -311,13 +311,14 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
        switch (sense_key) {
        case NOT_READY:
-                if (blk_fs_request(rq) && rq_data_dir(rq) == WRITE) {
+                if (rq->cmd_type == REQ_TYPE_FS && rq_data_dir(rq) == WRITE) {
                        if (ide_cd_breathe(drive, rq))
                                return 1;
                } else {
                        cdrom_saw_media_change(drive);
-                        if (blk_fs_request(rq) && !blk_rq_quiet(rq))
+                        if (rq->cmd_type == REQ_TYPE_FS &&
+                            !(rq->cmd_flags & REQ_QUIET)) {
                                printk(KERN_ERR PFX "%s: tray open\n",
                                        drive->name);
                }
@@ -326,7 +327,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
        case UNIT_ATTENTION:
                cdrom_saw_media_change(drive);
-                if (blk_fs_request(rq) == 0)
+                if (rq->cmd_type != REQ_TYPE_FS)
                        return 0;
                /*
@@ -352,7 +353,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
                 * No point in retrying after an illegal request or data
                 * protect error.
                 */
-                if (!blk_rq_quiet(rq))
+                if (!(rq->cmd_flags & REQ_QUIET))
                        ide_dump_status(drive, "command error", stat);
                do_end_request = 1;
                break;
@@ -361,20 +362,20 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
                 * No point in re-trying a zillion times on a bad sector.
                 * If we got here the error is not correctable.
                 */
-                if (!blk_rq_quiet(rq))
+                if (!(rq->cmd_flags & REQ_QUIET))
                        ide_dump_status(drive, "media error "
                                        "(bad sector)", stat);
                do_end_request = 1;
                break;
        case BLANK_CHECK:
                /* disk appears blank? */
-                if (!blk_rq_quiet(rq))
+                if (!(rq->cmd_flags & REQ_QUIET))
                        ide_dump_status(drive, "media error (blank)",
                                        stat);
                do_end_request = 1;
                break;
        default:
-                if (blk_fs_request(rq) == 0)
+                if (req->cmd_type != REQ_TYPE_FS)
                        break;
                if (err & ~ATA_ABORTED) {
                        /* go to the default handler for other errors */
@@ -385,7 +386,7 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
                        do_end_request = 1;
        }
-        if (blk_fs_request(rq) == 0) {
+        if (rq->cmd_type != REQ_TYPE_FS) {
                rq->cmd_flags |= REQ_FAILED;
                do_end_request = 1;
        }
@@ -525,7 +526,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
        ide_expiry_t *expiry = NULL;
        int dma_error = 0, dma, thislen, uptodate = 0;
        int write = (rq_data_dir(rq) == WRITE) ? 1 : 0, rc = 0;
-        int sense = blk_sense_request(rq);
+        int sense = (rq->cmd_type == REQ_TYPE_SENSE);
        unsigned int timeout;
        u16 len;
        u8 ireason, stat;
@@ -568,7 +569,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
        ide_read_bcount_and_ireason(drive, &len, &ireason);
-        thislen = blk_fs_request(rq) ? len : cmd->nleft;
+        thislen = (rq->cmd_type == REQ_TYPE_FS) ? len : cmd->nleft;
        if (thislen > len)
                thislen = len;
@@ -577,7 +578,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
        /* If DRQ is clear, the command has completed. */
        if ((stat & ATA_DRQ) == 0) {
-                if (blk_fs_request(rq)) {
+                if (rq->cmd_type == REQ_TYPE_FS) {
                        /*
                         * If we're not done reading/writing, complain.
                         * Otherwise, complete the command normally.
@@ -591,7 +592,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                                        rq->cmd_flags |= REQ_FAILED;
                                uptodate = 0;
                        }
-                } else if (!blk_pc_request(rq)) {
+                } else if (rq->cmd_type != REQ_TYPE_BLOCK_PC) {
                        ide_cd_request_sense_fixup(drive, cmd);
                        uptodate = cmd->nleft ? 0 : 1;
@@ -640,7 +641,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
        /* pad, if necessary */
        if (len > 0) {
-                if (blk_fs_request(rq) == 0 || write == 0)
+                if (rq->cmd_type != REQ_TYPE_FS || write == 0)
                        ide_pad_transfer(drive, write, len);
                else {
                        printk(KERN_ERR PFX "%s: confused, missing data\n",
@@ -649,11 +650,11 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
                }
        }
-        if (blk_pc_request(rq)) {
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                timeout = rq->timeout;
        } else {
                timeout = ATAPI_WAIT_PC;
-                if (!blk_fs_request(rq))
+                if (rq->cmd_type != REQ_TYPE_FS)
                        expiry = ide_cd_expiry;
        }
@@ -662,7 +663,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
        return ide_started;
 out_end:
-        if (blk_pc_request(rq) && rc == 0) {
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC && rc == 0) {
                rq->resid_len = 0;
                blk_end_request_all(rq, 0);
                hwif->rq = NULL;
@@ -670,7 +671,7 @@ out_end:
                if (sense && uptodate)
                        ide_cd_complete_failed_rq(drive, rq);
-                if (blk_fs_request(rq)) {
+                if (rq->cmd_type == REQ_TYPE_FS) {
                        if (cmd->nleft == 0)
                                uptodate = 1;
                } else {
@@ -682,7 +683,7 @@ out_end:
                        ide_cd_error_cmd(drive, cmd);
                /* make sure it's fully ended */
-                if (blk_fs_request(rq) == 0) {
+                if (rq->cmd_type != REQ_TYPE_FS) {
                        rq->resid_len -= cmd->nbytes - cmd->nleft;
                        if (uptodate == 0 && (cmd->tf_flags & IDE_TFLAG_WRITE))
                                rq->resid_len += cmd->last_xfer_len;
@@ -742,7 +743,7 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
        ide_debug_log(IDE_DBG_PC, "rq->cmd[0]: 0x%x, rq->cmd_type: 0x%x",
                                  rq->cmd[0], rq->cmd_type);
-        if (blk_pc_request(rq))
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
                rq->cmd_flags |= REQ_QUIET;
        else
                rq->cmd_flags &= ~REQ_FAILED;
@@ -783,21 +784,26 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
        if (drive->debug_mask & IDE_DBG_RQ)
                blk_dump_rq_flags(rq, "ide_cd_do_request");
-        if (blk_fs_request(rq)) {
+        switch (rq->cmd_type) {
+        case REQ_TYPE_FS:
                if (cdrom_start_rw(drive, rq) == ide_stopped)
                        goto out_end;
-        } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
+                break;
-                   rq->cmd_type == REQ_TYPE_ATA_PC) {
+        case REQ_TYPE_SENSE:
+        case REQ_TYPE_BLOCK_PC:
+        case REQ_TYPE_ATA_PC:
                if (!rq->timeout)
                        rq->timeout = ATAPI_WAIT_PC;
                cdrom_do_block_pc(drive, rq);
-        } else if (blk_special_request(rq)) {
+                break;
+        case REQ_TYPE_SPECIAL:
                /* right now this can only be a reset... */
                uptodate = 1;
                goto out_end;
-        } else
+        default:
                BUG();
+        }
        /* prepare sense request for this command */
        ide_prep_sense(drive, rq);
@@ -809,7 +815,7 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
        cmd.rq = rq;
-        if (blk_fs_request(rq) || blk_rq_bytes(rq)) {
+        if (rq->cmd_type == REQ_TYPE_FS || blk_rq_bytes(rq)) {
                ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
                ide_map_sg(drive, &cmd);
        }
@@ -1365,9 +1371,9 @@ static int ide_cdrom_prep_pc(struct request *rq)
 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
 {
-        if (blk_fs_request(rq))
+        if (rq->cmd_type == REQ_TYPE_FS)
                return ide_cdrom_prep_fs(q, rq);
-        else if (blk_pc_request(rq))
+        else if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
                return ide_cdrom_prep_pc(rq);
        return 0;
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 33d65039cce..df3d91ba1c9 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -184,7 +184,7 @@ static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
        ide_hwif_t *hwif = drive->hwif;
        BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
-        BUG_ON(!blk_fs_request(rq));
+        BUG_ON(rq->cmd_type != REQ_TYPE_FS);
        ledtrig_ide_activity();
diff --git a/drivers/ide/ide-eh.c b/drivers/ide/ide-eh.c
index e9abf2c3c33..c0aa93fb7a6 100644
--- a/drivers/ide/ide-eh.c
+++ b/drivers/ide/ide-eh.c
@@ -122,7 +122,7 @@ ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, u8 stat)
                return ide_stopped;
        /* retry only "normal" I/O: */
-        if (!blk_fs_request(rq)) {
+        if (rq->cmd_type != REQ_TYPE_FS) {
                if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                        struct ide_cmd *cmd = rq->special;
@@ -146,7 +146,8 @@ static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
 {
        struct request *rq = drive->hwif->rq;
-        if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET) {
+        if (rq && rq->cmd_type == REQ_TYPE_SPECIAL &&
+            rq->cmd[0] == REQ_DRIVE_RESET) {
                if (err <= 0 && rq->errors == 0)
                        rq->errors = -EIO;
                ide_complete_rq(drive, err ? err : 0, blk_rq_bytes(rq));
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 4713bdca20b..c7d0737bb18 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -73,7 +73,7 @@ static int ide_floppy_callback(ide_drive_t *drive, int dsc)
                drive->failed_pc = NULL;
        if (pc->c[0] == GPCMD_READ_10 || pc->c[0] == GPCMD_WRITE_10 ||
-            (rq && blk_pc_request(rq)))
+            (rq && rq->cmd_type == REQ_TYPE_BLOCK_PC))
                uptodate = 1; /* FIXME */
        else if (pc->c[0] == GPCMD_REQUEST_SENSE) {
@@ -98,7 +98,7 @@ static int ide_floppy_callback(ide_drive_t *drive, int dsc)
                               "Aborting request!\n");
        }
-        if (blk_special_request(rq))
+        if (rq->cmd_type == REQ_TYPE_SPECIAL)
                rq->errors = uptodate ? 0 : IDE_DRV_ERROR_GENERAL;
        return uptodate;
@@ -247,14 +247,16 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
                } else
                        printk(KERN_ERR PFX "%s: I/O error\n", drive->name);
-                if (blk_special_request(rq)) {
+                if (rq->cmd_type == REQ_TYPE_SPECIAL) {
                        rq->errors = 0;
                        ide_complete_rq(drive, 0, blk_rq_bytes(rq));
                        return ide_stopped;
                } else
                        goto out_end;
        }
-        if (blk_fs_request(rq)) {
+        switch (rq->cmd_type) {
+        case REQ_TYPE_FS:
                if (((long)blk_rq_pos(rq) % floppy->bs_factor) ||
                    (blk_rq_sectors(rq) % floppy->bs_factor)) {
                        printk(KERN_ERR PFX "%s: unsupported r/w rq size\n",
@@ -263,13 +265,18 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
                }
                pc = &floppy->queued_pc;
                idefloppy_create_rw_cmd(drive, pc, rq, (unsigned long)block);
-        } else if (blk_special_request(rq) || blk_sense_request(rq)) {
+                break;
+        case REQ_TYPE_SPECIAL:
+        case REQ_TYPE_SENSE:
                pc = (struct ide_atapi_pc *)rq->special;
-        } else if (blk_pc_request(rq)) {
+                break;
+        case REQ_TYPE_BLOCK_PC:
                pc = &floppy->queued_pc;
                idefloppy_blockpc_cmd(floppy, pc, rq);
-        } else
+                break;
+        default:
                BUG();
+        }
        ide_prep_sense(drive, rq);
@@ -280,7 +287,7 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
        cmd.rq = rq;
-        if (blk_fs_request(rq) || blk_rq_bytes(rq)) {
+        if (rq->cmd_type == REQ_TYPE_FS || blk_rq_bytes(rq)) {
                ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
                ide_map_sg(drive, &cmd);
        }
@@ -290,7 +297,7 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
        return ide_floppy_issue_pc(drive, &cmd, pc);
 out_end:
        drive->failed_pc = NULL;
-        if (blk_fs_request(rq) == 0 && rq->errors == 0)
+        if (rq->cmd_type != REQ_TYPE_FS && rq->errors == 0)
                rq->errors = -EIO;
        ide_complete_rq(drive, -EIO, blk_rq_bytes(rq));
        return ide_stopped;
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 172ac921815..9304a7e54d9 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -135,7 +135,7 @@ EXPORT_SYMBOL(ide_complete_rq);
 void ide_kill_rq(ide_drive_t *drive, struct request *rq)
 {
-        u8 drv_req = blk_special_request(rq) && rq->rq_disk;
+        u8 drv_req = (rq->cmd_type == REQ_TYPE_SPECIAL) && rq->rq_disk;
        u8 media = drive->media;
        drive->failed_pc = NULL;
@@ -145,7 +145,7 @@ void ide_kill_rq(ide_drive_t *drive, struct request *rq)
        } else {
                if (media == ide_tape)
                        rq->errors = IDE_DRV_ERROR_GENERAL;
-                else if (blk_fs_request(rq) == 0 && rq->errors == 0)
+                else if (rq->cmd_type != REQ_TYPE_FS && rq->errors == 0)
                        rq->errors = -EIO;
        }
@@ -307,7 +307,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
 {
        ide_startstop_t startstop;
-        BUG_ON(!blk_rq_started(rq));
+        BUG_ON(!(rq->cmd_flags & REQ_STARTED));
 #ifdef DEBUG
        printk("%s: start_request: current=0x%08lx\n",
@@ -353,7 +353,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
                            pm->pm_step == IDE_PM_COMPLETED)
                                ide_complete_pm_rq(drive, rq);
                        return startstop;
-                } else if (!rq->rq_disk && blk_special_request(rq))
+                } else if (!rq->rq_disk && rq->cmd_type == REQ_TYPE_SPECIAL) {
                        /*
                         * TODO: Once all ULDs have been modified to
                         * check for specific op codes rather than
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index 1c08311b0a0..92406097efe 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -191,10 +191,10 @@ void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 #ifdef DEBUG_PM
        printk("%s: completing PM request, %s\n", drive->name,
-               blk_pm_suspend_request(rq) ? "suspend" : "resume");
+               (rq->cmd_type == REQ_TYPE_PM_SUSPEND) ? "suspend" : "resume");
 #endif
        spin_lock_irqsave(q->queue_lock, flags);
-        if (blk_pm_suspend_request(rq))
+        if (rq->cmd_type == REQ_TYPE_PM_SUSPEND)
                blk_stop_queue(q);
        else
                drive->dev_flags &= ~IDE_DFLAG_BLOCKED;
@@ -210,11 +210,11 @@ void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
 {
        struct request_pm_state *pm = rq->special;
-        if (blk_pm_suspend_request(rq) &&
+        if (rq->cmd_type == REQ_TYPE_PM_SUSPEND &&
            pm->pm_step == IDE_PM_START_SUSPEND)
                /* Mark drive blocked when starting the suspend sequence. */
                drive->dev_flags |= IDE_DFLAG_BLOCKED;
-        else if (blk_pm_resume_request(rq) &&
+        else if (rq->cmd_type == REQ_TYPE_PM_RESUME &&
                 pm->pm_step == IDE_PM_START_RESUME) {
                /*
                 * The first thing we do on wakeup is to wait for BSY bit to
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index b07232880ec..635fd72d472 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -577,7 +577,8 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                      rq->cmd[0], (unsigned long long)blk_rq_pos(rq),
                      blk_rq_sectors(rq));
-        BUG_ON(!(blk_special_request(rq) || blk_sense_request(rq)));
+        BUG_ON(!(rq->cmd_type == REQ_TYPE_SPECIAL ||
+                 rq->cmd_type == REQ_TYPE_SENSE));
        /* Retry a failed packet command */
        if (drive->failed_pc && drive->pc->c[0] == REQUEST_SENSE) {
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index d21e1284604..1e0e6dd5150 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -792,12 +792,12 @@ static void dm_end_request(struct request *clone, int error)
 {
        int rw = rq_data_dir(clone);
        int run_queue = 1;
-        bool is_barrier = blk_barrier_rq(clone);
+        bool is_barrier = clone->cmd_flags & REQ_HARDBARRIER;
        struct dm_rq_target_io *tio = clone->end_io_data;
        struct mapped_device *md = tio->md;
        struct request *rq = tio->orig;
-        if (blk_pc_request(rq) && !is_barrier) {
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC && !is_barrier) {
                rq->errors = clone->errors;
                rq->resid_len = clone->resid_len;
@@ -844,7 +844,7 @@ void dm_requeue_unmapped_request(struct request *clone)
        struct request_queue *q = rq->q;
        unsigned long flags;
-        if (unlikely(blk_barrier_rq(clone))) {
+        if (unlikely(clone->cmd_flags & REQ_HARDBARRIER)) {
                /*
                 * Barrier clones share an original request.
                 * Leave it to dm_end_request(), which handles this special
@@ -943,7 +943,7 @@ static void dm_complete_request(struct request *clone, int error)
        struct dm_rq_target_io *tio = clone->end_io_data;
        struct request *rq = tio->orig;
-        if (unlikely(blk_barrier_rq(clone))) {
+        if (unlikely(clone->cmd_flags & REQ_HARDBARRIER)) {
                /*
                 * Barrier clones share an original request.  So can't use
                 * softirq_done with the original.
@@ -972,7 +972,7 @@ void dm_kill_unmapped_request(struct request *clone, int error)
        struct dm_rq_target_io *tio = clone->end_io_data;
        struct request *rq = tio->orig;
-        if (unlikely(blk_barrier_rq(clone))) {
+        if (unlikely(clone->cmd_flags & REQ_HARDBARRIER)) {
                /*
                 * Barrier clones share an original request.
                 * Leave it to dm_end_request(), which handles this special
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 8327e248520..56645408d22 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -805,7 +805,8 @@ static void mspro_block_start(struct memstick_dev *card)
 static int mspro_block_prepare_req(struct request_queue *q, struct request *req)
 {
-        if (!blk_fs_request(req) && !blk_pc_request(req)) {
+        if (req->cmd_type != REQ_TYPE_FS &&
+            req->cmd_type != REQ_TYPE_BLOCK_PC) {
                blk_dump_rq_flags(req, "MSPro unsupported request");
                return BLKPREP_KILL;
        }
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index fc593fbab69..108f0c2b2bf 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -883,7 +883,7 @@ static void i2o_block_request_fn(struct request_queue *q)
                if (!req)
                        break;
-                if (blk_fs_request(req)) {
+                if (req->cmd_type == REQ_TYPE_FS) {
                        struct i2o_block_delayed_request *dreq;
                        struct i2o_block_request *ireq = req->special;
                        unsigned int queue_depth;
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index d6ded247d94..ec92bcbdedd 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -32,7 +32,7 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
        /*
         * We only like normal block requests.
         */
-        if (!blk_fs_request(req)) {
+        if (req->cmd_type != REQ_TYPE_FS) {
                blk_dump_rq_flags(req, "MMC bad request");
                return BLKPREP_KILL;
        }
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 03e19c1965c..475af42745c 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -73,14 +73,14 @@ static int do_blktrans_request(struct mtd_blktrans_ops *tr,
        buf = req->buffer;
-        if (!blk_fs_request(req))
+        if (req->cmd_type != REQ_TYPE_FS)
                return -EIO;
        if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
            get_capacity(req->rq_disk))
                return -EIO;
-        if (blk_discard_rq(req))
+        if (req->cmd_flags & REQ_DISCARD)
                return tr->discard(dev, block, nsect);
        switch(rq_data_dir(req)) {
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index a5d630f5f51..1b88af89d0c 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -307,7 +307,7 @@ static int scsi_check_sense(struct scsi_cmnd *scmd)
                    (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
                        return FAILED;
-                if (blk_barrier_rq(scmd->request))
+                if (scmd->request->cmd_flags & REQ_HARDBARRIER)
                        /*
                         * barrier requests should always retry on UA
                         * otherwise block will get a spurious error
@@ -1318,16 +1318,16 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
        case DID_OK:
                break;
        case DID_BUS_BUSY:
-                return blk_failfast_transport(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_TRANSPORT);
        case DID_PARITY:
-                return blk_failfast_dev(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);
        case DID_ERROR:
                if (msg_byte(scmd->result) == COMMAND_COMPLETE &&
                    status_byte(scmd->result) == RESERVATION_CONFLICT)
                        return 0;
                /* fall through */
        case DID_SOFT_ERROR:
-                return blk_failfast_driver(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_DRIVER);
        }
        switch (status_byte(scmd->result)) {
@@ -1336,7 +1336,7 @@ int scsi_noretry_cmd(struct scsi_cmnd *scmd)
                 * assume caller has checked sense and determinted
                 * the check condition was retryable.
                 */
-                return blk_failfast_dev(scmd->request);
+                return (scmd->request->cmd_flags & REQ_FAILFAST_DEV);
        }
        return 0;
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 1646fe7cbd4..5f1160841b0 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -722,7 +722,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                        sense_deferred = scsi_sense_is_deferred(&sshdr);
        }
-        if (blk_pc_request(req)) { /* SG_IO ioctl from block level */
+        if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */
                req->errors = result;
                if (result) {
                        if (sense_valid && req->sense) {
@@ -757,7 +757,8 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                }
        }
-        BUG_ON(blk_bidi_rq(req)); /* bidi not support for !blk_pc_request yet */
+        /* no bidi support for !REQ_TYPE_BLOCK_PC yet */
+        BUG_ON(blk_bidi_rq(req));
        /*
         * Next deal with any sectors which we were able to correctly
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 8802e48bc06..a3fdf4dc59d 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -485,7 +485,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
         * Discard request come in as REQ_TYPE_FS but we turn them into
         * block PC requests to make life easier.
         */
-        if (blk_discard_rq(rq))
+        if (rq->cmd_flags & REQ_DISCARD)
                ret = sd_prepare_discard(rq);
        if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
@@ -636,7 +636,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
                SCpnt->cmnd[7] = 0x18;
                SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
-                SCpnt->cmnd[10] = protect | (blk_fua_rq(rq) ? 0x8 : 0);
+                SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
                /* LBA */
                SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
@@ -661,7 +661,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
        } else if (block > 0xffffffff) {
                SCpnt->cmnd[0] += READ_16 - READ_6;
-                SCpnt->cmnd[1] = protect | (blk_fua_rq(rq) ? 0x8 : 0);
+                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
                SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
                SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
                SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
@@ -682,7 +682,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                        this_count = 0xffff;
                SCpnt->cmnd[0] += READ_10 - READ_6;
-                SCpnt->cmnd[1] = protect | (blk_fua_rq(rq) ? 0x8 : 0);
+                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
                SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
                SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
                SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
@@ -691,7 +691,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
                SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
        } else {
-                if (unlikely(blk_fua_rq(rq))) {
+                if (unlikely(rq->cmd_flags & REQ_FUA)) {
                        /*
                         * This happens only if this drive failed
                         * 10byte rw command with ILLEGAL_REQUEST
@@ -1112,7 +1112,7 @@ static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
        u64 bad_lba;
        int info_valid;
-        if (!blk_fs_request(scmd->request))
+        if (scmd->request->cmd_type != REQ_TYPE_FS)
                return 0;
        info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index b5838d547c6..713620ed70d 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -2022,7 +2022,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance)
                if((count > SUN3_DMA_MINSIZE) && (sun3_dma_setup_done
                                                  != cmd))
                {
-                        if(blk_fs_request(cmd->request)) {
+                        if (cmd->request->cmd_type == REQ_TYPE_FS) {
                                sun3scsi_dma_setup(d, count,
                                                   rq_data_dir(cmd->request));
                                sun3_dma_setup_done = cmd;
diff --git a/drivers/scsi/sun3_scsi.c b/drivers/scsi/sun3_scsi.c
index e606cf0a2eb..613f5880d13 100644
--- a/drivers/scsi/sun3_scsi.c
+++ b/drivers/scsi/sun3_scsi.c
@@ -524,7 +524,7 @@ static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted,
                                                  struct scsi_cmnd *cmd,
                                                  int write_flag)
 {
-        if(blk_fs_request(cmd->request))
+        if (cmd->request->cmd_type == REQ_TYPE_FS)
                return wanted;
        else
                return 0;
diff --git a/drivers/scsi/sun3_scsi_vme.c b/drivers/scsi/sun3_scsi_vme.c
index aaa4fd0dd1b..7c526b8e30a 100644
--- a/drivers/scsi/sun3_scsi_vme.c
+++ b/drivers/scsi/sun3_scsi_vme.c
@@ -458,7 +458,7 @@ static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted,
                                                  struct scsi_cmnd *cmd,
                                                  int write_flag)
 {
-        if(blk_fs_request(cmd->request))
+        if (cmd->request->cmd_type == REQ_TYPE_FS)
                return wanted;
        else
                return 0;
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 61bd0be5fb1..a9aff90e58e 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -823,7 +823,8 @@ static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req)
                        blkvsc_req->cmnd[0] = READ_16;
                }
-                blkvsc_req->cmnd[1] |= blk_fua_rq(blkvsc_req->req) ? 0x8 : 0;
+                blkvsc_req->cmnd[1] |=
+                        (blkvsc_req->req->cmd_flags & REQ_FUA) ? 0x8 : 0;
                *(unsigned long long *)&blkvsc_req->cmnd[2] =
                                cpu_to_be64(blkvsc_req->sector_start);
@@ -839,7 +840,8 @@ static void blkvsc_init_rw(struct blkvsc_request *blkvsc_req)
                        blkvsc_req->cmnd[0] = READ_10;
                }
-                blkvsc_req->cmnd[1] |= blk_fua_rq(blkvsc_req->req) ? 0x8 : 0;
+                blkvsc_req->cmnd[1] |=
+                        (blkvsc_req->req->cmd_flags & REQ_FUA) ? 0x8 : 0;
                *(unsigned int *)&blkvsc_req->cmnd[2] =
                                cpu_to_be32(blkvsc_req->sector_start);
@@ -1286,7 +1288,7 @@ static void blkvsc_request(struct request_queue *queue)
                DPRINT_DBG(BLKVSC_DRV, "- req %p\n", req);
                blkdev = req->rq_disk->private_data;
-                if (blkdev->shutting_down || !blk_fs_request(req) ||
+                if (blkdev->shutting_down || req->cmd_type != REQ_TYPE_FS ||
                    blkdev->media_not_present) {
                        __blk_end_request_cur(req, 0);
                        continue;