13 files changed, 56 insertions, 41 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 10a0268a1f92..11b377762b8e 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 81c78b3ce2df..30ec6b37424e 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 28db925dbdad..b82c5ce5e9df 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 218d091f3c52..2e74e7d475ca 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 6cd8b705b11b..819002ba3433 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 c1e5cd029b23..4e8b9bff3abe 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 3b419e3fffa1..5f208c0bf156 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 0536b5b29adc..034b34440ffa 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 788d93882ab9..5663d3c284c8 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 258bc2ae2885..774144334ece 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;
-                }
-                if (blk_special_request(vbr->req))
+                        break;
+                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 18a80ff57ce8..4dc298376098 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 82ed403147c0..495533e66542 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 a7b83c0a7eb5..ac278ac908d5 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);