[PATCH] Split struct request ->flags into two parts

Right now ->flags is a bit of a mess: some are request types, and
others are just modifiers. Clean this up by splitting it into
->cmd_type and ->cmd_flags. This allows introduction of generic
Linux block message types, useful for sending generic Linux commands
to block devices.

Signed-off-by: Jens Axboe <axboe@suse.de>

32 files changed, 142 insertions, 135 deletions

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index ad1d7065a1b2..629c5769d994 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2991,8 +2991,8 @@ static void do_fd_request(request_queue_t * q)
         if (usage_count == 0) {
                 printk("warning: usage count=0, current_req=%p exiting\n",
                        current_req);
-                printk("sect=%ld flags=%lx\n", (long)current_req->sector,
-                       current_req->flags);
+                printk("sect=%ld type=%x flags=%x\n", (long)current_req->sector,
+                       current_req->cmd_type, current_req->cmd_flags);
                 return;
         }
         if (test_bit(0, &fdc_busy)) {
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index bdbade9a5cf5..9d1035e8d9d8 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -407,10 +407,10 @@ static void do_nbd_request(request_queue_t * q)
                 struct nbd_device *lo;
 
                 blkdev_dequeue_request(req);
-                dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%lx)\n",
-                                req->rq_disk->disk_name, req, req->flags);
+                dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
+                                req->rq_disk->disk_name, req, req->cmd_type);
 
-                if (!(req->flags & REQ_CMD))
+                if (!blk_fs_request(req))
                         goto error_out;
 
                 lo = req->rq_disk->private_data;
@@ -489,7 +489,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         switch (cmd) {
         case NBD_DISCONNECT:
                 printk(KERN_INFO "%s: NBD_DISCONNECT\n", lo->disk->disk_name);
-                sreq.flags = REQ_SPECIAL;
+                sreq.cmd_type = REQ_TYPE_SPECIAL;
                 nbd_cmd(&sreq) = NBD_CMD_DISC;
                 /*
                  * Set these to sane values in case server implementation
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 2403721f9db1..12ff1a274d91 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -437,7 +437,7 @@ static char *pd_buf;		/* buffer for request in progress */
 
 static enum action do_pd_io_start(void)
 {
-        if (pd_req->flags & REQ_SPECIAL) {
+        if (blk_special_request(pd_req)) {
                 phase = pd_special;
                 return pd_special();
         }
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 451b996bba91..42891d2b054e 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -365,16 +365,16 @@ static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *
         rq->sense = sense;
         memset(sense, 0, sizeof(sense));
         rq->sense_len = 0;
-        rq->flags |= REQ_BLOCK_PC | REQ_HARDBARRIER;
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
+        rq->cmd_flags |= REQ_HARDBARRIER;
         if (cgc->quiet)
-                rq->flags |= REQ_QUIET;
+                rq->cmd_flags |= REQ_QUIET;
         memcpy(rq->cmd, cgc->cmd, CDROM_PACKET_SIZE);
         if (sizeof(rq->cmd) > CDROM_PACKET_SIZE)
                 memset(rq->cmd + CDROM_PACKET_SIZE, 0, sizeof(rq->cmd) - CDROM_PACKET_SIZE);
         rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
 
         rq->ref_count++;
-        rq->flags |= REQ_NOMERGE;
         rq->waiting = &wait;
         rq->end_io = blk_end_sync_rq;
         elv_add_request(q, rq, ELEVATOR_INSERT_BACK, 1);
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index e828e4cbd3e1..ebf3025721d1 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -313,7 +313,7 @@ static void do_xd_request (request_queue_t * q)
                 int res = 0;
                 int retry;
 
-                if (!(req->flags & REQ_CMD)) {
+                if (!blk_fs_request(req)) {
                         end_request(req, 0);
                         continue;
                 }
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index d239cf8b20bd..b38c84a7a8e3 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -2129,7 +2129,7 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
                 rq->cmd[9] = 0xf8;
 
                 rq->cmd_len = 12;
-                rq->flags |= REQ_BLOCK_PC;
+                rq->cmd_type = REQ_TYPE_BLOCK_PC;
                 rq->timeout = 60 * HZ;
                 bio = rq->bio;
 
diff --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index 37bdb0163f0d..ccd91c1a84bd 100644
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -1338,8 +1338,10 @@ static void do_cdu31a_request(request_queue_t * q)
                 }
 
                 /* WTF??? */
-                if (!(req->flags & REQ_CMD))
+                if (!blk_fs_request(req)) {
+                        end_request(req, 0);
                         continue;
+                }
                 if (rq_data_dir(req) == WRITE) {
                         end_request(req, 0);
                         continue;
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 654d4cd09847..69bbb6206a00 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -372,7 +372,7 @@ static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
 {
         int log = 0;
 
-        if (!sense || !rq || (rq->flags & REQ_QUIET))
+        if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
                 return 0;
 
         switch (sense->sense_key) {
@@ -597,7 +597,7 @@ static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
         struct cdrom_info *cd = drive->driver_data;
 
         ide_init_drive_cmd(rq);
-        rq->flags = REQ_PC;
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->rq_disk = cd->disk;
 }
 
@@ -617,7 +617,7 @@ static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
         rq->cmd[0] = GPCMD_REQUEST_SENSE;
         rq->cmd[4] = rq->data_len = 18;
 
-        rq->flags = REQ_SENSE;
+        rq->cmd_type = REQ_TYPE_SENSE;
 
         /* NOTE! Save the failed command in "rq->buffer" */
         rq->buffer = (void *) failed_command;
@@ -630,10 +630,10 @@ static void cdrom_end_request (ide_drive_t *drive, int uptodate)
         struct request *rq = HWGROUP(drive)->rq;
         int nsectors = rq->hard_cur_sectors;
 
-        if ((rq->flags & REQ_SENSE) && uptodate) {
+        if (blk_sense_request(rq) && uptodate) {
                 /*
-                 * For REQ_SENSE, "rq->buffer" points to the original failed
-                 * request
+                 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
+                 * failed request
                  */
                 struct request *failed = (struct request *) rq->buffer;
                 struct cdrom_info *info = drive->driver_data;
@@ -706,17 +706,17 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                 return 1;
         }
 
-        if (rq->flags & REQ_SENSE) {
+        if (blk_sense_request(rq)) {
                 /* We got an error trying to get sense info
                    from the drive (probably while trying
                    to recover from a former error).  Just give up. */
 
-                rq->flags |= REQ_FAILED;
+                rq->cmd_flags |= REQ_FAILED;
                 cdrom_end_request(drive, 0);
                 ide_error(drive, "request sense failure", stat);
                 return 1;
 
-        } else if (rq->flags & (REQ_PC | REQ_BLOCK_PC)) {
+        } else if (blk_pc_request(rq)) {
                 /* All other functions, except for READ. */
                 unsigned long flags;
 
@@ -724,7 +724,7 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                  * if we have an error, pass back CHECK_CONDITION as the
                  * scsi status byte
                  */
-                if ((rq->flags & REQ_BLOCK_PC) && !rq->errors)
+                if (!rq->errors)
                         rq->errors = SAM_STAT_CHECK_CONDITION;
 
                 /* Check for tray open. */
@@ -735,12 +735,12 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                         cdrom_saw_media_change (drive);
                         /*printk("%s: media changed\n",drive->name);*/
                         return 0;
-                } else if (!(rq->flags & REQ_QUIET)) {
+                } else if (!(rq->cmd_flags & REQ_QUIET)) {
                         /* Otherwise, print an error. */
                         ide_dump_status(drive, "packet command error", stat);
                 }
                 
-                rq->flags |= REQ_FAILED;
+                rq->cmd_flags |= REQ_FAILED;
 
                 /*
                  * instead of playing games with moving completions around,
@@ -881,7 +881,7 @@ static int cdrom_timer_expiry(ide_drive_t *drive)
                         wait = ATAPI_WAIT_PC;
                         break;
                 default:
-                        if (!(rq->flags & REQ_QUIET))
+                        if (!(rq->cmd_flags & REQ_QUIET))
                                 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
                         wait = 0;
                         break;
@@ -1124,7 +1124,7 @@ static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
                 if (rq->current_nr_sectors > 0) {
                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
                                 drive->name, rq->current_nr_sectors);
-                        rq->flags |= REQ_FAILED;
+                        rq->cmd_flags |= REQ_FAILED;
                         cdrom_end_request(drive, 0);
                 } else
                         cdrom_end_request(drive, 1);
@@ -1456,7 +1456,7 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
                         printk ("%s: cdrom_pc_intr: data underrun %d\n",
                                 drive->name, pc->buflen);
                         */
-                        rq->flags |= REQ_FAILED;
+                        rq->cmd_flags |= REQ_FAILED;
                         cdrom_end_request(drive, 0);
                 }
                 return ide_stopped;
@@ -1509,7 +1509,7 @@ static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
                 rq->data += thislen;
                 rq->data_len -= thislen;
 
-                if (rq->flags & REQ_SENSE)
+                if (blk_sense_request(rq))
                         rq->sense_len += thislen;
         } else {
 confused:
@@ -1517,7 +1517,7 @@ confused:
                         "appears confused (ireason = 0x%02x). "
                         "Trying to recover by ending request.\n",
                         drive->name, ireason);
-                rq->flags |= REQ_FAILED;
+                rq->cmd_flags |= REQ_FAILED;
                 cdrom_end_request(drive, 0);
                 return ide_stopped;
         }
@@ -1546,7 +1546,7 @@ static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
         struct cdrom_info *info = drive->driver_data;
 
         info->dma = 0;
-        rq->flags &= ~REQ_FAILED;
+        rq->cmd_flags &= ~REQ_FAILED;
         len = rq->data_len;
 
         /* Start sending the command to the drive. */
@@ -1558,7 +1558,7 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
 {
         struct request_sense sense;
         int retries = 10;
-        unsigned int flags = rq->flags;
+        unsigned int flags = rq->cmd_flags;
 
         if (rq->sense == NULL)
                 rq->sense = &sense;
@@ -1567,14 +1567,14 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
         do {
                 int error;
                 unsigned long time = jiffies;
-                rq->flags = flags;
+                rq->cmd_flags = flags;
 
                 error = ide_do_drive_cmd(drive, rq, ide_wait);
                 time = jiffies - time;
 
                 /* FIXME: we should probably abort/retry or something 
                  * in case of failure */
-                if (rq->flags & REQ_FAILED) {
+                if (rq->cmd_flags & REQ_FAILED) {
                         /* The request failed.  Retry if it was due to a unit
                            attention status
                            (usually means media was changed). */
@@ -1596,10 +1596,10 @@ static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
                 }
 
                 /* End of retry loop. */
-        } while ((rq->flags & REQ_FAILED) && retries >= 0);
+        } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
 
         /* Return an error if the command failed. */
-        return (rq->flags & REQ_FAILED) ? -EIO : 0;
+        return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
 }
 
 /*
@@ -1963,7 +1963,7 @@ static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 {
         struct cdrom_info *info = drive->driver_data;
 
-        rq->flags |= REQ_QUIET;
+        rq->cmd_flags |= REQ_QUIET;
 
         info->dma = 0;
 
@@ -2023,11 +2023,11 @@ ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
                 }
                 info->last_block = block;
                 return action;
-        } else if (rq->flags & (REQ_PC | REQ_SENSE)) {
+        } else if (rq->cmd_type == REQ_TYPE_SENSE) {
                 return cdrom_do_packet_command(drive);
-        } else if (rq->flags & REQ_BLOCK_PC) {
+        } else if (blk_pc_request(rq)) {
                 return cdrom_do_block_pc(drive, rq);
-        } else if (rq->flags & REQ_SPECIAL) {
+        } else if (blk_special_request(rq)) {
                 /*
                  * right now this can only be a reset...
                  */
@@ -2105,7 +2105,7 @@ static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
 
         req.sense = sense;
         req.cmd[0] = GPCMD_TEST_UNIT_READY;
-        req.flags |= REQ_QUIET;
+        req.cmd_flags |= REQ_QUIET;
 
 #if ! STANDARD_ATAPI
         /* the Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to 
@@ -2207,7 +2207,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
         req.data = (char *)&capbuf;
         req.data_len = sizeof(capbuf);
-        req.flags |= REQ_QUIET;
+        req.cmd_flags |= REQ_QUIET;
 
         stat = cdrom_queue_packet_command(drive, &req);
         if (stat == 0) {
@@ -2230,7 +2230,7 @@ static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
         req.sense = sense;
         req.data =  buf;
         req.data_len = buflen;
-        req.flags |= REQ_QUIET;
+        req.cmd_flags |= REQ_QUIET;
         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
         req.cmd[6] = trackno;
         req.cmd[7] = (buflen >> 8);
@@ -2531,7 +2531,7 @@ static int ide_cdrom_packet(struct cdrom_device_info *cdi,
         req.timeout = cgc->timeout;
 
         if (cgc->quiet)
-                req.flags |= REQ_QUIET;
+                req.cmd_flags |= REQ_QUIET;
 
         req.sense = cgc->sense;
         cgc->stat = cdrom_queue_packet_command(drive, &req);
@@ -2629,7 +2629,8 @@ int ide_cdrom_reset (struct cdrom_device_info *cdi)
         int ret;
 
         cdrom_prepare_request(drive, &req);
-        req.flags = REQ_SPECIAL | REQ_QUIET;
+        req.cmd_type = REQ_TYPE_SPECIAL;
+        req.cmd_flags = REQ_QUIET;
         ret = ide_do_drive_cmd(drive, &req, ide_wait);
 
         /*
@@ -3116,9 +3117,9 @@ static int ide_cdrom_prep_pc(struct request *rq)
 
 static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
 {
-        if (rq->flags & REQ_CMD)
+        if (blk_fs_request(rq))
                 return ide_cdrom_prep_fs(q, rq);
-        else if (rq->flags & REQ_BLOCK_PC)
+        else if (blk_pc_request(rq))
                 return ide_cdrom_prep_pc(rq);
 
         return 0;
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 7cf3eb023521..0a05a377d66a 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -699,7 +699,8 @@ static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
                 rq->cmd[0] = WIN_FLUSH_CACHE;
 
 
-        rq->flags |= REQ_DRIVE_TASK;
+        rq->cmd_type = REQ_TYPE_ATA_TASK;
+        rq->cmd_flags |= REQ_SOFTBARRIER;
         rq->buffer = rq->cmd;
 }
 
@@ -740,7 +741,7 @@ static int set_multcount(ide_drive_t *drive, int arg)
         if (drive->special.b.set_multmode)
                 return -EBUSY;
         ide_init_drive_cmd (&rq);
-        rq.flags = REQ_DRIVE_CMD;
+        rq.cmd_type = REQ_TYPE_ATA_CMD;
         drive->mult_req = arg;
         drive->special.b.set_multmode = 1;
         (void) ide_do_drive_cmd (drive, &rq, ide_wait);
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 7c3a13e1cf64..c3546fe9af63 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -205,7 +205,7 @@ int ide_build_sglist(ide_drive_t *drive, struct request *rq)
         ide_hwif_t *hwif = HWIF(drive);
         struct scatterlist *sg = hwif->sg_table;
 
-        BUG_ON((rq->flags & REQ_DRIVE_TASKFILE) && rq->nr_sectors > 256);
+        BUG_ON((rq->cmd_type == REQ_TYPE_ATA_TASKFILE) && rq->nr_sectors > 256);
 
         ide_map_sg(drive, rq);
 
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index adbe9f76a505..0edc32204915 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -588,7 +588,7 @@ static int idefloppy_do_end_request(ide_drive_t *drive, int uptodate, int nsecs)
         /* Why does this happen? */
         if (!rq)
                 return 0;
-        if (!(rq->flags & REQ_SPECIAL)) { //if (!IDEFLOPPY_RQ_CMD (rq->cmd)) {
+        if (!blk_special_request(rq)) {
                 /* our real local end request function */
                 ide_end_request(drive, uptodate, nsecs);
                 return 0;
@@ -689,7 +689,7 @@ static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t *pc,struc
 
         ide_init_drive_cmd(rq);
         rq->buffer = (char *) pc;
-        rq->flags = REQ_SPECIAL;        //rq->cmd = IDEFLOPPY_PC_RQ;
+        rq->cmd_type = REQ_TYPE_SPECIAL;
         rq->rq_disk = floppy->disk;
         (void) ide_do_drive_cmd(drive, rq, ide_preempt);
 }
@@ -1250,7 +1250,7 @@ static void idefloppy_create_rw_cmd (idefloppy_floppy_t *floppy, idefloppy_pc_t
         pc->callback = &idefloppy_rw_callback;
         pc->rq = rq;
         pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
-        if (rq->flags & REQ_RW)
+        if (rq->cmd_flags & REQ_RW)
                 set_bit(PC_WRITING, &pc->flags);
         pc->buffer = NULL;
         pc->request_transfer = pc->buffer_size = blocks * floppy->block_size;
@@ -1303,7 +1303,7 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request
                 idefloppy_do_end_request(drive, 0, 0);
                 return ide_stopped;
         }
-        if (rq->flags & REQ_CMD) {
+        if (blk_fs_request(rq)) {
                 if (((long)rq->sector % floppy->bs_factor) ||
                     (rq->nr_sectors % floppy->bs_factor)) {
                         printk("%s: unsupported r/w request size\n",
@@ -1313,9 +1313,9 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request
                 }
                 pc = idefloppy_next_pc_storage(drive);
                 idefloppy_create_rw_cmd(floppy, pc, rq, block);
-        } else if (rq->flags & REQ_SPECIAL) {
+        } else if (blk_special_request(rq)) {
                 pc = (idefloppy_pc_t *) rq->buffer;
-        } else if (rq->flags & REQ_BLOCK_PC) {
+        } else if (blk_pc_request(rq)) {
                 pc = idefloppy_next_pc_storage(drive);
                 if (idefloppy_blockpc_cmd(floppy, pc, rq)) {
                         idefloppy_do_end_request(drive, 0, 0);
@@ -1343,7 +1343,7 @@ static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
 
         ide_init_drive_cmd (&rq);
         rq.buffer = (char *) pc;
-        rq.flags = REQ_SPECIAL;         //      rq.cmd = IDEFLOPPY_PC_RQ;
+        rq.cmd_type = REQ_TYPE_SPECIAL;
         rq.rq_disk = floppy->disk;
 
         return ide_do_drive_cmd(drive, &rq, ide_wait);
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index fb6795236e76..3436b1f104eb 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -59,7 +59,7 @@ static int __ide_end_request(ide_drive_t *drive, struct request *rq,
 {
         int ret = 1;
 
-        BUG_ON(!(rq->flags & REQ_STARTED));
+        BUG_ON(!blk_rq_started(rq));
 
         /*
          * if failfast is set on a request, override number of sectors and
@@ -244,7 +244,7 @@ int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
 
         spin_lock_irqsave(&ide_lock, flags);
 
-        BUG_ON(!(rq->flags & REQ_STARTED));
+        BUG_ON(!blk_rq_started(rq));
 
         /*
          * if failfast is set on a request, override number of sectors and
@@ -366,7 +366,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
         rq = HWGROUP(drive)->rq;
         spin_unlock_irqrestore(&ide_lock, flags);
 
-        if (rq->flags & REQ_DRIVE_CMD) {
+        if (rq->cmd_type == REQ_TYPE_ATA_CMD) {
                 u8 *args = (u8 *) rq->buffer;
                 if (rq->errors == 0)
                         rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
@@ -376,7 +376,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
                         args[1] = err;
                         args[2] = hwif->INB(IDE_NSECTOR_REG);
                 }
-        } else if (rq->flags & REQ_DRIVE_TASK) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASK) {
                 u8 *args = (u8 *) rq->buffer;
                 if (rq->errors == 0)
                         rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
@@ -390,7 +390,7 @@ void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err)
                         args[5] = hwif->INB(IDE_HCYL_REG);
                         args[6] = hwif->INB(IDE_SELECT_REG);
                 }
-        } else if (rq->flags & REQ_DRIVE_TASKFILE) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *args = (ide_task_t *) rq->special;
                 if (rq->errors == 0)
                         rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
@@ -587,7 +587,7 @@ ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat)
                 return ide_stopped;
 
         /* retry only "normal" I/O: */
-        if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
+        if (!blk_fs_request(rq)) {
                 rq->errors = 1;
                 ide_end_drive_cmd(drive, stat, err);
                 return ide_stopped;
@@ -638,7 +638,7 @@ ide_startstop_t ide_abort(ide_drive_t *drive, const char *msg)
                 return ide_stopped;
 
         /* retry only "normal" I/O: */
-        if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK | REQ_DRIVE_TASKFILE)) {
+        if (!blk_fs_request(rq)) {
                 rq->errors = 1;
                 ide_end_drive_cmd(drive, BUSY_STAT, 0);
                 return ide_stopped;
@@ -808,7 +808,7 @@ void ide_map_sg(ide_drive_t *drive, struct request *rq)
         if (hwif->sg_mapped)    /* needed by ide-scsi */
                 return;
 
-        if ((rq->flags & REQ_DRIVE_TASKFILE) == 0) {
+        if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) {
                 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
         } else {
                 sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE);
@@ -844,7 +844,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 struct request *rq)
 {
         ide_hwif_t *hwif = HWIF(drive);
-        if (rq->flags & REQ_DRIVE_TASKFILE) {
+        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *args = rq->special;
  
                 if (!args)
@@ -866,7 +866,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 if (args->tf_out_flags.all != 0) 
                         return flagged_taskfile(drive, args);
                 return do_rw_taskfile(drive, args);
-        } else if (rq->flags & REQ_DRIVE_TASK) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASK) {
                 u8 *args = rq->buffer;
                 u8 sel;
  
@@ -892,7 +892,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
                 hwif->OUTB(sel, IDE_SELECT_REG);
                 ide_cmd(drive, args[0], args[2], &drive_cmd_intr);
                 return ide_started;
-        } else if (rq->flags & REQ_DRIVE_CMD) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_CMD) {
                 u8 *args = rq->buffer;
 
                 if (!args)
@@ -980,7 +980,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
         ide_startstop_t startstop;
         sector_t block;
 
-        BUG_ON(!(rq->flags & REQ_STARTED));
+        BUG_ON(!blk_rq_started(rq));
 
 #ifdef DEBUG
         printk("%s: start_request: current=0x%08lx\n",
@@ -1013,9 +1013,9 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
         if (!drive->special.all) {
                 ide_driver_t *drv;
 
-                if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK))
-                        return execute_drive_cmd(drive, rq);
-                else if (rq->flags & REQ_DRIVE_TASKFILE)
+                if (rq->cmd_type == REQ_TYPE_ATA_CMD ||
+                    rq->cmd_type == REQ_TYPE_ATA_TASK ||
+                    rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
                         return execute_drive_cmd(drive, rq);
                 else if (blk_pm_request(rq)) {
                         struct request_pm_state *pm = rq->end_io_data;
@@ -1264,7 +1264,7 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
                  * We count how many times we loop here to make sure we service
                  * all drives in the hwgroup without looping for ever
                  */
-                if (drive->blocked && !blk_pm_request(rq) && !(rq->flags & REQ_PREEMPT)) {
+                if (drive->blocked && !blk_pm_request(rq) && !(rq->cmd_flags & REQ_PREEMPT)) {
                         drive = drive->next ? drive->next : hwgroup->drive;
                         if (loops++ < 4 && !blk_queue_plugged(drive->queue))
                                 goto again;
@@ -1670,7 +1670,7 @@ irqreturn_t ide_intr (int irq, void *dev_id, struct pt_regs *regs)
 void ide_init_drive_cmd (struct request *rq)
 {
         memset(rq, 0, sizeof(*rq));
-        rq->flags = REQ_DRIVE_CMD;
+        rq->cmd_type = REQ_TYPE_ATA_CMD;
         rq->ref_count = 1;
 }
 
@@ -1727,7 +1727,7 @@ int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t actio
                 hwgroup->rq = NULL;
         if (action == ide_preempt || action == ide_head_wait) {
                 where = ELEVATOR_INSERT_FRONT;
-                rq->flags |= REQ_PREEMPT;
+                rq->cmd_flags |= REQ_PREEMPT;
         }
         __elv_add_request(drive->queue, rq, where, 0);
         ide_do_request(hwgroup, IDE_NO_IRQ);
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 1feff23487d4..850ef63cc986 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -456,13 +456,14 @@ static void ide_dump_opcode(ide_drive_t *drive)
         spin_unlock(&ide_lock);
         if (!rq)
                 return;
-        if (rq->flags & (REQ_DRIVE_CMD | REQ_DRIVE_TASK)) {
+        if (rq->cmd_type == REQ_TYPE_ATA_CMD ||
+            rq->cmd_type == REQ_TYPE_ATA_TASK) {
                 char *args = rq->buffer;
                 if (args) {
                         opcode = args[0];
                         found = 1;
                 }
-        } else if (rq->flags & REQ_DRIVE_TASKFILE) {
+        } else if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *args = rq->special;
                 if (args) {
                         task_struct_t *tf = (task_struct_t *) args->tfRegister;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 7067ab997927..643e4b9ac651 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -1776,7 +1776,7 @@ static void idetape_create_request_sense_cmd (idetape_pc_t *pc)
 static void idetape_init_rq(struct request *rq, u8 cmd)
 {
         memset(rq, 0, sizeof(*rq));
-        rq->flags = REQ_SPECIAL;
+        rq->cmd_type = REQ_TYPE_SPECIAL;
         rq->cmd[0] = cmd;
 }
 
@@ -2433,12 +2433,12 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                         rq->sector, rq->nr_sectors, rq->current_nr_sectors);
 #endif /* IDETAPE_DEBUG_LOG */
 
-        if ((rq->flags & REQ_SPECIAL) == 0) {
+        if (!blk_special_request(rq)) {
                 /*
                  * We do not support buffer cache originated requests.
                  */
                 printk(KERN_NOTICE "ide-tape: %s: Unsupported request in "
-                        "request queue (%ld)\n", drive->name, rq->flags);
+                        "request queue (%d)\n", drive->name, rq->cmd_type);
                 ide_end_request(drive, 0, 0);
                 return ide_stopped;
         }
@@ -2768,7 +2768,7 @@ static void idetape_wait_for_request (ide_drive_t *drive, struct request *rq)
         idetape_tape_t *tape = drive->driver_data;
 
 #if IDETAPE_DEBUG_BUGS
-        if (rq == NULL || (rq->flags & REQ_SPECIAL) == 0) {
+        if (rq == NULL || !blk_special_request(rq)) {
                 printk (KERN_ERR "ide-tape: bug: Trying to sleep on non-valid request\n");
                 return;
         }
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 97a9244312fc..1d0470c1f957 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -363,7 +363,7 @@ static ide_startstop_t task_error(ide_drive_t *drive, struct request *rq,
 
 static void task_end_request(ide_drive_t *drive, struct request *rq, u8 stat)
 {
-        if (rq->flags & REQ_DRIVE_TASKFILE) {
+        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
                 ide_task_t *task = rq->special;
 
                 if (task->tf_out_flags.all) {
@@ -474,7 +474,7 @@ static int ide_diag_taskfile(ide_drive_t *drive, ide_task_t *args, unsigned long
         struct request rq;
 
         memset(&rq, 0, sizeof(rq));
-        rq.flags = REQ_DRIVE_TASKFILE;
+        rq.cmd_type = REQ_TYPE_ATA_TASKFILE;
         rq.buffer = buf;
 
         /*
@@ -499,7 +499,7 @@ static int ide_diag_taskfile(ide_drive_t *drive, ide_task_t *args, unsigned long
                 rq.hard_cur_sectors = rq.current_nr_sectors = rq.nr_sectors;
 
                 if (args->command_type == IDE_DRIVE_TASK_RAW_WRITE)
-                        rq.flags |= REQ_RW;
+                        rq.cmd_flags |= REQ_RW;
         }
 
         rq.special = args;
@@ -737,7 +737,7 @@ static int ide_wait_cmd_task(ide_drive_t *drive, u8 *buf)
         struct request rq;
 
         ide_init_drive_cmd(&rq);
-        rq.flags = REQ_DRIVE_TASK;
+        rq.cmd_type = REQ_TYPE_ATA_TASK;
         rq.buffer = buf;
         return ide_do_drive_cmd(drive, &rq, ide_wait);
 }
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 9c8468de1a75..9384a3fdde6c 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -1217,7 +1217,7 @@ static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         memset(&rq, 0, sizeof(rq));
         memset(&rqpm, 0, sizeof(rqpm));
         memset(&args, 0, sizeof(args));
-        rq.flags = REQ_PM_SUSPEND;
+        rq.cmd_type = REQ_TYPE_PM_SUSPEND;
         rq.special = &args;
         rq.end_io_data = &rqpm;
         rqpm.pm_step = ide_pm_state_start_suspend;
@@ -1238,7 +1238,7 @@ static int generic_ide_resume(struct device *dev)
         memset(&rq, 0, sizeof(rq));
         memset(&rqpm, 0, sizeof(rqpm));
         memset(&args, 0, sizeof(args));
-        rq.flags = REQ_PM_RESUME;
+        rq.cmd_type = REQ_TYPE_PM_RESUME;
         rq.special = &args;
         rq.end_io_data = &rqpm;
         rqpm.pm_step = ide_pm_state_start_resume;
diff --git a/drivers/ide/legacy/hd.c b/drivers/ide/legacy/hd.c
index aebecd8f51cc..4ab931145673 100644
--- a/drivers/ide/legacy/hd.c
+++ b/drivers/ide/legacy/hd.c
@@ -626,7 +626,7 @@ repeat:
                 req->rq_disk->disk_name, (req->cmd == READ)?"read":"writ",
                 cyl, head, sec, nsect, req->buffer);
 #endif
-        if (req->flags & REQ_CMD) {
+        if (blk_fs_request(req)) {
                 switch (rq_data_dir(req)) {
                 case READ:
                         hd_out(disk,nsect,sec,head,cyl,WIN_READ,&read_intr);
diff --git a/drivers/md/dm-emc.c b/drivers/md/dm-emc.c
index 2a374ccb30dd..2b2d45d7baaa 100644
--- a/drivers/md/dm-emc.c
+++ b/drivers/md/dm-emc.c
@@ -126,7 +126,8 @@ static struct request *get_failover_req(struct emc_handler *h,
         memset(&rq->cmd, 0, BLK_MAX_CDB);
 
         rq->timeout = EMC_FAILOVER_TIMEOUT;
-        rq->flags |= (REQ_BLOCK_PC | REQ_FAILFAST | REQ_NOMERGE);
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
+        rq->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE;
 
         return rq;
 }
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 1ddc2fb429d5..eaba81bf2eca 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -390,9 +390,9 @@ static int i2o_block_prep_req_fn(struct request_queue *q, struct request *req)
         }
 
         /* request is already processed by us, so return */
-        if (req->flags & REQ_SPECIAL) {
+        if (blk_special_request(req)) {
                 osm_debug("REQ_SPECIAL already set!\n");
-                req->flags |= REQ_DONTPREP;
+                req->cmd_flags |= REQ_DONTPREP;
                 return BLKPREP_OK;
         }
 
@@ -411,7 +411,8 @@ static int i2o_block_prep_req_fn(struct request_queue *q, struct request *req)
                 ireq = req->special;
 
         /* do not come back here */
-        req->flags |= REQ_DONTPREP | REQ_SPECIAL;
+        req->cmd_type = REQ_TYPE_SPECIAL;
+        req->cmd_flags |= REQ_DONTPREP;
 
         return BLKPREP_OK;
 };
diff --git a/drivers/mmc/mmc_queue.c b/drivers/mmc/mmc_queue.c
index 74f8cdeeff0f..4ccdd82b680f 100644
--- a/drivers/mmc/mmc_queue.c
+++ b/drivers/mmc/mmc_queue.c
@@ -28,7 +28,7 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
         struct mmc_queue *mq = q->queuedata;
         int ret = BLKPREP_KILL;
 
-        if (req->flags & REQ_SPECIAL) {
+        if (blk_special_request(req)) {
                 /*
                  * Special commands already have the command
                  * blocks already setup in req->special.
@@ -36,7 +36,7 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
                 BUG_ON(!req->special);
 
                 ret = BLKPREP_OK;
-        } else if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) {
+        } else if (blk_fs_request(req) || blk_pc_request(req)) {
                 /*
                  * Block I/O requests need translating according
                  * to the protocol.
@@ -50,7 +50,7 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
         }
 
         if (ret == BLKPREP_OK)
-                req->flags |= REQ_DONTPREP;
+                req->cmd_flags |= REQ_DONTPREP;
 
         return ret;
 }
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 458d3c8ae1ee..6baf5fe14230 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -46,7 +46,7 @@ static int do_blktrans_request(struct mtd_blktrans_ops *tr,
         nsect = req->current_nr_sectors;
         buf = req->buffer;
 
-        if (!(req->flags & REQ_CMD))
+        if (!blk_fs_request(req))
                 return 0;
 
         if (block + nsect > get_capacity(req->rq_disk))
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index 9d051e5687ea..222a8a71a5e8 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -529,7 +529,7 @@ dasd_diag_build_cp(struct dasd_device * device, struct request *req)
         }
         cqr->retries = DIAG_MAX_RETRIES;
         cqr->buildclk = get_clock();
-        if (req->flags & REQ_FAILFAST)
+        if (req->cmd_flags & REQ_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->device = device;
         cqr->expires = DIAG_TIMEOUT;
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index b7a7fac3f7c3..5ecea3e4fdef 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1266,7 +1266,7 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
                         recid++;
                 }
         }
-        if (req->flags & REQ_FAILFAST)
+        if (req->cmd_flags & REQ_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->device = device;
         cqr->expires = 5 * 60 * HZ;     /* 5 minutes */
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index e85015be109b..80926c548228 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -344,7 +344,7 @@ dasd_fba_build_cp(struct dasd_device * device, struct request *req)
                         recid++;
                 }
         }
-        if (req->flags & REQ_FAILFAST)
+        if (req->cmd_flags & REQ_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->device = device;
         cqr->expires = 5 * 60 * HZ;     /* 5 minutes */
diff --git a/drivers/scsi/aic7xxx_old.c b/drivers/scsi/aic7xxx_old.c
index 5dcef48d414f..10353379a074 100644
--- a/drivers/scsi/aic7xxx_old.c
+++ b/drivers/scsi/aic7xxx_old.c
@@ -2862,7 +2862,7 @@ aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
       aic_dev->r_total++;
       ptr = aic_dev->r_bins;
     }
-    if(cmd->device->simple_tags && cmd->request->flags & REQ_HARDBARRIER)
+    if(cmd->device->simple_tags && cmd->request->cmd_flags & REQ_HARDBARRIER)
     {
       aic_dev->barrier_total++;
       if(scb->tag_action == MSG_ORDERED_Q_TAG)
@@ -10158,7 +10158,7 @@ aic7xxx_buildscb(struct aic7xxx_host *p, Scsi_Cmnd *cmd,
     /* We always force TEST_UNIT_READY to untagged */
     if (cmd->cmnd[0] != TEST_UNIT_READY && sdptr->simple_tags)
     {
-      if (req->flags & REQ_HARDBARRIER)
+      if (req->cmd_flags & REQ_HARDBARRIER)
       {
         if(sdptr->ordered_tags)
         {
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 94d1de55607f..65b19695ebe2 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -344,7 +344,7 @@ static int idescsi_check_condition(ide_drive_t *drive, struct request *failed_co
         pc->buffer = buf;
         pc->c[0] = REQUEST_SENSE;
         pc->c[4] = pc->request_transfer = pc->buffer_size = SCSI_SENSE_BUFFERSIZE;
-        rq->flags = REQ_SENSE;
+        rq->cmd_type = REQ_TYPE_SENSE;
         pc->timeout = jiffies + WAIT_READY;
         /* NOTE! Save the failed packet command in "rq->buffer" */
         rq->buffer = (void *) failed_command->special;
@@ -398,12 +398,12 @@ static int idescsi_end_request (ide_drive_t *drive, int uptodate, int nrsecs)
         int errors = rq->errors;
         unsigned long flags;
 
-        if (!(rq->flags & (REQ_SPECIAL|REQ_SENSE))) {
+        if (!blk_special_request(rq) && !blk_sense_request(rq)) {
                 ide_end_request(drive, uptodate, nrsecs);
                 return 0;
         }
         ide_end_drive_cmd (drive, 0, 0);
-        if (rq->flags & REQ_SENSE) {
+        if (blk_sense_request(rq)) {
                 idescsi_pc_t *opc = (idescsi_pc_t *) rq->buffer;
                 if (log) {
                         printk ("ide-scsi: %s: wrap up check %lu, rst = ", drive->name, opc->scsi_cmd->serial_number);
@@ -712,7 +712,7 @@ static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *r
         printk (KERN_INFO "sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",rq->sector,rq->nr_sectors,rq->current_nr_sectors);
 #endif /* IDESCSI_DEBUG_LOG */
 
-        if (rq->flags & (REQ_SPECIAL|REQ_SENSE)) {
+        if (blk_sense_request(rq) || blk_special_request(rq)) {
                 return idescsi_issue_pc (drive, (idescsi_pc_t *) rq->special);
         }
         blk_dump_rq_flags(rq, "ide-scsi: unsup command");
@@ -938,7 +938,7 @@ static int idescsi_queue (struct scsi_cmnd *cmd,
 
         ide_init_drive_cmd (rq);
         rq->special = (char *) pc;
-        rq->flags = REQ_SPECIAL;
+        rq->cmd_type = REQ_TYPE_SPECIAL;
         spin_unlock_irq(host->host_lock);
         rq->rq_disk = scsi->disk;
         (void) ide_do_drive_cmd (drive, rq, ide_end);
@@ -992,7 +992,7 @@ static int idescsi_eh_abort (struct scsi_cmnd *cmd)
                  */
                 printk (KERN_ERR "ide-scsi: cmd aborted!\n");
 
-                if (scsi->pc->rq->flags & REQ_SENSE)
+                if (blk_sense_request(scsi->pc->rq))
                         kfree(scsi->pc->buffer);
                 kfree(scsi->pc->rq);
                 kfree(scsi->pc);
@@ -1042,7 +1042,7 @@ static int idescsi_eh_reset (struct scsi_cmnd *cmd)
         /* kill current request */
         blkdev_dequeue_request(req);
         end_that_request_last(req, 0);
-        if (req->flags & REQ_SENSE)
+        if (blk_sense_request(req))
                 kfree(scsi->pc->buffer);
         kfree(scsi->pc);
         scsi->pc = NULL;
diff --git a/drivers/scsi/pluto.c b/drivers/scsi/pluto.c
index 0bd9c60e6455..aa60a5f1fbc3 100644
--- a/drivers/scsi/pluto.c
+++ b/drivers/scsi/pluto.c
@@ -67,7 +67,6 @@ static void __init pluto_detect_done(Scsi_Cmnd *SCpnt)
 
 static void __init pluto_detect_scsi_done(Scsi_Cmnd *SCpnt)
 {
-        SCpnt->request->rq_status = RQ_SCSI_DONE;
         PLND(("Detect done %08lx\n", (long)SCpnt))
         if (atomic_dec_and_test (&fcss))
                 up(&fc_sem);
@@ -166,7 +165,7 @@ int __init pluto_detect(struct scsi_host_template *tpnt)
                 
                 SCpnt->cmd_len = COMMAND_SIZE(INQUIRY);
         
-                SCpnt->request->rq_status = RQ_SCSI_BUSY;
+                SCpnt->request->cmd_flags &= ~REQ_STARTED;
                 
                 SCpnt->done = pluto_detect_done;
                 SCpnt->request_bufflen = 256;
@@ -178,7 +177,8 @@ int __init pluto_detect(struct scsi_host_template *tpnt)
         for (retry = 0; retry < 5; retry++) {
                 for (i = 0; i < fcscount; i++) {
                         if (!fcs[i].fc) break;
-                        if (fcs[i].cmd.request->rq_status != RQ_SCSI_DONE) {
+                        if (!(fcs[i].cmd.request->cmd_flags & REQ_STARTED)) {
+                                fcs[i].cmd.request->cmd_flags |= REQ_STARTED;
                                 disable_irq(fcs[i].fc->irq);
                                 PLND(("queuecommand %d %d\n", retry, i))
                                 fcp_scsi_queuecommand (&(fcs[i].cmd), 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index d6743b959a72..71084728eb42 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -82,7 +82,7 @@ static void scsi_unprep_request(struct request *req)
 {
         struct scsi_cmnd *cmd = req->special;
 
-        req->flags &= ~REQ_DONTPREP;
+        req->cmd_flags &= ~REQ_DONTPREP;
         req->special = NULL;
 
         scsi_put_command(cmd);
@@ -196,7 +196,8 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
         req->sense_len = 0;
         req->retries = retries;
         req->timeout = timeout;
-        req->flags |= flags | REQ_BLOCK_PC | REQ_SPECIAL | REQ_QUIET;
+        req->cmd_type = REQ_TYPE_BLOCK_PC;
+        req->cmd_flags |= flags | REQ_QUIET | REQ_PREEMPT;
 
         /*
          * head injection *required* here otherwise quiesce won't work
@@ -397,7 +398,8 @@ int scsi_execute_async(struct scsi_device *sdev, const unsigned char *cmd,
         req = blk_get_request(sdev->request_queue, write, gfp);
         if (!req)
                 goto free_sense;
-        req->flags |= REQ_BLOCK_PC | REQ_QUIET;
+        req->cmd_type = REQ_TYPE_BLOCK_PC;
+        req->cmd_flags |= REQ_QUIET;
 
         if (use_sg)
                 err = scsi_req_map_sg(req, buffer, use_sg, bufflen, gfp);
@@ -933,7 +935,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                                         break;
                                 }
                         }
-                        if (!(req->flags & REQ_QUIET)) {
+                        if (!(req->cmd_flags & REQ_QUIET)) {
                                 scmd_printk(KERN_INFO, cmd,
                                             "Device not ready: ");
                                 scsi_print_sense_hdr("", &sshdr);
@@ -941,7 +943,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                         scsi_end_request(cmd, 0, this_count, 1);
                         return;
                 case VOLUME_OVERFLOW:
-                        if (!(req->flags & REQ_QUIET)) {
+                        if (!(req->cmd_flags & REQ_QUIET)) {
                                 scmd_printk(KERN_INFO, cmd,
                                             "Volume overflow, CDB: ");
                                 __scsi_print_command(cmd->cmnd);
@@ -963,7 +965,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                 return;
         }
         if (result) {
-                if (!(req->flags & REQ_QUIET)) {
+                if (!(req->cmd_flags & REQ_QUIET)) {
                         scmd_printk(KERN_INFO, cmd,
                                     "SCSI error: return code = 0x%08x\n",
                                     result);
@@ -995,7 +997,7 @@ static int scsi_init_io(struct scsi_cmnd *cmd)
         /*
          * if this is a rq->data based REQ_BLOCK_PC, setup for a non-sg xfer
          */
-        if ((req->flags & REQ_BLOCK_PC) && !req->bio) {
+        if (blk_pc_request(req) && !req->bio) {
                 cmd->request_bufflen = req->data_len;
                 cmd->request_buffer = req->data;
                 req->buffer = req->data;
@@ -1139,13 +1141,12 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
          * these two cases differently.  We differentiate by looking
          * at request->cmd, as this tells us the real story.
          */
-        if (req->flags & REQ_SPECIAL && req->special) {
+        if (blk_special_request(req) && req->special)
                 cmd = req->special;
-        } else if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) {
-
-                if(unlikely(specials_only) && !(req->flags & REQ_SPECIAL)) {
-                        if(specials_only == SDEV_QUIESCE ||
-                                        specials_only == SDEV_BLOCK)
+        else if (blk_pc_request(req) || blk_fs_request(req)) {
+                if (unlikely(specials_only) && !(req->cmd_flags & REQ_PREEMPT)){
+                        if (specials_only == SDEV_QUIESCE ||
+                            specials_only == SDEV_BLOCK)
                                 goto defer;
                         
                         sdev_printk(KERN_ERR, sdev,
@@ -1153,7 +1154,6 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
                         goto kill;
                 }
                         
-                        
                 /*
                  * Now try and find a command block that we can use.
                  */
@@ -1184,7 +1184,7 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
          * lock.  We hope REQ_STARTED prevents anything untoward from
          * happening now.
          */
-        if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) {
+        if (blk_fs_request(req) || blk_pc_request(req)) {
                 int ret;
 
                 /*
@@ -1216,7 +1216,7 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
                 /*
                  * Initialize the actual SCSI command for this request.
                  */
-                if (req->flags & REQ_BLOCK_PC) {
+                if (blk_pc_request(req)) {
                         scsi_setup_blk_pc_cmnd(cmd);
                 } else if (req->rq_disk) {
                         struct scsi_driver *drv;
@@ -1233,7 +1233,7 @@ static int scsi_prep_fn(struct request_queue *q, struct request *req)
         /*
          * The request is now prepped, no need to come back here
          */
-        req->flags |= REQ_DONTPREP;
+        req->cmd_flags |= REQ_DONTPREP;
         return BLKPREP_OK;
 
  defer:
@@ -1454,8 +1454,9 @@ static void scsi_request_fn(struct request_queue *q)
                 if (unlikely(cmd == NULL)) {
                         printk(KERN_CRIT "impossible request in %s.\n"
                                          "please mail a stack trace to "
-                                         "linux-scsi@vger.kernel.org",
+                                         "linux-scsi@vger.kernel.org\n",
                                          __FUNCTION__);
+                        blk_dump_rq_flags(req, "foo");
                         BUG();
                 }
                 spin_lock(shost->host_lock);
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 638cff41d436..10bc99c911fa 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -443,8 +443,7 @@ static int sd_init_command(struct scsi_cmnd * SCpnt)
                 SCpnt->cmnd[0] = READ_6;
                 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
         } else {
-                printk(KERN_ERR "sd: Unknown command %lx\n", rq->flags);
-/* overkill     panic("Unknown sd command %lx\n", rq->flags); */
+                printk(KERN_ERR "sd: Unknown command %x\n", rq->cmd_flags);
                 return 0;
         }
 
@@ -840,7 +839,7 @@ static int sd_issue_flush(struct device *dev, sector_t *error_sector)
 static void sd_prepare_flush(request_queue_t *q, struct request *rq)
 {
         memset(rq->cmd, 0, sizeof(rq->cmd));
-        rq->flags |= REQ_BLOCK_PC;
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->timeout = SD_TIMEOUT;
         rq->cmd[0] = SYNCHRONIZE_CACHE;
         rq->cmd_len = 10;
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index 2f8073b73bf3..7f9bcef6adfa 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -2017,7 +2017,7 @@ static void NCR5380_information_transfer (struct Scsi_Host *instance)
                 if((count > SUN3_DMA_MINSIZE) && (sun3_dma_setup_done
                                                   != cmd))
                 {
-                        if(cmd->request->flags & REQ_CMD) {
+                        if(blk_fs_request(cmd->request)) {
                                 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 837173415d4c..44a99aeb8180 100644
--- a/drivers/scsi/sun3_scsi.c
+++ b/drivers/scsi/sun3_scsi.c
@@ -524,7 +524,7 @@ static inline unsigned long sun3scsi_dma_residual(struct Scsi_Host *instance)
 static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted, Scsi_Cmnd *cmd,
                                     int write_flag)
 {
-        if(cmd->request->flags & REQ_CMD)
+        if(blk_fs_request(cmd->request))
                 return wanted;
         else
                 return 0;
diff --git a/drivers/scsi/sun3_scsi_vme.c b/drivers/scsi/sun3_scsi_vme.c
index 008a82ab8521..f5742b84b27a 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_residual(struct Scsi_Host *instance)
 static inline unsigned long sun3scsi_dma_xfer_len(unsigned long wanted, Scsi_Cmnd *cmd,
                                     int write_flag)
 {
-        if(cmd->request->flags & REQ_CMD)
+        if(blk_fs_request(cmd->request))
                 return wanted;
         else
                 return 0;