11 files changed, 138 insertions, 72 deletions

diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 90e19f13f26..dca401dc70a 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -426,7 +426,7 @@ static int list_devices(struct dm_ioctl *param, size_t param_size)
                                 old_nl->next = (uint32_t) ((void *) nl -
                                                            (void *) old_nl);
                         disk = dm_disk(hc->md);
-                        nl->dev = huge_encode_dev(MKDEV(disk->major, disk->first_minor));
+                        nl->dev = huge_encode_dev(disk_devt(disk));
                         nl->next = 0;
                         strcpy(nl->name, hc->name);
 
@@ -539,7 +539,7 @@ static int __dev_status(struct mapped_device *md, struct dm_ioctl *param)
         if (dm_suspended(md))
                 param->flags |= DM_SUSPEND_FLAG;
 
-        param->dev = huge_encode_dev(MKDEV(disk->major, disk->first_minor));
+        param->dev = huge_encode_dev(disk_devt(disk));
 
         /*
          * Yes, this will be out of date by the time it gets back
@@ -548,7 +548,7 @@ static int __dev_status(struct mapped_device *md, struct dm_ioctl *param)
          */
         param->open_count = dm_open_count(md);
 
-        if (disk->policy)
+        if (get_disk_ro(disk))
                 param->flags |= DM_READONLY_FLAG;
 
         param->event_nr = dm_get_event_nr(md);
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index b2ab8489d0e..103304c1e3b 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -34,6 +34,7 @@ struct pgpath {
         unsigned fail_count;            /* Cumulative failure count */
 
         struct dm_path path;
+        struct work_struct deactivate_path;
 };
 
 #define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path)
@@ -113,6 +114,7 @@ static struct workqueue_struct *kmultipathd, *kmpath_handlerd;
 static void process_queued_ios(struct work_struct *work);
 static void trigger_event(struct work_struct *work);
 static void activate_path(struct work_struct *work);
+static void deactivate_path(struct work_struct *work);
 
 
 /*-----------------------------------------------
@@ -123,8 +125,10 @@ static struct pgpath *alloc_pgpath(void)
 {
         struct pgpath *pgpath = kzalloc(sizeof(*pgpath), GFP_KERNEL);
 
-        if (pgpath)
+        if (pgpath) {
                 pgpath->is_active = 1;
+                INIT_WORK(&pgpath->deactivate_path, deactivate_path);
+        }
 
         return pgpath;
 }
@@ -134,6 +138,14 @@ static void free_pgpath(struct pgpath *pgpath)
         kfree(pgpath);
 }
 
+static void deactivate_path(struct work_struct *work)
+{
+        struct pgpath *pgpath =
+                container_of(work, struct pgpath, deactivate_path);
+
+        blk_abort_queue(pgpath->path.dev->bdev->bd_disk->queue);
+}
+
 static struct priority_group *alloc_priority_group(void)
 {
         struct priority_group *pg;
@@ -873,6 +885,7 @@ static int fail_path(struct pgpath *pgpath)
                       pgpath->path.dev->name, m->nr_valid_paths);
 
         queue_work(kmultipathd, &m->trigger_event);
+        queue_work(kmultipathd, &pgpath->deactivate_path);
 
 out:
         spin_unlock_irqrestore(&m->lock, flags);
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 4de90ab3968..b745d8ac625 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -284,8 +284,8 @@ static int stripe_end_io(struct dm_target *ti, struct bio *bio,
 
         memset(major_minor, 0, sizeof(major_minor));
         sprintf(major_minor, "%d:%d",
-                bio->bi_bdev->bd_disk->major,
-                bio->bi_bdev->bd_disk->first_minor);
+                MAJOR(disk_devt(bio->bi_bdev->bd_disk)),
+                MINOR(disk_devt(bio->bi_bdev->bd_disk)));
 
         /*
          * Test to see which stripe drive triggered the event
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index ace998ce59f..327de03a5bd 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -377,13 +377,14 @@ static void free_tio(struct mapped_device *md, struct dm_target_io *tio)
 static void start_io_acct(struct dm_io *io)
 {
         struct mapped_device *md = io->md;
+        int cpu;
 
         io->start_time = jiffies;
 
-        preempt_disable();
-        disk_round_stats(dm_disk(md));
-        preempt_enable();
-        dm_disk(md)->in_flight = atomic_inc_return(&md->pending);
+        cpu = part_stat_lock();
+        part_round_stats(cpu, &dm_disk(md)->part0);
+        part_stat_unlock();
+        dm_disk(md)->part0.in_flight = atomic_inc_return(&md->pending);
 }
 
 static int end_io_acct(struct dm_io *io)
@@ -391,15 +392,16 @@ static int end_io_acct(struct dm_io *io)
         struct mapped_device *md = io->md;
         struct bio *bio = io->bio;
         unsigned long duration = jiffies - io->start_time;
-        int pending;
+        int pending, cpu;
         int rw = bio_data_dir(bio);
 
-        preempt_disable();
-        disk_round_stats(dm_disk(md));
-        preempt_enable();
-        dm_disk(md)->in_flight = pending = atomic_dec_return(&md->pending);
+        cpu = part_stat_lock();
+        part_round_stats(cpu, &dm_disk(md)->part0);
+        part_stat_add(cpu, &dm_disk(md)->part0, ticks[rw], duration);
+        part_stat_unlock();
 
-        disk_stat_add(dm_disk(md), ticks[rw], duration);
+        dm_disk(md)->part0.in_flight = pending =
+                atomic_dec_return(&md->pending);
 
         return !pending;
 }
@@ -885,6 +887,7 @@ static int dm_request(struct request_queue *q, struct bio *bio)
         int r = -EIO;
         int rw = bio_data_dir(bio);
         struct mapped_device *md = q->queuedata;
+        int cpu;
 
         /*
          * There is no use in forwarding any barrier request since we can't
@@ -897,8 +900,10 @@ static int dm_request(struct request_queue *q, struct bio *bio)
 
         down_read(&md->io_lock);
 
-        disk_stat_inc(dm_disk(md), ios[rw]);
-        disk_stat_add(dm_disk(md), sectors[rw], bio_sectors(bio));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &dm_disk(md)->part0, ios[rw]);
+        part_stat_add(cpu, &dm_disk(md)->part0, sectors[rw], bio_sectors(bio));
+        part_stat_unlock();
 
         /*
          * If we're suspended we have to queue
@@ -1146,7 +1151,7 @@ static void unlock_fs(struct mapped_device *md);
 
 static void free_dev(struct mapped_device *md)
 {
-        int minor = md->disk->first_minor;
+        int minor = MINOR(disk_devt(md->disk));
 
         if (md->suspended_bdev) {
                 unlock_fs(md);
@@ -1182,7 +1187,7 @@ static void event_callback(void *context)
         list_splice_init(&md->uevent_list, &uevents);
         spin_unlock_irqrestore(&md->uevent_lock, flags);
 
-        dm_send_uevents(&uevents, &md->disk->dev.kobj);
+        dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
 
         atomic_inc(&md->event_nr);
         wake_up(&md->eventq);
@@ -1267,7 +1272,7 @@ static struct mapped_device *dm_find_md(dev_t dev)
 
         md = idr_find(&_minor_idr, minor);
         if (md && (md == MINOR_ALLOCED ||
-                   (dm_disk(md)->first_minor != minor) ||
+                   (MINOR(disk_devt(dm_disk(md))) != minor) ||
                    test_bit(DMF_FREEING, &md->flags))) {
                 md = NULL;
                 goto out;
@@ -1318,7 +1323,8 @@ void dm_put(struct mapped_device *md)
 
         if (atomic_dec_and_lock(&md->holders, &_minor_lock)) {
                 map = dm_get_table(md);
-                idr_replace(&_minor_idr, MINOR_ALLOCED, dm_disk(md)->first_minor);
+                idr_replace(&_minor_idr, MINOR_ALLOCED,
+                            MINOR(disk_devt(dm_disk(md))));
                 set_bit(DMF_FREEING, &md->flags);
                 spin_unlock(&_minor_lock);
                 if (!dm_suspended(md)) {
@@ -1638,7 +1644,7 @@ out:
  *---------------------------------------------------------------*/
 void dm_kobject_uevent(struct mapped_device *md)
 {
-        kobject_uevent(&md->disk->dev.kobj, KOBJ_CHANGE);
+        kobject_uevent(&disk_to_dev(md->disk)->kobj, KOBJ_CHANGE);
 }
 
 uint32_t dm_next_uevent_seq(struct mapped_device *md)
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index b1eebf88c20..b9cbee688fa 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -318,14 +318,18 @@ static int linear_make_request (struct request_queue *q, struct bio *bio)
         mddev_t *mddev = q->queuedata;
         dev_info_t *tmp_dev;
         sector_t block;
+        int cpu;
 
         if (unlikely(bio_barrier(bio))) {
                 bio_endio(bio, -EOPNOTSUPP);
                 return 0;
         }
 
-        disk_stat_inc(mddev->gendisk, ios[rw]);
-        disk_stat_add(mddev->gendisk, sectors[rw], bio_sectors(bio));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
+        part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
+                      bio_sectors(bio));
+        part_stat_unlock();
 
         tmp_dev = which_dev(mddev, bio->bi_sector);
         block = bio->bi_sector >> 1;
@@ -349,7 +353,7 @@ static int linear_make_request (struct request_queue *q, struct bio *bio)
                  * split it.
                  */
                 struct bio_pair *bp;
-                bp = bio_split(bio, bio_split_pool,
+                bp = bio_split(bio,
                                ((tmp_dev->offset + tmp_dev->size)<<1) - bio->bi_sector);
                 if (linear_make_request(q, &bp->bio1))
                         generic_make_request(&bp->bio1);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index deeac4b4417..0a3a4bdcd4a 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1464,10 +1464,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
         if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
                 goto fail;
 
-        if (rdev->bdev->bd_part)
-                ko = &rdev->bdev->bd_part->dev.kobj;
-        else
-                ko = &rdev->bdev->bd_disk->dev.kobj;
+        ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
         if ((err = sysfs_create_link(&rdev->kobj, ko, "block"))) {
                 kobject_del(&rdev->kobj);
                 goto fail;
@@ -3470,8 +3467,8 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         disk->queue = mddev->queue;
         add_disk(disk);
         mddev->gendisk = disk;
-        error = kobject_init_and_add(&mddev->kobj, &md_ktype, &disk->dev.kobj,
-                                     "%s", "md");
+        error = kobject_init_and_add(&mddev->kobj, &md_ktype,
+                                     &disk_to_dev(disk)->kobj, "%s", "md");
         mutex_unlock(&disks_mutex);
         if (error)
                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
@@ -3761,7 +3758,7 @@ static int do_md_run(mddev_t * mddev)
         sysfs_notify(&mddev->kobj, NULL, "array_state");
         sysfs_notify(&mddev->kobj, NULL, "sync_action");
         sysfs_notify(&mddev->kobj, NULL, "degraded");
-        kobject_uevent(&mddev->gendisk->dev.kobj, KOBJ_CHANGE);
+        kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
         return 0;
 }
 
@@ -5549,8 +5546,8 @@ static int is_mddev_idle(mddev_t *mddev)
         rcu_read_lock();
         rdev_for_each_rcu(rdev, mddev) {
                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
-                curr_events = disk_stat_read(disk, sectors[0]) + 
-                                disk_stat_read(disk, sectors[1]) - 
+                curr_events = part_stat_read(&disk->part0, sectors[0]) +
+                                part_stat_read(&disk->part0, sectors[1]) -
                                 atomic_read(&disk->sync_io);
                 /* sync IO will cause sync_io to increase before the disk_stats
                  * as sync_io is counted when a request starts, and
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index c4779ccba1c..8bb8794129b 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -147,6 +147,7 @@ static int multipath_make_request (struct request_queue *q, struct bio * bio)
         struct multipath_bh * mp_bh;
         struct multipath_info *multipath;
         const int rw = bio_data_dir(bio);
+        int cpu;
 
         if (unlikely(bio_barrier(bio))) {
                 bio_endio(bio, -EOPNOTSUPP);
@@ -158,8 +159,11 @@ static int multipath_make_request (struct request_queue *q, struct bio * bio)
         mp_bh->master_bio = bio;
         mp_bh->mddev = mddev;
 
-        disk_stat_inc(mddev->gendisk, ios[rw]);
-        disk_stat_add(mddev->gendisk, sectors[rw], bio_sectors(bio));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
+        part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
+                      bio_sectors(bio));
+        part_stat_unlock();
 
         mp_bh->path = multipath_map(conf);
         if (mp_bh->path < 0) {
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 18361063566..53508a8a981 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -399,14 +399,18 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio)
         sector_t chunk;
         sector_t block, rsect;
         const int rw = bio_data_dir(bio);
+        int cpu;
 
         if (unlikely(bio_barrier(bio))) {
                 bio_endio(bio, -EOPNOTSUPP);
                 return 0;
         }
 
-        disk_stat_inc(mddev->gendisk, ios[rw]);
-        disk_stat_add(mddev->gendisk, sectors[rw], bio_sectors(bio));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
+        part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
+                      bio_sectors(bio));
+        part_stat_unlock();
 
         chunk_size = mddev->chunk_size >> 10;
         chunk_sects = mddev->chunk_size >> 9;
@@ -423,7 +427,7 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio)
                 /* This is a one page bio that upper layers
                  * refuse to split for us, so we need to split it.
                  */
-                bp = bio_split(bio, bio_split_pool, chunk_sects - (bio->bi_sector & (chunk_sects - 1)) );
+                bp = bio_split(bio, chunk_sects - (bio->bi_sector & (chunk_sects - 1)));
                 if (raid0_make_request(q, &bp->bio1))
                         generic_make_request(&bp->bio1);
                 if (raid0_make_request(q, &bp->bio2))
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 03a5ab705c2..b9764429d85 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -779,7 +779,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
         struct page **behind_pages = NULL;
         const int rw = bio_data_dir(bio);
         const int do_sync = bio_sync(bio);
-        int do_barriers;
+        int cpu, do_barriers;
         mdk_rdev_t *blocked_rdev;
 
         /*
@@ -804,8 +804,11 @@ static int make_request(struct request_queue *q, struct bio * bio)
 
         bitmap = mddev->bitmap;
 
-        disk_stat_inc(mddev->gendisk, ios[rw]);
-        disk_stat_add(mddev->gendisk, sectors[rw], bio_sectors(bio));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
+        part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
+                      bio_sectors(bio));
+        part_stat_unlock();
 
         /*
          * make_request() can abort the operation when READA is being
@@ -1302,9 +1305,6 @@ static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
                                         sbio->bi_size = r1_bio->sectors << 9;
                                         sbio->bi_idx = 0;
                                         sbio->bi_phys_segments = 0;
-                                        sbio->bi_hw_segments = 0;
-                                        sbio->bi_hw_front_size = 0;
-                                        sbio->bi_hw_back_size = 0;
                                         sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
                                         sbio->bi_flags |= 1 << BIO_UPTODATE;
                                         sbio->bi_next = NULL;
@@ -1790,7 +1790,6 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
                 bio->bi_vcnt = 0;
                 bio->bi_idx = 0;
                 bio->bi_phys_segments = 0;
-                bio->bi_hw_segments = 0;
                 bio->bi_size = 0;
                 bio->bi_end_io = NULL;
                 bio->bi_private = NULL;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index e34cd0e6247..8bdc9bfc288 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -789,6 +789,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
         mirror_info_t *mirror;
         r10bio_t *r10_bio;
         struct bio *read_bio;
+        int cpu;
         int i;
         int chunk_sects = conf->chunk_mask + 1;
         const int rw = bio_data_dir(bio);
@@ -816,7 +817,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
                 /* This is a one page bio that upper layers
                  * refuse to split for us, so we need to split it.
                  */
-                bp = bio_split(bio, bio_split_pool,
+                bp = bio_split(bio,
                                chunk_sects - (bio->bi_sector & (chunk_sects - 1)) );
                 if (make_request(q, &bp->bio1))
                         generic_make_request(&bp->bio1);
@@ -843,8 +844,11 @@ static int make_request(struct request_queue *q, struct bio * bio)
          */
         wait_barrier(conf);
 
-        disk_stat_inc(mddev->gendisk, ios[rw]);
-        disk_stat_add(mddev->gendisk, sectors[rw], bio_sectors(bio));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
+        part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
+                      bio_sectors(bio));
+        part_stat_unlock();
 
         r10_bio = mempool_alloc(conf->r10bio_pool, GFP_NOIO);
 
@@ -1345,9 +1349,6 @@ static void sync_request_write(mddev_t *mddev, r10bio_t *r10_bio)
                 tbio->bi_size = r10_bio->sectors << 9;
                 tbio->bi_idx = 0;
                 tbio->bi_phys_segments = 0;
-                tbio->bi_hw_segments = 0;
-                tbio->bi_hw_front_size = 0;
-                tbio->bi_hw_back_size = 0;
                 tbio->bi_flags &= ~(BIO_POOL_MASK - 1);
                 tbio->bi_flags |= 1 << BIO_UPTODATE;
                 tbio->bi_next = NULL;
@@ -1947,7 +1948,6 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
                 bio->bi_vcnt = 0;
                 bio->bi_idx = 0;
                 bio->bi_phys_segments = 0;
-                bio->bi_hw_segments = 0;
                 bio->bi_size = 0;
         }
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 224de022e7c..ae16794bef2 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -101,6 +101,40 @@
 const char raid6_empty_zero_page[PAGE_SIZE] __attribute__((aligned(256)));
 #endif
 
+/*
+ * We maintain a biased count of active stripes in the bottom 16 bits of
+ * bi_phys_segments, and a count of processed stripes in the upper 16 bits
+ */
+static inline int raid5_bi_phys_segments(struct bio *bio)
+{
+        return bio->bi_phys_segments & 0xffff;
+}
+
+static inline int raid5_bi_hw_segments(struct bio *bio)
+{
+        return (bio->bi_phys_segments >> 16) & 0xffff;
+}
+
+static inline int raid5_dec_bi_phys_segments(struct bio *bio)
+{
+        --bio->bi_phys_segments;
+        return raid5_bi_phys_segments(bio);
+}
+
+static inline int raid5_dec_bi_hw_segments(struct bio *bio)
+{
+        unsigned short val = raid5_bi_hw_segments(bio);
+
+        --val;
+        bio->bi_phys_segments = (val << 16) | raid5_bi_phys_segments(bio);
+        return val;
+}
+
+static inline void raid5_set_bi_hw_segments(struct bio *bio, unsigned int cnt)
+{
+        bio->bi_phys_segments = raid5_bi_phys_segments(bio) || (cnt << 16);
+}
+
 static inline int raid6_next_disk(int disk, int raid_disks)
 {
         disk++;
@@ -507,7 +541,7 @@ static void ops_complete_biofill(void *stripe_head_ref)
                         while (rbi && rbi->bi_sector <
                                 dev->sector + STRIPE_SECTORS) {
                                 rbi2 = r5_next_bio(rbi, dev->sector);
-                                if (--rbi->bi_phys_segments == 0) {
+                                if (!raid5_dec_bi_phys_segments(rbi)) {
                                         rbi->bi_next = return_bi;
                                         return_bi = rbi;
                                 }
@@ -1725,7 +1759,7 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
         if (*bip)
                 bi->bi_next = *bip;
         *bip = bi;
-        bi->bi_phys_segments ++;
+        bi->bi_phys_segments++;
         spin_unlock_irq(&conf->device_lock);
         spin_unlock(&sh->lock);
 
@@ -1819,7 +1853,7 @@ handle_failed_stripe(raid5_conf_t *conf, struct stripe_head *sh,
                         sh->dev[i].sector + STRIPE_SECTORS) {
                         struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
                         clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                        if (--bi->bi_phys_segments == 0) {
+                        if (!raid5_dec_bi_phys_segments(bi)) {
                                 md_write_end(conf->mddev);
                                 bi->bi_next = *return_bi;
                                 *return_bi = bi;
@@ -1834,7 +1868,7 @@ handle_failed_stripe(raid5_conf_t *conf, struct stripe_head *sh,
                        sh->dev[i].sector + STRIPE_SECTORS) {
                         struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);
                         clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                        if (--bi->bi_phys_segments == 0) {
+                        if (!raid5_dec_bi_phys_segments(bi)) {
                                 md_write_end(conf->mddev);
                                 bi->bi_next = *return_bi;
                                 *return_bi = bi;
@@ -1858,7 +1892,7 @@ handle_failed_stripe(raid5_conf_t *conf, struct stripe_head *sh,
                                 struct bio *nextbi =
                                         r5_next_bio(bi, sh->dev[i].sector);
                                 clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                if (--bi->bi_phys_segments == 0) {
+                                if (!raid5_dec_bi_phys_segments(bi)) {
                                         bi->bi_next = *return_bi;
                                         *return_bi = bi;
                                 }
@@ -2033,7 +2067,7 @@ static void handle_stripe_clean_event(raid5_conf_t *conf,
                                 while (wbi && wbi->bi_sector <
                                         dev->sector + STRIPE_SECTORS) {
                                         wbi2 = r5_next_bio(wbi, dev->sector);
-                                        if (--wbi->bi_phys_segments == 0) {
+                                        if (!raid5_dec_bi_phys_segments(wbi)) {
                                                 md_write_end(conf->mddev);
                                                 wbi->bi_next = *return_bi;
                                                 *return_bi = wbi;
@@ -2814,7 +2848,7 @@ static bool handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                                 copy_data(0, rbi, dev->page, dev->sector);
                                 rbi2 = r5_next_bio(rbi, dev->sector);
                                 spin_lock_irq(&conf->device_lock);
-                                if (--rbi->bi_phys_segments == 0) {
+                                if (!raid5_dec_bi_phys_segments(rbi)) {
                                         rbi->bi_next = return_bi;
                                         return_bi = rbi;
                                 }
@@ -3155,8 +3189,11 @@ static struct bio *remove_bio_from_retry(raid5_conf_t *conf)
         if(bi) {
                 conf->retry_read_aligned_list = bi->bi_next;
                 bi->bi_next = NULL;
+                /*
+                 * this sets the active strip count to 1 and the processed
+                 * strip count to zero (upper 8 bits)
+                 */
                 bi->bi_phys_segments = 1; /* biased count of active stripes */
-                bi->bi_hw_segments = 0; /* count of processed stripes */
         }
 
         return bi;
@@ -3206,8 +3243,7 @@ static int bio_fits_rdev(struct bio *bi)
         if ((bi->bi_size>>9) > q->max_sectors)
                 return 0;
         blk_recount_segments(q, bi);
-        if (bi->bi_phys_segments > q->max_phys_segments ||
-            bi->bi_hw_segments > q->max_hw_segments)
+        if (bi->bi_phys_segments > q->max_phys_segments)
                 return 0;
 
         if (q->merge_bvec_fn)
@@ -3351,7 +3387,7 @@ static int make_request(struct request_queue *q, struct bio * bi)
         sector_t logical_sector, last_sector;
         struct stripe_head *sh;
         const int rw = bio_data_dir(bi);
-        int remaining;
+        int cpu, remaining;
 
         if (unlikely(bio_barrier(bi))) {
                 bio_endio(bi, -EOPNOTSUPP);
@@ -3360,8 +3396,11 @@ static int make_request(struct request_queue *q, struct bio * bi)
 
         md_write_start(mddev, bi);
 
-        disk_stat_inc(mddev->gendisk, ios[rw]);
-        disk_stat_add(mddev->gendisk, sectors[rw], bio_sectors(bi));
+        cpu = part_stat_lock();
+        part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
+        part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
+                      bio_sectors(bi));
+        part_stat_unlock();
 
         if (rw == READ &&
              mddev->reshape_position == MaxSector &&
@@ -3468,7 +3507,7 @@ static int make_request(struct request_queue *q, struct bio * bi)
                         
         }
         spin_lock_irq(&conf->device_lock);
-        remaining = --bi->bi_phys_segments;
+        remaining = raid5_dec_bi_phys_segments(bi);
         spin_unlock_irq(&conf->device_lock);
         if (remaining == 0) {
 
@@ -3752,7 +3791,7 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
                      sector += STRIPE_SECTORS,
                      scnt++) {
 
-                if (scnt < raid_bio->bi_hw_segments)
+                if (scnt < raid5_bi_hw_segments(raid_bio))
                         /* already done this stripe */
                         continue;
 
@@ -3760,7 +3799,7 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
 
                 if (!sh) {
                         /* failed to get a stripe - must wait */
-                        raid_bio->bi_hw_segments = scnt;
+                        raid5_set_bi_hw_segments(raid_bio, scnt);
                         conf->retry_read_aligned = raid_bio;
                         return handled;
                 }
@@ -3768,7 +3807,7 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
                 set_bit(R5_ReadError, &sh->dev[dd_idx].flags);
                 if (!add_stripe_bio(sh, raid_bio, dd_idx, 0)) {
                         release_stripe(sh);
-                        raid_bio->bi_hw_segments = scnt;
+                        raid5_set_bi_hw_segments(raid_bio, scnt);
                         conf->retry_read_aligned = raid_bio;
                         return handled;
                 }
@@ -3778,7 +3817,7 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
                 handled++;
         }
         spin_lock_irq(&conf->device_lock);
-        remaining = --raid_bio->bi_phys_segments;
+        remaining = raid5_dec_bi_phys_segments(raid_bio);
         spin_unlock_irq(&conf->device_lock);
         if (remaining == 0)
                 bio_endio(raid_bio, 0);