[linux-2.6-block.git] / drivers / md / persistent-data / dm-transaction-manager.c

/*
 * Copyright (C) 2011 Red Hat, Inc.
 *
 * This file is released under the GPL.
 */
#include "dm-transaction-manager.h"
#include "dm-space-map.h"
#include "dm-space-map-checker.h"
#include "dm-space-map-disk.h"
#include "dm-space-map-metadata.h"
#include "dm-persistent-data-internal.h"

#include <linux/export.h>
#include <linux/slab.h>
#include <linux/device-mapper.h>

#define DM_MSG_PREFIX "transaction manager"

/*----------------------------------------------------------------*/

struct shadow_info {
	struct hlist_node hlist;
	dm_block_t where;
};

/*
 * It would be nice if we scaled with the size of transaction.
 */
#define HASH_SIZE 256
#define HASH_MASK (HASH_SIZE - 1)

struct dm_transaction_manager {
	int is_clone;
	struct dm_transaction_manager *real;

	struct dm_block_manager *bm;
	struct dm_space_map *sm;

	spinlock_t lock;
	struct hlist_head buckets[HASH_SIZE];
};

/*----------------------------------------------------------------*/

static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
{
	int r = 0;
	unsigned bucket = dm_hash_block(b, HASH_MASK);
	struct shadow_info *si;
	struct hlist_node *n;

	spin_lock(&tm->lock);
	hlist_for_each_entry(si, n, tm->buckets + bucket, hlist)
		if (si->where == b) {
			r = 1;
			break;
		}
	spin_unlock(&tm->lock);

	return r;
}

/*
 * This can silently fail if there's no memory.  We're ok with this since
 * creating redundant shadows causes no harm.
 */
static void insert_shadow(struct dm_transaction_manager *tm, dm_block_t b)
{
	unsigned bucket;
	struct shadow_info *si;

	si = kmalloc(sizeof(*si), GFP_NOIO);
	if (si) {
		si->where = b;
		bucket = dm_hash_block(b, HASH_MASK);
		spin_lock(&tm->lock);
		hlist_add_head(&si->hlist, tm->buckets + bucket);
		spin_unlock(&tm->lock);
	}
}

static void wipe_shadow_table(struct dm_transaction_manager *tm)
{
	struct shadow_info *si;
	struct hlist_node *n, *tmp;
	struct hlist_head *bucket;
	int i;

	spin_lock(&tm->lock);
	for (i = 0; i < HASH_SIZE; i++) {
		bucket = tm->buckets + i;
		hlist_for_each_entry_safe(si, n, tmp, bucket, hlist)
			kfree(si);

		INIT_HLIST_HEAD(bucket);
	}

	spin_unlock(&tm->lock);
}

/*----------------------------------------------------------------*/

static struct dm_transaction_manager *dm_tm_create(struct dm_block_manager *bm,
						   struct dm_space_map *sm)
{
	int i;
	struct dm_transaction_manager *tm;

	tm = kmalloc(sizeof(*tm), GFP_KERNEL);
	if (!tm)
		return ERR_PTR(-ENOMEM);

	tm->is_clone = 0;
	tm->real = NULL;
	tm->bm = bm;
	tm->sm = sm;

	spin_lock_init(&tm->lock);
	for (i = 0; i < HASH_SIZE; i++)
		INIT_HLIST_HEAD(tm->buckets + i);

	return tm;
}

struct dm_transaction_manager *dm_tm_create_non_blocking_clone(struct dm_transaction_manager *real)
{
	struct dm_transaction_manager *tm;

	tm = kmalloc(sizeof(*tm), GFP_KERNEL);
	if (tm) {
		tm->is_clone = 1;
		tm->real = real;
	}

	return tm;
}
EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);

void dm_tm_destroy(struct dm_transaction_manager *tm)
{
	kfree(tm);
}
EXPORT_SYMBOL_GPL(dm_tm_destroy);

int dm_tm_pre_commit(struct dm_transaction_manager *tm)
{
	int r;

	if (tm->is_clone)
		return -EWOULDBLOCK;

	r = dm_sm_commit(tm->sm);
	if (r < 0)
		return r;

	return 0;
}
EXPORT_SYMBOL_GPL(dm_tm_pre_commit);

int dm_tm_commit(struct dm_transaction_manager *tm, struct dm_block *root)
{
	if (tm->is_clone)
		return -EWOULDBLOCK;

	wipe_shadow_table(tm);

	return dm_bm_flush_and_unlock(tm->bm, root);
}
EXPORT_SYMBOL_GPL(dm_tm_commit);

int dm_tm_new_block(struct dm_transaction_manager *tm,
		    struct dm_block_validator *v,
		    struct dm_block **result)
{
	int r;
	dm_block_t new_block;

	if (tm->is_clone)
		return -EWOULDBLOCK;

	r = dm_sm_new_block(tm->sm, &new_block);
	if (r < 0)
		return r;

	r = dm_bm_write_lock_zero(tm->bm, new_block, v, result);
	if (r < 0) {
		dm_sm_dec_block(tm->sm, new_block);
		return r;
	}

	/*
	 * New blocks count as shadows in that they don't need to be
	 * shadowed again.
	 */
	insert_shadow(tm, new_block);

	return 0;
}

static int __shadow_block(struct dm_transaction_manager *tm, dm_block_t orig,
			  struct dm_block_validator *v,
			  struct dm_block **result)
{
	int r;
	dm_block_t new;
	struct dm_block *orig_block;

	r = dm_sm_new_block(tm->sm, &new);
	if (r < 0)
		return r;

	r = dm_sm_dec_block(tm->sm, orig);
	if (r < 0)
		return r;

	r = dm_bm_read_lock(tm->bm, orig, v, &orig_block);
	if (r < 0)
		return r;

	r = dm_bm_unlock_move(orig_block, new);
	if (r < 0) {
		dm_bm_unlock(orig_block);
		return r;
	}

	return dm_bm_write_lock(tm->bm, new, v, result);
}

int 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)
{
	int r;

	if (tm->is_clone)
		return -EWOULDBLOCK;

	r = dm_sm_count_is_more_than_one(tm->sm, orig, inc_children);
	if (r < 0)
		return r;

	if (is_shadow(tm, orig) && !*inc_children)
		return dm_bm_write_lock(tm->bm, orig, v, result);

	r = __shadow_block(tm, orig, v, result);
	if (r < 0)
		return r;
	insert_shadow(tm, dm_block_location(*result));

	return r;
}

int dm_tm_read_lock(struct dm_transaction_manager *tm, dm_block_t b,
		    struct dm_block_validator *v,
		    struct dm_block **blk)
{
	if (tm->is_clone)
		return dm_bm_read_try_lock(tm->real->bm, b, v, blk);

	return dm_bm_read_lock(tm->bm, b, v, blk);
}

int dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
{
	return dm_bm_unlock(b);
}
EXPORT_SYMBOL_GPL(dm_tm_unlock);

void dm_tm_inc(struct dm_transaction_manager *tm, dm_block_t b)
{
	/*
	 * The non-blocking clone doesn't support this.
	 */
	BUG_ON(tm->is_clone);

	dm_sm_inc_block(tm->sm, b);
}
EXPORT_SYMBOL_GPL(dm_tm_inc);

void dm_tm_dec(struct dm_transaction_manager *tm, dm_block_t b)
{
	/*
	 * The non-blocking clone doesn't support this.
	 */
	BUG_ON(tm->is_clone);

	dm_sm_dec_block(tm->sm, b);
}
EXPORT_SYMBOL_GPL(dm_tm_dec);

int dm_tm_ref(struct dm_transaction_manager *tm, dm_block_t b,
	      uint32_t *result)
{
	if (tm->is_clone)
		return -EWOULDBLOCK;

	return dm_sm_get_count(tm->sm, b, result);
}

struct dm_block_manager *dm_tm_get_bm(struct dm_transaction_manager *tm)
{
	return tm->bm;
}

/*----------------------------------------------------------------*/

static int dm_tm_create_internal(struct dm_block_manager *bm,
				 dm_block_t sb_location,
				 struct dm_block_validator *sb_validator,
				 size_t root_offset, size_t root_max_len,
				 struct dm_transaction_manager **tm,
				 struct dm_space_map **sm,
				 struct dm_block **sblock,
				 int create)
{
	int r;
	struct dm_space_map *inner;

	inner = dm_sm_metadata_init();
	if (IS_ERR(inner))
		return PTR_ERR(inner);

	*tm = dm_tm_create(bm, inner);
	if (IS_ERR(*tm)) {
		dm_sm_destroy(inner);
		return PTR_ERR(*tm);
	}

	if (create) {
		r = dm_bm_write_lock_zero(dm_tm_get_bm(*tm), sb_location,
					  sb_validator, sblock);
		if (r < 0) {
			DMERR("couldn't lock superblock");
			goto bad1;
		}

		r = dm_sm_metadata_create(inner, *tm, dm_bm_nr_blocks(bm),
					  sb_location);
		if (r) {
			DMERR("couldn't create metadata space map");
			goto bad2;
		}

		*sm = dm_sm_checker_create(inner);
		if (!*sm)
			goto bad2;

	} else {
		r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
				     sb_validator, sblock);
		if (r < 0) {
			DMERR("couldn't lock superblock");
			goto bad1;
		}

		r = dm_sm_metadata_open(inner, *tm,
					dm_block_data(*sblock) + root_offset,
					root_max_len);
		if (r) {
			DMERR("couldn't open metadata space map");
			goto bad2;
		}

		*sm = dm_sm_checker_create(inner);
		if (!*sm)
			goto bad2;
	}

	return 0;

bad2:
	dm_tm_unlock(*tm, *sblock);
bad1:
	dm_tm_destroy(*tm);
	dm_sm_destroy(inner);
	return r;
}

int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
			 struct dm_block_validator *sb_validator,
			 struct dm_transaction_manager **tm,
			 struct dm_space_map **sm, struct dm_block **sblock)
{
	return dm_tm_create_internal(bm, sb_location, sb_validator,
				     0, 0, tm, sm, sblock, 1);
}
EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);

int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
		       struct dm_block_validator *sb_validator,
		       size_t root_offset, size_t root_max_len,
		       struct dm_transaction_manager **tm,
		       struct dm_space_map **sm, struct dm_block **sblock)
{
	return dm_tm_create_internal(bm, sb_location, sb_validator, root_offset,
				     root_max_len, tm, sm, sblock, 0);
}
EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);

/*----------------------------------------------------------------*/
Commit	Line	Data
3241b1d3 JT	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
1944ce60	13	#include <linux/export.h>
3241b1d3 JT	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	/----------------------------------------------------------------/