Merge tag 'keys-next-20171123' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowe...
[linux-2.6-microblaze.git] / fs / nfs_common / grace.c
1 /*
2  * Common code for control of lockd and nfsv4 grace periods.
3  *
4  * Transplanted from lockd code
5  */
6
7 #include <linux/module.h>
8 #include <net/net_namespace.h>
9 #include <net/netns/generic.h>
10 #include <linux/fs.h>
11
12 static unsigned int grace_net_id;
13 static DEFINE_SPINLOCK(grace_lock);
14
15 /**
16  * locks_start_grace
17  * @net: net namespace that this lock manager belongs to
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  */
27 void
28 locks_start_grace(struct net *net, struct lock_manager *lm)
29 {
30         struct list_head *grace_list = net_generic(net, grace_net_id);
31
32         spin_lock(&grace_lock);
33         list_add(&lm->list, grace_list);
34         spin_unlock(&grace_lock);
35 }
36 EXPORT_SYMBOL_GPL(locks_start_grace);
37
38 /**
39  * locks_end_grace
40  * @net: net namespace that this lock manager belongs to
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  */
49 void
50 locks_end_grace(struct lock_manager *lm)
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 static bool
59 __state_in_grace(struct net *net, bool open)
60 {
61         struct list_head *grace_list = net_generic(net, grace_net_id);
62         struct lock_manager *lm;
63
64         if (!open)
65                 return !list_empty(grace_list);
66
67         list_for_each_entry(lm, grace_list, list) {
68                 if (lm->block_opens)
69                         return true;
70         }
71         return false;
72 }
73
74 /**
75  * locks_in_grace
76  *
77  * Lock managers call this function to determine when it is OK for them
78  * to answer ordinary lock requests, and when they should accept only
79  * lock reclaims.
80  */
81 bool locks_in_grace(struct net *net)
82 {
83         return __state_in_grace(net, false);
84 }
85 EXPORT_SYMBOL_GPL(locks_in_grace);
86
87 bool opens_in_grace(struct net *net)
88 {
89         return __state_in_grace(net, true);
90 }
91 EXPORT_SYMBOL_GPL(opens_in_grace);
92
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)