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
locks_start_grace(struct net * net,struct lock_manager * lm)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 if (list_empty(&lm->list))
34 list_add(&lm->list, grace_list);
35 else
36 WARN(1, "double list_add attempt detected in net %x %s\n",
37 net->ns.inum, (net == &init_net) ? "(init_net)" : "");
38 spin_unlock(&grace_lock);
39 }
40 EXPORT_SYMBOL_GPL(locks_start_grace);
41
42 /**
43 * locks_end_grace
44 * @net: net namespace that this lock manager belongs to
45 * @lm: who this grace period is for
46 *
47 * Call this function to state that the given lock manager is ready to
48 * resume regular locking. The grace period will not end until all lock
49 * managers that called locks_start_grace() also call locks_end_grace().
50 * Note that callers count on it being safe to call this more than once,
51 * and the second call should be a no-op.
52 */
53 void
locks_end_grace(struct lock_manager * lm)54 locks_end_grace(struct lock_manager *lm)
55 {
56 spin_lock(&grace_lock);
57 list_del_init(&lm->list);
58 spin_unlock(&grace_lock);
59 }
60 EXPORT_SYMBOL_GPL(locks_end_grace);
61
62 static bool
__state_in_grace(struct net * net,bool open)63 __state_in_grace(struct net *net, bool open)
64 {
65 struct list_head *grace_list = net_generic(net, grace_net_id);
66 struct lock_manager *lm;
67
68 if (!open)
69 return !list_empty(grace_list);
70
71 spin_lock(&grace_lock);
72 list_for_each_entry(lm, grace_list, list) {
73 if (lm->block_opens) {
74 spin_unlock(&grace_lock);
75 return true;
76 }
77 }
78 spin_unlock(&grace_lock);
79 return false;
80 }
81
82 /**
83 * locks_in_grace
84 *
85 * Lock managers call this function to determine when it is OK for them
86 * to answer ordinary lock requests, and when they should accept only
87 * lock reclaims.
88 */
locks_in_grace(struct net * net)89 bool locks_in_grace(struct net *net)
90 {
91 return __state_in_grace(net, false);
92 }
93 EXPORT_SYMBOL_GPL(locks_in_grace);
94
opens_in_grace(struct net * net)95 bool opens_in_grace(struct net *net)
96 {
97 return __state_in_grace(net, true);
98 }
99 EXPORT_SYMBOL_GPL(opens_in_grace);
100
101 static int __net_init
grace_init_net(struct net * net)102 grace_init_net(struct net *net)
103 {
104 struct list_head *grace_list = net_generic(net, grace_net_id);
105
106 INIT_LIST_HEAD(grace_list);
107 return 0;
108 }
109
110 static void __net_exit
grace_exit_net(struct net * net)111 grace_exit_net(struct net *net)
112 {
113 struct list_head *grace_list = net_generic(net, grace_net_id);
114
115 WARN_ONCE(!list_empty(grace_list),
116 "net %x %s: grace_list is not empty\n",
117 net->ns.inum, __func__);
118 }
119
120 static struct pernet_operations grace_net_ops = {
121 .init = grace_init_net,
122 .exit = grace_exit_net,
123 .id = &grace_net_id,
124 .size = sizeof(struct list_head),
125 };
126
127 static int __init
init_grace(void)128 init_grace(void)
129 {
130 return register_pernet_subsys(&grace_net_ops);
131 }
132
133 static void __exit
exit_grace(void)134 exit_grace(void)
135 {
136 unregister_pernet_subsys(&grace_net_ops);
137 }
138
139 MODULE_AUTHOR("Jeff Layton <jlayton@primarydata.com>");
140 MODULE_LICENSE("GPL");
141 module_init(init_grace)
142 module_exit(exit_grace)
143