From 493df71c6420b211a68ae82b889c1e8a5fe701be Mon Sep 17 00:00:00 2001
From: Jonathan Brassow <jbrassow@redhat.com>
Date: Thu, 2 Apr 2009 19:55:31 +0100
Subject: dm exception store: introduce registry
Move exception stores into a registry.
Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
---
drivers/md/dm-exception-store.c | 162 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 162 insertions(+)
(limited to 'drivers/md/dm-exception-store.c')
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index dccbfb0e010f..8912a3637cae 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -14,6 +14,168 @@
#define DM_MSG_PREFIX "snapshot exception stores"
+static LIST_HEAD(_exception_store_types);
+static DEFINE_SPINLOCK(_lock);
+
+static struct dm_exception_store_type *__find_exception_store_type(const char *name)
+{
+ struct dm_exception_store_type *type;
+
+ list_for_each_entry(type, &_exception_store_types, list)
+ if (!strcmp(name, type->name))
+ return type;
+
+ return NULL;
+}
+
+static struct dm_exception_store_type *_get_exception_store_type(const char *name)
+{
+ struct dm_exception_store_type *type;
+
+ spin_lock(&_lock);
+
+ type = __find_exception_store_type(name);
+
+ if (type && !try_module_get(type->module))
+ type = NULL;
+
+ spin_unlock(&_lock);
+
+ return type;
+}
+
+/*
+ * get_type
+ * @type_name
+ *
+ * Attempt to retrieve the dm_exception_store_type by name. If not already
+ * available, attempt to load the appropriate module.
+ *
+ * Exstore modules are named "dm-exstore-" followed by the 'type_name'.
+ * Modules may contain multiple types.
+ * This function will first try the module "dm-exstore-<type_name>",
+ * then truncate 'type_name' on the last '-' and try again.
+ *
+ * For example, if type_name was "clustered-shared", it would search
+ * 'dm-exstore-clustered-shared' then 'dm-exstore-clustered'.
+ *
+ * 'dm-exception-store-<type_name>' is too long of a name in my
+ * opinion, which is why I've chosen to have the files
+ * containing exception store implementations be 'dm-exstore-<type_name>'.
+ * If you want your module to be autoloaded, you will follow this
+ * naming convention.
+ *
+ * Returns: dm_exception_store_type* on success, NULL on failure
+ */
+static struct dm_exception_store_type *get_type(const char *type_name)
+{
+ char *p, *type_name_dup;
+ struct dm_exception_store_type *type;
+
+ type = _get_exception_store_type(type_name);
+ if (type)
+ return type;
+
+ type_name_dup = kstrdup(type_name, GFP_KERNEL);
+ if (!type_name_dup) {
+ DMERR("No memory left to attempt load for \"%s\"", type_name);
+ return NULL;
+ }
+
+ while (request_module("dm-exstore-%s", type_name_dup) ||
+ !(type = _get_exception_store_type(type_name))) {
+ p = strrchr(type_name_dup, '-');
+ if (!p)
+ break;
+ p[0] = '\0';
+ }
+
+ if (!type)
+ DMWARN("Module for exstore type \"%s\" not found.", type_name);
+
+ kfree(type_name_dup);
+
+ return type;
+}
+
+static void put_type(struct dm_exception_store_type *type)
+{
+ spin_lock(&_lock);
+ module_put(type->module);
+ spin_unlock(&_lock);
+}
+
+int dm_exception_store_type_register(struct dm_exception_store_type *type)
+{
+ int r = 0;
+
+ spin_lock(&_lock);
+ if (!__find_exception_store_type(type->name))
+ list_add(&type->list, &_exception_store_types);
+ else
+ r = -EEXIST;
+ spin_unlock(&_lock);
+
+ return r;
+}
+EXPORT_SYMBOL(dm_exception_store_type_register);
+
+int dm_exception_store_type_unregister(struct dm_exception_store_type *type)
+{
+ spin_lock(&_lock);
+
+ if (!__find_exception_store_type(type->name)) {
+ spin_unlock(&_lock);
+ return -EINVAL;
+ }
+
+ list_del(&type->list);
+
+ spin_unlock(&_lock);
+
+ return 0;
+}
+EXPORT_SYMBOL(dm_exception_store_type_unregister);
+
+int dm_exception_store_create(const char *type_name,
+ struct dm_exception_store **store)
+{
+ int r = 0;
+ struct dm_exception_store_type *type;
+ struct dm_exception_store *tmp_store;
+
+ tmp_store = kmalloc(sizeof(*tmp_store), GFP_KERNEL);
+ if (!tmp_store)
+ return -ENOMEM;
+
+ type = get_type(type_name);
+ if (!type) {
+ kfree(tmp_store);
+ return -EINVAL;
+ }
+
+ tmp_store->type = type;
+
+ r = type->ctr(tmp_store, 0, NULL);
+ if (r) {
+ put_type(type);
+ kfree(tmp_store);
+ return r;
+ }
+
+ *store = tmp_store;
+ return 0;
+}
+EXPORT_SYMBOL(dm_exception_store_create);
+
+void dm_exception_store_destroy(struct dm_exception_store *store)
+{
+ store->type->dtr(store);
+ put_type(store->type);
+ kfree(store);
+}
+EXPORT_SYMBOL(dm_exception_store_destroy);
+
int dm_exception_store_init(void)
{
int r;
--
cgit v1.2.3
From 0cea9c78270cdf1d2ad74ce0e083d5555a0842e8 Mon Sep 17 00:00:00 2001
From: Jonathan Brassow <jbrassow@redhat.com>
Date: Thu, 2 Apr 2009 19:55:32 +0100
Subject: dm exception store: move dm_target pointer
Move target pointer from snapshot to exception store.
Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
---
drivers/md/dm-exception-store.c | 3 ++-
drivers/md/dm-exception-store.h | 3 ++-
drivers/md/dm-snap.c | 7 +++----
drivers/md/dm-snap.h | 1 -
4 files changed, 7 insertions(+), 7 deletions(-)
(limited to 'drivers/md/dm-exception-store.c')
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index 8912a3637cae..fe0cfa677139 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -137,7 +137,7 @@ int dm_exception_store_type_unregister(struct dm_exception_store_type *type)
}
EXPORT_SYMBOL(dm_exception_store_type_unregister);
-int dm_exception_store_create(const char *type_name,
+int dm_exception_store_create(const char *type_name, struct dm_target *ti,
struct dm_exception_store **store)
{
int r = 0;
@@ -155,6 +155,7 @@ int dm_exception_store_create(const char *type_name,
}
tmp_store->type = type;
+ tmp_store->ti = ti;
r = type->ctr(tmp_store, 0, NULL);
if (r) {
diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h
index 31377150080e..4b7f7d441f5f 100644
--- a/drivers/md/dm-exception-store.h
+++ b/drivers/md/dm-exception-store.h
@@ -95,6 +95,7 @@ struct dm_exception_store_type {
struct dm_exception_store {
struct dm_exception_store_type *type;
+ struct dm_target *ti;
struct dm_snapshot *snap;
@@ -147,7 +148,7 @@ static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
int dm_exception_store_type_register(struct dm_exception_store_type *type);
int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
-int dm_exception_store_create(const char *type_name,
+int dm_exception_store_create(const char *type_name, struct dm_target *ti,
struct dm_exception_store **store);
void dm_exception_store_destroy(struct dm_exception_store *store);
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index be698f3a4ae4..4429c2a1d6fb 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -615,7 +615,6 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
atomic_set(&s->pending_exceptions_count, 0);
init_rwsem(&s->lock);
spin_lock_init(&s->pe_lock);
- s->ti = ti;
/* Allocate hash table for COW data */
if (init_hash_tables(s)) {
@@ -624,7 +623,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
goto bad3;
}
- r = dm_exception_store_create(argv[2], &s->store);
+ r = dm_exception_store_create(argv[2], ti, &s->store);
if (r) {
ti->error = "Couldn't create exception store";
r = -EINVAL;
@@ -820,7 +819,7 @@ static void __invalidate_snapshot(struct dm_snapshot *s, int err)
s->valid = 0;
- dm_table_event(s->ti->table);
+ dm_table_event(s->store->ti->table);
}
static void get_pending_exception(struct dm_snap_pending_exception *pe)
@@ -1196,7 +1195,7 @@ static int __origin_write(struct list_head *snapshots, struct bio *bio)
goto next_snapshot;
/* Nothing to do if writing beyond end of snapshot */
- if (bio->bi_sector >= dm_table_get_size(snap->ti->table))
+ if (bio->bi_sector >= dm_table_get_size(snap->store->ti->table))
goto next_snapshot;
/*
diff --git a/drivers/md/dm-snap.h b/drivers/md/dm-snap.h
index 627be0f52c32..93cd8ee8997f 100644
--- a/drivers/md/dm-snap.h
+++ b/drivers/md/dm-snap.h
@@ -25,7 +25,6 @@ struct exception_table {
struct dm_snapshot {
struct rw_semaphore lock;
- struct dm_target *ti;
struct dm_dev *origin;
struct dm_dev *cow;
--
cgit v1.2.3
From d0216849519bec8dc96301a3cd80316e71243839 Mon Sep 17 00:00:00 2001
From: Jonathan Brassow <jbrassow@redhat.com>
Date: Thu, 2 Apr 2009 19:55:32 +0100
Subject: dm exception store: move chunk_fields
Move chunk fields from snapshot to exception store.
Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
---
drivers/md/dm-exception-store.c | 6 ++++++
drivers/md/dm-exception-store.h | 7 ++++++
drivers/md/dm-snap-persistent.c | 47 +++++++++++++++++++++--------------------
drivers/md/dm-snap-transient.c | 4 ++--
drivers/md/dm-snap.c | 47 +++++++++++++++++++++++------------------
drivers/md/dm-snap.h | 9 ++------
6 files changed, 67 insertions(+), 53 deletions(-)
(limited to 'drivers/md/dm-exception-store.c')
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index fe0cfa677139..59c949b53106 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -138,6 +138,8 @@ int dm_exception_store_type_unregister(struct dm_exception_store_type *type)
EXPORT_SYMBOL(dm_exception_store_type_unregister);
int dm_exception_store_create(const char *type_name, struct dm_target *ti,
+ chunk_t chunk_size, chunk_t chunk_mask,
+ chunk_t chunk_shift,
struct dm_exception_store **store)
{
int r = 0;
@@ -157,6 +159,10 @@ int dm_exception_store_create(const char *type_name, struct dm_target *ti,
tmp_store->type = type;
tmp_store->ti = ti;
+ tmp_store->chunk_size = chunk_size;
+ tmp_store->chunk_mask = chunk_mask;
+ tmp_store->chunk_shift = chunk_shift;
+
r = type->ctr(tmp_store, 0, NULL);
if (r) {
put_type(type);
diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h
index 4b7f7d441f5f..449a1e48f7aa 100644
--- a/drivers/md/dm-exception-store.h
+++ b/drivers/md/dm-exception-store.h
@@ -99,6 +99,11 @@ struct dm_exception_store {
struct dm_snapshot *snap;
+ /* Size of data blocks saved - must be a power of 2 */
+ chunk_t chunk_size;
+ chunk_t chunk_mask;
+ chunk_t chunk_shift;
+
void *context;
};
@@ -149,6 +154,8 @@ int dm_exception_store_type_register(struct dm_exception_store_type *type);
int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
int dm_exception_store_create(const char *type_name, struct dm_target *ti,
+ chunk_t chunk_size, chunk_t chunk_mask,
+ chunk_t chunk_shift,
struct dm_exception_store **store);
void dm_exception_store_destroy(struct dm_exception_store *store);
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index e85b7a186a13..c3c58159b6e8 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -141,7 +141,7 @@ static int alloc_area(struct pstore *ps)
int r = -ENOMEM;
size_t len;
- len = ps->snap->chunk_size << SECTOR_SHIFT;
+ len = ps->snap->store->chunk_size << SECTOR_SHIFT;
/*
* Allocate the chunk_size block of memory that will hold
@@ -190,8 +190,8 @@ static int chunk_io(struct pstore *ps, chunk_t chunk, int rw, int metadata)
{
struct dm_io_region where = {
.bdev = ps->snap->cow->bdev,
- .sector = ps->snap->chunk_size * chunk,
- .count = ps->snap->chunk_size,
+ .sector = ps->snap->store->chunk_size * chunk,
+ .count = ps->snap->store->chunk_size,
};
struct dm_io_request io_req = {
.bi_rw = rw,
@@ -247,15 +247,15 @@ static int area_io(struct pstore *ps, int rw)
static void zero_memory_area(struct pstore *ps)
{
- memset(ps->area, 0, ps->snap->chunk_size << SECTOR_SHIFT);
+ memset(ps->area, 0, ps->snap->store->chunk_size << SECTOR_SHIFT);
}
static int zero_disk_area(struct pstore *ps, chunk_t area)
{
struct dm_io_region where = {
.bdev = ps->snap->cow->bdev,
- .sector = ps->snap->chunk_size * area_location(ps, area),
- .count = ps->snap->chunk_size,
+ .sector = ps->snap->store->chunk_size * area_location(ps, area),
+ .count = ps->snap->store->chunk_size,
};
struct dm_io_request io_req = {
.bi_rw = WRITE,
@@ -278,16 +278,17 @@ static int read_header(struct pstore *ps, int *new_snapshot)
/*
* Use default chunk size (or hardsect_size, if larger) if none supplied
*/
- if (!ps->snap->chunk_size) {
- ps->snap->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
+ if (!ps->snap->store->chunk_size) {
+ ps->snap->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
bdev_hardsect_size(ps->snap->cow->bdev) >> 9);
- ps->snap->chunk_mask = ps->snap->chunk_size - 1;
- ps->snap->chunk_shift = ffs(ps->snap->chunk_size) - 1;
+ ps->snap->store->chunk_mask = ps->snap->store->chunk_size - 1;
+ ps->snap->store->chunk_shift = ffs(ps->snap->store->chunk_size)
+ - 1;
chunk_size_supplied = 0;
}
ps->io_client = dm_io_client_create(sectors_to_pages(ps->snap->
- chunk_size));
+ store->chunk_size));
if (IS_ERR(ps->io_client))
return PTR_ERR(ps->io_client);
@@ -317,22 +318,22 @@ static int read_header(struct pstore *ps, int *new_snapshot)
ps->version = le32_to_cpu(dh->version);
chunk_size = le32_to_cpu(dh->chunk_size);
- if (!chunk_size_supplied || ps->snap->chunk_size == chunk_size)
+ if (!chunk_size_supplied || ps->snap->store->chunk_size == chunk_size)
return 0;
DMWARN("chunk size %llu in device metadata overrides "
"table chunk size of %llu.",
(unsigned long long)chunk_size,
- (unsigned long long)ps->snap->chunk_size);
+ (unsigned long long)ps->snap->store->chunk_size);
/* We had a bogus chunk_size. Fix stuff up. */
free_area(ps);
- ps->snap->chunk_size = chunk_size;
- ps->snap->chunk_mask = chunk_size - 1;
- ps->snap->chunk_shift = ffs(chunk_size) - 1;
+ ps->snap->store->chunk_size = chunk_size;
+ ps->snap->store->chunk_mask = chunk_size - 1;
+ ps->snap->store->chunk_shift = ffs(chunk_size) - 1;
- r = dm_io_client_resize(sectors_to_pages(ps->snap->chunk_size),
+ r = dm_io_client_resize(sectors_to_pages(ps->snap->store->chunk_size),
ps->io_client);
if (r)
return r;
@@ -349,13 +350,13 @@ static int write_header(struct pstore *ps)
{
struct disk_header *dh;
- memset(ps->area, 0, ps->snap->chunk_size << SECTOR_SHIFT);
+ memset(ps->area, 0, ps->snap->store->chunk_size << SECTOR_SHIFT);
dh = (struct disk_header *) ps->area;
dh->magic = cpu_to_le32(SNAP_MAGIC);
dh->valid = cpu_to_le32(ps->valid);
dh->version = cpu_to_le32(ps->version);
- dh->chunk_size = cpu_to_le32(ps->snap->chunk_size);
+ dh->chunk_size = cpu_to_le32(ps->snap->store->chunk_size);
return chunk_io(ps, 0, WRITE, 1);
}
@@ -474,7 +475,7 @@ static struct pstore *get_info(struct dm_exception_store *store)
static void persistent_fraction_full(struct dm_exception_store *store,
sector_t *numerator, sector_t *denominator)
{
- *numerator = get_info(store)->next_free * store->snap->chunk_size;
+ *numerator = get_info(store)->next_free * store->chunk_size;
*denominator = get_dev_size(store->snap->cow->bdev);
}
@@ -507,8 +508,8 @@ static int persistent_read_metadata(struct dm_exception_store *store,
/*
* Now we know correct chunk_size, complete the initialisation.
*/
- ps->exceptions_per_area = (ps->snap->chunk_size << SECTOR_SHIFT) /
- sizeof(struct disk_exception);
+ ps->exceptions_per_area = (ps->snap->store->chunk_size << SECTOR_SHIFT)
+ / sizeof(struct disk_exception);
ps->callbacks = dm_vcalloc(ps->exceptions_per_area,
sizeof(*ps->callbacks));
if (!ps->callbacks)
@@ -567,7 +568,7 @@ static int persistent_prepare_exception(struct dm_exception_store *store,
sector_t size = get_dev_size(store->snap->cow->bdev);
/* Is there enough room ? */
- if (size < ((ps->next_free + 1) * store->snap->chunk_size))
+ if (size < ((ps->next_free + 1) * store->chunk_size))
return -ENOSPC;
e->new_chunk = ps->next_free;
diff --git a/drivers/md/dm-snap-transient.c b/drivers/md/dm-snap-transient.c
index 51bc4a78ce9a..c542ababb418 100644
--- a/drivers/md/dm-snap-transient.c
+++ b/drivers/md/dm-snap-transient.c
@@ -42,11 +42,11 @@ static int transient_prepare_exception(struct dm_exception_store *store,
struct transient_c *tc = store->context;
sector_t size = get_dev_size(store->snap->cow->bdev);
- if (size < (tc->next_free + store->snap->chunk_size))
+ if (size < (tc->next_free + store->chunk_size))
return -1;
e->new_chunk = sector_to_chunk(store->snap, tc->next_free);
- tc->next_free += store->snap->chunk_size;
+ tc->next_free += store->chunk_size;
return 0;
}
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 4429c2a1d6fb..7a90fed033fe 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -468,7 +468,7 @@ static int calc_max_buckets(void)
/*
* Allocate room for a suitable hash table.
*/
-static int init_hash_tables(struct dm_snapshot *s)
+static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift)
{
sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets;
@@ -480,7 +480,7 @@ static int init_hash_tables(struct dm_snapshot *s)
origin_dev_size = get_dev_size(s->origin->bdev);
max_buckets = calc_max_buckets();
- hash_size = min(origin_dev_size, cow_dev_size) >> s->chunk_shift;
+ hash_size = min(origin_dev_size, cow_dev_size) >> chunk_shift;
hash_size = min(hash_size, max_buckets);
hash_size = rounddown_pow_of_two(hash_size);
@@ -515,19 +515,20 @@ static ulong round_up(ulong n, ulong size)
}
static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
- char **error)
+ chunk_t *chunk_size, chunk_t *chunk_mask,
+ chunk_t *chunk_shift, char **error)
{
- unsigned long chunk_size;
+ unsigned long chunk_size_ulong;
char *value;
- chunk_size = simple_strtoul(chunk_size_arg, &value, 10);
+ chunk_size_ulong = simple_strtoul(chunk_size_arg, &value, 10);
if (*chunk_size_arg == '\0' || *value != '\0') {
*error = "Invalid chunk size";
return -EINVAL;
}
- if (!chunk_size) {
- s->chunk_size = s->chunk_mask = s->chunk_shift = 0;
+ if (!chunk_size_ulong) {
+ *chunk_size = *chunk_mask = *chunk_shift = 0;
return 0;
}
@@ -535,23 +536,23 @@ static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
* Chunk size must be multiple of page size. Silently
* round up if it's not.
*/
- chunk_size = round_up(chunk_size, PAGE_SIZE >> 9);
+ chunk_size_ulong = round_up(chunk_size_ulong, PAGE_SIZE >> 9);
/* Check chunk_size is a power of 2 */
- if (!is_power_of_2(chunk_size)) {
+ if (!is_power_of_2(chunk_size_ulong)) {
*error = "Chunk size is not a power of 2";
return -EINVAL;
}
/* Validate the chunk size against the device block size */
- if (chunk_size % (bdev_hardsect_size(s->cow->bdev) >> 9)) {
+ if (chunk_size_ulong % (bdev_hardsect_size(s->cow->bdev) >> 9)) {
*error = "Chunk size is not a multiple of device blocksize";
return -EINVAL;
}
- s->chunk_size = chunk_size;
- s->chunk_mask = chunk_size - 1;
- s->chunk_shift = ffs(chunk_size) - 1;
+ *chunk_size = chunk_size_ulong;
+ *chunk_mask = chunk_size_ulong - 1;
+ *chunk_shift = ffs(chunk_size_ulong) - 1;
return 0;
}
@@ -567,6 +568,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
char persistent;
char *origin_path;
char *cow_path;
+ chunk_t chunk_size, chunk_mask, chunk_shift;
if (argc != 4) {
ti->error = "requires exactly 4 arguments";
@@ -606,7 +608,8 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
goto bad2;
}
- r = set_chunk_size(s, argv[3], &ti->error);
+ r = set_chunk_size(s, argv[3], &chunk_size, &chunk_mask, &chunk_shift,
+ &ti->error);
if (r)
goto bad3;
@@ -617,13 +620,14 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
spin_lock_init(&s->pe_lock);
/* Allocate hash table for COW data */
- if (init_hash_tables(s)) {
+ if (init_hash_tables(s, chunk_shift)) {
ti->error = "Unable to allocate hash table space";
r = -ENOMEM;
goto bad3;
}
- r = dm_exception_store_create(argv[2], ti, &s->store);
+ r = dm_exception_store_create(argv[2], ti, chunk_size, chunk_mask,
+ chunk_shift, &s->store);
if (r) {
ti->error = "Couldn't create exception store";
r = -EINVAL;
@@ -680,7 +684,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
}
ti->private = s;
- ti->split_io = s->chunk_size;
+ ti->split_io = s->store->chunk_size;
return 0;
@@ -955,7 +959,7 @@ static void start_copy(struct dm_snap_pending_exception *pe)
src.bdev = bdev;
src.sector = chunk_to_sector(s, pe->e.old_chunk);
- src.count = min(s->chunk_size, dev_size - src.sector);
+ src.count = min(s->store->chunk_size, dev_size - src.sector);
dest.bdev = s->cow->bdev;
dest.sector = chunk_to_sector(s, pe->e.new_chunk);
@@ -1021,7 +1025,7 @@ static void remap_exception(struct dm_snapshot *s, struct dm_snap_exception *e,
bio->bi_bdev = s->cow->bdev;
bio->bi_sector = chunk_to_sector(s, dm_chunk_number(e->new_chunk) +
(chunk - e->old_chunk)) +
- (bio->bi_sector & s->chunk_mask);
+ (bio->bi_sector & s->store->chunk_mask);
}
static int snapshot_map(struct dm_target *ti, struct bio *bio,
@@ -1166,7 +1170,7 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
snprintf(result, maxlen, "%s %s %s %llu",
snap->origin->name, snap->cow->name,
snap->store->type->name,
- (unsigned long long)snap->chunk_size);
+ (unsigned long long)snap->store->chunk_size);
break;
}
@@ -1377,7 +1381,8 @@ static void origin_resume(struct dm_target *ti)
o = __lookup_origin(dev->bdev);
if (o)
list_for_each_entry (snap, &o->snapshots, list)
- chunk_size = min_not_zero(chunk_size, snap->chunk_size);
+ chunk_size = min_not_zero(chunk_size,
+ snap->store->chunk_size);
up_read(&_origins_lock);
ti->split_io = chunk_size;
diff --git a/drivers/md/dm-snap.h b/drivers/md/dm-snap.h
index 93cd8ee8997f..c2e4ebedbd49 100644
--- a/drivers/md/dm-snap.h
+++ b/drivers/md/dm-snap.h
@@ -32,11 +32,6 @@ struct dm_snapshot {
/* List of snapshots per Origin */
struct list_head list;
- /* Size of data blocks saved - must be a power of 2 */
- chunk_t chunk_size;
- chunk_t chunk_mask;
- chunk_t chunk_shift;
-
/* You can't use a snapshot if this is 0 (e.g. if full) */
int valid;
@@ -84,12 +79,12 @@ static inline sector_t get_dev_size(struct block_device *bdev)
static inline chunk_t sector_to_chunk(struct dm_snapshot *s, sector_t sector)
{
- return (sector & ~s->chunk_mask) >> s->chunk_shift;
+ return (sector & ~s->store->chunk_mask) >> s->store->chunk_shift;
}
static inline sector_t chunk_to_sector(struct dm_snapshot *s, chunk_t chunk)
{
- return chunk << s->chunk_shift;
+ return chunk << s->store->chunk_shift;
}
static inline int bdev_equal(struct block_device *lhs, struct block_device *rhs)
--
cgit v1.2.3
From 49beb2b87a972a994ff77633234ca3bf0d30a1d8 Mon Sep 17 00:00:00 2001
From: Jonathan Brassow <jbrassow@redhat.com>
Date: Thu, 2 Apr 2009 19:55:33 +0100
Subject: dm exception store: move cow pointer
Move COW device from snapshot to exception store.
Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
---
drivers/md/dm-exception-store.c | 4 +++-
drivers/md/dm-exception-store.h | 4 +++-
drivers/md/dm-snap-persistent.c | 10 +++++-----
drivers/md/dm-snap-transient.c | 4 ++--
drivers/md/dm-snap.c | 30 +++++++++++++++++-------------
drivers/md/dm-snap.h | 1 -
6 files changed, 30 insertions(+), 23 deletions(-)
(limited to 'drivers/md/dm-exception-store.c')
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index 59c949b53106..2078b92470a1 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -139,7 +139,7 @@ EXPORT_SYMBOL(dm_exception_store_type_unregister);
int dm_exception_store_create(const char *type_name, struct dm_target *ti,
chunk_t chunk_size, chunk_t chunk_mask,
- chunk_t chunk_shift,
+ chunk_t chunk_shift, struct dm_dev *cow,
struct dm_exception_store **store)
{
int r = 0;
@@ -163,6 +163,8 @@ int dm_exception_store_create(const char *type_name, struct dm_target *ti,
tmp_store->chunk_mask = chunk_mask;
tmp_store->chunk_shift = chunk_shift;
+ tmp_store->cow = cow;
+
r = type->ctr(tmp_store, 0, NULL);
if (r) {
put_type(type);
diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h
index 449a1e48f7aa..4dbf3577408e 100644
--- a/drivers/md/dm-exception-store.h
+++ b/drivers/md/dm-exception-store.h
@@ -99,6 +99,8 @@ struct dm_exception_store {
struct dm_snapshot *snap;
+ struct dm_dev *cow;
+
/* Size of data blocks saved - must be a power of 2 */
chunk_t chunk_size;
chunk_t chunk_mask;
@@ -155,7 +157,7 @@ int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
int dm_exception_store_create(const char *type_name, struct dm_target *ti,
chunk_t chunk_size, chunk_t chunk_mask,
- chunk_t chunk_shift,
+ chunk_t chunk_shift, struct dm_dev *cow,
struct dm_exception_store **store);
void dm_exception_store_destroy(struct dm_exception_store *store);
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index c3c58159b6e8..505afac9976f 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -189,7 +189,7 @@ static void do_metadata(struct work_struct *work)
static int chunk_io(struct pstore *ps, chunk_t chunk, int rw, int metadata)
{
struct dm_io_region where = {
- .bdev = ps->snap->cow->bdev,
+ .bdev = ps->snap->store->cow->bdev,
.sector = ps->snap->store->chunk_size * chunk,
.count = ps->snap->store->chunk_size,
};
@@ -253,7 +253,7 @@ static void zero_memory_area(struct pstore *ps)
static int zero_disk_area(struct pstore *ps, chunk_t area)
{
struct dm_io_region where = {
- .bdev = ps->snap->cow->bdev,
+ .bdev = ps->snap->store->cow->bdev,
.sector = ps->snap->store->chunk_size * area_location(ps, area),
.count = ps->snap->store->chunk_size,
};
@@ -280,7 +280,7 @@ static int read_header(struct pstore *ps, int *new_snapshot)
*/
if (!ps->snap->store->chunk_size) {
ps->snap->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
- bdev_hardsect_size(ps->snap->cow->bdev) >> 9);
+ bdev_hardsect_size(ps->snap->store->cow->bdev) >> 9);
ps->snap->store->chunk_mask = ps->snap->store->chunk_size - 1;
ps->snap->store->chunk_shift = ffs(ps->snap->store->chunk_size)
- 1;
@@ -476,7 +476,7 @@ static void persistent_fraction_full(struct dm_exception_store *store,
sector_t *numerator, sector_t *denominator)
{
*numerator = get_info(store)->next_free * store->chunk_size;
- *denominator = get_dev_size(store->snap->cow->bdev);
+ *denominator = get_dev_size(store->cow->bdev);
}
static void persistent_dtr(struct dm_exception_store *store)
@@ -565,7 +565,7 @@ static int persistent_prepare_exception(struct dm_exception_store *store,
struct pstore *ps = get_info(store);
uint32_t stride;
chunk_t next_free;
- sector_t size = get_dev_size(store->snap->cow->bdev);
+ sector_t size = get_dev_size(store->cow->bdev);
/* Is there enough room ? */
if (size < ((ps->next_free + 1) * store->chunk_size))
diff --git a/drivers/md/dm-snap-transient.c b/drivers/md/dm-snap-transient.c
index c542ababb418..77f58be080c4 100644
--- a/drivers/md/dm-snap-transient.c
+++ b/drivers/md/dm-snap-transient.c
@@ -40,7 +40,7 @@ static int transient_prepare_exception(struct dm_exception_store *store,
struct dm_snap_exception *e)
{
struct transient_c *tc = store->context;
- sector_t size = get_dev_size(store->snap->cow->bdev);
+ sector_t size = get_dev_size(store->cow->bdev);
if (size < (tc->next_free + store->chunk_size))
return -1;
@@ -64,7 +64,7 @@ static void transient_fraction_full(struct dm_exception_store *store,
sector_t *numerator, sector_t *denominator)
{
*numerator = ((struct transient_c *) store->context)->next_free;
- *denominator = get_dev_size(store->snap->cow->bdev);
+ *denominator = get_dev_size(store->cow->bdev);
}
static int transient_ctr(struct dm_exception_store *store,
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 7a90fed033fe..5c067efc665f 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -468,7 +468,8 @@ static int calc_max_buckets(void)
/*
* Allocate room for a suitable hash table.
*/
-static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift)
+static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift,
+ struct dm_dev *cow)
{
sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets;
@@ -476,7 +477,7 @@ static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift)
* Calculate based on the size of the original volume or
* the COW volume...
*/
- cow_dev_size = get_dev_size(s->cow->bdev);
+ cow_dev_size = get_dev_size(cow->bdev);
origin_dev_size = get_dev_size(s->origin->bdev);
max_buckets = calc_max_buckets();
@@ -516,7 +517,8 @@ static ulong round_up(ulong n, ulong size)
static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
chunk_t *chunk_size, chunk_t *chunk_mask,
- chunk_t *chunk_shift, char **error)
+ chunk_t *chunk_shift, struct dm_dev *cow,
+ char **error)
{
unsigned long chunk_size_ulong;
char *value;
@@ -545,7 +547,7 @@ static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
}
/* Validate the chunk size against the device block size */
- if (chunk_size_ulong % (bdev_hardsect_size(s->cow->bdev) >> 9)) {
+ if (chunk_size_ulong % (bdev_hardsect_size(cow->bdev) >> 9)) {
*error = "Chunk size is not a multiple of device blocksize";
return -EINVAL;
}
@@ -569,6 +571,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
char *origin_path;
char *cow_path;
chunk_t chunk_size, chunk_mask, chunk_shift;
+ struct dm_dev *cow;
if (argc != 4) {
ti->error = "requires exactly 4 arguments";
@@ -601,7 +604,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
}
r = dm_get_device(ti, cow_path, 0, 0,
- FMODE_READ | FMODE_WRITE, &s->cow);
+ FMODE_READ | FMODE_WRITE, &cow);
if (r) {
dm_put_device(ti, s->origin);
ti->error = "Cannot get COW device";
@@ -609,7 +612,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
}
r = set_chunk_size(s, argv[3], &chunk_size, &chunk_mask, &chunk_shift,
- &ti->error);
+ cow, &ti->error);
if (r)
goto bad3;
@@ -620,14 +623,14 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
spin_lock_init(&s->pe_lock);
/* Allocate hash table for COW data */
- if (init_hash_tables(s, chunk_shift)) {
+ if (init_hash_tables(s, chunk_shift, cow)) {
ti->error = "Unable to allocate hash table space";
r = -ENOMEM;
goto bad3;
}
r = dm_exception_store_create(argv[2], ti, chunk_size, chunk_mask,
- chunk_shift, &s->store);
+ chunk_shift, cow, &s->store);
if (r) {
ti->error = "Couldn't create exception store";
r = -EINVAL;
@@ -705,7 +708,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
exit_exception_table(&s->complete, exception_cache);
bad3:
- dm_put_device(ti, s->cow);
+ dm_put_device(ti, cow);
dm_put_device(ti, s->origin);
bad2:
@@ -732,6 +735,7 @@ static void snapshot_dtr(struct dm_target *ti)
int i;
#endif
struct dm_snapshot *s = ti->private;
+ struct dm_dev *cow = s->store->cow;
flush_workqueue(ksnapd);
@@ -759,7 +763,7 @@ static void snapshot_dtr(struct dm_target *ti)
mempool_destroy(s->pending_pool);
dm_put_device(ti, s->origin);
- dm_put_device(ti, s->cow);
+ dm_put_device(ti, cow);
kfree(s);
}
@@ -961,7 +965,7 @@ static void start_copy(struct dm_snap_pending_exception *pe)
src.sector = chunk_to_sector(s, pe->e.old_chunk);
src.count = min(s->store->chunk_size, dev_size - src.sector);
- dest.bdev = s->cow->bdev;
+ dest.bdev = s->store->cow->bdev;
dest.sector = chunk_to_sector(s, pe->e.new_chunk);
dest.count = src.count;
@@ -1022,7 +1026,7 @@ __find_pending_exception(struct dm_snapshot *s,
static void remap_exception(struct dm_snapshot *s, struct dm_snap_exception *e,
struct bio *bio, chunk_t chunk)
{
- bio->bi_bdev = s->cow->bdev;
+ bio->bi_bdev = s->store->cow->bdev;
bio->bi_sector = chunk_to_sector(s, dm_chunk_number(e->new_chunk) +
(chunk - e->old_chunk)) +
(bio->bi_sector & s->store->chunk_mask);
@@ -1168,7 +1172,7 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
* make sense.
*/
snprintf(result, maxlen, "%s %s %s %llu",
- snap->origin->name, snap->cow->name,
+ snap->origin->name, snap->store->cow->name,
snap->store->type->name,
(unsigned long long)snap->store->chunk_size);
break;
diff --git a/drivers/md/dm-snap.h b/drivers/md/dm-snap.h
index c2e4ebedbd49..c8a486e0ea2c 100644
--- a/drivers/md/dm-snap.h
+++ b/drivers/md/dm-snap.h
@@ -27,7 +27,6 @@ struct dm_snapshot {
struct rw_semaphore lock;
struct dm_dev *origin;
- struct dm_dev *cow;
/* List of snapshots per Origin */
struct list_head list;
--
cgit v1.2.3
From fee1998e9c690f9920671e1e0ef187a48cfbbde4 Mon Sep 17 00:00:00 2001
From: Jonathan Brassow <jbrassow@redhat.com>
Date: Thu, 2 Apr 2009 19:55:34 +0100
Subject: dm snapshot: move ctr parsing to exception store
First step of having the exception stores parse their own arguments -
generalizing the interface.
Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
---
drivers/md/dm-exception-store.c | 109 +++++++++++++++++++++++++----
drivers/md/dm-exception-store.h | 5 +-
drivers/md/dm-snap.c | 147 ++++++++++------------------------------
3 files changed, 132 insertions(+), 129 deletions(-)
(limited to 'drivers/md/dm-exception-store.c')
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index 2078b92470a1..a2e26c242141 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -7,6 +7,7 @@
#include "dm-exception-store.h"
+#include <linux/ctype.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/vmalloc.h>
@@ -137,49 +138,129 @@ int dm_exception_store_type_unregister(struct dm_exception_store_type *type)
}
EXPORT_SYMBOL(dm_exception_store_type_unregister);
-int dm_exception_store_create(const char *type_name, struct dm_target *ti,
- chunk_t chunk_size, chunk_t chunk_mask,
- chunk_t chunk_shift, struct dm_dev *cow,
+/*
+ * Round a number up to the nearest 'size' boundary. size must
+ * be a power of 2.
+ */
+static ulong round_up(ulong n, ulong size)
+{
+ size--;
+ return (n + size) & ~size;
+}
+
+static int set_chunk_size(struct dm_exception_store *store,
+ const char *chunk_size_arg, char **error)
+{
+ unsigned long chunk_size_ulong;
+ char *value;
+
+ chunk_size_ulong = simple_strtoul(chunk_size_arg, &value, 10);
+ if (*chunk_size_arg == '\0' || *value != '\0') {
+ *error = "Invalid chunk size";
+ return -EINVAL;
+ }
+
+ if (!chunk_size_ulong) {
+ store->chunk_size = store->chunk_mask = store->chunk_shift = 0;
+ return 0;
+ }
+
+ /*
+ * Chunk size must be multiple of page size. Silently
+ * round up if it's not.
+ */
+ chunk_size_ulong = round_up(chunk_size_ulong, PAGE_SIZE >> 9);
+
+ /* Check chunk_size is a power of 2 */
+ if (!is_power_of_2(chunk_size_ulong)) {
+ *error = "Chunk size is not a power of 2";
+ return -EINVAL;
+ }
+
+ /* Validate the chunk size against the device block size */
+ if (chunk_size_ulong % (bdev_hardsect_size(store->cow->bdev) >> 9)) {
+ *error = "Chunk size is not a multiple of device blocksize";
+ return -EINVAL;
+ }
+
+ store->chunk_size = chunk_size_ulong;
+ store->chunk_mask = chunk_size_ulong - 1;
+ store->chunk_shift = ffs(chunk_size_ulong) - 1;
+
+ return 0;
+}
+
+int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
+ unsigned *args_used,
struct dm_exception_store **store)
{
int r = 0;
struct dm_exception_store_type *type;
struct dm_exception_store *tmp_store;
+ char persistent;
+
+ if (argc < 3) {
+ ti->error = "Insufficient exception store arguments";
+ return -EINVAL;
+ }
tmp_store = kmalloc(sizeof(*tmp_store), GFP_KERNEL);
- if (!tmp_store)
+ if (!tmp_store) {
+ ti->error = "Exception store allocation failed";
return -ENOMEM;
+ }
- type = get_type(type_name);
- if (!type) {
- kfree(tmp_store);
+ persistent = toupper(*argv[1]);
+ if (persistent != 'P' && persistent != 'N') {
+ ti->error = "Persistent flag is not P or N";
return -EINVAL;
}
+ type = get_type(argv[1]);
+ if (!type) {
+ ti->error = "Exception store type not recognised";
+ r = -EINVAL;
+ goto bad_type;
+ }
+
tmp_store->type = type;
tmp_store->ti = ti;
- tmp_store->chunk_size = chunk_size;
- tmp_store->chunk_mask = chunk_mask;
- tmp_store->chunk_shift = chunk_shift;
+ r = dm_get_device(ti, argv[0], 0, 0,
+ FMODE_READ | FMODE_WRITE, &tmp_store->cow);
+ if (r) {
+ ti->error = "Cannot get COW device";
+ goto bad_cow;
+ }
- tmp_store->cow = cow;
+ r = set_chunk_size(tmp_store, argv[2], &ti->error);
+ if (r)
+ goto bad_cow;
r = type->ctr(tmp_store, 0, NULL);
if (r) {
- put_type(type);
- kfree(tmp_store);
- return r;
+ ti->error = "Exception store type constructor failed";
+ goto bad_ctr;
}
+ *args_used = 3;
*store = tmp_store;
return 0;
+
+bad_ctr:
+ dm_put_device(ti, tmp_store->cow);
+bad_cow:
+ put_type(type);
+bad_type:
+ kfree(tmp_store);
+ return r;
}
EXPORT_SYMBOL(dm_exception_store_create);
void dm_exception_store_destroy(struct dm_exception_store *store)
{
store->type->dtr(store);
+ dm_put_device(store->ti, store->cow);
put_type(store->type);
kfree(store);
}
diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h
index 835f402d9470..023a707503c4 100644
--- a/drivers/md/dm-exception-store.h
+++ b/drivers/md/dm-exception-store.h
@@ -167,9 +167,8 @@ static inline chunk_t sector_to_chunk(struct dm_exception_store *store,
int dm_exception_store_type_register(struct dm_exception_store_type *type);
int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
-int dm_exception_store_create(const char *type_name, struct dm_target *ti,
- chunk_t chunk_size, chunk_t chunk_mask,
- chunk_t chunk_shift, struct dm_dev *cow,
+int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
+ unsigned *args_used,
struct dm_exception_store **store);
void dm_exception_store_destroy(struct dm_exception_store *store);
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index fcb1ac12119f..974916b9ea21 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -7,7 +7,6 @@
*/
#include <linux/blkdev.h>
-#include <linux/ctype.h>
#include <linux/device-mapper.h>
#include <linux/delay.h>
#include <linux/fs.h>
@@ -538,8 +537,7 @@ static int calc_max_buckets(void)
/*
* Allocate room for a suitable hash table.
*/
-static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift,
- struct dm_dev *cow)
+static int init_hash_tables(struct dm_snapshot *s)
{
sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets;
@@ -547,11 +545,11 @@ static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift,
* Calculate based on the size of the original volume or
* the COW volume...
*/
- cow_dev_size = get_dev_size(cow->bdev);
+ cow_dev_size = get_dev_size(s->store->cow->bdev);
origin_dev_size = get_dev_size(s->origin->bdev);
max_buckets = calc_max_buckets();
- hash_size = min(origin_dev_size, cow_dev_size) >> chunk_shift;
+ hash_size = min(origin_dev_size, cow_dev_size) >> s->store->chunk_shift;
hash_size = min(hash_size, max_buckets);
hash_size = rounddown_pow_of_two(hash_size);
@@ -575,60 +573,6 @@ static int init_hash_tables(struct dm_snapshot *s, chunk_t chunk_shift,
return 0;
}
-/*
- * Round a number up to the nearest 'size' boundary. size must
- * be a power of 2.
- */
-static ulong round_up(ulong n, ulong size)
-{
- size--;
- return (n + size) & ~size;
-}
-
-static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
- chunk_t *chunk_size, chunk_t *chunk_mask,
- chunk_t *chunk_shift, struct dm_dev *cow,
- char **error)
-{
- unsigned long chunk_size_ulong;
- char *value;
-
- chunk_size_ulong = simple_strtoul(chunk_size_arg, &value, 10);
- if (*chunk_size_arg == '\0' || *value != '\0') {
- *error = "Invalid chunk size";
- return -EINVAL;
- }
-
- if (!chunk_size_ulong) {
- *chunk_size = *chunk_mask = *chunk_shift = 0;
- return 0;
- }
-
- /*
- * Chunk size must be multiple of page size. Silently
- * round up if it's not.
- */
- chunk_size_ulong = round_up(chunk_size_ulong, PAGE_SIZE >> 9);
-
- /* Check chunk_size is a power of 2 */
- if (!is_power_of_2(chunk_size_ulong)) {
- *error = "Chunk size is not a power of 2";
- return -EINVAL;
- }
-
- /* Validate the chunk size against the device block size */
- if (chunk_size_ulong % (bdev_hardsect_size(cow->bdev) >> 9)) {
- *error = "Chunk size is not a multiple of device blocksize";
- return -EINVAL;
- }
-
- *chunk_size = chunk_size_ulong;
- *chunk_mask = chunk_size_ulong - 1;
- *chunk_shift = ffs(chunk_size_ulong) - 1;
-
- return 0;
-}
-
/*
* Construct a snapshot mapping: <origin_dev> <COW-dev> <p/n> <chunk-size>
*/
@@ -637,55 +581,45 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
struct dm_snapshot *s;
int i;
int r = -EINVAL;
- char persistent;
char *origin_path;
- char *cow_path;
- chunk_t chunk_size, chunk_mask, chunk_shift;
- struct dm_dev *cow;
+ struct dm_exception_store *store;
+ unsigned args_used;
if (argc != 4) {
ti->error = "requires exactly 4 arguments";
r = -EINVAL;
- goto bad1;
+ goto bad_args;
}
origin_path = argv[0];
- cow_path = argv[1];
- persistent = toupper(*argv[2]);
+ argv++;
+ argc--;
- if (persistent != 'P' && persistent != 'N') {
- ti->error = "Persistent flag is not P or N";
+ r = dm_exception_store_create(ti, argc, argv, &args_used, &store);
+ if (r) {
+ ti->error = "Couldn't create exception store";
r = -EINVAL;
- goto bad1;
+ goto bad_args;
}
+ argv += args_used;
+ argc -= args_used;
+
s = kmalloc(sizeof(*s), GFP_KERNEL);
- if (s == NULL) {
+ if (!s) {
ti->error = "Cannot allocate snapshot context private "
"structure";
r = -ENOMEM;
- goto bad1;
+ goto bad_snap;
}
r = dm_get_device(ti, origin_path, 0, ti->len, FMODE_READ, &s->origin);
if (r) {
ti->error = "Cannot get origin device";
- goto bad2;
+ goto bad_origin;
}
- r = dm_get_device(ti, cow_path, 0, 0,
- FMODE_READ | FMODE_WRITE, &cow);
- if (r) {
- dm_put_device(ti, s->origin);
- ti->error = "Cannot get COW device";
- goto bad2;
- }
-
- r = set_chunk_size(s, argv[3], &chunk_size, &chunk_mask, &chunk_shift,
- cow, &ti->error);
- if (r)
- goto bad3;
-
+ s->store = store;
s->valid = 1;
s->active = 0;
atomic_set(&s->pending_exceptions_count, 0);
@@ -693,30 +627,22 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
spin_lock_init(&s->pe_lock);
/* Allocate hash table for COW data */
- if (init_hash_tables(s, chunk_shift, cow)) {
+ if (init_hash_tables(s)) {
ti->error = "Unable to allocate hash table space";
r = -ENOMEM;
- goto bad3;
- }
-
- r = dm_exception_store_create(argv[2], ti, chunk_size, chunk_mask,
- chunk_shift, cow, &s->store);
- if (r) {
- ti->error = "Couldn't create exception store";
- r = -EINVAL;
- goto bad4;
+ goto bad_hash_tables;
}
r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);
if (r) {
ti->error = "Could not create kcopyd client";
- goto bad5;
+ goto bad_kcopyd;
}
s->pending_pool = mempool_create_slab_pool(MIN_IOS, pending_cache);
if (!s->pending_pool) {
ti->error = "Could not allocate mempool for pending exceptions";
- goto bad6;
+ goto bad_pending_pool;
}
s->tracked_chunk_pool = mempool_create_slab_pool(MIN_IOS,
@@ -759,30 +685,29 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
return 0;
- bad_load_and_register:
+bad_load_and_register:
mempool_destroy(s->tracked_chunk_pool);
- bad_tracked_chunk_pool:
+bad_tracked_chunk_pool:
mempool_destroy(s->pending_pool);
- bad6:
+bad_pending_pool:
dm_kcopyd_client_destroy(s->kcopyd_client);
- bad5:
- s->store->type->dtr(s->store);
-
- bad4:
+bad_kcopyd:
exit_exception_table(&s->pending, pending_cache);
exit_exception_table(&s->complete, exception_cache);
- bad3:
- dm_put_device(ti, cow);
+bad_hash_tables:
dm_put_device(ti, s->origin);
- bad2:
+bad_origin:
kfree(s);
- bad1:
+bad_snap:
+ dm_exception_store_destroy(store);
+
+bad_args:
return r;
}
@@ -793,8 +718,6 @@ static void __free_exceptions(struct dm_snapshot *s)
exit_exception_table(&s->pending, pending_cache);
exit_exception_table(&s->complete, exception_cache);
-
- s->store->type->dtr(s->store);
}
static void snapshot_dtr(struct dm_target *ti)
@@ -803,7 +726,6 @@ static void snapshot_dtr(struct dm_target *ti)
int i;
#endif
struct dm_snapshot *s = ti->private;
- struct dm_dev *cow = s->store->cow;
flush_workqueue(ksnapd);
@@ -831,7 +753,8 @@ static void snapshot_dtr(struct dm_target *ti)
mempool_destroy(s->pending_pool);
dm_put_device(ti, s->origin);
- dm_put_device(ti, cow);
+
+ dm_exception_store_destroy(s->store);
kfree(s);
}
--
cgit v1.2.3