Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 "dm.h" | |
ca3a931f | 13 | #include "dm-bio-list.h" |
1da177e4 | 14 | #include <linux/blkdev.h> |
ca3a931f | 15 | #include <linux/workqueue.h> |
1da177e4 LT |
16 | |
17 | struct exception_table { | |
18 | uint32_t hash_mask; | |
d74f81f8 | 19 | unsigned hash_shift; |
1da177e4 LT |
20 | struct list_head *table; |
21 | }; | |
22 | ||
23 | /* | |
24 | * The snapshot code deals with largish chunks of the disk at a | |
d74f81f8 | 25 | * time. Typically 32k - 512k. |
1da177e4 | 26 | */ |
1da177e4 LT |
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. | |
d74f81f8 MB |
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. | |
1da177e4 | 35 | */ |
028867ac | 36 | struct dm_snap_exception { |
1da177e4 LT |
37 | struct list_head hash_list; |
38 | ||
39 | chunk_t old_chunk; | |
40 | chunk_t new_chunk; | |
41 | }; | |
42 | ||
d74f81f8 MB |
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 | ||
1da177e4 LT |
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, | |
028867ac | 107 | struct dm_snap_exception *e); |
1da177e4 LT |
108 | |
109 | /* | |
110 | * Update the metadata with this exception. | |
111 | */ | |
112 | void (*commit_exception) (struct exception_store *store, | |
028867ac | 113 | struct dm_snap_exception *e, |
1da177e4 LT |
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 | ||
cd45daff MP |
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 | ||
1da177e4 LT |
137 | struct dm_snapshot { |
138 | struct rw_semaphore lock; | |
72727bad | 139 | struct dm_target *ti; |
1da177e4 LT |
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; | |
aa14edeb AK |
154 | |
155 | /* Origin writes don't trigger exceptions until this is set */ | |
156 | int active; | |
1da177e4 LT |
157 | |
158 | /* Used for display of table */ | |
159 | char type; | |
160 | ||
161 | /* The last percentage we notified */ | |
162 | int last_percent; | |
163 | ||
92e86812 MP |
164 | mempool_t *pending_pool; |
165 | ||
1da177e4 LT |
166 | struct exception_table pending; |
167 | struct exception_table complete; | |
168 | ||
ca3a931f AK |
169 | /* |
170 | * pe_lock protects all pending_exception operations and access | |
171 | * as well as the snapshot_bios list. | |
172 | */ | |
173 | spinlock_t pe_lock; | |
174 | ||
1da177e4 LT |
175 | /* The on disk metadata handler */ |
176 | struct exception_store store; | |
177 | ||
eb69aca5 | 178 | struct dm_kcopyd_client *kcopyd_client; |
ca3a931f AK |
179 | |
180 | /* Queue of snapshot writes for ksnapd to flush */ | |
181 | struct bio_list queued_bios; | |
182 | struct work_struct queued_bios_work; | |
cd45daff MP |
183 | |
184 | /* Chunks with outstanding reads */ | |
185 | mempool_t *tracked_chunk_pool; | |
186 | spinlock_t tracked_chunk_lock; | |
187 | struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE]; | |
1da177e4 LT |
188 | }; |
189 | ||
190 | /* | |
191 | * Used by the exception stores to load exceptions hen | |
192 | * initialising. | |
193 | */ | |
194 | int dm_add_exception(struct dm_snapshot *s, chunk_t old, chunk_t new); | |
195 | ||
196 | /* | |
197 | * Constructor and destructor for the default persistent | |
198 | * store. | |
199 | */ | |
4c7e3bf4 | 200 | int dm_create_persistent(struct exception_store *store); |
1da177e4 | 201 | |
4c7e3bf4 | 202 | int dm_create_transient(struct exception_store *store); |
1da177e4 LT |
203 | |
204 | /* | |
205 | * Return the number of sectors in the device. | |
206 | */ | |
207 | static inline sector_t get_dev_size(struct block_device *bdev) | |
208 | { | |
209 | return bdev->bd_inode->i_size >> SECTOR_SHIFT; | |
210 | } | |
211 | ||
212 | static inline chunk_t sector_to_chunk(struct dm_snapshot *s, sector_t sector) | |
213 | { | |
214 | return (sector & ~s->chunk_mask) >> s->chunk_shift; | |
215 | } | |
216 | ||
217 | static inline sector_t chunk_to_sector(struct dm_snapshot *s, chunk_t chunk) | |
218 | { | |
219 | return chunk << s->chunk_shift; | |
220 | } | |
221 | ||
222 | static inline int bdev_equal(struct block_device *lhs, struct block_device *rhs) | |
223 | { | |
224 | /* | |
225 | * There is only ever one instance of a particular block | |
226 | * device so we can compare pointers safely. | |
227 | */ | |
228 | return lhs == rhs; | |
229 | } | |
230 | ||
231 | #endif |