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

Pull core block IO changes from Jens Axboe:
 "The major piece in here is the immutable bio_ve series from Kent, the
  rest is fairly minor.  It was supposed to go in last round, but
  various issues pushed it to this release instead.  The pull request
  contains:

   - Various smaller blk-mq fixes from different folks.  Nothing major
     here, just minor fixes and cleanups.

   - Fix for a memory leak in the error path in the block ioctl code
     from Christian Engelmayer.

   - Header export fix from CaiZhiyong.

   - Finally the immutable biovec changes from Kent Overstreet.  This
     enables some nice future work on making arbitrarily sized bios
     possible, and splitting more efficient.  Related fixes to immutable
     bio_vecs:

        - dm-cache immutable fixup from Mike Snitzer.
        - btrfs immutable fixup from Muthu Kumar.

  - bio-integrity fix from Nic Bellinger, which is also going to stable"

* 'for-3.14/core' of git://git.kernel.dk/linux-block: (44 commits)
  xtensa: fixup simdisk driver to work with immutable bio_vecs
  block/blk-mq-cpu.c: use hotcpu_notifier()
  blk-mq: for_each_* macro correctness
  block: Fix memory leak in rw_copy_check_uvector() handling
  bio-integrity: Fix bio_integrity_verify segment start bug
  block: remove unrelated header files and export symbol
  blk-mq: uses page->list incorrectly
  blk-mq: use __smp_call_function_single directly
  btrfs: fix missing increment of bi_remaining
  Revert "block: Warn and free bio if bi_end_io is not set"
  block: Warn and free bio if bi_end_io is not set
  blk-mq: fix initializing request's start time
  block: blk-mq: don't export blk_mq_free_queue()
  block: blk-mq: make blk_sync_queue support mq
  block: blk-mq: support draining mq queue
  dm cache: increment bi_remaining when bi_end_io is restored
  block: fixup for generic bio chaining
  block: Really silence spurious compiler warnings
  block: Silence spurious compiler warnings
  block: Kill bio_pair_split()
  ...

1 files changed, 38 insertions, 35 deletions

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index a49cfcc7a343..fd3a2a14b587 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -229,7 +229,7 @@ static void call_bio_endio(struct r1bio *r1_bio)
         int done;
         struct r1conf *conf = r1_bio->mddev->private;
         sector_t start_next_window = r1_bio->start_next_window;
-        sector_t bi_sector = bio->bi_sector;
+        sector_t bi_sector = bio->bi_iter.bi_sector;
 
         if (bio->bi_phys_segments) {
                 unsigned long flags;
@@ -265,9 +265,8 @@ static void raid_end_bio_io(struct r1bio *r1_bio)
         if (!test_and_set_bit(R1BIO_Returned, &r1_bio->state)) {
                 pr_debug("raid1: sync end %s on sectors %llu-%llu\n",
                          (bio_data_dir(bio) == WRITE) ? "write" : "read",
-                         (unsigned long long) bio->bi_sector,
-                         (unsigned long long) bio->bi_sector +
-                         bio_sectors(bio) - 1);
+                         (unsigned long long) bio->bi_iter.bi_sector,
+                         (unsigned long long) bio_end_sector(bio) - 1);
 
                 call_bio_endio(r1_bio);
         }
@@ -466,9 +465,8 @@ static void raid1_end_write_request(struct bio *bio, int error)
                                 struct bio *mbio = r1_bio->master_bio;
                                 pr_debug("raid1: behind end write sectors"
                                          " %llu-%llu\n",
-                                         (unsigned long long) mbio->bi_sector,
-                                         (unsigned long long) mbio->bi_sector +
-                                         bio_sectors(mbio) - 1);
+                                         (unsigned long long) mbio->bi_iter.bi_sector,
+                                         (unsigned long long) bio_end_sector(mbio) - 1);
                                 call_bio_endio(r1_bio);
                         }
                 }
@@ -875,7 +873,7 @@ static bool need_to_wait_for_sync(struct r1conf *conf, struct bio *bio)
                 else if ((conf->next_resync - RESYNC_WINDOW_SECTORS
                                 >= bio_end_sector(bio)) ||
                          (conf->next_resync + NEXT_NORMALIO_DISTANCE
-                                <= bio->bi_sector))
+                                <= bio->bi_iter.bi_sector))
                         wait = false;
                 else
                         wait = true;
@@ -913,14 +911,14 @@ static sector_t wait_barrier(struct r1conf *conf, struct bio *bio)
 
         if (bio && bio_data_dir(bio) == WRITE) {
                 if (conf->next_resync + NEXT_NORMALIO_DISTANCE
-                    <= bio->bi_sector) {
+                    <= bio->bi_iter.bi_sector) {
                         if (conf->start_next_window == MaxSector)
                                 conf->start_next_window =
                                         conf->next_resync +
                                         NEXT_NORMALIO_DISTANCE;
 
                         if ((conf->start_next_window + NEXT_NORMALIO_DISTANCE)
-                            <= bio->bi_sector)
+                            <= bio->bi_iter.bi_sector)
                                 conf->next_window_requests++;
                         else
                                 conf->current_window_requests++;
@@ -1027,7 +1025,8 @@ do_sync_io:
                 if (bvecs[i].bv_page)
                         put_page(bvecs[i].bv_page);
         kfree(bvecs);
-        pr_debug("%dB behind alloc failed, doing sync I/O\n", bio->bi_size);
+        pr_debug("%dB behind alloc failed, doing sync I/O\n",
+                 bio->bi_iter.bi_size);
 }
 
 struct raid1_plug_cb {
@@ -1107,7 +1106,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
 
         if (bio_data_dir(bio) == WRITE &&
             bio_end_sector(bio) > mddev->suspend_lo &&
-            bio->bi_sector < mddev->suspend_hi) {
+            bio->bi_iter.bi_sector < mddev->suspend_hi) {
                 /* As the suspend_* range is controlled by
                  * userspace, we want an interruptible
                  * wait.
@@ -1118,7 +1117,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
                         prepare_to_wait(&conf->wait_barrier,
                                         &w, TASK_INTERRUPTIBLE);
                         if (bio_end_sector(bio) <= mddev->suspend_lo ||
-                            bio->bi_sector >= mddev->suspend_hi)
+                            bio->bi_iter.bi_sector >= mddev->suspend_hi)
                                 break;
                         schedule();
                 }
@@ -1140,7 +1139,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         r1_bio->sectors = bio_sectors(bio);
         r1_bio->state = 0;
         r1_bio->mddev = mddev;
-        r1_bio->sector = bio->bi_sector;
+        r1_bio->sector = bio->bi_iter.bi_sector;
 
         /* We might need to issue multiple reads to different
          * devices if there are bad blocks around, so we keep
@@ -1180,12 +1179,13 @@ read_again:
                 r1_bio->read_disk = rdisk;
 
                 read_bio = bio_clone_mddev(bio, GFP_NOIO, mddev);
-                bio_trim(read_bio, r1_bio->sector - bio->bi_sector,
+                bio_trim(read_bio, r1_bio->sector - bio->bi_iter.bi_sector,
                          max_sectors);
 
                 r1_bio->bios[rdisk] = read_bio;
 
-                read_bio->bi_sector = r1_bio->sector + mirror->rdev->data_offset;
+                read_bio->bi_iter.bi_sector = r1_bio->sector +
+                        mirror->rdev->data_offset;
                 read_bio->bi_bdev = mirror->rdev->bdev;
                 read_bio->bi_end_io = raid1_end_read_request;
                 read_bio->bi_rw = READ | do_sync;
@@ -1197,7 +1197,7 @@ read_again:
                          */
 
                         sectors_handled = (r1_bio->sector + max_sectors
-                                           - bio->bi_sector);
+                                           - bio->bi_iter.bi_sector);
                         r1_bio->sectors = max_sectors;
                         spin_lock_irq(&conf->device_lock);
                         if (bio->bi_phys_segments == 0)
@@ -1218,7 +1218,8 @@ read_again:
                         r1_bio->sectors = bio_sectors(bio) - sectors_handled;
                         r1_bio->state = 0;
                         r1_bio->mddev = mddev;
-                        r1_bio->sector = bio->bi_sector + sectors_handled;
+                        r1_bio->sector = bio->bi_iter.bi_sector +
+                                sectors_handled;
                         goto read_again;
                 } else
                         generic_make_request(read_bio);
@@ -1321,7 +1322,7 @@ read_again:
                         if (r1_bio->bios[j])
                                 rdev_dec_pending(conf->mirrors[j].rdev, mddev);
                 r1_bio->state = 0;
-                allow_barrier(conf, start_next_window, bio->bi_sector);
+                allow_barrier(conf, start_next_window, bio->bi_iter.bi_sector);
                 md_wait_for_blocked_rdev(blocked_rdev, mddev);
                 start_next_window = wait_barrier(conf, bio);
                 /*
@@ -1348,7 +1349,7 @@ read_again:
                         bio->bi_phys_segments++;
                 spin_unlock_irq(&conf->device_lock);
         }
-        sectors_handled = r1_bio->sector + max_sectors - bio->bi_sector;
+        sectors_handled = r1_bio->sector + max_sectors - bio->bi_iter.bi_sector;
 
         atomic_set(&r1_bio->remaining, 1);
         atomic_set(&r1_bio->behind_remaining, 0);
@@ -1360,7 +1361,7 @@ read_again:
                         continue;
 
                 mbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
-                bio_trim(mbio, r1_bio->sector - bio->bi_sector, max_sectors);
+                bio_trim(mbio, r1_bio->sector - bio->bi_iter.bi_sector, max_sectors);
 
                 if (first_clone) {
                         /* do behind I/O ?
@@ -1394,7 +1395,7 @@ read_again:
 
                 r1_bio->bios[i] = mbio;
 
-                mbio->bi_sector = (r1_bio->sector +
+                mbio->bi_iter.bi_sector = (r1_bio->sector +
                                    conf->mirrors[i].rdev->data_offset);
                 mbio->bi_bdev = conf->mirrors[i].rdev->bdev;
                 mbio->bi_end_io = raid1_end_write_request;
@@ -1434,7 +1435,7 @@ read_again:
                 r1_bio->sectors = bio_sectors(bio) - sectors_handled;
                 r1_bio->state = 0;
                 r1_bio->mddev = mddev;
-                r1_bio->sector = bio->bi_sector + sectors_handled;
+                r1_bio->sector = bio->bi_iter.bi_sector + sectors_handled;
                 goto retry_write;
         }
 
@@ -1958,14 +1959,14 @@ static int process_checks(struct r1bio *r1_bio)
                 /* fixup the bio for reuse */
                 bio_reset(b);
                 b->bi_vcnt = vcnt;
-                b->bi_size = r1_bio->sectors << 9;
-                b->bi_sector = r1_bio->sector +
+                b->bi_iter.bi_size = r1_bio->sectors << 9;
+                b->bi_iter.bi_sector = r1_bio->sector +
                         conf->mirrors[i].rdev->data_offset;
                 b->bi_bdev = conf->mirrors[i].rdev->bdev;
                 b->bi_end_io = end_sync_read;
                 b->bi_private = r1_bio;
 
-                size = b->bi_size;
+                size = b->bi_iter.bi_size;
                 for (j = 0; j < vcnt ; j++) {
                         struct bio_vec *bi;
                         bi = &b->bi_io_vec[j];
@@ -2220,11 +2221,11 @@ static int narrow_write_error(struct r1bio *r1_bio, int i)
                 }
 
                 wbio->bi_rw = WRITE;
-                wbio->bi_sector = r1_bio->sector;
-                wbio->bi_size = r1_bio->sectors << 9;
+                wbio->bi_iter.bi_sector = r1_bio->sector;
+                wbio->bi_iter.bi_size = r1_bio->sectors << 9;
 
                 bio_trim(wbio, sector - r1_bio->sector, sectors);
-                wbio->bi_sector += rdev->data_offset;
+                wbio->bi_iter.bi_sector += rdev->data_offset;
                 wbio->bi_bdev = rdev->bdev;
                 if (submit_bio_wait(WRITE, wbio) == 0)
                         /* failure! */
@@ -2338,7 +2339,8 @@ read_more:
                 }
                 r1_bio->read_disk = disk;
                 bio = bio_clone_mddev(r1_bio->master_bio, GFP_NOIO, mddev);
-                bio_trim(bio, r1_bio->sector - bio->bi_sector, max_sectors);
+                bio_trim(bio, r1_bio->sector - bio->bi_iter.bi_sector,
+                         max_sectors);
                 r1_bio->bios[r1_bio->read_disk] = bio;
                 rdev = conf->mirrors[disk].rdev;
                 printk_ratelimited(KERN_ERR
@@ -2347,7 +2349,7 @@ read_more:
                                    mdname(mddev),
                                    (unsigned long long)r1_bio->sector,
                                    bdevname(rdev->bdev, b));
-                bio->bi_sector = r1_bio->sector + rdev->data_offset;
+                bio->bi_iter.bi_sector = r1_bio->sector + rdev->data_offset;
                 bio->bi_bdev = rdev->bdev;
                 bio->bi_end_io = raid1_end_read_request;
                 bio->bi_rw = READ | do_sync;
@@ -2356,7 +2358,7 @@ read_more:
                         /* Drat - have to split this up more */
                         struct bio *mbio = r1_bio->master_bio;
                         int sectors_handled = (r1_bio->sector + max_sectors
-                                               - mbio->bi_sector);
+                                               - mbio->bi_iter.bi_sector);
                         r1_bio->sectors = max_sectors;
                         spin_lock_irq(&conf->device_lock);
                         if (mbio->bi_phys_segments == 0)
@@ -2374,7 +2376,8 @@ read_more:
                         r1_bio->state = 0;
                         set_bit(R1BIO_ReadError, &r1_bio->state);
                         r1_bio->mddev = mddev;
-                        r1_bio->sector = mbio->bi_sector + sectors_handled;
+                        r1_bio->sector = mbio->bi_iter.bi_sector +
+                                sectors_handled;
 
                         goto read_more;
                 } else
@@ -2598,7 +2601,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
                 }
                 if (bio->bi_end_io) {
                         atomic_inc(&rdev->nr_pending);
-                        bio->bi_sector = sector_nr + rdev->data_offset;
+                        bio->bi_iter.bi_sector = sector_nr + rdev->data_offset;
                         bio->bi_bdev = rdev->bdev;
                         bio->bi_private = r1_bio;
                 }
@@ -2698,7 +2701,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
                                                         continue;
                                                 /* remove last page from this bio */
                                                 bio->bi_vcnt--;
-                                                bio->bi_size -= len;
+                                                bio->bi_iter.bi_size -= len;
                                                 bio->bi_flags &= ~(1<< BIO_SEG_VALID);
                                         }
                                         goto bio_full;