Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fee1998e authored by Jonathan Brassow's avatar Jonathan Brassow Committed by Alasdair G Kergon
Browse files

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: default avatarJonathan Brassow <jbrassow@redhat.com>
Signed-off-by: default avatarAlasdair G Kergon <agk@redhat.com>
parent 2e4a31df

drivers/md/dm-exception-store.c

+95 −14
Original line number Diff line number Diff line
@@ -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);

}

drivers/md/dm-exception-store.h

+2 −3
Original line number Diff line number Diff line
@@ -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);

drivers/md/dm-snap.c

+35 −112
Original line number Diff line number Diff line
@@ -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,
@@ -765,24 +691,23 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv) 
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);

}