block: better op and flags encoding

Now that we don't need the common flags to overflow outside the range
of a 32-bit type we can encode them the same way for both the bio and
request fields.  This in addition allows us to place the operation
first (and make some room for more ops while we're at it) and to
stop having to shift around the operation values.

In addition this allows passing around only one value in the block layer
instead of two (and eventuall also in the file systems, but we can do
that later) and thus clean up a lot of code.

Last but not least this allows decreasing the size of the cmd_flags
field in struct request to 32-bits.  Various functions passing this
value could also be updated, but I'd like to avoid the churn for now.

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

6 files changed, 48 insertions, 80 deletions

diff --git a/include/linux/blk-cgroup.h b/include/linux/blk-cgroup.h
index 3bf5d33800ab..ddaf28d0988f 100644
--- a/include/linux/blk-cgroup.h
+++ b/include/linux/blk-cgroup.h
@@ -581,15 +581,14 @@ static inline void blkg_rwstat_exit(struct blkg_rwstat *rwstat)
 /**
  * blkg_rwstat_add - add a value to a blkg_rwstat
  * @rwstat: target blkg_rwstat
- * @op: REQ_OP
- * @op_flags: rq_flag_bits
+ * @op: REQ_OP and flags
  * @val: value to add
  *
  * Add @val to @rwstat.  The counters are chosen according to @rw.  The
  * caller is responsible for synchronizing calls to this function.
  */
 static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
-                                   int op, int op_flags, uint64_t val)
+                                   unsigned int op, uint64_t val)
 {
         struct percpu_counter *cnt;
 
@@ -600,7 +599,7 @@ static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
 
         __percpu_counter_add(cnt, val, BLKG_STAT_CPU_BATCH);
 
-        if (op_flags & REQ_SYNC)
+        if (op & REQ_SYNC)
                 cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_SYNC];
         else
                 cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_ASYNC];
@@ -705,9 +704,9 @@ static inline bool blkcg_bio_issue_check(struct request_queue *q,
 
         if (!throtl) {
                 blkg = blkg ?: q->root_blkg;
-                blkg_rwstat_add(&blkg->stat_bytes, bio_op(bio), bio->bi_opf,
+                blkg_rwstat_add(&blkg->stat_bytes, bio->bi_opf,
                                 bio->bi_iter.bi_size);
-                blkg_rwstat_add(&blkg->stat_ios, bio_op(bio), bio->bi_opf, 1);
+                blkg_rwstat_add(&blkg->stat_ios, bio->bi_opf, 1);
         }
 
         rcu_read_unlock();
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index ec69a8fe3b29..dca972d67548 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -88,24 +88,6 @@ struct bio {
         struct bio_vec          bi_inline_vecs[0];
 };
 
-#define BIO_OP_SHIFT    (8 * FIELD_SIZEOF(struct bio, bi_opf) - REQ_OP_BITS)
-#define bio_flags(bio)  ((bio)->bi_opf & ((1 << BIO_OP_SHIFT) - 1))
-#define bio_op(bio)     ((bio)->bi_opf >> BIO_OP_SHIFT)
-
-#define bio_set_op_attrs(bio, op, op_flags) do {                        \
-        if (__builtin_constant_p(op))                                   \
-                BUILD_BUG_ON((op) + 0U >= (1U << REQ_OP_BITS));         \
-        else                                                            \
-                WARN_ON_ONCE((op) + 0U >= (1U << REQ_OP_BITS));         \
-        if (__builtin_constant_p(op_flags))                             \
-                BUILD_BUG_ON((op_flags) + 0U >= (1U << BIO_OP_SHIFT));  \
-        else                                                            \
-                WARN_ON_ONCE((op_flags) + 0U >= (1U << BIO_OP_SHIFT));  \
-        (bio)->bi_opf = bio_flags(bio);                                 \
-        (bio)->bi_opf |= (((op) + 0U) << BIO_OP_SHIFT);                 \
-        (bio)->bi_opf |= (op_flags);                                    \
-} while (0)
-
 #define BIO_RESET_BYTES         offsetof(struct bio, bi_max_vecs)
 
 /*
@@ -147,26 +129,40 @@ struct bio {
 #endif /* CONFIG_BLOCK */
 
 /*
- * Request flags.  For use in the cmd_flags field of struct request, and in
- * bi_opf of struct bio.  Note that some flags are only valid in either one.
+ * Operations and flags common to the bio and request structures.
+ * We use 8 bits for encoding the operation, and the remaining 24 for flags.
  */
-enum rq_flag_bits {
-        /* common flags */
-        __REQ_FAILFAST_DEV,     /* no driver retries of device errors */
+#define REQ_OP_BITS     8
+#define REQ_OP_MASK     ((1 << REQ_OP_BITS) - 1)
+#define REQ_FLAG_BITS   24
+
+enum req_opf {
+        REQ_OP_READ,
+        REQ_OP_WRITE,
+        REQ_OP_DISCARD,         /* request to discard sectors */
+        REQ_OP_SECURE_ERASE,    /* request to securely erase sectors */
+        REQ_OP_WRITE_SAME,      /* write same block many times */
+        REQ_OP_FLUSH,           /* request for cache flush */
+        REQ_OP_ZONE_REPORT,     /* Get zone information */
+        REQ_OP_ZONE_RESET,      /* Reset a zone write pointer */
+
+        REQ_OP_LAST,
+};
+
+enum req_flag_bits {
+        __REQ_FAILFAST_DEV =    /* no driver retries of device errors */
+                REQ_OP_BITS,
         __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
         __REQ_FAILFAST_DRIVER,  /* no driver retries of driver errors */
-
         __REQ_SYNC,             /* request is sync (sync write or read) */
         __REQ_META,             /* metadata io request */
         __REQ_PRIO,             /* boost priority in cfq */
-
         __REQ_NOMERGE,          /* don't touch this for merging */
         __REQ_NOIDLE,           /* don't anticipate more IO after this one */
         __REQ_INTEGRITY,        /* I/O includes block integrity payload */
         __REQ_FUA,              /* forced unit access */
         __REQ_PREFLUSH,         /* request for cache flush */
         __REQ_RAHEAD,           /* read ahead, can fail anytime */
-
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -176,37 +172,32 @@ enum rq_flag_bits {
 #define REQ_SYNC                (1ULL << __REQ_SYNC)
 #define REQ_META                (1ULL << __REQ_META)
 #define REQ_PRIO                (1ULL << __REQ_PRIO)
+#define REQ_NOMERGE             (1ULL << __REQ_NOMERGE)
 #define REQ_NOIDLE              (1ULL << __REQ_NOIDLE)
 #define REQ_INTEGRITY           (1ULL << __REQ_INTEGRITY)
+#define REQ_FUA                 (1ULL << __REQ_FUA)
+#define REQ_PREFLUSH            (1ULL << __REQ_PREFLUSH)
+#define REQ_RAHEAD              (1ULL << __REQ_RAHEAD)
 
 #define REQ_FAILFAST_MASK \
         (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
-#define REQ_COMMON_MASK \
-        (REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_PRIO | REQ_NOIDLE | \
-         REQ_PREFLUSH | REQ_FUA | REQ_INTEGRITY | REQ_NOMERGE | REQ_RAHEAD)
-#define REQ_CLONE_MASK          REQ_COMMON_MASK
 
-/* This mask is used for both bio and request merge checking */
 #define REQ_NOMERGE_FLAGS \
         (REQ_NOMERGE | REQ_PREFLUSH | REQ_FUA)
 
-#define REQ_RAHEAD              (1ULL << __REQ_RAHEAD)
-#define REQ_FUA                 (1ULL << __REQ_FUA)
-#define REQ_NOMERGE             (1ULL << __REQ_NOMERGE)
-#define REQ_PREFLUSH            (1ULL << __REQ_PREFLUSH)
+#define bio_op(bio) \
+        ((bio)->bi_opf & REQ_OP_MASK)
+#define req_op(req) \
+        ((req)->cmd_flags & REQ_OP_MASK)
 
-enum req_op {
-        REQ_OP_READ,
-        REQ_OP_WRITE,
-        REQ_OP_DISCARD,         /* request to discard sectors */
-        REQ_OP_SECURE_ERASE,    /* request to securely erase sectors */
-        REQ_OP_WRITE_SAME,      /* write same block many times */
-        REQ_OP_FLUSH,           /* request for cache flush */
-        REQ_OP_ZONE_REPORT,     /* Get zone information */
-        REQ_OP_ZONE_RESET,      /* Reset a zone write pointer */
-};
+/* obsolete, don't use in new code */
+#define bio_set_op_attrs(bio, op, op_flags) \
+        ((bio)->bi_opf |= (op | op_flags))
 
-#define REQ_OP_BITS 3
+static inline bool op_is_sync(unsigned int op)
+{
+        return (op & REQ_OP_MASK) == REQ_OP_READ || (op & REQ_SYNC);
+}
 
 typedef unsigned int blk_qc_t;
 #define BLK_QC_T_NONE   -1U
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index b4415feac679..8396da2bb698 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -142,7 +142,7 @@ struct request {
 
         int cpu;
         unsigned cmd_type;
-        u64 cmd_flags;
+        unsigned int cmd_flags;         /* op and common flags */
         req_flags_t rq_flags;
         unsigned long atomic_flags;
 
@@ -244,20 +244,6 @@ struct request {
         struct request *next_rq;
 };
 
-#define REQ_OP_SHIFT (8 * sizeof(u64) - REQ_OP_BITS)
-#define req_op(req)  ((req)->cmd_flags >> REQ_OP_SHIFT)
-
-#define req_set_op(req, op) do {                                \
-        WARN_ON(op >= (1 << REQ_OP_BITS));                      \
-        (req)->cmd_flags &= ((1ULL << REQ_OP_SHIFT) - 1);       \
-        (req)->cmd_flags |= ((u64) (op) << REQ_OP_SHIFT);       \
-} while (0)
-
-#define req_set_op_attrs(req, op, flags) do {   \
-        req_set_op(req, op);                    \
-        (req)->cmd_flags |= flags;              \
-} while (0)
-
 static inline unsigned short req_get_ioprio(struct request *req)
 {
         return req->ioprio;
@@ -741,17 +727,9 @@ static inline unsigned int blk_queue_zone_size(struct request_queue *q)
         return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
 }
 
-/*
- * We regard a request as sync, if either a read or a sync write
- */
-static inline bool rw_is_sync(int op, unsigned int rw_flags)
-{
-        return op == REQ_OP_READ || (rw_flags & REQ_SYNC);
-}
-
 static inline bool rq_is_sync(struct request *rq)
 {
-        return rw_is_sync(req_op(rq), rq->cmd_flags);
+        return op_is_sync(rq->cmd_flags);
 }
 
 static inline bool blk_rl_full(struct request_list *rl, bool sync)
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index cceb72f9e29f..e417f080219a 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -118,7 +118,7 @@ static inline int blk_cmd_buf_len(struct request *rq)
 }
 
 extern void blk_dump_cmd(char *buf, struct request *rq);
-extern void blk_fill_rwbs(char *rwbs, int op, u32 rw, int bytes);
+extern void blk_fill_rwbs(char *rwbs, unsigned int op, int bytes);
 
 #endif /* CONFIG_EVENT_TRACING && CONFIG_BLOCK */
 
diff --git a/include/linux/dm-io.h b/include/linux/dm-io.h
index b91b023deffb..a52c6580cc9a 100644
--- a/include/linux/dm-io.h
+++ b/include/linux/dm-io.h
@@ -58,7 +58,7 @@ struct dm_io_notify {
 struct dm_io_client;
 struct dm_io_request {
         int bi_op;                      /* REQ_OP */
-        int bi_op_flags;                /* rq_flag_bits */
+        int bi_op_flags;                /* req_flag_bits */
         struct dm_io_memory mem;        /* Memory to use for io */
         struct dm_io_notify notify;     /* Synchronous if notify.fn is NULL */
         struct dm_io_client *client;    /* Client memory handler */
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index e7f358d2e5fc..f219c9aed360 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -30,7 +30,7 @@ typedef int (elevator_dispatch_fn) (struct request_queue *, int);
 typedef void (elevator_add_req_fn) (struct request_queue *, struct request *);
 typedef struct request *(elevator_request_list_fn) (struct request_queue *, struct request *);
 typedef void (elevator_completed_req_fn) (struct request_queue *, struct request *);
-typedef int (elevator_may_queue_fn) (struct request_queue *, int, int);
+typedef int (elevator_may_queue_fn) (struct request_queue *, unsigned int);
 
 typedef void (elevator_init_icq_fn) (struct io_cq *);
 typedef void (elevator_exit_icq_fn) (struct io_cq *);
@@ -139,7 +139,7 @@ extern struct request *elv_former_request(struct request_queue *, struct request
 extern struct request *elv_latter_request(struct request_queue *, struct request *);
 extern int elv_register_queue(struct request_queue *q);
 extern void elv_unregister_queue(struct request_queue *q);
-extern int elv_may_queue(struct request_queue *, int, int);
+extern int elv_may_queue(struct request_queue *, unsigned int);
 extern void elv_completed_request(struct request_queue *, struct request *);
 extern int elv_set_request(struct request_queue *q, struct request *rq,
                            struct bio *bio, gfp_t gfp_mask);