[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>

8 files changed, 36 insertions, 36 deletions

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;