Patched in Tegra support.

1 files changed, 39 insertions, 41 deletions

diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 1642eae75a3..d5b5fb30017 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -20,7 +20,6 @@
  */
 
 #include <linux/blkdev.h>
-#include <linux/module.h>
 #include <linux/raid/md_u.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
@@ -32,7 +31,7 @@
 #define NR_RESERVED_BUFS        32
 
 
-static int multipath_map (struct mpconf *conf)
+static int multipath_map (multipath_conf_t *conf)
 {
         int i, disks = conf->raid_disks;
 
@@ -43,7 +42,7 @@ static int multipath_map (struct mpconf *conf)
 
         rcu_read_lock();
         for (i = 0; i < disks; i++) {
-                struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
+                mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
                 if (rdev && test_bit(In_sync, &rdev->flags)) {
                         atomic_inc(&rdev->nr_pending);
                         rcu_read_unlock();
@@ -59,8 +58,8 @@ static int multipath_map (struct mpconf *conf)
 static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
 {
         unsigned long flags;
-        struct mddev *mddev = mp_bh->mddev;
-        struct mpconf *conf = mddev->private;
+        mddev_t *mddev = mp_bh->mddev;
+        multipath_conf_t *conf = mddev->private;
 
         spin_lock_irqsave(&conf->device_lock, flags);
         list_add(&mp_bh->retry_list, &conf->retry_list);
@@ -77,7 +76,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;
-        struct mpconf *conf = mp_bh->mddev->private;
+        multipath_conf_t *conf = mp_bh->mddev->private;
 
         bio_endio(bio, err);
         mempool_free(mp_bh, conf->pool);
@@ -87,8 +86,8 @@ static void multipath_end_request(struct bio *bio, int error)
 {
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct multipath_bh *mp_bh = bio->bi_private;
-        struct mpconf *conf = mp_bh->mddev->private;
-        struct md_rdev *rdev = conf->multipaths[mp_bh->path].rdev;
+        multipath_conf_t *conf = mp_bh->mddev->private;
+        mdk_rdev_t *rdev = conf->multipaths[mp_bh->path].rdev;
 
         if (uptodate)
                 multipath_end_bh_io(mp_bh, 0);
@@ -107,15 +106,15 @@ static void multipath_end_request(struct bio *bio, int error)
         rdev_dec_pending(rdev, conf->mddev);
 }
 
-static void multipath_make_request(struct mddev *mddev, struct bio * bio)
+static int multipath_make_request(mddev_t *mddev, struct bio * bio)
 {
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
         struct multipath_bh * mp_bh;
         struct multipath_info *multipath;
 
         if (unlikely(bio->bi_rw & REQ_FLUSH)) {
                 md_flush_request(mddev, bio);
-                return;
+                return 0;
         }
 
         mp_bh = mempool_alloc(conf->pool, GFP_NOIO);
@@ -127,7 +126,7 @@ static void multipath_make_request(struct mddev *mddev, struct bio * bio)
         if (mp_bh->path < 0) {
                 bio_endio(bio, -EIO);
                 mempool_free(mp_bh, conf->pool);
-                return;
+                return 0;
         }
         multipath = conf->multipaths + mp_bh->path;
 
@@ -138,12 +137,12 @@ static void multipath_make_request(struct mddev *mddev, struct bio * bio)
         mp_bh->bio.bi_end_io = multipath_end_request;
         mp_bh->bio.bi_private = mp_bh;
         generic_make_request(&mp_bh->bio);
-        return;
+        return 0;
 }
 
-static void multipath_status (struct seq_file *seq, struct mddev *mddev)
+static void multipath_status (struct seq_file *seq, mddev_t *mddev)
 {
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
         int i;
         
         seq_printf (seq, " [%d/%d] [", conf->raid_disks,
@@ -157,8 +156,8 @@ static void multipath_status (struct seq_file *seq, struct mddev *mddev)
 
 static int multipath_congested(void *data, int bits)
 {
-        struct mddev *mddev = data;
-        struct mpconf *conf = mddev->private;
+        mddev_t *mddev = data;
+        multipath_conf_t *conf = mddev->private;
         int i, ret = 0;
 
         if (mddev_congested(mddev, bits))
@@ -166,7 +165,7 @@ static int multipath_congested(void *data, int bits)
 
         rcu_read_lock();
         for (i = 0; i < mddev->raid_disks ; i++) {
-                struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
+                mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
                         struct request_queue *q = bdev_get_queue(rdev->bdev);
 
@@ -184,9 +183,9 @@ static int multipath_congested(void *data, int bits)
 /*
  * Careful, this can execute in IRQ contexts as well!
  */
-static void multipath_error (struct mddev *mddev, struct md_rdev *rdev)
+static void multipath_error (mddev_t *mddev, mdk_rdev_t *rdev)
 {
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
         char b[BDEVNAME_SIZE];
 
         if (conf->raid_disks - mddev->degraded <= 1) {
@@ -219,7 +218,7 @@ static void multipath_error (struct mddev *mddev, struct md_rdev *rdev)
                conf->raid_disks - mddev->degraded);
 }
 
-static void print_multipath_conf (struct mpconf *conf)
+static void print_multipath_conf (multipath_conf_t *conf)
 {
         int i;
         struct multipath_info *tmp;
@@ -243,9 +242,9 @@ static void print_multipath_conf (struct mpconf *conf)
 }
 
 
-static int multipath_add_disk(struct mddev *mddev, struct md_rdev *rdev)
+static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
 {
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
         struct request_queue *q;
         int err = -EEXIST;
         int path;
@@ -292,16 +291,17 @@ static int multipath_add_disk(struct mddev *mddev, struct md_rdev *rdev)
         return err;
 }
 
-static int multipath_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
+static int multipath_remove_disk(mddev_t *mddev, int number)
 {
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
         int err = 0;
-        int number = rdev->raid_disk;
+        mdk_rdev_t *rdev;
         struct multipath_info *p = conf->multipaths + number;
 
         print_multipath_conf(conf);
 
-        if (rdev == p->rdev) {
+        rdev = p->rdev;
+        if (rdev) {
                 if (test_bit(In_sync, &rdev->flags) ||
                     atomic_read(&rdev->nr_pending)) {
                         printk(KERN_ERR "hot-remove-disk, slot %d is identified"
@@ -335,13 +335,12 @@ abort:
  *      3.      Performs writes following reads for array syncronising.
  */
 
-static void multipathd(struct md_thread *thread)
+static void multipathd (mddev_t *mddev)
 {
-        struct mddev *mddev = thread->mddev;
         struct multipath_bh *mp_bh;
         struct bio *bio;
         unsigned long flags;
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
         struct list_head *head = &conf->retry_list;
 
         md_check_recovery(mddev);
@@ -380,7 +379,7 @@ static void multipathd(struct md_thread *thread)
         spin_unlock_irqrestore(&conf->device_lock, flags);
 }
 
-static sector_t multipath_size(struct mddev *mddev, sector_t sectors, int raid_disks)
+static sector_t multipath_size(mddev_t *mddev, sector_t sectors, int raid_disks)
 {
         WARN_ONCE(sectors || raid_disks,
                   "%s does not support generic reshape\n", __func__);
@@ -388,12 +387,12 @@ static sector_t multipath_size(struct mddev *mddev, sector_t sectors, int raid_d
         return mddev->dev_sectors;
 }
 
-static int multipath_run (struct mddev *mddev)
+static int multipath_run (mddev_t *mddev)
 {
-        struct mpconf *conf;
+        multipath_conf_t *conf;
         int disk_idx;
         struct multipath_info *disk;
-        struct md_rdev *rdev;
+        mdk_rdev_t *rdev;
         int working_disks;
 
         if (md_check_no_bitmap(mddev))
@@ -410,7 +409,7 @@ static int multipath_run (struct mddev *mddev)
          * should be freed in multipath_stop()]
          */
 
-        conf = kzalloc(sizeof(struct mpconf), GFP_KERNEL);
+        conf = kzalloc(sizeof(multipath_conf_t), GFP_KERNEL);
         mddev->private = conf;
         if (!conf) {
                 printk(KERN_ERR 
@@ -429,7 +428,7 @@ static int multipath_run (struct mddev *mddev)
         }
 
         working_disks = 0;
-        rdev_for_each(rdev, mddev) {
+        list_for_each_entry(rdev, &mddev->disks, same_set) {
                 disk_idx = rdev->raid_disk;
                 if (disk_idx < 0 ||
                     disk_idx >= mddev->raid_disks)
@@ -475,8 +474,7 @@ static int multipath_run (struct mddev *mddev)
         }
 
         {
-                mddev->thread = md_register_thread(multipathd, mddev,
-                                                   "multipath");
+                mddev->thread = md_register_thread(multipathd, mddev, NULL);
                 if (!mddev->thread) {
                         printk(KERN_ERR "multipath: couldn't allocate thread"
                                 " for %s\n", mdname(mddev));
@@ -512,9 +510,9 @@ out:
 }
 
 
-static int multipath_stop (struct mddev *mddev)
+static int multipath_stop (mddev_t *mddev)
 {
-        struct mpconf *conf = mddev->private;
+        multipath_conf_t *conf = mddev->private;
 
         md_unregister_thread(&mddev->thread);
         blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
@@ -525,7 +523,7 @@ static int multipath_stop (struct mddev *mddev)
         return 0;
 }
 
-static struct md_personality multipath_personality =
+static struct mdk_personality multipath_personality =
 {
         .name           = "multipath",
         .level          = LEVEL_MULTIPATH,