Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756151AbZKTU37 (ORCPT ); Fri, 20 Nov 2009 15:29:59 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1755924AbZKTU1x (ORCPT ); Fri, 20 Nov 2009 15:27:53 -0500 Received: from mx1.redhat.com ([209.132.183.28]:9038 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755333AbZKTU1u (ORCPT ); Fri, 20 Nov 2009 15:27:50 -0500 From: Mike Snitzer To: dm-devel@redhat.com Cc: linux-kernel@vger.kernel.org, Mikulas Patocka Subject: [PATCH v4 03/13] dm exception store: add snapshot-merge specific methods Date: Fri, 20 Nov 2009 15:27:43 -0500 Message-Id: <1258748873-24185-4-git-send-email-snitzer@redhat.com> In-Reply-To: <1258748873-24185-1-git-send-email-snitzer@redhat.com> References: <1258748873-24185-1-git-send-email-snitzer@redhat.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 4983 Lines: 155 From: Mikulas Patocka prepare_merge: returns the last chunk in the variables passed by reference. The return value is the number of consecutive chunks. commit_merge: permanently removes 'n' chunks from the exception store. 'n' is less or equal that the number returned by prepare_merge. If the caller wishes, it can do the optimization of merging several consecutive chunks at once. If it doesn't want to do this optimization, it just calls commit_merge with n == 1. Signed-off-by: Mikulas Patocka Reviewed-by: Mike Snitzer --- drivers/md/dm-exception-store.h | 16 +++++++++ drivers/md/dm-snap-persistent.c | 70 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 86 insertions(+), 0 deletions(-) diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h index bb88746..534427f 100644 --- a/drivers/md/dm-exception-store.h +++ b/drivers/md/dm-exception-store.h @@ -75,6 +75,22 @@ struct dm_exception_store_type { void *callback_context); /* + * Returns the last chunk in the pointers. (TODO: -ENOPARSE) + * > 0: the number of consecutive chunks that can + * be copied in one shot. + * == 0: the exception store is empty. + * < 0: error. + */ + int (*prepare_merge) (struct dm_exception_store *store, + chunk_t *old_chunk, chunk_t *new_chunk); + + /* + * Clear the last n exceptions. + * n must be <= the value returned by prepare_merge. + */ + int (*commit_merge) (struct dm_exception_store *store, int n); + + /* * The snapshot is invalid, note this in the metadata. */ void (*drop_snapshot) (struct dm_exception_store *store); diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c index 157999e..1f5752e 100644 --- a/drivers/md/dm-snap-persistent.c +++ b/drivers/md/dm-snap-persistent.c @@ -409,6 +409,15 @@ static void write_exception(struct pstore *ps, e->new_chunk = cpu_to_le64(de->new_chunk); } +static void clear_exception(struct pstore *ps, uint32_t index) +{ + struct disk_exception *e = get_exception(ps, index); + + /* clear it */ + e->old_chunk = 0; + e->new_chunk = 0; +} + /* * Registers the exceptions that are present in the current area. * 'full' is filled in to indicate if the area has been @@ -680,6 +689,63 @@ static void persistent_commit_exception(struct dm_exception_store *store, ps->callback_count = 0; } +static int persistent_prepare_merge(struct dm_exception_store *store, + chunk_t *old_chunk, chunk_t *new_chunk) +{ + int r, i; + struct pstore *ps = get_info(store); + struct disk_exception de; + + if (!ps->current_committed) { + if (!ps->current_area) + return 0; + ps->current_area--; + r = area_io(ps, READ); + if (r < 0) + return r; + ps->current_committed = ps->exceptions_per_area; + } + + read_exception(ps, ps->current_committed - 1, &de); + *old_chunk = de.old_chunk; + *new_chunk = de.new_chunk; + + for (i = 1; i < ps->current_committed; i++) { + read_exception(ps, ps->current_committed - 1 - i, &de); + if (de.old_chunk != *old_chunk - i || + de.new_chunk != *new_chunk - i) + break; + } + + return i; +} + +static int persistent_commit_merge(struct dm_exception_store *store, int n) +{ + int r, i; + struct pstore *ps = get_info(store); + + BUG_ON(n > ps->current_committed); + + for (i = 0; i < n; i++) + clear_exception(ps, ps->current_committed - 1 - i); + + r = area_io(ps, WRITE); + if (r < 0) + return r; + + ps->current_committed -= i; + + /* + * ps->next_free cannot really be reliably decreased here (because of + * misordered chunks), so don't do it. We don't even need it, because + * there is no situation where merging snapshot would become + * non-merging. + */ + + return 0; +} + static void persistent_drop_snapshot(struct dm_exception_store *store) { struct pstore *ps = get_info(store); @@ -748,6 +814,8 @@ static struct dm_exception_store_type _persistent_type = { .read_metadata = persistent_read_metadata, .prepare_exception = persistent_prepare_exception, .commit_exception = persistent_commit_exception, + .prepare_merge = persistent_prepare_merge, + .commit_merge = persistent_commit_merge, .drop_snapshot = persistent_drop_snapshot, .usage = persistent_usage, .status = persistent_status, @@ -761,6 +829,8 @@ static struct dm_exception_store_type _persistent_compat_type = { .read_metadata = persistent_read_metadata, .prepare_exception = persistent_prepare_exception, .commit_exception = persistent_commit_exception, + .prepare_merge = persistent_prepare_merge, + .commit_merge = persistent_commit_merge, .drop_snapshot = persistent_drop_snapshot, .usage = persistent_usage, .status = persistent_status, -- 1.6.5.2 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/