drivers/md: change module.h -> export.h in persistent-data/dm-*
[linux-2.6.git] / drivers / md / persistent-data / dm-transaction-manager.c
1 /*
2  * Copyright (C) 2011 Red Hat, Inc.
3  *
4  * This file is released under the GPL.
5  */
6 #include "dm-transaction-manager.h"
7 #include "dm-space-map.h"
8 #include "dm-space-map-checker.h"
9 #include "dm-space-map-disk.h"
10 #include "dm-space-map-metadata.h"
11 #include "dm-persistent-data-internal.h"
12
13 #include <linux/export.h>
14 #include <linux/slab.h>
15 #include <linux/device-mapper.h>
16
17 #define DM_MSG_PREFIX "transaction manager"
18
19 /*----------------------------------------------------------------*/
20
21 struct shadow_info {
22         struct hlist_node hlist;
23         dm_block_t where;
24 };
25
26 /*
27  * It would be nice if we scaled with the size of transaction.
28  */
29 #define HASH_SIZE 256
30 #define HASH_MASK (HASH_SIZE - 1)
31
32 struct dm_transaction_manager {
33         int is_clone;
34         struct dm_transaction_manager *real;
35
36         struct dm_block_manager *bm;
37         struct dm_space_map *sm;
38
39         spinlock_t lock;
40         struct hlist_head buckets[HASH_SIZE];
41 };
42
43 /*----------------------------------------------------------------*/
44
45 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
46 {
47         int r = 0;
48         unsigned bucket = dm_hash_block(b, HASH_MASK);
49         struct shadow_info *si;
50         struct hlist_node *n;
51
52         spin_lock(&tm->lock);
53         hlist_for_each_entry(si, n, tm->buckets + bucket, hlist)
54                 if (si->where == b) {
55                         r = 1;
56                         break;
57                 }
58         spin_unlock(&tm->lock);
59
60         return r;
61 }
62
63 /*
64  * This can silently fail if there's no memory.  We're ok with this since
65  * creating redundant shadows causes no harm.
66  */
67 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
68 {
69         unsigned bucket;
70         struct shadow_info *si;
71
72         si = kmalloc(sizeof(*si), GFP_NOIO);
73         if (si) {
74                 si->where = b;
75                 bucket = dm_hash_block(b, HASH_MASK);
76                 spin_lock(&tm->lock);
77                 hlist_add_head(&si->hlist, tm->buckets + bucket);
78                 spin_unlock(&tm->lock);
79         }
80 }
81
82 static void wipe_shadow_table(struct dm_transaction_manager *tm)
83 {
84         struct shadow_info *si;
85         struct hlist_node *n, *tmp;
86         struct hlist_head *bucket;
87         int i;
88
89         spin_lock(&tm->lock);
90         for (i = 0; i < HASH_SIZE; i++) {
91                 bucket = tm->buckets + i;
92                 hlist_for_each_entry_safe(si, n, tmp, bucket, hlist)
93                         kfree(si);
94
95                 INIT_HLIST_HEAD(bucket);
96         }
97
98         spin_unlock(&tm->lock);
99 }
100
101 /*----------------------------------------------------------------*/
102
103 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
104                                                    struct dm_space_map *sm)
105 {
106         int i;
107         struct dm_transaction_manager *tm;
108
109         tm = kmalloc(sizeof(*tm), GFP_KERNEL);
110         if (!tm)
111                 return ERR_PTR(-ENOMEM);
112
113         tm->is_clone = 0;
114         tm->real = NULL;
115         tm->bm = bm;
116         tm->sm = sm;
117
118         spin_lock_init(&tm->lock);
119         for (i = 0; i < HASH_SIZE; i++)
120                 INIT_HLIST_HEAD(tm->buckets + i);
121
122         return tm;
123 }
124
125 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
126 {
127         struct dm_transaction_manager *tm;
128
129         tm = kmalloc(sizeof(*tm), GFP_KERNEL);
130         if (tm) {
131                 tm->is_clone = 1;
132                 tm->real = real;
133         }
134
135         return tm;
136 }
137 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
138
139 void dm_tm_destroy(struct dm_transaction_manager *tm)
140 {
141         kfree(tm);
142 }
143 EXPORT_SYMBOL_GPL(dm_tm_destroy);
144
145 int dm_tm_pre_commit(struct dm_transaction_manager *tm)
146 {
147         int r;
148
149         if (tm->is_clone)
150                 return -EWOULDBLOCK;
151
152         r = dm_sm_commit(tm->sm);
153         if (r < 0)
154                 return r;
155
156         return 0;
157 }
158 EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
159
160 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
161 {
162         if (tm->is_clone)
163                 return -EWOULDBLOCK;
164
165         wipe_shadow_table(tm);
166
167         return dm_bm_flush_and_unlock(tm->bm, root);
168 }
169 EXPORT_SYMBOL_GPL(dm_tm_commit);
170
171 int dm_tm_new_block(struct dm_transaction_manager *tm,
172                     struct dm_block_validator *v,
173                     struct dm_block **result)
174 {
175         int r;
176         dm_block_t new_block;
177
178         if (tm->is_clone)
179                 return -EWOULDBLOCK;
180
181         r = dm_sm_new_block(tm->sm, &new_block);
182         if (r < 0)
183                 return r;
184
185         r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
186         if (r < 0) {
187                 dm_sm_dec_block(tm->sm, new_block);
188                 return r;
189         }
190
191         /*
192          * New blocks count as shadows in that they don't need to be
193          * shadowed again.
194          */
195         insert_shadow(tm, new_block);
196
197         return 0;
198 }
199
200 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
201                           struct dm_block_validator *v,
202                           struct dm_block **result)
203 {
204         int r;
205         dm_block_t new;
206         struct dm_block *orig_block;
207
208         r = dm_sm_new_block(tm->sm, &new);
209         if (r < 0)
210                 return r;
211
212         r = dm_sm_dec_block(tm->sm, orig);
213         if (r < 0)
214                 return r;
215
216         r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
217         if (r < 0)
218                 return r;
219
220         r = dm_bm_unlock_move(orig_block, new);
221         if (r < 0) {
222                 dm_bm_unlock(orig_block);
223                 return r;
224         }
225
226         return dm_bm_write_lock(tm->bm, new, v, result);
227 }
228
229 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
230                        struct dm_block_validator *v, struct dm_block **result,
231                        int *inc_children)
232 {
233         int r;
234
235         if (tm->is_clone)
236                 return -EWOULDBLOCK;
237
238         r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
239         if (r < 0)
240                 return r;
241
242         if (is_shadow(tm, orig) && !*inc_children)
243                 return dm_bm_write_lock(tm->bm, orig, v, result);
244
245         r = __shadow_block(tm, orig, v, result);
246         if (r < 0)
247                 return r;
248         insert_shadow(tm, dm_block_location(*result));
249
250         return r;
251 }
252
253 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
254                     struct dm_block_validator *v,
255                     struct dm_block **blk)
256 {
257         if (tm->is_clone)
258                 return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
259
260         return dm_bm_read_lock(tm->bm, b, v, blk);
261 }
262
263 int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
264 {
265         return dm_bm_unlock(b);
266 }
267 EXPORT_SYMBOL_GPL(dm_tm_unlock);
268
269 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
270 {
271         /*
272          * The non-blocking clone doesn't support this.
273          */
274         BUG_ON(tm->is_clone);
275
276         dm_sm_inc_block(tm->sm, b);
277 }
278 EXPORT_SYMBOL_GPL(dm_tm_inc);
279
280 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
281 {
282         /*
283          * The non-blocking clone doesn't support this.
284          */
285         BUG_ON(tm->is_clone);
286
287         dm_sm_dec_block(tm->sm, b);
288 }
289 EXPORT_SYMBOL_GPL(dm_tm_dec);
290
291 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
292               uint32_t *result)
293 {
294         if (tm->is_clone)
295                 return -EWOULDBLOCK;
296
297         return dm_sm_get_count(tm->sm, b, result);
298 }
299
300 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
301 {
302         return tm->bm;
303 }
304
305 /*----------------------------------------------------------------*/
306
307 static int dm_tm_create_internal(struct dm_block_manager *bm,
308                                  dm_block_t sb_location,
309                                  struct dm_block_validator *sb_validator,
310                                  size_t root_offset, size_t root_max_len,
311                                  struct dm_transaction_manager **tm,
312                                  struct dm_space_map **sm,
313                                  struct dm_block **sblock,
314                                  int create)
315 {
316         int r;
317         struct dm_space_map *inner;
318
319         inner = dm_sm_metadata_init();
320         if (IS_ERR(inner))
321                 return PTR_ERR(inner);
322
323         *tm = dm_tm_create(bm, inner);
324         if (IS_ERR(*tm)) {
325                 dm_sm_destroy(inner);
326                 return PTR_ERR(*tm);
327         }
328
329         if (create) {
330                 r = dm_bm_write_lock_zero(dm_tm_get_bm(*tm), sb_location,
331                                           sb_validator, sblock);
332                 if (r < 0) {
333                         DMERR("couldn't lock superblock");
334                         goto bad1;
335                 }
336
337                 r = dm_sm_metadata_create(inner, *tm, dm_bm_nr_blocks(bm),
338                                           sb_location);
339                 if (r) {
340                         DMERR("couldn't create metadata space map");
341                         goto bad2;
342                 }
343
344                 *sm = dm_sm_checker_create(inner);
345                 if (!*sm)
346                         goto bad2;
347
348         } else {
349                 r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
350                                      sb_validator, sblock);
351                 if (r < 0) {
352                         DMERR("couldn't lock superblock");
353                         goto bad1;
354                 }
355
356                 r = dm_sm_metadata_open(inner, *tm,
357                                         dm_block_data(*sblock) + root_offset,
358                                         root_max_len);
359                 if (r) {
360                         DMERR("couldn't open metadata space map");
361                         goto bad2;
362                 }
363
364                 *sm = dm_sm_checker_create(inner);
365                 if (!*sm)
366                         goto bad2;
367         }
368
369         return 0;
370
371 bad2:
372         dm_tm_unlock(*tm, *sblock);
373 bad1:
374         dm_tm_destroy(*tm);
375         dm_sm_destroy(inner);
376         return r;
377 }
378
379 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
380                          struct dm_block_validator *sb_validator,
381                          struct dm_transaction_manager **tm,
382                          struct dm_space_map **sm, struct dm_block **sblock)
383 {
384         return dm_tm_create_internal(bm, sb_location, sb_validator,
385                                      0, 0, tm, sm, sblock, 1);
386 }
387 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
388
389 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
390                        struct dm_block_validator *sb_validator,
391                        size_t root_offset, size_t root_max_len,
392                        struct dm_transaction_manager **tm,
393                        struct dm_space_map **sm, struct dm_block **sblock)
394 {
395         return dm_tm_create_internal(bm, sb_location, sb_validator, root_offset,
396                                      root_max_len, tm, sm, sblock, 0);
397 }
398 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
399
400 /*----------------------------------------------------------------*/