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-disk.h"
9 #include "dm-space-map-metadata.h"
10 #include "dm-persistent-data-internal.h"
11 
12 #include <linux/export.h>
13 #include <linux/mutex.h>
14 #include <linux/hash.h>
15 #include <linux/slab.h>
16 #include <linux/device-mapper.h>
17 
18 #define DM_MSG_PREFIX "transaction manager"
19 
20 /*----------------------------------------------------------------*/
21 
22 #define PREFETCH_SIZE 128
23 #define PREFETCH_BITS 7
24 #define PREFETCH_SENTINEL ((dm_block_t) -1ULL)
25 
26 struct prefetch_set {
27 	struct mutex lock;
28 	dm_block_t blocks[PREFETCH_SIZE];
29 };
30 
prefetch_hash(dm_block_t b)31 static unsigned prefetch_hash(dm_block_t b)
32 {
33 	return hash_64(b, PREFETCH_BITS);
34 }
35 
prefetch_wipe(struct prefetch_set * p)36 static void prefetch_wipe(struct prefetch_set *p)
37 {
38 	unsigned i;
39 	for (i = 0; i < PREFETCH_SIZE; i++)
40 		p->blocks[i] = PREFETCH_SENTINEL;
41 }
42 
prefetch_init(struct prefetch_set * p)43 static void prefetch_init(struct prefetch_set *p)
44 {
45 	mutex_init(&p->lock);
46 	prefetch_wipe(p);
47 }
48 
prefetch_add(struct prefetch_set * p,dm_block_t b)49 static void prefetch_add(struct prefetch_set *p, dm_block_t b)
50 {
51 	unsigned h = prefetch_hash(b);
52 
53 	mutex_lock(&p->lock);
54 	if (p->blocks[h] == PREFETCH_SENTINEL)
55 		p->blocks[h] = b;
56 
57 	mutex_unlock(&p->lock);
58 }
59 
prefetch_issue(struct prefetch_set * p,struct dm_block_manager * bm)60 static void prefetch_issue(struct prefetch_set *p, struct dm_block_manager *bm)
61 {
62 	unsigned i;
63 
64 	mutex_lock(&p->lock);
65 
66 	for (i = 0; i < PREFETCH_SIZE; i++)
67 		if (p->blocks[i] != PREFETCH_SENTINEL) {
68 			dm_bm_prefetch(bm, p->blocks[i]);
69 			p->blocks[i] = PREFETCH_SENTINEL;
70 		}
71 
72 	mutex_unlock(&p->lock);
73 }
74 
75 /*----------------------------------------------------------------*/
76 
77 struct shadow_info {
78 	struct hlist_node hlist;
79 	dm_block_t where;
80 };
81 
82 /*
83  * It would be nice if we scaled with the size of transaction.
84  */
85 #define DM_HASH_SIZE 256
86 #define DM_HASH_MASK (DM_HASH_SIZE - 1)
87 
88 struct dm_transaction_manager {
89 	int is_clone;
90 	struct dm_transaction_manager *real;
91 
92 	struct dm_block_manager *bm;
93 	struct dm_space_map *sm;
94 
95 	spinlock_t lock;
96 	struct hlist_head buckets[DM_HASH_SIZE];
97 
98 	struct prefetch_set prefetches;
99 };
100 
101 /*----------------------------------------------------------------*/
102 
is_shadow(struct dm_transaction_manager * tm,dm_block_t b)103 static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
104 {
105 	int r = 0;
106 	unsigned bucket = dm_hash_block(b, DM_HASH_MASK);
107 	struct shadow_info *si;
108 
109 	spin_lock(&tm->lock);
110 	hlist_for_each_entry(si, tm->buckets + bucket, hlist)
111 		if (si->where == b) {
112 			r = 1;
113 			break;
114 		}
115 	spin_unlock(&tm->lock);
116 
117 	return r;
118 }
119 
120 /*
121  * This can silently fail if there's no memory.  We're ok with this since
122  * creating redundant shadows causes no harm.
123  */
insert_shadow(struct dm_transaction_manager * tm,dm_block_t b)124 static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
125 {
126 	unsigned bucket;
127 	struct shadow_info *si;
128 
129 	si = kmalloc(sizeof(*si), GFP_NOIO);
130 	if (si) {
131 		si->where = b;
132 		bucket = dm_hash_block(b, DM_HASH_MASK);
133 		spin_lock(&tm->lock);
134 		hlist_add_head(&si->hlist, tm->buckets + bucket);
135 		spin_unlock(&tm->lock);
136 	}
137 }
138 
wipe_shadow_table(struct dm_transaction_manager * tm)139 static void wipe_shadow_table(struct dm_transaction_manager *tm)
140 {
141 	struct shadow_info *si;
142 	struct hlist_node *tmp;
143 	struct hlist_head *bucket;
144 	int i;
145 
146 	spin_lock(&tm->lock);
147 	for (i = 0; i < DM_HASH_SIZE; i++) {
148 		bucket = tm->buckets + i;
149 		hlist_for_each_entry_safe(si, tmp, bucket, hlist)
150 			kfree(si);
151 
152 		INIT_HLIST_HEAD(bucket);
153 	}
154 
155 	spin_unlock(&tm->lock);
156 }
157 
158 /*----------------------------------------------------------------*/
159 
dm_tm_create(struct dm_block_manager * bm,struct dm_space_map * sm)160 static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
161 						   struct dm_space_map *sm)
162 {
163 	int i;
164 	struct dm_transaction_manager *tm;
165 
166 	tm = kmalloc(sizeof(*tm), GFP_KERNEL);
167 	if (!tm)
168 		return ERR_PTR(-ENOMEM);
169 
170 	tm->is_clone = 0;
171 	tm->real = NULL;
172 	tm->bm = bm;
173 	tm->sm = sm;
174 
175 	spin_lock_init(&tm->lock);
176 	for (i = 0; i < DM_HASH_SIZE; i++)
177 		INIT_HLIST_HEAD(tm->buckets + i);
178 
179 	prefetch_init(&tm->prefetches);
180 
181 	return tm;
182 }
183 
dm_tm_create_non_blocking_clone(struct dm_transaction_manager * real)184 struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
185 {
186 	struct dm_transaction_manager *tm;
187 
188 	tm = kmalloc(sizeof(*tm), GFP_KERNEL);
189 	if (tm) {
190 		tm->is_clone = 1;
191 		tm->real = real;
192 	}
193 
194 	return tm;
195 }
196 EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
197 
dm_tm_destroy(struct dm_transaction_manager * tm)198 void dm_tm_destroy(struct dm_transaction_manager *tm)
199 {
200 	if (!tm->is_clone)
201 		wipe_shadow_table(tm);
202 
203 	kfree(tm);
204 }
205 EXPORT_SYMBOL_GPL(dm_tm_destroy);
206 
dm_tm_pre_commit(struct dm_transaction_manager * tm)207 int dm_tm_pre_commit(struct dm_transaction_manager *tm)
208 {
209 	int r;
210 
211 	if (tm->is_clone)
212 		return -EWOULDBLOCK;
213 
214 	r = dm_sm_commit(tm->sm);
215 	if (r < 0)
216 		return r;
217 
218 	return dm_bm_flush(tm->bm);
219 }
220 EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
221 
dm_tm_commit(struct dm_transaction_manager * tm,struct dm_block * root)222 int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
223 {
224 	if (tm->is_clone)
225 		return -EWOULDBLOCK;
226 
227 	wipe_shadow_table(tm);
228 	dm_bm_unlock(root);
229 
230 	return dm_bm_flush(tm->bm);
231 }
232 EXPORT_SYMBOL_GPL(dm_tm_commit);
233 
dm_tm_new_block(struct dm_transaction_manager * tm,struct dm_block_validator * v,struct dm_block ** result)234 int dm_tm_new_block(struct dm_transaction_manager *tm,
235 		    struct dm_block_validator *v,
236 		    struct dm_block **result)
237 {
238 	int r;
239 	dm_block_t new_block;
240 
241 	if (tm->is_clone)
242 		return -EWOULDBLOCK;
243 
244 	r = dm_sm_new_block(tm->sm, &new_block);
245 	if (r < 0)
246 		return r;
247 
248 	r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
249 	if (r < 0) {
250 		dm_sm_dec_block(tm->sm, new_block);
251 		return r;
252 	}
253 
254 	/*
255 	 * New blocks count as shadows in that they don't need to be
256 	 * shadowed again.
257 	 */
258 	insert_shadow(tm, new_block);
259 
260 	return 0;
261 }
262 
__shadow_block(struct dm_transaction_manager * tm,dm_block_t orig,struct dm_block_validator * v,struct dm_block ** result)263 static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
264 			  struct dm_block_validator *v,
265 			  struct dm_block **result)
266 {
267 	int r;
268 	dm_block_t new;
269 	struct dm_block *orig_block;
270 
271 	r = dm_sm_new_block(tm->sm, &new);
272 	if (r < 0)
273 		return r;
274 
275 	r = dm_sm_dec_block(tm->sm, orig);
276 	if (r < 0)
277 		return r;
278 
279 	r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
280 	if (r < 0)
281 		return r;
282 
283 	/*
284 	 * It would be tempting to use dm_bm_unlock_move here, but some
285 	 * code, such as the space maps, keeps using the old data structures
286 	 * secure in the knowledge they won't be changed until the next
287 	 * transaction.  Using unlock_move would force a synchronous read
288 	 * since the old block would no longer be in the cache.
289 	 */
290 	r = dm_bm_write_lock_zero(tm->bm, new, v, result);
291 	if (r) {
292 		dm_bm_unlock(orig_block);
293 		return r;
294 	}
295 
296 	memcpy(dm_block_data(*result), dm_block_data(orig_block),
297 	       dm_bm_block_size(tm->bm));
298 
299 	dm_bm_unlock(orig_block);
300 	return r;
301 }
302 
dm_tm_shadow_block(struct dm_transaction_manager * tm,dm_block_t orig,struct dm_block_validator * v,struct dm_block ** result,int * inc_children)303 int dm_tm_shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
304 		       struct dm_block_validator *v, struct dm_block **result,
305 		       int *inc_children)
306 {
307 	int r;
308 
309 	if (tm->is_clone)
310 		return -EWOULDBLOCK;
311 
312 	r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
313 	if (r < 0)
314 		return r;
315 
316 	if (is_shadow(tm, orig) && !*inc_children)
317 		return dm_bm_write_lock(tm->bm, orig, v, result);
318 
319 	r = __shadow_block(tm, orig, v, result);
320 	if (r < 0)
321 		return r;
322 	insert_shadow(tm, dm_block_location(*result));
323 
324 	return r;
325 }
326 EXPORT_SYMBOL_GPL(dm_tm_shadow_block);
327 
dm_tm_read_lock(struct dm_transaction_manager * tm,dm_block_t b,struct dm_block_validator * v,struct dm_block ** blk)328 int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
329 		    struct dm_block_validator *v,
330 		    struct dm_block **blk)
331 {
332 	if (tm->is_clone) {
333 		int r = dm_bm_read_try_lock(tm->real->bm, b, v, blk);
334 
335 		if (r == -EWOULDBLOCK)
336 			prefetch_add(&tm->real->prefetches, b);
337 
338 		return r;
339 	}
340 
341 	return dm_bm_read_lock(tm->bm, b, v, blk);
342 }
343 EXPORT_SYMBOL_GPL(dm_tm_read_lock);
344 
dm_tm_unlock(struct dm_transaction_manager * tm,struct dm_block * b)345 void dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
346 {
347 	dm_bm_unlock(b);
348 }
349 EXPORT_SYMBOL_GPL(dm_tm_unlock);
350 
dm_tm_inc(struct dm_transaction_manager * tm,dm_block_t b)351 void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
352 {
353 	/*
354 	 * The non-blocking clone doesn't support this.
355 	 */
356 	BUG_ON(tm->is_clone);
357 
358 	dm_sm_inc_block(tm->sm, b);
359 }
360 EXPORT_SYMBOL_GPL(dm_tm_inc);
361 
dm_tm_inc_range(struct dm_transaction_manager * tm,dm_block_t b,dm_block_t e)362 void dm_tm_inc_range(struct dm_transaction_manager *tm, dm_block_t b, dm_block_t e)
363 {
364 	/*
365 	 * The non-blocking clone doesn't support this.
366 	 */
367 	BUG_ON(tm->is_clone);
368 
369 	dm_sm_inc_blocks(tm->sm, b, e);
370 }
371 EXPORT_SYMBOL_GPL(dm_tm_inc_range);
372 
dm_tm_dec(struct dm_transaction_manager * tm,dm_block_t b)373 void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
374 {
375 	/*
376 	 * The non-blocking clone doesn't support this.
377 	 */
378 	BUG_ON(tm->is_clone);
379 
380 	dm_sm_dec_block(tm->sm, b);
381 }
382 EXPORT_SYMBOL_GPL(dm_tm_dec);
383 
dm_tm_dec_range(struct dm_transaction_manager * tm,dm_block_t b,dm_block_t e)384 void dm_tm_dec_range(struct dm_transaction_manager *tm, dm_block_t b, dm_block_t e)
385 {
386 	/*
387 	 * The non-blocking clone doesn't support this.
388 	 */
389 	BUG_ON(tm->is_clone);
390 
391 	dm_sm_dec_blocks(tm->sm, b, e);
392 }
393 EXPORT_SYMBOL_GPL(dm_tm_dec_range);
394 
dm_tm_with_runs(struct dm_transaction_manager * tm,const __le64 * value_le,unsigned count,dm_tm_run_fn fn)395 void dm_tm_with_runs(struct dm_transaction_manager *tm,
396 		     const __le64 *value_le, unsigned count, dm_tm_run_fn fn)
397 {
398 	uint64_t b, begin, end;
399 	bool in_run = false;
400 	unsigned i;
401 
402 	for (i = 0; i < count; i++, value_le++) {
403 		b = le64_to_cpu(*value_le);
404 
405 		if (in_run) {
406 			if (b == end)
407 				end++;
408 			else {
409 				fn(tm, begin, end);
410 				begin = b;
411 				end = b + 1;
412 			}
413 		} else {
414 			in_run = true;
415 			begin = b;
416 			end = b + 1;
417 		}
418 	}
419 
420 	if (in_run)
421 		fn(tm, begin, end);
422 }
423 EXPORT_SYMBOL_GPL(dm_tm_with_runs);
424 
dm_tm_ref(struct dm_transaction_manager * tm,dm_block_t b,uint32_t * result)425 int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
426 	      uint32_t *result)
427 {
428 	if (tm->is_clone)
429 		return -EWOULDBLOCK;
430 
431 	return dm_sm_get_count(tm->sm, b, result);
432 }
433 
dm_tm_block_is_shared(struct dm_transaction_manager * tm,dm_block_t b,int * result)434 int dm_tm_block_is_shared(struct dm_transaction_manager *tm, dm_block_t b,
435 			  int *result)
436 {
437 	if (tm->is_clone)
438 		return -EWOULDBLOCK;
439 
440 	return dm_sm_count_is_more_than_one(tm->sm, b, result);
441 }
442 
dm_tm_get_bm(struct dm_transaction_manager * tm)443 struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
444 {
445 	return tm->bm;
446 }
447 
dm_tm_issue_prefetches(struct dm_transaction_manager * tm)448 void dm_tm_issue_prefetches(struct dm_transaction_manager *tm)
449 {
450 	prefetch_issue(&tm->prefetches, tm->bm);
451 }
452 EXPORT_SYMBOL_GPL(dm_tm_issue_prefetches);
453 
454 /*----------------------------------------------------------------*/
455 
dm_tm_create_internal(struct dm_block_manager * bm,dm_block_t sb_location,struct dm_transaction_manager ** tm,struct dm_space_map ** sm,int create,void * sm_root,size_t sm_len)456 static int dm_tm_create_internal(struct dm_block_manager *bm,
457 				 dm_block_t sb_location,
458 				 struct dm_transaction_manager **tm,
459 				 struct dm_space_map **sm,
460 				 int create,
461 				 void *sm_root, size_t sm_len)
462 {
463 	int r;
464 
465 	*sm = dm_sm_metadata_init();
466 	if (IS_ERR(*sm))
467 		return PTR_ERR(*sm);
468 
469 	*tm = dm_tm_create(bm, *sm);
470 	if (IS_ERR(*tm)) {
471 		dm_sm_destroy(*sm);
472 		return PTR_ERR(*tm);
473 	}
474 
475 	if (create) {
476 		r = dm_sm_metadata_create(*sm, *tm, dm_bm_nr_blocks(bm),
477 					  sb_location);
478 		if (r) {
479 			DMERR("couldn't create metadata space map");
480 			goto bad;
481 		}
482 
483 	} else {
484 		r = dm_sm_metadata_open(*sm, *tm, sm_root, sm_len);
485 		if (r) {
486 			DMERR("couldn't open metadata space map");
487 			goto bad;
488 		}
489 	}
490 
491 	return 0;
492 
493 bad:
494 	dm_tm_destroy(*tm);
495 	dm_sm_destroy(*sm);
496 	return r;
497 }
498 
dm_tm_create_with_sm(struct dm_block_manager * bm,dm_block_t sb_location,struct dm_transaction_manager ** tm,struct dm_space_map ** sm)499 int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
500 			 struct dm_transaction_manager **tm,
501 			 struct dm_space_map **sm)
502 {
503 	return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0);
504 }
505 EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
506 
dm_tm_open_with_sm(struct dm_block_manager * bm,dm_block_t sb_location,void * sm_root,size_t root_len,struct dm_transaction_manager ** tm,struct dm_space_map ** sm)507 int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
508 		       void *sm_root, size_t root_len,
509 		       struct dm_transaction_manager **tm,
510 		       struct dm_space_map **sm)
511 {
512 	return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len);
513 }
514 EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
515 
516 /*----------------------------------------------------------------*/
517