[linux.git] / drivers / md / dm-cache-policy.c

/*
 * Copyright (C) 2012 Red Hat. All rights reserved.
 *
 * This file is released under the GPL.
 */

#include "dm-cache-policy-internal.h"
#include "dm.h"

#include <linux/module.h>
#include <linux/slab.h>

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

#define DM_MSG_PREFIX "cache-policy"

static DEFINE_SPINLOCK(register_lock);
static LIST_HEAD(register_list);

static struct dm_cache_policy_type *__find_policy(const char *name)
{
	struct dm_cache_policy_type *t;

	list_for_each_entry(t, &register_list, list)
		if (!strcmp(t->name, name))
			return t;

	return NULL;
}

static struct dm_cache_policy_type *__get_policy_once(const char *name)
{
	struct dm_cache_policy_type *t = __find_policy(name);

	if (t && !try_module_get(t->owner)) {
		DMWARN("couldn't get module %s", name);
		t = ERR_PTR(-EINVAL);
	}

	return t;
}

static struct dm_cache_policy_type *get_policy_once(const char *name)
{
	struct dm_cache_policy_type *t;

	spin_lock(&register_lock);
	t = __get_policy_once(name);
	spin_unlock(&register_lock);

	return t;
}

static struct dm_cache_policy_type *get_policy(const char *name)
{
	struct dm_cache_policy_type *t;

	t = get_policy_once(name);
	if (IS_ERR(t))
		return NULL;

	if (t)
		return t;

	request_module("dm-cache-%s", name);

	t = get_policy_once(name);
	if (IS_ERR(t))
		return NULL;

	return t;
}

static void put_policy(struct dm_cache_policy_type *t)
{
	module_put(t->owner);
}

int dm_cache_policy_register(struct dm_cache_policy_type *type)
{
	int r;

	/* One size fits all for now */
	if (type->hint_size != 0 && type->hint_size != 4) {
		DMWARN("hint size must be 0 or 4 but %llu supplied.", (unsigned long long) type->hint_size);
		return -EINVAL;
	}

	spin_lock(&register_lock);
	if (__find_policy(type->name)) {
		DMWARN("attempt to register policy under duplicate name %s", type->name);
		r = -EINVAL;
	} else {
		list_add(&type->list, &register_list);
		r = 0;
	}
	spin_unlock(&register_lock);

	return r;
}
EXPORT_SYMBOL_GPL(dm_cache_policy_register);

void dm_cache_policy_unregister(struct dm_cache_policy_type *type)
{
	spin_lock(&register_lock);
	list_del_init(&type->list);
	spin_unlock(&register_lock);
}
EXPORT_SYMBOL_GPL(dm_cache_policy_unregister);

struct dm_cache_policy *dm_cache_policy_create(const char *name,
					       dm_cblock_t cache_size,
					       sector_t origin_size,
					       sector_t cache_block_size)
{
	struct dm_cache_policy *p = NULL;
	struct dm_cache_policy_type *type;

	type = get_policy(name);
	if (!type) {
		DMWARN("unknown policy type");
		return ERR_PTR(-EINVAL);
	}

	p = type->create(cache_size, origin_size, cache_block_size);
	if (!p) {
		put_policy(type);
		return ERR_PTR(-ENOMEM);
	}
	p->private = type;

	return p;
}
EXPORT_SYMBOL_GPL(dm_cache_policy_create);

void dm_cache_policy_destroy(struct dm_cache_policy *p)
{
	struct dm_cache_policy_type *t = p->private;

	p->destroy(p);
	put_policy(t);
}
EXPORT_SYMBOL_GPL(dm_cache_policy_destroy);

const char *dm_cache_policy_get_name(struct dm_cache_policy *p)
{
	struct dm_cache_policy_type *t = p->private;

	/* if t->real is set then an alias was used (e.g. "default") */
	if (t->real)
		return t->real->name;

	return t->name;
}
EXPORT_SYMBOL_GPL(dm_cache_policy_get_name);

const unsigned *dm_cache_policy_get_version(struct dm_cache_policy *p)
{
	struct dm_cache_policy_type *t = p->private;

	return t->version;
}
EXPORT_SYMBOL_GPL(dm_cache_policy_get_version);

size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p)
{
	struct dm_cache_policy_type *t = p->private;

	return t->hint_size;
}
EXPORT_SYMBOL_GPL(dm_cache_policy_get_hint_size);

/*----------------------------------------------------------------*/
Commit	Line	Data
c6b4fcba JT	1	/*
	2	* Copyright (C) 2012 Red Hat. All rights reserved.
	3	*
	4	* This file is released under the GPL.
	5	*/
	6
	7	#include "dm-cache-policy-internal.h"
	8	#include "dm.h"
	9
	10	#include <linux/module.h>
	11	#include <linux/slab.h>
	12
	13	/----------------------------------------------------------------/
	14
	15	#define DM_MSG_PREFIX "cache-policy"
	16
	17	static DEFINE_SPINLOCK(register_lock);
	18	static LIST_HEAD(register_list);
	19
	20	static struct dm_cache_policy_type __find_policy(const char name)
	21	{
	22	struct dm_cache_policy_type *t;
	23
	24	list_for_each_entry(t, &register_list, list)
	25	if (!strcmp(t->name, name))
	26	return t;
	27
	28	return NULL;
	29	}
	30
	31	static struct dm_cache_policy_type __get_policy_once(const char name)
	32	{
	33	struct dm_cache_policy_type *t = __find_policy(name);
	34
	35	if (t && !try_module_get(t->owner)) {
	36	DMWARN("couldn't get module %s", name);
	37	t = ERR_PTR(-EINVAL);
	38	}
	39
	40	return t;
	41	}
	42
	43	static struct dm_cache_policy_type get_policy_once(const char name)
	44	{
	45	struct dm_cache_policy_type *t;
	46
	47	spin_lock(&register_lock);
	48	t = __get_policy_once(name);
	49	spin_unlock(&register_lock);
	50
	51	return t;
	52	}
	53
	54	static struct dm_cache_policy_type get_policy(const char name)
	55	{
	56	struct dm_cache_policy_type *t;
	57
	58	t = get_policy_once(name);
	59	if (IS_ERR(t))
	60	return NULL;
	61
	62	if (t)
	63	return t;
	64
65	request_module("dm-cache-%s", name);
66
67	t = get_policy_once(name);
68	if (IS_ERR(t))
69	return NULL;
70
71	return t;
72	}
73
74	static void put_policy(struct dm_cache_policy_type *t)
75	{
76	module_put(t->owner);
77	}
78
79	int dm_cache_policy_register(struct dm_cache_policy_type *type)
80	{
81	int r;
82
83	/* One size fits all for now */
84	if (type->hint_size != 0 && type->hint_size != 4) {
85	DMWARN("hint size must be 0 or 4 but %llu supplied.", (unsigned long long) type->hint_size);
86	return -EINVAL;
87	}
88
89	spin_lock(&register_lock);
90	if (__find_policy(type->name)) {
91	DMWARN("attempt to register policy under duplicate name %s", type->name);
92	r = -EINVAL;
93	} else {
94	list_add(&type->list, &register_list);
95	r = 0;
96	}
97	spin_unlock(&register_lock);
98
99	return r;
100	}
101	EXPORT_SYMBOL_GPL(dm_cache_policy_register);
102
103	void dm_cache_policy_unregister(struct dm_cache_policy_type *type)
104	{
105	spin_lock(&register_lock);
106	list_del_init(&type->list);
107	spin_unlock(&register_lock);
108	}
109	EXPORT_SYMBOL_GPL(dm_cache_policy_unregister);
110
111	struct dm_cache_policy dm_cache_policy_create(const char name,
112	dm_cblock_t cache_size,
113	sector_t origin_size,
114	sector_t cache_block_size)
115	{
116	struct dm_cache_policy *p = NULL;
117	struct dm_cache_policy_type *type;
118
119	type = get_policy(name);
120	if (!type) {
121	DMWARN("unknown policy type");
4cb3e1db	122	return ERR_PTR(-EINVAL);
c6b4fcba JT	123	}
	124
	125	p = type->create(cache_size, origin_size, cache_block_size);
	126	if (!p) {
	127	put_policy(type);
4cb3e1db	128	return ERR_PTR(-ENOMEM);
c6b4fcba JT	129	}
	130	p->private = type;
	131
	132	return p;
	133	}
	134	EXPORT_SYMBOL_GPL(dm_cache_policy_create);
	135
	136	void dm_cache_policy_destroy(struct dm_cache_policy *p)
	137	{
	138	struct dm_cache_policy_type *t = p->private;
	139
	140	p->destroy(p);
	141	put_policy(t);
	142	}
	143	EXPORT_SYMBOL_GPL(dm_cache_policy_destroy);
	144
	145	const char dm_cache_policy_get_name(struct dm_cache_policy p)
	146	{
	147	struct dm_cache_policy_type *t = p->private;
	148
2e68c4e6 MS	149	/* if t->real is set then an alias was used (e.g. "default") */
	150	if (t->real)
	151	return t->real->name;
	152
c6b4fcba JT	153	return t->name;
	154	}
	155	EXPORT_SYMBOL_GPL(dm_cache_policy_get_name);
	156
4e7f506f MS	157	const unsigned dm_cache_policy_get_version(struct dm_cache_policy p)
	158	{
	159	struct dm_cache_policy_type *t = p->private;
	160
	161	return t->version;
	162	}
	163	EXPORT_SYMBOL_GPL(dm_cache_policy_get_version);
	164
c6b4fcba JT	165	size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p)
	166	{
	167	struct dm_cache_policy_type *t = p->private;
	168
	169	return t->hint_size;
	170	}
	171	EXPORT_SYMBOL_GPL(dm_cache_policy_get_hint_size);
	172
	173	/----------------------------------------------------------------/