dm cache: add cleaner policy

A simple cache policy that writes back all data to the origin.

This is used to decommission a dm cache by emptying it.

Signed-off-by: Heinz Mauelshagen <mauelshagen@redhat.com>
Signed-off-by: Joe Thornber <ejt@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>

4 files changed, 479 insertions, 0 deletions

diff --git a/Documentation/device-mapper/cache-policies.txt b/Documentation/device-mapper/cache-policies.txt
index 731879f97b80..d7c440b444cc 100644
--- a/Documentation/device-mapper/cache-policies.txt
+++ b/Documentation/device-mapper/cache-policies.txt
@@ -53,6 +53,11 @@ since spindles tend to have good bandwidth. The io_tracker counts
 contiguous I/Os to try to spot when the io is in one of these sequential
 modes.
 
+cleaner
+-------
+
+The cleaner writes back all dirty blocks in a cache to decommission it.
+
 Examples
 ========
 
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 1a96cbc7afda..e30b490055aa 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -291,6 +291,14 @@ config DM_CACHE_MQ
          This is meant to be a general purpose policy.  It prioritises
          reads over writes.
 
+config DM_CACHE_CLEANER
+       tristate "Cleaner Cache Policy (EXPERIMENTAL)"
+       depends on DM_CACHE
+       default y
+       ---help---
+         A simple cache policy that writes back all data to the
+         origin.  Used when decommissioning a dm-cache.
+
 config DM_MIRROR
        tristate "Mirror target"
        depends on BLK_DEV_DM
diff --git a/drivers/md/Makefile b/drivers/md/Makefile
index adc8710c2408..7ceeaefc0e95 100644
--- a/drivers/md/Makefile
+++ b/drivers/md/Makefile
@@ -13,6 +13,7 @@ dm-log-userspace-y \
 dm-thin-pool-y  += dm-thin.o dm-thin-metadata.o
 dm-cache-y      += dm-cache-target.o dm-cache-metadata.o dm-cache-policy.o
 dm-cache-mq-y   += dm-cache-policy-mq.o
+dm-cache-cleaner-y += dm-cache-policy-cleaner.o
 md-mod-y        += md.o bitmap.o
 raid456-y       += raid5.o
 
@@ -48,6 +49,7 @@ obj-$(CONFIG_DM_THIN_PROVISIONING)	+= dm-thin-pool.o
 obj-$(CONFIG_DM_VERITY)         += dm-verity.o
 obj-$(CONFIG_DM_CACHE)          += dm-cache.o
 obj-$(CONFIG_DM_CACHE_MQ)       += dm-cache-mq.o
+obj-$(CONFIG_DM_CACHE_CLEANER)  += dm-cache-cleaner.o
 
 ifeq ($(CONFIG_DM_UEVENT),y)
 dm-mod-objs                     += dm-uevent.o
diff --git a/drivers/md/dm-cache-policy-cleaner.c b/drivers/md/dm-cache-policy-cleaner.c
new file mode 100644
index 000000000000..cc05d70b3cb8
--- /dev/null
+++ b/drivers/md/dm-cache-policy-cleaner.c
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2012 Red Hat. All rights reserved.
+ *
+ * writeback cache policy supporting flushing out dirty cache blocks.
+ *
+ * This file is released under the GPL.
+ */
+
+#include "dm-cache-policy.h"
+#include "dm.h"
+
+#include <linux/hash.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+
+/*----------------------------------------------------------------*/
+
+#define DM_MSG_PREFIX "cache cleaner"
+#define CLEANER_VERSION "1.0.0"
+
+/* Cache entry struct. */
+struct wb_cache_entry {
+        struct list_head list;
+        struct hlist_node hlist;
+
+        dm_oblock_t oblock;
+        dm_cblock_t cblock;
+        bool dirty:1;
+        bool pending:1;
+};
+
+struct hash {
+        struct hlist_head *table;
+        dm_block_t hash_bits;
+        unsigned nr_buckets;
+};
+
+struct policy {
+        struct dm_cache_policy policy;
+        spinlock_t lock;
+
+        struct list_head free;
+        struct list_head clean;
+        struct list_head clean_pending;
+        struct list_head dirty;
+
+        /*
+         * We know exactly how many cblocks will be needed,
+         * so we can allocate them up front.
+         */
+        dm_cblock_t cache_size, nr_cblocks_allocated;
+        struct wb_cache_entry *cblocks;
+        struct hash chash;
+};
+
+/*----------------------------------------------------------------------------*/
+
+/*
+ * Low-level functions.
+ */
+static unsigned next_power(unsigned n, unsigned min)
+{
+        return roundup_pow_of_two(max(n, min));
+}
+
+static struct policy *to_policy(struct dm_cache_policy *p)
+{
+        return container_of(p, struct policy, policy);
+}
+
+static struct list_head *list_pop(struct list_head *q)
+{
+        struct list_head *r = q->next;
+
+        list_del(r);
+
+        return r;
+}
+
+/*----------------------------------------------------------------------------*/
+
+/* Allocate/free various resources. */
+static int alloc_hash(struct hash *hash, unsigned elts)
+{
+        hash->nr_buckets = next_power(elts >> 4, 16);
+        hash->hash_bits = ffs(hash->nr_buckets) - 1;
+        hash->table = vzalloc(sizeof(*hash->table) * hash->nr_buckets);
+
+        return hash->table ? 0 : -ENOMEM;
+}
+
+static void free_hash(struct hash *hash)
+{
+        vfree(hash->table);
+}
+
+static int alloc_cache_blocks_with_hash(struct policy *p, dm_cblock_t cache_size)
+{
+        int r = -ENOMEM;
+
+        p->cblocks = vzalloc(sizeof(*p->cblocks) * from_cblock(cache_size));
+        if (p->cblocks) {
+                unsigned u = from_cblock(cache_size);
+
+                while (u--)
+                        list_add(&p->cblocks[u].list, &p->free);
+
+                p->nr_cblocks_allocated = 0;
+
+                /* Cache entries hash. */
+                r = alloc_hash(&p->chash, from_cblock(cache_size));
+                if (r)
+                        vfree(p->cblocks);
+        }
+
+        return r;
+}
+
+static void free_cache_blocks_and_hash(struct policy *p)
+{
+        free_hash(&p->chash);
+        vfree(p->cblocks);
+}
+
+static struct wb_cache_entry *alloc_cache_entry(struct policy *p)
+{
+        struct wb_cache_entry *e;
+
+        BUG_ON(from_cblock(p->nr_cblocks_allocated) >= from_cblock(p->cache_size));
+
+        e = list_entry(list_pop(&p->free), struct wb_cache_entry, list);