dm-log.c 18.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * Copyright (C) 2003 Sistina Software
3
 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11
 *
 * This file is released under the LGPL.
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/vmalloc.h>
Alasdair G Kergon's avatar
Alasdair G Kergon committed
12 13
#include <linux/dm-io.h>
#include <linux/dm-dirty-log.h>
Linus Torvalds's avatar
Linus Torvalds committed
14

15
#include <linux/device-mapper.h>
Linus Torvalds's avatar
Linus Torvalds committed
16

17
#define DM_MSG_PREFIX "dirty region log"
18

Linus Torvalds's avatar
Linus Torvalds committed
19 20 21
static LIST_HEAD(_log_types);
static DEFINE_SPINLOCK(_lock);

22
static struct dm_dirty_log_type *__find_dirty_log_type(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
23
{
24
	struct dm_dirty_log_type *log_type;
25 26

	list_for_each_entry(log_type, &_log_types, list)
27
		if (!strcmp(name, log_type->name))
28 29 30 31 32
			return log_type;

	return NULL;
}

33
static struct dm_dirty_log_type *_get_dirty_log_type(const char *name)
34
{
35
	struct dm_dirty_log_type *log_type;
Linus Torvalds's avatar
Linus Torvalds committed
36 37

	spin_lock(&_lock);
38 39

	log_type = __find_dirty_log_type(name);
40
	if (log_type && !try_module_get(log_type->module))
41
		log_type = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
42 43

	spin_unlock(&_lock);
44 45

	return log_type;
Linus Torvalds's avatar
Linus Torvalds committed
46 47
}

Jonathan Brassow's avatar
Jonathan Brassow committed
48 49 50 51
/*
 * get_type
 * @type_name
 *
52
 * Attempt to retrieve the dm_dirty_log_type by name.  If not already
Jonathan Brassow's avatar
Jonathan Brassow committed
53 54 55 56 57 58 59 60 61 62 63 64
 * available, attempt to load the appropriate module.
 *
 * Log modules are named "dm-log-" followed by the 'type_name'.
 * Modules may contain multiple types.
 * This function will first try the module "dm-log-<type_name>",
 * then truncate 'type_name' on the last '-' and try again.
 *
 * For example, if type_name was "clustered-disk", it would search
 * 'dm-log-clustered-disk' then 'dm-log-clustered'.
 *
 * Returns: dirty_log_type* on success, NULL on failure
 */
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
65
static struct dm_dirty_log_type *get_type(const char *type_name)
Jonathan Brassow's avatar
Jonathan Brassow committed
66 67
{
	char *p, *type_name_dup;
68
	struct dm_dirty_log_type *log_type;
Jonathan Brassow's avatar
Jonathan Brassow committed
69

70 71 72 73 74
	if (!type_name)
		return NULL;

	log_type = _get_dirty_log_type(type_name);
	if (log_type)
75
		return log_type;
Jonathan Brassow's avatar
Jonathan Brassow committed
76 77 78 79 80 81 82 83 84

	type_name_dup = kstrdup(type_name, GFP_KERNEL);
	if (!type_name_dup) {
		DMWARN("No memory left to attempt log module load for \"%s\"",
		       type_name);
		return NULL;
	}

	while (request_module("dm-log-%s", type_name_dup) ||
85
	       !(log_type = _get_dirty_log_type(type_name))) {
Jonathan Brassow's avatar
Jonathan Brassow committed
86 87 88 89 90 91
		p = strrchr(type_name_dup, '-');
		if (!p)
			break;
		p[0] = '\0';
	}

92
	if (!log_type)
Jonathan Brassow's avatar
Jonathan Brassow committed
93 94 95 96
		DMWARN("Module for logging type \"%s\" not found.", type_name);

	kfree(type_name_dup);

97
	return log_type;
Jonathan Brassow's avatar
Jonathan Brassow committed
98 99
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
100
static void put_type(struct dm_dirty_log_type *type)
Linus Torvalds's avatar
Linus Torvalds committed
101
{
102 103 104
	if (!type)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
105
	spin_lock(&_lock);
106
	if (!__find_dirty_log_type(type->name))
107 108
		goto out;

109
	module_put(type->module);
110 111

out:
Linus Torvalds's avatar
Linus Torvalds committed
112 113 114
	spin_unlock(&_lock);
}

115 116
int dm_dirty_log_type_register(struct dm_dirty_log_type *type)
{
117 118
	int r = 0;

119
	spin_lock(&_lock);
120
	if (!__find_dirty_log_type(type->name))
121 122
		list_add(&type->list, &_log_types);
	else
123
		r = -EEXIST;
124 125
	spin_unlock(&_lock);

126
	return r;
127 128 129 130 131 132 133
}
EXPORT_SYMBOL(dm_dirty_log_type_register);

int dm_dirty_log_type_unregister(struct dm_dirty_log_type *type)
{
	spin_lock(&_lock);

134
	if (!__find_dirty_log_type(type->name)) {
135 136 137 138
		spin_unlock(&_lock);
		return -EINVAL;
	}

139
	list_del(&type->list);
140 141 142 143 144 145 146

	spin_unlock(&_lock);

	return 0;
}
EXPORT_SYMBOL(dm_dirty_log_type_unregister);

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
147 148 149
struct dm_dirty_log *dm_dirty_log_create(const char *type_name,
					 struct dm_target *ti,
					 unsigned int argc, char **argv)
Linus Torvalds's avatar
Linus Torvalds committed
150
{
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
151 152
	struct dm_dirty_log_type *type;
	struct dm_dirty_log *log;
Linus Torvalds's avatar
Linus Torvalds committed
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172

	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;
}
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
173
EXPORT_SYMBOL(dm_dirty_log_create);
Linus Torvalds's avatar
Linus Torvalds committed
174

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
175
void dm_dirty_log_destroy(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179 180
{
	log->type->dtr(log);
	put_type(log->type);
	kfree(log);
}
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
181
EXPORT_SYMBOL(dm_dirty_log_destroy);
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184 185 186 187 188 189 190 191 192 193 194

/*-----------------------------------------------------------------
 * 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.
 */
195
#define MIRROR_DISK_VERSION 2
Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
#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;

230 231
	struct dm_io_request io_req;

Linus Torvalds's avatar
Linus Torvalds committed
232 233 234
	/*
	 * Disk log fields
	 */
Jonathan E Brassow's avatar
Jonathan E Brassow committed
235
	int log_dev_failed;
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238
	struct dm_dev *log_dev;
	struct log_header header;

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
239
	struct dm_io_region header_location;
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242 243 244 245 246
	struct log_header *disk_header;
};

/*
 * The touched member needs to be updated every time we access
 * one of the bitsets.
 */
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
247
static inline int log_test_bit(uint32_t *bs, unsigned bit)
Linus Torvalds's avatar
Linus Torvalds committed
248
{
249
	return ext2_test_bit(bit, (unsigned long *) bs) ? 1 : 0;
Linus Torvalds's avatar
Linus Torvalds committed
250 251 252 253 254
}

static inline void log_set_bit(struct log_c *l,
			       uint32_t *bs, unsigned bit)
{
255
	ext2_set_bit(bit, (unsigned long *) bs);
Linus Torvalds's avatar
Linus Torvalds committed
256 257 258 259 260 261
	l->touched = 1;
}

static inline void log_clear_bit(struct log_c *l,
				 uint32_t *bs, unsigned bit)
{
262
	ext2_clear_bit(bit, (unsigned long *) bs);
Linus Torvalds's avatar
Linus Torvalds committed
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
	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);
}

283 284 285 286 287 288 289
static int rw_header(struct log_c *lc, int rw)
{
	lc->io_req.bi_rw = rw;

	return dm_io(&lc->io_req, 1, &lc->header_location, NULL);
}

Linus Torvalds's avatar
Linus Torvalds committed
290 291 292 293
static int read_header(struct log_c *log)
{
	int r;

294
	r = rw_header(log, READ);
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297 298 299 300 301 302 303 304 305 306
	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;
	}

307 308 309 310 311
#ifdef __LITTLE_ENDIAN
	if (log->header.version == 1)
		log->header.version = 2;
#endif

Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317 318 319
	if (log->header.version != MIRROR_DISK_VERSION) {
		DMWARN("incompatible disk log version");
		return -EINVAL;
	}

	return 0;
}

320 321 322 323 324 325 326 327 328 329 330
static int _check_region_size(struct dm_target *ti, uint32_t region_size)
{
	if (region_size < 2 || region_size > ti->len)
		return 0;

	if (!is_power_of_2(region_size))
		return 0;

	return 1;
}

Linus Torvalds's avatar
Linus Torvalds committed
331 332 333 334 335 336
/*----------------------------------------------------------------
 * core log constructor/destructor
 *
 * argv contains region_size followed optionally by [no]sync
 *--------------------------------------------------------------*/
#define BYTE_SHIFT 3
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
337
static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
338 339
			      unsigned int argc, char **argv,
			      struct dm_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
340 341 342 343 344 345
{
	enum sync sync = DEFAULTSYNC;

	struct log_c *lc;
	uint32_t region_size;
	unsigned int region_count;
346
	size_t bitset_size, buf_size;
347
	int r;
Linus Torvalds's avatar
Linus Torvalds committed
348 349

	if (argc < 1 || argc > 2) {
350
		DMWARN("wrong number of arguments to dirty region log");
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354 355 356 357 358 359
		return -EINVAL;
	}

	if (argc > 1) {
		if (!strcmp(argv[1], "sync"))
			sync = FORCESYNC;
		else if (!strcmp(argv[1], "nosync"))
			sync = NOSYNC;
		else {
360 361
			DMWARN("unrecognised sync argument to "
			       "dirty region log: %s", argv[1]);
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365
			return -EINVAL;
		}
	}

366 367 368
	if (sscanf(argv[0], "%u", &region_size) != 1 ||
	    !_check_region_size(ti, region_size)) {
		DMWARN("invalid region size %s", argv[0]);
Linus Torvalds's avatar
Linus Torvalds committed
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
		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;

	/*
387
	 * Work out how many "unsigned long"s we need to hold the bitset.
Linus Torvalds's avatar
Linus Torvalds committed
388 389
	 */
	bitset_size = dm_round_up(region_count,
390
				  sizeof(*lc->clean_bits) << BYTE_SHIFT);
Linus Torvalds's avatar
Linus Torvalds committed
391 392
	bitset_size >>= BYTE_SHIFT;

393
	lc->bitset_uint32_count = bitset_size / sizeof(*lc->clean_bits);
394 395 396 397 398 399 400 401 402 403 404 405 406 407

	/*
	 * Disk log?
	 */
	if (!dev) {
		lc->clean_bits = vmalloc(bitset_size);
		if (!lc->clean_bits) {
			DMWARN("couldn't allocate clean bitset");
			kfree(lc);
			return -ENOMEM;
		}
		lc->disk_header = NULL;
	} else {
		lc->log_dev = dev;
Jonathan E Brassow's avatar
Jonathan E Brassow committed
408
		lc->log_dev_failed = 0;
409 410 411 412 413 414 415
		lc->header_location.bdev = lc->log_dev->bdev;
		lc->header_location.sector = 0;

		/*
		 * Buffer holds both header and bitset.
		 */
		buf_size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) +
416 417
				       bitset_size,
				       ti->limits.logical_block_size);
418 419 420 421 422 423 424 425

		if (buf_size > dev->bdev->bd_inode->i_size) {
			DMWARN("log device %s too small: need %llu bytes",
				dev->name, (unsigned long long)buf_size);
			kfree(lc);
			return -EINVAL;
		}

426
		lc->header_location.count = buf_size >> SECTOR_SHIFT;
427

428
		lc->io_req.mem.type = DM_IO_VMA;
429
		lc->io_req.notify.fn = NULL;
430 431 432 433 434 435 436 437
		lc->io_req.client = dm_io_client_create(dm_div_up(buf_size,
								   PAGE_SIZE));
		if (IS_ERR(lc->io_req.client)) {
			r = PTR_ERR(lc->io_req.client);
			DMWARN("couldn't allocate disk io client");
			kfree(lc);
			return -ENOMEM;
		}
438 439 440 441

		lc->disk_header = vmalloc(buf_size);
		if (!lc->disk_header) {
			DMWARN("couldn't allocate disk log buffer");
442
			dm_io_client_destroy(lc->io_req.client);
443 444 445 446
			kfree(lc);
			return -ENOMEM;
		}

447
		lc->io_req.mem.ptr.vma = lc->disk_header;
448 449
		lc->clean_bits = (void *)lc->disk_header +
				 (LOG_OFFSET << SECTOR_SHIFT);
Linus Torvalds's avatar
Linus Torvalds committed
450
	}
451

Linus Torvalds's avatar
Linus Torvalds committed
452 453 454 455 456
	memset(lc->clean_bits, -1, bitset_size);

	lc->sync_bits = vmalloc(bitset_size);
	if (!lc->sync_bits) {
		DMWARN("couldn't allocate sync bitset");
457 458
		if (!dev)
			vfree(lc->clean_bits);
459 460
		else
			dm_io_client_destroy(lc->io_req.client);
461
		vfree(lc->disk_header);
Linus Torvalds's avatar
Linus Torvalds committed
462 463 464 465 466 467 468 469 470 471
		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);
472 473
		if (!dev)
			vfree(lc->clean_bits);
474 475
		else
			dm_io_client_destroy(lc->io_req.client);
476
		vfree(lc->disk_header);
Linus Torvalds's avatar
Linus Torvalds committed
477 478 479 480 481 482
		kfree(lc);
		return -ENOMEM;
	}
	memset(lc->recovering_bits, 0, bitset_size);
	lc->sync_search = 0;
	log->context = lc;
483

Linus Torvalds's avatar
Linus Torvalds committed
484 485 486
	return 0;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
487
static int core_ctr(struct dm_dirty_log *log, struct dm_target *ti,
488 489 490 491 492 493
		    unsigned int argc, char **argv)
{
	return create_log_context(log, ti, argc, argv, NULL);
}

static void destroy_log_context(struct log_c *lc)
Linus Torvalds's avatar
Linus Torvalds committed
494 495 496 497 498 499
{
	vfree(lc->sync_bits);
	vfree(lc->recovering_bits);
	kfree(lc);
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
500
static void core_dtr(struct dm_dirty_log *log)
501 502 503 504 505 506 507
{
	struct log_c *lc = (struct log_c *) log->context;

	vfree(lc->clean_bits);
	destroy_log_context(lc);
}

Linus Torvalds's avatar
Linus Torvalds committed
508 509 510 511 512
/*----------------------------------------------------------------
 * disk log constructor/destructor
 *
 * argv contains log_device region_size followed optionally by [no]sync
 *--------------------------------------------------------------*/
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
513
static int disk_ctr(struct dm_dirty_log *log, struct dm_target *ti,
Linus Torvalds's avatar
Linus Torvalds committed
514 515 516 517 518 519
		    unsigned int argc, char **argv)
{
	int r;
	struct dm_dev *dev;

	if (argc < 2 || argc > 3) {
520
		DMWARN("wrong number of arguments to disk dirty region log");
Linus Torvalds's avatar
Linus Torvalds committed
521 522 523 524 525 526 527 528
		return -EINVAL;
	}

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

529
	r = create_log_context(log, ti, argc - 1, argv + 1, dev);
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532 533 534 535 536 537
	if (r) {
		dm_put_device(ti, dev);
		return r;
	}

	return 0;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
538
static void disk_dtr(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
539 540
{
	struct log_c *lc = (struct log_c *) log->context;
541

Linus Torvalds's avatar
Linus Torvalds committed
542 543
	dm_put_device(lc->ti, lc->log_dev);
	vfree(lc->disk_header);
544
	dm_io_client_destroy(lc->io_req.client);
545
	destroy_log_context(lc);
Linus Torvalds's avatar
Linus Torvalds committed
546 547 548 549 550 551 552 553 554 555 556 557
}

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

Jonathan E Brassow's avatar
Jonathan E Brassow committed
558 559 560 561 562 563 564 565 566
static void fail_log_device(struct log_c *lc)
{
	if (lc->log_dev_failed)
		return;

	lc->log_dev_failed = 1;
	dm_table_event(lc->ti->table);
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
567
static int disk_resume(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571 572 573 574 575
{
	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);
Jonathan E Brassow's avatar
Jonathan E Brassow committed
576
	if (r) {
577
		DMWARN("%s: Failed to read header on dirty region log device",
Jonathan E Brassow's avatar
Jonathan E Brassow committed
578 579
		       lc->log_dev->name);
		fail_log_device(lc);
580 581 582 583 584 585 586 587
		/*
		 * If the log device cannot be read, we must assume
		 * all regions are out-of-sync.  If we simply return
		 * here, the state will be uninitialized and could
		 * lead us to return 'in-sync' status for regions
		 * that are actually 'out-of-sync'.
		 */
		lc->header.nr_regions = 0;
Jonathan E Brassow's avatar
Jonathan E Brassow committed
588
	}
Linus Torvalds's avatar
Linus Torvalds committed
589

590
	/* set or clear any new bits -- device has grown */
Linus Torvalds's avatar
Linus Torvalds committed
591 592 593 594 595 596 597 598 599
	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);

600 601 602 603
	/* clear any old bits -- device has shrunk */
	for (i = lc->region_count; i % (sizeof(*lc->clean_bits) << BYTE_SHIFT); i++)
		log_clear_bit(lc, lc->clean_bits, i);

Linus Torvalds's avatar
Linus Torvalds committed
604 605 606
	/* 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);
607
	lc->sync_search = 0;
Linus Torvalds's avatar
Linus Torvalds committed
608 609 610 611

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

612 613
	header_to_disk(&lc->header, lc->disk_header);

Linus Torvalds's avatar
Linus Torvalds committed
614
	/* write the new header */
615
	r = rw_header(lc, WRITE);
Jonathan E Brassow's avatar
Jonathan E Brassow committed
616
	if (r) {
617
		DMWARN("%s: Failed to write header on dirty region log device",
Jonathan E Brassow's avatar
Jonathan E Brassow committed
618 619 620 621 622
		       lc->log_dev->name);
		fail_log_device(lc);
	}

	return r;
Linus Torvalds's avatar
Linus Torvalds committed
623 624
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
625
static uint32_t core_get_region_size(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
626 627 628 629 630
{
	struct log_c *lc = (struct log_c *) log->context;
	return lc->region_size;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
631
static int core_resume(struct dm_dirty_log *log)
632 633 634 635 636 637
{
	struct log_c *lc = (struct log_c *) log->context;
	lc->sync_search = 0;
	return 0;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
638
static int core_is_clean(struct dm_dirty_log *log, region_t region)
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643
{
	struct log_c *lc = (struct log_c *) log->context;
	return log_test_bit(lc->clean_bits, region);
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
644
static int core_in_sync(struct dm_dirty_log *log, region_t region, int block)
Linus Torvalds's avatar
Linus Torvalds committed
645 646 647 648 649
{
	struct log_c *lc = (struct log_c *) log->context;
	return log_test_bit(lc->sync_bits, region);
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
650
static int core_flush(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
651 652 653 654 655
{
	/* no op */
	return 0;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
656
static int disk_flush(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
657 658 659 660 661 662 663 664
{
	int r;
	struct log_c *lc = (struct log_c *) log->context;

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

665
	r = rw_header(lc, WRITE);
Jonathan E Brassow's avatar
Jonathan E Brassow committed
666 667 668
	if (r)
		fail_log_device(lc);
	else
Linus Torvalds's avatar
Linus Torvalds committed
669 670 671 672 673
		lc->touched = 0;

	return r;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
674
static void core_mark_region(struct dm_dirty_log *log, region_t region)
Linus Torvalds's avatar
Linus Torvalds committed
675 676 677 678 679
{
	struct log_c *lc = (struct log_c *) log->context;
	log_clear_bit(lc, lc->clean_bits, region);
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
680
static void core_clear_region(struct dm_dirty_log *log, region_t region)
Linus Torvalds's avatar
Linus Torvalds committed
681 682 683 684 685
{
	struct log_c *lc = (struct log_c *) log->context;
	log_set_bit(lc, lc->clean_bits, region);
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
686
static int core_get_resync_work(struct dm_dirty_log *log, region_t *region)
Linus Torvalds's avatar
Linus Torvalds committed
687 688 689 690 691 692 693
{
	struct log_c *lc = (struct log_c *) log->context;

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

	do {
694 695
		*region = ext2_find_next_zero_bit(
					     (unsigned long *) lc->sync_bits,
Linus Torvalds's avatar
Linus Torvalds committed
696 697 698 699
					     lc->region_count,
					     lc->sync_search);
		lc->sync_search = *region + 1;

700
		if (*region >= lc->region_count)
Linus Torvalds's avatar
Linus Torvalds committed
701 702 703 704 705 706 707 708
			return 0;

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

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

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
709
static void core_set_region_sync(struct dm_dirty_log *log, region_t region,
710
				 int in_sync)
Linus Torvalds's avatar
Linus Torvalds committed
711 712 713 714
{
	struct log_c *lc = (struct log_c *) log->context;

	log_clear_bit(lc, lc->recovering_bits, region);
715
	if (in_sync) {
Linus Torvalds's avatar
Linus Torvalds committed
716 717
		log_set_bit(lc, lc->sync_bits, region);
                lc->sync_count++;
718 719 720 721
        } else if (log_test_bit(lc->sync_bits, region)) {
		lc->sync_count--;
		log_clear_bit(lc, lc->sync_bits, region);
	}
Linus Torvalds's avatar
Linus Torvalds committed
722 723
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
724
static region_t core_get_sync_count(struct dm_dirty_log *log)
Linus Torvalds's avatar
Linus Torvalds committed
725 726 727 728 729 730 731 732 733 734
{
        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" : "")

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
735
static int core_status(struct dm_dirty_log *log, status_type_t status,
Linus Torvalds's avatar
Linus Torvalds committed
736 737 738 739 740 741 742
		       char *result, unsigned int maxlen)
{
	int sz = 0;
	struct log_c *lc = log->context;

	switch(status) {
	case STATUSTYPE_INFO:
743
		DMEMIT("1 %s", log->type->name);
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746 747 748 749 750 751 752 753 754
		break;

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

	return sz;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
755
static int disk_status(struct dm_dirty_log *log, status_type_t status,
Linus Torvalds's avatar
Linus Torvalds committed
756 757 758 759 760 761 762
		       char *result, unsigned int maxlen)
{
	int sz = 0;
	struct log_c *lc = log->context;

	switch(status) {
	case STATUSTYPE_INFO:
763 764
		DMEMIT("3 %s %s %c", log->type->name, lc->log_dev->name,
		       lc->log_dev_failed ? 'D' : 'A');
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768
		break;

	case STATUSTYPE_TABLE:
		DMEMIT("%s %u %s %u ", log->type->name,
769
		       lc->sync == DEFAULTSYNC ? 2 : 3, lc->log_dev->name,
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773 774 775 776
		       lc->region_size);
		DMEMIT_SYNC;
	}

	return sz;
}

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
777
static struct dm_dirty_log_type _core_type = {
Linus Torvalds's avatar
Linus Torvalds committed
778 779 780 781
	.name = "core",
	.module = THIS_MODULE,
	.ctr = core_ctr,
	.dtr = core_dtr,
782
	.resume = core_resume,
Linus Torvalds's avatar
Linus Torvalds committed
783 784 785 786 787 788 789
	.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,
790
	.set_region_sync = core_set_region_sync,
Linus Torvalds's avatar
Linus Torvalds committed
791 792 793 794
	.get_sync_count = core_get_sync_count,
	.status = core_status,
};

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
795
static struct dm_dirty_log_type _disk_type = {
Linus Torvalds's avatar
Linus Torvalds committed
796 797 798 799
	.name = "disk",
	.module = THIS_MODULE,
	.ctr = disk_ctr,
	.dtr = disk_dtr,
Jonathan Brassow's avatar
Jonathan Brassow committed
800
	.postsuspend = disk_flush,
Linus Torvalds's avatar
Linus Torvalds committed
801 802 803 804 805 806 807 808
	.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,
809
	.set_region_sync = core_set_region_sync,
Linus Torvalds's avatar
Linus Torvalds committed
810 811 812 813
	.get_sync_count = core_get_sync_count,
	.status = disk_status,
};

814
static int __init dm_dirty_log_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
815 816 817
{
	int r;

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
818
	r = dm_dirty_log_type_register(&_core_type);
Linus Torvalds's avatar
Linus Torvalds committed
819 820 821
	if (r)
		DMWARN("couldn't register core log");

Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
822
	r = dm_dirty_log_type_register(&_disk_type);
Linus Torvalds's avatar
Linus Torvalds committed
823 824
	if (r) {
		DMWARN("couldn't register disk type");
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
825
		dm_dirty_log_type_unregister(&_core_type);
Linus Torvalds's avatar
Linus Torvalds committed
826 827 828 829 830
	}

	return r;
}

831
static void __exit dm_dirty_log_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
832
{
Heinz Mauelshagen's avatar
Heinz Mauelshagen committed
833 834
	dm_dirty_log_type_unregister(&_disk_type);
	dm_dirty_log_type_unregister(&_core_type);
Linus Torvalds's avatar
Linus Torvalds committed
835 836
}

837 838 839 840 841 842
module_init(dm_dirty_log_init);
module_exit(dm_dirty_log_exit);

MODULE_DESCRIPTION(DM_NAME " dirty region log");
MODULE_AUTHOR("Joe Thornber, Heinz Mauelshagen <dm-devel@redhat.com>");
MODULE_LICENSE("GPL");