[linux.git] / drivers / md / dm-log.c

/*
 * Copyright (C) 2003 Sistina Software
 *
 * This file is released under the LGPL.
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/vmalloc.h>

#include "dm-log.h"
#include "dm-io.h"

static LIST_HEAD(_log_types);
static DEFINE_SPINLOCK(_lock);

int dm_register_dirty_log_type(struct dirty_log_type *type)
{
	spin_lock(&_lock);
	type->use_count = 0;
	list_add(&type->list, &_log_types);
	spin_unlock(&_lock);

	return 0;
}

int dm_unregister_dirty_log_type(struct dirty_log_type *type)
{
	spin_lock(&_lock);

	if (type->use_count)
		DMWARN("Attempt to unregister a log type that is still in use");
	else
		list_del(&type->list);

	spin_unlock(&_lock);

	return 0;
}

static struct dirty_log_type *get_type(const char *type_name)
{
	struct dirty_log_type *type;

	spin_lock(&_lock);
	list_for_each_entry (type, &_log_types, list)
		if (!strcmp(type_name, type->name)) {
			if (!type->use_count && !try_module_get(type->module)){
				spin_unlock(&_lock);
				return NULL;
			}
			type->use_count++;
			spin_unlock(&_lock);
			return type;
		}

	spin_unlock(&_lock);
	return NULL;
}

static void put_type(struct dirty_log_type *type)
{
	spin_lock(&_lock);
	if (!--type->use_count)
		module_put(type->module);
	spin_unlock(&_lock);
}

struct dirty_log *dm_create_dirty_log(const char *type_name, struct dm_target *ti,
				      unsigned int argc, char **argv)
{
	struct dirty_log_type *type;
	struct dirty_log *log;

	log = kmalloc(sizeof(*log), GFP_KERNEL);
	if (!log)
		return NULL;

	type = get_type(type_name);
	if (!type) {
		kfree(log);
		return NULL;
	}

	log->type = type;
	if (type->ctr(log, ti, argc, argv)) {
		kfree(log);
		put_type(type);
		return NULL;
	}

	return log;
}

void dm_destroy_dirty_log(struct dirty_log *log)
{
	log->type->dtr(log);
	put_type(log->type);
	kfree(log);
}

/*-----------------------------------------------------------------
 * Persistent and core logs share a lot of their implementation.
 * FIXME: need a reload method to be called from a resume
 *---------------------------------------------------------------*/
/*
 * Magic for persistent mirrors: "MiRr"
 */
#define MIRROR_MAGIC 0x4D695272

/*
 * The on-disk version of the metadata.
 */
#define MIRROR_DISK_VERSION 2
#define LOG_OFFSET 2

struct log_header {
	uint32_t magic;

	/*
	 * Simple, incrementing version. no backward
	 * compatibility.
	 */
	uint32_t version;
	sector_t nr_regions;
};

struct log_c {
	struct dm_target *ti;
	int touched;
	uint32_t region_size;
	unsigned int region_count;
	region_t sync_count;

	unsigned bitset_uint32_count;
	uint32_t *clean_bits;
	uint32_t *sync_bits;
	uint32_t *recovering_bits;	/* FIXME: this seems excessive */

	int sync_search;

	/* Resync flag */
	enum sync {
		DEFAULTSYNC,	/* Synchronize if necessary */
		NOSYNC,		/* Devices known to be already in sync */
		FORCESYNC,	/* Force a sync to happen */
	} sync;

	/*
	 * Disk log fields
	 */
	struct dm_dev *log_dev;
	struct log_header header;

	struct io_region header_location;
	struct log_header *disk_header;
};

/*
 * The touched member needs to be updated every time we access
 * one of the bitsets.
 */
static  inline int log_test_bit(uint32_t *bs, unsigned bit)
{
	return ext2_test_bit(bit, (unsigned long *) bs) ? 1 : 0;
}

static inline void log_set_bit(struct log_c *l,
			       uint32_t *bs, unsigned bit)
{
	ext2_set_bit(bit, (unsigned long *) bs);
	l->touched = 1;
}

static inline void log_clear_bit(struct log_c *l,
				 uint32_t *bs, unsigned bit)
{
	ext2_clear_bit(bit, (unsigned long *) bs);
	l->touched = 1;
}

/*----------------------------------------------------------------
 * Header IO
 *--------------------------------------------------------------*/
static void header_to_disk(struct log_header *core, struct log_header *disk)
{
	disk->magic = cpu_to_le32(core->magic);
	disk->version = cpu_to_le32(core->version);
	disk->nr_regions = cpu_to_le64(core->nr_regions);
}

static void header_from_disk(struct log_header *core, struct log_header *disk)
{
	core->magic = le32_to_cpu(disk->magic);
	core->version = le32_to_cpu(disk->version);
	core->nr_regions = le64_to_cpu(disk->nr_regions);
}

static int read_header(struct log_c *log)
{
	int r;
	unsigned long ebits;

	r = dm_io_sync_vm(1, &log->header_location, READ,
			  log->disk_header, &ebits);
	if (r)
		return r;

	header_from_disk(&log->header, log->disk_header);

	/* New log required? */
	if (log->sync != DEFAULTSYNC || log->header.magic != MIRROR_MAGIC) {
		log->header.magic = MIRROR_MAGIC;
		log->header.version = MIRROR_DISK_VERSION;
		log->header.nr_regions = 0;
	}

#ifdef __LITTLE_ENDIAN
	if (log->header.version == 1)
		log->header.version = 2;
#endif

	if (log->header.version != MIRROR_DISK_VERSION) {
		DMWARN("incompatible disk log version");
		return -EINVAL;
	}

	return 0;
}

static inline int write_header(struct log_c *log)
{
	unsigned long ebits;

	header_to_disk(&log->header, log->disk_header);
	return dm_io_sync_vm(1, &log->header_location, WRITE,
			     log->disk_header, &ebits);
}

/*----------------------------------------------------------------
 * core log constructor/destructor
 *
 * argv contains region_size followed optionally by [no]sync
 *--------------------------------------------------------------*/
#define BYTE_SHIFT 3
static int core_ctr(struct dirty_log *log, struct dm_target *ti,
		    unsigned int argc, char **argv)
{
	enum sync sync = DEFAULTSYNC;

	struct log_c *lc;
	uint32_t region_size;
	unsigned int region_count;
	size_t bitset_size;

	if (argc < 1 || argc > 2) {
		DMWARN("wrong number of arguments to mirror log");
		return -EINVAL;
	}

	if (argc > 1) {
		if (!strcmp(argv[1], "sync"))
			sync = FORCESYNC;
		else if (!strcmp(argv[1], "nosync"))
			sync = NOSYNC;
		else {
			DMWARN("unrecognised sync argument to mirror log: %s",
			       argv[1]);
			return -EINVAL;
		}
	}

	if (sscanf(argv[0], "%u", &region_size) != 1) {
		DMWARN("invalid region size string");
		return -EINVAL;
	}

	region_count = dm_sector_div_up(ti->len, region_size);

	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
	if (!lc) {
		DMWARN("couldn't allocate core log");
		return -ENOMEM;
	}

	lc->ti = ti;
	lc->touched = 0;
	lc->region_size = region_size;
	lc->region_count = region_count;
	lc->sync = sync;

	/*
	 * Work out how many "unsigned long"s we need to hold the bitset.
	 */
	bitset_size = dm_round_up(region_count,
				  sizeof(unsigned long) << BYTE_SHIFT);
	bitset_size >>= BYTE_SHIFT;

	lc->bitset_uint32_count = bitset_size / 4;
	lc->clean_bits = vmalloc(bitset_size);
	if (!lc->clean_bits) {
		DMWARN("couldn't allocate clean bitset");
		kfree(lc);
		return -ENOMEM;
	}
	memset(lc->clean_bits, -1, bitset_size);

	lc->sync_bits = vmalloc(bitset_size);
	if (!lc->sync_bits) {
		DMWARN("couldn't allocate sync bitset");
		vfree(lc->clean_bits);
		kfree(lc);
		return -ENOMEM;
	}
	memset(lc->sync_bits, (sync == NOSYNC) ? -1 : 0, bitset_size);
	lc->sync_count = (sync == NOSYNC) ? region_count : 0;

	lc->recovering_bits = vmalloc(bitset_size);
	if (!lc->recovering_bits) {
		DMWARN("couldn't allocate sync bitset");
		vfree(lc->sync_bits);
		vfree(lc->clean_bits);
		kfree(lc);
		return -ENOMEM;
	}
	memset(lc->recovering_bits, 0, bitset_size);
	lc->sync_search = 0;
	log->context = lc;
	return 0;
}

static void core_dtr(struct dirty_log *log)
{
	struct log_c *lc = (struct log_c *) log->context;
	vfree(lc->clean_bits);
	vfree(lc->sync_bits);
	vfree(lc->recovering_bits);
	kfree(lc);
}

/*----------------------------------------------------------------
 * disk log constructor/destructor
 *
 * argv contains log_device region_size followed optionally by [no]sync
 *--------------------------------------------------------------*/
static int disk_ctr(struct dirty_log *log, struct dm_target *ti,
		    unsigned int argc, char **argv)
{
	int r;
	size_t size, bitset_size;
	struct log_c *lc;
	struct dm_dev *dev;
	uint32_t *clean_bits;

	if (argc < 2 || argc > 3) {
		DMWARN("wrong number of arguments to disk mirror log");
		return -EINVAL;
	}

	r = dm_get_device(ti, argv[0], 0, 0 /* FIXME */,
			  FMODE_READ | FMODE_WRITE, &dev);
	if (r)
		return r;

	r = core_ctr(log, ti, argc - 1, argv + 1);
	if (r) {
		dm_put_device(ti, dev);
		return r;
	}

	lc = (struct log_c *) log->context;
	lc->log_dev = dev;

	/* setup the disk header fields */
	lc->header_location.bdev = lc->log_dev->bdev;
	lc->header_location.sector = 0;

	/* Include both the header and the bitset in one buffer. */
	bitset_size = lc->bitset_uint32_count * sizeof(uint32_t);
	size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,
			   ti->limits.hardsect_size);
	lc->header_location.count = size >> SECTOR_SHIFT;

	lc->disk_header = vmalloc(size);
	if (!lc->disk_header)
		goto bad;

	/*
	 * Deallocate the clean_bits buffer that was allocated in core_ctr()
	 * and point it at the appropriate place in the disk_header buffer.
	 */
	clean_bits = lc->clean_bits;
	lc->clean_bits = (void *)lc->disk_header + (LOG_OFFSET << SECTOR_SHIFT);
	memcpy(lc->clean_bits, clean_bits, bitset_size);
	vfree(clean_bits);

	return 0;

 bad:
	dm_put_device(ti, lc->log_dev);
	core_dtr(log);
	return -ENOMEM;
}

static void disk_dtr(struct dirty_log *log)
{
	struct log_c *lc = (struct log_c *) log->context;
	dm_put_device(lc->ti, lc->log_dev);
	vfree(lc->disk_header);
	lc->clean_bits = NULL;
	core_dtr(log);
}

static int count_bits32(uint32_t *addr, unsigned size)
{
	int count = 0, i;

	for (i = 0; i < size; i++) {
		count += hweight32(*(addr+i));
	}
	return count;
}

static int disk_resume(struct dirty_log *log)
{
	int r;
	unsigned i;
	struct log_c *lc = (struct log_c *) log->context;
	size_t size = lc->bitset_uint32_count * sizeof(uint32_t);

	/* read the disk header */
	r = read_header(lc);
	if (r)
		return r;

	/* set or clear any new bits */
	if (lc->sync == NOSYNC)
		for (i = lc->header.nr_regions; i < lc->region_count; i++)
			/* FIXME: amazingly inefficient */
			log_set_bit(lc, lc->clean_bits, i);
	else
		for (i = lc->header.nr_regions; i < lc->region_count; i++)
			/* FIXME: amazingly inefficient */
			log_clear_bit(lc, lc->clean_bits, i);

	/* copy clean across to sync */
	memcpy(lc->sync_bits, lc->clean_bits, size);
	lc->sync_count = count_bits32(lc->clean_bits, lc->bitset_uint32_count);

	/* set the correct number of regions in the header */
	lc->header.nr_regions = lc->region_count;

	/* write the new header */
	return write_header(lc);
}

static uint32_t core_get_region_size(struct dirty_log *log)
{
	struct log_c *lc = (struct log_c *) log->context;
	return lc->region_size;
}

static int core_is_clean(struct dirty_log *log, region_t region)
{
	struct log_c *lc = (struct log_c *) log->context;
	return log_test_bit(lc->clean_bits, region);
}

static int core_in_sync(struct dirty_log *log, region_t region, int block)
{
	struct log_c *lc = (struct log_c *) log->context;
	return log_test_bit(lc->sync_bits, region);
}

static int core_flush(struct dirty_log *log)
{
	/* no op */
	return 0;
}

static int disk_flush(struct dirty_log *log)
{
	int r;
	struct log_c *lc = (struct log_c *) log->context;

	/* only write if the log has changed */
	if (!lc->touched)
		return 0;

	r = write_header(lc);
	if (!r)
		lc->touched = 0;

	return r;
}

static void core_mark_region(struct dirty_log *log, region_t region)
{
	struct log_c *lc = (struct log_c *) log->context;
	log_clear_bit(lc, lc->clean_bits, region);
}

static void core_clear_region(struct dirty_log *log, region_t region)
{
	struct log_c *lc = (struct log_c *) log->context;
	log_set_bit(lc, lc->clean_bits, region);
}

static int core_get_resync_work(struct dirty_log *log, region_t *region)
{
	struct log_c *lc = (struct log_c *) log->context;

	if (lc->sync_search >= lc->region_count)
		return 0;

	do {
		*region = ext2_find_next_zero_bit(
					     (unsigned long *) lc->sync_bits,
					     lc->region_count,
					     lc->sync_search);
		lc->sync_search = *region + 1;

		if (*region >= lc->region_count)
			return 0;

	} while (log_test_bit(lc->recovering_bits, *region));

	log_set_bit(lc, lc->recovering_bits, *region);
	return 1;
}

static void core_complete_resync_work(struct dirty_log *log, region_t region,
				      int success)
{
	struct log_c *lc = (struct log_c *) log->context;

	log_clear_bit(lc, lc->recovering_bits, region);
	if (success) {
		log_set_bit(lc, lc->sync_bits, region);
                lc->sync_count++;
        }
}

static region_t core_get_sync_count(struct dirty_log *log)
{
        struct log_c *lc = (struct log_c *) log->context;

        return lc->sync_count;
}

#define	DMEMIT_SYNC \
	if (lc->sync != DEFAULTSYNC) \
		DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")

static int core_status(struct dirty_log *log, status_type_t status,
		       char *result, unsigned int maxlen)
{
	int sz = 0;
	struct log_c *lc = log->context;

	switch(status) {
	case STATUSTYPE_INFO:
		break;

	case STATUSTYPE_TABLE:
		DMEMIT("%s %u %u ", log->type->name,
		       lc->sync == DEFAULTSYNC ? 1 : 2, lc->region_size);
		DMEMIT_SYNC;
	}

	return sz;
}

static int disk_status(struct dirty_log *log, status_type_t status,
		       char *result, unsigned int maxlen)
{
	int sz = 0;
	char buffer[16];
	struct log_c *lc = log->context;

	switch(status) {
	case STATUSTYPE_INFO:
		break;

	case STATUSTYPE_TABLE:
		format_dev_t(buffer, lc->log_dev->bdev->bd_dev);
		DMEMIT("%s %u %s %u ", log->type->name,
		       lc->sync == DEFAULTSYNC ? 2 : 3, buffer,
		       lc->region_size);
		DMEMIT_SYNC;
	}

	return sz;
}

static struct dirty_log_type _core_type = {
	.name = "core",
	.module = THIS_MODULE,
	.ctr = core_ctr,
	.dtr = core_dtr,
	.get_region_size = core_get_region_size,
	.is_clean = core_is_clean,
	.in_sync = core_in_sync,
	.flush = core_flush,
	.mark_region = core_mark_region,
	.clear_region = core_clear_region,
	.get_resync_work = core_get_resync_work,
	.complete_resync_work = core_complete_resync_work,
	.get_sync_count = core_get_sync_count,
	.status = core_status,
};

static struct dirty_log_type _disk_type = {
	.name = "disk",
	.module = THIS_MODULE,
	.ctr = disk_ctr,
	.dtr = disk_dtr,
	.suspend = disk_flush,
	.resume = disk_resume,
	.get_region_size = core_get_region_size,
	.is_clean = core_is_clean,
	.in_sync = core_in_sync,
	.flush = disk_flush,
	.mark_region = core_mark_region,
	.clear_region = core_clear_region,
	.get_resync_work = core_get_resync_work,
	.complete_resync_work = core_complete_resync_work,
	.get_sync_count = core_get_sync_count,
	.status = disk_status,
};

int __init dm_dirty_log_init(void)
{
	int r;

	r = dm_register_dirty_log_type(&_core_type);
	if (r)
		DMWARN("couldn't register core log");

	r = dm_register_dirty_log_type(&_disk_type);
	if (r) {
		DMWARN("couldn't register disk type");
		dm_unregister_dirty_log_type(&_core_type);
	}

	return r;
}

void dm_dirty_log_exit(void)
{
	dm_unregister_dirty_log_type(&_disk_type);
	dm_unregister_dirty_log_type(&_core_type);
}

EXPORT_SYMBOL(dm_register_dirty_log_type);
EXPORT_SYMBOL(dm_unregister_dirty_log_type);
EXPORT_SYMBOL(dm_create_dirty_log);
EXPORT_SYMBOL(dm_destroy_dirty_log);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2003 Sistina Software
	3	*
	4	* This file is released under the LGPL.
	5	*/
	6
	7	#include <linux/init.h>
	8	#include <linux/slab.h>
	9	#include <linux/module.h>
	10	#include <linux/vmalloc.h>
	11
	12	#include "dm-log.h"
	13	#include "dm-io.h"
	14
	15	static LIST_HEAD(_log_types);
	16	static DEFINE_SPINLOCK(_lock);
	17
	18	int dm_register_dirty_log_type(struct dirty_log_type *type)
	19	{
	20	spin_lock(&_lock);
	21	type->use_count = 0;
	22	list_add(&type->list, &_log_types);
	23	spin_unlock(&_lock);
	24
	25	return 0;
	26	}
	27
	28	int dm_unregister_dirty_log_type(struct dirty_log_type *type)
	29	{
	30	spin_lock(&_lock);
	31
	32	if (type->use_count)
	33	DMWARN("Attempt to unregister a log type that is still in use");
	34	else
	35	list_del(&type->list);
	36
	37	spin_unlock(&_lock);
	38
	39	return 0;
	40	}
	41
	42	static struct dirty_log_type get_type(const char type_name)
	43	{
	44	struct dirty_log_type *type;
	45
	46	spin_lock(&_lock);
	47	list_for_each_entry (type, &_log_types, list)
	48	if (!strcmp(type_name, type->name)) {
	49	if (!type->use_count && !try_module_get(type->module)){
	50	spin_unlock(&_lock);
	51	return NULL;
	52	}
	53	type->use_count++;
	54	spin_unlock(&_lock);
	55	return type;
	56	}
	57
	58	spin_unlock(&_lock);
	59	return NULL;
	60	}
	61
	62	static void put_type(struct dirty_log_type *type)
	63	{
	64	spin_lock(&_lock);
65	if (!--type->use_count)
66	module_put(type->module);
67	spin_unlock(&_lock);
68	}
69
70	struct dirty_log dm_create_dirty_log(const char type_name, struct dm_target *ti,
71	unsigned int argc, char **argv)
72	{
73	struct dirty_log_type *type;
74	struct dirty_log *log;
75
76	log = kmalloc(sizeof(*log), GFP_KERNEL);
77	if (!log)
78	return NULL;
79
80	type = get_type(type_name);
81	if (!type) {
82	kfree(log);
83	return NULL;
84	}
85
86	log->type = type;
87	if (type->ctr(log, ti, argc, argv)) {
88	kfree(log);
89	put_type(type);
90	return NULL;
91	}
92
93	return log;
94	}
95
96	void dm_destroy_dirty_log(struct dirty_log *log)
97	{
98	log->type->dtr(log);
99	put_type(log->type);
100	kfree(log);
101	}
102
103	/*-----------------------------------------------------------------
104	* Persistent and core logs share a lot of their implementation.
105	* FIXME: need a reload method to be called from a resume
106	---------------------------------------------------------------/
107	/*
108	* Magic for persistent mirrors: "MiRr"
109	*/
110	#define MIRROR_MAGIC 0x4D695272
111
112	/*
113	* The on-disk version of the metadata.
114	*/
a4fc4717	115	#define MIRROR_DISK_VERSION 2
1da177e4 LT	116	#define LOG_OFFSET 2
	117
	118	struct log_header {
	119	uint32_t magic;
	120
	121	/*
	122	* Simple, incrementing version. no backward
	123	* compatibility.
	124	*/
	125	uint32_t version;
	126	sector_t nr_regions;
	127	};
	128
	129	struct log_c {
	130	struct dm_target *ti;
	131	int touched;
	132	uint32_t region_size;
	133	unsigned int region_count;
	134	region_t sync_count;
	135
	136	unsigned bitset_uint32_count;
	137	uint32_t *clean_bits;
	138	uint32_t *sync_bits;
	139	uint32_t recovering_bits; / FIXME: this seems excessive */
	140
	141	int sync_search;
	142
	143	/* Resync flag */
	144	enum sync {
	145	DEFAULTSYNC, /* Synchronize if necessary */
	146	NOSYNC, /* Devices known to be already in sync */
	147	FORCESYNC, /* Force a sync to happen */
	148	} sync;
	149
	150	/*
	151	* Disk log fields
	152	*/
	153	struct dm_dev *log_dev;
	154	struct log_header header;
	155
	156	struct io_region header_location;
	157	struct log_header *disk_header;
1da177e4 LT	158	};
	159
	160	/*
	161	* The touched member needs to be updated every time we access
	162	* one of the bitsets.
	163	*/
	164	static inline int log_test_bit(uint32_t *bs, unsigned bit)
	165	{
a4fc4717	166	return ext2_test_bit(bit, (unsigned long *) bs) ? 1 : 0;
1da177e4 LT	167	}
	168
	169	static inline void log_set_bit(struct log_c *l,
	170	uint32_t *bs, unsigned bit)
	171	{
a4fc4717	172	ext2_set_bit(bit, (unsigned long *) bs);
1da177e4 LT	173	l->touched = 1;
	174	}
	175
	176	static inline void log_clear_bit(struct log_c *l,
	177	uint32_t *bs, unsigned bit)
	178	{
a4fc4717	179	ext2_clear_bit(bit, (unsigned long *) bs);
1da177e4 LT	180	l->touched = 1;
	181	}
	182
	183	/*----------------------------------------------------------------
	184	* Header IO
	185	--------------------------------------------------------------/
	186	static void header_to_disk(struct log_header core, struct log_header disk)
	187	{
	188	disk->magic = cpu_to_le32(core->magic);
	189	disk->version = cpu_to_le32(core->version);
	190	disk->nr_regions = cpu_to_le64(core->nr_regions);
	191	}
	192
	193	static void header_from_disk(struct log_header core, struct log_header disk)
	194	{
	195	core->magic = le32_to_cpu(disk->magic);
	196	core->version = le32_to_cpu(disk->version);
	197	core->nr_regions = le64_to_cpu(disk->nr_regions);
	198	}
	199
	200	static int read_header(struct log_c *log)
	201	{
	202	int r;
	203	unsigned long ebits;
	204
	205	r = dm_io_sync_vm(1, &log->header_location, READ,
	206	log->disk_header, &ebits);
	207	if (r)
	208	return r;
	209
	210	header_from_disk(&log->header, log->disk_header);
	211
	212	/* New log required? */
	213	if (log->sync != DEFAULTSYNC \|\| log->header.magic != MIRROR_MAGIC) {
	214	log->header.magic = MIRROR_MAGIC;
	215	log->header.version = MIRROR_DISK_VERSION;
	216	log->header.nr_regions = 0;
	217	}
	218
a4fc4717 PC	219	#ifdef __LITTLE_ENDIAN
	220	if (log->header.version == 1)
	221	log->header.version = 2;
	222	#endif
	223
1da177e4 LT	224	if (log->header.version != MIRROR_DISK_VERSION) {
	225	DMWARN("incompatible disk log version");
	226	return -EINVAL;
	227	}
	228
	229	return 0;
	230	}
	231
	232	static inline int write_header(struct log_c *log)
	233	{
	234	unsigned long ebits;
	235
	236	header_to_disk(&log->header, log->disk_header);
	237	return dm_io_sync_vm(1, &log->header_location, WRITE,
	238	log->disk_header, &ebits);
	239	}
	240
1da177e4 LT	241	/*----------------------------------------------------------------
	242	* core log constructor/destructor
	243	*
	244	* argv contains region_size followed optionally by [no]sync
	245	--------------------------------------------------------------/
	246	#define BYTE_SHIFT 3
	247	static int core_ctr(struct dirty_log log, struct dm_target ti,
	248	unsigned int argc, char **argv)
	249	{
	250	enum sync sync = DEFAULTSYNC;
	251
	252	struct log_c *lc;
	253	uint32_t region_size;
	254	unsigned int region_count;
	255	size_t bitset_size;
	256
	257	if (argc < 1 \|\| argc > 2) {
	258	DMWARN("wrong number of arguments to mirror log");
	259	return -EINVAL;
	260	}
	261
	262	if (argc > 1) {
	263	if (!strcmp(argv[1], "sync"))
	264	sync = FORCESYNC;
	265	else if (!strcmp(argv[1], "nosync"))
	266	sync = NOSYNC;
	267	else {
	268	DMWARN("unrecognised sync argument to mirror log: %s",
	269	argv[1]);
	270	return -EINVAL;
	271	}
	272	}
	273
	274	if (sscanf(argv[0], "%u", &region_size) != 1) {
	275	DMWARN("invalid region size string");
	276	return -EINVAL;
	277	}
	278
	279	region_count = dm_sector_div_up(ti->len, region_size);
	280
	281	lc = kmalloc(sizeof(*lc), GFP_KERNEL);
	282	if (!lc) {
	283	DMWARN("couldn't allocate core log");
	284	return -ENOMEM;
	285	}
	286
	287	lc->ti = ti;
	288	lc->touched = 0;
	289	lc->region_size = region_size;
	290	lc->region_count = region_count;
	291	lc->sync = sync;
	292
	293	/*
0e56822d	294	* Work out how many "unsigned long"s we need to hold the bitset.
1da177e4 LT	295	*/
1da177e4 LT	296	bitset_size = dm_round_up(region_count,
0e56822d	297	sizeof(unsigned long) << BYTE_SHIFT);
1da177e4 LT	298	bitset_size >>= BYTE_SHIFT;
	299
	300	lc->bitset_uint32_count = bitset_size / 4;
	301	lc->clean_bits = vmalloc(bitset_size);
	302	if (!lc->clean_bits) {
	303	DMWARN("couldn't allocate clean bitset");
	304	kfree(lc);
	305	return -ENOMEM;
	306	}
	307	memset(lc->clean_bits, -1, bitset_size);
	308
	309	lc->sync_bits = vmalloc(bitset_size);
	310	if (!lc->sync_bits) {
	311	DMWARN("couldn't allocate sync bitset");
	312	vfree(lc->clean_bits);
	313	kfree(lc);
	314	return -ENOMEM;
	315	}
	316	memset(lc->sync_bits, (sync == NOSYNC) ? -1 : 0, bitset_size);
	317	lc->sync_count = (sync == NOSYNC) ? region_count : 0;
	318
	319	lc->recovering_bits = vmalloc(bitset_size);
	320	if (!lc->recovering_bits) {
	321	DMWARN("couldn't allocate sync bitset");
	322	vfree(lc->sync_bits);
	323	vfree(lc->clean_bits);
	324	kfree(lc);
	325	return -ENOMEM;
	326	}
	327	memset(lc->recovering_bits, 0, bitset_size);
	328	lc->sync_search = 0;
	329	log->context = lc;
	330	return 0;
	331	}
	332
	333	static void core_dtr(struct dirty_log *log)
	334	{
	335	struct log_c lc = (struct log_c ) log->context;
	336	vfree(lc->clean_bits);
	337	vfree(lc->sync_bits);
	338	vfree(lc->recovering_bits);
	339	kfree(lc);
	340	}
	341
	342	/*----------------------------------------------------------------
	343	* disk log constructor/destructor
	344	*
	345	* argv contains log_device region_size followed optionally by [no]sync
	346	--------------------------------------------------------------/
	347	static int disk_ctr(struct dirty_log log, struct dm_target ti,
	348	unsigned int argc, char **argv)
	349	{
	350	int r;
702ca6f0	351	size_t size, bitset_size;
1da177e4 LT	352	struct log_c *lc;
1da177e4 LT	353	struct dm_dev *dev;
702ca6f0	354	uint32_t *clean_bits;
1da177e4 LT	355
	356	if (argc < 2 \|\| argc > 3) {
	357	DMWARN("wrong number of arguments to disk mirror log");
	358	return -EINVAL;
	359	}
	360
	361	r = dm_get_device(ti, argv[0], 0, 0 /* FIXME */,
	362	FMODE_READ \| FMODE_WRITE, &dev);
	363	if (r)
	364	return r;
	365
	366	r = core_ctr(log, ti, argc - 1, argv + 1);
	367	if (r) {
	368	dm_put_device(ti, dev);
	369	return r;
	370	}
	371
	372	lc = (struct log_c *) log->context;
	373	lc->log_dev = dev;
	374
	375	/* setup the disk header fields */
	376	lc->header_location.bdev = lc->log_dev->bdev;
	377	lc->header_location.sector = 0;
1da177e4	378
702ca6f0 KC	379	/* Include both the header and the bitset in one buffer. */
	380	bitset_size = lc->bitset_uint32_count * sizeof(uint32_t);
	381	size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,
	382	ti->limits.hardsect_size);
	383	lc->header_location.count = size >> SECTOR_SHIFT;
	384
	385	lc->disk_header = vmalloc(size);
1da177e4 LT	386	if (!lc->disk_header)
	387	goto bad;
	388
702ca6f0 KC	389	/*
	390	* Deallocate the clean_bits buffer that was allocated in core_ctr()
	391	* and point it at the appropriate place in the disk_header buffer.
	392	*/
	393	clean_bits = lc->clean_bits;
	394	lc->clean_bits = (void *)lc->disk_header + (LOG_OFFSET << SECTOR_SHIFT);
	395	memcpy(lc->clean_bits, clean_bits, bitset_size);
	396	vfree(clean_bits);
1da177e4	397
1da177e4 LT	398	return 0;
	399
	400	bad:
	401	dm_put_device(ti, lc->log_dev);
	402	core_dtr(log);
	403	return -ENOMEM;
	404	}
	405
	406	static void disk_dtr(struct dirty_log *log)
	407	{
	408	struct log_c lc = (struct log_c ) log->context;
	409	dm_put_device(lc->ti, lc->log_dev);
	410	vfree(lc->disk_header);
702ca6f0	411	lc->clean_bits = NULL;
1da177e4 LT	412	core_dtr(log);
	413	}
	414
	415	static int count_bits32(uint32_t *addr, unsigned size)
	416	{
	417	int count = 0, i;
	418
	419	for (i = 0; i < size; i++) {
	420	count += hweight32(*(addr+i));
	421	}
	422	return count;
	423	}
	424
	425	static int disk_resume(struct dirty_log *log)
	426	{
	427	int r;
	428	unsigned i;
	429	struct log_c lc = (struct log_c ) log->context;
	430	size_t size = lc->bitset_uint32_count * sizeof(uint32_t);
	431
	432	/* read the disk header */
	433	r = read_header(lc);
	434	if (r)
	435	return r;
	436
1da177e4 LT	437	/* set or clear any new bits */
	438	if (lc->sync == NOSYNC)
	439	for (i = lc->header.nr_regions; i < lc->region_count; i++)
	440	/* FIXME: amazingly inefficient */
	441	log_set_bit(lc, lc->clean_bits, i);
	442	else
	443	for (i = lc->header.nr_regions; i < lc->region_count; i++)
	444	/* FIXME: amazingly inefficient */
	445	log_clear_bit(lc, lc->clean_bits, i);
	446
	447	/* copy clean across to sync */
	448	memcpy(lc->sync_bits, lc->clean_bits, size);
	449	lc->sync_count = count_bits32(lc->clean_bits, lc->bitset_uint32_count);
	450
1da177e4 LT	451	/* set the correct number of regions in the header */
	452	lc->header.nr_regions = lc->region_count;
	453
	454	/* write the new header */
	455	return write_header(lc);
	456	}
	457
	458	static uint32_t core_get_region_size(struct dirty_log *log)
	459	{
	460	struct log_c lc = (struct log_c ) log->context;
	461	return lc->region_size;
	462	}
	463
	464	static int core_is_clean(struct dirty_log *log, region_t region)
	465	{
	466	struct log_c lc = (struct log_c ) log->context;
	467	return log_test_bit(lc->clean_bits, region);
	468	}
	469
	470	static int core_in_sync(struct dirty_log *log, region_t region, int block)
	471	{
	472	struct log_c lc = (struct log_c ) log->context;
	473	return log_test_bit(lc->sync_bits, region);
	474	}
	475
	476	static int core_flush(struct dirty_log *log)
	477	{
	478	/* no op */
	479	return 0;
	480	}
	481
	482	static int disk_flush(struct dirty_log *log)
	483	{
	484	int r;
	485	struct log_c lc = (struct log_c ) log->context;
	486
	487	/* only write if the log has changed */
	488	if (!lc->touched)
	489	return 0;
	490
702ca6f0	491	r = write_header(lc);
1da177e4 LT	492	if (!r)
	493	lc->touched = 0;
	494
	495	return r;
	496	}
	497
	498	static void core_mark_region(struct dirty_log *log, region_t region)
	499	{
	500	struct log_c lc = (struct log_c ) log->context;
	501	log_clear_bit(lc, lc->clean_bits, region);
	502	}
	503
	504	static void core_clear_region(struct dirty_log *log, region_t region)
	505	{
	506	struct log_c lc = (struct log_c ) log->context;
	507	log_set_bit(lc, lc->clean_bits, region);
	508	}
	509
	510	static int core_get_resync_work(struct dirty_log log, region_t region)
	511	{
	512	struct log_c lc = (struct log_c ) log->context;
	513
	514	if (lc->sync_search >= lc->region_count)
	515	return 0;
	516
	517	do {
1113a7e9 SB	518	*region = ext2_find_next_zero_bit(
1113a7e9 SB	519	(unsigned long *) lc->sync_bits,
1da177e4 LT	520	lc->region_count,
	521	lc->sync_search);
	522	lc->sync_search = *region + 1;
	523
ac81b2ee	524	if (*region >= lc->region_count)
1da177e4 LT	525	return 0;
	526
	527	} while (log_test_bit(lc->recovering_bits, *region));
	528
	529	log_set_bit(lc, lc->recovering_bits, *region);
	530	return 1;
	531	}
	532
	533	static void core_complete_resync_work(struct dirty_log *log, region_t region,
	534	int success)
	535	{
	536	struct log_c lc = (struct log_c ) log->context;
	537
	538	log_clear_bit(lc, lc->recovering_bits, region);
	539	if (success) {
	540	log_set_bit(lc, lc->sync_bits, region);
	541	lc->sync_count++;
	542	}
	543	}
	544
	545	static region_t core_get_sync_count(struct dirty_log *log)
	546	{
	547	struct log_c lc = (struct log_c ) log->context;
	548
	549	return lc->sync_count;
	550	}
	551
	552	#define DMEMIT_SYNC \
	553	if (lc->sync != DEFAULTSYNC) \
	554	DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")
	555
	556	static int core_status(struct dirty_log *log, status_type_t status,
	557	char *result, unsigned int maxlen)
	558	{
	559	int sz = 0;
	560	struct log_c *lc = log->context;
	561
	562	switch(status) {
	563	case STATUSTYPE_INFO:
	564	break;
	565
	566	case STATUSTYPE_TABLE:
	567	DMEMIT("%s %u %u ", log->type->name,
	568	lc->sync == DEFAULTSYNC ? 1 : 2, lc->region_size);
	569	DMEMIT_SYNC;
	570	}
	571
	572	return sz;
	573	}
	574
	575	static int disk_status(struct dirty_log *log, status_type_t status,
	576	char *result, unsigned int maxlen)
	577	{
	578	int sz = 0;
	579	char buffer[16];
	580	struct log_c *lc = log->context;
	581
	582	switch(status) {
	583	case STATUSTYPE_INFO:
	584	break;
	585
	586	case STATUSTYPE_TABLE:
	587	format_dev_t(buffer, lc->log_dev->bdev->bd_dev);
	588	DMEMIT("%s %u %s %u ", log->type->name,
589	lc->sync == DEFAULTSYNC ? 2 : 3, buffer,
590	lc->region_size);
591	DMEMIT_SYNC;
592	}
593
594	return sz;
595	}
596
597	static struct dirty_log_type _core_type = {
598	.name = "core",
599	.module = THIS_MODULE,
600	.ctr = core_ctr,
601	.dtr = core_dtr,
602	.get_region_size = core_get_region_size,
603	.is_clean = core_is_clean,
604	.in_sync = core_in_sync,
605	.flush = core_flush,
606	.mark_region = core_mark_region,
607	.clear_region = core_clear_region,
608	.get_resync_work = core_get_resync_work,
609	.complete_resync_work = core_complete_resync_work,
610	.get_sync_count = core_get_sync_count,
611	.status = core_status,
612	};
613
614	static struct dirty_log_type _disk_type = {
615	.name = "disk",
616	.module = THIS_MODULE,
617	.ctr = disk_ctr,
618	.dtr = disk_dtr,
619	.suspend = disk_flush,
620	.resume = disk_resume,
621	.get_region_size = core_get_region_size,
622	.is_clean = core_is_clean,
623	.in_sync = core_in_sync,
624	.flush = disk_flush,
625	.mark_region = core_mark_region,
626	.clear_region = core_clear_region,
627	.get_resync_work = core_get_resync_work,
628	.complete_resync_work = core_complete_resync_work,
629	.get_sync_count = core_get_sync_count,
630	.status = disk_status,
631	};
632
633	int __init dm_dirty_log_init(void)
634	{
635	int r;
636
637	r = dm_register_dirty_log_type(&_core_type);
638	if (r)
639	DMWARN("couldn't register core log");
640
641	r = dm_register_dirty_log_type(&_disk_type);
642	if (r) {
643	DMWARN("couldn't register disk type");
644	dm_unregister_dirty_log_type(&_core_type);
645	}
646
647	return r;
648	}
649
650	void dm_dirty_log_exit(void)
651	{
652	dm_unregister_dirty_log_type(&_disk_type);
653	dm_unregister_dirty_log_type(&_core_type);
654	}
655
656	EXPORT_SYMBOL(dm_register_dirty_log_type);
657	EXPORT_SYMBOL(dm_unregister_dirty_log_type);
658	EXPORT_SYMBOL(dm_create_dirty_log);
659	EXPORT_SYMBOL(dm_destroy_dirty_log);