The merging process. We don't need a separate thread, kcopyd does the job just fine (provided that we have private kcopyd). Merging is started when origin is resumed and it is stopped when origin is suspended or when the merging snapshot is destoyed. Merging is not interlocked with writes, so there is a race condition with concurrent access. It will be fixed in further patches. Signed-off-by: Mikulas Patocka --- drivers/md/dm-snap.c | 148 +++++++++++++++++++++++++++++++++++++++++++++++++++ drivers/md/dm-snap.h | 10 +++ 2 files changed, 158 insertions(+) Index: linux-2.6.26-rc5-devel/drivers/md/dm-snap.c =================================================================== --- linux-2.6.26-rc5-devel.orig/drivers/md/dm-snap.c 2008-06-16 22:02:43.000000000 +0200 +++ linux-2.6.26-rc5-devel/drivers/md/dm-snap.c 2008-06-17 01:13:22.000000000 +0200 @@ -18,6 +18,7 @@ #include #include #include +#include #include #include "dm-snap.h" @@ -562,6 +563,140 @@ return 0; } +static void merge_callback(int read_err, unsigned long write_err, void *context); + +static void snapshot_merge_process(struct dm_snapshot *s) +{ + int r; + chunk_t old_chunk, new_chunk; + struct dm_snap_exception *e; + struct dm_io_region src, dest; + + BUG_ON(!s->merge_running); + if (s->merge_shutdown) + goto shut; + + if (!s->valid) { + DMERR("snapshot is invalid, can't merge"); + goto shut; + } + + if (!s->store.prepare_exception || !s->store.commit_exception) { + DMERR("target store does not support merging"); + goto shut; + } + r = s->store.prepare_merge(&s->store, &old_chunk, &new_chunk); + if (r <= 0) { + if (r < 0) + DMERR("Read error in exception store, shutting down merge"); + goto shut; + } + + /* TODO: use larger I/O size once we verify that kcopyd handles it */ + + /* !!! FIXME: intelock writes to this chunk */ + down_write(&s->lock); + e = lookup_exception(&s->complete, old_chunk); + if (!e) { + DMERR("exception for block %Lu is on disk but not in memory", (unsigned long long)old_chunk); + up_write(&s->lock); + goto shut; + } + if (dm_consecutive_chunk_count(e)) { + dm_consecutive_chunk_count_dec(e); + } else { + remove_exception(e); + free_exception(e); + } + up_write(&s->lock); + + dest.bdev = s->origin->bdev; + dest.sector = chunk_to_sector(s, old_chunk); + dest.count = min(s->chunk_size, get_dev_size(dest.bdev) - dest.sector); + + src.bdev = s->cow->bdev; + src.sector = chunk_to_sector(s, new_chunk); + src.count = dest.count; + + dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, merge_callback, s); + return; + + shut: + s->merge_running = 0; +} + +static void merge_callback(int read_err, unsigned long write_err, void *context) +{ + int r; + struct dm_snapshot *s = context; + + if (read_err || write_err) { + if (read_err) + DMERR("Read error in data, shutting down merge"); + else + DMERR("Write error in data, shutting down merge"); + goto shut; + } + + r = s->store.commit_merge(&s->store, 1); + if (r < 0) { + DMERR("Write error in exception store, shutting down merge"); + goto shut; + } + + snapshot_merge_process(s); + return; + + shut: + s->merge_running = 0; +} + +static void start_merge(struct block_device *origin) +{ + struct dm_snapshot *merging; + + down_write(&_origins_lock); + merging = __find_merging_snapshot(origin); + if (merging) { + if (!merging->merge_running && !merging->merge_shutdown && !merging->merge_permanent_shutdown) + merging->merge_running = 1; + else + merging = NULL; + } + up_write(&_origins_lock); + + if (merging) + snapshot_merge_process(merging); +} + +/* + * Stop the merging process and wait until it finishes. + * If "permanent" is nonzero, then merging can't ever be restarted --- used + * before destroying the snapshot. + */ + +static void stop_merge(struct block_device *origin, int permanent) +{ + struct dm_snapshot *merging; + + wait_for_merge: + down_write(&_origins_lock); + merging = __find_merging_snapshot(origin); + if (merging) { + if (permanent) + merging->merge_permanent_shutdown = 1; + if (merging->merge_running) { + merging->merge_shutdown = 1; + up_write(&_origins_lock); + msleep(1); + goto wait_for_merge; + } else { + merging->merge_shutdown = 0; + } + } + up_write(&_origins_lock); +} + /* * Construct a snapshot mapping:

*/ @@ -627,6 +762,9 @@ s->valid = 1; s->active = 0; s->handover = 0; + s->merge_running = 0; + s->merge_shutdown = 0; + s->merge_permanent_shutdown = 0; init_rwsem(&s->lock); s->ti = ti; @@ -782,6 +920,9 @@ up_write(&s->lock); up_write(&_origins_lock); + if (is_merge(ti)) + stop_merge(s->origin->bdev, 1); + /* Prevent further origin writes from using this snapshot. */ /* After this returns there can be no new kcopyd jobs. */ unregister_snapshot(s); @@ -1373,6 +1514,8 @@ static void origin_dtr(struct dm_target *ti) { struct dm_dev *dev = ti->private; + + stop_merge(dev->bdev, 0); dm_put_device(ti, dev); } @@ -1399,6 +1542,14 @@ o = __lookup_origin(dev->bdev); ti->split_io = minimum_chunk_size(o); up_read(&_origins_lock); + + start_merge(dev->bdev); +} + +static void origin_postsuspend(struct dm_target *ti) +{ + struct dm_dev *dev = ti->private; + stop_merge(dev->bdev, 0); } static int origin_status(struct dm_target *ti, status_type_t type, char *result, @@ -1427,6 +1578,7 @@ .dtr = origin_dtr, .map = origin_map, .resume = origin_resume, + .postsuspend = origin_postsuspend, .status = origin_status, }; Index: linux-2.6.26-rc5-devel/drivers/md/dm-snap.h =================================================================== --- linux-2.6.26-rc5-devel.orig/drivers/md/dm-snap.h 2008-06-16 22:02:26.000000000 +0200 +++ linux-2.6.26-rc5-devel/drivers/md/dm-snap.h 2008-06-16 22:02:46.000000000 +0200 @@ -209,6 +209,16 @@ mempool_t *tracked_chunk_pool; spinlock_t tracked_chunk_lock; struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE]; + + /* Merge operation is in progress */ + int merge_running; + + /* It is requested to shut down merging */ + /* Cleared back to 0 when the merging is stopped */ + int merge_shutdown; + + /* It is requested to permanently shut down */ + int merge_permanent_shutdown; }; /*