md: fix clearing of 'blocked' flag in the presence of bad blocks.

[deliverable/linux.git] / drivers / md / md.c

diff --git a/drivers/md/md.c b/drivers/md/md.c
index d97a6253479809bc99dba19425530caa8620b49b..3742ce8b0acf6b70cf119bc412654c94ec0aa165 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -848,7 +848,7 @@ void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
        bio->bi_end_io = super_written;
 
        atomic_inc(&mddev->pending_writes);
-       submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio);
+       submit_bio(WRITE_FLUSH_FUA, bio);
 }
 
 void md_super_wait(mddev_t *mddev)
@@ -1738,6 +1738,11 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
        sb->level = cpu_to_le32(mddev->level);
        sb->layout = cpu_to_le32(mddev->layout);
 
+       if (test_bit(WriteMostly, &rdev->flags))
+               sb->devflags |= WriteMostly1;
+       else
+               sb->devflags &= ~WriteMostly1;
+
        if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
                sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
                sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
@@ -2561,7 +2566,10 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
        int err = -EINVAL;
        if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
                md_error(rdev->mddev, rdev);
-               err = 0;
+               if (test_bit(Faulty, &rdev->flags))
+                       err = 0;
+               else
+                       err = -EBUSY;
        } else if (cmd_match(buf, "remove")) {
                if (rdev->raid_disk >= 0)
                        err = -EBUSY;
@@ -2584,7 +2592,7 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                err = 0;
        } else if (cmd_match(buf, "-blocked")) {
                if (!test_bit(Faulty, &rdev->flags) &&
-                   test_bit(BlockedBadBlocks, &rdev->flags)) {
+                   rdev->badblocks.unacked_exist) {
                        /* metadata handler doesn't understand badblocks,
                         * so we need to fail the device
                         */
@@ -5983,6 +5991,8 @@ static int set_disk_faulty(mddev_t *mddev, dev_t dev)
                return -ENODEV;
 
        md_error(mddev, rdev);
+       if (!test_bit(Faulty, &rdev->flags))
+               return -EBUSY;
        return 0;
 }
 
@@ -6616,16 +6626,11 @@ static void md_seq_stop(struct seq_file *seq, void *v)
                mddev_put(mddev);
 }
 
-struct mdstat_info {
-       int event;
-};
-
 static int md_seq_show(struct seq_file *seq, void *v)
 {
        mddev_t *mddev = v;
        sector_t sectors;
        mdk_rdev_t *rdev;
-       struct mdstat_info *mi = seq->private;
        struct bitmap *bitmap;
 
        if (v == (void*)1) {
@@ -6637,7 +6642,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
 
                spin_unlock(&pers_lock);
                seq_printf(seq, "\n");
-               mi->event = atomic_read(&md_event_count);
+               seq->poll_event = atomic_read(&md_event_count);
                return 0;
        }
        if (v == (void*)2) {
@@ -6749,26 +6754,21 @@ static const struct seq_operations md_seq_ops = {
 
 static int md_seq_open(struct inode *inode, struct file *file)
 {
+       struct seq_file *seq;
        int error;
-       struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
-       if (mi == NULL)
-               return -ENOMEM;
 
        error = seq_open(file, &md_seq_ops);
        if (error)
-               kfree(mi);
-       else {
-               struct seq_file *p = file->private_data;
-               p->private = mi;
-               mi->event = atomic_read(&md_event_count);
-       }
+               return error;
+
+       seq = file->private_data;
+       seq->poll_event = atomic_read(&md_event_count);
        return error;
 }
 
 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
 {
-       struct seq_file *m = filp->private_data;
-       struct mdstat_info *mi = m->private;
+       struct seq_file *seq = filp->private_data;
        int mask;
 
        poll_wait(filp, &md_event_waiters, wait);
@@ -6776,7 +6776,7 @@ static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
        /* always allow read */
        mask = POLLIN | POLLRDNORM;
 
-       if (mi->event != atomic_read(&md_event_count))
+       if (seq->poll_event != atomic_read(&md_event_count))
                mask |= POLLERR | POLLPRI;
        return mask;
 }