drivers/md/dm-snap.h

   1 /*
   2  * dm-snapshot.c
   3  *
   4  * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
   5  *
   6  * This file is released under the GPL.
   7  */
   8
   9 #ifndef DM_SNAPSHOT_H
  10 #define DM_SNAPSHOT_H
  11
  12 #include <linux/device-mapper.h>
  13 #include "dm-bio-list.h"
  14 #include <linux/blkdev.h>
  15 #include <linux/workqueue.h>
  16
  17 struct exception_table {
  18         uint32_t hash_mask;
  19         unsigned hash_shift;
  20         struct list_head *table;
  21 };
  22
  23 /*
  24  * The snapshot code deals with largish chunks of the disk at a
  25  * time. Typically 32k - 512k.
  26  */
  27 typedef sector_t chunk_t;
  28
  29 /*
  30  * An exception is used where an old chunk of data has been
  31  * replaced by a new one.
  32  * If chunk_t is 64 bits in size, the top 8 bits of new_chunk hold the number
  33  * of chunks that follow contiguously.  Remaining bits hold the number of the
  34  * chunk within the device.
  35  */
  36 struct dm_snap_exception {
  37         struct list_head hash_list;
  38
  39         chunk_t old_chunk;
  40         chunk_t new_chunk;
  41 };
  42
  43 /*
  44  * Funtions to manipulate consecutive chunks
  45  */
  46 #  if defined(CONFIG_LBD) || (BITS_PER_LONG == 64)
  47 #    define DM_CHUNK_CONSECUTIVE_BITS 8
  48 #    define DM_CHUNK_NUMBER_BITS 56
  49
  50 static inline chunk_t dm_chunk_number(chunk_t chunk)
  51 {
  52         return chunk & (chunk_t)((1ULL << DM_CHUNK_NUMBER_BITS) - 1ULL);
  53 }
  54
  55 static inline unsigned dm_consecutive_chunk_count(struct dm_snap_exception *e)
  56 {
  57         return e->new_chunk >> DM_CHUNK_NUMBER_BITS;
  58 }
  59
  60 static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
  61 {
  62         e->new_chunk += (1ULL << DM_CHUNK_NUMBER_BITS);
  63
  64         BUG_ON(!dm_consecutive_chunk_count(e));
  65 }
  66
  67 #  else
  68 #    define DM_CHUNK_CONSECUTIVE_BITS 0
  69
  70 static inline chunk_t dm_chunk_number(chunk_t chunk)
  71 {
  72         return chunk;
  73 }
  74
  75 static inline unsigned dm_consecutive_chunk_count(struct dm_snap_exception *e)
  76 {
  77         return 0;
  78 }
  79
  80 static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
  81 {
  82 }
  83
  84 #  endif
  85
  86 /*
  87  * Abstraction to handle the meta/layout of exception stores (the
  88  * COW device).
  89  */
  90 struct exception_store {
  91
  92         /*
  93          * Destroys this object when you've finished with it.
  94          */
  95         void (*destroy) (struct exception_store *store);
  96
  97         /*
  98          * The target shouldn't read the COW device until this is
  99          * called.
 100          */
 101         int (*read_metadata) (struct exception_store *store);
 102
 103         /*
 104          * Find somewhere to store the next exception.
 105          */
 106         int (*prepare_exception) (struct exception_store *store,
 107                                   struct dm_snap_exception *e);
 108
 109         /*
 110          * Update the metadata with this exception.
 111          */
 112         void (*commit_exception) (struct exception_store *store,
 113                                   struct dm_snap_exception *e,
 114                                   void (*callback) (void *, int success),
 115                                   void *callback_context);
 116
 117         /*
 118          * The snapshot is invalid, note this in the metadata.
 119          */
 120         void (*drop_snapshot) (struct exception_store *store);
 121
 122         /*
 123          * Return how full the snapshot is.
 124          */
 125         void (*fraction_full) (struct exception_store *store,
 126                                sector_t *numerator,
 127                                sector_t *denominator);
 128
 129         struct dm_snapshot *snap;
 130         void *context;
 131 };
 132
 133 #define DM_TRACKED_CHUNK_HASH_SIZE      16
 134 #define DM_TRACKED_CHUNK_HASH(x)        ((unsigned long)(x) & \
 135                                          (DM_TRACKED_CHUNK_HASH_SIZE - 1))
 136
 137 struct dm_snapshot {
 138         struct rw_semaphore lock;
 139         struct dm_target *ti;
 140
 141         struct dm_dev *origin;
 142         struct dm_dev *cow;
 143
 144         /* List of snapshots per Origin */
 145         struct list_head list;
 146
 147         /* Size of data blocks saved - must be a power of 2 */
 148         chunk_t chunk_size;
 149         chunk_t chunk_mask;
 150         chunk_t chunk_shift;
 151
 152         /* You can't use a snapshot if this is 0 (e.g. if full) */
 153         int valid;
 154
 155         /* Origin writes don't trigger exceptions until this is set */
 156         int active;
 157
 158         /* Used for display of table */
 159         char type;
 160
 161         mempool_t *pending_pool;
 162
 163         struct exception_table pending;
 164         struct exception_table complete;
 165
 166         /*
 167          * pe_lock protects all pending_exception operations and access
 168          * as well as the snapshot_bios list.
 169          */
 170         spinlock_t pe_lock;
 171
 172         /* The on disk metadata handler */
 173         struct exception_store store;
 174
 175         struct dm_kcopyd_client *kcopyd_client;
 176
 177         /* Queue of snapshot writes for ksnapd to flush */
 178         struct bio_list queued_bios;
 179         struct work_struct queued_bios_work;
 180
 181         /* Chunks with outstanding reads */
 182         mempool_t *tracked_chunk_pool;
 183         spinlock_t tracked_chunk_lock;
 184         struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE];
 185 };
 186
 187 /*
 188  * Used by the exception stores to load exceptions hen
 189  * initialising.
 190  */
 191 int dm_add_exception(struct dm_snapshot *s, chunk_t old, chunk_t new);
 192
 193 /*
 194  * Constructor and destructor for the default persistent
 195  * store.
 196  */
 197 int dm_create_persistent(struct exception_store *store);
 198
 199 int dm_create_transient(struct exception_store *store);
 200
 201 /*
 202  * Return the number of sectors in the device.
 203  */
 204 static inline sector_t get_dev_size(struct block_device *bdev)
 205 {
 206         return bdev->bd_inode->i_size >> SECTOR_SHIFT;
 207 }
 208
 209 static inline chunk_t sector_to_chunk(struct dm_snapshot *s, sector_t sector)
 210 {
 211         return (sector & ~s->chunk_mask) >> s->chunk_shift;
 212 }
 213
 214 static inline sector_t chunk_to_sector(struct dm_snapshot *s, chunk_t chunk)
 215 {
 216         return chunk << s->chunk_shift;
 217 }
 218
 219 static inline int bdev_equal(struct block_device *lhs, struct block_device *rhs)
 220 {
 221         /*
 222          * There is only ever one instance of a particular block
 223          * device so we can compare pointers safely.
 224          */
 225         return lhs == rhs;
 226 }
 227
 228 #endif