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

1 files changed, 31 insertions, 30 deletions

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 7706c8dc5fa6..5d5cae05818d 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -1673,6 +1673,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                 }
                 bio->bi_bdev = block_ctx->dev->bdev;
                 bio->bi_iter.bi_sector = dev_bytenr >> 9;
+                bio_set_op_attrs(bio, REQ_OP_READ, 0);
 
                 for (j = i; j < num_pages; j++) {
                         ret = bio_add_page(bio, block_ctx->pagev[j],
@@ -1685,7 +1686,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                                "btrfsic: error, failed to add a single page!\n");
                         return -1;
                 }
-                if (submit_bio_wait(READ, bio)) {
+                if (submit_bio_wait(bio)) {
                         printk(KERN_INFO
                                "btrfsic: read error at logical %llu dev %s!\n",
                                block_ctx->start, block_ctx->dev->name);
@@ -2206,7 +2207,7 @@ static void btrfsic_bio_end_io(struct bio *bp)
                                block->dev_bytenr, block->mirror_num);
                 next_block = block->next_in_same_bio;
                 block->iodone_w_error = iodone_w_error;
-                if (block->submit_bio_bh_rw & REQ_FLUSH) {
+                if (block->submit_bio_bh_rw & REQ_PREFLUSH) {
                         dev_state->last_flush_gen++;
                         if ((dev_state->state->print_mask &
                              BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
@@ -2242,7 +2243,7 @@ static void btrfsic_bh_end_io(struct buffer_head *bh, int uptodate)
                        block->dev_bytenr, block->mirror_num);
 
         block->iodone_w_error = iodone_w_error;
-        if (block->submit_bio_bh_rw & REQ_FLUSH) {
+        if (block->submit_bio_bh_rw & REQ_PREFLUSH) {
                 dev_state->last_flush_gen++;
                 if ((dev_state->state->print_mask &
                      BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
@@ -2855,12 +2856,12 @@ static struct btrfsic_dev_state *btrfsic_dev_state_lookup(
         return ds;
 }
 
-int btrfsic_submit_bh(int rw, struct buffer_head *bh)
+int btrfsic_submit_bh(int op, int op_flags, struct buffer_head *bh)
 {
         struct btrfsic_dev_state *dev_state;
 
         if (!btrfsic_is_initialized)
-                return submit_bh(rw, bh);
+                return submit_bh(op, op_flags, bh);
 
         mutex_lock(&btrfsic_mutex);
         /* since btrfsic_submit_bh() might also be called before
@@ -2869,26 +2870,26 @@ int btrfsic_submit_bh(int rw, struct buffer_head *bh)
 
         /* Only called to write the superblock (incl. FLUSH/FUA) */
         if (NULL != dev_state &&
-            (rw & WRITE) && bh->b_size > 0) {
+            (op == REQ_OP_WRITE) && bh->b_size > 0) {
                 u64 dev_bytenr;
 
                 dev_bytenr = 4096 * bh->b_blocknr;
                 if (dev_state->state->print_mask &
                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
                         printk(KERN_INFO
-                               "submit_bh(rw=0x%x, blocknr=%llu (bytenr %llu),"
-                               " size=%zu, data=%p, bdev=%p)\n",
-                               rw, (unsigned long long)bh->b_blocknr,
+                               "submit_bh(op=0x%x,0x%x, blocknr=%llu "
+                               "(bytenr %llu), size=%zu, data=%p, bdev=%p)\n",
+                               op, op_flags, (unsigned long long)bh->b_blocknr,
                                dev_bytenr, bh->b_size, bh->b_data, bh->b_bdev);
                 btrfsic_process_written_block(dev_state, dev_bytenr,
                                               &bh->b_data, 1, NULL,
-                                              NULL, bh, rw);
-        } else if (NULL != dev_state && (rw & REQ_FLUSH)) {
+                                              NULL, bh, op_flags);
+        } else if (NULL != dev_state && (op_flags & REQ_PREFLUSH)) {
                 if (dev_state->state->print_mask &
                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
                         printk(KERN_INFO
-                               "submit_bh(rw=0x%x FLUSH, bdev=%p)\n",
-                               rw, bh->b_bdev);
+                               "submit_bh(op=0x%x,0x%x FLUSH, bdev=%p)\n",
+                               op, op_flags, bh->b_bdev);
                 if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) {
                         if ((dev_state->state->print_mask &
                              (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
@@ -2906,7 +2907,7 @@ int btrfsic_submit_bh(int rw, struct buffer_head *bh)
                         block->never_written = 0;
                         block->iodone_w_error = 0;
                         block->flush_gen = dev_state->last_flush_gen + 1;
-                        block->submit_bio_bh_rw = rw;
+                        block->submit_bio_bh_rw = op_flags;
                         block->orig_bio_bh_private = bh->b_private;
                         block->orig_bio_bh_end_io.bh = bh->b_end_io;
                         block->next_in_same_bio = NULL;
@@ -2915,10 +2916,10 @@ int btrfsic_submit_bh(int rw, struct buffer_head *bh)
                 }
         }
         mutex_unlock(&btrfsic_mutex);
-        return submit_bh(rw, bh);
+        return submit_bh(op, op_flags, bh);
 }
 
-static void __btrfsic_submit_bio(int rw, struct bio *bio)
+static void __btrfsic_submit_bio(struct bio *bio)
 {
         struct btrfsic_dev_state *dev_state;
 
@@ -2930,7 +2931,7 @@ static void __btrfsic_submit_bio(int rw, struct bio *bio)
          * btrfsic_mount(), this might return NULL */
         dev_state = btrfsic_dev_state_lookup(bio->bi_bdev);
         if (NULL != dev_state &&
-            (rw & WRITE) && NULL != bio->bi_io_vec) {
+            (bio_op(bio) == REQ_OP_WRITE) && NULL != bio->bi_io_vec) {
                 unsigned int i;
                 u64 dev_bytenr;
                 u64 cur_bytenr;
@@ -2942,9 +2943,9 @@ static void __btrfsic_submit_bio(int rw, struct bio *bio)
                 if (dev_state->state->print_mask &
                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
                         printk(KERN_INFO
-                               "submit_bio(rw=0x%x, bi_vcnt=%u,"
+                               "submit_bio(rw=%d,0x%x, bi_vcnt=%u,"
                                " bi_sector=%llu (bytenr %llu), bi_bdev=%p)\n",
-                               rw, bio->bi_vcnt,
+                               bio_op(bio), bio->bi_rw, bio->bi_vcnt,
                                (unsigned long long)bio->bi_iter.bi_sector,
                                dev_bytenr, bio->bi_bdev);
 
@@ -2975,18 +2976,18 @@ static void __btrfsic_submit_bio(int rw, struct bio *bio)
                 btrfsic_process_written_block(dev_state, dev_bytenr,
                                               mapped_datav, bio->bi_vcnt,
                                               bio, &bio_is_patched,
-                                              NULL, rw);
+                                              NULL, bio->bi_rw);
                 while (i > 0) {
                         i--;
                         kunmap(bio->bi_io_vec[i].bv_page);
                 }
                 kfree(mapped_datav);
-        } else if (NULL != dev_state && (rw & REQ_FLUSH)) {
+        } else if (NULL != dev_state && (bio->bi_rw & REQ_PREFLUSH)) {
                 if (dev_state->state->print_mask &
                     BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH)
                         printk(KERN_INFO
-                               "submit_bio(rw=0x%x FLUSH, bdev=%p)\n",
-                               rw, bio->bi_bdev);
+                               "submit_bio(rw=%d,0x%x FLUSH, bdev=%p)\n",
+                               bio_op(bio), bio->bi_rw, bio->bi_bdev);
                 if (!dev_state->dummy_block_for_bio_bh_flush.is_iodone) {
                         if ((dev_state->state->print_mask &
                              (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
@@ -3004,7 +3005,7 @@ static void __btrfsic_submit_bio(int rw, struct bio *bio)
                         block->never_written = 0;
                         block->iodone_w_error = 0;
                         block->flush_gen = dev_state->last_flush_gen + 1;
-                        block->submit_bio_bh_rw = rw;
+                        block->submit_bio_bh_rw = bio->bi_rw;
                         block->orig_bio_bh_private = bio->bi_private;
                         block->orig_bio_bh_end_io.bio = bio->bi_end_io;
                         block->next_in_same_bio = NULL;
@@ -3016,16 +3017,16 @@ leave:
         mutex_unlock(&btrfsic_mutex);
 }
 
-void btrfsic_submit_bio(int rw, struct bio *bio)
+void btrfsic_submit_bio(struct bio *bio)
 {
-        __btrfsic_submit_bio(rw, bio);
-        submit_bio(rw, bio);
+        __btrfsic_submit_bio(bio);
+        submit_bio(bio);
 }
 
-int btrfsic_submit_bio_wait(int rw, struct bio *bio)
+int btrfsic_submit_bio_wait(struct bio *bio)
 {
-        __btrfsic_submit_bio(rw, bio);
-        return submit_bio_wait(rw, bio);
+        __btrfsic_submit_bio(bio);
+        return submit_bio_wait(bio);
 }
 
 int btrfsic_mount(struct btrfs_root *root,