LXR linux/drivers/md/dm-exception-store.h

   1/*
   2 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
   3 * Copyright (C) 2008 Red Hat, Inc. All rights reserved.
   4 *
   5 * Device-mapper snapshot exception store.
   6 *
   7 * This file is released under the GPL.
   8 */
   9
  10#ifndef _LINUX_DM_EXCEPTION_STORE
  11#define _LINUX_DM_EXCEPTION_STORE
  12
  13#include <linux/blkdev.h>
  14#include <linux/device-mapper.h>
  15
  16/*
  17 * The snapshot code deals with largish chunks of the disk at a
  18 * time. Typically 32k - 512k.
  19 */
  20typedef sector_t chunk_t;
  21
  22/*
  23 * An exception is used where an old chunk of data has been
  24 * replaced by a new one.
  25 * If chunk_t is 64 bits in size, the top 8 bits of new_chunk hold the number
  26 * of chunks that follow contiguously.  Remaining bits hold the number of the
  27 * chunk within the device.
  28 */
  29struct dm_snap_exception {
  30        struct list_head hash_list;
  31
  32        chunk_t old_chunk;
  33        chunk_t new_chunk;
  34};
  35
  36/*
  37 * Abstraction to handle the meta/layout of exception stores (the
  38 * COW device).
  39 */
  40struct dm_exception_store;
  41struct dm_exception_store_type {
  42        const char *name;
  43        struct module *module;
  44
  45        int (*ctr) (struct dm_exception_store *store,
  46                    unsigned argc, char **argv);
  47
  48        /*
  49         * Destroys this object when you've finished with it.
  50         */
  51        void (*dtr) (struct dm_exception_store *store);
  52
  53        /*
  54         * The target shouldn't read the COW device until this is
  55         * called.  As exceptions are read from the COW, they are
  56         * reported back via the callback.
  57         */
  58        int (*read_metadata) (struct dm_exception_store *store,
  59                              int (*callback)(void *callback_context,
  60                                              chunk_t old, chunk_t new),
  61                              void *callback_context);
  62
  63        /*
  64         * Find somewhere to store the next exception.
  65         */
  66        int (*prepare_exception) (struct dm_exception_store *store,
  67                                  struct dm_snap_exception *e);
  68
  69        /*
  70         * Update the metadata with this exception.
  71         */
  72        void (*commit_exception) (struct dm_exception_store *store,
  73                                  struct dm_snap_exception *e,
  74                                  void (*callback) (void *, int success),
  75                                  void *callback_context);
  76
  77        /*
  78         * The snapshot is invalid, note this in the metadata.
  79         */
  80        void (*drop_snapshot) (struct dm_exception_store *store);
  81
  82        unsigned (*status) (struct dm_exception_store *store,
  83                            status_type_t status, char *result,
  84                            unsigned maxlen);
  85
  86        /*
  87         * Return how full the snapshot is.
  88         */
  89        void (*fraction_full) (struct dm_exception_store *store,
  90                               sector_t *numerator,
  91                               sector_t *denominator);
  92
  93        /* For internal device-mapper use only. */
  94        struct list_head list;
  95};
  96
  97struct dm_exception_store {
  98        struct dm_exception_store_type *type;
  99        struct dm_target *ti;
 100
 101        struct dm_dev *cow;
 102
 103        /* Size of data blocks saved - must be a power of 2 */
 104        unsigned chunk_size;
 105        unsigned chunk_mask;
 106        unsigned chunk_shift;
 107
 108        void *context;
 109};
 110
 111/*
 112 * Funtions to manipulate consecutive chunks
 113 */
 114#  if defined(CONFIG_LBDAF) || (BITS_PER_LONG == 64)
 115#    define DM_CHUNK_CONSECUTIVE_BITS 8
 116#    define DM_CHUNK_NUMBER_BITS 56
 117
 118static inline chunk_t dm_chunk_number(chunk_t chunk)
 119{
 120        return chunk & (chunk_t)((1ULL << DM_CHUNK_NUMBER_BITS) - 1ULL);
 121}
 122
 123static inline unsigned dm_consecutive_chunk_count(struct dm_snap_exception *e)
 124{
 125        return e->new_chunk >> DM_CHUNK_NUMBER_BITS;
 126}
 127
 128static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
 129{
 130        e->new_chunk += (1ULL << DM_CHUNK_NUMBER_BITS);
 131
 132        BUG_ON(!dm_consecutive_chunk_count(e));
 133}
 134
 135#  else
 136#    define DM_CHUNK_CONSECUTIVE_BITS 0
 137
 138static inline chunk_t dm_chunk_number(chunk_t chunk)
 139{
 140        return chunk;
 141}
 142
 143static inline unsigned dm_consecutive_chunk_count(struct dm_snap_exception *e)
 144{
 145        return 0;
 146}
 147
 148static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
 149{
 150}
 151
 152#  endif
 153
 154/*
 155 * Return the number of sectors in the device.
 156 */
 157static inline sector_t get_dev_size(struct block_device *bdev)
 158{
 159        return i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
 160}
 161
 162static inline chunk_t sector_to_chunk(struct dm_exception_store *store,
 163                                      sector_t sector)
 164{
 165        return (sector & ~store->chunk_mask) >> store->chunk_shift;
 166}
 167
 168int dm_exception_store_type_register(struct dm_exception_store_type *type);
 169int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
 170
 171int dm_exception_store_set_chunk_size(struct dm_exception_store *store,
 172                                      unsigned chunk_size,
 173                                      char **error);
 174
 175int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
 176                              unsigned *args_used,
 177                              struct dm_exception_store **store);
 178void dm_exception_store_destroy(struct dm_exception_store *store);
 179
 180int dm_exception_store_init(void);
 181void dm_exception_store_exit(void);
 182
 183/*
 184 * Two exception store implementations.
 185 */
 186int dm_persistent_snapshot_init(void);
 187void dm_persistent_snapshot_exit(void);
 188
 189int dm_transient_snapshot_init(void);
 190void dm_transient_snapshot_exit(void);
 191
 192#endif /* _LINUX_DM_EXCEPTION_STORE */
 193