Merge branch 'for-4.8/core' of git://git.kernel.dk/linux-block

Pull core block updates from Jens Axboe:

   - the big change is the cleanup from Mike Christie, cleaning up our
     uses of command types and modified flags.  This is what will throw
     some merge conflicts

   - regression fix for the above for btrfs, from Vincent

   - following up to the above, better packing of struct request from
     Christoph

   - a 2038 fix for blktrace from Arnd

   - a few trivial/spelling fixes from Bart Van Assche

   - a front merge check fix from Damien, which could cause issues on
     SMR drives

   - Atari partition fix from Gabriel

   - convert cfq to highres timers, since jiffies isn't granular enough
     for some devices these days.  From Jan and Jeff

   - CFQ priority boost fix idle classes, from me

   - cleanup series from Ming, improving our bio/bvec iteration

   - a direct issue fix for blk-mq from Omar

   - fix for plug merging not involving the IO scheduler, like we do for
     other types of merges.  From Tahsin

   - expose DAX type internally and through sysfs.  From Toshi and Yigal

* 'for-4.8/core' of git://git.kernel.dk/linux-block: (76 commits)
  block: Fix front merge check
  block: do not merge requests without consulting with io scheduler
  block: Fix spelling in a source code comment
  block: expose QUEUE_FLAG_DAX in sysfs
  block: add QUEUE_FLAG_DAX for devices to advertise their DAX support
  Btrfs: fix comparison in __btrfs_map_block()
  block: atari: Return early for unsupported sector size
  Doc: block: Fix a typo in queue-sysfs.txt
  cfq-iosched: Charge at least 1 jiffie instead of 1 ns
  cfq-iosched: Fix regression in bonnie++ rewrite performance
  cfq-iosched: Convert slice_resid from u64 to s64
  block: Convert fifo_time from ulong to u64
  blktrace: avoid using timespec
  block/blk-cgroup.c: Declare local symbols static
  block/bio-integrity.c: Add #include "blk.h"
  block/partition-generic.c: Remove a set-but-not-used variable
  block: bio: kill BIO_MAX_SIZE
  cfq-iosched: temporarily boost queue priority for idle classes
  block: drbd: avoid to use BIO_MAX_SIZE
  block: bio: remove BIO_MAX_SECTORS
  ...

6 files changed, 27 insertions, 21 deletions

diff --git a/fs/nilfs2/btnode.c b/fs/nilfs2/btnode.c
index 0576033699bc..4cca998ec7a0 100644
--- a/fs/nilfs2/btnode.c
+++ b/fs/nilfs2/btnode.c
@@ -62,7 +62,7 @@ nilfs_btnode_create_block(struct address_space *btnc, __u64 blocknr)
 }
 
 int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,
-                              sector_t pblocknr, int mode,
+                              sector_t pblocknr, int mode, int mode_flags,
                               struct buffer_head **pbh, sector_t *submit_ptr)
 {
         struct buffer_head *bh;
@@ -95,7 +95,7 @@ int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,
                 }
         }
 
-        if (mode == READA) {
+        if (mode_flags & REQ_RAHEAD) {
                 if (pblocknr != *submit_ptr + 1 || !trylock_buffer(bh)) {
                         err = -EBUSY; /* internal code */
                         brelse(bh);
@@ -114,7 +114,7 @@ int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,
         bh->b_blocknr = pblocknr; /* set block address for read */
         bh->b_end_io = end_buffer_read_sync;
         get_bh(bh);
-        submit_bh(mode, bh);
+        submit_bh(mode, mode_flags, bh);
         bh->b_blocknr = blocknr; /* set back to the given block address */
         *submit_ptr = pblocknr;
         err = 0;
diff --git a/fs/nilfs2/btnode.h b/fs/nilfs2/btnode.h
index 2cc1b80e18f7..4e8aaa1aeb65 100644
--- a/fs/nilfs2/btnode.h
+++ b/fs/nilfs2/btnode.h
@@ -43,7 +43,7 @@ void nilfs_btnode_cache_clear(struct address_space *);
 struct buffer_head *nilfs_btnode_create_block(struct address_space *btnc,
                                               __u64 blocknr);
 int nilfs_btnode_submit_block(struct address_space *, __u64, sector_t, int,
-                              struct buffer_head **, sector_t *);
+                              int, struct buffer_head **, sector_t *);
 void nilfs_btnode_delete(struct buffer_head *);
 int nilfs_btnode_prepare_change_key(struct address_space *,
                                     struct nilfs_btnode_chkey_ctxt *);
diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
index eccb1c89ccbb..982d1e3df3a5 100644
--- a/fs/nilfs2/btree.c
+++ b/fs/nilfs2/btree.c
@@ -476,7 +476,8 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr,
         sector_t submit_ptr = 0;
         int ret;
 
-        ret = nilfs_btnode_submit_block(btnc, ptr, 0, READ, &bh, &submit_ptr);
+        ret = nilfs_btnode_submit_block(btnc, ptr, 0, REQ_OP_READ, 0, &bh,
+                                        &submit_ptr);
         if (ret) {
                 if (ret != -EEXIST)
                         return ret;
@@ -492,7 +493,8 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr,
                      n > 0 && i < ra->ncmax; n--, i++) {
                         ptr2 = nilfs_btree_node_get_ptr(ra->node, i, ra->ncmax);
 
-                        ret = nilfs_btnode_submit_block(btnc, ptr2, 0, READA,
+                        ret = nilfs_btnode_submit_block(btnc, ptr2, 0,
+                                                        REQ_OP_READ, REQ_RAHEAD,
                                                         &ra_bh, &submit_ptr);
                         if (likely(!ret || ret == -EEXIST))
                                 brelse(ra_bh);
diff --git a/fs/nilfs2/gcinode.c b/fs/nilfs2/gcinode.c
index 693aded72498..e9148f94d696 100644
--- a/fs/nilfs2/gcinode.c
+++ b/fs/nilfs2/gcinode.c
@@ -101,7 +101,7 @@ int nilfs_gccache_submit_read_data(struct inode *inode, sector_t blkoff,
         bh->b_blocknr = pbn;
         bh->b_end_io = end_buffer_read_sync;
         get_bh(bh);
-        submit_bh(READ, bh);
+        submit_bh(REQ_OP_READ, 0, bh);
         if (vbn)
                 bh->b_blocknr = vbn;
  out:
@@ -138,7 +138,8 @@ int nilfs_gccache_submit_read_node(struct inode *inode, sector_t pbn,
         int ret;
 
         ret = nilfs_btnode_submit_block(&NILFS_I(inode)->i_btnode_cache,
-                                        vbn ? : pbn, pbn, READ, out_bh, &pbn);
+                                        vbn ? : pbn, pbn, REQ_OP_READ, 0,
+                                        out_bh, &pbn);
         if (ret == -EEXIST) /* internal code (cache hit) */
                 ret = 0;
         return ret;
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index 3417d859a03c..0d7b71fbeff8 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -121,7 +121,7 @@ static int nilfs_mdt_create_block(struct inode *inode, unsigned long block,
 
 static int
 nilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,
-                       int mode, struct buffer_head **out_bh)
+                       int mode, int mode_flags, struct buffer_head **out_bh)
 {
         struct buffer_head *bh;
         __u64 blknum = 0;
@@ -135,7 +135,7 @@ nilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,
         if (buffer_uptodate(bh))
                 goto out;
 
-        if (mode == READA) {
+        if (mode_flags & REQ_RAHEAD) {
                 if (!trylock_buffer(bh)) {
                         ret = -EBUSY;
                         goto failed_bh;
@@ -157,7 +157,7 @@ nilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,
 
         bh->b_end_io = end_buffer_read_sync;
         get_bh(bh);
-        submit_bh(mode, bh);
+        submit_bh(mode, mode_flags, bh);
         ret = 0;
 
         trace_nilfs2_mdt_submit_block(inode, inode->i_ino, blkoff, mode);
@@ -181,7 +181,7 @@ static int nilfs_mdt_read_block(struct inode *inode, unsigned long block,
         int i, nr_ra_blocks = NILFS_MDT_MAX_RA_BLOCKS;
         int err;
 
-        err = nilfs_mdt_submit_block(inode, block, READ, &first_bh);
+        err = nilfs_mdt_submit_block(inode, block, REQ_OP_READ, 0, &first_bh);
         if (err == -EEXIST) /* internal code */
                 goto out;
 
@@ -191,7 +191,8 @@ static int nilfs_mdt_read_block(struct inode *inode, unsigned long block,
         if (readahead) {
                 blkoff = block + 1;
                 for (i = 0; i < nr_ra_blocks; i++, blkoff++) {
-                        err = nilfs_mdt_submit_block(inode, blkoff, READA, &bh);
+                        err = nilfs_mdt_submit_block(inode, blkoff, REQ_OP_READ,
+                                                     REQ_RAHEAD, &bh);
                         if (likely(!err || err == -EEXIST))
                                 brelse(bh);
                         else if (err != -EBUSY)
diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
index bf36df10540b..a962d7d83447 100644
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -346,7 +346,8 @@ static void nilfs_end_bio_write(struct bio *bio)
 }
 
 static int nilfs_segbuf_submit_bio(struct nilfs_segment_buffer *segbuf,
-                                   struct nilfs_write_info *wi, int mode)
+                                   struct nilfs_write_info *wi, int mode,
+                                   int mode_flags)
 {
         struct bio *bio = wi->bio;
         int err;
@@ -364,7 +365,8 @@ static int nilfs_segbuf_submit_bio(struct nilfs_segment_buffer *segbuf,
 
         bio->bi_end_io = nilfs_end_bio_write;
         bio->bi_private = segbuf;
-        submit_bio(mode, bio);
+        bio_set_op_attrs(bio, mode, mode_flags);
+        submit_bio(bio);
         segbuf->sb_nbio++;
 
         wi->bio = NULL;
@@ -437,7 +439,7 @@ static int nilfs_segbuf_submit_bh(struct nilfs_segment_buffer *segbuf,
                 return 0;
         }
         /* bio is FULL */
-        err = nilfs_segbuf_submit_bio(segbuf, wi, mode);
+        err = nilfs_segbuf_submit_bio(segbuf, wi, mode, 0);
         /* never submit current bh */
         if (likely(!err))
                 goto repeat;
@@ -461,19 +463,19 @@ static int nilfs_segbuf_write(struct nilfs_segment_buffer *segbuf,
 {
         struct nilfs_write_info wi;
         struct buffer_head *bh;
-        int res = 0, rw = WRITE;
+        int res = 0;
 
         wi.nilfs = nilfs;
         nilfs_segbuf_prepare_write(segbuf, &wi);
 
         list_for_each_entry(bh, &segbuf->sb_segsum_buffers, b_assoc_buffers) {
-                res = nilfs_segbuf_submit_bh(segbuf, &wi, bh, rw);
+                res = nilfs_segbuf_submit_bh(segbuf, &wi, bh, REQ_OP_WRITE);
                 if (unlikely(res))
                         goto failed_bio;
         }
 
         list_for_each_entry(bh, &segbuf->sb_payload_buffers, b_assoc_buffers) {
-                res = nilfs_segbuf_submit_bh(segbuf, &wi, bh, rw);
+                res = nilfs_segbuf_submit_bh(segbuf, &wi, bh, REQ_OP_WRITE);
                 if (unlikely(res))
                         goto failed_bio;
         }
@@ -483,8 +485,8 @@ static int nilfs_segbuf_write(struct nilfs_segment_buffer *segbuf,
                  * Last BIO is always sent through the following
                  * submission.
                  */
-                rw |= REQ_SYNC;
-                res = nilfs_segbuf_submit_bio(segbuf, &wi, rw);
+                res = nilfs_segbuf_submit_bio(segbuf, &wi, REQ_OP_WRITE,
+                                              REQ_SYNC);
         }
 
  failed_bio: