linux/drivers/md/dm-exception-store.h
<<
>>
Prefs
   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_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_exception *e);
  68
  69        /*
  70         * Update the metadata with this exception.
  71         */
  72        void (*commit_exception) (struct dm_exception_store *store,
  73                                  struct dm_exception *e,
  74                                  void (*callback) (void *, int success),
  75                                  void *callback_context);
  76
  77        /*
  78         * Returns 0 if the exception store is empty.
  79         *
  80         * If there are exceptions still to be merged, sets
  81         * *last_old_chunk and *last_new_chunk to the most recent
  82         * still-to-be-merged chunk and returns the number of
  83         * consecutive previous ones.
  84         */
  85        int (*prepare_merge) (struct dm_exception_store *store,
  86                              chunk_t *last_old_chunk, chunk_t *last_new_chunk);
  87
  88        /*
  89         * Clear the last n exceptions.
  90         * nr_merged must be <= the value returned by prepare_merge.
  91         */
  92        int (*commit_merge) (struct dm_exception_store *store, int nr_merged);
  93
  94        /*
  95         * The snapshot is invalid, note this in the metadata.
  96         */
  97        void (*drop_snapshot) (struct dm_exception_store *store);
  98
  99        unsigned (*status) (struct dm_exception_store *store,
 100                            status_type_t status, char *result,
 101                            unsigned maxlen);
 102
 103        /*
 104         * Return how full the snapshot is.
 105         */
 106        void (*usage) (struct dm_exception_store *store,
 107                       sector_t *total_sectors, sector_t *sectors_allocated,
 108                       sector_t *metadata_sectors);
 109
 110        /* For internal device-mapper use only. */
 111        struct list_head list;
 112};
 113
 114struct dm_snapshot;
 115
 116struct dm_exception_store {
 117        struct dm_exception_store_type *type;
 118        struct dm_snapshot *snap;
 119
 120        /* Size of data blocks saved - must be a power of 2 */
 121        unsigned chunk_size;
 122        unsigned chunk_mask;
 123        unsigned chunk_shift;
 124
 125        void *context;
 126};
 127
 128/*
 129 * Obtain the origin or cow device used by a given snapshot.
 130 */
 131struct dm_dev *dm_snap_origin(struct dm_snapshot *snap);
 132struct dm_dev *dm_snap_cow(struct dm_snapshot *snap);
 133
 134/*
 135 * Funtions to manipulate consecutive chunks
 136 */
 137#  if defined(CONFIG_LBDAF) || (BITS_PER_LONG == 64)
 138#    define DM_CHUNK_CONSECUTIVE_BITS 8
 139#    define DM_CHUNK_NUMBER_BITS 56
 140
 141static inline chunk_t dm_chunk_number(chunk_t chunk)
 142{
 143        return chunk & (chunk_t)((1ULL << DM_CHUNK_NUMBER_BITS) - 1ULL);
 144}
 145
 146static inline unsigned dm_consecutive_chunk_count(struct dm_exception *e)
 147{
 148        return e->new_chunk >> DM_CHUNK_NUMBER_BITS;
 149}
 150
 151static inline void dm_consecutive_chunk_count_inc(struct dm_exception *e)
 152{
 153        e->new_chunk += (1ULL << DM_CHUNK_NUMBER_BITS);
 154
 155        BUG_ON(!dm_consecutive_chunk_count(e));
 156}
 157
 158static inline void dm_consecutive_chunk_count_dec(struct dm_exception *e)
 159{
 160        BUG_ON(!dm_consecutive_chunk_count(e));
 161
 162        e->new_chunk -= (1ULL << DM_CHUNK_NUMBER_BITS);
 163}
 164
 165#  else
 166#    define DM_CHUNK_CONSECUTIVE_BITS 0
 167
 168static inline chunk_t dm_chunk_number(chunk_t chunk)
 169{
 170        return chunk;
 171}
 172
 173static inline unsigned dm_consecutive_chunk_count(struct dm_exception *e)
 174{
 175        return 0;
 176}
 177
 178static inline void dm_consecutive_chunk_count_inc(struct dm_exception *e)
 179{
 180}
 181
 182static inline void dm_consecutive_chunk_count_dec(struct dm_exception *e)
 183{
 184}
 185
 186#  endif
 187
 188/*
 189 * Return the number of sectors in the device.
 190 */
 191static inline sector_t get_dev_size(struct block_device *bdev)
 192{
 193        return i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
 194}
 195
 196static inline chunk_t sector_to_chunk(struct dm_exception_store *store,
 197                                      sector_t sector)
 198{
 199        return sector >> store->chunk_shift;
 200}
 201
 202int dm_exception_store_type_register(struct dm_exception_store_type *type);
 203int dm_exception_store_type_unregister(struct dm_exception_store_type *type);
 204
 205int dm_exception_store_set_chunk_size(struct dm_exception_store *store,
 206                                      unsigned chunk_size,
 207                                      char **error);
 208
 209int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
 210                              struct dm_snapshot *snap,
 211                              unsigned *args_used,
 212                              struct dm_exception_store **store);
 213void dm_exception_store_destroy(struct dm_exception_store *store);
 214
 215int dm_exception_store_init(void);
 216void dm_exception_store_exit(void);
 217
 218/*
 219 * Two exception store implementations.
 220 */
 221int dm_persistent_snapshot_init(void);
 222void dm_persistent_snapshot_exit(void);
 223
 224int dm_transient_snapshot_init(void);
 225void dm_transient_snapshot_exit(void);
 226
 227#endif /* _LINUX_DM_EXCEPTION_STORE */
 228
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.