block: unify flags for struct bio and struct request

Remove the current bio flags and reuse the request flags for the bio, too.
This allows to more easily trace the type of I/O from the filesystem
down to the block driver.  There were two flags in the bio that were
missing in the requests:  BIO_RW_UNPLUG and BIO_RW_AHEAD.  Also I've
renamed two request flags that had a superflous RW in them.

Note that the flags are in bio.h despite having the REQ_ name - as
blkdev.h includes bio.h that is the only way to go for now.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

6 files changed, 21 insertions, 39 deletions

diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index 74e404393172..7c6f4a714687 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -203,7 +203,7 @@ static inline bool start_ordered(struct request_queue *q, struct request **rqp)
                 /* initialize proxy request and queue it */
                 blk_rq_init(q, rq);
                 if (bio_data_dir(q->orig_bar_rq->bio) == WRITE)
-                        rq->cmd_flags |= REQ_RW;
+                        rq->cmd_flags |= REQ_WRITE;
                 if (q->ordered & QUEUE_ORDERED_DO_FUA)
                         rq->cmd_flags |= REQ_FUA;
                 init_request_from_bio(rq, q->orig_bar_rq->bio);
diff --git a/block/blk-core.c b/block/blk-core.c
index dca43a31e725..66c3cfe94d0a 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1140,25 +1140,9 @@ void init_request_from_bio(struct request *req, struct bio *bio)
         req->cpu = bio->bi_comp_cpu;
         req->cmd_type = REQ_TYPE_FS;
 
-        /*
-         * Inherit FAILFAST from bio (for read-ahead, and explicit
-         * FAILFAST).  FAILFAST flags are identical for req and bio.
-         */
-        if (bio_rw_flagged(bio, BIO_RW_AHEAD))
+        req->cmd_flags |= bio->bi_rw & REQ_COMMON_MASK;
+        if (bio->bi_rw & REQ_RAHEAD)
                 req->cmd_flags |= REQ_FAILFAST_MASK;
-        else
-                req->cmd_flags |= bio->bi_rw & REQ_FAILFAST_MASK;
-
-        if (bio_rw_flagged(bio, BIO_RW_DISCARD))
-                req->cmd_flags |= REQ_DISCARD;
-        if (bio_rw_flagged(bio, BIO_RW_BARRIER))
-                req->cmd_flags |= REQ_HARDBARRIER;
-        if (bio_rw_flagged(bio, BIO_RW_SYNCIO))
-                req->cmd_flags |= REQ_RW_SYNC;
-        if (bio_rw_flagged(bio, BIO_RW_META))
-                req->cmd_flags |= REQ_RW_META;
-        if (bio_rw_flagged(bio, BIO_RW_NOIDLE))
-                req->cmd_flags |= REQ_NOIDLE;
 
         req->errors = 0;
         req->__sector = bio->bi_sector;
@@ -1181,12 +1165,12 @@ static int __make_request(struct request_queue *q, struct bio *bio)
         int el_ret;
         unsigned int bytes = bio->bi_size;
         const unsigned short prio = bio_prio(bio);
-        const bool sync = bio_rw_flagged(bio, BIO_RW_SYNCIO);
-        const bool unplug = bio_rw_flagged(bio, BIO_RW_UNPLUG);
+        const bool sync = (bio->bi_rw & REQ_SYNC);
+        const bool unplug = (bio->bi_rw & REQ_UNPLUG);
         const unsigned int ff = bio->bi_rw & REQ_FAILFAST_MASK;
         int rw_flags;
 
-        if (bio_rw_flagged(bio, BIO_RW_BARRIER) &&
+        if ((bio->bi_rw & REQ_HARDBARRIER) &&
             (q->next_ordered == QUEUE_ORDERED_NONE)) {
                 bio_endio(bio, -EOPNOTSUPP);
                 return 0;
@@ -1200,7 +1184,7 @@ static int __make_request(struct request_queue *q, struct bio *bio)
 
         spin_lock_irq(q->queue_lock);
 
-        if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER)) || elv_queue_empty(q))
+        if (unlikely((bio->bi_rw & REQ_HARDBARRIER)) || elv_queue_empty(q))
                 goto get_rq;
 
         el_ret = elv_merge(q, &req, bio);
@@ -1275,7 +1259,7 @@ get_rq:
          */
         rw_flags = bio_data_dir(bio);
         if (sync)
-                rw_flags |= REQ_RW_SYNC;
+                rw_flags |= REQ_SYNC;
 
         /*
          * Grab a free request. This is might sleep but can not fail.
@@ -1464,7 +1448,7 @@ static inline void __generic_make_request(struct bio *bio)
                         goto end_io;
                 }
 
-                if (unlikely(!bio_rw_flagged(bio, BIO_RW_DISCARD) &&
+                if (unlikely(!(bio->bi_rw & REQ_DISCARD) &&
                              nr_sectors > queue_max_hw_sectors(q))) {
                         printk(KERN_ERR "bio too big device %s (%u > %u)\n",
                                bdevname(bio->bi_bdev, b),
@@ -1497,8 +1481,7 @@ static inline void __generic_make_request(struct bio *bio)
                 if (bio_check_eod(bio, nr_sectors))
                         goto end_io;
 
-                if (bio_rw_flagged(bio, BIO_RW_DISCARD) &&
-                    !blk_queue_discard(q)) {
+                if ((bio->bi_rw & REQ_DISCARD) && !blk_queue_discard(q)) {
                         err = -EOPNOTSUPP;
                         goto end_io;
                 }
@@ -2365,7 +2348,7 @@ void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
                      struct bio *bio)
 {
         /* Bit 0 (R/W) is identical in rq->cmd_flags and bio->bi_rw */
-        rq->cmd_flags |= bio->bi_rw & REQ_RW;
+        rq->cmd_flags |= bio->bi_rw & REQ_WRITE;
 
         if (bio_has_data(bio)) {
                 rq->nr_phys_segments = bio_phys_segments(q, bio);
diff --git a/block/blk-map.c b/block/blk-map.c
index 9083cf0180cc..c65d7593f7f1 100644
--- a/block/blk-map.c
+++ b/block/blk-map.c
@@ -307,7 +307,7 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
                 return PTR_ERR(bio);
 
         if (rq_data_dir(rq) == WRITE)
-                bio->bi_rw |= (1 << BIO_RW);
+                bio->bi_rw |= (1 << REQ_WRITE);
 
         if (do_copy)
                 rq->cmd_flags |= REQ_COPY_USER;
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 87e4fb7d0e98..4852475521ea 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -180,7 +180,7 @@ new_segment:
         }
 
         if (q->dma_drain_size && q->dma_drain_needed(rq)) {
-                if (rq->cmd_flags & REQ_RW)
+                if (rq->cmd_flags & REQ_WRITE)
                         memset(q->dma_drain_buffer, 0, q->dma_drain_size);
 
                 sg->page_link &= ~0x02;
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index d4edeb8fceb8..eb4086f7dfef 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -458,7 +458,7 @@ static inline struct cfq_data *cic_to_cfqd(struct cfq_io_context *cic)
  */
 static inline bool cfq_bio_sync(struct bio *bio)
 {
-        return bio_data_dir(bio) == READ || bio_rw_flagged(bio, BIO_RW_SYNCIO);
+        return bio_data_dir(bio) == READ || (bio->bi_rw & REQ_SYNC);
 }
 
 /*
@@ -646,10 +646,10 @@ cfq_choose_req(struct cfq_data *cfqd, struct request *rq1, struct request *rq2,
                 return rq1;
         else if (rq_is_sync(rq2) && !rq_is_sync(rq1))
                 return rq2;
-        if ((rq1->cmd_flags & REQ_RW_META) && !(rq2->cmd_flags & REQ_RW_META))
+        if ((rq1->cmd_flags & REQ_META) && !(rq2->cmd_flags & REQ_META))
                 return rq1;
-        else if ((rq2->cmd_flags & REQ_RW_META) &&
-                 !(rq1->cmd_flags & REQ_RW_META))
+        else if ((rq2->cmd_flags & REQ_META) &&
+                 !(rq1->cmd_flags & REQ_META))
                 return rq2;
 
         s1 = blk_rq_pos(rq1);
@@ -1485,7 +1485,7 @@ static void cfq_remove_request(struct request *rq)
         cfqq->cfqd->rq_queued--;
         cfq_blkiocg_update_io_remove_stats(&(RQ_CFQG(rq))->blkg,
                                         rq_data_dir(rq), rq_is_sync(rq));
-        if (rq->cmd_flags & REQ_RW_META) {
+        if (rq->cmd_flags & REQ_META) {
                 WARN_ON(!cfqq->meta_pending);
                 cfqq->meta_pending--;
         }
@@ -3177,7 +3177,7 @@ cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq,
          * So both queues are sync. Let the new request get disk time if
          * it's a metadata request and the current queue is doing regular IO.
          */
-        if ((rq->cmd_flags & REQ_RW_META) && !cfqq->meta_pending)
+        if ((rq->cmd_flags & REQ_META) && !cfqq->meta_pending)
                 return true;
 
         /*
@@ -3231,7 +3231,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
         struct cfq_io_context *cic = RQ_CIC(rq);
 
         cfqd->rq_queued++;
-        if (rq->cmd_flags & REQ_RW_META)
+        if (rq->cmd_flags & REQ_META)
                 cfqq->meta_pending++;
 
         cfq_update_io_thinktime(cfqd, cic);
diff --git a/block/elevator.c b/block/elevator.c
index aa99b59c03d6..816a7c8d6394 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -79,8 +79,7 @@ int elv_rq_merge_ok(struct request *rq, struct bio *bio)
         /*
          * Don't merge file system requests and discard requests
          */
-        if (bio_rw_flagged(bio, BIO_RW_DISCARD) !=
-            bio_rw_flagged(rq->bio, BIO_RW_DISCARD))
+        if ((bio->bi_rw & REQ_DISCARD) != (rq->bio->bi_rw & REQ_DISCARD))
                 return 0;
 
         /*