1 files changed, 39 insertions, 15 deletions

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index b26927ce889c..621a272a2c74 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -225,7 +225,7 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
                     || test_bit(Faulty, &rdev->flags))
                         continue;
 
-                target = (rdev->sb_offset << 1) + offset + index * (PAGE_SIZE/512);
+                target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
 
                 if (sync_page_io(rdev->bdev, target, PAGE_SIZE, page, READ)) {
                         page->index = index;
@@ -241,10 +241,10 @@ static struct page *read_sb_page(mddev_t *mddev, long offset, unsigned long inde
 static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
 {
         mdk_rdev_t *rdev;
-        struct list_head *tmp;
         mddev_t *mddev = bitmap->mddev;
 
-        rdev_for_each(rdev, tmp, mddev)
+        rcu_read_lock();
+        rdev_for_each_rcu(rdev, mddev)
                 if (test_bit(In_sync, &rdev->flags)
                     && !test_bit(Faulty, &rdev->flags)) {
                         int size = PAGE_SIZE;
@@ -260,32 +260,37 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                                     + (long)(page->index * (PAGE_SIZE/512))
                                     + size/512 > 0)
                                         /* bitmap runs in to metadata */
-                                        return -EINVAL;
+                                        goto bad_alignment;
                                 if (rdev->data_offset + mddev->size*2
-                                    > rdev->sb_offset*2 + bitmap->offset)
+                                    > rdev->sb_start + bitmap->offset)
                                         /* data runs in to bitmap */
-                                        return -EINVAL;
-                        } else if (rdev->sb_offset*2 < rdev->data_offset) {
+                                        goto bad_alignment;
+                        } else if (rdev->sb_start < rdev->data_offset) {
                                 /* METADATA BITMAP DATA */
-                                if (rdev->sb_offset*2
+                                if (rdev->sb_start
                                     + bitmap->offset
                                     + page->index*(PAGE_SIZE/512) + size/512
                                     > rdev->data_offset)
                                         /* bitmap runs in to data */
-                                        return -EINVAL;
+                                        goto bad_alignment;
                         } else {
                                 /* DATA METADATA BITMAP - no problems */
                         }
                         md_super_write(mddev, rdev,
-                                       (rdev->sb_offset<<1) + bitmap->offset
+                                       rdev->sb_start + bitmap->offset
                                        + page->index * (PAGE_SIZE/512),
                                        size,
                                        page);
                 }
+        rcu_read_unlock();
 
         if (wait)
                 md_super_wait(mddev);
         return 0;
+
+ bad_alignment:
+        rcu_read_unlock();
+        return -EINVAL;
 }
 
 static void bitmap_file_kick(struct bitmap *bitmap);
@@ -454,8 +459,11 @@ void bitmap_update_sb(struct bitmap *bitmap)
         spin_unlock_irqrestore(&bitmap->lock, flags);
         sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
         sb->events = cpu_to_le64(bitmap->mddev->events);
-        if (!bitmap->mddev->degraded)
-                sb->events_cleared = cpu_to_le64(bitmap->mddev->events);
+        if (bitmap->mddev->events < bitmap->events_cleared) {
+                /* rocking back to read-only */
+                bitmap->events_cleared = bitmap->mddev->events;
+                sb->events_cleared = cpu_to_le64(bitmap->events_cleared);
+        }
         kunmap_atomic(sb, KM_USER0);
         write_page(bitmap, bitmap->sb_page, 1);
 }
@@ -1085,9 +1093,19 @@ void bitmap_daemon_work(struct bitmap *bitmap)
                         } else
                                 spin_unlock_irqrestore(&bitmap->lock, flags);
                         lastpage = page;
-/*
-                        printk("bitmap clean at page %lu\n", j);
-*/
+
+                        /* We are possibly going to clear some bits, so make
+                         * sure that events_cleared is up-to-date.
+                         */
+                        if (bitmap->need_sync) {
+                                bitmap_super_t *sb;
+                                bitmap->need_sync = 0;
+                                sb = kmap_atomic(bitmap->sb_page, KM_USER0);
+                                sb->events_cleared =
+                                        cpu_to_le64(bitmap->events_cleared);
+                                kunmap_atomic(sb, KM_USER0);
+                                write_page(bitmap, bitmap->sb_page, 1);
+                        }
                         spin_lock_irqsave(&bitmap->lock, flags);
                         clear_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
                 }
@@ -1257,6 +1275,12 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto
                         return;
                 }
 
+                if (success &&
+                    bitmap->events_cleared < bitmap->mddev->events) {
+                        bitmap->events_cleared = bitmap->mddev->events;
+                        bitmap->need_sync = 1;
+                }
+
                 if (!success && ! (*bmc & NEEDED_MASK))
                         *bmc |= NEEDED_MASK;