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>

1 files changed, 24 insertions, 23 deletions

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;