string: factorize skip_spaces and export it to be generally available

[safe/jmp/linux-2.6] / drivers / md / dm-exception-store.h

diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h
index d75f775..8a223a4 100644 (file)
--- a/drivers/md/dm-exception-store.h
+++ b/drivers/md/dm-exception-store.h
@@ -11,6 +11,7 @@
 #define _LINUX_DM_EXCEPTION_STORE
 
 #include <linux/blkdev.h>
+#include <linux/device-mapper.h>
 
 /*
  * The snapshot code deals with largish chunks of the disk at a
@@ -36,28 +37,39 @@ struct dm_snap_exception {
  * Abstraction to handle the meta/layout of exception stores (the
  * COW device).
  */
-struct exception_store {
+struct dm_exception_store;
+struct dm_exception_store_type {
+       const char *name;
+       struct module *module;
+
+       int (*ctr) (struct dm_exception_store *store,
+                   unsigned argc, char **argv);
+
        /*
         * Destroys this object when you've finished with it.
         */
-       void (*destroy) (struct exception_store *store);
+       void (*dtr) (struct dm_exception_store *store);
 
        /*
         * The target shouldn't read the COW device until this is
-        * called.
+        * called.  As exceptions are read from the COW, they are
+        * reported back via the callback.
         */
-       int (*read_metadata) (struct exception_store *store);
+       int (*read_metadata) (struct dm_exception_store *store,
+                             int (*callback)(void *callback_context,
+                                             chunk_t old, chunk_t new),
+                             void *callback_context);
 
        /*
         * Find somewhere to store the next exception.
         */
-       int (*prepare_exception) (struct exception_store *store,
+       int (*prepare_exception) (struct dm_exception_store *store,
                                  struct dm_snap_exception *e);
 
        /*
         * Update the metadata with this exception.
         */
-       void (*commit_exception) (struct exception_store *store,
+       void (*commit_exception) (struct dm_exception_store *store,
                                  struct dm_snap_exception *e,
                                  void (*callback) (void *, int success),
                                  void *callback_context);
@@ -65,23 +77,41 @@ struct exception_store {
        /*
         * The snapshot is invalid, note this in the metadata.
         */
-       void (*drop_snapshot) (struct exception_store *store);
+       void (*drop_snapshot) (struct dm_exception_store *store);
+
+       unsigned (*status) (struct dm_exception_store *store,
+                           status_type_t status, char *result,
+                           unsigned maxlen);
 
        /*
         * Return how full the snapshot is.
         */
-       void (*fraction_full) (struct exception_store *store,
+       void (*fraction_full) (struct dm_exception_store *store,
                               sector_t *numerator,
                               sector_t *denominator);
 
-       struct dm_snapshot *snap;
+       /* For internal device-mapper use only. */
+       struct list_head list;
+};
+
+struct dm_exception_store {
+       struct dm_exception_store_type *type;
+       struct dm_target *ti;
+
+       struct dm_dev *cow;
+
+       /* Size of data blocks saved - must be a power of 2 */
+       unsigned chunk_size;
+       unsigned chunk_mask;
+       unsigned chunk_shift;
+
        void *context;
 };
 
 /*
  * Funtions to manipulate consecutive chunks
  */
-#  if defined(CONFIG_LBD) || (BITS_PER_LONG == 64)
+#  if defined(CONFIG_LBDAF) || (BITS_PER_LONG == 64)
 #    define DM_CHUNK_CONSECUTIVE_BITS 8
 #    define DM_CHUNK_NUMBER_BITS 56
 
@@ -122,10 +152,41 @@ static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
 #  endif
 
 /*
+ * Return the number of sectors in the device.
+ */
+static inline sector_t get_dev_size(struct block_device *bdev)
+{
+       return i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
+}
+
+static inline chunk_t sector_to_chunk(struct dm_exception_store *store,
+                                     sector_t sector)
+{
+       return (sector & ~store->chunk_mask) >> store->chunk_shift;
+}
+
+int dm_exception_store_type_register(struct dm_exception_store_type *type);
+int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
+
+int dm_exception_store_set_chunk_size(struct dm_exception_store *store,
+                                     unsigned chunk_size,
+                                     char **error);
+
+int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
+                             unsigned *args_used,
+                             struct dm_exception_store **store);
+void dm_exception_store_destroy(struct dm_exception_store *store);
+
+int dm_exception_store_init(void);
+void dm_exception_store_exit(void);
+
+/*
  * Two exception store implementations.
  */
-int dm_create_persistent(struct exception_store *store);
+int dm_persistent_snapshot_init(void);
+void dm_persistent_snapshot_exit(void);
 
-int dm_create_transient(struct exception_store *store);
+int dm_transient_snapshot_init(void);
+void dm_transient_snapshot_exit(void);
 
 #endif /* _LINUX_DM_EXCEPTION_STORE */