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-disk.h"
9 #include "dm-space-map-metadata.h"
10 #include "dm-persistent-data-internal.h"
12 #include <linux/export.h>
13 #include <linux/slab.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.
28 #define DM_HASH_SIZE 256
29 #define DM_HASH_MASK (DM_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[DM_HASH_SIZE];
42 /*----------------------------------------------------------------*/
44 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
47 unsigned bucket = dm_hash_block(b, DM_HASH_MASK);
48 struct shadow_info *si;
51 hlist_for_each_entry(si, tm->buckets + bucket, hlist)
56 spin_unlock(&tm->lock);
62 * This can silently fail if there's no memory. We're ok with this since
63 * creating redundant shadows causes no harm.
65 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
68 struct shadow_info *si;
70 si = kmalloc(sizeof(*si), GFP_NOIO);
73 bucket = dm_hash_block(b, DM_HASH_MASK);
75 hlist_add_head(&si->hlist, tm->buckets + bucket);
76 spin_unlock(&tm->lock);
80 static void wipe_shadow_table(struct dm_transaction_manager *tm)
82 struct shadow_info *si;
83 struct hlist_node *tmp;
84 struct hlist_head *bucket;
88 for (i = 0; i < DM_HASH_SIZE; i++) {
89 bucket = tm->buckets + i;
90 hlist_for_each_entry_safe(si, tmp, bucket, hlist)
93 INIT_HLIST_HEAD(bucket);
96 spin_unlock(&tm->lock);
99 /*----------------------------------------------------------------*/
101 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
102 struct dm_space_map *sm)
105 struct dm_transaction_manager *tm;
107 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
109 return ERR_PTR(-ENOMEM);
116 spin_lock_init(&tm->lock);
117 for (i = 0; i < DM_HASH_SIZE; i++)
118 INIT_HLIST_HEAD(tm->buckets + i);
123 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
125 struct dm_transaction_manager *tm;
127 tm = kmalloc(sizeof(*tm), GFP_KERNEL);
135 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
137 void dm_tm_destroy(struct dm_transaction_manager *tm)
140 wipe_shadow_table(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);
157 return dm_bm_flush(tm->bm);
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);
169 return dm_bm_flush(tm->bm);
171 EXPORT_SYMBOL_GPL(dm_tm_commit);
173 int dm_tm_new_block(struct dm_transaction_manager *tm,
174 struct dm_block_validator *v,
175 struct dm_block **result)
178 dm_block_t new_block;
183 r = dm_sm_new_block(tm->sm, &new_block);
187 r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
189 dm_sm_dec_block(tm->sm, new_block);
194 * New blocks count as shadows in that they don't need to be
197 insert_shadow(tm, new_block);
202 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
203 struct dm_block_validator *v,
204 struct dm_block **result)
208 struct dm_block *orig_block;
210 r = dm_sm_new_block(tm->sm, &new);
214 r = dm_sm_dec_block(tm->sm, orig);
218 r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
223 * It would be tempting to use dm_bm_unlock_move here, but some
224 * code, such as the space maps, keeps using the old data structures
225 * secure in the knowledge they won't be changed until the next
226 * transaction. Using unlock_move would force a synchronous read
227 * since the old block would no longer be in the cache.
229 r = dm_bm_write_lock_zero(tm->bm, new, v, result);
231 dm_bm_unlock(orig_block);
235 memcpy(dm_block_data(*result), dm_block_data(orig_block),
236 dm_bm_block_size(tm->bm));
238 dm_bm_unlock(orig_block);
242 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
243 struct dm_block_validator *v, struct dm_block **result,
251 r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
255 if (is_shadow(tm, orig) && !*inc_children)
256 return dm_bm_write_lock(tm->bm, orig, v, result);
258 r = __shadow_block(tm, orig, v, result);
261 insert_shadow(tm, dm_block_location(*result));
265 EXPORT_SYMBOL_GPL(dm_tm_shadow_block);
267 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
268 struct dm_block_validator *v,
269 struct dm_block **blk)
272 return dm_bm_read_try_lock(tm->real->bm, b, v, blk);
274 return dm_bm_read_lock(tm->bm, b, v, blk);
276 EXPORT_SYMBOL_GPL(dm_tm_read_lock);
278 int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
280 return dm_bm_unlock(b);
282 EXPORT_SYMBOL_GPL(dm_tm_unlock);
284 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
287 * The non-blocking clone doesn't support this.
289 BUG_ON(tm->is_clone);
291 dm_sm_inc_block(tm->sm, b);
293 EXPORT_SYMBOL_GPL(dm_tm_inc);
295 void dm_tm_dec(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_dec_block(tm->sm, b);
304 EXPORT_SYMBOL_GPL(dm_tm_dec);
306 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
312 return dm_sm_get_count(tm->sm, b, result);
315 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
320 /*----------------------------------------------------------------*/
322 static int dm_tm_create_internal(struct dm_block_manager *bm,
323 dm_block_t sb_location,
324 struct dm_transaction_manager **tm,
325 struct dm_space_map **sm,
327 void *sm_root, size_t sm_len)
331 *sm = dm_sm_metadata_init();
335 *tm = dm_tm_create(bm, *sm);
342 r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm),
345 DMERR("couldn't create metadata space map");
350 r = dm_sm_metadata_open(*sm, *tm, sm_root, sm_len);
352 DMERR("couldn't open metadata space map");
365 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
366 struct dm_transaction_manager **tm,
367 struct dm_space_map **sm)
369 return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0);
371 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
373 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
374 void *sm_root, size_t root_len,
375 struct dm_transaction_manager **tm,
376 struct dm_space_map **sm)
378 return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len);
380 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
382 /*----------------------------------------------------------------*/