md-cluster: Use a small window for resync

Suspending the entire device for resync could take too long. Resync
in small chunks.

cluster's resync window (32M) is maintained in r1conf as
cluster_sync_low and cluster_sync_high and processed in
raid1's sync_request(). If the current resync is outside the cluster
resync window:

1. Set the cluster_sync_low to curr_resync_completed.
2. Check if the sync will fit in the new window, if not issue a
   wait_barrier() and set cluster_sync_low to sector_nr.
3. Set cluster_sync_high to cluster_sync_low + resync_window.
4. Send a message to all nodes so they may add it in their suspension
   list.

bitmap_cond_end_sync is modified to allow to force a sync inorder
to get the curr_resync_completed uptodate with the sector passed.

Signed-off-by: Goldwyn Rodrigues <rgoldwyn@suse.com>
Signed-off-by: NeilBrown <neilb@suse.de>

1 files changed, 25 insertions, 1 deletions

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 049df6c4a8cc..1dd13bb52940 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)
@@ -2488,6 +2490,13 @@ 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;
+                        /* Send zeros to mark end of resync */
+                        md_cluster_ops->resync_info_update(mddev, 0, 0);
+                }
                 return 0;
         }
 
@@ -2508,7 +2517,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 +2713,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
          */