[S390] Use tape_generic_offline directly.

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

diff --git a/drivers/md/md.c b/drivers/md/md.c
index ed5727c..612343f 100644 (file)
--- 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) {
@@ -2117,6 +2120,9 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
                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)
@@ -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");