DM RAID: Add message/status support for changing sync action

DM RAID:  Add message/status support for changing sync action

This patch adds a message interface to dm-raid to allow the user to more
finely control the sync actions being performed by the MD driver.  This
gives the user the ability to initiate "check" and "repair" (i.e. scrubbing).
Two additional fields have been appended to the status output to provide more
information about the type of sync action occurring and the results of those
actions, specifically: <sync_action> and <mismatch_cnt>.  These new fields
will always be populated.  This is essentially the device-mapper way of doing
what MD controls through the 'sync_action' sysfs file and shows through the
'mismatch_cnt' sysfs file.

Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: NeilBrown <neilb@suse.de>

1 files changed, 109 insertions, 2 deletions

diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index 311e3d35b272..1d3fe1a40a9b 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -1279,6 +1279,31 @@ static int raid_map(struct dm_target *ti, struct bio *bio)
         return DM_MAPIO_SUBMITTED;
 }
 
+static const char *decipher_sync_action(struct mddev *mddev)
+{
+        if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
+                return "frozen";
+
+        if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
+            (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
+                if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
+                        return "reshape";
+
+                if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
+                        if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
+                                return "resync";
+                        else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
+                                return "check";
+                        return "repair";
+                }
+
+                if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
+                        return "recover";
+        }
+
+        return "idle";
+}
+
 static void raid_status(struct dm_target *ti, status_type_t type,
                         unsigned status_flags, char *result, unsigned maxlen)
 {
@@ -1298,8 +1323,18 @@ static void raid_status(struct dm_target *ti, status_type_t type,
                         sync = rs->md.recovery_cp;
 
                 if (sync >= rs->md.resync_max_sectors) {
+                        /*
+                         * Sync complete.
+                         */
                         array_in_sync = 1;
                         sync = rs->md.resync_max_sectors;
+                } else if (test_bit(MD_RECOVERY_REQUESTED, &rs->md.recovery)) {
+                        /*
+                         * If "check" or "repair" is occurring, the array has
+                         * undergone and initial sync and the health characters
+                         * should not be 'a' anymore.
+                         */
+                        array_in_sync = 1;
                 } else {
                         /*
                          * The array may be doing an initial sync, or it may
@@ -1311,6 +1346,7 @@ static void raid_status(struct dm_target *ti, status_type_t type,
                                 if (!test_bit(In_sync, &rs->dev[i].rdev.flags))
                                         array_in_sync = 1;
                 }
+
                 /*
                  * Status characters:
                  *  'D' = Dead/Failed device
@@ -1339,6 +1375,21 @@ static void raid_status(struct dm_target *ti, status_type_t type,
                        (unsigned long long) sync,
                        (unsigned long long) rs->md.resync_max_sectors);
 
+                /*
+                 * Sync action:
+                 *   See Documentation/device-mapper/dm-raid.c for
+                 *   information on each of these states.
+                 */
+                DMEMIT(" %s", decipher_sync_action(&rs->md));
+
+                /*
+                 * resync_mismatches/mismatch_cnt
+                 *   This field shows the number of discrepancies found when
+                 *   performing a "check" of the array.
+                 */
+                DMEMIT(" %llu",
+                       (unsigned long long)
+                       atomic64_read(&rs->md.resync_mismatches));
                 break;
         case STATUSTYPE_TABLE:
                 /* The string you would use to construct this array */
@@ -1425,7 +1476,62 @@ static void raid_status(struct dm_target *ti, status_type_t type,
         }
 }
 
-static int raid_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn, void *data)
+static int raid_message(struct dm_target *ti, unsigned argc, char **argv)
+{
+        struct raid_set *rs = ti->private;
+        struct mddev *mddev = &rs->md;
+
+        if (!strcasecmp(argv[0], "reshape")) {
+                DMERR("Reshape not supported.");
+                return -EINVAL;
+        }
+
+        if (!mddev->pers || !mddev->pers->sync_request)
+                return -EINVAL;
+
+        if (!strcasecmp(argv[0], "frozen"))
+                set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
+        else
+                clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
+
+        if (!strcasecmp(argv[0], "idle") || !strcasecmp(argv[0], "frozen")) {
+                if (mddev->sync_thread) {
+                        set_bit(MD_RECOVERY_INTR, &mddev->recovery);
+                        md_reap_sync_thread(mddev);
+                }
+        } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
+                   test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
+                return -EBUSY;
+        else if (!strcasecmp(argv[0], "resync"))
+                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+        else if (!strcasecmp(argv[0], "recover")) {
+                set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
+                set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+        } else {
+                if (!strcasecmp(argv[0], "check"))
+                        set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+                else if (!!strcasecmp(argv[0], "repair"))
+                        return -EINVAL;
+                set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
+                set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
+        }
+        if (mddev->ro == 2) {
+                /* A write to sync_action is enough to justify
+                 * canceling read-auto mode
+                 */
+                mddev->ro = 0;
+                if (!mddev->suspended)
+                        md_wakeup_thread(mddev->sync_thread);
+        }
+        set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+        if (!mddev->suspended)
+                md_wakeup_thread(mddev->thread);
+
+        return 0;
+}
+
+static int raid_iterate_devices(struct dm_target *ti,
+                                iterate_devices_callout_fn fn, void *data)
 {
         struct raid_set *rs = ti->private;
         unsigned i;
@@ -1482,12 +1588,13 @@ static void raid_resume(struct dm_target *ti)
 
 static struct target_type raid_target = {
         .name = "raid",
-        .version = {1, 4, 2},
+        .version = {1, 5, 0},
         .module = THIS_MODULE,
         .ctr = raid_ctr,
         .dtr = raid_dtr,
         .map = raid_map,
         .status = raid_status,
+        .message = raid_message,
         .iterate_devices = raid_iterate_devices,
         .io_hints = raid_io_hints,
         .presuspend = raid_presuspend,