[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
__state_in_grace(struct net *net, bool open)
{
	struct list_head *grace_list = net_generic(net, grace_net_id);
	struct lock_manager *lm;

	if (!open)
		return !list_empty(grace_list);

	list_for_each_entry(lm, grace_list, list) {
		if (lm->block_opens)
			return true;
	}
	return false;
}

int locks_in_grace(struct net *net)
{
	return __state_in_grace(net, 0);
}
EXPORT_SYMBOL_GPL(locks_in_grace);

int opens_in_grace(struct net *net)
{
	return __state_in_grace(net, 1);
}
EXPORT_SYMBOL_GPL(opens_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	65	int
c87fb4a3	66	__state_in_grace(struct net *net, bool open)
af558e33	67	{
f7790029	68	struct list_head *grace_list = net_generic(net, grace_net_id);
c87fb4a3	69	struct lock_manager *lm;
db9c4553	70
c87fb4a3 BF	71	if (!open)
	72	return !list_empty(grace_list);
	73
	74	list_for_each_entry(lm, grace_list, list) {
	75	if (lm->block_opens)
	76	return true;
	77	}
	78	return false;
	79	}
	80
	81	int locks_in_grace(struct net *net)
	82	{
	83	return __state_in_grace(net, 0);
af558e33 BF	84	}
af558e33 BF	85	EXPORT_SYMBOL_GPL(locks_in_grace);
f7790029	86
c87fb4a3 BF	87	int opens_in_grace(struct net *net)
	88	{
	89	return __state_in_grace(net, 1);
	90	}
	91	EXPORT_SYMBOL_GPL(opens_in_grace);
	92
f7790029 JL	93	static int __net_init
	94	grace_init_net(struct net *net)
	95	{
	96	struct list_head *grace_list = net_generic(net, grace_net_id);
	97
	98	INIT_LIST_HEAD(grace_list);
	99	return 0;
	100	}
	101
	102	static void __net_exit
	103	grace_exit_net(struct net *net)
	104	{
	105	struct list_head *grace_list = net_generic(net, grace_net_id);
	106
	107	BUG_ON(!list_empty(grace_list));
	108	}
	109
	110	static struct pernet_operations grace_net_ops = {
	111	.init = grace_init_net,
	112	.exit = grace_exit_net,
	113	.id = &grace_net_id,
	114	.size = sizeof(struct list_head),
	115	};
	116
	117	static int __init
	118	init_grace(void)
	119	{
	120	return register_pernet_subsys(&grace_net_ops);
	121	}
	122
	123	static void __exit
	124	exit_grace(void)
	125	{
	126	unregister_pernet_subsys(&grace_net_ops);
	127	}
	128
	129	MODULE_AUTHOR("Jeff Layton <jlayton@primarydata.com>");
	130	MODULE_LICENSE("GPL");
	131	module_init(init_grace)
	132	module_exit(exit_grace)