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

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

dm snapshot: remove dm_snap header use 



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

Signed-off-by: default avatarJonathan Brassow <jbrassow@redhat.com>
Signed-off-by: default avatarAlasdair G Kergon <agk@redhat.com>
parent 49beb2b8

drivers/md/dm-exception-store.h

+14 −2
Original line number Diff line number Diff line
@@ -97,8 +97,6 @@ struct dm_exception_store { 
	struct dm_exception_store_type *type;

	struct dm_target *ti;



	struct dm_snapshot *snap;



	struct dm_dev *cow;



	/* 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



/*

 * 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_unregister(struct dm_exception_store_type *type);

drivers/md/dm-snap-persistent.c

+27 −29
Original line number Diff line number Diff line
@@ -6,7 +6,6 @@ 
 */



#include "dm-exception-store.h"

#include "dm-snap.h"



#include <linux/mm.h>

#include <linux/pagemap.h>
@@ -89,7 +88,7 @@ struct commit_callback { 
 * The top level structure for a persistent exception store.

 */

struct pstore {

	struct dm_snapshot *snap;	/* up pointer to my snapshot */

	struct dm_exception_store *store;

	int version;

	int valid;

	uint32_t exceptions_per_area;
@@ -141,7 +140,7 @@ static int alloc_area(struct pstore *ps) 
	int r = -ENOMEM;

	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
@@ -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)

{

	struct dm_io_region where = {

		.bdev = ps->snap->store->cow->bdev,

		.sector = ps->snap->store->chunk_size * chunk,

		.count = ps->snap->store->chunk_size,

		.bdev = ps->store->cow->bdev,

		.sector = ps->store->chunk_size * chunk,

		.count = ps->store->chunk_size,

	};

	struct dm_io_request io_req = {

		.bi_rw = rw,
@@ -247,15 +246,15 @@ static int area_io(struct pstore *ps, int rw) 


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)

{

	struct dm_io_region where = {

		.bdev = ps->snap->store->cow->bdev,

		.sector = ps->snap->store->chunk_size * area_location(ps, area),

		.count = ps->snap->store->chunk_size,

		.bdev = ps->store->cow->bdev,

		.sector = ps->store->chunk_size * area_location(ps, area),

		.count = ps->store->chunk_size,

	};

	struct dm_io_request io_req = {

		.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

	 */

	if (!ps->snap->store->chunk_size) {

		ps->snap->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,

		    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;

	if (!ps->store->chunk_size) {

		ps->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,

		    bdev_hardsect_size(ps->store->cow->bdev) >> 9);

		ps->store->chunk_mask = ps->store->chunk_size - 1;

		ps->store->chunk_shift = ffs(ps->store->chunk_size) - 1;

		chunk_size_supplied = 0;

	}



	ps->io_client = dm_io_client_create(sectors_to_pages(ps->snap->

							    store->chunk_size));

	ps->io_client = dm_io_client_create(sectors_to_pages(ps->store->

							     chunk_size));

	if (IS_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);

	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;



	DMWARN("chunk size %llu in device metadata overrides "

	       "table chunk size of %llu.",

	       (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. */

	free_area(ps);



	ps->snap->store->chunk_size = chunk_size;

	ps->snap->store->chunk_mask = chunk_size - 1;

	ps->snap->store->chunk_shift = ffs(chunk_size) - 1;

	ps->store->chunk_size = chunk_size;

	ps->store->chunk_mask = 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);

	if (r)

		return r;
@@ -350,13 +348,13 @@ static int write_header(struct pstore *ps) 
{

	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->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->store->chunk_size);

	dh->chunk_size = cpu_to_le32(ps->store->chunk_size);



	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.

	 */

	ps->exceptions_per_area = (ps->snap->store->chunk_size << SECTOR_SHIFT)

				  / sizeof(struct disk_exception);

	ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /

				  sizeof(struct disk_exception);

	ps->callbacks = dm_vcalloc(ps->exceptions_per_area,

			sizeof(*ps->callbacks));

	if (!ps->callbacks)
@@ -667,7 +665,7 @@ static int persistent_ctr(struct dm_exception_store *store, 
	if (!ps)

		return -ENOMEM;



	ps->snap = store->snap;

	ps->store = store;

	ps->valid = 1;

	ps->version = SNAPSHOT_DISK_VERSION;

	ps->area = NULL;

drivers/md/dm-snap-transient.c

+1 −2
Original line number Diff line number Diff line
@@ -6,7 +6,6 @@ 
 */



#include "dm-exception-store.h"

#include "dm-snap.h"



#include <linux/mm.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))

		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;



	return 0;

drivers/md/dm-snap.c

+9 −9
Original line number Diff line number Diff line
@@ -637,8 +637,6 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv) 
		goto bad4;

	}



	s->store->snap = s;



	r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);

	if (r) {

		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);



	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);



	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;



	/* 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)

{

	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,

					 dm_chunk_number(e->new_chunk) +

					 (chunk - e->old_chunk)) +

			 (bio->bi_sector & s->store->chunk_mask);

					 (bio->bi_sector &

					  s->store->chunk_mask);

}



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;

	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 */

	/* 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

		 * 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

drivers/md/dm-snap.h

+3 −15
Original line number Diff line number Diff line
@@ -68,22 +68,10 @@ struct dm_snapshot { 
	struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE];

};



/*

 * 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_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)

static inline sector_t chunk_to_sector(struct dm_exception_store *store,

				      chunk_t chunk)

{

	return chunk << s->store->chunk_shift;

	return chunk << store->chunk_shift;

}



static inline int bdev_equal(struct block_device *lhs, struct block_device *rhs)