as-iosched: get rid of private REQ_SYNC/REQ_ASYNC defines

We can just use the block layer BLK_RW_SYNC/ASYNC defines now.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

1 files changed, 57 insertions, 59 deletions

diff --git a/block/as-iosched.c b/block/as-iosched.c
index 631f6f44460a..c48fa670d221 100644
--- a/block/as-iosched.c
+++ b/block/as-iosched.c
@@ -17,9 +17,6 @@
 #include <linux/rbtree.h>
 #include <linux/interrupt.h>
 
-#define REQ_SYNC        1
-#define REQ_ASYNC       0
-
 /*
  * See Documentation/block/as-iosched.txt
  */
@@ -93,7 +90,7 @@ struct as_data {
         struct list_head fifo_list[2];
 
         struct request *next_rq[2];     /* next in sort order */
-        sector_t last_sector[2];        /* last REQ_SYNC & REQ_ASYNC sectors */
+        sector_t last_sector[2];        /* last SYNC & ASYNC sectors */
 
         unsigned long exit_prob;        /* probability a task will exit while
                                            being waited on */
@@ -109,7 +106,7 @@ struct as_data {
         unsigned long last_check_fifo[2];
         int changed_batch;              /* 1: waiting for old batch to end */
         int new_batch;                  /* 1: waiting on first read complete */
-        int batch_data_dir;             /* current batch REQ_SYNC / REQ_ASYNC */
+        int batch_data_dir;             /* current batch SYNC / ASYNC */
         int write_batch_count;          /* max # of reqs in a write batch */
         int current_write_count;        /* how many requests left this batch */
         int write_batch_idled;          /* has the write batch gone idle? */
@@ -554,7 +551,7 @@ static void as_update_iohist(struct as_data *ad, struct as_io_context *aic,
         if (aic == NULL)
                 return;
 
-        if (data_dir == REQ_SYNC) {
+        if (data_dir == BLK_RW_SYNC) {
                 unsigned long in_flight = atomic_read(&aic->nr_queued)
                                         + atomic_read(&aic->nr_dispatched);
                 spin_lock(&aic->lock);
@@ -811,7 +808,7 @@ static void as_update_rq(struct as_data *ad, struct request *rq)
  */
 static void update_write_batch(struct as_data *ad)
 {
-        unsigned long batch = ad->batch_expire[REQ_ASYNC];
+        unsigned long batch = ad->batch_expire[BLK_RW_ASYNC];
         long write_time;
 
         write_time = (jiffies - ad->current_batch_expires) + batch;
@@ -855,7 +852,7 @@ static void as_completed_request(struct request_queue *q, struct request *rq)
                 kblockd_schedule_work(q, &ad->antic_work);
                 ad->changed_batch = 0;
 
-                if (ad->batch_data_dir == REQ_SYNC)
+                if (ad->batch_data_dir == BLK_RW_SYNC)
                         ad->new_batch = 1;
         }
         WARN_ON(ad->nr_dispatched == 0);
@@ -869,7 +866,7 @@ static void as_completed_request(struct request_queue *q, struct request *rq)
         if (ad->new_batch && ad->batch_data_dir == rq_is_sync(rq)) {
                 update_write_batch(ad);
                 ad->current_batch_expires = jiffies +
-                                ad->batch_expire[REQ_SYNC];
+                                ad->batch_expire[BLK_RW_SYNC];
                 ad->new_batch = 0;
         }
 
@@ -960,7 +957,7 @@ static inline int as_batch_expired(struct as_data *ad)
         if (ad->changed_batch || ad->new_batch)
                 return 0;
 
-        if (ad->batch_data_dir == REQ_SYNC)
+        if (ad->batch_data_dir == BLK_RW_SYNC)
                 /* TODO! add a check so a complete fifo gets written? */
                 return time_after(jiffies, ad->current_batch_expires);
 
@@ -986,7 +983,7 @@ static void as_move_to_dispatch(struct as_data *ad, struct request *rq)
          */
         ad->last_sector[data_dir] = rq->sector + rq->nr_sectors;
 
-        if (data_dir == REQ_SYNC) {
+        if (data_dir == BLK_RW_SYNC) {
                 struct io_context *ioc = RQ_IOC(rq);
                 /* In case we have to anticipate after this */
                 copy_io_context(&ad->io_context, &ioc);
@@ -1025,41 +1022,41 @@ static void as_move_to_dispatch(struct as_data *ad, struct request *rq)
 static int as_dispatch_request(struct request_queue *q, int force)
 {
         struct as_data *ad = q->elevator->elevator_data;
-        const int reads = !list_empty(&ad->fifo_list[REQ_SYNC]);
-        const int writes = !list_empty(&ad->fifo_list[REQ_ASYNC]);
+        const int reads = !list_empty(&ad->fifo_list[BLK_RW_SYNC]);
+        const int writes = !list_empty(&ad->fifo_list[BLK_RW_ASYNC]);
         struct request *rq;
 
         if (unlikely(force)) {
                 /*
                  * Forced dispatch, accounting is useless.  Reset
                  * accounting states and dump fifo_lists.  Note that
-                 * batch_data_dir is reset to REQ_SYNC to avoid
+                 * batch_data_dir is reset to BLK_RW_SYNC to avoid
                  * screwing write batch accounting as write batch
                  * accounting occurs on W->R transition.
                  */
                 int dispatched = 0;
 
-                ad->batch_data_dir = REQ_SYNC;
+                ad->batch_data_dir = BLK_RW_SYNC;
                 ad->changed_batch = 0;
                 ad->new_batch = 0;
 
-                while (ad->next_rq[REQ_SYNC]) {
-                        as_move_to_dispatch(ad, ad->next_rq[REQ_SYNC]);
+                while (ad->next_rq[BLK_RW_SYNC]) {
+                        as_move_to_dispatch(ad, ad->next_rq[BLK_RW_SYNC]);
                         dispatched++;
                 }
-                ad->last_check_fifo[REQ_SYNC] = jiffies;
+                ad->last_check_fifo[BLK_RW_SYNC] = jiffies;
 
-                while (ad->next_rq[REQ_ASYNC]) {
-                        as_move_to_dispatch(ad, ad->next_rq[REQ_ASYNC]);
+                while (ad->next_rq[BLK_RW_ASYNC]) {
+                        as_move_to_dispatch(ad, ad->next_rq[BLK_RW_ASYNC]);
                         dispatched++;
                 }
-                ad->last_check_fifo[REQ_ASYNC] = jiffies;
+                ad->last_check_fifo[BLK_RW_ASYNC] = jiffies;
 
                 return dispatched;
         }
 
         /* Signal that the write batch was uncontended, so we can't time it */
-        if (ad->batch_data_dir == REQ_ASYNC && !reads) {
+        if (ad->batch_data_dir == BLK_RW_ASYNC && !reads) {
                 if (ad->current_write_count == 0 || !writes)
                         ad->write_batch_idled = 1;
         }
@@ -1076,8 +1073,8 @@ static int as_dispatch_request(struct request_queue *q, int force)
                  */
                 rq = ad->next_rq[ad->batch_data_dir];
 
-                if (ad->batch_data_dir == REQ_SYNC && ad->antic_expire) {
-                        if (as_fifo_expired(ad, REQ_SYNC))
+                if (ad->batch_data_dir == BLK_RW_SYNC && ad->antic_expire) {
+                        if (as_fifo_expired(ad, BLK_RW_SYNC))
                                 goto fifo_expired;
 
                         if (as_can_anticipate(ad, rq)) {
@@ -1090,7 +1087,7 @@ static int as_dispatch_request(struct request_queue *q, int force)
                         /* we have a "next request" */
                         if (reads && !writes)
                                 ad->current_batch_expires =
-                                        jiffies + ad->batch_expire[REQ_SYNC];
+                                        jiffies + ad->batch_expire[BLK_RW_SYNC];
                         goto dispatch_request;
                 }
         }
@@ -1101,20 +1098,20 @@ static int as_dispatch_request(struct request_queue *q, int force)
          */
 
         if (reads) {
-                BUG_ON(RB_EMPTY_ROOT(&ad->sort_list[REQ_SYNC]));
+                BUG_ON(RB_EMPTY_ROOT(&ad->sort_list[BLK_RW_SYNC]));
 
-                if (writes && ad->batch_data_dir == REQ_SYNC)
+                if (writes && ad->batch_data_dir == BLK_RW_SYNC)
                         /*
                          * Last batch was a read, switch to writes
                          */
                         goto dispatch_writes;
 
-                if (ad->batch_data_dir == REQ_ASYNC) {
+                if (ad->batch_data_dir == BLK_RW_ASYNC) {
                         WARN_ON(ad->new_batch);
                         ad->changed_batch = 1;
                 }
-                ad->batch_data_dir = REQ_SYNC;
-                rq = rq_entry_fifo(ad->fifo_list[REQ_SYNC].next);
+                ad->batch_data_dir = BLK_RW_SYNC;
+                rq = rq_entry_fifo(ad->fifo_list[BLK_RW_SYNC].next);
                 ad->last_check_fifo[ad->batch_data_dir] = jiffies;
                 goto dispatch_request;
         }
@@ -1125,9 +1122,9 @@ static int as_dispatch_request(struct request_queue *q, int force)
 
         if (writes) {
 dispatch_writes:
-                BUG_ON(RB_EMPTY_ROOT(&ad->sort_list[REQ_ASYNC]));
+                BUG_ON(RB_EMPTY_ROOT(&ad->sort_list[BLK_RW_ASYNC]));
 
-                if (ad->batch_data_dir == REQ_SYNC) {
+                if (ad->batch_data_dir == BLK_RW_SYNC) {
                         ad->changed_batch = 1;
 
                         /*
@@ -1137,11 +1134,11 @@ dispatch_writes:
                          */
                         ad->new_batch = 0;
                 }
-                ad->batch_data_dir = REQ_ASYNC;
+                ad->batch_data_dir = BLK_RW_ASYNC;
                 ad->current_write_count = ad->write_batch_count;
                 ad->write_batch_idled = 0;
-                rq = rq_entry_fifo(ad->fifo_list[REQ_ASYNC].next);
-                ad->last_check_fifo[REQ_ASYNC] = jiffies;
+                rq = rq_entry_fifo(ad->fifo_list[BLK_RW_ASYNC].next);
+                ad->last_check_fifo[BLK_RW_ASYNC] = jiffies;
                 goto dispatch_request;
         }
 
@@ -1164,9 +1161,9 @@ fifo_expired:
                 if (ad->nr_dispatched)
                         return 0;
 
-                if (ad->batch_data_dir == REQ_ASYNC)
+                if (ad->batch_data_dir == BLK_RW_ASYNC)
                         ad->current_batch_expires = jiffies +
-                                        ad->batch_expire[REQ_ASYNC];
+                                        ad->batch_expire[BLK_RW_ASYNC];
                 else
                         ad->new_batch = 1;
 
@@ -1238,8 +1235,8 @@ static int as_queue_empty(struct request_queue *q)
 {
         struct as_data *ad = q->elevator->elevator_data;
 
-        return list_empty(&ad->fifo_list[REQ_ASYNC])
-                && list_empty(&ad->fifo_list[REQ_SYNC]);
+        return list_empty(&ad->fifo_list[BLK_RW_ASYNC])
+                && list_empty(&ad->fifo_list[BLK_RW_SYNC]);
 }
 
 static int
@@ -1346,8 +1343,8 @@ static void as_exit_queue(struct elevator_queue *e)
         del_timer_sync(&ad->antic_timer);
         cancel_work_sync(&ad->antic_work);
 
-        BUG_ON(!list_empty(&ad->fifo_list[REQ_SYNC]));
-        BUG_ON(!list_empty(&ad->fifo_list[REQ_ASYNC]));
+        BUG_ON(!list_empty(&ad->fifo_list[BLK_RW_SYNC]));
+        BUG_ON(!list_empty(&ad->fifo_list[BLK_RW_ASYNC]));
 
         put_io_context(ad->io_context);
         kfree(ad);
@@ -1372,18 +1369,18 @@ static void *as_init_queue(struct request_queue *q)
         init_timer(&ad->antic_timer);
         INIT_WORK(&ad->antic_work, as_work_handler);
 
-        INIT_LIST_HEAD(&ad->fifo_list[REQ_SYNC]);
-        INIT_LIST_HEAD(&ad->fifo_list[REQ_ASYNC]);
-        ad->sort_list[REQ_SYNC] = RB_ROOT;
-        ad->sort_list[REQ_ASYNC] = RB_ROOT;
-        ad->fifo_expire[REQ_SYNC] = default_read_expire;
-        ad->fifo_expire[REQ_ASYNC] = default_write_expire;
+        INIT_LIST_HEAD(&ad->fifo_list[BLK_RW_SYNC]);
+        INIT_LIST_HEAD(&ad->fifo_list[BLK_RW_ASYNC]);
+        ad->sort_list[BLK_RW_SYNC] = RB_ROOT;
+        ad->sort_list[BLK_RW_ASYNC] = RB_ROOT;
+        ad->fifo_expire[BLK_RW_SYNC] = default_read_expire;
+        ad->fifo_expire[BLK_RW_ASYNC] = default_write_expire;
         ad->antic_expire = default_antic_expire;
-        ad->batch_expire[REQ_SYNC] = default_read_batch_expire;
-        ad->batch_expire[REQ_ASYNC] = default_write_batch_expire;
+        ad->batch_expire[BLK_RW_SYNC] = default_read_batch_expire;
+        ad->batch_expire[BLK_RW_ASYNC] = default_write_batch_expire;
 
-        ad->current_batch_expires = jiffies + ad->batch_expire[REQ_SYNC];
-        ad->write_batch_count = ad->batch_expire[REQ_ASYNC] / 10;
+        ad->current_batch_expires = jiffies + ad->batch_expire[BLK_RW_SYNC];
+        ad->write_batch_count = ad->batch_expire[BLK_RW_ASYNC] / 10;
         if (ad->write_batch_count < 2)
                 ad->write_batch_count = 2;
 
@@ -1432,11 +1429,11 @@ static ssize_t __FUNC(struct elevator_queue *e, char *page)	\
         struct as_data *ad = e->elevator_data;                  \
         return as_var_show(jiffies_to_msecs((__VAR)), (page));  \
 }
-SHOW_FUNCTION(as_read_expire_show, ad->fifo_expire[REQ_SYNC]);
-SHOW_FUNCTION(as_write_expire_show, ad->fifo_expire[REQ_ASYNC]);
+SHOW_FUNCTION(as_read_expire_show, ad->fifo_expire[BLK_RW_SYNC]);
+SHOW_FUNCTION(as_write_expire_show, ad->fifo_expire[BLK_RW_ASYNC]);
 SHOW_FUNCTION(as_antic_expire_show, ad->antic_expire);
-SHOW_FUNCTION(as_read_batch_expire_show, ad->batch_expire[REQ_SYNC]);
-SHOW_FUNCTION(as_write_batch_expire_show, ad->batch_expire[REQ_ASYNC]);
+SHOW_FUNCTION(as_read_batch_expire_show, ad->batch_expire[BLK_RW_SYNC]);
+SHOW_FUNCTION(as_write_batch_expire_show, ad->batch_expire[BLK_RW_ASYNC]);
 #undef SHOW_FUNCTION
 
 #define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX)                         \
@@ -1451,13 +1448,14 @@ static ssize_t __FUNC(struct elevator_queue *e, const char *page, size_t count)
         *(__PTR) = msecs_to_jiffies(*(__PTR));                          \
         return ret;                                                     \
 }
-STORE_FUNCTION(as_read_expire_store, &ad->fifo_expire[REQ_SYNC], 0, INT_MAX);
-STORE_FUNCTION(as_write_expire_store, &ad->fifo_expire[REQ_ASYNC], 0, INT_MAX);
+STORE_FUNCTION(as_read_expire_store, &ad->fifo_expire[BLK_RW_SYNC], 0, INT_MAX);
+STORE_FUNCTION(as_write_expire_store,
+                        &ad->fifo_expire[BLK_RW_ASYNC], 0, INT_MAX);
 STORE_FUNCTION(as_antic_expire_store, &ad->antic_expire, 0, INT_MAX);
 STORE_FUNCTION(as_read_batch_expire_store,
-                        &ad->batch_expire[REQ_SYNC], 0, INT_MAX);
+                        &ad->batch_expire[BLK_RW_SYNC], 0, INT_MAX);
 STORE_FUNCTION(as_write_batch_expire_store,
-                        &ad->batch_expire[REQ_ASYNC], 0, INT_MAX);
+                        &ad->batch_expire[BLK_RW_ASYNC], 0, INT_MAX);
 #undef STORE_FUNCTION
 
 #define AS_ATTR(name) \