dm log: clean interface

Clean up the dm-log 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>

1 files changed, 43 insertions, 41 deletions

diff --git a/drivers/md/dm-log.h b/drivers/md/dm-log.h
index 3fae87eb5963..2da48a857cb9 100644
--- a/drivers/md/dm-log.h
+++ b/drivers/md/dm-log.h
@@ -1,52 +1,58 @@
 /*
  * Copyright (C) 2003 Sistina Software
+ * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
+ *
+ * Device-Mapper dirty region log.
  *
  * This file is released under the LGPL.
  */
 
-#ifndef DM_DIRTY_LOG
-#define DM_DIRTY_LOG
+#ifndef _LINUX_DM_DIRTY_LOG
+#define _LINUX_DM_DIRTY_LOG
+
+#ifdef __KERNEL__
 
-#include "dm.h"
+#include <linux/types.h>
+#include <linux/device-mapper.h>
 
 typedef sector_t region_t;
 
-struct dirty_log_type;
+struct dm_dirty_log_type;
 
-struct dirty_log {
-        struct dirty_log_type *type;
+struct dm_dirty_log {
+        struct dm_dirty_log_type *type;
         void *context;
 };
 
-struct dirty_log_type {
+struct dm_dirty_log_type {
         struct list_head list;
         const char *name;
         struct module *module;
-        unsigned int use_count;
+        unsigned use_count;
 
-        int (*ctr)(struct dirty_log *log, struct dm_target *ti,
-                   unsigned int argc, char **argv);
-        void (*dtr)(struct dirty_log *log);
+        int (*ctr)(struct dm_dirty_log *log, struct dm_target *ti,
+                   unsigned argc, char **argv);
+        void (*dtr)(struct dm_dirty_log *log);
 
         /*
          * There are times when we don't want the log to touch
          * the disk.
          */
-        int (*presuspend)(struct dirty_log *log);
-        int (*postsuspend)(struct dirty_log *log);
-        int (*resume)(struct dirty_log *log);
+        int (*presuspend)(struct dm_dirty_log *log);
+        int (*postsuspend)(struct dm_dirty_log *log);
+        int (*resume)(struct dm_dirty_log *log);
 
         /*
          * Retrieves the smallest size of region that the log can
          * deal with.
          */
-        uint32_t (*get_region_size)(struct dirty_log *log);
+        uint32_t (*get_region_size)(struct dm_dirty_log *log);
 
-        /*
+        /*
          * A predicate to say whether a region is clean or not.
          * May block.
          */
-        int (*is_clean)(struct dirty_log *log, region_t region);
+        int (*is_clean)(struct dm_dirty_log *log, region_t region);
 
         /*
          *  Returns: 0, 1, -EWOULDBLOCK, < 0
@@ -59,13 +65,14 @@ struct dirty_log_type {
          * passed to a daemon to deal with, since a daemon is
          * allowed to block.
          */
-        int (*in_sync)(struct dirty_log *log, region_t region, int can_block);
+        int (*in_sync)(struct dm_dirty_log *log, region_t region,
+                       int can_block);
 
         /*
          * Flush the current log state (eg, to disk).  This
          * function may block.
          */
-        int (*flush)(struct dirty_log *log);
+        int (*flush)(struct dm_dirty_log *log);
 
         /*
          * Mark an area as clean or dirty.  These functions may
@@ -73,8 +80,8 @@ struct dirty_log_type {
          * be extremely rare (eg, allocating another chunk of
          * memory for some reason).
          */
-        void (*mark_region)(struct dirty_log *log, region_t region);
-        void (*clear_region)(struct dirty_log *log, region_t region);
+        void (*mark_region)(struct dm_dirty_log *log, region_t region);
+        void (*clear_region)(struct dm_dirty_log *log, region_t region);
 
         /*
          * Returns: <0 (error), 0 (no region), 1 (region)
@@ -88,44 +95,39 @@ struct dirty_log_type {
          * tells you if an area is synchronised, the other
          * assigns recovery work.
         */
-        int (*get_resync_work)(struct dirty_log *log, region_t *region);
+        int (*get_resync_work)(struct dm_dirty_log *log, region_t *region);
 
         /*
          * This notifies the log that the resync status of a region
          * has changed.  It also clears the region from the recovering
          * list (if present).
          */
-        void (*set_region_sync)(struct dirty_log *log,
+        void (*set_region_sync)(struct dm_dirty_log *log,
                                 region_t region, int in_sync);
 
-        /*
+        /*
          * Returns the number of regions that are in sync.
-         */
-        region_t (*get_sync_count)(struct dirty_log *log);
+         */
+        region_t (*get_sync_count)(struct dm_dirty_log *log);
 
         /*
          * Support function for mirror status requests.
          */
-        int (*status)(struct dirty_log *log, status_type_t status_type,
-                      char *result, unsigned int maxlen);
+        int (*status)(struct dm_dirty_log *log, status_type_t status_type,
+                      char *result, unsigned maxlen);
 };
 
-int dm_register_dirty_log_type(struct dirty_log_type *type);
-int dm_unregister_dirty_log_type(struct dirty_log_type *type);
-
+int dm_dirty_log_type_register(struct dm_dirty_log_type *type);
+int dm_dirty_log_type_unregister(struct dm_dirty_log_type *type);
 
 /*
  * Make sure you use these two functions, rather than calling
  * type->constructor/destructor() directly.
  */
-struct dirty_log *dm_create_dirty_log(const char *type_name, struct dm_target *ti,
-                                      unsigned int argc, char **argv);
-void dm_destroy_dirty_log(struct dirty_log *log);
-
-/*
- * init/exit functions.
- */
-int dm_dirty_log_init(void);
-void dm_dirty_log_exit(void);
+struct dm_dirty_log *dm_dirty_log_create(const char *type_name,
+                                         struct dm_target *ti,
+                                         unsigned argc, char **argv);
+void dm_dirty_log_destroy(struct dm_dirty_log *log);
 
-#endif
+#endif  /* __KERNEL__ */
+#endif  /* _LINUX_DM_DIRTY_LOG_H */