[PATCH] dm snapshot: allow zero chunk_size
authorMark McLoughlin <markmc@redhat.com>
Tue, 3 Oct 2006 08:15:25 +0000 (01:15 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Tue, 3 Oct 2006 15:04:14 +0000 (08:04 -0700)
The chunk size of snapshots cannot be changed so it is redundant to require it
as a parameter when activating an existing snapshot.  Allow a value of zero in
this case and ignore it.  For a new snapshot, use a default value if zero is
specified.

Signed-off-by: Mark McLoughlin <markmc@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
drivers/md/dm-exception-store.c
drivers/md/dm-snap.c
drivers/md/dm-snap.h

index d12379b5cdb5137da258453bf6729cc1f44d49af..8b4cd02f75a819957dd9a3a0f41a12742741dc04 100644 (file)
@@ -17,6 +17,7 @@
 #include <linux/slab.h>
 
 #define DM_MSG_PREFIX "snapshots"
+#define DM_CHUNK_SIZE_DEFAULT_SECTORS 32       /* 16KB */
 
 /*-----------------------------------------------------------------
  * Persistent snapshots, by persistent we mean that the snapshot
@@ -150,6 +151,7 @@ static int alloc_area(struct pstore *ps)
 static void free_area(struct pstore *ps)
 {
        vfree(ps->area);
+       ps->area = NULL;
 }
 
 /*
@@ -198,48 +200,79 @@ static int read_header(struct pstore *ps, int *new_snapshot)
        int r;
        struct disk_header *dh;
        chunk_t chunk_size;
+       int chunk_size_supplied = 1;
 
-       r = chunk_io(ps, 0, READ);
+       /*
+        * 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,
+                   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;
+               chunk_size_supplied = 0;
+       }
+
+       r = dm_io_get(sectors_to_pages(ps->snap->chunk_size));
        if (r)
                return r;
 
+       r = alloc_area(ps);
+       if (r)
+               goto bad1;
+
+       r = chunk_io(ps, 0, READ);
+       if (r)
+               goto bad2;
+
        dh = (struct disk_header *) ps->area;
 
        if (le32_to_cpu(dh->magic) == 0) {
                *new_snapshot = 1;
+               return 0;
+       }
 
-       } else if (le32_to_cpu(dh->magic) == SNAP_MAGIC) {
-               *new_snapshot = 0;
-               ps->valid = le32_to_cpu(dh->valid);
-               ps->version = le32_to_cpu(dh->version);
-               chunk_size = le32_to_cpu(dh->chunk_size);
-               if (ps->snap->chunk_size != chunk_size) {
-                       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);
-
-                       /* We had a bogus chunk_size. Fix stuff up. */
-                       dm_io_put(sectors_to_pages(ps->snap->chunk_size));
-                       free_area(ps);
-
-                       ps->snap->chunk_size = chunk_size;
-                       ps->snap->chunk_mask = chunk_size - 1;
-                       ps->snap->chunk_shift = ffs(chunk_size) - 1;
-
-                       r = alloc_area(ps);
-                       if (r)
-                               return r;
-
-                       r = dm_io_get(sectors_to_pages(chunk_size));
-                       if (r)
-                               return r;
-               }
-       } else {
-               DMWARN("Invalid/corrupt snapshot");
+       if (le32_to_cpu(dh->magic) != SNAP_MAGIC) {
+               DMWARN("Invalid or corrupt snapshot");
                r = -ENXIO;
+               goto bad2;
        }
 
+       *new_snapshot = 0;
+       ps->valid = le32_to_cpu(dh->valid);
+       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)
+               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);
+
+       /* We had a bogus chunk_size. Fix stuff up. */
+       dm_io_put(sectors_to_pages(ps->snap->chunk_size));
+       free_area(ps);
+
+       ps->snap->chunk_size = chunk_size;
+       ps->snap->chunk_mask = chunk_size - 1;
+       ps->snap->chunk_shift = ffs(chunk_size) - 1;
+
+       r = dm_io_get(sectors_to_pages(chunk_size));
+       if (r)
+               return r;
+
+       r = alloc_area(ps);
+       if (r)
+               goto bad1;
+
+       return 0;
+
+bad2:
+       free_area(ps);
+bad1:
+       dm_io_put(sectors_to_pages(ps->snap->chunk_size));
        return r;
 }
 
@@ -547,32 +580,22 @@ static void persistent_drop(struct exception_store *store)
                DMWARN("write header failed");
 }
 
-int dm_create_persistent(struct exception_store *store, uint32_t chunk_size)
+int dm_create_persistent(struct exception_store *store)
 {
-       int r;
        struct pstore *ps;
 
-       r = dm_io_get(sectors_to_pages(chunk_size));
-       if (r)
-               return r;
-
        /* allocate the pstore */
        ps = kmalloc(sizeof(*ps), GFP_KERNEL);
-       if (!ps) {
-               r = -ENOMEM;
-               goto bad;
-       }
+       if (!ps)
+               return -ENOMEM;
 
        ps->snap = store->snap;
        ps->valid = 1;
        ps->version = SNAPSHOT_DISK_VERSION;
+       ps->area = NULL;
        ps->next_free = 2;      /* skipping the header and first area */
        ps->current_committed = 0;
 
-       r = alloc_area(ps);
-       if (r)
-               goto bad;
-
        ps->callback_count = 0;
        atomic_set(&ps->pending_count, 0);
        ps->callbacks = NULL;
@@ -586,13 +609,6 @@ int dm_create_persistent(struct exception_store *store, uint32_t chunk_size)
        store->context = ps;
 
        return 0;
-
-      bad:
-       dm_io_put(sectors_to_pages(chunk_size));
-       if (ps && ps->area)
-               free_area(ps);
-       kfree(ps);
-       return r;
 }
 
 /*-----------------------------------------------------------------
@@ -642,18 +658,16 @@ static void transient_fraction_full(struct exception_store *store,
        *denominator = get_dev_size(store->snap->cow->bdev);
 }
 
-int dm_create_transient(struct exception_store *store,
-                       struct dm_snapshot *s, int blocksize)
+int dm_create_transient(struct exception_store *store)
 {
        struct transient_c *tc;
 
-       memset(store, 0, sizeof(*store));
        store->destroy = transient_destroy;
        store->read_metadata = transient_read_metadata;
        store->prepare_exception = transient_prepare;
        store->commit_exception = transient_commit;
+       store->drop_snapshot = NULL;
        store->fraction_full = transient_fraction_full;
-       store->snap = s;
 
        tc = kmalloc(sizeof(struct transient_c), GFP_KERNEL);
        if (!tc)
index 7c14867b5903e6cac0f6360a0633aed2cdfb9aeb..89f8dd1bfaa01684cd569374686e6fb3ef109a36 100644 (file)
@@ -398,21 +398,60 @@ static void read_snapshot_metadata(struct dm_snapshot *s)
        }
 }
 
+static int set_chunk_size(struct dm_snapshot *s, const char *chunk_size_arg,
+                         char **error)
+{
+       unsigned long chunk_size;
+       char *value;
+
+       chunk_size = 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;
+               return 0;
+       }
+
+       /*
+        * Chunk size must be multiple of page size.  Silently
+        * round up if it's not.
+        */
+       chunk_size = round_up(chunk_size, PAGE_SIZE >> 9);
+
+       /* Check chunk_size is a power of 2 */
+       if (chunk_size & (chunk_size - 1)) {
+               *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)) {
+               *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;
+
+       return 0;
+}
+
 /*
  * Construct a snapshot mapping: <origin_dev> <COW-dev> <p/n> <chunk-size>
  */
 static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
        struct dm_snapshot *s;
-       unsigned long chunk_size;
        int r = -EINVAL;
        char persistent;
        char *origin_path;
        char *cow_path;
-       char *value;
-       int blocksize;
 
-       if (argc < 4) {
+       if (argc != 4) {
                ti->error = "requires exactly 4 arguments";
                r = -EINVAL;
                goto bad1;
@@ -428,13 +467,6 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto bad1;
        }
 
-       chunk_size = simple_strtoul(argv[3], &value, 10);
-       if (chunk_size == 0 || value == NULL) {
-               ti->error = "Invalid chunk size";
-               r = -EINVAL;
-               goto bad1;
-       }
-
        s = kmalloc(sizeof(*s), GFP_KERNEL);
        if (s == NULL) {
                ti->error = "Cannot allocate snapshot context private "
@@ -457,31 +489,11 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto bad2;
        }
 
-       /*
-        * Chunk size must be multiple of page size.  Silently
-        * round up if it's not.
-        */
-       chunk_size = round_up(chunk_size, PAGE_SIZE >> 9);
-
-       /* Validate the chunk size against the device block size */
-       blocksize = s->cow->bdev->bd_disk->queue->hardsect_size;
-       if (chunk_size % (blocksize >> 9)) {
-               ti->error = "Chunk size is not a multiple of device blocksize";
-               r = -EINVAL;
-               goto bad3;
-       }
-
-       /* Check chunk_size is a power of 2 */
-       if (chunk_size & (chunk_size - 1)) {
-               ti->error = "Chunk size is not a power of 2";
-               r = -EINVAL;
+       r = set_chunk_size(s, argv[3], &ti->error);
+       if (r)
                goto bad3;
-       }
 
-       s->chunk_size = chunk_size;
-       s->chunk_mask = chunk_size - 1;
        s->type = persistent;
-       s->chunk_shift = ffs(chunk_size) - 1;
 
        s->valid = 1;
        s->active = 0;
@@ -496,16 +508,12 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto bad3;
        }
 
-       /*
-        * Check the persistent flag - done here because we need the iobuf
-        * to check the LV header
-        */
        s->store.snap = s;
 
        if (persistent == 'P')
-               r = dm_create_persistent(&s->store, chunk_size);
+               r = dm_create_persistent(&s->store);
        else
-               r = dm_create_transient(&s->store, s, blocksize);
+               r = dm_create_transient(&s->store);
 
        if (r) {
                ti->error = "Couldn't create exception store";
@@ -1205,7 +1213,7 @@ static int origin_status(struct dm_target *ti, status_type_t type, char *result,
 
 static struct target_type origin_target = {
        .name    = "snapshot-origin",
-       .version = {1, 4, 0},
+       .version = {1, 5, 0},
        .module  = THIS_MODULE,
        .ctr     = origin_ctr,
        .dtr     = origin_dtr,
@@ -1216,7 +1224,7 @@ static struct target_type origin_target = {
 
 static struct target_type snapshot_target = {
        .name    = "snapshot",
-       .version = {1, 4, 0},
+       .version = {1, 5, 0},
        .module  = THIS_MODULE,
        .ctr     = snapshot_ctr,
        .dtr     = snapshot_dtr,
index fdec1e2dc87183926cac41e1d62fc961e9aab851..221eb8880c80aac21e5ae8aad3c02e43e71ec673 100644 (file)
@@ -128,10 +128,9 @@ int dm_add_exception(struct dm_snapshot *s, chunk_t old, chunk_t new);
  * Constructor and destructor for the default persistent
  * store.
  */
-int dm_create_persistent(struct exception_store *store, uint32_t chunk_size);
+int dm_create_persistent(struct exception_store *store);
 
-int dm_create_transient(struct exception_store *store,
-                       struct dm_snapshot *s, int blocksize);
+int dm_create_transient(struct exception_store *store);
 
 /*
  * Return the number of sectors in the device.