dm kcopyd: clean interface

Clean up the kcopyd interface to prepare for publishing it in include/linux.

Signed-off-by: Heinz Mauelshagen <hjm@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>

diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 0d4e7e9653ffc707b07077f5d1cbc56802760a19..32c7c6d109393fa38984ed45a363f9e2a1db1647 100644 (file)
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -133,7 +133,7 @@ struct mirror_set {
        struct dm_target *ti;
        struct list_head list;
        struct region_hash rh;
-       struct kcopyd_client *kcopyd_client;
+       struct dm_kcopyd_client *kcopyd_client;
        uint64_t features;
 
        spinlock_t lock;        /* protects the lists */
@@ -788,7 +788,7 @@ static int recover(struct mirror_set *ms, struct region *reg)
 {
        int r;
        unsigned int i;
-       struct dm_io_region from, to[KCOPYD_MAX_REGIONS], *dest;
+       struct dm_io_region from, to[DM_KCOPYD_MAX_REGIONS], *dest;
        struct mirror *m;
        unsigned long flags = 0;
 
@@ -820,9 +820,9 @@ static int recover(struct mirror_set *ms, struct region *reg)
        }
 
        /* hand to kcopyd */
-       set_bit(KCOPYD_IGNORE_ERROR, &flags);
-       r = kcopyd_copy(ms->kcopyd_client, &from, ms->nr_mirrors - 1, to, flags,
-                       recovery_complete, reg);
+       set_bit(DM_KCOPYD_IGNORE_ERROR, &flags);
+       r = dm_kcopyd_copy(ms->kcopyd_client, &from, ms->nr_mirrors - 1, to,
+                          flags, recovery_complete, reg);
 
        return r;
 }
@@ -1504,7 +1504,7 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        argc -= args_used;
 
        if (!argc || sscanf(argv[0], "%u", &nr_mirrors) != 1 ||
-           nr_mirrors < 2 || nr_mirrors > KCOPYD_MAX_REGIONS + 1) {
+           nr_mirrors < 2 || nr_mirrors > DM_KCOPYD_MAX_REGIONS + 1) {
                ti->error = "Invalid number of mirrors";
                dm_destroy_dirty_log(dl);
                return -EINVAL;
@@ -1569,7 +1569,7 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto err_destroy_wq;
        }
 
-       r = kcopyd_client_create(DM_IO_PAGES, &ms->kcopyd_client);
+       r = dm_kcopyd_client_create(DM_IO_PAGES, &ms->kcopyd_client);
        if (r)
                goto err_destroy_wq;
 
@@ -1588,7 +1588,7 @@ static void mirror_dtr(struct dm_target *ti)
        struct mirror_set *ms = (struct mirror_set *) ti->private;
 
        flush_workqueue(ms->kmirrord_wq);
-       kcopyd_client_destroy(ms->kcopyd_client);
+       dm_kcopyd_client_destroy(ms->kcopyd_client);
        destroy_workqueue(ms->kmirrord_wq);
        free_context(ms, ti, ms->nr_mirrors);
 }

diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index bab159b77742e6bc4c03464c70a7f0b85f4da93a..e1dcca99392ef0227dcc54698e9ea4093617a14d 100644 (file)
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -558,7 +558,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto bad4;
        }
 
-       r = kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);
+       r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);
        if (r) {
                ti->error = "Could not create kcopyd client";
                goto bad5;
@@ -591,7 +591,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        return 0;
 
  bad6:
-       kcopyd_client_destroy(s->kcopyd_client);
+       dm_kcopyd_client_destroy(s->kcopyd_client);
 
  bad5:
        s->store.destroy(&s->store);
@@ -613,7 +613,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
 static void __free_exceptions(struct dm_snapshot *s)
 {
-       kcopyd_client_destroy(s->kcopyd_client);
+       dm_kcopyd_client_destroy(s->kcopyd_client);
        s->kcopyd_client = NULL;
 
        exit_exception_table(&s->pending, pending_cache);
@@ -839,7 +839,7 @@ static void start_copy(struct dm_snap_pending_exception *pe)
        dest.count = src.count;
 
        /* Hand over to kcopyd */
-       kcopyd_copy(s->kcopyd_client,
+       dm_kcopyd_copy(s->kcopyd_client,
                    &src, 1, &dest, 0, copy_callback, pe);
 }
 

diff --git a/drivers/md/dm-snap.h b/drivers/md/dm-snap.h
index 434d1dbe6bce33b878a4be338af0a6cd8670fc2d..24f9fb73b982d0cd148ef15d56428ba6c7ce6877 100644 (file)
--- a/drivers/md/dm-snap.h
+++ b/drivers/md/dm-snap.h
@@ -169,7 +169,7 @@ struct dm_snapshot {
        /* The on disk metadata handler */
        struct exception_store store;
 
-       struct kcopyd_client *kcopyd_client;
+       struct dm_kcopyd_client *kcopyd_client;
 
        /* Queue of snapshot writes for ksnapd to flush */
        struct bio_list queued_bios;

diff --git a/drivers/md/kcopyd.c b/drivers/md/kcopyd.c
index 21fea42c68c452a54793adbf1e750055e35c3708..4f2c61acf7c64323225b0cf98948e2f04eb0ea2d 100644 (file)
--- a/drivers/md/kcopyd.c
+++ b/drivers/md/kcopyd.c
@@ -9,9 +9,8 @@
  * completion notification.
  */
 
-#include <asm/types.h>
+#include <linux/types.h>
 #include <asm/atomic.h>
-
 #include <linux/blkdev.h>
 #include <linux/fs.h>
 #include <linux/init.h>
@@ -39,7 +38,7 @@ static void wake(void)
  * Each kcopyd client has its own little pool of preallocated
  * pages for kcopyd io.
  *---------------------------------------------------------------*/
-struct kcopyd_client {
+struct dm_kcopyd_client {
        struct list_head list;
 
        spinlock_t lock;
@@ -76,7 +75,7 @@ static void free_pl(struct page_list *pl)
        kfree(pl);
 }
 
-static int kcopyd_get_pages(struct kcopyd_client *kc,
+static int kcopyd_get_pages(struct dm_kcopyd_client *kc,
                            unsigned int nr, struct page_list **pages)
 {
        struct page_list *pl;
@@ -99,7 +98,7 @@ static int kcopyd_get_pages(struct kcopyd_client *kc,
        return 0;
 }
 
-static void kcopyd_put_pages(struct kcopyd_client *kc, struct page_list *pl)
+static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl)
 {
        struct page_list *cursor;
 
@@ -127,7 +126,7 @@ static void drop_pages(struct page_list *pl)
        }
 }
 
-static int client_alloc_pages(struct kcopyd_client *kc, unsigned int nr)
+static int client_alloc_pages(struct dm_kcopyd_client *kc, unsigned int nr)
 {
        unsigned int i;
        struct page_list *pl = NULL, *next;
@@ -148,7 +147,7 @@ static int client_alloc_pages(struct kcopyd_client *kc, unsigned int nr)
        return 0;
 }
 
-static void client_free_pages(struct kcopyd_client *kc)
+static void client_free_pages(struct dm_kcopyd_client *kc)
 {
        BUG_ON(kc->nr_free_pages != kc->nr_pages);
        drop_pages(kc->pages);
@@ -162,7 +161,7 @@ static void client_free_pages(struct kcopyd_client *kc)
  * ever having to do io (which could cause a deadlock).
  *---------------------------------------------------------------*/
 struct kcopyd_job {
-       struct kcopyd_client *kc;
+       struct dm_kcopyd_client *kc;
        struct list_head list;
        unsigned long flags;
 
@@ -182,7 +181,7 @@ struct kcopyd_job {
         * The destinations for the transfer.
         */
        unsigned int num_dests;
-       struct dm_io_region dests[KCOPYD_MAX_REGIONS];
+       struct dm_io_region dests[DM_KCOPYD_MAX_REGIONS];
 
        sector_t offset;
        unsigned int nr_pages;
@@ -192,7 +191,7 @@ struct kcopyd_job {
         * Set this to ensure you are notified when the job has
         * completed.  'context' is for callback to use.
         */
-       kcopyd_notify_fn fn;
+       dm_kcopyd_notify_fn fn;
        void *context;
 
        /*
@@ -295,8 +294,8 @@ static int run_complete_job(struct kcopyd_job *job)
        void *context = job->context;
        int read_err = job->read_err;
        unsigned long write_err = job->write_err;
-       kcopyd_notify_fn fn = job->fn;
-       struct kcopyd_client *kc = job->kc;
+       dm_kcopyd_notify_fn fn = job->fn;
+       struct dm_kcopyd_client *kc = job->kc;
 
        kcopyd_put_pages(kc, job->pages);
        mempool_free(job, _job_pool);
@@ -318,7 +317,7 @@ static void complete_io(unsigned long error, void *context)
                else
                        job->read_err = 1;
 
-               if (!test_bit(KCOPYD_IGNORE_ERROR, &job->flags)) {
+               if (!test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) {
                        push(&_complete_jobs, job);
                        wake();
                        return;
@@ -470,7 +469,7 @@ static void segment_complete(int read_err, unsigned long write_err,
         * Only dispatch more work if there hasn't been an error.
         */
        if ((!job->read_err && !job->write_err) ||
-           test_bit(KCOPYD_IGNORE_ERROR, &job->flags)) {
+           test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) {
                /* get the next chunk of work */
                progress = job->progress;
                count = job->source.count - progress;
@@ -527,9 +526,9 @@ static void split_job(struct kcopyd_job *job)
                segment_complete(0, 0u, job);
 }
 
-int kcopyd_copy(struct kcopyd_client *kc, struct dm_io_region *from,
-               unsigned int num_dests, struct dm_io_region *dests,
-               unsigned int flags, kcopyd_notify_fn fn, void *context)
+int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
+                  unsigned int num_dests, struct dm_io_region *dests,
+                  unsigned int flags, dm_kcopyd_notify_fn fn, void *context)
 {
        struct kcopyd_job *job;
 
@@ -570,6 +569,7 @@ int kcopyd_copy(struct kcopyd_client *kc, struct dm_io_region *from,
 
        return 0;
 }
+EXPORT_SYMBOL(dm_kcopyd_copy);
 
 /*
  * Cancels a kcopyd job, eg. someone might be deactivating a
@@ -589,14 +589,14 @@ int kcopyd_cancel(struct kcopyd_job *job, int block)
 static DEFINE_MUTEX(_client_lock);
 static LIST_HEAD(_clients);
 
-static void client_add(struct kcopyd_client *kc)
+static void client_add(struct dm_kcopyd_client *kc)
 {
        mutex_lock(&_client_lock);
        list_add(&kc->list, &_clients);
        mutex_unlock(&_client_lock);
 }
 
-static void client_del(struct kcopyd_client *kc)
+static void client_del(struct dm_kcopyd_client *kc)
 {
        mutex_lock(&_client_lock);
        list_del(&kc->list);
@@ -650,10 +650,11 @@ static void kcopyd_exit(void)
        mutex_unlock(&kcopyd_init_lock);
 }
 
-int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
+int dm_kcopyd_client_create(unsigned int nr_pages,
+                           struct dm_kcopyd_client **result)
 {
        int r = 0;
-       struct kcopyd_client *kc;
+       struct dm_kcopyd_client *kc;
 
        r = kcopyd_init();
        if (r)
@@ -691,8 +692,9 @@ int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
        *result = kc;
        return 0;
 }
+EXPORT_SYMBOL(dm_kcopyd_client_create);
 
-void kcopyd_client_destroy(struct kcopyd_client *kc)
+void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc)
 {
        /* Wait for completion of all jobs submitted by this client. */
        wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs));
@@ -703,7 +705,4 @@ void kcopyd_client_destroy(struct kcopyd_client *kc)
        kfree(kc);
        kcopyd_exit();
 }
-
-EXPORT_SYMBOL(kcopyd_client_create);
-EXPORT_SYMBOL(kcopyd_client_destroy);
-EXPORT_SYMBOL(kcopyd_copy);
+EXPORT_SYMBOL(dm_kcopyd_client_destroy);

diff --git a/drivers/md/kcopyd.h b/drivers/md/kcopyd.h
index 588f05dffbe1a099247fc1ee3850c7c38fd43080..d3057846b0b089d3a614f22f5c2caae62656f320 100644 (file)
--- a/drivers/md/kcopyd.h
+++ b/drivers/md/kcopyd.h
@@ -1,29 +1,33 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001 - 2003 Sistina Software
+ * Copyright (C) 2004 - 2008 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * kcopyd provides a simple interface for copying an area of one
+ * block-device to one or more other block-devices, either synchronous
+ * or with an asynchronous completion notification.
  *
- * Kcopyd provides a simple interface for copying an area of one
- * block-device to one or more other block-devices, with an asynchronous
- * completion notification.
+ * This file is released under the GPL.
  */
 
-#ifndef DM_KCOPYD_H
-#define DM_KCOPYD_H
+#ifndef _LINUX_DM_KCOPYD_H
+#define _LINUX_DM_KCOPYD_H
+
+#ifdef __KERNEL__
 
 #include "dm-io.h"
 
 /* FIXME: make this configurable */
-#define KCOPYD_MAX_REGIONS 8
+#define DM_KCOPYD_MAX_REGIONS 8
 
-#define KCOPYD_IGNORE_ERROR 1
+#define DM_KCOPYD_IGNORE_ERROR 1
 
 /*
- * To use kcopyd you must first create a kcopyd client object.
+ * To use kcopyd you must first create a dm_kcopyd_client object.
  */
-struct kcopyd_client;
-int kcopyd_client_create(unsigned int num_pages, struct kcopyd_client **result);
-void kcopyd_client_destroy(struct kcopyd_client *kc);
+struct dm_kcopyd_client;
+int dm_kcopyd_client_create(unsigned num_pages,
+                           struct dm_kcopyd_client **result);
+void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc);
 
 /*
  * Submit a copy job to kcopyd.  This is built on top of the
@@ -32,11 +36,12 @@ void kcopyd_client_destroy(struct kcopyd_client *kc);
  * read_err is a boolean,
  * write_err is a bitset, with 1 bit for each destination region
  */
-typedef void (*kcopyd_notify_fn)(int read_err, unsigned long write_err,
-                                void *context);
+typedef void (*dm_kcopyd_notify_fn)(int read_err, unsigned long write_err,
+                                   void *context);
 
-int kcopyd_copy(struct kcopyd_client *kc, struct dm_io_region *from,
-               unsigned num_dests, struct dm_io_region *dests,
-               unsigned int flags, kcopyd_notify_fn fn, void *context);
+int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
+                  unsigned num_dests, struct dm_io_region *dests,
+                  unsigned flags, dm_kcopyd_notify_fn fn, void *context);
 
-#endif
+#endif /* __KERNEL__ */
+#endif /* _LINUX_DM_KCOPYD_H */