2 * Copyright (C) 2011 Red Hat, Inc. All rights reserved.
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-disk.h"
9 #include "dm-space-map-metadata.h"
10 #include "dm-persistent-data-internal.h"
12 #include <linux/slab.h>
13 #include <linux/export.h>
14 #include <linux/device-mapper.h>
16 #define DM_MSG_PREFIX "transaction manager"
18 /*----------------------------------------------------------------*/
21 struct hlist_node hlist;
26 * It would be nice if we scaled with the size of transaction.
29 #define HASH_MASK (HASH_SIZE - 1)
31 struct dm_transaction_manager {
33 struct dm_transaction_manager *real;
35 struct dm_block_manager *bm;
36 struct dm_space_map *sm;
39 struct hlist_head buckets[HASH_SIZE];
42 /*----------------------------------------------------------------*/
44 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
46 unsigned bucket = dm_hash_block(b, HASH_MASK);
47 struct shadow_info *si;
53 hlist_for_each_entry(si, n, tm->buckets + bucket, hlist)
59 spin_unlock(&tm->lock);
65 * This can silently fail if there's no memory. We're ok with this since
66 * creating redundant shadows causes no harm.
68 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
71 struct shadow_info *si;
73 si = kmalloc(sizeof(*si), GFP_NOIO);
76 bucket = dm_hash_block(b, HASH_MASK);
79 hlist_add_head(&si->hlist, tm->buckets + bucket);
80 spin_unlock(&tm->lock);
84 static void wipe_shadow_table(struct dm_transaction_manager *tm)
86 struct shadow_info *si;
87 struct hlist_node *n, *tmp;
88 struct hlist_head *bucket;
92 for (i = 0; i < HASH_SIZE; i++) {
93 bucket = tm->buckets + i;
94 hlist_for_each_entry_safe(si, n, tmp, bucket, hlist)
97 INIT_HLIST_HEAD(bucket);
99 spin_unlock(&tm->lock);
102 /*----------------------------------------------------------------*/
104 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
105 struct dm_space_map *sm)
108 struct dm_transaction_manager *tm;
110 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
112 return ERR_PTR(-ENOMEM);
119 spin_lock_init(&tm->lock);
120 for (i = 0; i < HASH_SIZE; i++)
121 INIT_HLIST_HEAD(tm->buckets + i);
126 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
128 struct dm_transaction_manager *tm;
130 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
138 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
140 void dm_tm_destroy(struct dm_transaction_manager *tm)
144 EXPORT_SYMBOL_GPL(dm_tm_destroy);
146 int dm_tm_pre_commit(struct dm_transaction_manager *tm)
153 r = dm_sm_commit(tm->sm);
159 EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
161 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
166 wipe_shadow_table(tm);
168 return dm_bm_flush_and_unlock(tm->bm, root);
170 EXPORT_SYMBOL_GPL(dm_tm_commit);
172 int dm_tm_new_block(struct dm_transaction_manager *tm,
173 struct dm_block_validator *v,
174 struct dm_block **result)
177 dm_block_t new_block;
182 r = dm_sm_new_block(tm->sm, &new_block);
186 r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
188 dm_sm_dec_block(tm->sm, new_block);
193 * New blocks count as shadows in that they don't need to be
196 insert_shadow(tm, new_block);
201 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
202 struct dm_block_validator *v,
203 struct dm_block **result, int *inc_children)
208 struct dm_block *orig_block;
210 r = dm_sm_new_block(tm->sm, &new);
214 r = dm_bm_write_lock_zero(tm->bm, new, v, result);
218 r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
222 memcpy(dm_block_data(*result), dm_block_data(orig_block),
223 dm_bm_block_size(tm->bm));
225 r = dm_bm_unlock(orig_block);
229 r = dm_sm_get_count(tm->sm, orig, &count);
233 r = dm_sm_dec_block(tm->sm, orig);
237 *inc_children = count > 1;
242 dm_bm_unlock(*result);
244 dm_sm_dec_block(tm->sm, new);
249 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
250 struct dm_block_validator *v, struct dm_block **result,
253 int r, more_than_one;
258 if (is_shadow(tm, orig)) {
259 r = dm_sm_count_is_more_than_one(tm->sm, orig, &more_than_one);
263 if (!more_than_one) {
265 return dm_bm_write_lock(tm->bm, orig, v, result);
270 r = __shadow_block(tm, orig, v, result, inc_children);
274 insert_shadow(tm, dm_block_location(*result));
279 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
280 struct dm_block_validator *v,
281 struct dm_block **blk)
284 return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
286 return dm_bm_read_lock(tm->bm, b, v, blk);
289 int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
291 return dm_bm_unlock(b);
293 EXPORT_SYMBOL_GPL(dm_tm_unlock);
295 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
298 * The non-blocking clone doesn't support this.
300 BUG_ON(tm->is_clone);
302 dm_sm_inc_block(tm->sm, b);
304 EXPORT_SYMBOL_GPL(dm_tm_inc);
306 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
309 * The non-blocking clone doesn't support this.
311 BUG_ON(tm->is_clone);
313 dm_sm_dec_block(tm->sm, b);
316 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
322 return dm_sm_get_count(tm->sm, b, result);
325 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
330 /*----------------------------------------------------------------*/
332 static int dm_tm_create_internal(struct dm_block_manager *bm,
333 dm_block_t sb_location,
334 struct dm_block_validator *sb_validator,
335 size_t root_offset, size_t root_max_len,
336 struct dm_transaction_manager **tm,
337 struct dm_space_map **sm,
338 struct dm_block **sblock,
343 *sm = dm_sm_metadata_init();
347 *tm = dm_tm_create(bm, *sm);
354 r = dm_bm_write_lock_zero(dm_tm_get_bm(*tm), sb_location,
355 sb_validator, sblock);
357 DMERR("couldn't lock superblock");
361 r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm),
364 DMERR("couldn't create metadata space map");
369 r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
370 sb_validator, sblock);
372 DMERR("couldn't lock superblock");
376 r = dm_sm_metadata_open(*sm, *tm,
377 dm_block_data(*sblock) + root_offset,
380 DMERR("couldn't open metadata space map");
388 dm_tm_unlock(*tm, *sblock);
395 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
396 struct dm_block_validator *sb_validator,
397 struct dm_transaction_manager **tm,
398 struct dm_space_map **sm, struct dm_block **sblock)
400 return dm_tm_create_internal(bm, sb_location, sb_validator,
401 0, 0, tm, sm, sblock, 1);
403 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
405 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
406 struct dm_block_validator *sb_validator,
407 size_t root_offset, size_t root_max_len,
408 struct dm_transaction_manager **tm,
409 struct dm_space_map **sm, struct dm_block **sblock)
411 return dm_tm_create_internal(bm, sb_location, sb_validator, root_offset,
412 root_max_len, tm, sm, sblock, 0);
414 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);