[linux-2.6-block.git] / fs / nfs_common / grace.c

/*
 * Common code for control of lockd and nfsv4 grace periods.
 *
 * Transplanted from lockd code
 */

#include <linux/module.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <linux/fs.h>

static int grace_net_id;
static DEFINE_SPINLOCK(grace_lock);

/**
 * locks_start_grace
 * @net: net namespace that this lock manager belongs to
 * @lm: who this grace period is for
 *
 * A grace period is a period during which locks should not be given
 * out.  Currently grace periods are only enforced by the two lock
 * managers (lockd and nfsd), using the locks_in_grace() function to
 * check when they are in a grace period.
 *
 * This function is called to start a grace period.
 */
void
locks_start_grace(struct net *net, struct lock_manager *lm)
{
	struct list_head *grace_list = net_generic(net, grace_net_id);

	spin_lock(&grace_lock);
	list_add(&lm->list, grace_list);
	spin_unlock(&grace_lock);
}
EXPORT_SYMBOL_GPL(locks_start_grace);

/**
 * locks_end_grace
 * @net: net namespace that this lock manager belongs to
 * @lm: who this grace period is for
 *
 * Call this function to state that the given lock manager is ready to
 * resume regular locking.  The grace period will not end until all lock
 * managers that called locks_start_grace() also call locks_end_grace().
 * Note that callers count on it being safe to call this more than once,
 * and the second call should be a no-op.
 */
void
locks_end_grace(struct lock_manager *lm)
{
	spin_lock(&grace_lock);
	list_del_init(&lm->list);
	spin_unlock(&grace_lock);
}
EXPORT_SYMBOL_GPL(locks_end_grace);

/**
 * locks_in_grace
 *
 * Lock managers call this function to determine when it is OK for them
 * to answer ordinary lock requests, and when they should accept only
 * lock reclaims.
 */
int
locks_in_grace(struct net *net)
{
	struct list_head *grace_list = net_generic(net, grace_net_id);

	return !list_empty(grace_list);
}
EXPORT_SYMBOL_GPL(locks_in_grace);

static int __net_init
grace_init_net(struct net *net)
{
	struct list_head *grace_list = net_generic(net, grace_net_id);

	INIT_LIST_HEAD(grace_list);
	return 0;
}

static void __net_exit
grace_exit_net(struct net *net)
{
	struct list_head *grace_list = net_generic(net, grace_net_id);

	BUG_ON(!list_empty(grace_list));
}

static struct pernet_operations grace_net_ops = {
	.init = grace_init_net,
	.exit = grace_exit_net,
	.id   = &grace_net_id,
	.size = sizeof(struct list_head),
};

static int __init
init_grace(void)
{
	return register_pernet_subsys(&grace_net_ops);
}

static void __exit
exit_grace(void)
{
	unregister_pernet_subsys(&grace_net_ops);
}

MODULE_AUTHOR("Jeff Layton <jlayton@primarydata.com>");
MODULE_LICENSE("GPL");
module_init(init_grace)
module_exit(exit_grace)
Commit	Line	Data
af558e33 BF	1	/*
af558e33 BF	2	* Common code for control of lockd and nfsv4 grace periods.
f7790029 JL	3	*
f7790029 JL	4	* Transplanted from lockd code
af558e33 BF	5	*/
	6
	7	#include <linux/module.h>
db9c4553	8	#include <net/net_namespace.h>
f7790029 JL	9	#include <net/netns/generic.h>
f7790029 JL	10	#include <linux/fs.h>
db9c4553	11
f7790029	12	static int grace_net_id;
af558e33 BF	13	static DEFINE_SPINLOCK(grace_lock);
	14
	15	/**
	16	* locks_start_grace
f7790029	17	* @net: net namespace that this lock manager belongs to
af558e33 BF	18	* @lm: who this grace period is for
	19	*
	20	* A grace period is a period during which locks should not be given
	21	* out. Currently grace periods are only enforced by the two lock
	22	* managers (lockd and nfsd), using the locks_in_grace() function to
	23	* check when they are in a grace period.
	24	*
	25	* This function is called to start a grace period.
	26	*/
f7790029 JL	27	void
f7790029 JL	28	locks_start_grace(struct net net, struct lock_manager lm)
af558e33	29	{
f7790029	30	struct list_head *grace_list = net_generic(net, grace_net_id);
db9c4553	31
af558e33	32	spin_lock(&grace_lock);
f7790029	33	list_add(&lm->list, grace_list);
af558e33 BF	34	spin_unlock(&grace_lock);
	35	}
	36	EXPORT_SYMBOL_GPL(locks_start_grace);
	37
	38	/**
	39	* locks_end_grace
f7790029	40	* @net: net namespace that this lock manager belongs to
af558e33 BF	41	* @lm: who this grace period is for
	42	*
	43	* Call this function to state that the given lock manager is ready to
	44	* resume regular locking. The grace period will not end until all lock
	45	* managers that called locks_start_grace() also call locks_end_grace().
	46	* Note that callers count on it being safe to call this more than once,
	47	* and the second call should be a no-op.
	48	*/
f7790029 JL	49	void
f7790029 JL	50	locks_end_grace(struct lock_manager *lm)
af558e33 BF	51	{
	52	spin_lock(&grace_lock);
	53	list_del_init(&lm->list);
	54	spin_unlock(&grace_lock);
	55	}
	56	EXPORT_SYMBOL_GPL(locks_end_grace);
	57
	58	/**
	59	* locks_in_grace
	60	*
	61	* Lock managers call this function to determine when it is OK for them
	62	* to answer ordinary lock requests, and when they should accept only
	63	* lock reclaims.
	64	*/
f7790029 JL	65	int
f7790029 JL	66	locks_in_grace(struct net *net)
af558e33	67	{
f7790029	68	struct list_head *grace_list = net_generic(net, grace_net_id);
db9c4553	69
f7790029	70	return !list_empty(grace_list);
af558e33 BF	71	}
af558e33 BF	72	EXPORT_SYMBOL_GPL(locks_in_grace);
f7790029 JL	73
	74	static int __net_init
	75	grace_init_net(struct net *net)
	76	{
	77	struct list_head *grace_list = net_generic(net, grace_net_id);
	78
	79	INIT_LIST_HEAD(grace_list);
	80	return 0;
	81	}
	82
	83	static void __net_exit
	84	grace_exit_net(struct net *net)
	85	{
	86	struct list_head *grace_list = net_generic(net, grace_net_id);
	87
	88	BUG_ON(!list_empty(grace_list));
	89	}
	90
	91	static struct pernet_operations grace_net_ops = {
	92	.init = grace_init_net,
	93	.exit = grace_exit_net,
	94	.id = &grace_net_id,
	95	.size = sizeof(struct list_head),
	96	};
	97
	98	static int __init
	99	init_grace(void)
	100	{
	101	return register_pernet_subsys(&grace_net_ops);
	102	}
	103
	104	static void __exit
	105	exit_grace(void)
	106	{
	107	unregister_pernet_subsys(&grace_net_ops);
	108	}
	109
	110	MODULE_AUTHOR("Jeff Layton <jlayton@primarydata.com>");
	111	MODULE_LICENSE("GPL");
	112	module_init(init_grace)
	113	module_exit(exit_grace)