[linux-2.6-block.git] / fs / gfs2 / locking.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/kmod.h>
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/lm_interface.h>

struct lmh_wrapper {
	struct list_head lw_list;
	const struct lm_lockops *lw_ops;
};

static int nolock_mount(char *table_name, char *host_data,
			lm_callback_t cb, void *cb_data,
			unsigned int min_lvb_size, int flags,
			struct lm_lockstruct *lockstruct,
			struct kobject *fskobj);

/* List of registered low-level locking protocols.  A file system selects one
   of them by name at mount time, e.g. lock_nolock, lock_dlm. */

static const struct lm_lockops nolock_ops = {
	.lm_proto_name = "lock_nolock",
	.lm_mount = nolock_mount,
};

static struct lmh_wrapper nolock_proto  = {
	.lw_list = LIST_HEAD_INIT(nolock_proto.lw_list),
	.lw_ops = &nolock_ops,
};

static LIST_HEAD(lmh_list);
static DEFINE_MUTEX(lmh_lock);

static int nolock_mount(char *table_name, char *host_data,
			lm_callback_t cb, void *cb_data,
			unsigned int min_lvb_size, int flags,
			struct lm_lockstruct *lockstruct,
			struct kobject *fskobj)
{
	char *c;
	unsigned int jid;

	c = strstr(host_data, "jid=");
	if (!c)
		jid = 0;
	else {
		c += 4;
		sscanf(c, "%u", &jid);
	}

	lockstruct->ls_jid = jid;
	lockstruct->ls_first = 1;
	lockstruct->ls_lvb_size = min_lvb_size;
	lockstruct->ls_ops = &nolock_ops;
	lockstruct->ls_flags = LM_LSFLAG_LOCAL;

	return 0;
}

/**
 * gfs2_register_lockproto - Register a low-level locking protocol
 * @proto: the protocol definition
 *
 * Returns: 0 on success, -EXXX on failure
 */

int gfs2_register_lockproto(const struct lm_lockops *proto)
{
	struct lmh_wrapper *lw;

	mutex_lock(&lmh_lock);

	list_for_each_entry(lw, &lmh_list, lw_list) {
		if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
			mutex_unlock(&lmh_lock);
			printk(KERN_INFO "GFS2: protocol %s already exists\n",
			       proto->lm_proto_name);
			return -EEXIST;
		}
	}

	lw = kzalloc(sizeof(struct lmh_wrapper), GFP_KERNEL);
	if (!lw) {
		mutex_unlock(&lmh_lock);
		return -ENOMEM;
	}

	lw->lw_ops = proto;
	list_add(&lw->lw_list, &lmh_list);

	mutex_unlock(&lmh_lock);

	return 0;
}

/**
 * gfs2_unregister_lockproto - Unregister a low-level locking protocol
 * @proto: the protocol definition
 *
 */

void gfs2_unregister_lockproto(const struct lm_lockops *proto)
{
	struct lmh_wrapper *lw;

	mutex_lock(&lmh_lock);

	list_for_each_entry(lw, &lmh_list, lw_list) {
		if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
			list_del(&lw->lw_list);
			mutex_unlock(&lmh_lock);
			kfree(lw);
			return;
		}
	}

	mutex_unlock(&lmh_lock);

	printk(KERN_WARNING "GFS2: can't unregister lock protocol %s\n",
	       proto->lm_proto_name);
}

/**
 * gfs2_mount_lockproto - Mount a lock protocol
 * @proto_name - the name of the protocol
 * @table_name - the name of the lock space
 * @host_data - data specific to this host
 * @cb - the callback to the code using the lock module
 * @sdp - The GFS2 superblock
 * @min_lvb_size - the mininum LVB size that the caller can deal with
 * @flags - LM_MFLAG_*
 * @lockstruct - a structure returned describing the mount
 *
 * Returns: 0 on success, -EXXX on failure
 */

int gfs2_mount_lockproto(char *proto_name, char *table_name, char *host_data,
			 lm_callback_t cb, void *cb_data,
			 unsigned int min_lvb_size, int flags,
			 struct lm_lockstruct *lockstruct,
			 struct kobject *fskobj)
{
	struct lmh_wrapper *lw = NULL;
	int try = 0;
	int error, found;


retry:
	mutex_lock(&lmh_lock);

	if (list_empty(&nolock_proto.lw_list))
		list_add(&nolock_proto.lw_list, &lmh_list);

	found = 0;
	list_for_each_entry(lw, &lmh_list, lw_list) {
		if (!strcmp(lw->lw_ops->lm_proto_name, proto_name)) {
			found = 1;
			break;
		}
	}

	if (!found) {
		if (!try && capable(CAP_SYS_MODULE)) {
			try = 1;
			mutex_unlock(&lmh_lock);
			request_module(proto_name);
			goto retry;
		}
		printk(KERN_INFO "GFS2: can't find protocol %s\n", proto_name);
		error = -ENOENT;
		goto out;
	}

	if (lw->lw_ops->lm_owner &&
	    !try_module_get(lw->lw_ops->lm_owner)) {
		try = 0;
		mutex_unlock(&lmh_lock);
		msleep(1000);
		goto retry;
	}

	error = lw->lw_ops->lm_mount(table_name, host_data, cb, cb_data,
				     min_lvb_size, flags, lockstruct, fskobj);
	if (error)
		module_put(lw->lw_ops->lm_owner);
out:
	mutex_unlock(&lmh_lock);
	return error;
}

void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct)
{
	mutex_lock(&lmh_lock);
	if (lockstruct->ls_ops->lm_unmount)
		lockstruct->ls_ops->lm_unmount(lockstruct->ls_lockspace);
	if (lockstruct->ls_ops->lm_owner)
		module_put(lockstruct->ls_ops->lm_owner);
	mutex_unlock(&lmh_lock);
}

/**
 * gfs2_withdraw_lockproto - abnormally unmount a lock module
 * @lockstruct: the lockstruct passed into mount
 *
 */

void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct)
{
	mutex_lock(&lmh_lock);
	lockstruct->ls_ops->lm_withdraw(lockstruct->ls_lockspace);
	if (lockstruct->ls_ops->lm_owner)
		module_put(lockstruct->ls_ops->lm_owner);
	mutex_unlock(&lmh_lock);
}

EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
Commit	Line	Data
b3b94faa DT	1	/*
b3b94faa DT	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa DT	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0	7	* of the GNU General Public License version 2.
b3b94faa DT	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/string.h>
	13	#include <linux/slab.h>
	14	#include <linux/wait.h>
	15	#include <linux/sched.h>
	16	#include <linux/kmod.h>
	17	#include <linux/fs.h>
	18	#include <linux/delay.h>
7d308590	19	#include <linux/lm_interface.h>
b3b94faa DT	20
	21	struct lmh_wrapper {
	22	struct list_head lw_list;
9b47c11d	23	const struct lm_lockops *lw_ops;
b3b94faa DT	24	};
b3b94faa DT	25
048bca22 SW	26	static int nolock_mount(char table_name, char host_data,
	27	lm_callback_t cb, void *cb_data,
	28	unsigned int min_lvb_size, int flags,
	29	struct lm_lockstruct *lockstruct,
	30	struct kobject *fskobj);
	31
b3b94faa DT	32	/* List of registered low-level locking protocols. A file system selects one
	33	of them by name at mount time, e.g. lock_nolock, lock_dlm. */
	34
048bca22 SW	35	static const struct lm_lockops nolock_ops = {
	36	.lm_proto_name = "lock_nolock",
	37	.lm_mount = nolock_mount,
	38	};
	39
	40	static struct lmh_wrapper nolock_proto = {
	41	.lw_list = LIST_HEAD_INIT(nolock_proto.lw_list),
	42	.lw_ops = &nolock_ops,
	43	};
	44
50299965 SW	45	static LIST_HEAD(lmh_list);
50299965 SW	46	static DEFINE_MUTEX(lmh_lock);
b3b94faa	47
048bca22 SW	48	static int nolock_mount(char table_name, char host_data,
	49	lm_callback_t cb, void *cb_data,
	50	unsigned int min_lvb_size, int flags,
	51	struct lm_lockstruct *lockstruct,
	52	struct kobject *fskobj)
	53	{
	54	char *c;
	55	unsigned int jid;
	56
	57	c = strstr(host_data, "jid=");
	58	if (!c)
	59	jid = 0;
	60	else {
	61	c += 4;
	62	sscanf(c, "%u", &jid);
	63	}
	64
	65	lockstruct->ls_jid = jid;
	66	lockstruct->ls_first = 1;
	67	lockstruct->ls_lvb_size = min_lvb_size;
	68	lockstruct->ls_ops = &nolock_ops;
	69	lockstruct->ls_flags = LM_LSFLAG_LOCAL;
	70
	71	return 0;
	72	}
	73
b3b94faa	74	/**
2b557f6d	75	* gfs2_register_lockproto - Register a low-level locking protocol
b3b94faa DT	76	* @proto: the protocol definition
	77	*
	78	* Returns: 0 on success, -EXXX on failure
	79	*/
	80
9b47c11d	81	int gfs2_register_lockproto(const struct lm_lockops *proto)
b3b94faa DT	82	{
	83	struct lmh_wrapper *lw;
	84
a74604be	85	mutex_lock(&lmh_lock);
b3b94faa DT	86
	87	list_for_each_entry(lw, &lmh_list, lw_list) {
	88	if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
a74604be	89	mutex_unlock(&lmh_lock);
d92a8d48	90	printk(KERN_INFO "GFS2: protocol %s already exists\n",
b3b94faa DT	91	proto->lm_proto_name);
	92	return -EEXIST;
	93	}
	94	}
	95
d92a8d48	96	lw = kzalloc(sizeof(struct lmh_wrapper), GFP_KERNEL);
b3b94faa	97	if (!lw) {
a74604be	98	mutex_unlock(&lmh_lock);
b3b94faa DT	99	return -ENOMEM;
b3b94faa DT	100	}
b3b94faa DT	101
	102	lw->lw_ops = proto;
	103	list_add(&lw->lw_list, &lmh_list);
	104
a74604be	105	mutex_unlock(&lmh_lock);
b3b94faa DT	106
	107	return 0;
	108	}
	109
	110	/**
2b557f6d	111	* gfs2_unregister_lockproto - Unregister a low-level locking protocol
b3b94faa DT	112	* @proto: the protocol definition
	113	*
	114	*/
	115
9b47c11d	116	void gfs2_unregister_lockproto(const struct lm_lockops *proto)
b3b94faa DT	117	{
	118	struct lmh_wrapper *lw;
	119
a74604be	120	mutex_lock(&lmh_lock);
b3b94faa DT	121
	122	list_for_each_entry(lw, &lmh_list, lw_list) {
	123	if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
	124	list_del(&lw->lw_list);
a74604be	125	mutex_unlock(&lmh_lock);
b3b94faa DT	126	kfree(lw);
	127	return;
	128	}
	129	}
	130
a74604be	131	mutex_unlock(&lmh_lock);
b3b94faa	132
d92a8d48	133	printk(KERN_WARNING "GFS2: can't unregister lock protocol %s\n",
b3b94faa DT	134	proto->lm_proto_name);
	135	}
	136
	137	/**
	138	* gfs2_mount_lockproto - Mount a lock protocol
	139	* @proto_name - the name of the protocol
	140	* @table_name - the name of the lock space
	141	* @host_data - data specific to this host
	142	* @cb - the callback to the code using the lock module
1c089c32	143	* @sdp - The GFS2 superblock
b3b94faa DT	144	* @min_lvb_size - the mininum LVB size that the caller can deal with
	145	* @flags - LM_MFLAG_*
	146	* @lockstruct - a structure returned describing the mount
	147	*
	148	* Returns: 0 on success, -EXXX on failure
	149	*/
	150
	151	int gfs2_mount_lockproto(char proto_name, char table_name, char *host_data,
9b47c11d	152	lm_callback_t cb, void *cb_data,
b3b94faa DT	153	unsigned int min_lvb_size, int flags,
	154	struct lm_lockstruct *lockstruct,
	155	struct kobject *fskobj)
	156	{
	157	struct lmh_wrapper *lw = NULL;
	158	int try = 0;
	159	int error, found;
	160
048bca22	161
2b557f6d	162	retry:
a74604be	163	mutex_lock(&lmh_lock);
b3b94faa	164
048bca22	165	if (list_empty(&nolock_proto.lw_list))
80274737	166	list_add(&nolock_proto.lw_list, &lmh_list);
048bca22	167
b3b94faa DT	168	found = 0;
	169	list_for_each_entry(lw, &lmh_list, lw_list) {
	170	if (!strcmp(lw->lw_ops->lm_proto_name, proto_name)) {
	171	found = 1;
	172	break;
	173	}
	174	}
	175
	176	if (!found) {
	177	if (!try && capable(CAP_SYS_MODULE)) {
	178	try = 1;
a74604be	179	mutex_unlock(&lmh_lock);
b3b94faa DT	180	request_module(proto_name);
	181	goto retry;
	182	}
d92a8d48	183	printk(KERN_INFO "GFS2: can't find protocol %s\n", proto_name);
b3b94faa DT	184	error = -ENOENT;
	185	goto out;
	186	}
	187
048bca22 SW	188	if (lw->lw_ops->lm_owner &&
048bca22 SW	189	!try_module_get(lw->lw_ops->lm_owner)) {
b3b94faa	190	try = 0;
a74604be	191	mutex_unlock(&lmh_lock);
b3b94faa DT	192	msleep(1000);
	193	goto retry;
	194	}
	195
9b47c11d	196	error = lw->lw_ops->lm_mount(table_name, host_data, cb, cb_data,
b3b94faa DT	197	min_lvb_size, flags, lockstruct, fskobj);
	198	if (error)
	199	module_put(lw->lw_ops->lm_owner);
2b557f6d	200	out:
a74604be	201	mutex_unlock(&lmh_lock);
b3b94faa DT	202	return error;
	203	}
	204
	205	void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct)
	206	{
a74604be	207	mutex_lock(&lmh_lock);
048bca22 SW	208	if (lockstruct->ls_ops->lm_unmount)
048bca22 SW	209	lockstruct->ls_ops->lm_unmount(lockstruct->ls_lockspace);
b3b94faa DT	210	if (lockstruct->ls_ops->lm_owner)
b3b94faa DT	211	module_put(lockstruct->ls_ops->lm_owner);
a74604be	212	mutex_unlock(&lmh_lock);
b3b94faa DT	213	}
	214
	215	/**
	216	* gfs2_withdraw_lockproto - abnormally unmount a lock module
	217	* @lockstruct: the lockstruct passed into mount
	218	*
	219	*/
	220
	221	void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct)
	222	{
a74604be	223	mutex_lock(&lmh_lock);
b3b94faa DT	224	lockstruct->ls_ops->lm_withdraw(lockstruct->ls_lockspace);
	225	if (lockstruct->ls_ops->lm_owner)
	226	module_put(lockstruct->ls_ops->lm_owner);
a74604be	227	mutex_unlock(&lmh_lock);
b3b94faa DT	228	}
b3b94faa DT	229
2b557f6d SW	230	EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
2b557f6d SW	231	EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
b3b94faa	232