1/*
 2 * Common code for control of lockd and nfsv4 grace periods.
 3 */
 4
 5#include <linux/module.h>
 6#include <linux/lockd/bind.h>
 
 
 
 7
 8static LIST_HEAD(grace_list);
 9static DEFINE_SPINLOCK(grace_lock);
10
11/**
12 * locks_start_grace
13 * @lm: who this grace period is for
14 *
15 * A grace period is a period during which locks should not be given
16 * out.  Currently grace periods are only enforced by the two lock
17 * managers (lockd and nfsd), using the locks_in_grace() function to
18 * check when they are in a grace period.
19 *
20 * This function is called to start a grace period.
21 */
22void locks_start_grace(struct lock_manager *lm)
23{
 
 
24	spin_lock(&grace_lock);
25	list_add(&lm->list, &grace_list);
26	spin_unlock(&grace_lock);
27}
28EXPORT_SYMBOL_GPL(locks_start_grace);
29
30/**
31 * locks_end_grace
32 * @lm: who this grace period is for
33 *
34 * Call this function to state that the given lock manager is ready to
35 * resume regular locking.  The grace period will not end until all lock
36 * managers that called locks_start_grace() also call locks_end_grace().
37 * Note that callers count on it being safe to call this more than once,
38 * and the second call should be a no-op.
39 */
40void locks_end_grace(struct lock_manager *lm)
41{
42	spin_lock(&grace_lock);
43	list_del_init(&lm->list);
44	spin_unlock(&grace_lock);
45}
46EXPORT_SYMBOL_GPL(locks_end_grace);
47
48/**
49 * locks_in_grace
50 *
51 * Lock managers call this function to determine when it is OK for them
52 * to answer ordinary lock requests, and when they should accept only
53 * lock reclaims.
54 */
55int locks_in_grace(void)
56{
57	return !list_empty(&grace_list);
 
 
58}
59EXPORT_SYMBOL_GPL(locks_in_grace);

 1/*
 2 * Common code for control of lockd and nfsv4 grace periods.
 3 */
 4
 5#include <linux/module.h>
 6#include <linux/lockd/bind.h>
 7#include <net/net_namespace.h>
 8
 9#include "netns.h"
10
 
11static DEFINE_SPINLOCK(grace_lock);
12
13/**
14 * locks_start_grace
15 * @lm: who this grace period is for
16 *
17 * A grace period is a period during which locks should not be given
18 * out.  Currently grace periods are only enforced by the two lock
19 * managers (lockd and nfsd), using the locks_in_grace() function to
20 * check when they are in a grace period.
21 *
22 * This function is called to start a grace period.
23 */
24void locks_start_grace(struct net *net, struct lock_manager *lm)
25{
26	struct lockd_net *ln = net_generic(net, lockd_net_id);
27
28	spin_lock(&grace_lock);
29	list_add(&lm->list, &ln->grace_list);
30	spin_unlock(&grace_lock);
31}
32EXPORT_SYMBOL_GPL(locks_start_grace);
33
34/**
35 * locks_end_grace
36 * @lm: who this grace period is for
37 *
38 * Call this function to state that the given lock manager is ready to
39 * resume regular locking.  The grace period will not end until all lock
40 * managers that called locks_start_grace() also call locks_end_grace().
41 * Note that callers count on it being safe to call this more than once,
42 * and the second call should be a no-op.
43 */
44void locks_end_grace(struct lock_manager *lm)
45{
46	spin_lock(&grace_lock);
47	list_del_init(&lm->list);
48	spin_unlock(&grace_lock);
49}
50EXPORT_SYMBOL_GPL(locks_end_grace);
51
52/**
53 * locks_in_grace
54 *
55 * Lock managers call this function to determine when it is OK for them
56 * to answer ordinary lock requests, and when they should accept only
57 * lock reclaims.
58 */
59int locks_in_grace(struct net *net)
60{
61	struct lockd_net *ln = net_generic(net, lockd_net_id);
62
63	return !list_empty(&ln->grace_list);
64}
65EXPORT_SYMBOL_GPL(locks_in_grace);