[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-disk.h"
#include "dm-space-map-metadata.h"
#include "dm-persistent-data-internal.h"

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

#define DM_MSG_PREFIX "transaction manager"

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

#define PREFETCH_SIZE 128
#define PREFETCH_BITS 7
#define PREFETCH_SENTINEL ((dm_block_t) -1ULL)

struct prefetch_set {
	struct mutex lock;
	dm_block_t blocks[PREFETCH_SIZE];
};

static unsigned prefetch_hash(dm_block_t b)
{
	return hash_64(b, PREFETCH_BITS);
}

static void prefetch_wipe(struct prefetch_set *p)
{
	unsigned i;
	for (i = 0; i < PREFETCH_SIZE; i++)
		p->blocks[i] = PREFETCH_SENTINEL;
}

static void prefetch_init(struct prefetch_set *p)
{
	mutex_init(&p->lock);
	prefetch_wipe(p);
}

static void prefetch_add(struct prefetch_set *p, dm_block_t b)
{
	unsigned h = prefetch_hash(b);

	mutex_lock(&p->lock);
	if (p->blocks[h] == PREFETCH_SENTINEL)
		p->blocks[h] = b;

	mutex_unlock(&p->lock);
}

static void prefetch_issue(struct prefetch_set *p, struct dm_block_manager *bm)
{
	unsigned i;

	mutex_lock(&p->lock);

	for (i = 0; i < PREFETCH_SIZE; i++)
		if (p->blocks[i] != PREFETCH_SENTINEL) {
			dm_bm_prefetch(bm, p->blocks[i]);
			p->blocks[i] = PREFETCH_SENTINEL;
		}

	mutex_unlock(&p->lock);
}

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

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

/*
 * It would be nice if we scaled with the size of transaction.
 */
#define DM_HASH_SIZE 256
#define DM_HASH_MASK (DM_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[DM_HASH_SIZE];

	struct prefetch_set prefetches;
};

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

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

	spin_lock(&tm->lock);
	hlist_for_each_entry(si, 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, DM_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 *tmp;
	struct hlist_head *bucket;
	int i;

	spin_lock(&tm->lock);
	for (i = 0; i < DM_HASH_SIZE; i++) {
		bucket = tm->buckets + i;
		hlist_for_each_entry_safe(si, 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 < DM_HASH_SIZE; i++)
		INIT_HLIST_HEAD(tm->buckets + i);

	prefetch_init(&tm->prefetches);

	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)
{
	if (!tm->is_clone)
		wipe_shadow_table(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 dm_bm_flush(tm->bm);
}
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);
	dm_bm_unlock(root);

	return dm_bm_flush(tm->bm);
}
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;

	/*
	 * It would be tempting to use dm_bm_unlock_move here, but some
	 * code, such as the space maps, keeps using the old data structures
	 * secure in the knowledge they won't be changed until the next
	 * transaction.  Using unlock_move would force a synchronous read
	 * since the old block would no longer be in the cache.
	 */
	r = dm_bm_write_lock_zero(tm->bm, new, v, result);
	if (r) {
		dm_bm_unlock(orig_block);
		return r;
	}

	memcpy(dm_block_data(*result), dm_block_data(orig_block),
	       dm_bm_block_size(tm->bm));

	dm_bm_unlock(orig_block);
	return r;
}

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;
}
EXPORT_SYMBOL_GPL(dm_tm_shadow_block);

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) {
		int r = dm_bm_read_try_lock(tm->real->bm, b, v, blk);

		if (r == -EWOULDBLOCK)
			prefetch_add(&tm->real->prefetches, b);

		return r;
	}

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

void dm_tm_unlock(struct dm_transaction_manager *tm, struct dm_block *b)
{
	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_inc_range(struct dm_transaction_manager *tm, dm_block_t b, dm_block_t e)
{
	/*
	 * The non-blocking clone doesn't support this.
	 */
	BUG_ON(tm->is_clone);

	dm_sm_inc_blocks(tm->sm, b, e);
}
EXPORT_SYMBOL_GPL(dm_tm_inc_range);

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);

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

	dm_sm_dec_blocks(tm->sm, b, e);
}
EXPORT_SYMBOL_GPL(dm_tm_dec_range);

void dm_tm_with_runs(struct dm_transaction_manager *tm,
		     const __le64 *value_le, unsigned count, dm_tm_run_fn fn)
{
	uint64_t b, begin, end;
	bool in_run = false;
	unsigned i;

	for (i = 0; i < count; i++, value_le++) {
		b = le64_to_cpu(*value_le);

		if (in_run) {
			if (b == end)
				end++;
			else {
				fn(tm, begin, end);
				begin = b;
				end = b + 1;
			}
		} else {
			in_run = true;
			begin = b;
			end = b + 1;
		}
	}

	if (in_run)
		fn(tm, begin, end);
}
EXPORT_SYMBOL_GPL(dm_tm_with_runs);

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);
}

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

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

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

void dm_tm_issue_prefetches(struct dm_transaction_manager *tm)
{
	prefetch_issue(&tm->prefetches, tm->bm);
}
EXPORT_SYMBOL_GPL(dm_tm_issue_prefetches);

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

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

	*sm = dm_sm_metadata_init();
	if (IS_ERR(*sm))
		return PTR_ERR(*sm);

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

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

	} else {
		r = dm_sm_metadata_open(*sm, *tm, sm_root, sm_len);
		if (r) {
			DMERR("couldn't open metadata space map");
			goto bad;
		}
	}

	return 0;

bad:
	dm_tm_destroy(*tm);
	dm_sm_destroy(*sm);
	return r;
}

int 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)
{
	return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0);
}
EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);

int 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)
{
	return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len);
}
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"
3241b1d3 JT	8	#include "dm-space-map-disk.h"
	9	#include "dm-space-map-metadata.h"
	10	#include "dm-persistent-data-internal.h"
	11
1944ce60	12	#include <linux/export.h>
4646015d JT	13	#include <linux/mutex.h>
4646015d JT	14	#include <linux/hash.h>
3241b1d3 JT	15	#include <linux/slab.h>
	16	#include <linux/device-mapper.h>
	17
	18	#define DM_MSG_PREFIX "transaction manager"
	19
	20	/----------------------------------------------------------------/
	21
4646015d JT	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
	31	static unsigned prefetch_hash(dm_block_t b)
	32	{
	33	return hash_64(b, PREFETCH_BITS);
	34	}
	35
	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
	43	static void prefetch_init(struct prefetch_set *p)
	44	{
	45	mutex_init(&p->lock);
	46	prefetch_wipe(p);
	47	}
	48
	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
	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
3241b1d3 JT	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	*/
df855798 AM	85	#define DM_HASH_SIZE 256
df855798 AM	86	#define DM_HASH_MASK (DM_HASH_SIZE - 1)
3241b1d3 JT	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;
df855798	96	struct hlist_head buckets[DM_HASH_SIZE];
4646015d JT	97
4646015d JT	98	struct prefetch_set prefetches;
3241b1d3 JT	99	};
	100
	101	/----------------------------------------------------------------/
	102
	103	static int is_shadow(struct dm_transaction_manager *tm, dm_block_t b)
	104	{
	105	int r = 0;
df855798	106	unsigned bucket = dm_hash_block(b, DM_HASH_MASK);
3241b1d3	107	struct shadow_info *si;
3241b1d3 JT	108
3241b1d3 JT	109	spin_lock(&tm->lock);
b67bfe0d	110	hlist_for_each_entry(si, tm->buckets + bucket, hlist)
3241b1d3 JT	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	*/
	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;
df855798	132	bucket = dm_hash_block(b, DM_HASH_MASK);
3241b1d3 JT	133	spin_lock(&tm->lock);
	134	hlist_add_head(&si->hlist, tm->buckets + bucket);
	135	spin_unlock(&tm->lock);
	136	}
	137	}
	138
	139	static void wipe_shadow_table(struct dm_transaction_manager *tm)
	140	{
	141	struct shadow_info *si;
b67bfe0d	142	struct hlist_node *tmp;
3241b1d3 JT	143	struct hlist_head *bucket;
	144	int i;
	145
	146	spin_lock(&tm->lock);
df855798	147	for (i = 0; i < DM_HASH_SIZE; i++) {
3241b1d3	148	bucket = tm->buckets + i;
b67bfe0d	149	hlist_for_each_entry_safe(si, tmp, bucket, hlist)
3241b1d3 JT	150	kfree(si);
	151
	152	INIT_HLIST_HEAD(bucket);
	153	}
	154
	155	spin_unlock(&tm->lock);
	156	}
	157
	158	/----------------------------------------------------------------/
	159
	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);
df855798	176	for (i = 0; i < DM_HASH_SIZE; i++)
3241b1d3 JT	177	INIT_HLIST_HEAD(tm->buckets + i);
3241b1d3 JT	178
4646015d JT	179	prefetch_init(&tm->prefetches);
4646015d JT	180
3241b1d3 JT	181	return tm;
	182	}
	183
	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
	198	void dm_tm_destroy(struct dm_transaction_manager *tm)
	199	{
25d7cd6f MS	200	if (!tm->is_clone)
	201	wipe_shadow_table(tm);
	202
3241b1d3 JT	203	kfree(tm);
	204	}
	205	EXPORT_SYMBOL_GPL(dm_tm_destroy);
	206
	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
a9d45396	218	return dm_bm_flush(tm->bm);
3241b1d3 JT	219	}
	220	EXPORT_SYMBOL_GPL(dm_tm_pre_commit);
	221
	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);
a9d45396	228	dm_bm_unlock(root);
3241b1d3	229
a9d45396	230	return dm_bm_flush(tm->bm);
3241b1d3 JT	231	}
	232	EXPORT_SYMBOL_GPL(dm_tm_commit);
	233
	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
	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
3c9ad9bd JT	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) {
3241b1d3 JT	292	dm_bm_unlock(orig_block);
	293	return r;
	294	}
	295
3c9ad9bd JT	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;
3241b1d3 JT	301	}
	302
	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	}
cc8394d8	326	EXPORT_SYMBOL_GPL(dm_tm_shadow_block);
3241b1d3 JT	327
	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	{
4646015d JT	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	}
3241b1d3 JT	340
	341	return dm_bm_read_lock(tm->bm, b, v, blk);
	342	}
cc8394d8	343	EXPORT_SYMBOL_GPL(dm_tm_read_lock);
3241b1d3	344
4c7da06f	345	void dm_tm_unlock(struct dm_transaction_manager tm, struct dm_block b)
3241b1d3	346	{
4c7da06f	347	dm_bm_unlock(b);
3241b1d3 JT	348	}
	349	EXPORT_SYMBOL_GPL(dm_tm_unlock);
	350
	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
be500ed7 JT	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
3241b1d3 JT	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
be500ed7 JT	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
	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
3241b1d3 JT	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
4eafdb15 JT	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
3241b1d3 JT	443	struct dm_block_manager dm_tm_get_bm(struct dm_transaction_manager tm)
	444	{
	445	return tm->bm;
	446	}
	447
4646015d JT	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
3241b1d3 JT	454	/----------------------------------------------------------------/
	455
	456	static int dm_tm_create_internal(struct dm_block_manager *bm,
	457	dm_block_t sb_location,
3241b1d3 JT	458	struct dm_transaction_manager **tm,
3241b1d3 JT	459	struct dm_space_map **sm,
384ef0e6 JT	460	int create,
384ef0e6 JT	461	void *sm_root, size_t sm_len)
3241b1d3 JT	462	{
3241b1d3 JT	463	int r;
3241b1d3	464
3caf6d73 JT	465	*sm = dm_sm_metadata_init();
	466	if (IS_ERR(*sm))
	467	return PTR_ERR(*sm);
3241b1d3	468
3caf6d73	469	tm = dm_tm_create(bm, sm);
3241b1d3	470	if (IS_ERR(*tm)) {
3caf6d73	471	dm_sm_destroy(*sm);
3241b1d3 JT	472	return PTR_ERR(*tm);
	473	}
	474
	475	if (create) {
3caf6d73	476	r = dm_sm_metadata_create(sm, tm, dm_bm_nr_blocks(bm),
3241b1d3 JT	477	sb_location);
	478	if (r) {
	479	DMERR("couldn't create metadata space map");
384ef0e6	480	goto bad;
3241b1d3 JT	481	}
3241b1d3 JT	482
3241b1d3	483	} else {
384ef0e6	484	r = dm_sm_metadata_open(sm, tm, sm_root, sm_len);
3241b1d3 JT	485	if (r) {
3241b1d3 JT	486	DMERR("couldn't open metadata space map");
384ef0e6	487	goto bad;
3241b1d3	488	}
3241b1d3 JT	489	}
	490
	491	return 0;
	492
384ef0e6	493	bad:
3241b1d3	494	dm_tm_destroy(*tm);
384ef0e6	495	dm_sm_destroy(*sm);
3241b1d3 JT	496	return r;
	497	}
	498
	499	int dm_tm_create_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
3241b1d3	500	struct dm_transaction_manager **tm,
384ef0e6	501	struct dm_space_map **sm)
3241b1d3	502	{
384ef0e6	503	return dm_tm_create_internal(bm, sb_location, tm, sm, 1, NULL, 0);
3241b1d3 JT	504	}
	505	EXPORT_SYMBOL_GPL(dm_tm_create_with_sm);
	506
	507	int dm_tm_open_with_sm(struct dm_block_manager *bm, dm_block_t sb_location,
384ef0e6	508	void *sm_root, size_t root_len,
3241b1d3	509	struct dm_transaction_manager **tm,
384ef0e6	510	struct dm_space_map **sm)
3241b1d3	511	{
384ef0e6	512	return dm_tm_create_internal(bm, sb_location, tm, sm, 0, sm_root, root_len);
3241b1d3 JT	513	}
	514	EXPORT_SYMBOL_GPL(dm_tm_open_with_sm);
	515
	516	/----------------------------------------------------------------/