Merge branch 'md-next' of git://github.com/goldwynr/linux into for-next

md-cluster: A better way for METADATA_UPDATED processing The processing of METADATA_UPDATED message is too simple and prone to errors. Besides, it would not update the internal data structures as required. This set of patches reads the superblock from one of the device of the MD and checks for changes in the in-memory data structures. If there is a change, it performs the necessary actions to keep the internal data structures as it would be in the primary node. An example is if a devices turns faulty. The algorithm is: 1. The initiator node marks the device as faulty and updates the superblock 2. The initiator node sends METADATA_UPDATED with an advisory device number to the rest of the nodes. 3. The receiving node on receiving the METADATA_UPDATED message 3.1 Reads the superblock 3.2 Detects a device has failed by comparing with memory structure 3.3 Calls the necessary functions to record the failure and get the device out of the active array. 3.4 Acknowledges the message. The patch series also fixes adding the disk which was impacted because of the changes. Patches can also be found at https://github.com/goldwynr/linux branch md-next Changes since V2: - Fix status synchrnoization after --add and --re-add operations - Included Guoqing's patches on endian correctness, zeroing cmsg etc - Restructure add_new_disk() and cancel()
author: NeilBrown <neilb@suse.com> 2015-10-13 16:09:52 -0400
committer: NeilBrown <neilb@suse.com> 2015-10-13 16:09:52 -0400
commit: c2a06c38d92d044a69a3eae0138ab95ff0788030 (patch)
tree: e193af1aaf9ea876dedf6db38ded53f8d7a7f9b4
parent: 25cb62b76430a91cc6195f902e61c2cb84ade622 (diff)
parent: 23b63f9fa82eed128b5c585cbfe10ced82d73e91 (diff)
11 files changed, 421 insertions, 214 deletions
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 48b5890c28e3..4f22e919787a 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -613,12 +613,10 @@ re_read:
        daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
        write_behind = le32_to_cpu(sb->write_behind);
        sectors_reserved = le32_to_cpu(sb->sectors_reserved);
-        /* XXX: This is a hack to ensure that we don't use clustering
+        /* Setup nodes/clustername only if bitmap version is
-         *  in case:
+         * cluster-compatible
-         *      - dm-raid is in use and
-         *      - the nodes written in bitmap_sb is erroneous.
         */
-        if (!bitmap->mddev->sync_super) {
+        if (sb->version == cpu_to_le32(BITMAP_MAJOR_CLUSTERED)) {
                nodes = le32_to_cpu(sb->nodes);
                strlcpy(bitmap->mddev->bitmap_info.cluster_name,
                                sb->cluster_name, 64);
@@ -628,7 +626,7 @@ re_read:
        if (sb->magic != cpu_to_le32(BITMAP_MAGIC))
                reason = "bad magic";
        else if (le32_to_cpu(sb->version) < BITMAP_MAJOR_LO ||
-                 le32_to_cpu(sb->version) > BITMAP_MAJOR_HI)
+                 le32_to_cpu(sb->version) > BITMAP_MAJOR_CLUSTERED)
                reason = "unrecognized superblock version";
        else if (chunksize < 512)
                reason = "bitmap chunksize too small";
@@ -1572,7 +1570,7 @@ void bitmap_close_sync(struct bitmap *bitmap)
 }
 EXPORT_SYMBOL(bitmap_close_sync);
-void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
+void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector, bool force)
 {
        sector_t s = 0;
        sector_t blocks;
@@ -1583,7 +1581,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
                bitmap->last_end_sync = jiffies;
                return;
        }
-        if (time_before(jiffies, (bitmap->last_end_sync
+        if (!force && time_before(jiffies, (bitmap->last_end_sync
                                  + bitmap->mddev->bitmap_info.daemon_sleep)))
                return;
        wait_event(bitmap->mddev->recovery_wait,
diff --git a/drivers/md/bitmap.h b/drivers/md/bitmap.h
index f1f4dd01090d..7d5c3a610ca5 100644
--- a/drivers/md/bitmap.h
+++ b/drivers/md/bitmap.h
@@ -9,8 +9,10 @@
 #define BITMAP_MAJOR_LO 3
 /* version 4 insists the bitmap is in little-endian order
 * with version 3, it is host-endian which is non-portable
+ * Version 5 is currently set only for clustered devices
 */
 #define BITMAP_MAJOR_HI 4
+#define BITMAP_MAJOR_CLUSTERED 5
 #define BITMAP_MAJOR_HOSTENDIAN 3
 /*
@@ -255,7 +257,7 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset,
 int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded);
 void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted);
 void bitmap_close_sync(struct bitmap *bitmap);
-void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector);
+void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector, bool force);
 void bitmap_unplug(struct bitmap *bitmap);
 void bitmap_daemon_work(struct mddev *mddev);
diff --git a/drivers/md/md-cluster.c b/drivers/md/md-cluster.c
index 11e3bc9d2a4b..35ac2e8cb7f1 100644
--- a/drivers/md/md-cluster.c
+++ b/drivers/md/md-cluster.c
@@ -28,6 +28,7 @@ struct dlm_lock_resource {
        struct completion completion; /* completion for synchronized locking */
        void (*bast)(void *arg, int mode); /* blocking AST function pointer*/
        struct mddev *mddev; /* pointing back to mddev. */
+        int mode;
 };
 struct suspend_info {
@@ -55,6 +56,7 @@ struct md_cluster_info {
        struct completion completion;
        struct mutex sb_mutex;
        struct dlm_lock_resource *bitmap_lockres;
+        struct dlm_lock_resource *resync_lockres;
        struct list_head suspend_list;
        spinlock_t suspend_lock;
        struct md_thread *recovery_thread;
@@ -106,6 +108,8 @@ static int dlm_lock_sync(struct dlm_lock_resource *res, int mode)
        if (ret)
                return ret;
        wait_for_completion(&res->completion);
+        if (res->lksb.sb_status == 0)
+                res->mode = mode;
        return res->lksb.sb_status;
 }
@@ -127,6 +131,7 @@ static struct dlm_lock_resource *lockres_init(struct mddev *mddev,
        init_completion(&res->completion);
        res->ls = cinfo->lockspace;
        res->mddev = mddev;
+        res->mode = DLM_LOCK_IV;
        namelen = strlen(name);
        res->name = kzalloc(namelen + 1, GFP_KERNEL);
        if (!res->name) {
@@ -358,29 +363,32 @@ static void __remove_suspend_info(struct md_cluster_info *cinfo, int slot)
        list_for_each_entry_safe(s, tmp, &cinfo->suspend_list, list)
                if (slot == s->slot) {
-                        pr_info("%s:%d Deleting suspend_info: %d\n",
-                                        __func__, __LINE__, slot);
                        list_del(&s->list);
                        kfree(s);
                        break;
                }
 }
-static void remove_suspend_info(struct md_cluster_info *cinfo, int slot)
+static void remove_suspend_info(struct mddev *mddev, int slot)
 {
+        struct md_cluster_info *cinfo = mddev->cluster_info;
        spin_lock_irq(&cinfo->suspend_lock);
        __remove_suspend_info(cinfo, slot);
        spin_unlock_irq(&cinfo->suspend_lock);
+        mddev->pers->quiesce(mddev, 2);
 }
-static void process_suspend_info(struct md_cluster_info *cinfo,
+static void process_suspend_info(struct mddev *mddev,
                int slot, sector_t lo, sector_t hi)
 {
+        struct md_cluster_info *cinfo = mddev->cluster_info;
        struct suspend_info *s;
        if (!hi) {
-                remove_suspend_info(cinfo, slot);
+                remove_suspend_info(mddev, slot);
+                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+                md_wakeup_thread(mddev->thread);
                return;
        }
        s = kzalloc(sizeof(struct suspend_info), GFP_KERNEL);
@@ -389,11 +397,14 @@ static void process_suspend_info(struct md_cluster_info *cinfo,
        s->slot = slot;
        s->lo = lo;
        s->hi = hi;
+        mddev->pers->quiesce(mddev, 1);
+        mddev->pers->quiesce(mddev, 0);
        spin_lock_irq(&cinfo->suspend_lock);
        /* Remove existing entry (if exists) before adding */
        __remove_suspend_info(cinfo, slot);
        list_add(&s->list, &cinfo->suspend_list);
        spin_unlock_irq(&cinfo->suspend_lock);
+        mddev->pers->quiesce(mddev, 2);
 }
 static void process_add_new_disk(struct mddev *mddev, struct cluster_msg *cmsg)
@@ -407,7 +418,7 @@ static void process_add_new_disk(struct mddev *mddev, struct cluster_msg *cmsg)
        len = snprintf(disk_uuid, 64, "DEVICE_UUID=");
        sprintf(disk_uuid + len, "%pU", cmsg->uuid);
-        snprintf(raid_slot, 16, "RAID_DISK=%d", cmsg->raid_slot);
+        snprintf(raid_slot, 16, "RAID_DISK=%d", le32_to_cpu(cmsg->raid_slot));
        pr_info("%s:%d Sending kobject change with %s and %s\n", __func__, __LINE__, disk_uuid, raid_slot);
        init_completion(&cinfo->newdisk_completion);
        set_bit(MD_CLUSTER_WAITING_FOR_NEWDISK, &cinfo->state);
@@ -421,63 +432,57 @@ static void process_add_new_disk(struct mddev *mddev, struct cluster_msg *cmsg)
 static void process_metadata_update(struct mddev *mddev, struct cluster_msg *msg)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
+        md_reload_sb(mddev, le32_to_cpu(msg->raid_slot));
-        md_reload_sb(mddev);
        dlm_lock_sync(cinfo->no_new_dev_lockres, DLM_LOCK_CR);
 }
 static void process_remove_disk(struct mddev *mddev, struct cluster_msg *msg)
 {
-        struct md_rdev *rdev = md_find_rdev_nr_rcu(mddev, msg->raid_slot);
+        struct md_rdev *rdev = md_find_rdev_nr_rcu(mddev,
+                                                   le32_to_cpu(msg->raid_slot));
        if (rdev)
                md_kick_rdev_from_array(rdev);
        else
-                pr_warn("%s: %d Could not find disk(%d) to REMOVE\n", __func__, __LINE__, msg->raid_slot);
+                pr_warn("%s: %d Could not find disk(%d) to REMOVE\n",
+                        __func__, __LINE__, le32_to_cpu(msg->raid_slot));
 }
 static void process_readd_disk(struct mddev *mddev, struct cluster_msg *msg)
 {
-        struct md_rdev *rdev = md_find_rdev_nr_rcu(mddev, msg->raid_slot);
+        struct md_rdev *rdev = md_find_rdev_nr_rcu(mddev,
+                                                   le32_to_cpu(msg->raid_slot));
        if (rdev && test_bit(Faulty, &rdev->flags))
                clear_bit(Faulty, &rdev->flags);
        else
-                pr_warn("%s: %d Could not find disk(%d) which is faulty", __func__, __LINE__, msg->raid_slot);
+                pr_warn("%s: %d Could not find disk(%d) which is faulty",
+                        __func__, __LINE__, le32_to_cpu(msg->raid_slot));
 }
 static void process_recvd_msg(struct mddev *mddev, struct cluster_msg *msg)
 {
+        if (WARN(mddev->cluster_info->slot_number - 1 == le32_to_cpu(msg->slot),
+                "node %d received it's own msg\n", le32_to_cpu(msg->slot)))
+                return;
        switch (msg->type) {
        case METADATA_UPDATED:
-                pr_info("%s: %d Received message: METADATA_UPDATE from %d\n",
-                        __func__, __LINE__, msg->slot);
                process_metadata_update(mddev, msg);
                break;
        case RESYNCING:
-                pr_info("%s: %d Received message: RESYNCING from %d\n",
+                process_suspend_info(mddev, msg->slot,
-                        __func__, __LINE__, msg->slot);
-                process_suspend_info(mddev->cluster_info, msg->slot,
                                msg->low, msg->high);
                break;
        case NEWDISK:
-                pr_info("%s: %d Received message: NEWDISK from %d\n",
-                        __func__, __LINE__, msg->slot);
                process_add_new_disk(mddev, msg);
                break;
        case REMOVE:
-                pr_info("%s: %d Received REMOVE from %d\n",
-                        __func__, __LINE__, msg->slot);
                process_remove_disk(mddev, msg);
                break;
        case RE_ADD:
-                pr_info("%s: %d Received RE_ADD from %d\n",
-                        __func__, __LINE__, msg->slot);
                process_readd_disk(mddev, msg);
                break;
        case BITMAP_NEEDS_SYNC:
-                pr_info("%s: %d Received BITMAP_NEEDS_SYNC from %d\n",
-                        __func__, __LINE__, msg->slot);
                __recover_slot(mddev, msg->slot);
                break;
        default:
@@ -528,11 +533,17 @@ static void recv_daemon(struct md_thread *thread)
 /* lock_comm()
 * Takes the lock on the TOKEN lock resource so no other
 * node can communicate while the operation is underway.
+ * If called again, and the TOKEN lock is alread in EX mode
+ * return success. However, care must be taken that unlock_comm()
+ * is called only once.
 */
 static int lock_comm(struct md_cluster_info *cinfo)
 {
        int error;
+        if (cinfo->token_lockres->mode == DLM_LOCK_EX)
+                return 0;
        error = dlm_lock_sync(cinfo->token_lockres, DLM_LOCK_EX);
        if (error)
                pr_err("md-cluster(%s:%d): failed to get EX on TOKEN (%d)\n",
@@ -542,6 +553,7 @@ static int lock_comm(struct md_cluster_info *cinfo)
 static void unlock_comm(struct md_cluster_info *cinfo)
 {
+        WARN_ON(cinfo->token_lockres->mode != DLM_LOCK_EX);
        dlm_unlock_sync(cinfo->token_lockres);
 }
@@ -753,6 +765,10 @@ static int join(struct mddev *mddev, int nodes)
                goto err;
        }
+        cinfo->resync_lockres = lockres_init(mddev, "resync", NULL, 0);
+        if (!cinfo->resync_lockres)
+                goto err;
        ret = gather_all_resync_info(mddev, nodes);
        if (ret)
                goto err;
@@ -763,6 +779,7 @@ err:
        lockres_free(cinfo->token_lockres);
        lockres_free(cinfo->ack_lockres);
        lockres_free(cinfo->no_new_dev_lockres);
+        lockres_free(cinfo->resync_lockres);
        lockres_free(cinfo->bitmap_lockres);
        if (cinfo->lockspace)
                dlm_release_lockspace(cinfo->lockspace, 2);
@@ -771,12 +788,32 @@ err:
        return ret;
 }
+static void resync_bitmap(struct mddev *mddev)
+{
+        struct md_cluster_info *cinfo = mddev->cluster_info;
+        struct cluster_msg cmsg = {0};
+        int err;
+        cmsg.type = cpu_to_le32(BITMAP_NEEDS_SYNC);
+        err = sendmsg(cinfo, &cmsg);
+        if (err)
+                pr_err("%s:%d: failed to send BITMAP_NEEDS_SYNC message (%d)\n",
+                        __func__, __LINE__, err);
+}
 static int leave(struct mddev *mddev)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
        if (!cinfo)
                return 0;
+        /* BITMAP_NEEDS_SYNC message should be sent when node
+         * is leaving the cluster with dirty bitmap, also we
+         * can only deliver it when dlm connection is available */
+        if (cinfo->slot_number > 0 && mddev->recovery_cp != MaxSector)
+                resync_bitmap(mddev);
        md_unregister_thread(&cinfo->recovery_thread);
        md_unregister_thread(&cinfo->recv_thread);
        lockres_free(cinfo->message_lockres);
@@ -799,15 +836,6 @@ static int slot_number(struct mddev *mddev)
        return cinfo->slot_number - 1;
 }
-static void resync_info_update(struct mddev *mddev, sector_t lo, sector_t hi)
-{
-        struct md_cluster_info *cinfo = mddev->cluster_info;
-        add_resync_info(mddev, cinfo->bitmap_lockres, lo, hi);
-        /* Re-acquire the lock to refresh LVB */
-        dlm_lock_sync(cinfo->bitmap_lockres, DLM_LOCK_PW);
-}
 static int metadata_update_start(struct mddev *mddev)
 {
        return lock_comm(mddev->cluster_info);
@@ -817,59 +845,61 @@ static int metadata_update_finish(struct mddev *mddev)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
        struct cluster_msg cmsg;
-        int ret;
+        struct md_rdev *rdev;
+        int ret = 0;
        memset(&cmsg, 0, sizeof(cmsg));
        cmsg.type = cpu_to_le32(METADATA_UPDATED);
-        ret = __sendmsg(cinfo, &cmsg);
+        cmsg.raid_slot = -1;
+        /* Pick up a good active device number to send.
+         */
+        rdev_for_each(rdev, mddev)
+                if (rdev->raid_disk > -1 && !test_bit(Faulty, &rdev->flags)) {
+                        cmsg.raid_slot = cpu_to_le32(rdev->desc_nr);
+                        break;
+                }
+        if (cmsg.raid_slot >= 0)
+                ret = __sendmsg(cinfo, &cmsg);
+        else
+                pr_warn("md-cluster: No good device id found to send\n");
        unlock_comm(cinfo);
        return ret;
 }
-static int metadata_update_cancel(struct mddev *mddev)
+static void metadata_update_cancel(struct mddev *mddev)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
+        unlock_comm(cinfo);
+}
-        return dlm_unlock_sync(cinfo->token_lockres);
+static int resync_start(struct mddev *mddev)
+{
+        struct md_cluster_info *cinfo = mddev->cluster_info;
+        cinfo->resync_lockres->flags |= DLM_LKF_NOQUEUE;
+        return dlm_lock_sync(cinfo->resync_lockres, DLM_LOCK_EX);
 }
-static int resync_send(struct mddev *mddev, enum msg_type type,
+static int resync_info_update(struct mddev *mddev, sector_t lo, sector_t hi)
-                sector_t lo, sector_t hi)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
-        struct cluster_msg cmsg;
+        struct cluster_msg cmsg = {0};
-        int slot = cinfo->slot_number - 1;
-        pr_info("%s:%d lo: %llu hi: %llu\n", __func__, __LINE__,
+        add_resync_info(mddev, cinfo->bitmap_lockres, lo, hi);
-                        (unsigned long long)lo,
+        /* Re-acquire the lock to refresh LVB */
-                        (unsigned long long)hi);
+        dlm_lock_sync(cinfo->bitmap_lockres, DLM_LOCK_PW);
-        resync_info_update(mddev, lo, hi);
+        cmsg.type = cpu_to_le32(RESYNCING);
-        cmsg.type = cpu_to_le32(type);
-        cmsg.slot = cpu_to_le32(slot);
        cmsg.low = cpu_to_le64(lo);
        cmsg.high = cpu_to_le64(hi);
-        return sendmsg(cinfo, &cmsg);
-}
-static int resync_start(struct mddev *mddev, sector_t lo, sector_t hi)
+        return sendmsg(cinfo, &cmsg);
-{
-        pr_info("%s:%d\n", __func__, __LINE__);
-        return resync_send(mddev, RESYNCING, lo, hi);
 }
-static void resync_finish(struct mddev *mddev)
+static int resync_finish(struct mddev *mddev)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
-        struct cluster_msg cmsg;
+        cinfo->resync_lockres->flags &= ~DLM_LKF_NOQUEUE;
-        int slot = cinfo->slot_number - 1;
+        dlm_unlock_sync(cinfo->resync_lockres);
+        return resync_info_update(mddev, 0, 0);
-        pr_info("%s:%d\n", __func__, __LINE__);
-        resync_send(mddev, RESYNCING, 0, 0);
-        if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
-                cmsg.type = cpu_to_le32(BITMAP_NEEDS_SYNC);
-                cmsg.slot = cpu_to_le32(slot);
-                sendmsg(cinfo, &cmsg);
-        }
 }
 static int area_resyncing(struct mddev *mddev, int direction,
@@ -896,7 +926,11 @@ out:
        return ret;
 }
-static int add_new_disk_start(struct mddev *mddev, struct md_rdev *rdev)
+/* add_new_disk() - initiates a disk add
+ * However, if this fails before writing md_update_sb(),
+ * add_new_disk_cancel() must be called to release token lock
+ */
+static int add_new_disk(struct mddev *mddev, struct md_rdev *rdev)
 {
        struct md_cluster_info *cinfo = mddev->cluster_info;
        struct cluster_msg cmsg;
@@ -907,7 +941,7 @@ static int add_new_disk_start(struct mddev *mddev, struct md_rdev *rdev)
        memset(&cmsg, 0, sizeof(cmsg));
        cmsg.type = cpu_to_le32(NEWDISK);
        memcpy(cmsg.uuid, uuid, 16);
-        cmsg.raid_slot = rdev->desc_nr;
+        cmsg.raid_slot = cpu_to_le32(rdev->desc_nr);
        lock_comm(cinfo);
        ret = __sendmsg(cinfo, &cmsg);
        if (ret)
@@ -918,22 +952,17 @@ static int add_new_disk_start(struct mddev *mddev, struct md_rdev *rdev)
        /* Some node does not "see" the device */
        if (ret == -EAGAIN)
                ret = -ENOENT;
+        if (ret)
+                unlock_comm(cinfo);
        else
                dlm_lock_sync(cinfo->no_new_dev_lockres, DLM_LOCK_CR);
        return ret;
 }
-static int add_new_disk_finish(struct mddev *mddev)
+static void add_new_disk_cancel(struct mddev *mddev)
 {
-        struct cluster_msg cmsg;
        struct md_cluster_info *cinfo = mddev->cluster_info;
-        int ret;
-        /* Write sb and inform others */
-        md_update_sb(mddev, 1);
-        cmsg.type = METADATA_UPDATED;
-        ret = __sendmsg(cinfo, &cmsg);
        unlock_comm(cinfo);
-        return ret;
 }
 static int new_disk_ack(struct mddev *mddev, bool ack)
@@ -953,10 +982,10 @@ static int new_disk_ack(struct mddev *mddev, bool ack)
 static int remove_disk(struct mddev *mddev, struct md_rdev *rdev)
 {
-        struct cluster_msg cmsg;
+        struct cluster_msg cmsg = {0};
        struct md_cluster_info *cinfo = mddev->cluster_info;
-        cmsg.type = REMOVE;
+        cmsg.type = cpu_to_le32(REMOVE);
-        cmsg.raid_slot = rdev->desc_nr;
+        cmsg.raid_slot = cpu_to_le32(rdev->desc_nr);
        return __sendmsg(cinfo, &cmsg);
 }
@@ -964,12 +993,12 @@ static int gather_bitmaps(struct md_rdev *rdev)
 {
        int sn, err;
        sector_t lo, hi;
-        struct cluster_msg cmsg;
+        struct cluster_msg cmsg = {0};
        struct mddev *mddev = rdev->mddev;
        struct md_cluster_info *cinfo = mddev->cluster_info;
-        cmsg.type = RE_ADD;
+        cmsg.type = cpu_to_le32(RE_ADD);
-        cmsg.raid_slot = rdev->desc_nr;
+        cmsg.raid_slot = cpu_to_le32(rdev->desc_nr);
        err = sendmsg(cinfo, &cmsg);
        if (err)
                goto out;
@@ -993,15 +1022,15 @@ static struct md_cluster_operations cluster_ops = {
        .join   = join,
        .leave  = leave,
        .slot_number = slot_number,
-        .resync_info_update = resync_info_update,
        .resync_start = resync_start,
        .resync_finish = resync_finish,
+        .resync_info_update = resync_info_update,
        .metadata_update_start = metadata_update_start,
        .metadata_update_finish = metadata_update_finish,
        .metadata_update_cancel = metadata_update_cancel,
        .area_resyncing = area_resyncing,
-        .add_new_disk_start = add_new_disk_start,
+        .add_new_disk = add_new_disk,
-        .add_new_disk_finish = add_new_disk_finish,
+        .add_new_disk_cancel = add_new_disk_cancel,
        .new_disk_ack = new_disk_ack,
        .remove_disk = remove_disk,
        .gather_bitmaps = gather_bitmaps,
@@ -1022,5 +1051,6 @@ static void cluster_exit(void)
 module_init(cluster_init);
 module_exit(cluster_exit);
+MODULE_AUTHOR("SUSE");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Clustering support for MD");
diff --git a/drivers/md/md-cluster.h b/drivers/md/md-cluster.h
index 00defe2badbc..e75ea2613184 100644
--- a/drivers/md/md-cluster.h
+++ b/drivers/md/md-cluster.h
@@ -12,15 +12,15 @@ struct md_cluster_operations {
        int (*join)(struct mddev *mddev, int nodes);
        int (*leave)(struct mddev *mddev);
        int (*slot_number)(struct mddev *mddev);
-        void (*resync_info_update)(struct mddev *mddev, sector_t lo, sector_t hi);
+        int (*resync_info_update)(struct mddev *mddev, sector_t lo, sector_t hi);
-        int (*resync_start)(struct mddev *mddev, sector_t lo, sector_t hi);
-        void (*resync_finish)(struct mddev *mddev);
        int (*metadata_update_start)(struct mddev *mddev);
        int (*metadata_update_finish)(struct mddev *mddev);
-        int (*metadata_update_cancel)(struct mddev *mddev);
+        void (*metadata_update_cancel)(struct mddev *mddev);
+        int (*resync_start)(struct mddev *mddev);
+        int (*resync_finish)(struct mddev *mddev);
        int (*area_resyncing)(struct mddev *mddev, int direction, sector_t lo, sector_t hi);
-        int (*add_new_disk_start)(struct mddev *mddev, struct md_rdev *rdev);
+        int (*add_new_disk)(struct mddev *mddev, struct md_rdev *rdev);
-        int (*add_new_disk_finish)(struct mddev *mddev);
+        void (*add_new_disk_cancel)(struct mddev *mddev);
        int (*new_disk_ack)(struct mddev *mddev, bool ack);
        int (*remove_disk)(struct mddev *mddev, struct md_rdev *rdev);
        int (*gather_bitmaps)(struct md_rdev *rdev);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index c702de18207a..a71b36f0acb0 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1735,6 +1735,9 @@ static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
                }
        }
+        if (mddev_is_clustered(mddev))
+                sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
        if (rdev->badblocks.count == 0)
                /* Nothing to do for bad blocks*/ ;
        else if (sb->bblog_offset == 0)
@@ -2196,18 +2199,72 @@ static void sync_sbs(struct mddev *mddev, int nospares)
        }
 }
+static bool does_sb_need_changing(struct mddev *mddev)
+{
+        struct md_rdev *rdev;
+        struct mdp_superblock_1 *sb;
+        int role;
+        /* Find a good rdev */
+        rdev_for_each(rdev, mddev)
+                if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
+                        break;
+        /* No good device found. */
+        if (!rdev)
+                return false;
+        sb = page_address(rdev->sb_page);
+        /* Check if a device has become faulty or a spare become active */
+        rdev_for_each(rdev, mddev) {
+                role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
+                /* Device activated? */
+                if (role == 0xffff && rdev->raid_disk >=0 &&
+                    !test_bit(Faulty, &rdev->flags))
+                        return true;
+                /* Device turned faulty? */
+                if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
+                        return true;
+        }
+        /* Check if any mddev parameters have changed */
+        if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
+            (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
+            (mddev->recovery_cp != le64_to_cpu(sb->resync_offset)) ||
+            (mddev->layout != le64_to_cpu(sb->layout)) ||
+            (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
+            (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
+                return true;
+        return false;
+}
 void md_update_sb(struct mddev *mddev, int force_change)
 {
        struct md_rdev *rdev;
        int sync_req;
        int nospares = 0;
        int any_badblocks_changed = 0;
+        int ret = -1;
        if (mddev->ro) {
                if (force_change)
                        set_bit(MD_CHANGE_DEVS, &mddev->flags);
                return;
        }
+        if (mddev_is_clustered(mddev)) {
+                if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
+                        force_change = 1;
+                ret = md_cluster_ops->metadata_update_start(mddev);
+                /* Has someone else has updated the sb */
+                if (!does_sb_need_changing(mddev)) {
+                        if (ret == 0)
+                                md_cluster_ops->metadata_update_cancel(mddev);
+                        clear_bit(MD_CHANGE_PENDING, &mddev->flags);
+                        return;
+                }
+        }
 repeat:
        /* First make sure individual recovery_offsets are correct */
        rdev_for_each(rdev, mddev) {
@@ -2356,6 +2413,9 @@ repeat:
                clear_bit(BlockedBadBlocks, &rdev->flags);
                wake_up(&rdev->blocked_wait);
        }
+        if (mddev_is_clustered(mddev) && ret == 0)
+                md_cluster_ops->metadata_update_finish(mddev);
 }
 EXPORT_SYMBOL(md_update_sb);
@@ -2490,17 +2550,16 @@ state_store(struct md_rdev *rdev, const char *buf, size_t len)
                        err = -EBUSY;
                else {
                        struct mddev *mddev = rdev->mddev;
-                        if (mddev_is_clustered(mddev))
-                                md_cluster_ops->remove_disk(mddev, rdev);
-                        md_kick_rdev_from_array(rdev);
-                        if (mddev_is_clustered(mddev))
-                                md_cluster_ops->metadata_update_start(mddev);
-                        if (mddev->pers)
-                                md_update_sb(mddev, 1);
-                        md_new_event(mddev);
-                        if (mddev_is_clustered(mddev))
-                                md_cluster_ops->metadata_update_finish(mddev);
                        err = 0;
+                        if (mddev_is_clustered(mddev))
+                                err = md_cluster_ops->remove_disk(mddev, rdev);
+                        if (err == 0) {
+                                md_kick_rdev_from_array(rdev);
+                                if (mddev->pers)
+                                        md_update_sb(mddev, 1);
+                                md_new_event(mddev);
+                        }
                }
        } else if (cmd_match(buf, "writemostly")) {
                set_bit(WriteMostly, &rdev->flags);
@@ -2688,15 +2747,9 @@ slot_store(struct md_rdev *rdev, const char *buf, size_t len)
                        rdev->saved_raid_disk = -1;
                clear_bit(In_sync, &rdev->flags);
                clear_bit(Bitmap_sync, &rdev->flags);
-                err = rdev->mddev->pers->
+                remove_and_add_spares(rdev->mddev, rdev);
-                        hot_add_disk(rdev->mddev, rdev);
+                if (rdev->raid_disk == -1)
-                if (err) {
+                        return -EBUSY;
-                        rdev->raid_disk = -1;
-                        return err;
-                } else
-                        sysfs_notify_dirent_safe(rdev->sysfs_state);
-                if (sysfs_link_rdev(rdev->mddev, rdev))
-                        /* failure here is OK */;
                /* don't wakeup anyone, leave that to userspace. */
        } else {
                if (slot >= rdev->mddev->raid_disks &&
@@ -3198,14 +3251,6 @@ static void analyze_sbs(struct mddev *mddev)
                                md_kick_rdev_from_array(rdev);
                                continue;
                        }
-                        /* No device should have a Candidate flag
-                         * when reading devices
-                         */
-                        if (test_bit(Candidate, &rdev->flags)) {
-                                pr_info("md: kicking Cluster Candidate %s from array!\n",
-                                        bdevname(rdev->bdev, b));
-                                md_kick_rdev_from_array(rdev);
-                        }
                }
                if (mddev->level == LEVEL_MULTIPATH) {
                        rdev->desc_nr = i++;
@@ -4066,12 +4111,8 @@ size_store(struct mddev *mddev, const char *buf, size_t len)
        if (err)
                return err;
        if (mddev->pers) {
-                if (mddev_is_clustered(mddev))
-                        md_cluster_ops->metadata_update_start(mddev);
                err = update_size(mddev, sectors);
                md_update_sb(mddev, 1);
-                if (mddev_is_clustered(mddev))
-                        md_cluster_ops->metadata_update_finish(mddev);
        } else {
                if (mddev->dev_sectors == 0 ||
                    mddev->dev_sectors > sectors)
@@ -5309,8 +5350,6 @@ static void md_clean(struct mddev *mddev)
 static void __md_stop_writes(struct mddev *mddev)
 {
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_start(mddev);
        set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
        flush_workqueue(md_misc_wq);
        if (mddev->sync_thread) {
@@ -5329,8 +5368,6 @@ static void __md_stop_writes(struct mddev *mddev)
                mddev->in_sync = 1;
                md_update_sb(mddev, 1);
        }
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_finish(mddev);
 }
 void md_stop_writes(struct mddev *mddev)
@@ -5910,19 +5947,12 @@ static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
                 * check whether the device shows up in other nodes
                 */
                if (mddev_is_clustered(mddev)) {
-                        if (info->state & (1 << MD_DISK_CANDIDATE)) {
+                        if (info->state & (1 << MD_DISK_CANDIDATE))
-                                /* Through --cluster-confirm */
                                set_bit(Candidate, &rdev->flags);
-                                err = md_cluster_ops->new_disk_ack(mddev, true);
+                        else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
-                                if (err) {
-                                        export_rdev(rdev);
-                                        return err;
-                                }
-                        } else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
                                /* --add initiated by this node */
-                                err = md_cluster_ops->add_new_disk_start(mddev, rdev);
+                                err = md_cluster_ops->add_new_disk(mddev, rdev);
                                if (err) {
-                                        md_cluster_ops->add_new_disk_finish(mddev);
                                        export_rdev(rdev);
                                        return err;
                                }
@@ -5931,13 +5961,23 @@ static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
                rdev->raid_disk = -1;
                err = bind_rdev_to_array(rdev, mddev);
                if (err)
                        export_rdev(rdev);
-                else
+                if (mddev_is_clustered(mddev)) {
+                        if (info->state & (1 << MD_DISK_CANDIDATE))
+                                md_cluster_ops->new_disk_ack(mddev, (err == 0));
+                        else {
+                                if (err)
+                                        md_cluster_ops->add_new_disk_cancel(mddev);
+                                else
+                                        err = add_bound_rdev(rdev);
+                        }
+                } else if (!err)
                        err = add_bound_rdev(rdev);
-                if (mddev_is_clustered(mddev) &&
-                                (info->state & (1 << MD_DISK_CLUSTER_ADD)))
-                        md_cluster_ops->add_new_disk_finish(mddev);
                return err;
        }
@@ -5993,13 +6033,17 @@ static int hot_remove_disk(struct mddev *mddev, dev_t dev)
 {
        char b[BDEVNAME_SIZE];
        struct md_rdev *rdev;
+        int ret = -1;
        rdev = find_rdev(mddev, dev);
        if (!rdev)
                return -ENXIO;
        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_start(mddev);
+                ret = md_cluster_ops->metadata_update_start(mddev);
+        if (rdev->raid_disk < 0)
+                goto kick_rdev;
        clear_bit(Blocked, &rdev->flags);
        remove_and_add_spares(mddev, rdev);
@@ -6007,20 +6051,19 @@ static int hot_remove_disk(struct mddev *mddev, dev_t dev)
        if (rdev->raid_disk >= 0)
                goto busy;
-        if (mddev_is_clustered(mddev))
+kick_rdev:
+        if (mddev_is_clustered(mddev) && ret == 0)
                md_cluster_ops->remove_disk(mddev, rdev);
        md_kick_rdev_from_array(rdev);
        md_update_sb(mddev, 1);
        md_new_event(mddev);
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_finish(mddev);
        return 0;
 busy:
-        if (mddev_is_clustered(mddev))
+        if (mddev_is_clustered(mddev) && ret == 0)
                md_cluster_ops->metadata_update_cancel(mddev);
        printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
                bdevname(rdev->bdev,b), mdname(mddev));
        return -EBUSY;
@@ -6071,14 +6114,12 @@ static int hot_add_disk(struct mddev *mddev, dev_t dev)
                goto abort_export;
        }
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_start(mddev);
        clear_bit(In_sync, &rdev->flags);
        rdev->desc_nr = -1;
        rdev->saved_raid_disk = -1;
        err = bind_rdev_to_array(rdev, mddev);
        if (err)
-                goto abort_clustered;
+                goto abort_export;
        /*
         * The rest should better be atomic, we can have disk failures
@@ -6088,9 +6129,6 @@ static int hot_add_disk(struct mddev *mddev, dev_t dev)
        rdev->raid_disk = -1;
        md_update_sb(mddev, 1);
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_finish(mddev);
        /*
         * Kick recovery, maybe this spare has to be added to the
         * array immediately.
@@ -6100,9 +6138,6 @@ static int hot_add_disk(struct mddev *mddev, dev_t dev)
        md_new_event(mddev);
        return 0;
-abort_clustered:
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_cancel(mddev);
 abort_export:
        export_rdev(rdev);
        return err;
@@ -6420,8 +6455,6 @@ static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
                        return rv;
                }
        }
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_start(mddev);
        if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
                rv = update_size(mddev, (sector_t)info->size * 2);
@@ -6479,12 +6512,8 @@ static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
                }
        }
        md_update_sb(mddev, 1);
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_finish(mddev);
        return rv;
 err:
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_cancel(mddev);
        return rv;
 }
@@ -7597,11 +7626,7 @@ int md_allow_write(struct mddev *mddev)
                    mddev->safemode == 0)
                        mddev->safemode = 1;
                spin_unlock(&mddev->lock);
-                if (mddev_is_clustered(mddev))
-                        md_cluster_ops->metadata_update_start(mddev);
                md_update_sb(mddev, 0);
-                if (mddev_is_clustered(mddev))
-                        md_cluster_ops->metadata_update_finish(mddev);
                sysfs_notify_dirent_safe(mddev->sysfs_state);
        } else
                spin_unlock(&mddev->lock);
@@ -7633,6 +7658,7 @@ void md_do_sync(struct md_thread *thread)
        struct md_rdev *rdev;
        char *desc, *action = NULL;
        struct blk_plug plug;
+        bool cluster_resync_finished = false;
        /* just incase thread restarts... */
        if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
@@ -7802,9 +7828,6 @@ void md_do_sync(struct md_thread *thread)
        md_new_event(mddev);
        update_time = jiffies;
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->resync_start(mddev, j, max_sectors);
        blk_start_plug(&plug);
        while (j < max_sectors) {
                sector_t sectors;
@@ -7868,8 +7891,6 @@ void md_do_sync(struct md_thread *thread)
                        j = max_sectors;
                if (j > 2)
                        mddev->curr_resync = j;
-                if (mddev_is_clustered(mddev))
-                        md_cluster_ops->resync_info_update(mddev, j, max_sectors);
                mddev->curr_mark_cnt = io_sectors;
                if (last_check == 0)
                        /* this is the earliest that rebuild will be
@@ -7940,7 +7961,11 @@ void md_do_sync(struct md_thread *thread)
                mddev->curr_resync_completed = mddev->curr_resync;
                sysfs_notify(&mddev->kobj, NULL, "sync_completed");
        }
-        /* tell personality that we are finished */
+        /* tell personality and other nodes that we are finished */
+        if (mddev_is_clustered(mddev)) {
+                md_cluster_ops->resync_finish(mddev);
+                cluster_resync_finished = true;
+        }
        mddev->pers->sync_request(mddev, max_sectors, &skipped);
        if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
@@ -7976,11 +8001,13 @@ void md_do_sync(struct md_thread *thread)
                }
        }
 skip:
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->resync_finish(mddev);
        set_bit(MD_CHANGE_DEVS, &mddev->flags);
+        if (mddev_is_clustered(mddev) &&
+            test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
+            !cluster_resync_finished)
+                md_cluster_ops->resync_finish(mddev);
        spin_lock(&mddev->lock);
        if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
                /* We completed so min/max setting can be forgotten if used. */
@@ -8023,10 +8050,14 @@ static int remove_and_add_spares(struct mddev *mddev,
        if (removed && mddev->kobj.sd)
                sysfs_notify(&mddev->kobj, NULL, "degraded");
-        if (this)
+        if (this && removed)
                goto no_add;
        rdev_for_each(rdev, mddev) {
+                if (this && this != rdev)
+                        continue;
+                if (test_bit(Candidate, &rdev->flags))
+                        continue;
                if (rdev->raid_disk >= 0 &&
                    !test_bit(In_sync, &rdev->flags) &&
                    !test_bit(Faulty, &rdev->flags))
@@ -8060,14 +8091,25 @@ no_add:
 static void md_start_sync(struct work_struct *ws)
 {
        struct mddev *mddev = container_of(ws, struct mddev, del_work);
+        int ret = 0;
+        if (mddev_is_clustered(mddev)) {
+                ret = md_cluster_ops->resync_start(mddev);
+                if (ret) {
+                        mddev->sync_thread = NULL;
+                        goto out;
+                }
+        }
        mddev->sync_thread = md_register_thread(md_do_sync,
                                                mddev,
                                                "resync");
+out:
        if (!mddev->sync_thread) {
-                printk(KERN_ERR "%s: could not start resync"
+                if (!(mddev_is_clustered(mddev) && ret == -EAGAIN))
-                       " thread...\n",
+                        printk(KERN_ERR "%s: could not start resync"
-                       mdname(mddev));
+                               " thread...\n",
+                               mdname(mddev));
                /* leave the spares where they are, it shouldn't hurt */
                clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
                clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
@@ -8186,13 +8228,8 @@ void md_check_recovery(struct mddev *mddev)
                                sysfs_notify_dirent_safe(mddev->sysfs_state);
                }
-                if (mddev->flags & MD_UPDATE_SB_FLAGS) {
+                if (mddev->flags & MD_UPDATE_SB_FLAGS)
-                        if (mddev_is_clustered(mddev))
-                                md_cluster_ops->metadata_update_start(mddev);
                        md_update_sb(mddev, 0);
-                        if (mddev_is_clustered(mddev))
-                                md_cluster_ops->metadata_update_finish(mddev);
-                }
                if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
                    !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
@@ -8290,8 +8327,6 @@ void md_reap_sync_thread(struct mddev *mddev)
                        set_bit(MD_CHANGE_DEVS, &mddev->flags);
                }
        }
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_start(mddev);
        if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
            mddev->pers->finish_reshape)
                mddev->pers->finish_reshape(mddev);
@@ -8304,8 +8339,6 @@ void md_reap_sync_thread(struct mddev *mddev)
                        rdev->saved_raid_disk = -1;
        md_update_sb(mddev, 1);
-        if (mddev_is_clustered(mddev))
-                md_cluster_ops->metadata_update_finish(mddev);
        clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
        clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
        clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
@@ -8928,25 +8961,129 @@ err_wq:
        return ret;
 }
-void md_reload_sb(struct mddev *mddev)
+static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
 {
-        struct md_rdev *rdev, *tmp;
+        struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
+        struct md_rdev *rdev2;
+        int role, ret;
+        char b[BDEVNAME_SIZE];
-        rdev_for_each_safe(rdev, tmp, mddev) {
+        /* Check for change of roles in the active devices */
-                rdev->sb_loaded = 0;
+        rdev_for_each(rdev2, mddev) {
-                ClearPageUptodate(rdev->sb_page);
+                if (test_bit(Faulty, &rdev2->flags))
+                        continue;
+                /* Check if the roles changed */
+                role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
+                if (test_bit(Candidate, &rdev2->flags)) {
+                        if (role == 0xfffe) {
+                                pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
+                                md_kick_rdev_from_array(rdev2);
+                                continue;
+                        }
+                        else
+                                clear_bit(Candidate, &rdev2->flags);
+                }
+                if (role != rdev2->raid_disk) {
+                        /* got activated */
+                        if (rdev2->raid_disk == -1 && role != 0xffff) {
+                                rdev2->saved_raid_disk = role;
+                                ret = remove_and_add_spares(mddev, rdev2);
+                                pr_info("Activated spare: %s\n",
+                                                bdevname(rdev2->bdev,b));
+                                continue;
+                        }
+                        /* device faulty
+                         * We just want to do the minimum to mark the disk
+                         * as faulty. The recovery is performed by the
+                         * one who initiated the error.
+                         */
+                        if ((role == 0xfffe) || (role == 0xfffd)) {
+                                md_error(mddev, rdev2);
+                                clear_bit(Blocked, &rdev2->flags);
+                        }
+                }
        }
-        mddev->raid_disks = 0;
-        analyze_sbs(mddev);
+        /* recovery_cp changed */
-        rdev_for_each_safe(rdev, tmp, mddev) {
+        if (le64_to_cpu(sb->resync_offset) != mddev->recovery_cp)
-                struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
+                mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
-                /* since we don't write to faulty devices, we figure out if the
-                 *  disk is faulty by comparing events
+        /* Finally set the event to be up to date */
-                 */
+        mddev->events = le64_to_cpu(sb->events);
-                if (mddev->events > sb->events)
+}
-                        set_bit(Faulty, &rdev->flags);
+static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
+{
+        int err;
+        struct page *swapout = rdev->sb_page;
+        struct mdp_superblock_1 *sb;
+        /* Store the sb page of the rdev in the swapout temporary
+         * variable in case we err in the future
+         */
+        rdev->sb_page = NULL;
+        alloc_disk_sb(rdev);
+        ClearPageUptodate(rdev->sb_page);
+        rdev->sb_loaded = 0;
+        err = super_types[mddev->major_version].load_super(rdev, NULL, mddev->minor_version);
+        if (err < 0) {
+                pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
+                                __func__, __LINE__, rdev->desc_nr, err);
+                put_page(rdev->sb_page);
+                rdev->sb_page = swapout;
+                rdev->sb_loaded = 1;
+                return err;
+        }
+        sb = page_address(rdev->sb_page);
+        /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
+         * is not set
+         */
+        if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
+                rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
+        /* The other node finished recovery, call spare_active to set
+         * device In_sync and mddev->degraded
+         */
+        if (rdev->recovery_offset == MaxSector &&
+            !test_bit(In_sync, &rdev->flags) &&
+            mddev->pers->spare_active(mddev))
+                sysfs_notify(&mddev->kobj, NULL, "degraded");
+        put_page(swapout);
+        return 0;
+}
+void md_reload_sb(struct mddev *mddev, int nr)
+{
+        struct md_rdev *rdev;
+        int err;
+        /* Find the rdev */
+        rdev_for_each_rcu(rdev, mddev) {
+                if (rdev->desc_nr == nr)
+                        break;
+        }
+        if (!rdev || rdev->desc_nr != nr) {
+                pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
+                return;
        }
+        err = read_rdev(mddev, rdev);
+        if (err < 0)
+                return;
+        check_sb_changes(mddev, rdev);
+        /* Read all rdev's to update recovery_offset */
+        rdev_for_each_rcu(rdev, mddev)
+                read_rdev(mddev, rdev);
 }
 EXPORT_SYMBOL(md_reload_sb);
diff --git a/drivers/md/md.h b/drivers/md/md.h
index ab339571e57f..2ea00356bb23 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -658,7 +658,7 @@ extern struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
                                   struct mddev *mddev);
 extern void md_unplug(struct blk_plug_cb *cb, bool from_schedule);
-extern void md_reload_sb(struct mddev *mddev);
+extern void md_reload_sb(struct mddev *mddev, int raid_disk);
 extern void md_update_sb(struct mddev *mddev, int force);
 extern void md_kick_rdev_from_array(struct md_rdev * rdev);
 struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index ddd8a5f572aa..ce2d797f8787 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -90,6 +90,8 @@ static void r1bio_pool_free(void *r1_bio, void *data)
 #define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
 #define RESYNC_WINDOW (RESYNC_BLOCK_SIZE * RESYNC_DEPTH)
 #define RESYNC_WINDOW_SECTORS (RESYNC_WINDOW >> 9)
+#define CLUSTER_RESYNC_WINDOW (16 * RESYNC_WINDOW)
+#define CLUSTER_RESYNC_WINDOW_SECTORS (CLUSTER_RESYNC_WINDOW >> 9)
 #define NEXT_NORMALIO_DISTANCE (3 * RESYNC_WINDOW_SECTORS)
 static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
@@ -1590,6 +1592,15 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
        if (rdev->raid_disk >= 0)
                first = last = rdev->raid_disk;
+        /*
+         * find the disk ... but prefer rdev->saved_raid_disk
+         * if possible.
+         */
+        if (rdev->saved_raid_disk >= 0 &&
+            rdev->saved_raid_disk >= first &&
+            conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
+                first = last = rdev->saved_raid_disk;
        for (mirror = first; mirror <= last; mirror++) {
                p = conf->mirrors+mirror;
                if (!p->rdev) {
@@ -2488,6 +2499,11 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
                bitmap_close_sync(mddev->bitmap);
                close_sync(conf);
+                if (mddev_is_clustered(mddev)) {
+                        conf->cluster_sync_low = 0;
+                        conf->cluster_sync_high = 0;
+                }
                return 0;
        }
@@ -2508,7 +2524,12 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
                return sync_blocks;
        }
-        bitmap_cond_end_sync(mddev->bitmap, sector_nr);
+        /* we are incrementing sector_nr below. To be safe, we check against
+         * sector_nr + two times RESYNC_SECTORS
+         */
+        bitmap_cond_end_sync(mddev->bitmap, sector_nr,
+                mddev_is_clustered(mddev) && (sector_nr + 2 * RESYNC_SECTORS > conf->cluster_sync_high));
        r1_bio = mempool_alloc(conf->r1buf_pool, GFP_NOIO);
        raise_barrier(conf, sector_nr);
@@ -2699,6 +2720,16 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
 bio_full:
        r1_bio->sectors = nr_sectors;
+        if (mddev_is_clustered(mddev) &&
+                        conf->cluster_sync_high < sector_nr + nr_sectors) {
+                conf->cluster_sync_low = mddev->curr_resync_completed;
+                conf->cluster_sync_high = conf->cluster_sync_low + CLUSTER_RESYNC_WINDOW_SECTORS;
+                /* Send resync message */
+                md_cluster_ops->resync_info_update(mddev,
+                                conf->cluster_sync_low,
+                                conf->cluster_sync_high);
+        }
        /* For a user-requested sync, we read all readable devices and do a
         * compare
         */
diff --git a/drivers/md/raid1.h b/drivers/md/raid1.h
index c52d7139c5d7..61c39b390cd8 100644
--- a/drivers/md/raid1.h
+++ b/drivers/md/raid1.h
@@ -111,6 +111,13 @@ struct r1conf {
         * the new thread here until we fully activate the array.
         */
        struct md_thread        *thread;
+        /* Keep track of cluster resync window to send to other
+         * nodes.
+         */
+        sector_t                cluster_sync_low;
+        sector_t                cluster_sync_high;
 };
 /*
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 9f69dc526f8c..e0983c30e73b 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -3137,7 +3137,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                /* resync. Schedule a read for every block at this virt offset */
                int count = 0;
-                bitmap_cond_end_sync(mddev->bitmap, sector_nr);
+                bitmap_cond_end_sync(mddev->bitmap, sector_nr, 0);
                if (!bitmap_start_sync(mddev->bitmap, sector_nr,
                                       &sync_blocks, mddev->degraded) &&
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 49bb8d3ff9be..5b79770c4f08 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -5613,7 +5613,7 @@ static inline sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int
                return sync_blocks * STRIPE_SECTORS; /* keep things rounded to whole stripes */
        }
-        bitmap_cond_end_sync(mddev->bitmap, sector_nr);
+        bitmap_cond_end_sync(mddev->bitmap, sector_nr, false);
        sh = get_active_stripe(conf, sector_nr, 0, 1, 0);
        if (sh == NULL) {
diff --git a/include/uapi/linux/raid/md_p.h b/include/uapi/linux/raid/md_p.h
index 2ae6131e69a5..867ee874fa80 100644
--- a/include/uapi/linux/raid/md_p.h
+++ b/include/uapi/linux/raid/md_p.h
@@ -302,6 +302,7 @@ struct mdp_superblock_1 {
 #define MD_FEATURE_RECOVERY_BITMAP      128 /* recovery that is happening
                                             * is guided by bitmap.
                                             */
+#define MD_FEATURE_CLUSTERED            256 /* clustered MD */
 #define MD_FEATURE_ALL                  (MD_FEATURE_BITMAP_OFFSET       \
                                        |MD_FEATURE_RECOVERY_OFFSET     \
                                        |MD_FEATURE_RESHAPE_ACTIVE      \
@@ -310,6 +311,7 @@ struct mdp_superblock_1 {
                                        |MD_FEATURE_RESHAPE_BACKWARDS   \
                                        |MD_FEATURE_NEW_OFFSET          \
                                        |MD_FEATURE_RECOVERY_BITMAP     \
+                                        |MD_FEATURE_CLUSTERED           \
                                        )
 #endif
author	NeilBrown <neilb@suse.com>	2015-10-13 16:09:52 -0400
committer	NeilBrown <neilb@suse.com>	2015-10-13 16:09:52 -0400
commit	c2a06c38d92d044a69a3eae0138ab95ff0788030 (patch)
tree	e193af1aaf9ea876dedf6db38ded53f8d7a7f9b4
parent	25cb62b76430a91cc6195f902e61c2cb84ade622 (diff)
parent	23b63f9fa82eed128b5c585cbfe10ced82d73e91 (diff)