lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

dm snapshot: remove dm_snap header use

Browse Source 
Move useful functions out of dm-snap.h and stop using dm-snap.h.

Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
This commit is contained in:
Jonathan Brassow
2009-04-02 19:55:33 +01:00
committed by Alasdair G Kergon
parent 49beb2b87a
commit 71fab00a6b
5 changed files with 54 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
drivers/md/dm-exception-store.h
View File

@@ -97,8 +97,6 @@ struct dm_exception_store {
struct dm_exception_store_type *type; struct dm_exception_store_type *type;
struct dm_target *ti; struct dm_target *ti;
struct dm_snapshot *snap;
struct dm_dev *cow; struct dm_dev *cow;
/* Size of data blocks saved - must be a power of 2 */ /* Size of data blocks saved - must be a power of 2 */
@@ -152,6 +150,20 @@ static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
# endif # endif
/*
* Return the number of sectors in the device.
*/
static inline sector_t get_dev_size(struct block_device *bdev)
{
return bdev->bd_inode->i_size >> SECTOR_SHIFT;
}
static inline chunk_t sector_to_chunk(struct dm_exception_store *store,
sector_t sector)
{
return (sector & ~store->chunk_mask) >> store->chunk_shift;
}
int dm_exception_store_type_register(struct dm_exception_store_type *type); 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_type_unregister(struct dm_exception_store_type *type);

56
drivers/md/dm-snap-persistent.c
View File

@@ -6,7 +6,6 @@
*/ */
#include "dm-exception-store.h" #include "dm-exception-store.h"
#include "dm-snap.h"
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
@@ -89,7 +88,7 @@ struct commit_callback {
* The top level structure for a persistent exception store. * The top level structure for a persistent exception store.
*/ */
struct pstore { struct pstore {
struct dm_snapshot *snap; /* up pointer to my snapshot */ struct dm_exception_store *store;
int version; int version;
int valid; int valid;
uint32_t exceptions_per_area; uint32_t exceptions_per_area;
@@ -141,7 +140,7 @@ static int alloc_area(struct pstore *ps)
int r = -ENOMEM; int r = -ENOMEM;
size_t len; size_t len;
len = ps->snap->store->chunk_size << SECTOR_SHIFT; len = ps->store->chunk_size << SECTOR_SHIFT;
/* /*
* Allocate the chunk_size block of memory that will hold * Allocate the chunk_size block of memory that will hold
@@ -189,9 +188,9 @@ static void do_metadata(struct work_struct *work)
static int chunk_io(struct pstore *ps, chunk_t chunk, int rw, int metadata) static int chunk_io(struct pstore *ps, chunk_t chunk, int rw, int metadata)
{ {
struct dm_io_region where = { struct dm_io_region where = {
.bdev = ps->snap->store->cow->bdev, .bdev = ps->store->cow->bdev,
.sector = ps->snap->store->chunk_size * chunk, .sector = ps->store->chunk_size * chunk,
.count = ps->snap->store->chunk_size, .count = ps->store->chunk_size,
}; };
struct dm_io_request io_req = { struct dm_io_request io_req = {
.bi_rw = rw, .bi_rw = rw,
@@ -247,15 +246,15 @@ static int area_io(struct pstore *ps, int rw)
static void zero_memory_area(struct pstore *ps) static void zero_memory_area(struct pstore *ps)
{ {
memset(ps->area, 0, ps->snap->store->chunk_size << SECTOR_SHIFT); memset(ps->area, 0, ps->store->chunk_size << SECTOR_SHIFT);
} }
static int zero_disk_area(struct pstore *ps, chunk_t area) static int zero_disk_area(struct pstore *ps, chunk_t area)
{ {
struct dm_io_region where = { struct dm_io_region where = {
.bdev = ps->snap->store->cow->bdev, .bdev = ps->store->cow->bdev,
.sector = ps->snap->store->chunk_size * area_location(ps, area), .sector = ps->store->chunk_size * area_location(ps, area),
.count = ps->snap->store->chunk_size, .count = ps->store->chunk_size,
}; };
struct dm_io_request io_req = { struct dm_io_request io_req = {
.bi_rw = WRITE, .bi_rw = WRITE,
@@ -278,17 +277,16 @@ static int read_header(struct pstore *ps, int *new_snapshot)
/* /*
* Use default chunk size (or hardsect_size, if larger) if none supplied * Use default chunk size (or hardsect_size, if larger) if none supplied
*/ */
if (!ps->snap->store->chunk_size) { if (!ps->store->chunk_size) {
ps->snap->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS, ps->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
bdev_hardsect_size(ps->snap->store->cow->bdev) >> 9); bdev_hardsect_size(ps->store->cow->bdev) >> 9);
ps->snap->store->chunk_mask = ps->snap->store->chunk_size - 1; ps->store->chunk_mask = ps->store->chunk_size - 1;
ps->snap->store->chunk_shift = ffs(ps->snap->store->chunk_size) ps->store->chunk_shift = ffs(ps->store->chunk_size) - 1;
- 1;
chunk_size_supplied = 0; chunk_size_supplied = 0;
} }
ps->io_client = dm_io_client_create(sectors_to_pages(ps->snap-> ps->io_client = dm_io_client_create(sectors_to_pages(ps->store->
store->chunk_size)); chunk_size));
if (IS_ERR(ps->io_client)) if (IS_ERR(ps->io_client))
return PTR_ERR(ps->io_client); return PTR_ERR(ps->io_client);
@@ -318,22 +316,22 @@ static int read_header(struct pstore *ps, int *new_snapshot)
ps->version = le32_to_cpu(dh->version); ps->version = le32_to_cpu(dh->version);
chunk_size = le32_to_cpu(dh->chunk_size); chunk_size = le32_to_cpu(dh->chunk_size);
if (!chunk_size_supplied || ps->snap->store->chunk_size == chunk_size) if (!chunk_size_supplied || ps->store->chunk_size == chunk_size)
return 0; return 0;
DMWARN("chunk size %llu in device metadata overrides " DMWARN("chunk size %llu in device metadata overrides "
"table chunk size of %llu.", "table chunk size of %llu.",
(unsigned long long)chunk_size, (unsigned long long)chunk_size,
(unsigned long long)ps->snap->store->chunk_size); (unsigned long long)ps->store->chunk_size);
/* We had a bogus chunk_size. Fix stuff up. */ /* We had a bogus chunk_size. Fix stuff up. */
free_area(ps); free_area(ps);
ps->snap->store->chunk_size = chunk_size; ps->store->chunk_size = chunk_size;
ps->snap->store->chunk_mask = chunk_size - 1; ps->store->chunk_mask = chunk_size - 1;
ps->snap->store->chunk_shift = ffs(chunk_size) - 1; ps->store->chunk_shift = ffs(chunk_size) - 1;
r = dm_io_client_resize(sectors_to_pages(ps->snap->store->chunk_size), r = dm_io_client_resize(sectors_to_pages(ps->store->chunk_size),
ps->io_client); ps->io_client);
if (r) if (r)
return r; return r;
@@ -350,13 +348,13 @@ static int write_header(struct pstore *ps)
{ {
struct disk_header *dh; struct disk_header *dh;
memset(ps->area, 0, ps->snap->store->chunk_size << SECTOR_SHIFT); memset(ps->area, 0, ps->store->chunk_size << SECTOR_SHIFT);
dh = (struct disk_header *) ps->area; dh = (struct disk_header *) ps->area;
dh->magic = cpu_to_le32(SNAP_MAGIC); dh->magic = cpu_to_le32(SNAP_MAGIC);
dh->valid = cpu_to_le32(ps->valid); dh->valid = cpu_to_le32(ps->valid);
dh->version = cpu_to_le32(ps->version); dh->version = cpu_to_le32(ps->version);
dh->chunk_size = cpu_to_le32(ps->snap->store->chunk_size); dh->chunk_size = cpu_to_le32(ps->store->chunk_size);
return chunk_io(ps, 0, WRITE, 1); return chunk_io(ps, 0, WRITE, 1);
} }
@@ -508,8 +506,8 @@ static int persistent_read_metadata(struct dm_exception_store *store,
/* /*
* Now we know correct chunk_size, complete the initialisation. * Now we know correct chunk_size, complete the initialisation.
*/ */
ps->exceptions_per_area = (ps->snap->store->chunk_size << SECTOR_SHIFT) ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /
/ sizeof(struct disk_exception); sizeof(struct disk_exception);
ps->callbacks = dm_vcalloc(ps->exceptions_per_area, ps->callbacks = dm_vcalloc(ps->exceptions_per_area,
sizeof(*ps->callbacks)); sizeof(*ps->callbacks));
if (!ps->callbacks) if (!ps->callbacks)
@@ -667,7 +665,7 @@ static int persistent_ctr(struct dm_exception_store *store,
if (!ps) if (!ps)
return -ENOMEM; return -ENOMEM;
ps->snap = store->snap; ps->store = store;
ps->valid = 1; ps->valid = 1;
ps->version = SNAPSHOT_DISK_VERSION; ps->version = SNAPSHOT_DISK_VERSION;
ps->area = NULL; ps->area = NULL;

3
drivers/md/dm-snap-transient.c
View File

@@ -6,7 +6,6 @@
*/ */
#include "dm-exception-store.h" #include "dm-exception-store.h"
#include "dm-snap.h"
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
@@ -45,7 +44,7 @@ static int transient_prepare_exception(struct dm_exception_store *store,
if (size < (tc->next_free + store->chunk_size)) if (size < (tc->next_free + store->chunk_size))
return -1; return -1;
e->new_chunk = sector_to_chunk(store->snap, tc->next_free); e->new_chunk = sector_to_chunk(store, tc->next_free);
tc->next_free += store->chunk_size; tc->next_free += store->chunk_size;
return 0; return 0;

18
drivers/md/dm-snap.c
View File

@@ -637,8 +637,6 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
goto bad4; goto bad4;
} }
s->store->snap = s;
r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client); r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);
if (r) { if (r) {
ti->error = "Could not create kcopyd client"; ti->error = "Could not create kcopyd client";
@@ -962,11 +960,11 @@ static void start_copy(struct dm_snap_pending_exception *pe)
dev_size = get_dev_size(bdev); dev_size = get_dev_size(bdev);
src.bdev = bdev; src.bdev = bdev;
src.sector = chunk_to_sector(s, pe->e.old_chunk); src.sector = chunk_to_sector(s->store, pe->e.old_chunk);
src.count = min(s->store->chunk_size, dev_size - src.sector); src.count = min(s->store->chunk_size, dev_size - src.sector);
dest.bdev = s->store->cow->bdev; dest.bdev = s->store->cow->bdev;
dest.sector = chunk_to_sector(s, pe->e.new_chunk); dest.sector = chunk_to_sector(s->store, pe->e.new_chunk);
dest.count = src.count; dest.count = src.count;
/* Hand over to kcopyd */ /* Hand over to kcopyd */
@@ -1027,9 +1025,11 @@ static void remap_exception(struct dm_snapshot *s, struct dm_snap_exception *e,
struct bio *bio, chunk_t chunk) struct bio *bio, chunk_t chunk)
{ {
bio->bi_bdev = s->store->cow->bdev; bio->bi_bdev = s->store->cow->bdev;
bio->bi_sector = chunk_to_sector(s, dm_chunk_number(e->new_chunk) + bio->bi_sector = chunk_to_sector(s->store,
(chunk - e->old_chunk)) + dm_chunk_number(e->new_chunk) +
(bio->bi_sector & s->store->chunk_mask); (chunk - e->old_chunk)) +
(bio->bi_sector &
s->store->chunk_mask);
} }
static int snapshot_map(struct dm_target *ti, struct bio *bio, static int snapshot_map(struct dm_target *ti, struct bio *bio,
@@ -1041,7 +1041,7 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
chunk_t chunk; chunk_t chunk;
struct dm_snap_pending_exception *pe = NULL; struct dm_snap_pending_exception *pe = NULL;
chunk = sector_to_chunk(s, bio->bi_sector); chunk = sector_to_chunk(s->store, bio->bi_sector);
/* Full snapshots are not usable */ /* Full snapshots are not usable */
/* To get here the table must be live so s->active is always set. */ /* To get here the table must be live so s->active is always set. */
@@ -1210,7 +1210,7 @@ static int __origin_write(struct list_head *snapshots, struct bio *bio)
* Remember, different snapshots can have * Remember, different snapshots can have
* different chunk sizes. * different chunk sizes.
*/ */
chunk = sector_to_chunk(snap, bio->bi_sector); chunk = sector_to_chunk(snap->store, bio->bi_sector);
/* /*
* Check exception table to see if block * Check exception table to see if block

18
drivers/md/dm-snap.h
View File

@@ -68,22 +68,10 @@ struct dm_snapshot {
struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE]; struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE];
}; };
/* static inline sector_t chunk_to_sector(struct dm_exception_store *store,
* Return the number of sectors in the device. chunk_t chunk)
*/
static inline sector_t get_dev_size(struct block_device *bdev)
{ {
return bdev->bd_inode->i_size >> SECTOR_SHIFT; return chunk << store->chunk_shift;
}
static inline chunk_t sector_to_chunk(struct dm_snapshot *s, sector_t sector)
{
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->store->chunk_shift;
} }
static inline int bdev_equal(struct block_device *lhs, struct block_device *rhs) static inline int bdev_equal(struct block_device *lhs, struct block_device *rhs)