11 files changed, 104 insertions, 202 deletions

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 13c15480d940..6d2d41ae9e32 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -858,8 +858,7 @@ static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
         unsigned int i;
         struct bio_vec *bv;
 
-        for (i = 0; i < clone->bi_vcnt; i++) {
-                bv = bio_iovec_idx(clone, i);
+        bio_for_each_segment_all(bv, clone, i) {
                 BUG_ON(!bv->bv_page);
                 mempool_free(bv->bv_page, cc->page_pool);
                 bv->bv_page = NULL;
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index d053098c6a91..699b5be68d31 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -458,7 +458,7 @@ static void map_region(struct dm_io_region *io, struct mirror *m,
 {
         io->bdev = m->dev->bdev;
         io->sector = map_sector(m, bio);
-        io->count = bio->bi_size >> 9;
+        io->count = bio_sectors(bio);
 }
 
 static void hold_bio(struct mirror_set *ms, struct bio *bio)
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index d8837d313f54..ea5e878a30b9 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -258,7 +258,7 @@ static int stripe_map_range(struct stripe_c *sc, struct bio *bio,
         sector_t begin, end;
 
         stripe_map_range_sector(sc, bio->bi_sector, target_stripe, &begin);
-        stripe_map_range_sector(sc, bio->bi_sector + bio_sectors(bio),
+        stripe_map_range_sector(sc, bio_end_sector(bio),
                                 target_stripe, &end);
         if (begin < end) {
                 bio->bi_bdev = sc->stripe[target_stripe].dev->bdev;
diff --git a/drivers/md/dm-verity.c b/drivers/md/dm-verity.c
index a746f1d21c66..b948fd864d45 100644
--- a/drivers/md/dm-verity.c
+++ b/drivers/md/dm-verity.c
@@ -501,7 +501,7 @@ static int verity_map(struct dm_target *ti, struct bio *bio)
                 return -EIO;
         }
 
-        if ((bio->bi_sector + bio_sectors(bio)) >>
+        if (bio_end_sector(bio) >>
             (v->data_dev_block_bits - SECTOR_SHIFT) > v->data_blocks) {
                 DMERR_LIMIT("io out of range");
                 return -EIO;
@@ -519,7 +519,7 @@ static int verity_map(struct dm_target *ti, struct bio *bio)
 
         bio->bi_end_io = verity_end_io;
         bio->bi_private = io;
-        io->io_vec_size = bio->bi_vcnt - bio->bi_idx;
+        io->io_vec_size = bio_segments(bio);
         if (io->io_vec_size < DM_VERITY_IO_VEC_INLINE)
                 io->io_vec = io->io_vec_inline;
         else
diff --git a/drivers/md/faulty.c b/drivers/md/faulty.c
index 5e7dc772f5de..3193aefe982b 100644
--- a/drivers/md/faulty.c
+++ b/drivers/md/faulty.c
@@ -185,8 +185,7 @@ static void make_request(struct mddev *mddev, struct bio *bio)
                         return;
                 }
 
-                if (check_sector(conf, bio->bi_sector, bio->bi_sector+(bio->bi_size>>9),
-                                 WRITE))
+                if (check_sector(conf, bio->bi_sector, bio_end_sector(bio), WRITE))
                         failit = 1;
                 if (check_mode(conf, WritePersistent)) {
                         add_sector(conf, bio->bi_sector, WritePersistent);
@@ -196,8 +195,7 @@ static void make_request(struct mddev *mddev, struct bio *bio)
                         failit = 1;
         } else {
                 /* read request */
-                if (check_sector(conf, bio->bi_sector, bio->bi_sector + (bio->bi_size>>9),
-                                 READ))
+                if (check_sector(conf, bio->bi_sector, bio_end_sector(bio), READ))
                         failit = 1;
                 if (check_mode(conf, ReadTransient))
                         failit = 1;
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 21014836bdbf..f03fabd2b37b 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -317,8 +317,7 @@ static void linear_make_request(struct mddev *mddev, struct bio *bio)
                 bio_io_error(bio);
                 return;
         }
-        if (unlikely(bio->bi_sector + (bio->bi_size >> 9) >
-                     tmp_dev->end_sector)) {
+        if (unlikely(bio_end_sector(bio) > tmp_dev->end_sector)) {
                 /* This bio crosses a device boundary, so we have to
                  * split it.
                  */
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 6330c727396c..681d1099a2d5 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -197,21 +197,12 @@ void md_trim_bio(struct bio *bio, int offset, int size)
         if (offset == 0 && size == bio->bi_size)
                 return;
 
-        bio->bi_sector += offset;
-        bio->bi_size = size;
-        offset <<= 9;
         clear_bit(BIO_SEG_VALID, &bio->bi_flags);
 
-        while (bio->bi_idx < bio->bi_vcnt &&
-               bio->bi_io_vec[bio->bi_idx].bv_len <= offset) {
-                /* remove this whole bio_vec */
-                offset -= bio->bi_io_vec[bio->bi_idx].bv_len;
-                bio->bi_idx++;
-        }
-        if (bio->bi_idx < bio->bi_vcnt) {
-                bio->bi_io_vec[bio->bi_idx].bv_offset += offset;
-                bio->bi_io_vec[bio->bi_idx].bv_len -= offset;
-        }
+        bio_advance(bio, offset << 9);
+
+        bio->bi_size = size;
+
         /* avoid any complications with bi_idx being non-zero*/
         if (bio->bi_idx) {
                 memmove(bio->bi_io_vec, bio->bi_io_vec+bio->bi_idx,
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 0505452de8d6..fcf65e512cf5 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -502,11 +502,11 @@ static inline int is_io_in_chunk_boundary(struct mddev *mddev,
 {
         if (likely(is_power_of_2(chunk_sects))) {
                 return chunk_sects >= ((bio->bi_sector & (chunk_sects-1))
-                                        + (bio->bi_size >> 9));
+                                        + bio_sectors(bio));
         } else{
                 sector_t sector = bio->bi_sector;
                 return chunk_sects >= (sector_div(sector, chunk_sects)
-                                                + (bio->bi_size >> 9));
+                                                + bio_sectors(bio));
         }
 }
 
@@ -527,8 +527,7 @@ static void raid0_make_request(struct mddev *mddev, struct bio *bio)
                 sector_t sector = bio->bi_sector;
                 struct bio_pair *bp;
                 /* Sanity check -- queue functions should prevent this happening */
-                if ((bio->bi_vcnt != 1 && bio->bi_vcnt != 0) ||
-                    bio->bi_idx != 0)
+                if (bio_segments(bio) > 1)
                         goto bad_map;
                 /* This is a one page bio that upper layers
                  * refuse to split for us, so we need to split it.
@@ -567,7 +566,7 @@ bad_map:
         printk("md/raid0:%s: make_request bug: can't convert block across chunks"
                " or bigger than %dk %llu %d\n",
                mdname(mddev), chunk_sects / 2,
-               (unsigned long long)bio->bi_sector, bio->bi_size >> 10);
+               (unsigned long long)bio->bi_sector, bio_sectors(bio) / 2);
 
         bio_io_error(bio);
         return;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 851023e2ba5d..55951182af73 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -92,7 +92,6 @@ static void r1bio_pool_free(void *r1_bio, void *data)
 static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
 {
         struct pool_info *pi = data;
-        struct page *page;
         struct r1bio *r1_bio;
         struct bio *bio;
         int i, j;
@@ -122,14 +121,10 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
                 j = 1;
         while(j--) {
                 bio = r1_bio->bios[j];
-                for (i = 0; i < RESYNC_PAGES; i++) {
-                        page = alloc_page(gfp_flags);
-                        if (unlikely(!page))
-                                goto out_free_pages;
+                bio->bi_vcnt = RESYNC_PAGES;
 
-                        bio->bi_io_vec[i].bv_page = page;
-                        bio->bi_vcnt = i+1;
-                }
+                if (bio_alloc_pages(bio, gfp_flags))
+                        goto out_free_bio;
         }
         /* If not user-requests, copy the page pointers to all bios */
         if (!test_bit(MD_RECOVERY_REQUESTED, &pi->mddev->recovery)) {
@@ -143,11 +138,6 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
 
         return r1_bio;
 
-out_free_pages:
-        for (j=0 ; j < pi->raid_disks; j++)
-                for (i=0; i < r1_bio->bios[j]->bi_vcnt ; i++)
-                        put_page(r1_bio->bios[j]->bi_io_vec[i].bv_page);
-        j = -1;
 out_free_bio:
         while (++j < pi->raid_disks)
                 bio_put(r1_bio->bios[j]);
@@ -267,7 +257,7 @@ static void raid_end_bio_io(struct r1bio *r1_bio)
                          (bio_data_dir(bio) == WRITE) ? "write" : "read",
                          (unsigned long long) bio->bi_sector,
                          (unsigned long long) bio->bi_sector +
-                         (bio->bi_size >> 9) - 1);
+                         bio_sectors(bio) - 1);
 
                 call_bio_endio(r1_bio);
         }
@@ -458,7 +448,7 @@ static void raid1_end_write_request(struct bio *bio, int error)
                                          " %llu-%llu\n",
                                          (unsigned long long) mbio->bi_sector,
                                          (unsigned long long) mbio->bi_sector +
-                                         (mbio->bi_size >> 9) - 1);
+                                         bio_sectors(mbio) - 1);
                                 call_bio_endio(r1_bio);
                         }
                 }
@@ -925,7 +915,7 @@ static void alloc_behind_pages(struct bio *bio, struct r1bio *r1_bio)
         if (unlikely(!bvecs))
                 return;
 
-        bio_for_each_segment(bvec, bio, i) {
+        bio_for_each_segment_all(bvec, bio, i) {
                 bvecs[i] = *bvec;
                 bvecs[i].bv_page = alloc_page(GFP_NOIO);
                 if (unlikely(!bvecs[i].bv_page))
@@ -1023,7 +1013,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         md_write_start(mddev, bio); /* wait on superblock update early */
 
         if (bio_data_dir(bio) == WRITE &&
-            bio->bi_sector + bio->bi_size/512 > mddev->suspend_lo &&
+            bio_end_sector(bio) > mddev->suspend_lo &&
             bio->bi_sector < mddev->suspend_hi) {
                 /* As the suspend_* range is controlled by
                  * userspace, we want an interruptible
@@ -1034,7 +1024,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
                         flush_signals(current);
                         prepare_to_wait(&conf->wait_barrier,
                                         &w, TASK_INTERRUPTIBLE);
-                        if (bio->bi_sector + bio->bi_size/512 <= mddev->suspend_lo ||
+                        if (bio_end_sector(bio) <= mddev->suspend_lo ||
                             bio->bi_sector >= mddev->suspend_hi)
                                 break;
                         schedule();
@@ -1054,7 +1044,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
 
         r1_bio->master_bio = bio;
-        r1_bio->sectors = bio->bi_size >> 9;
+        r1_bio->sectors = bio_sectors(bio);
         r1_bio->state = 0;
         r1_bio->mddev = mddev;
         r1_bio->sector = bio->bi_sector;
@@ -1132,7 +1122,7 @@ read_again:
                         r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
 
                         r1_bio->master_bio = bio;
-                        r1_bio->sectors = (bio->bi_size >> 9) - sectors_handled;
+                        r1_bio->sectors = bio_sectors(bio) - sectors_handled;
                         r1_bio->state = 0;
                         r1_bio->mddev = mddev;
                         r1_bio->sector = bio->bi_sector + sectors_handled;
@@ -1289,14 +1279,10 @@ read_again:
                         struct bio_vec *bvec;
                         int j;
 
-                        /* Yes, I really want the '__' version so that
-                         * we clear any unused pointer in the io_vec, rather
-                         * than leave them unchanged.  This is important
-                         * because when we come to free the pages, we won't
-                         * know the original bi_idx, so we just free
-                         * them all
+                        /*
+                         * We trimmed the bio, so _all is legit
                          */
-                        __bio_for_each_segment(bvec, mbio, j, 0)
+                        bio_for_each_segment_all(bvec, mbio, j)
                                 bvec->bv_page = r1_bio->behind_bvecs[j].bv_page;
                         if (test_bit(WriteMostly, &conf->mirrors[i].rdev->flags))
                                 atomic_inc(&r1_bio->behind_remaining);
@@ -1334,14 +1320,14 @@ read_again:
         /* Mustn't call r1_bio_write_done before this next test,
          * as it could result in the bio being freed.
          */
-        if (sectors_handled < (bio->bi_size >> 9)) {
+        if (sectors_handled < bio_sectors(bio)) {
                 r1_bio_write_done(r1_bio);
                 /* We need another r1_bio.  It has already been counted
                  * in bio->bi_phys_segments
                  */
                 r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
                 r1_bio->master_bio = bio;
-                r1_bio->sectors = (bio->bi_size >> 9) - sectors_handled;
+                r1_bio->sectors = bio_sectors(bio) - sectors_handled;
                 r1_bio->state = 0;
                 r1_bio->mddev = mddev;
                 r1_bio->sector = bio->bi_sector + sectors_handled;
@@ -1867,7 +1853,7 @@ static int process_checks(struct r1bio *r1_bio)
                 struct bio *sbio = r1_bio->bios[i];
                 int size;
 
-                if (r1_bio->bios[i]->bi_end_io != end_sync_read)
+                if (sbio->bi_end_io != end_sync_read)
                         continue;
 
                 if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
@@ -1892,16 +1878,15 @@ static int process_checks(struct r1bio *r1_bio)
                         continue;
                 }
                 /* fixup the bio for reuse */
+                bio_reset(sbio);
                 sbio->bi_vcnt = vcnt;
                 sbio->bi_size = r1_bio->sectors << 9;
-                sbio->bi_idx = 0;
-                sbio->bi_phys_segments = 0;
-                sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                sbio->bi_flags |= 1 << BIO_UPTODATE;
-                sbio->bi_next = NULL;
                 sbio->bi_sector = r1_bio->sector +
                         conf->mirrors[i].rdev->data_offset;
                 sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
+                sbio->bi_end_io = end_sync_read;
+                sbio->bi_private = r1_bio;
+
                 size = sbio->bi_size;
                 for (j = 0; j < vcnt ; j++) {
                         struct bio_vec *bi;
@@ -1912,10 +1897,9 @@ static int process_checks(struct r1bio *r1_bio)
                         else
                                 bi->bv_len = size;
                         size -= PAGE_SIZE;
-                        memcpy(page_address(bi->bv_page),
-                               page_address(pbio->bi_io_vec[j].bv_page),
-                               PAGE_SIZE);
                 }
+
+                bio_copy_data(sbio, pbio);
         }
         return 0;
 }
@@ -1952,7 +1936,7 @@ static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio)
                 wbio->bi_rw = WRITE;
                 wbio->bi_end_io = end_sync_write;
                 atomic_inc(&r1_bio->remaining);
-                md_sync_acct(conf->mirrors[i].rdev->bdev, wbio->bi_size >> 9);
+                md_sync_acct(conf->mirrors[i].rdev->bdev, bio_sectors(wbio));
 
                 generic_make_request(wbio);
         }
@@ -2064,32 +2048,11 @@ static void fix_read_error(struct r1conf *conf, int read_disk,
         }
 }
 
-static void bi_complete(struct bio *bio, int error)
-{
-        complete((struct completion *)bio->bi_private);
-}
-
-static int submit_bio_wait(int rw, struct bio *bio)
-{
-        struct completion event;
-        rw |= REQ_SYNC;
-
-        init_completion(&event);
-        bio->bi_private = &event;
-        bio->bi_end_io = bi_complete;
-        submit_bio(rw, bio);
-        wait_for_completion(&event);
-
-        return test_bit(BIO_UPTODATE, &bio->bi_flags);
-}
-
 static int narrow_write_error(struct r1bio *r1_bio, int i)
 {
         struct mddev *mddev = r1_bio->mddev;
         struct r1conf *conf = mddev->private;
         struct md_rdev *rdev = conf->mirrors[i].rdev;
-        int vcnt, idx;
-        struct bio_vec *vec;
 
         /* bio has the data to be written to device 'i' where
          * we just recently had a write error.
@@ -2117,30 +2080,32 @@ static int narrow_write_error(struct r1bio *r1_bio, int i)
                    & ~(sector_t)(block_sectors - 1))
                 - sector;
 
-        if (test_bit(R1BIO_BehindIO, &r1_bio->state)) {
-                vcnt = r1_bio->behind_page_count;
-                vec = r1_bio->behind_bvecs;
-                idx = 0;
-                while (vec[idx].bv_page == NULL)
-                        idx++;
-        } else {
-                vcnt = r1_bio->master_bio->bi_vcnt;
-                vec = r1_bio->master_bio->bi_io_vec;
-                idx = r1_bio->master_bio->bi_idx;
-        }
         while (sect_to_write) {
                 struct bio *wbio;
                 if (sectors > sect_to_write)
                         sectors = sect_to_write;
                 /* Write at 'sector' for 'sectors'*/
 
-                wbio = bio_alloc_mddev(GFP_NOIO, vcnt, mddev);
-                memcpy(wbio->bi_io_vec, vec, vcnt * sizeof(struct bio_vec));
-                wbio->bi_sector = r1_bio->sector;
+                if (test_bit(R1BIO_BehindIO, &r1_bio->state)) {
+                        unsigned vcnt = r1_bio->behind_page_count;
+                        struct bio_vec *vec = r1_bio->behind_bvecs;
+
+                        while (!vec->bv_page) {
+                                vec++;
+                                vcnt--;
+                        }
+
+                        wbio = bio_alloc_mddev(GFP_NOIO, vcnt, mddev);
+                        memcpy(wbio->bi_io_vec, vec, vcnt * sizeof(struct bio_vec));
+
+                        wbio->bi_vcnt = vcnt;
+                } else {
+                        wbio = bio_clone_mddev(r1_bio->master_bio, GFP_NOIO, mddev);
+                }
+
                 wbio->bi_rw = WRITE;
-                wbio->bi_vcnt = vcnt;
+                wbio->bi_sector = r1_bio->sector;
                 wbio->bi_size = r1_bio->sectors << 9;
-                wbio->bi_idx = idx;
 
                 md_trim_bio(wbio, sector - r1_bio->sector, sectors);
                 wbio->bi_sector += rdev->data_offset;
@@ -2289,8 +2254,7 @@ read_more:
                         r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO);
 
                         r1_bio->master_bio = mbio;
-                        r1_bio->sectors = (mbio->bi_size >> 9)
-                                          - sectors_handled;
+                        r1_bio->sectors = bio_sectors(mbio) - sectors_handled;
                         r1_bio->state = 0;
                         set_bit(R1BIO_ReadError, &r1_bio->state);
                         r1_bio->mddev = mddev;
@@ -2464,18 +2428,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
         for (i = 0; i < conf->raid_disks * 2; i++) {
                 struct md_rdev *rdev;
                 bio = r1_bio->bios[i];
-
-                /* take from bio_init */
-                bio->bi_next = NULL;
-                bio->bi_flags &= ~(BIO_POOL_MASK-1);
-                bio->bi_flags |= 1 << BIO_UPTODATE;
-                bio->bi_rw = READ;
-                bio->bi_vcnt = 0;
-                bio->bi_idx = 0;
-                bio->bi_phys_segments = 0;
-                bio->bi_size = 0;
-                bio->bi_end_io = NULL;
-                bio->bi_private = NULL;
+                bio_reset(bio);
 
                 rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev == NULL ||
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 018741ba9310..59d4daa5f4c7 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1174,14 +1174,13 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         /* If this request crosses a chunk boundary, we need to
          * split it.  This will only happen for 1 PAGE (or less) requests.
          */
-        if (unlikely((bio->bi_sector & chunk_mask) + (bio->bi_size >> 9)
+        if (unlikely((bio->bi_sector & chunk_mask) + bio_sectors(bio)
                      > chunk_sects
                      && (conf->geo.near_copies < conf->geo.raid_disks
                          || conf->prev.near_copies < conf->prev.raid_disks))) {
                 struct bio_pair *bp;
                 /* Sanity check -- queue functions should prevent this happening */
-                if ((bio->bi_vcnt != 1 && bio->bi_vcnt != 0) ||
-                    bio->bi_idx != 0)
+                if (bio_segments(bio) > 1)
                         goto bad_map;
                 /* This is a one page bio that upper layers
                  * refuse to split for us, so we need to split it.
@@ -1214,7 +1213,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         bad_map:
                 printk("md/raid10:%s: make_request bug: can't convert block across chunks"
                        " or bigger than %dk %llu %d\n", mdname(mddev), chunk_sects/2,
-                       (unsigned long long)bio->bi_sector, bio->bi_size >> 10);
+                       (unsigned long long)bio->bi_sector, bio_sectors(bio) / 2);
 
                 bio_io_error(bio);
                 return;
@@ -1229,7 +1228,7 @@ static void make_request(struct mddev *mddev, struct bio * bio)
          */
         wait_barrier(conf);
 
-        sectors = bio->bi_size >> 9;
+        sectors = bio_sectors(bio);
         while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
             bio->bi_sector < conf->reshape_progress &&
             bio->bi_sector + sectors > conf->reshape_progress) {
@@ -1331,8 +1330,7 @@ read_again:
                         r10_bio = mempool_alloc(conf->r10bio_pool, GFP_NOIO);
 
                         r10_bio->master_bio = bio;
-                        r10_bio->sectors = ((bio->bi_size >> 9)
-                                            - sectors_handled);
+                        r10_bio->sectors = bio_sectors(bio) - sectors_handled;
                         r10_bio->state = 0;
                         r10_bio->mddev = mddev;
                         r10_bio->sector = bio->bi_sector + sectors_handled;
@@ -1574,7 +1572,7 @@ retry_write:
          * after checking if we need to go around again.
          */
 
-        if (sectors_handled < (bio->bi_size >> 9)) {
+        if (sectors_handled < bio_sectors(bio)) {
                 one_write_done(r10_bio);
                 /* We need another r10_bio.  It has already been counted
                  * in bio->bi_phys_segments.
@@ -1582,7 +1580,7 @@ retry_write:
                 r10_bio = mempool_alloc(conf->r10bio_pool, GFP_NOIO);
 
                 r10_bio->master_bio = bio;
-                r10_bio->sectors = (bio->bi_size >> 9) - sectors_handled;
+                r10_bio->sectors = bio_sectors(bio) - sectors_handled;
 
                 r10_bio->mddev = mddev;
                 r10_bio->sector = bio->bi_sector + sectors_handled;
@@ -2084,13 +2082,10 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
                  * First we need to fixup bv_offset, bv_len and
                  * bi_vecs, as the read request might have corrupted these
                  */
+                bio_reset(tbio);
+
                 tbio->bi_vcnt = vcnt;
                 tbio->bi_size = r10_bio->sectors << 9;
-                tbio->bi_idx = 0;
-                tbio->bi_phys_segments = 0;
-                tbio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                tbio->bi_flags |= 1 << BIO_UPTODATE;
-                tbio->bi_next = NULL;
                 tbio->bi_rw = WRITE;
                 tbio->bi_private = r10_bio;
                 tbio->bi_sector = r10_bio->devs[i].addr;
@@ -2108,7 +2103,7 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
                 d = r10_bio->devs[i].devnum;
                 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
                 atomic_inc(&r10_bio->remaining);
-                md_sync_acct(conf->mirrors[d].rdev->bdev, tbio->bi_size >> 9);
+                md_sync_acct(conf->mirrors[d].rdev->bdev, bio_sectors(tbio));
 
                 tbio->bi_sector += conf->mirrors[d].rdev->data_offset;
                 tbio->bi_bdev = conf->mirrors[d].rdev->bdev;
@@ -2133,7 +2128,7 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
                 d = r10_bio->devs[i].devnum;
                 atomic_inc(&r10_bio->remaining);
                 md_sync_acct(conf->mirrors[d].replacement->bdev,
-                             tbio->bi_size >> 9);
+                             bio_sectors(tbio));
                 generic_make_request(tbio);
         }
 
@@ -2259,13 +2254,13 @@ static void recovery_request_write(struct mddev *mddev, struct r10bio *r10_bio)
         wbio2 = r10_bio->devs[1].repl_bio;
         if (wbio->bi_end_io) {
                 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
-                md_sync_acct(conf->mirrors[d].rdev->bdev, wbio->bi_size >> 9);
+                md_sync_acct(conf->mirrors[d].rdev->bdev, bio_sectors(wbio));
                 generic_make_request(wbio);
         }
         if (wbio2 && wbio2->bi_end_io) {
                 atomic_inc(&conf->mirrors[d].replacement->nr_pending);
                 md_sync_acct(conf->mirrors[d].replacement->bdev,
-                             wbio2->bi_size >> 9);
+                             bio_sectors(wbio2));
                 generic_make_request(wbio2);
         }
 }
@@ -2536,25 +2531,6 @@ static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10
         }
 }
 
-static void bi_complete(struct bio *bio, int error)
-{
-        complete((struct completion *)bio->bi_private);
-}
-
-static int submit_bio_wait(int rw, struct bio *bio)
-{
-        struct completion event;
-        rw |= REQ_SYNC;
-
-        init_completion(&event);
-        bio->bi_private = &event;
-        bio->bi_end_io = bi_complete;
-        submit_bio(rw, bio);
-        wait_for_completion(&event);
-
-        return test_bit(BIO_UPTODATE, &bio->bi_flags);
-}
-
 static int narrow_write_error(struct r10bio *r10_bio, int i)
 {
         struct bio *bio = r10_bio->master_bio;
@@ -2695,8 +2671,7 @@ read_more:
                 r10_bio = mempool_alloc(conf->r10bio_pool,
                                         GFP_NOIO);
                 r10_bio->master_bio = mbio;
-                r10_bio->sectors = (mbio->bi_size >> 9)
-                        - sectors_handled;
+                r10_bio->sectors = bio_sectors(mbio) - sectors_handled;
                 r10_bio->state = 0;
                 set_bit(R10BIO_ReadError,
                         &r10_bio->state);
@@ -3133,6 +3108,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                                         }
                                 }
                                 bio = r10_bio->devs[0].bio;
+                                bio_reset(bio);
                                 bio->bi_next = biolist;
                                 biolist = bio;
                                 bio->bi_private = r10_bio;
@@ -3157,6 +3133,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                                 rdev = mirror->rdev;
                                 if (!test_bit(In_sync, &rdev->flags)) {
                                         bio = r10_bio->devs[1].bio;
+                                        bio_reset(bio);
                                         bio->bi_next = biolist;
                                         biolist = bio;
                                         bio->bi_private = r10_bio;
@@ -3185,6 +3162,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                                 if (rdev == NULL || bio == NULL ||
                                     test_bit(Faulty, &rdev->flags))
                                         break;
+                                bio_reset(bio);
                                 bio->bi_next = biolist;
                                 biolist = bio;
                                 bio->bi_private = r10_bio;
@@ -3283,7 +3261,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                                 r10_bio->devs[i].repl_bio->bi_end_io = NULL;
 
                         bio = r10_bio->devs[i].bio;
-                        bio->bi_end_io = NULL;
+                        bio_reset(bio);
                         clear_bit(BIO_UPTODATE, &bio->bi_flags);
                         if (conf->mirrors[d].rdev == NULL ||
                             test_bit(Faulty, &conf->mirrors[d].rdev->flags))
@@ -3320,6 +3298,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
 
                         /* Need to set up for writing to the replacement */
                         bio = r10_bio->devs[i].repl_bio;
+                        bio_reset(bio);
                         clear_bit(BIO_UPTODATE, &bio->bi_flags);
 
                         sector = r10_bio->devs[i].addr;
@@ -3353,17 +3332,6 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                 }
         }
 
-        for (bio = biolist; bio ; bio=bio->bi_next) {
-
-                bio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                if (bio->bi_end_io)
-                        bio->bi_flags |= 1 << BIO_UPTODATE;
-                bio->bi_vcnt = 0;
-                bio->bi_idx = 0;
-                bio->bi_phys_segments = 0;
-                bio->bi_size = 0;
-        }
-
         nr_sectors = 0;
         if (sector_nr + max_sync < max_sector)
                 max_sector = sector_nr + max_sync;
@@ -4411,7 +4379,6 @@ read_more:
         read_bio->bi_flags &= ~(BIO_POOL_MASK - 1);
         read_bio->bi_flags |= 1 << BIO_UPTODATE;
         read_bio->bi_vcnt = 0;
-        read_bio->bi_idx = 0;
         read_bio->bi_size = 0;
         r10_bio->master_bio = read_bio;
         r10_bio->read_slot = r10_bio->devs[r10_bio->read_slot].devnum;
@@ -4435,17 +4402,14 @@ read_more:
                 }
                 if (!rdev2 || test_bit(Faulty, &rdev2->flags))
                         continue;
+
+                bio_reset(b);
                 b->bi_bdev = rdev2->bdev;
                 b->bi_sector = r10_bio->devs[s/2].addr + rdev2->new_data_offset;
                 b->bi_private = r10_bio;
                 b->bi_end_io = end_reshape_write;
                 b->bi_rw = WRITE;
-                b->bi_flags &= ~(BIO_POOL_MASK - 1);
-                b->bi_flags |= 1 << BIO_UPTODATE;
                 b->bi_next = blist;
-                b->bi_vcnt = 0;
-                b->bi_idx = 0;
-                b->bi_size = 0;
                 blist = b;
         }
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 4a7be455d6d8..9359828ffe26 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -90,7 +90,7 @@ static inline struct hlist_head *stripe_hash(struct r5conf *conf, sector_t sect)
  */
 static inline struct bio *r5_next_bio(struct bio *bio, sector_t sector)
 {
-        int sectors = bio->bi_size >> 9;
+        int sectors = bio_sectors(bio);
         if (bio->bi_sector + sectors < sector + STRIPE_SECTORS)
                 return bio->bi_next;
         else
@@ -569,14 +569,6 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
                 bi = &sh->dev[i].req;
                 rbi = &sh->dev[i].rreq; /* For writing to replacement */
 
-                bi->bi_rw = rw;
-                rbi->bi_rw = rw;
-                if (rw & WRITE) {
-                        bi->bi_end_io = raid5_end_write_request;
-                        rbi->bi_end_io = raid5_end_write_request;
-                } else
-                        bi->bi_end_io = raid5_end_read_request;
-
                 rcu_read_lock();
                 rrdev = rcu_dereference(conf->disks[i].replacement);
                 smp_mb(); /* Ensure that if rrdev is NULL, rdev won't be */
@@ -651,7 +643,14 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
 
                         set_bit(STRIPE_IO_STARTED, &sh->state);
 
+                        bio_reset(bi);
                         bi->bi_bdev = rdev->bdev;
+                        bi->bi_rw = rw;
+                        bi->bi_end_io = (rw & WRITE)
+                                ? raid5_end_write_request
+                                : raid5_end_read_request;
+                        bi->bi_private = sh;
+
                         pr_debug("%s: for %llu schedule op %ld on disc %d\n",
                                 __func__, (unsigned long long)sh->sector,
                                 bi->bi_rw, i);
@@ -665,12 +664,9 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
                         if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags))
                                 bi->bi_rw |= REQ_FLUSH;
 
-                        bi->bi_flags = 1 << BIO_UPTODATE;
-                        bi->bi_idx = 0;
                         bi->bi_io_vec[0].bv_len = STRIPE_SIZE;
                         bi->bi_io_vec[0].bv_offset = 0;
                         bi->bi_size = STRIPE_SIZE;
-                        bi->bi_next = NULL;
                         if (rrdev)
                                 set_bit(R5_DOUBLE_LOCKED, &sh->dev[i].flags);
 
@@ -687,7 +683,13 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
 
                         set_bit(STRIPE_IO_STARTED, &sh->state);
 
+                        bio_reset(rbi);
                         rbi->bi_bdev = rrdev->bdev;
+                        rbi->bi_rw = rw;
+                        BUG_ON(!(rw & WRITE));
+                        rbi->bi_end_io = raid5_end_write_request;
+                        rbi->bi_private = sh;
+
                         pr_debug("%s: for %llu schedule op %ld on "
                                  "replacement disc %d\n",
                                 __func__, (unsigned long long)sh->sector,
@@ -699,12 +701,9 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
                         else
                                 rbi->bi_sector = (sh->sector
                                                   + rrdev->data_offset);
-                        rbi->bi_flags = 1 << BIO_UPTODATE;
-                        rbi->bi_idx = 0;
                         rbi->bi_io_vec[0].bv_len = STRIPE_SIZE;
                         rbi->bi_io_vec[0].bv_offset = 0;
                         rbi->bi_size = STRIPE_SIZE;
-                        rbi->bi_next = NULL;
                         if (conf->mddev->gendisk)
                                 trace_block_bio_remap(bdev_get_queue(rbi->bi_bdev),
                                                       rbi, disk_devt(conf->mddev->gendisk),
@@ -2402,11 +2401,11 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
         } else
                 bip = &sh->dev[dd_idx].toread;
         while (*bip && (*bip)->bi_sector < bi->bi_sector) {
-                if ((*bip)->bi_sector + ((*bip)->bi_size >> 9) > bi->bi_sector)
+                if (bio_end_sector(*bip) > bi->bi_sector)
                         goto overlap;
                 bip = & (*bip)->bi_next;
         }
-        if (*bip && (*bip)->bi_sector < bi->bi_sector + ((bi->bi_size)>>9))
+        if (*bip && (*bip)->bi_sector < bio_end_sector(bi))
                 goto overlap;
 
         BUG_ON(*bip && bi->bi_next && (*bip) != bi->bi_next);
@@ -2422,8 +2421,8 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
                      sector < sh->dev[dd_idx].sector + STRIPE_SECTORS &&
                              bi && bi->bi_sector <= sector;
                      bi = r5_next_bio(bi, sh->dev[dd_idx].sector)) {
-                        if (bi->bi_sector + (bi->bi_size>>9) >= sector)
-                                sector = bi->bi_sector + (bi->bi_size>>9);
+                        if (bio_end_sector(bi) >= sector)
+                                sector = bio_end_sector(bi);
                 }
                 if (sector >= sh->dev[dd_idx].sector + STRIPE_SECTORS)
                         set_bit(R5_OVERWRITE, &sh->dev[dd_idx].flags);
@@ -3849,7 +3848,7 @@ static int in_chunk_boundary(struct mddev *mddev, struct bio *bio)
 {
         sector_t sector = bio->bi_sector + get_start_sect(bio->bi_bdev);
         unsigned int chunk_sectors = mddev->chunk_sectors;
-        unsigned int bio_sectors = bio->bi_size >> 9;
+        unsigned int bio_sectors = bio_sectors(bio);
 
         if (mddev->new_chunk_sectors < mddev->chunk_sectors)
                 chunk_sectors = mddev->new_chunk_sectors;
@@ -3941,7 +3940,7 @@ static int bio_fits_rdev(struct bio *bi)
 {
         struct request_queue *q = bdev_get_queue(bi->bi_bdev);
 
-        if ((bi->bi_size>>9) > queue_max_sectors(q))
+        if (bio_sectors(bi) > queue_max_sectors(q))
                 return 0;
         blk_recount_segments(q, bi);
         if (bi->bi_phys_segments > queue_max_segments(q))
@@ -3988,7 +3987,7 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                                                     0,
                                                     &dd_idx, NULL);
 
-        end_sector = align_bi->bi_sector + (align_bi->bi_size >> 9);
+        end_sector = bio_end_sector(align_bi);
         rcu_read_lock();
         rdev = rcu_dereference(conf->disks[dd_idx].replacement);
         if (!rdev || test_bit(Faulty, &rdev->flags) ||
@@ -4011,7 +4010,7 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                 align_bi->bi_flags &= ~(1 << BIO_SEG_VALID);
 
                 if (!bio_fits_rdev(align_bi) ||
-                    is_badblock(rdev, align_bi->bi_sector, align_bi->bi_size>>9,
+                    is_badblock(rdev, align_bi->bi_sector, bio_sectors(align_bi),
                                 &first_bad, &bad_sectors)) {
                         /* too big in some way, or has a known bad block */
                         bio_put(align_bi);
@@ -4273,7 +4272,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
         }
 
         logical_sector = bi->bi_sector & ~((sector_t)STRIPE_SECTORS-1);
-        last_sector = bi->bi_sector + (bi->bi_size>>9);
+        last_sector = bio_end_sector(bi);
         bi->bi_next = NULL;
         bi->bi_phys_segments = 1;       /* over-loaded to count active stripes */
 
@@ -4739,7 +4738,7 @@ static int  retry_aligned_read(struct r5conf *conf, struct bio *raid_bio)
         logical_sector = raid_bio->bi_sector & ~((sector_t)STRIPE_SECTORS-1);
         sector = raid5_compute_sector(conf, logical_sector,
                                       0, &dd_idx, NULL);
-        last_sector = raid_bio->bi_sector + (raid_bio->bi_size>>9);
+        last_sector = bio_end_sector(raid_bio);
 
         for (; logical_sector < last_sector;
              logical_sector += STRIPE_SECTORS,