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

/*
 * Copyright (C) 2012 Red Hat, Inc.
 *
 * This file is released under the GPL.
 */

#include "dm-bitset.h"
#include "dm-transaction-manager.h"

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

#define DM_MSG_PREFIX "bitset"
#define BITS_PER_ARRAY_ENTRY 64

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

static struct dm_btree_value_type bitset_bvt = {
	.context = NULL,
	.size = sizeof(__le64),
	.inc = NULL,
	.dec = NULL,
	.equal = NULL,
};

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

void dm_disk_bitset_init(struct dm_transaction_manager *tm,
			 struct dm_disk_bitset *info)
{
	dm_array_info_init(&info->array_info, tm, &bitset_bvt);
	info->current_index_set = false;
}
EXPORT_SYMBOL_GPL(dm_disk_bitset_init);

int dm_bitset_empty(struct dm_disk_bitset *info, dm_block_t *root)
{
	return dm_array_empty(&info->array_info, root);
}
EXPORT_SYMBOL_GPL(dm_bitset_empty);

int dm_bitset_resize(struct dm_disk_bitset *info, dm_block_t root,
		     uint32_t old_nr_entries, uint32_t new_nr_entries,
		     bool default_value, dm_block_t *new_root)
{
	uint32_t old_blocks = dm_div_up(old_nr_entries, BITS_PER_ARRAY_ENTRY);
	uint32_t new_blocks = dm_div_up(new_nr_entries, BITS_PER_ARRAY_ENTRY);
	__le64 value = default_value ? cpu_to_le64(~0) : cpu_to_le64(0);

	__dm_bless_for_disk(&value);
	return dm_array_resize(&info->array_info, root, old_blocks, new_blocks,
			       &value, new_root);
}
EXPORT_SYMBOL_GPL(dm_bitset_resize);

int dm_bitset_del(struct dm_disk_bitset *info, dm_block_t root)
{
	return dm_array_del(&info->array_info, root);
}
EXPORT_SYMBOL_GPL(dm_bitset_del);

int dm_bitset_flush(struct dm_disk_bitset *info, dm_block_t root,
		    dm_block_t *new_root)
{
	int r;
	__le64 value;

	if (!info->current_index_set || !info->dirty)
		return 0;

	value = cpu_to_le64(info->current_bits);

	__dm_bless_for_disk(&value);
	r = dm_array_set_value(&info->array_info, root, info->current_index,
			       &value, new_root);
	if (r)
		return r;

	info->current_index_set = false;
	info->dirty = false;

	return 0;
}
EXPORT_SYMBOL_GPL(dm_bitset_flush);

static int read_bits(struct dm_disk_bitset *info, dm_block_t root,
		     uint32_t array_index)
{
	int r;
	__le64 value;

	r = dm_array_get_value(&info->array_info, root, array_index, &value);
	if (r)
		return r;

	info->current_bits = le64_to_cpu(value);
	info->current_index_set = true;
	info->current_index = array_index;
	info->dirty = false;

	return 0;
}

static int get_array_entry(struct dm_disk_bitset *info, dm_block_t root,
			   uint32_t index, dm_block_t *new_root)
{
	int r;
	unsigned array_index = index / BITS_PER_ARRAY_ENTRY;

	if (info->current_index_set) {
		if (info->current_index == array_index)
			return 0;

		r = dm_bitset_flush(info, root, new_root);
		if (r)
			return r;
	}

	return read_bits(info, root, array_index);
}

int dm_bitset_set_bit(struct dm_disk_bitset *info, dm_block_t root,
		      uint32_t index, dm_block_t *new_root)
{
	int r;
	unsigned b = index % BITS_PER_ARRAY_ENTRY;

	r = get_array_entry(info, root, index, new_root);
	if (r)
		return r;

	set_bit(b, (unsigned long *) &info->current_bits);
	info->dirty = true;

	return 0;
}
EXPORT_SYMBOL_GPL(dm_bitset_set_bit);

int dm_bitset_clear_bit(struct dm_disk_bitset *info, dm_block_t root,
			uint32_t index, dm_block_t *new_root)
{
	int r;
	unsigned b = index % BITS_PER_ARRAY_ENTRY;

	r = get_array_entry(info, root, index, new_root);
	if (r)
		return r;

	clear_bit(b, (unsigned long *) &info->current_bits);
	info->dirty = true;

	return 0;
}
EXPORT_SYMBOL_GPL(dm_bitset_clear_bit);

int dm_bitset_test_bit(struct dm_disk_bitset *info, dm_block_t root,
		       uint32_t index, dm_block_t *new_root, bool *result)
{
	int r;
	unsigned b = index % BITS_PER_ARRAY_ENTRY;

	r = get_array_entry(info, root, index, new_root);
	if (r)
		return r;

	*result = test_bit(b, (unsigned long *) &info->current_bits);
	return 0;
}
EXPORT_SYMBOL_GPL(dm_bitset_test_bit);

/*----------------------------------------------------------------*/
Commit	Line	Data
7a87edfe JT	1	/*
	2	* Copyright (C) 2012 Red Hat, Inc.
	3	*
	4	* This file is released under the GPL.
	5	*/
	6
	7	#include "dm-bitset.h"
	8	#include "dm-transaction-manager.h"
	9
	10	#include <linux/export.h>
	11	#include <linux/device-mapper.h>
	12
	13	#define DM_MSG_PREFIX "bitset"
	14	#define BITS_PER_ARRAY_ENTRY 64
	15
	16	/----------------------------------------------------------------/
	17
	18	static struct dm_btree_value_type bitset_bvt = {
	19	.context = NULL,
	20	.size = sizeof(__le64),
	21	.inc = NULL,
	22	.dec = NULL,
	23	.equal = NULL,
	24	};
	25
	26	/----------------------------------------------------------------/
	27
	28	void dm_disk_bitset_init(struct dm_transaction_manager *tm,
	29	struct dm_disk_bitset *info)
	30	{
	31	dm_array_info_init(&info->array_info, tm, &bitset_bvt);
	32	info->current_index_set = false;
	33	}
	34	EXPORT_SYMBOL_GPL(dm_disk_bitset_init);
	35
	36	int dm_bitset_empty(struct dm_disk_bitset info, dm_block_t root)
	37	{
	38	return dm_array_empty(&info->array_info, root);
	39	}
	40	EXPORT_SYMBOL_GPL(dm_bitset_empty);
	41
	42	int dm_bitset_resize(struct dm_disk_bitset *info, dm_block_t root,
	43	uint32_t old_nr_entries, uint32_t new_nr_entries,
	44	bool default_value, dm_block_t *new_root)
	45	{
	46	uint32_t old_blocks = dm_div_up(old_nr_entries, BITS_PER_ARRAY_ENTRY);
	47	uint32_t new_blocks = dm_div_up(new_nr_entries, BITS_PER_ARRAY_ENTRY);
	48	__le64 value = default_value ? cpu_to_le64(~0) : cpu_to_le64(0);
	49
	50	__dm_bless_for_disk(&value);
	51	return dm_array_resize(&info->array_info, root, old_blocks, new_blocks,
	52	&value, new_root);
	53	}
	54	EXPORT_SYMBOL_GPL(dm_bitset_resize);
	55
	56	int dm_bitset_del(struct dm_disk_bitset *info, dm_block_t root)
	57	{
	58	return dm_array_del(&info->array_info, root);
	59	}
	60	EXPORT_SYMBOL_GPL(dm_bitset_del);
	61
	62	int dm_bitset_flush(struct dm_disk_bitset *info, dm_block_t root,
	63	dm_block_t *new_root)
	64	{
65	int r;
66	__le64 value;
67
428e4698	68	if (!info->current_index_set \|\| !info->dirty)
7a87edfe JT	69	return 0;
	70
	71	value = cpu_to_le64(info->current_bits);
	72
	73	__dm_bless_for_disk(&value);
	74	r = dm_array_set_value(&info->array_info, root, info->current_index,
	75	&value, new_root);
	76	if (r)
	77	return r;
	78
	79	info->current_index_set = false;
428e4698 JT	80	info->dirty = false;
428e4698 JT	81
7a87edfe JT	82	return 0;
	83	}
	84	EXPORT_SYMBOL_GPL(dm_bitset_flush);
	85
	86	static int read_bits(struct dm_disk_bitset *info, dm_block_t root,
	87	uint32_t array_index)
	88	{
	89	int r;
	90	__le64 value;
	91
	92	r = dm_array_get_value(&info->array_info, root, array_index, &value);
	93	if (r)
	94	return r;
	95
	96	info->current_bits = le64_to_cpu(value);
	97	info->current_index_set = true;
	98	info->current_index = array_index;
428e4698 JT	99	info->dirty = false;
428e4698 JT	100
7a87edfe JT	101	return 0;
	102	}
	103
	104	static int get_array_entry(struct dm_disk_bitset *info, dm_block_t root,
	105	uint32_t index, dm_block_t *new_root)
	106	{
	107	int r;
	108	unsigned array_index = index / BITS_PER_ARRAY_ENTRY;
	109
	110	if (info->current_index_set) {
	111	if (info->current_index == array_index)
	112	return 0;
	113
	114	r = dm_bitset_flush(info, root, new_root);
	115	if (r)
	116	return r;
	117	}
	118
	119	return read_bits(info, root, array_index);
	120	}
	121
	122	int dm_bitset_set_bit(struct dm_disk_bitset *info, dm_block_t root,
	123	uint32_t index, dm_block_t *new_root)
	124	{
	125	int r;
	126	unsigned b = index % BITS_PER_ARRAY_ENTRY;
	127
	128	r = get_array_entry(info, root, index, new_root);
	129	if (r)
	130	return r;
	131
	132	set_bit(b, (unsigned long *) &info->current_bits);
428e4698 JT	133	info->dirty = true;
428e4698 JT	134
7a87edfe JT	135	return 0;
	136	}
	137	EXPORT_SYMBOL_GPL(dm_bitset_set_bit);
	138
	139	int dm_bitset_clear_bit(struct dm_disk_bitset *info, dm_block_t root,
	140	uint32_t index, dm_block_t *new_root)
	141	{
	142	int r;
	143	unsigned b = index % BITS_PER_ARRAY_ENTRY;
	144
	145	r = get_array_entry(info, root, index, new_root);
	146	if (r)
	147	return r;
	148
	149	clear_bit(b, (unsigned long *) &info->current_bits);
428e4698 JT	150	info->dirty = true;
428e4698 JT	151
7a87edfe JT	152	return 0;
	153	}
	154	EXPORT_SYMBOL_GPL(dm_bitset_clear_bit);
	155
	156	int dm_bitset_test_bit(struct dm_disk_bitset *info, dm_block_t root,
	157	uint32_t index, dm_block_t new_root, bool result)
	158	{
	159	int r;
	160	unsigned b = index % BITS_PER_ARRAY_ENTRY;
	161
	162	r = get_array_entry(info, root, index, new_root);
	163	if (r)
	164	return r;
	165
	166	result = test_bit(b, (unsigned long ) &info->current_bits);
	167	return 0;
	168	}
	169	EXPORT_SYMBOL_GPL(dm_bitset_test_bit);
	170
	171	/----------------------------------------------------------------/