dm-snap.c 52.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10
/*
 * dm-snapshot.c
 *
 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
 *
 * This file is released under the GPL.
 */

#include <linux/blkdev.h>
#include <linux/device-mapper.h>
11
#include <linux/delay.h>
L
Linus Torvalds 已提交
12 13 14 15 16 17 18 19
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kdev_t.h>
#include <linux/list.h>
#include <linux/mempool.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
V
vignesh babu 已提交
20
#include <linux/log2.h>
A
Alasdair G Kergon 已提交
21
#include <linux/dm-kcopyd.h>
L
Linus Torvalds 已提交
22

23
#include "dm-exception-store.h"
L
Linus Torvalds 已提交
24

25 26
#define DM_MSG_PREFIX "snapshots"

M
Mikulas Patocka 已提交
27 28 29 30 31
static const char dm_snapshot_merge_target_name[] = "snapshot-merge";

#define dm_target_is_snapshot_merge(ti) \
	((ti)->type->name == dm_snapshot_merge_target_name)

32 33 34 35 36
/*
 * The size of the mempool used to track chunks in use.
 */
#define MIN_IOS 256

37 38 39 40
#define DM_TRACKED_CHUNK_HASH_SIZE	16
#define DM_TRACKED_CHUNK_HASH(x)	((unsigned long)(x) & \
					 (DM_TRACKED_CHUNK_HASH_SIZE - 1))

41
struct dm_exception_table {
42 43 44 45 46 47 48 49 50
	uint32_t hash_mask;
	unsigned hash_shift;
	struct list_head *table;
};

struct dm_snapshot {
	struct rw_semaphore lock;

	struct dm_dev *origin;
51 52 53
	struct dm_dev *cow;

	struct dm_target *ti;
54 55 56 57

	/* List of snapshots per Origin */
	struct list_head list;

58 59 60 61
	/*
	 * You can't use a snapshot if this is 0 (e.g. if full).
	 * A snapshot-merge target never clears this.
	 */
62 63 64 65 66 67 68
	int valid;

	/* Origin writes don't trigger exceptions until this is set */
	int active;

	atomic_t pending_exceptions_count;

69 70
	mempool_t *pending_pool;

71 72
	struct dm_exception_table pending;
	struct dm_exception_table complete;
73 74 75 76 77 78 79

	/*
	 * pe_lock protects all pending_exception operations and access
	 * as well as the snapshot_bios list.
	 */
	spinlock_t pe_lock;

80 81 82 83 84
	/* Chunks with outstanding reads */
	spinlock_t tracked_chunk_lock;
	mempool_t *tracked_chunk_pool;
	struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE];

85 86 87 88 89
	/* The on disk metadata handler */
	struct dm_exception_store *store;

	struct dm_kcopyd_client *kcopyd_client;

90 91 92 93 94 95
	/* Wait for events based on state_bits */
	unsigned long state_bits;

	/* Range of chunks currently being merged. */
	chunk_t first_merging_chunk;
	int num_merging_chunks;
M
Mikulas Patocka 已提交
96

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
	/*
	 * The merge operation failed if this flag is set.
	 * Failure modes are handled as follows:
	 * - I/O error reading the header
	 *   	=> don't load the target; abort.
	 * - Header does not have "valid" flag set
	 *   	=> use the origin; forget about the snapshot.
	 * - I/O error when reading exceptions
	 *   	=> don't load the target; abort.
	 *         (We can't use the intermediate origin state.)
	 * - I/O error while merging
	 *	=> stop merging; set merge_failed; process I/O normally.
	 */
	int merge_failed;

112 113 114 115 116
	/*
	 * Incoming bios that overlap with chunks being merged must wait
	 * for them to be committed.
	 */
	struct bio_list bios_queued_during_merge;
117 118
};

M
Mikulas Patocka 已提交
119 120 121 122 123 124 125 126 127
/*
 * state_bits:
 *   RUNNING_MERGE  - Merge operation is in progress.
 *   SHUTDOWN_MERGE - Set to signal that merge needs to be stopped;
 *                    cleared afterwards.
 */
#define RUNNING_MERGE          0
#define SHUTDOWN_MERGE         1

128 129 130 131 132 133
struct dm_dev *dm_snap_origin(struct dm_snapshot *s)
{
	return s->origin;
}
EXPORT_SYMBOL(dm_snap_origin);

134 135 136 137 138 139
struct dm_dev *dm_snap_cow(struct dm_snapshot *s)
{
	return s->cow;
}
EXPORT_SYMBOL(dm_snap_cow);

140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
static sector_t chunk_to_sector(struct dm_exception_store *store,
				chunk_t chunk)
{
	return chunk << store->chunk_shift;
}

static int bdev_equal(struct block_device *lhs, struct block_device *rhs)
{
	/*
	 * There is only ever one instance of a particular block
	 * device so we can compare pointers safely.
	 */
	return lhs == rhs;
}

A
Alasdair G Kergon 已提交
155
struct dm_snap_pending_exception {
156
	struct dm_exception e;
L
Linus Torvalds 已提交
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172

	/*
	 * Origin buffers waiting for this to complete are held
	 * in a bio list
	 */
	struct bio_list origin_bios;
	struct bio_list snapshot_bios;

	/* Pointer back to snapshot context */
	struct dm_snapshot *snap;

	/*
	 * 1 indicates the exception has already been sent to
	 * kcopyd.
	 */
	int started;
173 174 175 176 177 178 179

	/*
	 * For writing a complete chunk, bypassing the copy.
	 */
	struct bio *full_bio;
	bio_end_io_t *full_bio_end_io;
	void *full_bio_private;
L
Linus Torvalds 已提交
180 181 182 183 184 185
};

/*
 * Hash table mapping origin volumes to lists of snapshots and
 * a lock to protect it
 */
186 187
static struct kmem_cache *exception_cache;
static struct kmem_cache *pending_cache;
L
Linus Torvalds 已提交
188

189 190 191 192 193 194 195 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
struct dm_snap_tracked_chunk {
	struct hlist_node node;
	chunk_t chunk;
};

static struct kmem_cache *tracked_chunk_cache;

static struct dm_snap_tracked_chunk *track_chunk(struct dm_snapshot *s,
						 chunk_t chunk)
{
	struct dm_snap_tracked_chunk *c = mempool_alloc(s->tracked_chunk_pool,
							GFP_NOIO);
	unsigned long flags;

	c->chunk = chunk;

	spin_lock_irqsave(&s->tracked_chunk_lock, flags);
	hlist_add_head(&c->node,
		       &s->tracked_chunk_hash[DM_TRACKED_CHUNK_HASH(chunk)]);
	spin_unlock_irqrestore(&s->tracked_chunk_lock, flags);

	return c;
}

static void stop_tracking_chunk(struct dm_snapshot *s,
				struct dm_snap_tracked_chunk *c)
{
	unsigned long flags;

	spin_lock_irqsave(&s->tracked_chunk_lock, flags);
	hlist_del(&c->node);
	spin_unlock_irqrestore(&s->tracked_chunk_lock, flags);

	mempool_free(c, s->tracked_chunk_pool);
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
static int __chunk_is_tracked(struct dm_snapshot *s, chunk_t chunk)
{
	struct dm_snap_tracked_chunk *c;
	struct hlist_node *hn;
	int found = 0;

	spin_lock_irq(&s->tracked_chunk_lock);

	hlist_for_each_entry(c, hn,
	    &s->tracked_chunk_hash[DM_TRACKED_CHUNK_HASH(chunk)], node) {
		if (c->chunk == chunk) {
			found = 1;
			break;
		}
	}

	spin_unlock_irq(&s->tracked_chunk_lock);

	return found;
}

246 247 248 249 250 251 252 253 254 255
/*
 * This conflicting I/O is extremely improbable in the caller,
 * so msleep(1) is sufficient and there is no need for a wait queue.
 */
static void __check_for_conflicting_io(struct dm_snapshot *s, chunk_t chunk)
{
	while (__chunk_is_tracked(s, chunk))
		msleep(1);
}

L
Linus Torvalds 已提交
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
/*
 * One of these per registered origin, held in the snapshot_origins hash
 */
struct origin {
	/* The origin device */
	struct block_device *bdev;

	struct list_head hash_list;

	/* List of snapshots for this origin */
	struct list_head snapshots;
};

/*
 * Size of the hash table for origin volumes. If we make this
 * the size of the minors list then it should be nearly perfect
 */
#define ORIGIN_HASH_SIZE 256
#define ORIGIN_MASK      0xFF
static struct list_head *_origins;
static struct rw_semaphore _origins_lock;

278 279 280 281
static DECLARE_WAIT_QUEUE_HEAD(_pending_exceptions_done);
static DEFINE_SPINLOCK(_pending_exceptions_done_spinlock);
static uint64_t _pending_exceptions_done_count;

L
Linus Torvalds 已提交
282 283 284 285 286 287 288
static int init_origin_hash(void)
{
	int i;

	_origins = kmalloc(ORIGIN_HASH_SIZE * sizeof(struct list_head),
			   GFP_KERNEL);
	if (!_origins) {
289
		DMERR("unable to allocate memory");
L
Linus Torvalds 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
		return -ENOMEM;
	}

	for (i = 0; i < ORIGIN_HASH_SIZE; i++)
		INIT_LIST_HEAD(_origins + i);
	init_rwsem(&_origins_lock);

	return 0;
}

static void exit_origin_hash(void)
{
	kfree(_origins);
}

A
Alasdair G Kergon 已提交
305
static unsigned origin_hash(struct block_device *bdev)
L
Linus Torvalds 已提交
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
{
	return bdev->bd_dev & ORIGIN_MASK;
}

static struct origin *__lookup_origin(struct block_device *origin)
{
	struct list_head *ol;
	struct origin *o;

	ol = &_origins[origin_hash(origin)];
	list_for_each_entry (o, ol, hash_list)
		if (bdev_equal(o->bdev, origin))
			return o;

	return NULL;
}

static void __insert_origin(struct origin *o)
{
	struct list_head *sl = &_origins[origin_hash(o->bdev)];
	list_add_tail(&o->hash_list, sl);
}

329 330 331 332 333
/*
 * _origins_lock must be held when calling this function.
 * Returns number of snapshots registered using the supplied cow device, plus:
 * snap_src - a snapshot suitable for use as a source of exception handover
 * snap_dest - a snapshot capable of receiving exception handover.
334 335
 * snap_merge - an existing snapshot-merge target linked to the same origin.
 *   There can be at most one snapshot-merge target. The parameter is optional.
336
 *
337
 * Possible return values and states of snap_src and snap_dest.
338 339 340 341 342 343 344 345
 *   0: NULL, NULL  - first new snapshot
 *   1: snap_src, NULL - normal snapshot
 *   2: snap_src, snap_dest  - waiting for handover
 *   2: snap_src, NULL - handed over, waiting for old to be deleted
 *   1: NULL, snap_dest - source got destroyed without handover
 */
static int __find_snapshots_sharing_cow(struct dm_snapshot *snap,
					struct dm_snapshot **snap_src,
346 347
					struct dm_snapshot **snap_dest,
					struct dm_snapshot **snap_merge)
348 349 350 351 352 353 354 355 356 357 358
{
	struct dm_snapshot *s;
	struct origin *o;
	int count = 0;
	int active;

	o = __lookup_origin(snap->origin->bdev);
	if (!o)
		goto out;

	list_for_each_entry(s, &o->snapshots, list) {
359 360
		if (dm_target_is_snapshot_merge(s->ti) && snap_merge)
			*snap_merge = s;
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
		if (!bdev_equal(s->cow->bdev, snap->cow->bdev))
			continue;

		down_read(&s->lock);
		active = s->active;
		up_read(&s->lock);

		if (active) {
			if (snap_src)
				*snap_src = s;
		} else if (snap_dest)
			*snap_dest = s;

		count++;
	}

out:
	return count;
}

/*
 * On success, returns 1 if this snapshot is a handover destination,
 * otherwise returns 0.
 */
static int __validate_exception_handover(struct dm_snapshot *snap)
{
	struct dm_snapshot *snap_src = NULL, *snap_dest = NULL;
388
	struct dm_snapshot *snap_merge = NULL;
389 390

	/* Does snapshot need exceptions handed over to it? */
391 392
	if ((__find_snapshots_sharing_cow(snap, &snap_src, &snap_dest,
					  &snap_merge) == 2) ||
393 394 395 396 397 398 399 400 401 402 403 404 405
	    snap_dest) {
		snap->ti->error = "Snapshot cow pairing for exception "
				  "table handover failed";
		return -EINVAL;
	}

	/*
	 * If no snap_src was found, snap cannot become a handover
	 * destination.
	 */
	if (!snap_src)
		return 0;

406 407 408 409 410 411 412 413 414 415 416 417 418 419
	/*
	 * Non-snapshot-merge handover?
	 */
	if (!dm_target_is_snapshot_merge(snap->ti))
		return 1;

	/*
	 * Do not allow more than one merging snapshot.
	 */
	if (snap_merge) {
		snap->ti->error = "A snapshot is already merging.";
		return -EINVAL;
	}

M
Mikulas Patocka 已提交
420 421 422 423 424 425 426
	if (!snap_src->store->type->prepare_merge ||
	    !snap_src->store->type->commit_merge) {
		snap->ti->error = "Snapshot exception store does not "
				  "support snapshot-merge.";
		return -EINVAL;
	}

427 428 429 430 431 432 433 434 435 436 437 438 439 440
	return 1;
}

static void __insert_snapshot(struct origin *o, struct dm_snapshot *s)
{
	struct dm_snapshot *l;

	/* Sort the list according to chunk size, largest-first smallest-last */
	list_for_each_entry(l, &o->snapshots, list)
		if (l->store->chunk_size < s->store->chunk_size)
			break;
	list_add_tail(&s->list, &l->list);
}

L
Linus Torvalds 已提交
441 442 443
/*
 * Make a note of the snapshot and its origin so we can look it
 * up when the origin has a write on it.
444 445 446 447
 *
 * Also validate snapshot exception store handovers.
 * On success, returns 1 if this registration is a handover destination,
 * otherwise returns 0.
L
Linus Torvalds 已提交
448 449 450
 */
static int register_snapshot(struct dm_snapshot *snap)
{
451
	struct origin *o, *new_o = NULL;
L
Linus Torvalds 已提交
452
	struct block_device *bdev = snap->origin->bdev;
453
	int r = 0;
L
Linus Torvalds 已提交
454

455 456 457 458
	new_o = kmalloc(sizeof(*new_o), GFP_KERNEL);
	if (!new_o)
		return -ENOMEM;

L
Linus Torvalds 已提交
459 460
	down_write(&_origins_lock);

461 462 463 464 465 466 467
	r = __validate_exception_handover(snap);
	if (r < 0) {
		kfree(new_o);
		goto out;
	}

	o = __lookup_origin(bdev);
468 469 470
	if (o)
		kfree(new_o);
	else {
L
Linus Torvalds 已提交
471
		/* New origin */
472
		o = new_o;
L
Linus Torvalds 已提交
473 474 475 476 477 478 479 480

		/* Initialise the struct */
		INIT_LIST_HEAD(&o->snapshots);
		o->bdev = bdev;

		__insert_origin(o);
	}

481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
	__insert_snapshot(o, snap);

out:
	up_write(&_origins_lock);

	return r;
}

/*
 * Move snapshot to correct place in list according to chunk size.
 */
static void reregister_snapshot(struct dm_snapshot *s)
{
	struct block_device *bdev = s->origin->bdev;

	down_write(&_origins_lock);

	list_del(&s->list);
	__insert_snapshot(__lookup_origin(bdev), s);
L
Linus Torvalds 已提交
500 501 502 503 504 505 506 507 508 509 510 511

	up_write(&_origins_lock);
}

static void unregister_snapshot(struct dm_snapshot *s)
{
	struct origin *o;

	down_write(&_origins_lock);
	o = __lookup_origin(s->origin->bdev);

	list_del(&s->list);
512
	if (o && list_empty(&o->snapshots)) {
L
Linus Torvalds 已提交
513 514 515 516 517 518 519 520 521
		list_del(&o->hash_list);
		kfree(o);
	}

	up_write(&_origins_lock);
}

/*
 * Implementation of the exception hash tables.
522 523
 * The lowest hash_shift bits of the chunk number are ignored, allowing
 * some consecutive chunks to be grouped together.
L
Linus Torvalds 已提交
524
 */
525 526
static int dm_exception_table_init(struct dm_exception_table *et,
				   uint32_t size, unsigned hash_shift)
L
Linus Torvalds 已提交
527 528 529
{
	unsigned int i;

530
	et->hash_shift = hash_shift;
L
Linus Torvalds 已提交
531 532 533 534 535 536 537 538 539 540 541
	et->hash_mask = size - 1;
	et->table = dm_vcalloc(size, sizeof(struct list_head));
	if (!et->table)
		return -ENOMEM;

	for (i = 0; i < size; i++)
		INIT_LIST_HEAD(et->table + i);

	return 0;
}

542 543
static void dm_exception_table_exit(struct dm_exception_table *et,
				    struct kmem_cache *mem)
L
Linus Torvalds 已提交
544 545
{
	struct list_head *slot;
546
	struct dm_exception *ex, *next;
L
Linus Torvalds 已提交
547 548 549 550 551 552 553 554 555 556 557 558 559
	int i, size;

	size = et->hash_mask + 1;
	for (i = 0; i < size; i++) {
		slot = et->table + i;

		list_for_each_entry_safe (ex, next, slot, hash_list)
			kmem_cache_free(mem, ex);
	}

	vfree(et->table);
}

560
static uint32_t exception_hash(struct dm_exception_table *et, chunk_t chunk)
L
Linus Torvalds 已提交
561
{
562
	return (chunk >> et->hash_shift) & et->hash_mask;
L
Linus Torvalds 已提交
563 564
}

565
static void dm_remove_exception(struct dm_exception *e)
L
Linus Torvalds 已提交
566 567 568 569 570 571 572 573
{
	list_del(&e->hash_list);
}

/*
 * Return the exception data for a sector, or NULL if not
 * remapped.
 */
574 575
static struct dm_exception *dm_lookup_exception(struct dm_exception_table *et,
						chunk_t chunk)
L
Linus Torvalds 已提交
576 577
{
	struct list_head *slot;
578
	struct dm_exception *e;
L
Linus Torvalds 已提交
579 580 581

	slot = &et->table[exception_hash(et, chunk)];
	list_for_each_entry (e, slot, hash_list)
582 583
		if (chunk >= e->old_chunk &&
		    chunk <= e->old_chunk + dm_consecutive_chunk_count(e))
L
Linus Torvalds 已提交
584 585 586 587 588
			return e;

	return NULL;
}

589
static struct dm_exception *alloc_completed_exception(void)
L
Linus Torvalds 已提交
590
{
591
	struct dm_exception *e;
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599

	e = kmem_cache_alloc(exception_cache, GFP_NOIO);
	if (!e)
		e = kmem_cache_alloc(exception_cache, GFP_ATOMIC);

	return e;
}

600
static void free_completed_exception(struct dm_exception *e)
L
Linus Torvalds 已提交
601 602 603 604
{
	kmem_cache_free(exception_cache, e);
}

605
static struct dm_snap_pending_exception *alloc_pending_exception(struct dm_snapshot *s)
L
Linus Torvalds 已提交
606
{
607 608 609
	struct dm_snap_pending_exception *pe = mempool_alloc(s->pending_pool,
							     GFP_NOIO);

610
	atomic_inc(&s->pending_exceptions_count);
611 612 613
	pe->snap = s;

	return pe;
L
Linus Torvalds 已提交
614 615
}

A
Alasdair G Kergon 已提交
616
static void free_pending_exception(struct dm_snap_pending_exception *pe)
L
Linus Torvalds 已提交
617
{
618 619 620 621 622
	struct dm_snapshot *s = pe->snap;

	mempool_free(pe, s->pending_pool);
	smp_mb__before_atomic_dec();
	atomic_dec(&s->pending_exceptions_count);
L
Linus Torvalds 已提交
623 624
}

625 626
static void dm_insert_exception(struct dm_exception_table *eh,
				struct dm_exception *new_e)
627 628
{
	struct list_head *l;
629
	struct dm_exception *e = NULL;
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644

	l = &eh->table[exception_hash(eh, new_e->old_chunk)];

	/* Add immediately if this table doesn't support consecutive chunks */
	if (!eh->hash_shift)
		goto out;

	/* List is ordered by old_chunk */
	list_for_each_entry_reverse(e, l, hash_list) {
		/* Insert after an existing chunk? */
		if (new_e->old_chunk == (e->old_chunk +
					 dm_consecutive_chunk_count(e) + 1) &&
		    new_e->new_chunk == (dm_chunk_number(e->new_chunk) +
					 dm_consecutive_chunk_count(e) + 1)) {
			dm_consecutive_chunk_count_inc(e);
645
			free_completed_exception(new_e);
646 647 648 649 650 651 652 653 654
			return;
		}

		/* Insert before an existing chunk? */
		if (new_e->old_chunk == (e->old_chunk - 1) &&
		    new_e->new_chunk == (dm_chunk_number(e->new_chunk) - 1)) {
			dm_consecutive_chunk_count_inc(e);
			e->old_chunk--;
			e->new_chunk--;
655
			free_completed_exception(new_e);
656 657 658 659 660 661 662 663 664 665 666
			return;
		}

		if (new_e->old_chunk > e->old_chunk)
			break;
	}

out:
	list_add(&new_e->hash_list, e ? &e->hash_list : l);
}

667 668 669 670 671
/*
 * Callback used by the exception stores to load exceptions when
 * initialising.
 */
static int dm_add_exception(void *context, chunk_t old, chunk_t new)
L
Linus Torvalds 已提交
672
{
673
	struct dm_snapshot *s = context;
674
	struct dm_exception *e;
L
Linus Torvalds 已提交
675

676
	e = alloc_completed_exception();
L
Linus Torvalds 已提交
677 678 679 680
	if (!e)
		return -ENOMEM;

	e->old_chunk = old;
681 682

	/* Consecutive_count is implicitly initialised to zero */
L
Linus Torvalds 已提交
683
	e->new_chunk = new;
684

685
	dm_insert_exception(&s->complete, e);
686

L
Linus Torvalds 已提交
687 688 689
	return 0;
}

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
/*
 * Return a minimum chunk size of all snapshots that have the specified origin.
 * Return zero if the origin has no snapshots.
 */
static sector_t __minimum_chunk_size(struct origin *o)
{
	struct dm_snapshot *snap;
	unsigned chunk_size = 0;

	if (o)
		list_for_each_entry(snap, &o->snapshots, list)
			chunk_size = min_not_zero(chunk_size,
						  snap->store->chunk_size);

	return chunk_size;
}

L
Linus Torvalds 已提交
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
/*
 * Hard coded magic.
 */
static int calc_max_buckets(void)
{
	/* use a fixed size of 2MB */
	unsigned long mem = 2 * 1024 * 1024;
	mem /= sizeof(struct list_head);

	return mem;
}

/*
 * Allocate room for a suitable hash table.
 */
722
static int init_hash_tables(struct dm_snapshot *s)
L
Linus Torvalds 已提交
723 724 725 726 727 728 729
{
	sector_t hash_size, cow_dev_size, origin_dev_size, max_buckets;

	/*
	 * Calculate based on the size of the original volume or
	 * the COW volume...
	 */
730
	cow_dev_size = get_dev_size(s->cow->bdev);
L
Linus Torvalds 已提交
731 732 733
	origin_dev_size = get_dev_size(s->origin->bdev);
	max_buckets = calc_max_buckets();

734
	hash_size = min(origin_dev_size, cow_dev_size) >> s->store->chunk_shift;
L
Linus Torvalds 已提交
735 736
	hash_size = min(hash_size, max_buckets);

737 738
	if (hash_size < 64)
		hash_size = 64;
739
	hash_size = rounddown_pow_of_two(hash_size);
740 741
	if (dm_exception_table_init(&s->complete, hash_size,
				    DM_CHUNK_CONSECUTIVE_BITS))
L
Linus Torvalds 已提交
742 743 744 745 746 747 748 749 750 751
		return -ENOMEM;

	/*
	 * Allocate hash table for in-flight exceptions
	 * Make this smaller than the real hash table
	 */
	hash_size >>= 3;
	if (hash_size < 64)
		hash_size = 64;

752 753
	if (dm_exception_table_init(&s->pending, hash_size, 0)) {
		dm_exception_table_exit(&s->complete, exception_cache);
L
Linus Torvalds 已提交
754 755 756 757 758 759
		return -ENOMEM;
	}

	return 0;
}

M
Mikulas Patocka 已提交
760 761 762 763 764 765 766
static void merge_shutdown(struct dm_snapshot *s)
{
	clear_bit_unlock(RUNNING_MERGE, &s->state_bits);
	smp_mb__after_clear_bit();
	wake_up_bit(&s->state_bits, RUNNING_MERGE);
}

767 768 769 770 771 772 773 774
static struct bio *__release_queued_bios_after_merge(struct dm_snapshot *s)
{
	s->first_merging_chunk = 0;
	s->num_merging_chunks = 0;

	return bio_list_get(&s->bios_queued_during_merge);
}

M
Mikulas Patocka 已提交
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
/*
 * Remove one chunk from the index of completed exceptions.
 */
static int __remove_single_exception_chunk(struct dm_snapshot *s,
					   chunk_t old_chunk)
{
	struct dm_exception *e;

	e = dm_lookup_exception(&s->complete, old_chunk);
	if (!e) {
		DMERR("Corruption detected: exception for block %llu is "
		      "on disk but not in memory",
		      (unsigned long long)old_chunk);
		return -EINVAL;
	}

	/*
	 * If this is the only chunk using this exception, remove exception.
	 */
	if (!dm_consecutive_chunk_count(e)) {
		dm_remove_exception(e);
		free_completed_exception(e);
		return 0;
	}

	/*
	 * The chunk may be either at the beginning or the end of a
	 * group of consecutive chunks - never in the middle.  We are
	 * removing chunks in the opposite order to that in which they
	 * were added, so this should always be true.
	 * Decrement the consecutive chunk counter and adjust the
	 * starting point if necessary.
	 */
	if (old_chunk == e->old_chunk) {
		e->old_chunk++;
		e->new_chunk++;
	} else if (old_chunk != e->old_chunk +
		   dm_consecutive_chunk_count(e)) {
		DMERR("Attempt to merge block %llu from the "
		      "middle of a chunk range [%llu - %llu]",
		      (unsigned long long)old_chunk,
		      (unsigned long long)e->old_chunk,
		      (unsigned long long)
		      e->old_chunk + dm_consecutive_chunk_count(e));
		return -EINVAL;
	}

	dm_consecutive_chunk_count_dec(e);

	return 0;
}

827 828 829
static void flush_bios(struct bio *bio);

static int remove_single_exception_chunk(struct dm_snapshot *s)
M
Mikulas Patocka 已提交
830
{
831 832 833
	struct bio *b = NULL;
	int r;
	chunk_t old_chunk = s->first_merging_chunk + s->num_merging_chunks - 1;
M
Mikulas Patocka 已提交
834 835

	down_write(&s->lock);
836 837 838 839 840 841 842 843 844 845 846 847 848 849

	/*
	 * Process chunks (and associated exceptions) in reverse order
	 * so that dm_consecutive_chunk_count_dec() accounting works.
	 */
	do {
		r = __remove_single_exception_chunk(s, old_chunk);
		if (r)
			goto out;
	} while (old_chunk-- > s->first_merging_chunk);

	b = __release_queued_bios_after_merge(s);

out:
M
Mikulas Patocka 已提交
850
	up_write(&s->lock);
851 852
	if (b)
		flush_bios(b);
M
Mikulas Patocka 已提交
853 854 855 856

	return r;
}

857 858 859
static int origin_write_extent(struct dm_snapshot *merging_snap,
			       sector_t sector, unsigned chunk_size);

M
Mikulas Patocka 已提交
860 861 862
static void merge_callback(int read_err, unsigned long write_err,
			   void *context);

863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
static uint64_t read_pending_exceptions_done_count(void)
{
	uint64_t pending_exceptions_done;

	spin_lock(&_pending_exceptions_done_spinlock);
	pending_exceptions_done = _pending_exceptions_done_count;
	spin_unlock(&_pending_exceptions_done_spinlock);

	return pending_exceptions_done;
}

static void increment_pending_exceptions_done_count(void)
{
	spin_lock(&_pending_exceptions_done_spinlock);
	_pending_exceptions_done_count++;
	spin_unlock(&_pending_exceptions_done_spinlock);

	wake_up_all(&_pending_exceptions_done);
}

M
Mikulas Patocka 已提交
883 884
static void snapshot_merge_next_chunks(struct dm_snapshot *s)
{
885
	int i, linear_chunks;
M
Mikulas Patocka 已提交
886 887
	chunk_t old_chunk, new_chunk;
	struct dm_io_region src, dest;
888
	sector_t io_size;
889
	uint64_t previous_count;
M
Mikulas Patocka 已提交
890 891 892 893 894 895 896 897 898 899 900 901 902

	BUG_ON(!test_bit(RUNNING_MERGE, &s->state_bits));
	if (unlikely(test_bit(SHUTDOWN_MERGE, &s->state_bits)))
		goto shut;

	/*
	 * valid flag never changes during merge, so no lock required.
	 */
	if (!s->valid) {
		DMERR("Snapshot is invalid: can't merge");
		goto shut;
	}

903 904 905
	linear_chunks = s->store->type->prepare_merge(s->store, &old_chunk,
						      &new_chunk);
	if (linear_chunks <= 0) {
906
		if (linear_chunks < 0) {
M
Mikulas Patocka 已提交
907 908
			DMERR("Read error in exception store: "
			      "shutting down merge");
909 910 911 912
			down_write(&s->lock);
			s->merge_failed = 1;
			up_write(&s->lock);
		}
M
Mikulas Patocka 已提交
913 914 915
		goto shut;
	}

916 917 918 919 920 921 922 923 924
	/* Adjust old_chunk and new_chunk to reflect start of linear region */
	old_chunk = old_chunk + 1 - linear_chunks;
	new_chunk = new_chunk + 1 - linear_chunks;

	/*
	 * Use one (potentially large) I/O to copy all 'linear_chunks'
	 * from the exception store to the origin
	 */
	io_size = linear_chunks * s->store->chunk_size;
M
Mikulas Patocka 已提交
925 926 927

	dest.bdev = s->origin->bdev;
	dest.sector = chunk_to_sector(s->store, old_chunk);
928
	dest.count = min(io_size, get_dev_size(dest.bdev) - dest.sector);
M
Mikulas Patocka 已提交
929 930 931 932 933

	src.bdev = s->cow->bdev;
	src.sector = chunk_to_sector(s->store, new_chunk);
	src.count = dest.count;

934 935 936 937 938 939 940 941 942 943
	/*
	 * Reallocate any exceptions needed in other snapshots then
	 * wait for the pending exceptions to complete.
	 * Each time any pending exception (globally on the system)
	 * completes we are woken and repeat the process to find out
	 * if we can proceed.  While this may not seem a particularly
	 * efficient algorithm, it is not expected to have any
	 * significant impact on performance.
	 */
	previous_count = read_pending_exceptions_done_count();
944
	while (origin_write_extent(s, dest.sector, io_size)) {
945 946 947 948 949 950 951
		wait_event(_pending_exceptions_done,
			   (read_pending_exceptions_done_count() !=
			    previous_count));
		/* Retry after the wait, until all exceptions are done. */
		previous_count = read_pending_exceptions_done_count();
	}

952 953
	down_write(&s->lock);
	s->first_merging_chunk = old_chunk;
954
	s->num_merging_chunks = linear_chunks;
955 956
	up_write(&s->lock);

957 958 959
	/* Wait until writes to all 'linear_chunks' drain */
	for (i = 0; i < linear_chunks; i++)
		__check_for_conflicting_io(s, old_chunk + i);
960

M
Mikulas Patocka 已提交
961 962 963 964 965 966 967
	dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, merge_callback, s);
	return;

shut:
	merge_shutdown(s);
}

968 969
static void error_bios(struct bio *bio);

M
Mikulas Patocka 已提交
970 971 972
static void merge_callback(int read_err, unsigned long write_err, void *context)
{
	struct dm_snapshot *s = context;
973
	struct bio *b = NULL;
M
Mikulas Patocka 已提交
974 975 976 977 978 979 980 981 982

	if (read_err || write_err) {
		if (read_err)
			DMERR("Read error: shutting down merge.");
		else
			DMERR("Write error: shutting down merge.");
		goto shut;
	}

983 984
	if (s->store->type->commit_merge(s->store,
					 s->num_merging_chunks) < 0) {
M
Mikulas Patocka 已提交
985 986 987 988
		DMERR("Write error in exception store: shutting down merge");
		goto shut;
	}

989 990 991
	if (remove_single_exception_chunk(s) < 0)
		goto shut;

M
Mikulas Patocka 已提交
992 993 994 995 996
	snapshot_merge_next_chunks(s);

	return;

shut:
997
	down_write(&s->lock);
998
	s->merge_failed = 1;
999 1000 1001 1002
	b = __release_queued_bios_after_merge(s);
	up_write(&s->lock);
	error_bios(b);

M
Mikulas Patocka 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
	merge_shutdown(s);
}

static void start_merge(struct dm_snapshot *s)
{
	if (!test_and_set_bit(RUNNING_MERGE, &s->state_bits))
		snapshot_merge_next_chunks(s);
}

static int wait_schedule(void *ptr)
{
	schedule();

	return 0;
}

/*
 * Stop the merging process and wait until it finishes.
 */
static void stop_merge(struct dm_snapshot *s)
{
	set_bit(SHUTDOWN_MERGE, &s->state_bits);
	wait_on_bit(&s->state_bits, RUNNING_MERGE, wait_schedule,
		    TASK_UNINTERRUPTIBLE);
	clear_bit(SHUTDOWN_MERGE, &s->state_bits);
}

L
Linus Torvalds 已提交
1030 1031 1032 1033 1034 1035
/*
 * Construct a snapshot mapping: <origin_dev> <COW-dev> <p/n> <chunk-size>
 */
static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
{
	struct dm_snapshot *s;
1036
	int i;
L
Linus Torvalds 已提交
1037
	int r = -EINVAL;
1038
	char *origin_path, *cow_path;
1039 1040
	unsigned args_used, num_flush_requests = 1;
	fmode_t origin_mode = FMODE_READ;
L
Linus Torvalds 已提交
1041

1042
	if (argc != 4) {
1043
		ti->error = "requires exactly 4 arguments";
L
Linus Torvalds 已提交
1044
		r = -EINVAL;
1045
		goto bad;
L
Linus Torvalds 已提交
1046 1047
	}

1048 1049 1050 1051 1052
	if (dm_target_is_snapshot_merge(ti)) {
		num_flush_requests = 2;
		origin_mode = FMODE_WRITE;
	}

1053 1054
	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (!s) {
J
Jonathan Brassow 已提交
1055
		ti->error = "Cannot allocate private snapshot structure";
1056 1057 1058 1059
		r = -ENOMEM;
		goto bad;
	}

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
	origin_path = argv[0];
	argv++;
	argc--;

	r = dm_get_device(ti, origin_path, origin_mode, &s->origin);
	if (r) {
		ti->error = "Cannot get origin device";
		goto bad_origin;
	}

1070 1071 1072 1073
	cow_path = argv[0];
	argv++;
	argc--;

1074
	r = dm_get_device(ti, cow_path, dm_table_get_mode(ti->table), &s->cow);
1075 1076 1077 1078 1079 1080
	if (r) {
		ti->error = "Cannot get COW device";
		goto bad_cow;
	}

	r = dm_exception_store_create(ti, argc, argv, s, &args_used, &s->store);
1081 1082
	if (r) {
		ti->error = "Couldn't create exception store";
L
Linus Torvalds 已提交
1083
		r = -EINVAL;
1084
		goto bad_store;
L
Linus Torvalds 已提交
1085 1086
	}

1087 1088 1089
	argv += args_used;
	argc -= args_used;

1090
	s->ti = ti;
L
Linus Torvalds 已提交
1091
	s->valid = 1;
1092
	s->active = 0;
1093
	atomic_set(&s->pending_exceptions_count, 0);
L
Linus Torvalds 已提交
1094
	init_rwsem(&s->lock);
1095
	INIT_LIST_HEAD(&s->list);
1096
	spin_lock_init(&s->pe_lock);
M
Mikulas Patocka 已提交
1097
	s->state_bits = 0;
1098
	s->merge_failed = 0;
1099 1100 1101
	s->first_merging_chunk = 0;
	s->num_merging_chunks = 0;
	bio_list_init(&s->bios_queued_during_merge);
L
Linus Torvalds 已提交
1102 1103

	/* Allocate hash table for COW data */
1104
	if (init_hash_tables(s)) {
L
Linus Torvalds 已提交
1105 1106
		ti->error = "Unable to allocate hash table space";
		r = -ENOMEM;
1107
		goto bad_hash_tables;
L
Linus Torvalds 已提交
1108 1109
	}

1110 1111 1112
	s->kcopyd_client = dm_kcopyd_client_create();
	if (IS_ERR(s->kcopyd_client)) {
		r = PTR_ERR(s->kcopyd_client);
L
Linus Torvalds 已提交
1113
		ti->error = "Could not create kcopyd client";
1114
		goto bad_kcopyd;
L
Linus Torvalds 已提交
1115 1116
	}

1117 1118 1119
	s->pending_pool = mempool_create_slab_pool(MIN_IOS, pending_cache);
	if (!s->pending_pool) {
		ti->error = "Could not allocate mempool for pending exceptions";
1120
		goto bad_pending_pool;
1121 1122
	}

1123 1124 1125 1126 1127
	s->tracked_chunk_pool = mempool_create_slab_pool(MIN_IOS,
							 tracked_chunk_cache);
	if (!s->tracked_chunk_pool) {
		ti->error = "Could not allocate tracked_chunk mempool for "
			    "tracking reads";
1128
		goto bad_tracked_chunk_pool;
1129 1130 1131 1132 1133 1134 1135
	}

	for (i = 0; i < DM_TRACKED_CHUNK_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&s->tracked_chunk_hash[i]);

	spin_lock_init(&s->tracked_chunk_lock);

1136
	ti->private = s;
1137
	ti->num_flush_requests = num_flush_requests;
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160

	/* Add snapshot to the list of snapshots for this origin */
	/* Exceptions aren't triggered till snapshot_resume() is called */
	r = register_snapshot(s);
	if (r == -ENOMEM) {
		ti->error = "Snapshot origin struct allocation failed";
		goto bad_load_and_register;
	} else if (r < 0) {
		/* invalid handover, register_snapshot has set ti->error */
		goto bad_load_and_register;
	}

	/*
	 * Metadata must only be loaded into one table at once, so skip this
	 * if metadata will be handed over during resume.
	 * Chunk size will be set during the handover - set it to zero to
	 * ensure it's ignored.
	 */
	if (r > 0) {
		s->store->chunk_size = 0;
		return 0;
	}

1161 1162
	r = s->store->type->read_metadata(s->store, dm_add_exception,
					  (void *)s);
1163
	if (r < 0) {
1164
		ti->error = "Failed to read snapshot metadata";
1165
		goto bad_read_metadata;
1166 1167 1168
	} else if (r > 0) {
		s->valid = 0;
		DMWARN("Snapshot is marked invalid.");
1169
	}
1170

1171 1172
	if (!s->store->chunk_size) {
		ti->error = "Chunk size not set";
1173
		goto bad_read_metadata;
L
Linus Torvalds 已提交
1174
	}
1175
	ti->split_io = s->store->chunk_size;
L
Linus Torvalds 已提交
1176 1177 1178

	return 0;

1179 1180 1181
bad_read_metadata:
	unregister_snapshot(s);

1182
bad_load_and_register:
1183 1184
	mempool_destroy(s->tracked_chunk_pool);

1185
bad_tracked_chunk_pool:
1186 1187
	mempool_destroy(s->pending_pool);

1188
bad_pending_pool:
H
Heinz Mauelshagen 已提交
1189
	dm_kcopyd_client_destroy(s->kcopyd_client);
L
Linus Torvalds 已提交
1190

1191
bad_kcopyd:
1192 1193
	dm_exception_table_exit(&s->pending, pending_cache);
	dm_exception_table_exit(&s->complete, exception_cache);
L
Linus Torvalds 已提交
1194

1195
bad_hash_tables:
1196
	dm_exception_store_destroy(s->store);
L
Linus Torvalds 已提交
1197

1198 1199
bad_store:
	dm_put_device(ti, s->cow);
1200

1201
bad_cow:
1202 1203 1204
	dm_put_device(ti, s->origin);

bad_origin:
1205 1206 1207
	kfree(s);

bad:
L
Linus Torvalds 已提交
1208 1209 1210
	return r;
}

1211 1212
static void __free_exceptions(struct dm_snapshot *s)
{
H
Heinz Mauelshagen 已提交
1213
	dm_kcopyd_client_destroy(s->kcopyd_client);
1214 1215
	s->kcopyd_client = NULL;

1216 1217
	dm_exception_table_exit(&s->pending, pending_cache);
	dm_exception_table_exit(&s->complete, exception_cache);
1218 1219
}

1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
static void __handover_exceptions(struct dm_snapshot *snap_src,
				  struct dm_snapshot *snap_dest)
{
	union {
		struct dm_exception_table table_swap;
		struct dm_exception_store *store_swap;
	} u;

	/*
	 * Swap all snapshot context information between the two instances.
	 */
	u.table_swap = snap_dest->complete;
	snap_dest->complete = snap_src->complete;
	snap_src->complete = u.table_swap;

	u.store_swap = snap_dest->store;
	snap_dest->store = snap_src->store;
	snap_src->store = u.store_swap;

	snap_dest->store->snap = snap_dest;
	snap_src->store->snap = snap_src;

	snap_dest->ti->split_io = snap_dest->store->chunk_size;
	snap_dest->valid = snap_src->valid;

	/*
	 * Set source invalid to ensure it receives no further I/O.
	 */
	snap_src->valid = 0;
}

L
Linus Torvalds 已提交
1251 1252
static void snapshot_dtr(struct dm_target *ti)
{
1253 1254 1255
#ifdef CONFIG_DM_DEBUG
	int i;
#endif
A
Alasdair G Kergon 已提交
1256
	struct dm_snapshot *s = ti->private;
1257
	struct dm_snapshot *snap_src = NULL, *snap_dest = NULL;
L
Linus Torvalds 已提交
1258

1259 1260
	down_read(&_origins_lock);
	/* Check whether exception handover must be cancelled */
1261
	(void) __find_snapshots_sharing_cow(s, &snap_src, &snap_dest, NULL);
1262 1263 1264 1265 1266 1267 1268 1269
	if (snap_src && snap_dest && (s == snap_src)) {
		down_write(&snap_dest->lock);
		snap_dest->valid = 0;
		up_write(&snap_dest->lock);
		DMERR("Cancelling snapshot handover.");
	}
	up_read(&_origins_lock);

M
Mikulas Patocka 已提交
1270 1271 1272
	if (dm_target_is_snapshot_merge(ti))
		stop_merge(s);

1273 1274
	/* Prevent further origin writes from using this snapshot. */
	/* After this returns there can be no new kcopyd jobs. */
L
Linus Torvalds 已提交
1275 1276
	unregister_snapshot(s);

1277
	while (atomic_read(&s->pending_exceptions_count))
1278
		msleep(1);
1279 1280 1281 1282 1283 1284
	/*
	 * Ensure instructions in mempool_destroy aren't reordered
	 * before atomic_read.
	 */
	smp_mb();

1285 1286 1287 1288 1289 1290 1291
#ifdef CONFIG_DM_DEBUG
	for (i = 0; i < DM_TRACKED_CHUNK_HASH_SIZE; i++)
		BUG_ON(!hlist_empty(&s->tracked_chunk_hash[i]));
#endif

	mempool_destroy(s->tracked_chunk_pool);

1292
	__free_exceptions(s);
L
Linus Torvalds 已提交
1293

1294 1295
	mempool_destroy(s->pending_pool);

1296
	dm_exception_store_destroy(s->store);
1297

1298 1299
	dm_put_device(ti, s->cow);

1300 1301
	dm_put_device(ti, s->origin);

L
Linus Torvalds 已提交
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
	kfree(s);
}

/*
 * Flush a list of buffers.
 */
static void flush_bios(struct bio *bio)
{
	struct bio *n;

	while (bio) {
		n = bio->bi_next;
		bio->bi_next = NULL;
		generic_make_request(bio);
		bio = n;
	}
}

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
static int do_origin(struct dm_dev *origin, struct bio *bio);

/*
 * Flush a list of buffers.
 */
static void retry_origin_bios(struct dm_snapshot *s, struct bio *bio)
{
	struct bio *n;
	int r;

	while (bio) {
		n = bio->bi_next;
		bio->bi_next = NULL;
		r = do_origin(s->origin, bio);
		if (r == DM_MAPIO_REMAPPED)
			generic_make_request(bio);
		bio = n;
	}
}

L
Linus Torvalds 已提交
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
/*
 * Error a list of buffers.
 */
static void error_bios(struct bio *bio)
{
	struct bio *n;

	while (bio) {
		n = bio->bi_next;
		bio->bi_next = NULL;
1350
		bio_io_error(bio);
L
Linus Torvalds 已提交
1351 1352 1353 1354
		bio = n;
	}
}

1355
static void __invalidate_snapshot(struct dm_snapshot *s, int err)
1356 1357 1358 1359 1360 1361 1362 1363 1364
{
	if (!s->valid)
		return;

	if (err == -EIO)
		DMERR("Invalidating snapshot: Error reading/writing.");
	else if (err == -ENOMEM)
		DMERR("Invalidating snapshot: Unable to allocate exception.");

1365 1366
	if (s->store->type->drop_snapshot)
		s->store->type->drop_snapshot(s->store);
1367 1368 1369

	s->valid = 0;

1370
	dm_table_event(s->ti->table);
1371 1372
}

A
Alasdair G Kergon 已提交
1373
static void pending_complete(struct dm_snap_pending_exception *pe, int success)
L
Linus Torvalds 已提交
1374
{
1375
	struct dm_exception *e;
L
Linus Torvalds 已提交
1376
	struct dm_snapshot *s = pe->snap;
1377 1378
	struct bio *origin_bios = NULL;
	struct bio *snapshot_bios = NULL;
1379
	struct bio *full_bio = NULL;
1380
	int error = 0;
L
Linus Torvalds 已提交
1381

1382 1383
	if (!success) {
		/* Read/write error - snapshot is unusable */
L
Linus Torvalds 已提交
1384
		down_write(&s->lock);
1385
		__invalidate_snapshot(s, -EIO);
1386
		error = 1;
1387 1388 1389
		goto out;
	}

1390
	e = alloc_completed_exception();
1391
	if (!e) {
L
Linus Torvalds 已提交
1392
		down_write(&s->lock);
1393
		__invalidate_snapshot(s, -ENOMEM);
1394
		error = 1;
1395 1396 1397
		goto out;
	}
	*e = pe->e;
L
Linus Torvalds 已提交
1398

1399 1400
	down_write(&s->lock);
	if (!s->valid) {
1401
		free_completed_exception(e);
1402
		error = 1;
1403
		goto out;
L
Linus Torvalds 已提交
1404 1405
	}

1406 1407
	/* Check for conflicting reads */
	__check_for_conflicting_io(s, pe->e.old_chunk);
1408

1409 1410 1411 1412
	/*
	 * Add a proper exception, and remove the
	 * in-flight exception from the list.
	 */
1413
	dm_insert_exception(&s->complete, e);
1414

J
Jonathan Brassow 已提交
1415
out:
1416
	dm_remove_exception(&pe->e);
1417
	snapshot_bios = bio_list_get(&pe->snapshot_bios);
1418
	origin_bios = bio_list_get(&pe->origin_bios);
1419 1420 1421 1422 1423
	full_bio = pe->full_bio;
	if (full_bio) {
		full_bio->bi_end_io = pe->full_bio_end_io;
		full_bio->bi_private = pe->full_bio_private;
	}
1424
	free_pending_exception(pe);
L
Linus Torvalds 已提交
1425

1426 1427
	increment_pending_exceptions_done_count();

1428 1429 1430
	up_write(&s->lock);

	/* Submit any pending write bios */
1431 1432 1433
	if (error) {
		if (full_bio)
			bio_io_error(full_bio);
1434
		error_bios(snapshot_bios);
1435 1436 1437
	} else {
		if (full_bio)
			bio_endio(full_bio, 0);
1438
		flush_bios(snapshot_bios);
1439
	}
1440

1441
	retry_origin_bios(s, origin_bios);
L
Linus Torvalds 已提交
1442 1443 1444 1445
}

static void commit_callback(void *context, int success)
{
A
Alasdair G Kergon 已提交
1446 1447
	struct dm_snap_pending_exception *pe = context;

L
Linus Torvalds 已提交
1448 1449 1450 1451 1452 1453 1454
	pending_complete(pe, success);
}

/*
 * Called when the copy I/O has finished.  kcopyd actually runs
 * this code so don't block.
 */
1455
static void copy_callback(int read_err, unsigned long write_err, void *context)
L
Linus Torvalds 已提交
1456
{
A
Alasdair G Kergon 已提交
1457
	struct dm_snap_pending_exception *pe = context;
L
Linus Torvalds 已提交
1458 1459 1460 1461 1462 1463 1464
	struct dm_snapshot *s = pe->snap;

	if (read_err || write_err)
		pending_complete(pe, 0);

	else
		/* Update the metadata if we are persistent */
1465 1466
		s->store->type->commit_exception(s->store, &pe->e,
						 commit_callback, pe);
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471
}

/*
 * Dispatches the copy operation to kcopyd.
 */
A
Alasdair G Kergon 已提交
1472
static void start_copy(struct dm_snap_pending_exception *pe)
L
Linus Torvalds 已提交
1473 1474
{
	struct dm_snapshot *s = pe->snap;
H
Heinz Mauelshagen 已提交
1475
	struct dm_io_region src, dest;
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480 1481
	struct block_device *bdev = s->origin->bdev;
	sector_t dev_size;

	dev_size = get_dev_size(bdev);

	src.bdev = bdev;
1482
	src.sector = chunk_to_sector(s->store, pe->e.old_chunk);
1483
	src.count = min((sector_t)s->store->chunk_size, dev_size - src.sector);
L
Linus Torvalds 已提交
1484

1485
	dest.bdev = s->cow->bdev;
1486
	dest.sector = chunk_to_sector(s->store, pe->e.new_chunk);
L
Linus Torvalds 已提交
1487 1488 1489
	dest.count = src.count;

	/* Hand over to kcopyd */
J
Jonathan Brassow 已提交
1490
	dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, copy_callback, pe);
L
Linus Torvalds 已提交
1491 1492
}

1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
static void full_bio_end_io(struct bio *bio, int error)
{
	void *callback_data = bio->bi_private;

	dm_kcopyd_do_callback(callback_data, 0, error ? 1 : 0);
}

static void start_full_bio(struct dm_snap_pending_exception *pe,
			   struct bio *bio)
{
	struct dm_snapshot *s = pe->snap;
	void *callback_data;

	pe->full_bio = bio;
	pe->full_bio_end_io = bio->bi_end_io;
	pe->full_bio_private = bio->bi_private;

	callback_data = dm_kcopyd_prepare_callback(s->kcopyd_client,
						   copy_callback, pe);

	bio->bi_end_io = full_bio_end_io;
	bio->bi_private = callback_data;

	generic_make_request(bio);
}

1519 1520 1521
static struct dm_snap_pending_exception *
__lookup_pending_exception(struct dm_snapshot *s, chunk_t chunk)
{
1522
	struct dm_exception *e = dm_lookup_exception(&s->pending, chunk);
1523 1524 1525 1526 1527 1528 1529

	if (!e)
		return NULL;

	return container_of(e, struct dm_snap_pending_exception, e);
}

L
Linus Torvalds 已提交
1530 1531 1532 1533 1534 1535 1536 1537
/*
 * Looks to see if this snapshot already has a pending exception
 * for this chunk, otherwise it allocates a new one and inserts
 * it into the pending table.
 *
 * NOTE: a write lock must be held on snap->lock before calling
 * this.
 */
A
Alasdair G Kergon 已提交
1538
static struct dm_snap_pending_exception *
1539 1540
__find_pending_exception(struct dm_snapshot *s,
			 struct dm_snap_pending_exception *pe, chunk_t chunk)
L
Linus Torvalds 已提交
1541
{
1542
	struct dm_snap_pending_exception *pe2;
L
Linus Torvalds 已提交
1543

1544 1545
	pe2 = __lookup_pending_exception(s, chunk);
	if (pe2) {
1546
		free_pending_exception(pe);
1547
		return pe2;
L
Linus Torvalds 已提交
1548 1549
	}

1550 1551 1552 1553
	pe->e.old_chunk = chunk;
	bio_list_init(&pe->origin_bios);
	bio_list_init(&pe->snapshot_bios);
	pe->started = 0;
1554
	pe->full_bio = NULL;
1555

1556
	if (s->store->type->prepare_exception(s->store, &pe->e)) {
1557 1558 1559 1560
		free_pending_exception(pe);
		return NULL;
	}

1561
	dm_insert_exception(&s->pending, &pe->e);
1562

L
Linus Torvalds 已提交
1563 1564 1565
	return pe;
}

1566
static void remap_exception(struct dm_snapshot *s, struct dm_exception *e,
1567
			    struct bio *bio, chunk_t chunk)
L
Linus Torvalds 已提交
1568
{
1569
	bio->bi_bdev = s->cow->bdev;
1570 1571 1572 1573 1574
	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);
L
Linus Torvalds 已提交
1575 1576 1577 1578 1579
}

static int snapshot_map(struct dm_target *ti, struct bio *bio,
			union map_info *map_context)
{
1580
	struct dm_exception *e;
A
Alasdair G Kergon 已提交
1581
	struct dm_snapshot *s = ti->private;
1582
	int r = DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
1583
	chunk_t chunk;
A
Alasdair G Kergon 已提交
1584
	struct dm_snap_pending_exception *pe = NULL;
L
Linus Torvalds 已提交
1585

1586
	if (bio->bi_rw & REQ_FLUSH) {
1587
		bio->bi_bdev = s->cow->bdev;
M
Mikulas Patocka 已提交
1588 1589 1590
		return DM_MAPIO_REMAPPED;
	}

1591
	chunk = sector_to_chunk(s->store, bio->bi_sector);
L
Linus Torvalds 已提交
1592 1593

	/* Full snapshots are not usable */
1594
	/* To get here the table must be live so s->active is always set. */
L
Linus Torvalds 已提交
1595
	if (!s->valid)
1596
		return -EIO;
L
Linus Torvalds 已提交
1597

1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
	/* FIXME: should only take write lock if we need
	 * to copy an exception */
	down_write(&s->lock);

	if (!s->valid) {
		r = -EIO;
		goto out_unlock;
	}

	/* If the block is already remapped - use that, else remap it */
1608
	e = dm_lookup_exception(&s->complete, chunk);
1609
	if (e) {
1610
		remap_exception(s, e, bio, chunk);
1611 1612 1613
		goto out_unlock;
	}

L
Linus Torvalds 已提交
1614 1615 1616 1617 1618 1619
	/*
	 * Write to snapshot - higher level takes care of RW/RO
	 * flags so we should only get this if we are
	 * writeable.
	 */
	if (bio_rw(bio) == WRITE) {
1620
		pe = __lookup_pending_exception(s, chunk);
1621
		if (!pe) {
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
			up_write(&s->lock);
			pe = alloc_pending_exception(s);
			down_write(&s->lock);

			if (!s->valid) {
				free_pending_exception(pe);
				r = -EIO;
				goto out_unlock;
			}

1632
			e = dm_lookup_exception(&s->complete, chunk);
1633 1634 1635 1636 1637 1638
			if (e) {
				free_pending_exception(pe);
				remap_exception(s, e, bio, chunk);
				goto out_unlock;
			}

1639
			pe = __find_pending_exception(s, pe, chunk);
1640 1641 1642 1643 1644
			if (!pe) {
				__invalidate_snapshot(s, -ENOMEM);
				r = -EIO;
				goto out_unlock;
			}
L
Linus Torvalds 已提交
1645 1646
		}

1647
		remap_exception(s, &pe->e, bio, chunk);
1648

1649
		r = DM_MAPIO_SUBMITTED;
1650

1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
		if (!pe->started &&
		    bio->bi_size == (s->store->chunk_size << SECTOR_SHIFT)) {
			pe->started = 1;
			up_write(&s->lock);
			start_full_bio(pe, bio);
			goto out;
		}

		bio_list_add(&pe->snapshot_bios, bio);

1661 1662 1663
		if (!pe->started) {
			/* this is protected by snap->lock */
			pe->started = 1;
1664
			up_write(&s->lock);
1665
			start_copy(pe);
1666 1667
			goto out;
		}
1668
	} else {
1669
		bio->bi_bdev = s->origin->bdev;
1670 1671
		map_context->ptr = track_chunk(s, chunk);
	}
L
Linus Torvalds 已提交
1672

J
Jonathan Brassow 已提交
1673
out_unlock:
1674
	up_write(&s->lock);
J
Jonathan Brassow 已提交
1675
out:
L
Linus Torvalds 已提交
1676 1677 1678
	return r;
}

1679 1680 1681 1682 1683 1684 1685 1686 1687
/*
 * A snapshot-merge target behaves like a combination of a snapshot
 * target and a snapshot-origin target.  It only generates new
 * exceptions in other snapshots and not in the one that is being
 * merged.
 *
 * For each chunk, if there is an existing exception, it is used to
 * redirect I/O to the cow device.  Otherwise I/O is sent to the origin,
 * which in turn might generate exceptions in other snapshots.
1688 1689
 * If merging is currently taking place on the chunk in question, the
 * I/O is deferred by adding it to s->bios_queued_during_merge.
1690 1691 1692 1693 1694 1695 1696 1697 1698
 */
static int snapshot_merge_map(struct dm_target *ti, struct bio *bio,
			      union map_info *map_context)
{
	struct dm_exception *e;
	struct dm_snapshot *s = ti->private;
	int r = DM_MAPIO_REMAPPED;
	chunk_t chunk;

1699
	if (bio->bi_rw & REQ_FLUSH) {
1700
		if (!map_context->target_request_nr)
1701 1702 1703 1704 1705 1706 1707
			bio->bi_bdev = s->origin->bdev;
		else
			bio->bi_bdev = s->cow->bdev;
		map_context->ptr = NULL;
		return DM_MAPIO_REMAPPED;
	}

1708 1709
	chunk = sector_to_chunk(s->store, bio->bi_sector);

1710
	down_write(&s->lock);
1711

1712 1713 1714
	/* Full merging snapshots are redirected to the origin */
	if (!s->valid)
		goto redirect_to_origin;
1715 1716 1717 1718

	/* If the block is already remapped - use that */
	e = dm_lookup_exception(&s->complete, chunk);
	if (e) {
1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
		/* Queue writes overlapping with chunks being merged */
		if (bio_rw(bio) == WRITE &&
		    chunk >= s->first_merging_chunk &&
		    chunk < (s->first_merging_chunk +
			     s->num_merging_chunks)) {
			bio->bi_bdev = s->origin->bdev;
			bio_list_add(&s->bios_queued_during_merge, bio);
			r = DM_MAPIO_SUBMITTED;
			goto out_unlock;
		}
1729

1730
		remap_exception(s, e, bio, chunk);
1731 1732 1733

		if (bio_rw(bio) == WRITE)
			map_context->ptr = track_chunk(s, chunk);
1734 1735 1736
		goto out_unlock;
	}

1737
redirect_to_origin:
1738 1739 1740
	bio->bi_bdev = s->origin->bdev;

	if (bio_rw(bio) == WRITE) {
1741
		up_write(&s->lock);
1742 1743 1744 1745
		return do_origin(s->origin, bio);
	}

out_unlock:
1746
	up_write(&s->lock);
1747 1748 1749 1750

	return r;
}

1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
static int snapshot_end_io(struct dm_target *ti, struct bio *bio,
			   int error, union map_info *map_context)
{
	struct dm_snapshot *s = ti->private;
	struct dm_snap_tracked_chunk *c = map_context->ptr;

	if (c)
		stop_tracking_chunk(s, c);

	return 0;
}

M
Mikulas Patocka 已提交
1763 1764 1765 1766 1767 1768 1769
static void snapshot_merge_presuspend(struct dm_target *ti)
{
	struct dm_snapshot *s = ti->private;

	stop_merge(s);
}

1770 1771 1772 1773 1774 1775 1776
static int snapshot_preresume(struct dm_target *ti)
{
	int r = 0;
	struct dm_snapshot *s = ti->private;
	struct dm_snapshot *snap_src = NULL, *snap_dest = NULL;

	down_read(&_origins_lock);
1777
	(void) __find_snapshots_sharing_cow(s, &snap_src, &snap_dest, NULL);
1778 1779 1780 1781 1782 1783
	if (snap_src && snap_dest) {
		down_read(&snap_src->lock);
		if (s == snap_src) {
			DMERR("Unable to resume snapshot source until "
			      "handover completes.");
			r = -EINVAL;
1784
		} else if (!dm_suspended(snap_src->ti)) {
1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
			DMERR("Unable to perform snapshot handover until "
			      "source is suspended.");
			r = -EINVAL;
		}
		up_read(&snap_src->lock);
	}
	up_read(&_origins_lock);

	return r;
}

L
Linus Torvalds 已提交
1796 1797
static void snapshot_resume(struct dm_target *ti)
{
A
Alasdair G Kergon 已提交
1798
	struct dm_snapshot *s = ti->private;
1799 1800 1801
	struct dm_snapshot *snap_src = NULL, *snap_dest = NULL;

	down_read(&_origins_lock);
1802
	(void) __find_snapshots_sharing_cow(s, &snap_src, &snap_dest, NULL);
1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
	if (snap_src && snap_dest) {
		down_write(&snap_src->lock);
		down_write_nested(&snap_dest->lock, SINGLE_DEPTH_NESTING);
		__handover_exceptions(snap_src, snap_dest);
		up_write(&snap_dest->lock);
		up_write(&snap_src->lock);
	}
	up_read(&_origins_lock);

	/* Now we have correct chunk size, reregister */
	reregister_snapshot(s);
L
Linus Torvalds 已提交
1814

1815 1816 1817
	down_write(&s->lock);
	s->active = 1;
	up_write(&s->lock);
L
Linus Torvalds 已提交
1818 1819
}

M
Mikulas Patocka 已提交
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
static sector_t get_origin_minimum_chunksize(struct block_device *bdev)
{
	sector_t min_chunksize;

	down_read(&_origins_lock);
	min_chunksize = __minimum_chunk_size(__lookup_origin(bdev));
	up_read(&_origins_lock);

	return min_chunksize;
}

static void snapshot_merge_resume(struct dm_target *ti)
{
	struct dm_snapshot *s = ti->private;

	/*
	 * Handover exceptions from existing snapshot.
	 */
	snapshot_resume(ti);

	/*
	 * snapshot-merge acts as an origin, so set ti->split_io
	 */
	ti->split_io = get_origin_minimum_chunksize(s->origin->bdev);

	start_merge(s);
}

L
Linus Torvalds 已提交
1848 1849 1850
static int snapshot_status(struct dm_target *ti, status_type_t type,
			   char *result, unsigned int maxlen)
{
1851
	unsigned sz = 0;
A
Alasdair G Kergon 已提交
1852
	struct dm_snapshot *snap = ti->private;
L
Linus Torvalds 已提交
1853 1854 1855

	switch (type) {
	case STATUSTYPE_INFO:
1856 1857 1858

		down_write(&snap->lock);

L
Linus Torvalds 已提交
1859
		if (!snap->valid)
1860
			DMEMIT("Invalid");
1861 1862
		else if (snap->merge_failed)
			DMEMIT("Merge failed");
L
Linus Torvalds 已提交
1863
		else {
1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
			if (snap->store->type->usage) {
				sector_t total_sectors, sectors_allocated,
					 metadata_sectors;
				snap->store->type->usage(snap->store,
							 &total_sectors,
							 &sectors_allocated,
							 &metadata_sectors);
				DMEMIT("%llu/%llu %llu",
				       (unsigned long long)sectors_allocated,
				       (unsigned long long)total_sectors,
				       (unsigned long long)metadata_sectors);
L
Linus Torvalds 已提交
1875 1876
			}
			else
1877
				DMEMIT("Unknown");
L
Linus Torvalds 已提交
1878
		}
1879 1880 1881

		up_write(&snap->lock);

L
Linus Torvalds 已提交
1882 1883 1884 1885 1886 1887 1888 1889
		break;

	case STATUSTYPE_TABLE:
		/*
		 * kdevname returns a static pointer so we need
		 * to make private copies if the output is to
		 * make sense.
		 */
1890
		DMEMIT("%s %s", snap->origin->name, snap->cow->name);
1891 1892
		snap->store->type->status(snap->store, type, result + sz,
					  maxlen - sz);
L
Linus Torvalds 已提交
1893 1894 1895 1896 1897 1898
		break;
	}

	return 0;
}

1899 1900 1901 1902
static int snapshot_iterate_devices(struct dm_target *ti,
				    iterate_devices_callout_fn fn, void *data)
{
	struct dm_snapshot *snap = ti->private;
1903 1904 1905
	int r;

	r = fn(ti, snap->origin, 0, ti->len, data);
1906

1907 1908 1909 1910
	if (!r)
		r = fn(ti, snap->cow, 0, get_dev_size(snap->cow->bdev), data);

	return r;
1911 1912 1913
}


L
Linus Torvalds 已提交
1914 1915 1916
/*-----------------------------------------------------------------
 * Origin methods
 *---------------------------------------------------------------*/
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929

/*
 * If no exceptions need creating, DM_MAPIO_REMAPPED is returned and any
 * supplied bio was ignored.  The caller may submit it immediately.
 * (No remapping actually occurs as the origin is always a direct linear
 * map.)
 *
 * If further exceptions are required, DM_MAPIO_SUBMITTED is returned
 * and any supplied bio is added to a list to be submitted once all
 * the necessary exceptions exist.
 */
static int __origin_write(struct list_head *snapshots, sector_t sector,
			  struct bio *bio)
L
Linus Torvalds 已提交
1930
{
1931
	int r = DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
1932
	struct dm_snapshot *snap;
1933
	struct dm_exception *e;
1934 1935 1936
	struct dm_snap_pending_exception *pe;
	struct dm_snap_pending_exception *pe_to_start_now = NULL;
	struct dm_snap_pending_exception *pe_to_start_last = NULL;
L
Linus Torvalds 已提交
1937 1938 1939 1940
	chunk_t chunk;

	/* Do all the snapshots on this origin */
	list_for_each_entry (snap, snapshots, list) {
1941 1942 1943 1944 1945 1946 1947
		/*
		 * Don't make new exceptions in a merging snapshot
		 * because it has effectively been deleted
		 */
		if (dm_target_is_snapshot_merge(snap->ti))
			continue;

1948 1949
		down_write(&snap->lock);

1950 1951
		/* Only deal with valid and active snapshots */
		if (!snap->valid || !snap->active)
1952
			goto next_snapshot;
L
Linus Torvalds 已提交
1953

1954
		/* Nothing to do if writing beyond end of snapshot */
1955
		if (sector >= dm_table_get_size(snap->ti->table))
1956
			goto next_snapshot;
L
Linus Torvalds 已提交
1957 1958 1959 1960 1961

		/*
		 * Remember, different snapshots can have
		 * different chunk sizes.
		 */
1962
		chunk = sector_to_chunk(snap->store, sector);
L
Linus Torvalds 已提交
1963 1964 1965 1966 1967 1968

		/*
		 * Check exception table to see if block
		 * is already remapped in this snapshot
		 * and trigger an exception if not.
		 */
1969
		e = dm_lookup_exception(&snap->complete, chunk);
1970 1971 1972
		if (e)
			goto next_snapshot;

1973
		pe = __lookup_pending_exception(snap, chunk);
1974
		if (!pe) {
1975 1976 1977 1978 1979 1980 1981 1982 1983
			up_write(&snap->lock);
			pe = alloc_pending_exception(snap);
			down_write(&snap->lock);

			if (!snap->valid) {
				free_pending_exception(pe);
				goto next_snapshot;
			}

1984
			e = dm_lookup_exception(&snap->complete, chunk);
1985 1986 1987 1988 1989
			if (e) {
				free_pending_exception(pe);
				goto next_snapshot;
			}

1990
			pe = __find_pending_exception(snap, pe, chunk);
1991 1992 1993 1994
			if (!pe) {
				__invalidate_snapshot(snap, -ENOMEM);
				goto next_snapshot;
			}
1995 1996
		}

1997
		r = DM_MAPIO_SUBMITTED;
1998

1999 2000 2001 2002 2003 2004 2005 2006
		/*
		 * If an origin bio was supplied, queue it to wait for the
		 * completion of this exception, and start this one last,
		 * at the end of the function.
		 */
		if (bio) {
			bio_list_add(&pe->origin_bios, bio);
			bio = NULL;
2007

2008 2009 2010 2011
			if (!pe->started) {
				pe->started = 1;
				pe_to_start_last = pe;
			}
2012 2013 2014 2015
		}

		if (!pe->started) {
			pe->started = 1;
2016
			pe_to_start_now = pe;
L
Linus Torvalds 已提交
2017 2018
		}

J
Jonathan Brassow 已提交
2019
next_snapshot:
L
Linus Torvalds 已提交
2020 2021
		up_write(&snap->lock);

2022 2023 2024 2025
		if (pe_to_start_now) {
			start_copy(pe_to_start_now);
			pe_to_start_now = NULL;
		}
2026 2027
	}

L
Linus Torvalds 已提交
2028
	/*
2029 2030
	 * Submit the exception against which the bio is queued last,
	 * to give the other exceptions a head start.
L
Linus Torvalds 已提交
2031
	 */
2032 2033
	if (pe_to_start_last)
		start_copy(pe_to_start_last);
L
Linus Torvalds 已提交
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043

	return r;
}

/*
 * Called on a write from the origin driver.
 */
static int do_origin(struct dm_dev *origin, struct bio *bio)
{
	struct origin *o;
2044
	int r = DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
2045 2046 2047 2048

	down_read(&_origins_lock);
	o = __lookup_origin(origin->bdev);
	if (o)
2049
		r = __origin_write(&o->snapshots, bio->bi_sector, bio);
L
Linus Torvalds 已提交
2050 2051 2052 2053 2054
	up_read(&_origins_lock);

	return r;
}

2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
/*
 * Trigger exceptions in all non-merging snapshots.
 *
 * The chunk size of the merging snapshot may be larger than the chunk
 * size of some other snapshot so we may need to reallocate multiple
 * chunks in other snapshots.
 *
 * We scan all the overlapping exceptions in the other snapshots.
 * Returns 1 if anything was reallocated and must be waited for,
 * otherwise returns 0.
 *
 * size must be a multiple of merging_snap's chunk_size.
 */
static int origin_write_extent(struct dm_snapshot *merging_snap,
			       sector_t sector, unsigned size)
{
	int must_wait = 0;
	sector_t n;
	struct origin *o;

	/*
	 * The origin's __minimum_chunk_size() got stored in split_io
	 * by snapshot_merge_resume().
	 */
	down_read(&_origins_lock);
	o = __lookup_origin(merging_snap->origin->bdev);
	for (n = 0; n < size; n += merging_snap->ti->split_io)
		if (__origin_write(&o->snapshots, sector + n, NULL) ==
		    DM_MAPIO_SUBMITTED)
			must_wait = 1;
	up_read(&_origins_lock);

	return must_wait;
}

L
Linus Torvalds 已提交
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
/*
 * Origin: maps a linear range of a device, with hooks for snapshotting.
 */

/*
 * Construct an origin mapping: <dev_path>
 * The context for an origin is merely a 'struct dm_dev *'
 * pointing to the real device.
 */
static int origin_ctr(struct dm_target *ti, unsigned int argc, char **argv)
{
	int r;
	struct dm_dev *dev;

	if (argc != 1) {
2105
		ti->error = "origin: incorrect number of arguments";
L
Linus Torvalds 已提交
2106 2107 2108
		return -EINVAL;
	}

2109
	r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &dev);
L
Linus Torvalds 已提交
2110 2111 2112 2113 2114 2115
	if (r) {
		ti->error = "Cannot get target device";
		return r;
	}

	ti->private = dev;
M
Mikulas Patocka 已提交
2116 2117
	ti->num_flush_requests = 1;

L
Linus Torvalds 已提交
2118 2119 2120 2121 2122
	return 0;
}

static void origin_dtr(struct dm_target *ti)
{
A
Alasdair G Kergon 已提交
2123
	struct dm_dev *dev = ti->private;
L
Linus Torvalds 已提交
2124 2125 2126 2127 2128 2129
	dm_put_device(ti, dev);
}

static int origin_map(struct dm_target *ti, struct bio *bio,
		      union map_info *map_context)
{
A
Alasdair G Kergon 已提交
2130
	struct dm_dev *dev = ti->private;
L
Linus Torvalds 已提交
2131 2132
	bio->bi_bdev = dev->bdev;

2133
	if (bio->bi_rw & REQ_FLUSH)
M
Mikulas Patocka 已提交
2134 2135
		return DM_MAPIO_REMAPPED;

L
Linus Torvalds 已提交
2136
	/* Only tell snapshots if this is a write */
2137
	return (bio_rw(bio) == WRITE) ? do_origin(dev, bio) : DM_MAPIO_REMAPPED;
L
Linus Torvalds 已提交
2138 2139 2140 2141 2142 2143 2144 2145
}

/*
 * Set the target "split_io" field to the minimum of all the snapshots'
 * chunk sizes.
 */
static void origin_resume(struct dm_target *ti)
{
A
Alasdair G Kergon 已提交
2146
	struct dm_dev *dev = ti->private;
L
Linus Torvalds 已提交
2147

M
Mikulas Patocka 已提交
2148
	ti->split_io = get_origin_minimum_chunksize(dev->bdev);
L
Linus Torvalds 已提交
2149 2150 2151 2152 2153
}

static int origin_status(struct dm_target *ti, status_type_t type, char *result,
			 unsigned int maxlen)
{
A
Alasdair G Kergon 已提交
2154
	struct dm_dev *dev = ti->private;
L
Linus Torvalds 已提交
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168

	switch (type) {
	case STATUSTYPE_INFO:
		result[0] = '\0';
		break;

	case STATUSTYPE_TABLE:
		snprintf(result, maxlen, "%s", dev->name);
		break;
	}

	return 0;
}

M
Mikulas Patocka 已提交
2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
static int origin_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
			struct bio_vec *biovec, int max_size)
{
	struct dm_dev *dev = ti->private;
	struct request_queue *q = bdev_get_queue(dev->bdev);

	if (!q->merge_bvec_fn)
		return max_size;

	bvm->bi_bdev = dev->bdev;

	return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
}

2183 2184 2185 2186 2187 2188 2189 2190
static int origin_iterate_devices(struct dm_target *ti,
				  iterate_devices_callout_fn fn, void *data)
{
	struct dm_dev *dev = ti->private;

	return fn(ti, dev, 0, ti->len, data);
}

L
Linus Torvalds 已提交
2191 2192
static struct target_type origin_target = {
	.name    = "snapshot-origin",
2193
	.version = {1, 7, 1},
L
Linus Torvalds 已提交
2194 2195 2196 2197 2198 2199
	.module  = THIS_MODULE,
	.ctr     = origin_ctr,
	.dtr     = origin_dtr,
	.map     = origin_map,
	.resume  = origin_resume,
	.status  = origin_status,
M
Mikulas Patocka 已提交
2200
	.merge	 = origin_merge,
2201
	.iterate_devices = origin_iterate_devices,
L
Linus Torvalds 已提交
2202 2203 2204 2205
};

static struct target_type snapshot_target = {
	.name    = "snapshot",
2206
	.version = {1, 10, 0},
L
Linus Torvalds 已提交
2207 2208 2209 2210
	.module  = THIS_MODULE,
	.ctr     = snapshot_ctr,
	.dtr     = snapshot_dtr,
	.map     = snapshot_map,
2211
	.end_io  = snapshot_end_io,
2212
	.preresume  = snapshot_preresume,
L
Linus Torvalds 已提交
2213 2214
	.resume  = snapshot_resume,
	.status  = snapshot_status,
2215
	.iterate_devices = snapshot_iterate_devices,
L
Linus Torvalds 已提交
2216 2217
};

M
Mikulas Patocka 已提交
2218 2219
static struct target_type merge_target = {
	.name    = dm_snapshot_merge_target_name,
2220
	.version = {1, 1, 0},
M
Mikulas Patocka 已提交
2221 2222 2223
	.module  = THIS_MODULE,
	.ctr     = snapshot_ctr,
	.dtr     = snapshot_dtr,
2224
	.map     = snapshot_merge_map,
M
Mikulas Patocka 已提交
2225
	.end_io  = snapshot_end_io,
M
Mikulas Patocka 已提交
2226
	.presuspend = snapshot_merge_presuspend,
M
Mikulas Patocka 已提交
2227
	.preresume  = snapshot_preresume,
M
Mikulas Patocka 已提交
2228
	.resume  = snapshot_merge_resume,
M
Mikulas Patocka 已提交
2229 2230 2231 2232
	.status  = snapshot_status,
	.iterate_devices = snapshot_iterate_devices,
};

L
Linus Torvalds 已提交
2233 2234 2235 2236
static int __init dm_snapshot_init(void)
{
	int r;

2237 2238 2239 2240 2241 2242
	r = dm_exception_store_init();
	if (r) {
		DMERR("Failed to initialize exception stores");
		return r;
	}

L
Linus Torvalds 已提交
2243
	r = dm_register_target(&snapshot_target);
M
Mikulas Patocka 已提交
2244
	if (r < 0) {
L
Linus Torvalds 已提交
2245
		DMERR("snapshot target register failed %d", r);
2246
		goto bad_register_snapshot_target;
L
Linus Torvalds 已提交
2247 2248 2249 2250
	}

	r = dm_register_target(&origin_target);
	if (r < 0) {
2251
		DMERR("Origin target register failed %d", r);
M
Mikulas Patocka 已提交
2252 2253 2254 2255 2256 2257 2258
		goto bad_register_origin_target;
	}

	r = dm_register_target(&merge_target);
	if (r < 0) {
		DMERR("Merge target register failed %d", r);
		goto bad_register_merge_target;
L
Linus Torvalds 已提交
2259 2260 2261 2262 2263
	}

	r = init_origin_hash();
	if (r) {
		DMERR("init_origin_hash failed.");
M
Mikulas Patocka 已提交
2264
		goto bad_origin_hash;
L
Linus Torvalds 已提交
2265 2266
	}

2267
	exception_cache = KMEM_CACHE(dm_exception, 0);
L
Linus Torvalds 已提交
2268 2269 2270
	if (!exception_cache) {
		DMERR("Couldn't create exception cache.");
		r = -ENOMEM;
M
Mikulas Patocka 已提交
2271
		goto bad_exception_cache;
L
Linus Torvalds 已提交
2272 2273
	}

A
Alasdair G Kergon 已提交
2274
	pending_cache = KMEM_CACHE(dm_snap_pending_exception, 0);
L
Linus Torvalds 已提交
2275 2276 2277
	if (!pending_cache) {
		DMERR("Couldn't create pending cache.");
		r = -ENOMEM;
M
Mikulas Patocka 已提交
2278
		goto bad_pending_cache;
L
Linus Torvalds 已提交
2279 2280
	}

2281 2282 2283 2284
	tracked_chunk_cache = KMEM_CACHE(dm_snap_tracked_chunk, 0);
	if (!tracked_chunk_cache) {
		DMERR("Couldn't create cache to track chunks in use.");
		r = -ENOMEM;
M
Mikulas Patocka 已提交
2285
		goto bad_tracked_chunk_cache;
2286 2287
	}

L
Linus Torvalds 已提交
2288 2289
	return 0;

M
Mikulas Patocka 已提交
2290
bad_tracked_chunk_cache:
L
Linus Torvalds 已提交
2291
	kmem_cache_destroy(pending_cache);
M
Mikulas Patocka 已提交
2292
bad_pending_cache:
L
Linus Torvalds 已提交
2293
	kmem_cache_destroy(exception_cache);
M
Mikulas Patocka 已提交
2294
bad_exception_cache:
L
Linus Torvalds 已提交
2295
	exit_origin_hash();
M
Mikulas Patocka 已提交
2296 2297 2298
bad_origin_hash:
	dm_unregister_target(&merge_target);
bad_register_merge_target:
L
Linus Torvalds 已提交
2299
	dm_unregister_target(&origin_target);
M
Mikulas Patocka 已提交
2300
bad_register_origin_target:
L
Linus Torvalds 已提交
2301
	dm_unregister_target(&snapshot_target);
2302 2303
bad_register_snapshot_target:
	dm_exception_store_exit();
M
Mikulas Patocka 已提交
2304

L
Linus Torvalds 已提交
2305 2306 2307 2308 2309
	return r;
}

static void __exit dm_snapshot_exit(void)
{
2310 2311
	dm_unregister_target(&snapshot_target);
	dm_unregister_target(&origin_target);
M
Mikulas Patocka 已提交
2312
	dm_unregister_target(&merge_target);
L
Linus Torvalds 已提交
2313 2314 2315 2316

	exit_origin_hash();
	kmem_cache_destroy(pending_cache);
	kmem_cache_destroy(exception_cache);
2317
	kmem_cache_destroy(tracked_chunk_cache);
2318 2319

	dm_exception_store_exit();
L
Linus Torvalds 已提交
2320 2321 2322 2323 2324 2325 2326 2327 2328
}

/* Module hooks */
module_init(dm_snapshot_init);
module_exit(dm_snapshot_exit);

MODULE_DESCRIPTION(DM_NAME " snapshot target");
MODULE_AUTHOR("Joe Thornber");
MODULE_LICENSE("GPL");