md: remove mddev_to_conf "helper" macro

Having a macro just to cast a void* isn't really helpful.
I would must rather see that we are simply de-referencing ->private,
than have to know what the macro does.

So open code the macro everywhere and remove the pointless cast.

Signed-off-by: NeilBrown <neilb@suse.de>

12 files changed, 79 insertions, 103 deletions

diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 64f1f3e046e0..31f8ec7131bd 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -28,7 +28,7 @@
 static inline dev_info_t *which_dev(mddev_t *mddev, sector_t sector)
 {
         dev_info_t *hash;
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf = mddev->private;
         sector_t idx = sector >> conf->sector_shift;
 
         /*
@@ -79,7 +79,7 @@ static int linear_mergeable_bvec(struct request_queue *q,
 static void linear_unplug(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf = mddev->private;
         int i;
 
         for (i=0; i < mddev->raid_disks; i++) {
@@ -91,7 +91,7 @@ static void linear_unplug(struct request_queue *q)
 static int linear_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf = mddev->private;
         int i, ret = 0;
 
         for (i = 0; i < mddev->raid_disks && !ret ; i++) {
@@ -103,7 +103,7 @@ static int linear_congested(void *data, int bits)
 
 static sector_t linear_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf = mddev->private;
 
         WARN_ONCE(sectors || raid_disks,
                   "%s does not support generic reshape\n", __func__);
@@ -294,7 +294,7 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
         if (!newconf)
                 return -ENOMEM;
 
-        newconf->prev = mddev_to_conf(mddev);
+        newconf->prev = mddev->private;
         mddev->private = newconf;
         mddev->raid_disks++;
         md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
@@ -304,7 +304,7 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)
 
 static int linear_stop (mddev_t *mddev)
 {
-        linear_conf_t *conf = mddev_to_conf(mddev);
+        linear_conf_t *conf = mddev->private;
   
         blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
         do {
diff --git a/drivers/md/linear.h b/drivers/md/linear.h
index bf8179587f95..76078f1cded0 100644
--- a/drivers/md/linear.h
+++ b/drivers/md/linear.h
@@ -24,6 +24,4 @@ struct linear_private_data
 
 typedef struct linear_private_data linear_conf_t;
 
-#define mddev_to_conf(mddev) ((linear_conf_t *) mddev->private)
-
 #endif
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 4ee31aa13c40..c1ca63f278a9 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -58,7 +58,7 @@ static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
 {
         unsigned long flags;
         mddev_t *mddev = mp_bh->mddev;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
 
         spin_lock_irqsave(&conf->device_lock, flags);
         list_add(&mp_bh->retry_list, &conf->retry_list);
@@ -75,7 +75,7 @@ static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
 static void multipath_end_bh_io (struct multipath_bh *mp_bh, int err)
 {
         struct bio *bio = mp_bh->master_bio;
-        multipath_conf_t *conf = mddev_to_conf(mp_bh->mddev);
+        multipath_conf_t *conf = mp_bh->mddev->private;
 
         bio_endio(bio, err);
         mempool_free(mp_bh, conf->pool);
@@ -85,7 +85,7 @@ static void multipath_end_request(struct bio *bio, int error)
 {
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct multipath_bh * mp_bh = (struct multipath_bh *)(bio->bi_private);
-        multipath_conf_t *conf = mddev_to_conf(mp_bh->mddev);
+        multipath_conf_t *conf = mp_bh->mddev->private;
         mdk_rdev_t *rdev = conf->multipaths[mp_bh->path].rdev;
 
         if (uptodate)
@@ -107,7 +107,7 @@ static void multipath_end_request(struct bio *bio, int error)
 
 static void unplug_slaves(mddev_t *mddev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
         int i;
 
         rcu_read_lock();
@@ -138,7 +138,7 @@ static void multipath_unplug(struct request_queue *q)
 static int multipath_make_request (struct request_queue *q, struct bio * bio)
 {
         mddev_t *mddev = q->queuedata;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
         struct multipath_bh * mp_bh;
         struct multipath_info *multipath;
         const int rw = bio_data_dir(bio);
@@ -180,7 +180,7 @@ static int multipath_make_request (struct request_queue *q, struct bio * bio)
 
 static void multipath_status (struct seq_file *seq, mddev_t *mddev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
         int i;
         
         seq_printf (seq, " [%d/%d] [", conf->raid_disks,
@@ -195,7 +195,7 @@ static void multipath_status (struct seq_file *seq, mddev_t *mddev)
 static int multipath_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
         int i, ret = 0;
 
         rcu_read_lock();
@@ -220,7 +220,7 @@ static int multipath_congested(void *data, int bits)
  */
 static void multipath_error (mddev_t *mddev, mdk_rdev_t *rdev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
 
         if (conf->working_disks <= 1) {
                 /*
@@ -367,7 +367,7 @@ static void multipathd (mddev_t *mddev)
         struct multipath_bh *mp_bh;
         struct bio *bio;
         unsigned long flags;
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
         struct list_head *head = &conf->retry_list;
 
         md_check_recovery(mddev);
@@ -531,7 +531,7 @@ out:
 
 static int multipath_stop (mddev_t *mddev)
 {
-        multipath_conf_t *conf = mddev_to_conf(mddev);
+        multipath_conf_t *conf = mddev->private;
 
         md_unregister_thread(mddev->thread);
         mddev->thread = NULL;
diff --git a/drivers/md/multipath.h b/drivers/md/multipath.h
index 6fa70b400cda..d1c2a8d78395 100644
--- a/drivers/md/multipath.h
+++ b/drivers/md/multipath.h
@@ -19,12 +19,6 @@ struct multipath_private_data {
 typedef struct multipath_private_data multipath_conf_t;
 
 /*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((multipath_conf_t *) mddev->private)
-
-/*
  * this is our 'private' 'collective' MULTIPATH buffer head.
  * it contains information about what kind of IO operations were started
  * for this MULTIPATH operation, and about their status:
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index e2e9c1833336..77764dad1bcb 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -26,7 +26,7 @@
 static void raid0_unplug(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
         mdk_rdev_t **devlist = conf->devlist;
         int i;
 
@@ -40,7 +40,7 @@ static void raid0_unplug(struct request_queue *q)
 static int raid0_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
         mdk_rdev_t **devlist = conf->devlist;
         int i, ret = 0;
 
@@ -294,7 +294,7 @@ static int raid0_run(mddev_t *mddev)
 
 static int raid0_stop(mddev_t *mddev)
 {
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
 
         blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
         kfree(conf->strip_zone);
@@ -327,7 +327,7 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio)
 {
         mddev_t *mddev = q->queuedata;
         unsigned int sect_in_chunk, chunksect_bits, chunk_sects;
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
         struct strip_zone *zone;
         mdk_rdev_t *tmp_dev;
         sector_t chunk;
@@ -406,7 +406,7 @@ static void raid0_status (struct seq_file *seq, mddev_t *mddev)
 #ifdef MD_DEBUG
         int j, k, h;
         char b[BDEVNAME_SIZE];
-        raid0_conf_t *conf = mddev_to_conf(mddev);
+        raid0_conf_t *conf = mddev->private;
 
         h = 0;
         for (j = 0; j < conf->nr_strip_zones; j++) {
diff --git a/drivers/md/raid0.h b/drivers/md/raid0.h
index 7b3605e570c0..91f8e876ee64 100644
--- a/drivers/md/raid0.h
+++ b/drivers/md/raid0.h
@@ -17,6 +17,4 @@ struct raid0_private_data
 
 typedef struct raid0_private_data raid0_conf_t;
 
-#define mddev_to_conf(mddev) ((raid0_conf_t *) mddev->private)
-
 #endif
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index e23758b4a34e..5ea5bca53a5e 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -182,7 +182,7 @@ static void put_all_bios(conf_t *conf, r1bio_t *r1_bio)
 
 static void free_r1bio(r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
 
         /*
          * Wake up any possible resync thread that waits for the device
@@ -196,7 +196,7 @@ static void free_r1bio(r1bio_t *r1_bio)
 
 static void put_buf(r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
         int i;
 
         for (i=0; i<conf->raid_disks; i++) {
@@ -214,7 +214,7 @@ static void reschedule_retry(r1bio_t *r1_bio)
 {
         unsigned long flags;
         mddev_t *mddev = r1_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         spin_lock_irqsave(&conf->device_lock, flags);
         list_add(&r1_bio->retry_list, &conf->retry_list);
@@ -253,7 +253,7 @@ static void raid_end_bio_io(r1bio_t *r1_bio)
  */
 static inline void update_head_pos(int disk, r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
 
         conf->mirrors[disk].head_position =
                 r1_bio->sector + (r1_bio->sectors);
@@ -264,7 +264,7 @@ static void raid1_end_read_request(struct bio *bio, int error)
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         r1bio_t * r1_bio = (r1bio_t *)(bio->bi_private);
         int mirror;
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
 
         mirror = r1_bio->read_disk;
         /*
@@ -309,7 +309,7 @@ static void raid1_end_write_request(struct bio *bio, int error)
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         r1bio_t * r1_bio = (r1bio_t *)(bio->bi_private);
         int mirror, behind = test_bit(R1BIO_BehindIO, &r1_bio->state);
-        conf_t *conf = mddev_to_conf(r1_bio->mddev);
+        conf_t *conf = r1_bio->mddev->private;
         struct bio *to_put = NULL;
 
 
@@ -541,7 +541,7 @@ static int read_balance(conf_t *conf, r1bio_t *r1_bio)
 
 static void unplug_slaves(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i;
 
         rcu_read_lock();
@@ -573,7 +573,7 @@ static void raid1_unplug(struct request_queue *q)
 static int raid1_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i, ret = 0;
 
         rcu_read_lock();
@@ -772,7 +772,7 @@ do_sync_io:
 static int make_request(struct request_queue *q, struct bio * bio)
 {
         mddev_t *mddev = q->queuedata;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         mirror_info_t *mirror;
         r1bio_t *r1_bio;
         struct bio *read_bio;
@@ -991,7 +991,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
 
 static void status(struct seq_file *seq, mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i;
 
         seq_printf(seq, " [%d/%d] [", conf->raid_disks,
@@ -1010,7 +1010,7 @@ static void status(struct seq_file *seq, mddev_t *mddev)
 static void error(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         char b[BDEVNAME_SIZE];
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         /*
          * If it is not operational, then we have already marked it as dead
@@ -1214,7 +1214,7 @@ static void end_sync_write(struct bio *bio, int error)
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         r1bio_t * r1_bio = (r1bio_t *)(bio->bi_private);
         mddev_t *mddev = r1_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i;
         int mirror=0;
 
@@ -1248,7 +1248,7 @@ static void end_sync_write(struct bio *bio, int error)
 
 static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i;
         int disks = conf->raid_disks;
         struct bio *bio, *wbio;
@@ -1562,7 +1562,7 @@ static void raid1d(mddev_t *mddev)
         r1bio_t *r1_bio;
         struct bio *bio;
         unsigned long flags;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         struct list_head *head = &conf->retry_list;
         int unplug=0;
         mdk_rdev_t *rdev;
@@ -1585,7 +1585,7 @@ static void raid1d(mddev_t *mddev)
                 spin_unlock_irqrestore(&conf->device_lock, flags);
 
                 mddev = r1_bio->mddev;
-                conf = mddev_to_conf(mddev);
+                conf = mddev->private;
                 if (test_bit(R1BIO_IsSync, &r1_bio->state)) {
                         sync_request_write(mddev, r1_bio);
                         unplug = 1;
@@ -1706,7 +1706,7 @@ static int init_resync(conf_t *conf)
 
 static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         r1bio_t *r1_bio;
         struct bio *bio;
         sector_t max_sector, nr_sectors;
@@ -2087,7 +2087,7 @@ out:
 
 static int stop(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         struct bitmap *bitmap = mddev->bitmap;
         int behind_wait = 0;
 
@@ -2155,7 +2155,7 @@ static int raid1_reshape(mddev_t *mddev)
         mempool_t *newpool, *oldpool;
         struct pool_info *newpoolinfo;
         mirror_info_t *newmirrors;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int cnt, raid_disks;
         unsigned long flags;
         int d, d2, err;
@@ -2252,7 +2252,7 @@ static int raid1_reshape(mddev_t *mddev)
 
 static void raid1_quiesce(mddev_t *mddev, int state)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         switch(state) {
         case 1:
diff --git a/drivers/md/raid1.h b/drivers/md/raid1.h
index 1620eea3d57c..e87b84deff68 100644
--- a/drivers/md/raid1.h
+++ b/drivers/md/raid1.h
@@ -64,12 +64,6 @@ struct r1_private_data_s {
 typedef struct r1_private_data_s conf_t;
 
 /*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
-
-/*
  * this is our 'private' RAID1 bio.
  *
  * it contains information about what kind of IO operations were started
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 750550c1166f..9a5beb4fd954 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -188,7 +188,7 @@ static void put_all_bios(conf_t *conf, r10bio_t *r10_bio)
 
 static void free_r10bio(r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
 
         /*
          * Wake up any possible resync thread that waits for the device
@@ -202,7 +202,7 @@ static void free_r10bio(r10bio_t *r10_bio)
 
 static void put_buf(r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
 
         mempool_free(r10_bio, conf->r10buf_pool);
 
@@ -213,7 +213,7 @@ static void reschedule_retry(r10bio_t *r10_bio)
 {
         unsigned long flags;
         mddev_t *mddev = r10_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         spin_lock_irqsave(&conf->device_lock, flags);
         list_add(&r10_bio->retry_list, &conf->retry_list);
@@ -245,7 +245,7 @@ static void raid_end_bio_io(r10bio_t *r10_bio)
  */
 static inline void update_head_pos(int slot, r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
 
         conf->mirrors[r10_bio->devs[slot].devnum].head_position =
                 r10_bio->devs[slot].addr + (r10_bio->sectors);
@@ -256,7 +256,7 @@ static void raid10_end_read_request(struct bio *bio, int error)
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
         int slot, dev;
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
 
 
         slot = r10_bio->read_slot;
@@ -297,7 +297,7 @@ static void raid10_end_write_request(struct bio *bio, int error)
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
         int slot, dev;
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
 
         for (slot = 0; slot < conf->copies; slot++)
                 if (r10_bio->devs[slot].bio == bio)
@@ -596,7 +596,7 @@ rb_out:
 
 static void unplug_slaves(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i;
 
         rcu_read_lock();
@@ -628,7 +628,7 @@ static void raid10_unplug(struct request_queue *q)
 static int raid10_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i, ret = 0;
 
         rcu_read_lock();
@@ -788,7 +788,7 @@ static void unfreeze_array(conf_t *conf)
 static int make_request(struct request_queue *q, struct bio * bio)
 {
         mddev_t *mddev = q->queuedata;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         mirror_info_t *mirror;
         r10bio_t *r10_bio;
         struct bio *read_bio;
@@ -981,7 +981,7 @@ static int make_request(struct request_queue *q, struct bio * bio)
 
 static void status(struct seq_file *seq, mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i;
 
         if (conf->near_copies < conf->raid_disks)
@@ -1006,7 +1006,7 @@ static void status(struct seq_file *seq, mddev_t *mddev)
 static void error(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         char b[BDEVNAME_SIZE];
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         /*
          * If it is not operational, then we have already marked it as dead
@@ -1215,7 +1215,7 @@ abort:
 static void end_sync_read(struct bio *bio, int error)
 {
         r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
-        conf_t *conf = mddev_to_conf(r10_bio->mddev);
+        conf_t *conf = r10_bio->mddev->private;
         int i,d;
 
         for (i=0; i<conf->copies; i++)
@@ -1253,7 +1253,7 @@ static void end_sync_write(struct bio *bio, int error)
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         r10bio_t * r10_bio = (r10bio_t *)(bio->bi_private);
         mddev_t *mddev = r10_bio->mddev;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i,d;
 
         for (i = 0; i < conf->copies; i++)
@@ -1300,7 +1300,7 @@ static void end_sync_write(struct bio *bio, int error)
  */
 static void sync_request_write(mddev_t *mddev, r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i, first;
         struct bio *tbio, *fbio;
 
@@ -1400,7 +1400,7 @@ done:
 
 static void recovery_request_write(mddev_t *mddev, r10bio_t *r10_bio)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         int i, d;
         struct bio *bio, *wbio;
 
@@ -1549,7 +1549,7 @@ static void raid10d(mddev_t *mddev)
         r10bio_t *r10_bio;
         struct bio *bio;
         unsigned long flags;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         struct list_head *head = &conf->retry_list;
         int unplug=0;
         mdk_rdev_t *rdev;
@@ -1572,7 +1572,7 @@ static void raid10d(mddev_t *mddev)
                 spin_unlock_irqrestore(&conf->device_lock, flags);
 
                 mddev = r10_bio->mddev;
-                conf = mddev_to_conf(mddev);
+                conf = mddev->private;
                 if (test_bit(R10BIO_IsSync, &r10_bio->state)) {
                         sync_request_write(mddev, r10_bio);
                         unplug = 1;
@@ -1680,7 +1680,7 @@ static int init_resync(conf_t *conf)
 
 static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, int go_faster)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
         r10bio_t *r10_bio;
         struct bio *biolist = NULL, *bio;
         sector_t max_sector, nr_sectors;
@@ -2026,7 +2026,7 @@ static sector_t
 raid10_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
         sector_t size;
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         if (!raid_disks)
                 raid_disks = mddev->raid_disks;
@@ -2227,7 +2227,7 @@ out:
 
 static int stop(mddev_t *mddev)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         raise_barrier(conf, 0);
         lower_barrier(conf);
@@ -2245,7 +2245,7 @@ static int stop(mddev_t *mddev)
 
 static void raid10_quiesce(mddev_t *mddev, int state)
 {
-        conf_t *conf = mddev_to_conf(mddev);
+        conf_t *conf = mddev->private;
 
         switch(state) {
         case 1:
diff --git a/drivers/md/raid10.h b/drivers/md/raid10.h
index 244dbe507a54..59cd1efb8d30 100644
--- a/drivers/md/raid10.h
+++ b/drivers/md/raid10.h
@@ -62,12 +62,6 @@ struct r10_private_data_s {
 typedef struct r10_private_data_s conf_t;
 
 /*
- * this is the only point in the RAID code where we violate
- * C type safety. mddev->private is an 'opaque' pointer.
- */
-#define mddev_to_conf(mddev) ((conf_t *) mddev->private)
-
-/*
  * this is our 'private' RAID10 bio.
  *
  * it contains information about what kind of IO operations were started
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index bef876698232..7fb97c65ad37 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3284,7 +3284,7 @@ static void activate_bit_delay(raid5_conf_t *conf)
 
 static void unplug_slaves(mddev_t *mddev)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         int i;
 
         rcu_read_lock();
@@ -3308,7 +3308,7 @@ static void unplug_slaves(mddev_t *mddev)
 static void raid5_unplug_device(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         unsigned long flags;
 
         spin_lock_irqsave(&conf->device_lock, flags);
@@ -3327,7 +3327,7 @@ static void raid5_unplug_device(struct request_queue *q)
 static int raid5_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
 
         /* No difference between reads and writes.  Just check
          * how busy the stripe_cache is
@@ -3440,7 +3440,7 @@ static void raid5_align_endio(struct bio *bi, int error)
         bio_put(bi);
 
         mddev = raid_bi->bi_bdev->bd_disk->queue->queuedata;
-        conf = mddev_to_conf(mddev);
+        conf = mddev->private;
         rdev = (void*)raid_bi->bi_next;
         raid_bi->bi_next = NULL;
 
@@ -3482,7 +3482,7 @@ static int bio_fits_rdev(struct bio *bi)
 static int chunk_aligned_read(struct request_queue *q, struct bio * raid_bio)
 {
         mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         unsigned int dd_idx;
         struct bio* align_bi;
         mdk_rdev_t *rdev;
@@ -3599,7 +3599,7 @@ static struct stripe_head *__get_priority_stripe(raid5_conf_t *conf)
 static int make_request(struct request_queue *q, struct bio * bi)
 {
         mddev_t *mddev = q->queuedata;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         int dd_idx;
         sector_t new_sector;
         sector_t logical_sector, last_sector;
@@ -4129,7 +4129,7 @@ static int  retry_aligned_read(raid5_conf_t *conf, struct bio *raid_bio)
 static void raid5d(mddev_t *mddev)
 {
         struct stripe_head *sh;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         int handled;
 
         pr_debug("+++ raid5d active\n");
@@ -4185,7 +4185,7 @@ static void raid5d(mddev_t *mddev)
 static ssize_t
 raid5_show_stripe_cache_size(mddev_t *mddev, char *page)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         if (conf)
                 return sprintf(page, "%d\n", conf->max_nr_stripes);
         else
@@ -4195,7 +4195,7 @@ raid5_show_stripe_cache_size(mddev_t *mddev, char *page)
 static ssize_t
 raid5_store_stripe_cache_size(mddev_t *mddev, const char *page, size_t len)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         unsigned long new;
         int err;
 
@@ -4233,7 +4233,7 @@ raid5_stripecache_size = __ATTR(stripe_cache_size, S_IRUGO | S_IWUSR,
 static ssize_t
 raid5_show_preread_threshold(mddev_t *mddev, char *page)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         if (conf)
                 return sprintf(page, "%d\n", conf->bypass_threshold);
         else
@@ -4243,7 +4243,7 @@ raid5_show_preread_threshold(mddev_t *mddev, char *page)
 static ssize_t
 raid5_store_preread_threshold(mddev_t *mddev, const char *page, size_t len)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         unsigned long new;
         if (len >= PAGE_SIZE)
                 return -EINVAL;
@@ -4267,7 +4267,7 @@ raid5_preread_bypass_threshold = __ATTR(preread_bypass_threshold,
 static ssize_t
 stripe_cache_active_show(mddev_t *mddev, char *page)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         if (conf)
                 return sprintf(page, "%d\n", atomic_read(&conf->active_stripes));
         else
@@ -4291,7 +4291,7 @@ static struct attribute_group raid5_attrs_group = {
 static sector_t
 raid5_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
 
         if (!sectors)
                 sectors = mddev->dev_sectors;
@@ -4845,7 +4845,7 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
 
 static int raid5_check_reshape(mddev_t *mddev)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
 
         if (mddev->delta_disks == 0 &&
             mddev->new_layout == mddev->layout &&
@@ -4890,7 +4890,7 @@ static int raid5_check_reshape(mddev_t *mddev)
 
 static int raid5_start_reshape(mddev_t *mddev)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
         mdk_rdev_t *rdev;
         int spares = 0;
         int added_devices = 0;
@@ -5022,7 +5022,7 @@ static void end_reshape(raid5_conf_t *conf)
 static void raid5_finish_reshape(mddev_t *mddev)
 {
         struct block_device *bdev;
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
 
         if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
 
@@ -5061,7 +5061,7 @@ static void raid5_finish_reshape(mddev_t *mddev)
 
 static void raid5_quiesce(mddev_t *mddev, int state)
 {
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
 
         switch(state) {
         case 2: /* resume for a suspend */
@@ -5157,7 +5157,7 @@ static int raid5_reconfig(mddev_t *mddev, int new_layout, int new_chunk)
          * For larger arrays we record the new value - after validation
          * to be used by a reshape pass.
          */
-        raid5_conf_t *conf = mddev_to_conf(mddev);
+        raid5_conf_t *conf = mddev->private;
 
         if (new_layout >= 0 && !algorithm_valid_raid5(new_layout))
                 return -EINVAL;
diff --git a/drivers/md/raid5.h b/drivers/md/raid5.h
index 52ba99954dec..1a25c9e252b4 100644
--- a/drivers/md/raid5.h
+++ b/drivers/md/raid5.h
@@ -408,8 +408,6 @@ struct raid5_private_data {
 
 typedef struct raid5_private_data raid5_conf_t;
 
-#define mddev_to_conf(mddev) ((raid5_conf_t *) mddev->private)
-
 /*
  * Our supported algorithms
  */