13 files changed, 51 insertions, 151 deletions

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index f8a9f7ab2cb8..1fb91edc7de2 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -1479,6 +1479,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
                 s += blocks;
         }
         bitmap->last_end_sync = jiffies;
+        sysfs_notify(&bitmap->mddev->kobj, NULL, "sync_completed");
 }
 
 static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)
@@ -1589,7 +1590,7 @@ void bitmap_destroy(mddev_t *mddev)
 int bitmap_create(mddev_t *mddev)
 {
         struct bitmap *bitmap;
-        unsigned long blocks = mddev->resync_max_sectors;
+        sector_t blocks = mddev->resync_max_sectors;
         unsigned long chunks;
         unsigned long pages;
         struct file *file = mddev->bitmap_file;
@@ -1631,8 +1632,8 @@ int bitmap_create(mddev_t *mddev)
         bitmap->chunkshift = ffz(~bitmap->chunksize);
 
         /* now that chunksize and chunkshift are set, we can use these macros */
-        chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) /
-                        CHUNK_BLOCK_RATIO(bitmap);
+        chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
+                        CHUNK_BLOCK_SHIFT(bitmap);
         pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
 
         BUG_ON(!pages);
diff --git a/drivers/md/dm-bio-list.h b/drivers/md/dm-bio-list.h
deleted file mode 100644
index 345098b4ca77..000000000000
--- a/drivers/md/dm-bio-list.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (C) 2004 Red Hat UK Ltd.
- *
- * This file is released under the GPL.
- */
-
-#ifndef DM_BIO_LIST_H
-#define DM_BIO_LIST_H
-
-#include <linux/bio.h>
-
-#ifdef CONFIG_BLOCK
-
-struct bio_list {
-        struct bio *head;
-        struct bio *tail;
-};
-
-static inline int bio_list_empty(const struct bio_list *bl)
-{
-        return bl->head == NULL;
-}
-
-static inline void bio_list_init(struct bio_list *bl)
-{
-        bl->head = bl->tail = NULL;
-}
-
-#define bio_list_for_each(bio, bl) \
-        for (bio = (bl)->head; bio; bio = bio->bi_next)
-
-static inline unsigned bio_list_size(const struct bio_list *bl)
-{
-        unsigned sz = 0;
-        struct bio *bio;
-
-        bio_list_for_each(bio, bl)
-                sz++;
-
-        return sz;
-}
-
-static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
-{
-        bio->bi_next = NULL;
-
-        if (bl->tail)
-                bl->tail->bi_next = bio;
-        else
-                bl->head = bio;
-
-        bl->tail = bio;
-}
-
-static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
-{
-        bio->bi_next = bl->head;
-
-        bl->head = bio;
-
-        if (!bl->tail)
-                bl->tail = bio;
-}
-
-static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
-{
-        if (!bl2->head)
-                return;
-
-        if (bl->tail)
-                bl->tail->bi_next = bl2->head;
-        else
-                bl->head = bl2->head;
-
-        bl->tail = bl2->tail;
-}
-
-static inline void bio_list_merge_head(struct bio_list *bl,
-                                       struct bio_list *bl2)
-{
-        if (!bl2->head)
-                return;
-
-        if (bl->head)
-                bl2->tail->bi_next = bl->head;
-        else
-                bl->tail = bl2->tail;
-
-        bl->head = bl2->head;
-}
-
-static inline struct bio *bio_list_pop(struct bio_list *bl)
-{
-        struct bio *bio = bl->head;
-
-        if (bio) {
-                bl->head = bl->head->bi_next;
-                if (!bl->head)
-                        bl->tail = NULL;
-
-                bio->bi_next = NULL;
-        }
-
-        return bio;
-}
-
-static inline struct bio *bio_list_get(struct bio_list *bl)
-{
-        struct bio *bio = bl->head;
-
-        bl->head = bl->tail = NULL;
-
-        return bio;
-}
-
-#endif /* CONFIG_BLOCK */
-#endif
diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
index 59ee1b015d2d..559dbb52bc85 100644
--- a/drivers/md/dm-delay.c
+++ b/drivers/md/dm-delay.c
@@ -15,8 +15,6 @@
 
 #include <linux/device-mapper.h>
 
-#include "dm-bio-list.h"
-
 #define DM_MSG_PREFIX "delay"
 
 struct delay_c {
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 095f77bf9681..6a386ab4f7eb 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -8,7 +8,6 @@
 #include <linux/device-mapper.h>
 
 #include "dm-path-selector.h"
-#include "dm-bio-list.h"
 #include "dm-bio-record.h"
 #include "dm-uevent.h"
 
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 536ef0bef154..076fbb4e967a 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -5,7 +5,6 @@
  * This file is released under the GPL.
  */
 
-#include "dm-bio-list.h"
 #include "dm-bio-record.h"
 
 #include <linux/init.h>
diff --git a/drivers/md/dm-region-hash.c b/drivers/md/dm-region-hash.c
index 59f8d9df9e1a..7b899be0b087 100644
--- a/drivers/md/dm-region-hash.c
+++ b/drivers/md/dm-region-hash.c
@@ -14,7 +14,6 @@
 #include <linux/vmalloc.h>
 
 #include "dm.h"
-#include "dm-bio-list.h"
 
 #define DM_MSG_PREFIX   "region hash"
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 981a0413068f..d73f17fc7778 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -22,7 +22,6 @@
 #include <linux/workqueue.h>
 
 #include "dm-exception-store.h"
-#include "dm-bio-list.h"
 
 #define DM_MSG_PREFIX "snapshots"
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index b01514afb6b5..e2ee4a79ea2c 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -6,7 +6,6 @@
  */
 
 #include "dm.h"
-#include "dm-bio-list.h"
 #include "dm-uevent.h"
 
 #include <linux/init.h>
diff --git a/drivers/md/md.c b/drivers/md/md.c
index ed5727c089a9..612343fdde94 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2017,6 +2017,8 @@ repeat:
         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
         spin_unlock_irq(&mddev->write_lock);
         wake_up(&mddev->sb_wait);
+        if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
+                sysfs_notify(&mddev->kobj, NULL, "sync_completed");
 
 }
 
@@ -2086,6 +2088,7 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
          *  -writemostly - clears write_mostly
          *  blocked - sets the Blocked flag
          *  -blocked - clears the Blocked flag
+         *  insync - sets Insync providing device isn't active
          */
         int err = -EINVAL;
         if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
@@ -2118,6 +2121,9 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 md_wakeup_thread(rdev->mddev->thread);
 
                 err = 0;
+        } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
+                set_bit(In_sync, &rdev->flags);
+                err = 0;
         }
         if (!err && rdev->sysfs_state)
                 sysfs_notify_dirent(rdev->sysfs_state);
@@ -2190,7 +2196,7 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
         } else if (rdev->mddev->pers) {
                 mdk_rdev_t *rdev2;
                 /* Activating a spare .. or possibly reactivating
-                 * if we every get bitmaps working here.
+                 * if we ever get bitmaps working here.
                  */
 
                 if (rdev->raid_disk != -1)
@@ -3482,12 +3488,15 @@ sync_completed_show(mddev_t *mddev, char *page)
 {
         unsigned long max_sectors, resync;
 
+        if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
+                return sprintf(page, "none\n");
+
         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
                 max_sectors = mddev->resync_max_sectors;
         else
                 max_sectors = mddev->dev_sectors;
 
-        resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
+        resync = mddev->curr_resync_completed;
         return sprintf(page, "%lu / %lu\n", resync, max_sectors);
 }
 
@@ -6334,18 +6343,13 @@ void md_do_sync(mddev_t *mddev)
                 sector_t sectors;
 
                 skipped = 0;
-                if (j >= mddev->resync_max) {
-                        sysfs_notify(&mddev->kobj, NULL, "sync_completed");
-                        wait_event(mddev->recovery_wait,
-                                   mddev->resync_max > j
-                                   || kthread_should_stop());
-                }
-                if (kthread_should_stop())
-                        goto interrupted;
 
-                if (mddev->curr_resync > mddev->curr_resync_completed &&
-                    (mddev->curr_resync - mddev->curr_resync_completed)
-                    > (max_sectors >> 4)) {
+                if ((mddev->curr_resync > mddev->curr_resync_completed &&
+                     (mddev->curr_resync - mddev->curr_resync_completed)
+                    > (max_sectors >> 4)) ||
+                    (j - mddev->curr_resync_completed)*2
+                    >= mddev->resync_max - mddev->curr_resync_completed
+                        ) {
                         /* time to update curr_resync_completed */
                         blk_unplug(mddev->queue);
                         wait_event(mddev->recovery_wait,
@@ -6353,7 +6357,17 @@ void md_do_sync(mddev_t *mddev)
                         mddev->curr_resync_completed =
                                 mddev->curr_resync;
                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
+                        sysfs_notify(&mddev->kobj, NULL, "sync_completed");
                 }
+
+                if (j >= mddev->resync_max)
+                        wait_event(mddev->recovery_wait,
+                                   mddev->resync_max > j
+                                   || kthread_should_stop());
+
+                if (kthread_should_stop())
+                        goto interrupted;
+
                 sectors = mddev->pers->sync_request(mddev, j, &skipped,
                                                   currspeed < speed_min(mddev));
                 if (sectors == 0) {
@@ -6461,6 +6475,7 @@ void md_do_sync(mddev_t *mddev)
 
  skip:
         mddev->curr_resync = 0;
+        mddev->curr_resync_completed = 0;
         mddev->resync_min = 0;
         mddev->resync_max = MaxSector;
         sysfs_notify(&mddev->kobj, NULL, "sync_completed");
diff --git a/drivers/md/md.h b/drivers/md/md.h
index e9b7f54c24d6..8227ab909d44 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -12,10 +12,17 @@
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
 */
 
-#ifndef _MD_K_H
-#define _MD_K_H
-
-#ifdef CONFIG_BLOCK
+#ifndef _MD_MD_H
+#define _MD_MD_H
+
+#include <linux/blkdev.h>
+#include <linux/kobject.h>
+#include <linux/list.h>
+#include <linux/mm.h>
+#include <linux/mutex.h>
+#include <linux/timer.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
 
 #define MaxSector (~(sector_t)0)
 
@@ -408,10 +415,6 @@ static inline void safe_put_page(struct page *p)
         if (p) put_page(p);
 }
 
-#endif /* CONFIG_BLOCK */
-#endif
-
-
 extern int register_md_personality(struct mdk_personality *p);
 extern int unregister_md_personality(struct mdk_personality *p);
 extern mdk_thread_t * md_register_thread(void (*run) (mddev_t *mddev),
@@ -434,3 +437,5 @@ extern void md_new_event(mddev_t *mddev);
 extern int md_allow_write(mddev_t *mddev);
 extern void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev);
 extern void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors);
+
+#endif /* _MD_MD_H */
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 274b491a11c1..36df9109cde1 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -35,7 +35,6 @@
 #include <linux/blkdev.h>
 #include <linux/seq_file.h>
 #include "md.h"
-#include "dm-bio-list.h"
 #include "raid1.h"
 #include "bitmap.h"
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index e293d92641ac..81a54f17417e 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -22,7 +22,6 @@
 #include <linux/blkdev.h>
 #include <linux/seq_file.h>
 #include "md.h"
-#include "dm-bio-list.h"
 #include "raid10.h"
 #include "bitmap.h"
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 3bbc6d647044..4616bc3a6e71 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3845,6 +3845,7 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
                 wait_event(conf->wait_for_overlap,
                            atomic_read(&conf->reshape_stripes)==0);
                 mddev->reshape_position = conf->reshape_progress;
+                mddev->curr_resync_completed = mddev->curr_resync;
                 conf->reshape_checkpoint = jiffies;
                 set_bit(MD_CHANGE_DEVS, &mddev->flags);
                 md_wakeup_thread(mddev->thread);
@@ -3854,6 +3855,7 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
                 conf->reshape_safe = mddev->reshape_position;
                 spin_unlock_irq(&conf->device_lock);
                 wake_up(&conf->wait_for_overlap);
+                sysfs_notify(&mddev->kobj, NULL, "sync_completed");
         }
 
         if (mddev->delta_disks < 0) {
@@ -3938,11 +3940,13 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
          * then we need to write out the superblock.
          */
         sector_nr += reshape_sectors;
-        if (sector_nr >= mddev->resync_max) {
+        if ((sector_nr - mddev->curr_resync_completed) * 2
+            >= mddev->resync_max - mddev->curr_resync_completed) {
                 /* Cannot proceed until we've updated the superblock... */
                 wait_event(conf->wait_for_overlap,
                            atomic_read(&conf->reshape_stripes) == 0);
                 mddev->reshape_position = conf->reshape_progress;
+                mddev->curr_resync_completed = mddev->curr_resync;
                 conf->reshape_checkpoint = jiffies;
                 set_bit(MD_CHANGE_DEVS, &mddev->flags);
                 md_wakeup_thread(mddev->thread);
@@ -3953,6 +3957,7 @@ static sector_t reshape_request(mddev_t *mddev, sector_t sector_nr, int *skipped
                 conf->reshape_safe = mddev->reshape_position;
                 spin_unlock_irq(&conf->device_lock);
                 wake_up(&conf->wait_for_overlap);
+                sysfs_notify(&mddev->kobj, NULL, "sync_completed");
         }
         return reshape_sectors;
 }