[linux.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;
};

/* 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 LIST_HEAD(lmh_list);
static DEFINE_MUTEX(lmh_lock);

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

	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 (!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);
	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	};
	25
	26	/* List of registered low-level locking protocols. A file system selects one
	27	of them by name at mount time, e.g. lock_nolock, lock_dlm. */
	28
50299965 SW	29	static LIST_HEAD(lmh_list);
50299965 SW	30	static DEFINE_MUTEX(lmh_lock);
b3b94faa DT	31
b3b94faa DT	32	/**
2b557f6d	33	* gfs2_register_lockproto - Register a low-level locking protocol
b3b94faa DT	34	* @proto: the protocol definition
	35	*
	36	* Returns: 0 on success, -EXXX on failure
	37	*/
	38
9b47c11d	39	int gfs2_register_lockproto(const struct lm_lockops *proto)
b3b94faa DT	40	{
	41	struct lmh_wrapper *lw;
	42
a74604be	43	mutex_lock(&lmh_lock);
b3b94faa DT	44
	45	list_for_each_entry(lw, &lmh_list, lw_list) {
	46	if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
a74604be	47	mutex_unlock(&lmh_lock);
d92a8d48	48	printk(KERN_INFO "GFS2: protocol %s already exists\n",
b3b94faa DT	49	proto->lm_proto_name);
	50	return -EEXIST;
	51	}
	52	}
	53
d92a8d48	54	lw = kzalloc(sizeof(struct lmh_wrapper), GFP_KERNEL);
b3b94faa	55	if (!lw) {
a74604be	56	mutex_unlock(&lmh_lock);
b3b94faa DT	57	return -ENOMEM;
b3b94faa DT	58	}
b3b94faa DT	59
	60	lw->lw_ops = proto;
	61	list_add(&lw->lw_list, &lmh_list);
	62
a74604be	63	mutex_unlock(&lmh_lock);
b3b94faa DT	64
	65	return 0;
	66	}
	67
	68	/**
2b557f6d	69	* gfs2_unregister_lockproto - Unregister a low-level locking protocol
b3b94faa DT	70	* @proto: the protocol definition
	71	*
	72	*/
	73
9b47c11d	74	void gfs2_unregister_lockproto(const struct lm_lockops *proto)
b3b94faa DT	75	{
	76	struct lmh_wrapper *lw;
	77
a74604be	78	mutex_lock(&lmh_lock);
b3b94faa DT	79
	80	list_for_each_entry(lw, &lmh_list, lw_list) {
	81	if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
	82	list_del(&lw->lw_list);
a74604be	83	mutex_unlock(&lmh_lock);
b3b94faa DT	84	kfree(lw);
	85	return;
	86	}
	87	}
	88
a74604be	89	mutex_unlock(&lmh_lock);
b3b94faa	90
d92a8d48	91	printk(KERN_WARNING "GFS2: can't unregister lock protocol %s\n",
b3b94faa DT	92	proto->lm_proto_name);
	93	}
	94
	95	/**
	96	* gfs2_mount_lockproto - Mount a lock protocol
	97	* @proto_name - the name of the protocol
	98	* @table_name - the name of the lock space
	99	* @host_data - data specific to this host
	100	* @cb - the callback to the code using the lock module
1c089c32	101	* @sdp - The GFS2 superblock
b3b94faa DT	102	* @min_lvb_size - the mininum LVB size that the caller can deal with
	103	* @flags - LM_MFLAG_*
	104	* @lockstruct - a structure returned describing the mount
	105	*
	106	* Returns: 0 on success, -EXXX on failure
	107	*/
	108
	109	int gfs2_mount_lockproto(char proto_name, char table_name, char *host_data,
9b47c11d	110	lm_callback_t cb, void *cb_data,
b3b94faa DT	111	unsigned int min_lvb_size, int flags,
	112	struct lm_lockstruct *lockstruct,
	113	struct kobject *fskobj)
	114	{
	115	struct lmh_wrapper *lw = NULL;
	116	int try = 0;
	117	int error, found;
	118
2b557f6d	119	retry:
a74604be	120	mutex_lock(&lmh_lock);
b3b94faa DT	121
	122	found = 0;
	123	list_for_each_entry(lw, &lmh_list, lw_list) {
	124	if (!strcmp(lw->lw_ops->lm_proto_name, proto_name)) {
	125	found = 1;
	126	break;
	127	}
	128	}
	129
	130	if (!found) {
	131	if (!try && capable(CAP_SYS_MODULE)) {
	132	try = 1;
a74604be	133	mutex_unlock(&lmh_lock);
b3b94faa DT	134	request_module(proto_name);
	135	goto retry;
	136	}
d92a8d48	137	printk(KERN_INFO "GFS2: can't find protocol %s\n", proto_name);
b3b94faa DT	138	error = -ENOENT;
	139	goto out;
	140	}
	141
	142	if (!try_module_get(lw->lw_ops->lm_owner)) {
	143	try = 0;
a74604be	144	mutex_unlock(&lmh_lock);
b3b94faa DT	145	msleep(1000);
	146	goto retry;
	147	}
	148
9b47c11d	149	error = lw->lw_ops->lm_mount(table_name, host_data, cb, cb_data,
b3b94faa DT	150	min_lvb_size, flags, lockstruct, fskobj);
	151	if (error)
	152	module_put(lw->lw_ops->lm_owner);
2b557f6d	153	out:
a74604be	154	mutex_unlock(&lmh_lock);
b3b94faa DT	155	return error;
	156	}
	157
	158	void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct)
	159	{
a74604be	160	mutex_lock(&lmh_lock);
b3b94faa DT	161	lockstruct->ls_ops->lm_unmount(lockstruct->ls_lockspace);
	162	if (lockstruct->ls_ops->lm_owner)
	163	module_put(lockstruct->ls_ops->lm_owner);
a74604be	164	mutex_unlock(&lmh_lock);
b3b94faa DT	165	}
	166
	167	/**
	168	* gfs2_withdraw_lockproto - abnormally unmount a lock module
	169	* @lockstruct: the lockstruct passed into mount
	170	*
	171	*/
	172
	173	void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct)
	174	{
a74604be	175	mutex_lock(&lmh_lock);
b3b94faa DT	176	lockstruct->ls_ops->lm_withdraw(lockstruct->ls_lockspace);
	177	if (lockstruct->ls_ops->lm_owner)
	178	module_put(lockstruct->ls_ops->lm_owner);
a74604be	179	mutex_unlock(&lmh_lock);
b3b94faa DT	180	}
b3b94faa DT	181
2b557f6d SW	182	EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
2b557f6d SW	183	EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
b3b94faa	184