1 files changed, 437 insertions, 0 deletions

diff --git a/drivers/md/persistent-data/dm-space-map-checker.c b/drivers/md/persistent-data/dm-space-map-checker.c
new file mode 100644
index 000000000000..bb44a937fe63
--- /dev/null
+++ b/drivers/md/persistent-data/dm-space-map-checker.c
@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * This file is released under the GPL.
+ */
+
+#include "dm-space-map-checker.h"
+
+#include <linux/device-mapper.h>
+
+#ifdef CONFIG_DM_DEBUG_SPACE_MAPS
+
+#define DM_MSG_PREFIX "space map checker"
+
+/*----------------------------------------------------------------*/
+
+struct count_array {
+        dm_block_t nr;
+        dm_block_t nr_free;
+
+        uint32_t *counts;
+};
+
+static int ca_get_count(struct count_array *ca, dm_block_t b, uint32_t *count)
+{
+        if (b >= ca->nr)
+                return -EINVAL;
+
+        *count = ca->counts[b];
+        return 0;
+}
+
+static int ca_count_more_than_one(struct count_array *ca, dm_block_t b, int *r)
+{
+        if (b >= ca->nr)
+                return -EINVAL;
+
+        *r = ca->counts[b] > 1;
+        return 0;
+}
+
+static int ca_set_count(struct count_array *ca, dm_block_t b, uint32_t count)
+{
+        uint32_t old_count;
+
+        if (b >= ca->nr)
+                return -EINVAL;
+
+        old_count = ca->counts[b];
+
+        if (!count && old_count)
+                ca->nr_free++;
+
+        else if (count && !old_count)
+                ca->nr_free--;
+
+        ca->counts[b] = count;
+        return 0;
+}
+
+static int ca_inc_block(struct count_array *ca, dm_block_t b)
+{
+        if (b >= ca->nr)
+                return -EINVAL;
+
+        ca_set_count(ca, b, ca->counts[b] + 1);
+        return 0;
+}
+
+static int ca_dec_block(struct count_array *ca, dm_block_t b)
+{
+        if (b >= ca->nr)
+                return -EINVAL;
+
+        BUG_ON(ca->counts[b] == 0);
+        ca_set_count(ca, b, ca->counts[b] - 1);
+        return 0;
+}
+
+static int ca_create(struct count_array *ca, struct dm_space_map *sm)
+{
+        int r;
+        dm_block_t nr_blocks;
+
+        r = dm_sm_get_nr_blocks(sm, &nr_blocks);
+        if (r)
+                return r;
+
+        ca->nr = nr_blocks;
+        ca->nr_free = nr_blocks;
+        ca->counts = kzalloc(sizeof(*ca->counts) * nr_blocks, GFP_KERNEL);
+        if (!ca->counts)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static int ca_load(struct count_array *ca, struct dm_space_map *sm)
+{
+        int r;
+        uint32_t count;
+        dm_block_t nr_blocks, i;
+
+        r = dm_sm_get_nr_blocks(sm, &nr_blocks);
+        if (r)
+                return r;
+
+        BUG_ON(ca->nr != nr_blocks);
+
+        DMWARN("Loading debug space map from disk.  This may take some time");
+        for (i = 0; i < nr_blocks; i++) {
+                r = dm_sm_get_count(sm, i, &count);
+                if (r) {
+                        DMERR("load failed");
+                        return r;
+                }
+
+                ca_set_count(ca, i, count);
+        }
+        DMWARN("Load complete");
+
+        return 0;
+}
+
+static int ca_extend(struct count_array *ca, dm_block_t extra_blocks)
+{
+        dm_block_t nr_blocks = ca->nr + extra_blocks;
+        uint32_t *counts = kzalloc(sizeof(*counts) * nr_blocks, GFP_KERNEL);
+        if (!counts)
+                return -ENOMEM;
+
+        memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
+        kfree(ca->counts);
+        ca->nr = nr_blocks;
+        ca->nr_free += extra_blocks;
+        ca->counts = counts;
+        return 0;
+}
+
+static int ca_commit(struct count_array *old, struct count_array *new)
+{
+        if (old->nr != new->nr) {
+                BUG_ON(old->nr > new->nr);
+                ca_extend(old, new->nr - old->nr);
+        }
+
+        BUG_ON(old->nr != new->nr);
+        old->nr_free = new->nr_free;
+        memcpy(old->counts, new->counts, sizeof(*old->counts) * old->nr);
+        return 0;
+}
+
+static void ca_destroy(struct count_array *ca)
+{
+        kfree(ca->counts);
+}
+
+/*----------------------------------------------------------------*/
+
+struct sm_checker {
+        struct dm_space_map sm;
+
+        struct count_array old_counts;
+        struct count_array counts;
+
+        struct dm_space_map *real_sm;
+};
+
+static void sm_checker_destroy(struct dm_space_map *sm)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+
+        dm_sm_destroy(smc->real_sm);
+        ca_destroy(&smc->old_counts);
+        ca_destroy(&smc->counts);
+        kfree(smc);
+}
+
+static int sm_checker_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r = dm_sm_get_nr_blocks(smc->real_sm, count);
+        if (!r)
+                BUG_ON(smc->old_counts.nr != *count);
+        return r;
+}
+
+static int sm_checker_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r = dm_sm_get_nr_free(smc->real_sm, count);
+        if (!r) {
+                /*
+                 * Slow, but we know it's correct.
+                 */
+                dm_block_t b, n = 0;
+                for (b = 0; b < smc->old_counts.nr; b++)
+                        if (smc->old_counts.counts[b] == 0 &&
+                            smc->counts.counts[b] == 0)
+                                n++;
+
+                if (n != *count)
+                        DMERR("free block counts differ, checker %u, sm-disk:%u",
+                              (unsigned) n, (unsigned) *count);
+        }
+        return r;
+}
+
+static int sm_checker_new_block(struct dm_space_map *sm, dm_block_t *b)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r = dm_sm_new_block(smc->real_sm, b);
+
+        if (!r) {
+                BUG_ON(*b >= smc->old_counts.nr);
+                BUG_ON(smc->old_counts.counts[*b] != 0);
+                BUG_ON(*b >= smc->counts.nr);
+                BUG_ON(smc->counts.counts[*b] != 0);
+                ca_set_count(&smc->counts, *b, 1);
+        }
+
+        return r;
+}
+
+static int sm_checker_inc_block(struct dm_space_map *sm, dm_block_t b)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r = dm_sm_inc_block(smc->real_sm, b);
+        int r2 = ca_inc_block(&smc->counts, b);
+        BUG_ON(r != r2);
+        return r;
+}
+
+static int sm_checker_dec_block(struct dm_space_map *sm, dm_block_t b)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r = dm_sm_dec_block(smc->real_sm, b);
+        int r2 = ca_dec_block(&smc->counts, b);
+        BUG_ON(r != r2);
+        return r;
+}
+
+static int sm_checker_get_count(struct dm_space_map *sm, dm_block_t b, uint32_t *result)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        uint32_t result2 = 0;
+        int r = dm_sm_get_count(smc->real_sm, b, result);
+        int r2 = ca_get_count(&smc->counts, b, &result2);
+
+        BUG_ON(r != r2);
+        if (!r)
+                BUG_ON(*result != result2);
+        return r;
+}
+
+static int sm_checker_count_more_than_one(struct dm_space_map *sm, dm_block_t b, int *result)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int result2 = 0;
+        int r = dm_sm_count_is_more_than_one(smc->real_sm, b, result);
+        int r2 = ca_count_more_than_one(&smc->counts, b, &result2);
+
+        BUG_ON(r != r2);
+        if (!r)
+                BUG_ON(!(*result) && result2);
+        return r;
+}
+
+static int sm_checker_set_count(struct dm_space_map *sm, dm_block_t b, uint32_t count)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        uint32_t old_rc;
+        int r = dm_sm_set_count(smc->real_sm, b, count);
+        int r2;
+
+        BUG_ON(b >= smc->counts.nr);
+        old_rc = smc->counts.counts[b];
+        r2 = ca_set_count(&smc->counts, b, count);
+        BUG_ON(r != r2);
+
+        return r;
+}
+
+static int sm_checker_commit(struct dm_space_map *sm)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r;
+
+        r = dm_sm_commit(smc->real_sm);
+        if (r)
+                return r;
+
+        r = ca_commit(&smc->old_counts, &smc->counts);
+        if (r)
+                return r;
+
+        return 0;
+}
+
+static int sm_checker_extend(struct dm_space_map *sm, dm_block_t extra_blocks)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        int r = dm_sm_extend(smc->real_sm, extra_blocks);
+        if (r)
+                return r;
+
+        return ca_extend(&smc->counts, extra_blocks);
+}
+
+static int sm_checker_root_size(struct dm_space_map *sm, size_t *result)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        return dm_sm_root_size(smc->real_sm, result);
+}
+
+static int sm_checker_copy_root(struct dm_space_map *sm, void *copy_to_here_le, size_t len)
+{
+        struct sm_checker *smc = container_of(sm, struct sm_checker, sm);
+        return dm_sm_copy_root(smc->real_sm, copy_to_here_le, len);
+}
+
+/*----------------------------------------------------------------*/
+
+static struct dm_space_map ops_ = {
+        .destroy = sm_checker_destroy,
+        .get_nr_blocks = sm_checker_get_nr_blocks,
+        .get_nr_free = sm_checker_get_nr_free,
+        .inc_block = sm_checker_inc_block,
+        .dec_block = sm_checker_dec_block,
+        .new_block = sm_checker_new_block,
+        .get_count = sm_checker_get_count,
+        .count_is_more_than_one = sm_checker_count_more_than_one,
+        .set_count = sm_checker_set_count,
+        .commit = sm_checker_commit,
+        .extend = sm_checker_extend,
+        .root_size = sm_checker_root_size,
+        .copy_root = sm_checker_copy_root
+};
+
+struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
+{
+        int r;
+        struct sm_checker *smc;
+
+        if (!sm)
+                return NULL;
+
+        smc = kmalloc(sizeof(*smc), GFP_KERNEL);
+        if (!smc)
+                return NULL;
+
+        memcpy(&smc->sm, &ops_, sizeof(smc->sm));
+        r = ca_create(&smc->old_counts, sm);
+        if (r) {
+                kfree(smc);
+                return NULL;
+        }
+
+        r = ca_create(&smc->counts, sm);
+        if (r) {
+                ca_destroy(&smc->old_counts);
+                kfree(smc);
+                return NULL;
+        }
+
+        smc->real_sm = sm;
+
+        r = ca_load(&smc->counts, sm);
+        if (r) {
+                ca_destroy(&smc->counts);
+                ca_destroy(&smc->old_counts);
+                kfree(smc);
+                return NULL;
+        }
+
+        r = ca_commit(&smc->old_counts, &smc->counts);
+        if (r) {
+                ca_destroy(&smc->counts);
+                ca_destroy(&smc->old_counts);
+                kfree(smc);
+                return NULL;
+        }
+
+        return &smc->sm;
+}
+EXPORT_SYMBOL_GPL(dm_sm_checker_create);
+
+struct dm_space_map *dm_sm_checker_create_fresh(struct dm_space_map *sm)
+{
+        int r;
+        struct sm_checker *smc;
+
+        if (!sm)
+                return NULL;
+
+        smc = kmalloc(sizeof(*smc), GFP_KERNEL);
+        if (!smc)
+                return NULL;
+
+        memcpy(&smc->sm, &ops_, sizeof(smc->sm));
+        r = ca_create(&smc->old_counts, sm);
+        if (r) {
+                kfree(smc);
+                return NULL;
+        }
+
+        r = ca_create(&smc->counts, sm);
+        if (r) {
+                ca_destroy(&smc->old_counts);
+                kfree(smc);
+                return NULL;
+        }
+
+        smc->real_sm = sm;
+        return &smc->sm;
+}
+EXPORT_SYMBOL_GPL(dm_sm_checker_create_fresh);
+
+/*----------------------------------------------------------------*/
+
+#else
+
+struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
+{
+        return sm;
+}
+EXPORT_SYMBOL_GPL(dm_sm_checker_create);
+
+struct dm_space_map *dm_sm_checker_create_fresh(struct dm_space_map *sm)
+{
+        return sm;
+}
+EXPORT_SYMBOL_GPL(dm_sm_checker_create_fresh);
+
+/*----------------------------------------------------------------*/
+
+#endif