2 * Copyright (C) 2011 Red Hat, Inc.
4 * This file is released under the GPL.
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"
13 #include <linux/export.h>
14 #include <linux/slab.h>
15 #include <linux/device-mapper.h>
17 #define DM_MSG_PREFIX "transaction manager"
19 /*----------------------------------------------------------------*/
22 struct hlist_node hlist;
27 * It would be nice if we scaled with the size of transaction.
30 #define HASH_MASK (HASH_SIZE - 1)
32 struct dm_transaction_manager {
34 struct dm_transaction_manager *real;
36 struct dm_block_manager *bm;
37 struct dm_space_map *sm;
40 struct hlist_head buckets[HASH_SIZE];
43 /*----------------------------------------------------------------*/
45 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
48 unsigned bucket = dm_hash_block(b, HASH_MASK);
49 struct shadow_info *si;
53 hlist_for_each_entry(si, n, tm->buckets + bucket, hlist)
58 spin_unlock(&tm->lock);
64 * This can silently fail if there's no memory. We're ok with this since
65 * creating redundant shadows causes no harm.
67 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
70 struct shadow_info *si;
72 si = kmalloc(sizeof(*si), GFP_NOIO);
75 bucket = dm_hash_block(b, HASH_MASK);
77 hlist_add_head(&si->hlist, tm->buckets + bucket);
78 spin_unlock(&tm->lock);
82 static void wipe_shadow_table(struct dm_transaction_manager *tm)
84 struct shadow_info *si;
85 struct hlist_node *n, *tmp;
86 struct hlist_head *bucket;
90 for (i = 0; i < HASH_SIZE; i++) {
91 bucket = tm->buckets + i;
92 hlist_for_each_entry_safe(si, n, tmp, bucket, hlist)
95 INIT_HLIST_HEAD(bucket);
98 spin_unlock(&tm->lock);
101 /*----------------------------------------------------------------*/
103 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
104 struct dm_space_map *sm)
107 struct dm_transaction_manager *tm;
109 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
111 return ERR_PTR(-ENOMEM);
118 spin_lock_init(&tm->lock);
119 for (i = 0; i < HASH_SIZE; i++)
120 INIT_HLIST_HEAD(tm->buckets + i);
125 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
127 struct dm_transaction_manager *tm;
129 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
137 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
139 void dm_tm_destroy(struct dm_transaction_manager *tm)
143 EXPORT_SYMBOL_GPL(dm_tm_destroy);
145 int dm_tm_pre_commit(struct dm_transaction_manager *tm)
152 r = dm_sm_commit(tm->sm);
158 EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
160 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
165 wipe_shadow_table(tm);
167 return dm_bm_flush_and_unlock(tm->bm, root);
169 EXPORT_SYMBOL_GPL(dm_tm_commit);
171 int dm_tm_new_block(struct dm_transaction_manager *tm,
172 struct dm_block_validator *v,
173 struct dm_block **result)
176 dm_block_t new_block;
181 r = dm_sm_new_block(tm->sm, &new_block);
185 r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
187 dm_sm_dec_block(tm->sm, new_block);
192 * New blocks count as shadows in that they don't need to be
195 insert_shadow(tm, new_block);
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)
206 struct dm_block *orig_block;
208 r = dm_sm_new_block(tm->sm, &new);
212 r = dm_sm_dec_block(tm->sm, orig);
216 r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
220 r = dm_bm_unlock_move(orig_block, new);
222 dm_bm_unlock(orig_block);
226 return dm_bm_write_lock(tm->bm, new, v, result);
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,
238 r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
242 if (is_shadow(tm, orig) && !*inc_children)
243 return dm_bm_write_lock(tm->bm, orig, v, result);
245 r = __shadow_block(tm, orig, v, result);
248 insert_shadow(tm, dm_block_location(*result));
252 EXPORT_SYMBOL_GPL(dm_tm_shadow_block);
254 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
255 struct dm_block_validator *v,
256 struct dm_block **blk)
259 return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
261 return dm_bm_read_lock(tm->bm, b, v, blk);
263 EXPORT_SYMBOL_GPL(dm_tm_read_lock);
265 int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
267 return dm_bm_unlock(b);
269 EXPORT_SYMBOL_GPL(dm_tm_unlock);
271 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
274 * The non-blocking clone doesn't support this.
276 BUG_ON(tm->is_clone);
278 dm_sm_inc_block(tm->sm, b);
280 EXPORT_SYMBOL_GPL(dm_tm_inc);
282 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
285 * The non-blocking clone doesn't support this.
287 BUG_ON(tm->is_clone);
289 dm_sm_dec_block(tm->sm, b);
291 EXPORT_SYMBOL_GPL(dm_tm_dec);
293 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
299 return dm_sm_get_count(tm->sm, b, result);
302 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
307 /*----------------------------------------------------------------*/
309 static int dm_tm_create_internal(struct dm_block_manager *bm,
310 dm_block_t sb_location,
311 struct dm_block_validator *sb_validator,
312 size_t root_offset, size_t root_max_len,
313 struct dm_transaction_manager **tm,
314 struct dm_space_map **sm,
315 struct dm_block **sblock,
319 struct dm_space_map *inner;
321 inner = dm_sm_metadata_init();
323 return PTR_ERR(inner);
325 *tm = dm_tm_create(bm, inner);
327 dm_sm_destroy(inner);
332 r = dm_bm_write_lock_zero(dm_tm_get_bm(*tm), sb_location,
333 sb_validator, sblock);
335 DMERR("couldn't lock superblock");
339 r = dm_sm_metadata_create(inner, *tm, dm_bm_nr_blocks(bm),
342 DMERR("couldn't create metadata space map");
346 *sm = dm_sm_checker_create(inner);
351 r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
352 sb_validator, sblock);
354 DMERR("couldn't lock superblock");
358 r = dm_sm_metadata_open(inner, *tm,
359 dm_block_data(*sblock) + root_offset,
362 DMERR("couldn't open metadata space map");
366 *sm = dm_sm_checker_create(inner);
374 dm_tm_unlock(*tm, *sblock);
377 dm_sm_destroy(inner);
381 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
382 struct dm_block_validator *sb_validator,
383 struct dm_transaction_manager **tm,
384 struct dm_space_map **sm, struct dm_block **sblock)
386 return dm_tm_create_internal(bm, sb_location, sb_validator,
387 0, 0, tm, sm, sblock, 1);
389 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
391 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
392 struct dm_block_validator *sb_validator,
393 size_t root_offset, size_t root_max_len,
394 struct dm_transaction_manager **tm,
395 struct dm_space_map **sm, struct dm_block **sblock)
397 return dm_tm_create_internal(bm, sb_location, sb_validator, root_offset,
398 root_max_len, tm, sm, sblock, 0);
400 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
402 /*----------------------------------------------------------------*/