blob: c19123dcd1a41c8182db1ee5db84bfd6e11644e1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/lockd/svc.c
3 *
4 * This is the central lockd service.
5 *
6 * FIXME: Separate the lockd NFS server functionality from the lockd NFS
7 * client functionality. Oh why didn't Sun create two separate
8 * services in the first place?
9 *
10 * Authors: Olaf Kirch (okir@monad.swb.de)
11 *
12 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
13 */
14
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/sysctl.h>
18#include <linux/moduleparam.h>
19
20#include <linux/sched.h>
21#include <linux/errno.h>
22#include <linux/in.h>
23#include <linux/uio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/smp.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080025#include <linux/mutex.h>
Jeff Laytond751a7c2008-02-07 16:34:55 -050026#include <linux/kthread.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070027#include <linux/freezer.h>
Scott Mayhew0751ddf2015-12-11 16:46:00 -050028#include <linux/inetdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include <linux/sunrpc/types.h>
31#include <linux/sunrpc/stats.h>
32#include <linux/sunrpc/clnt.h>
33#include <linux/sunrpc/svc.h>
34#include <linux/sunrpc/svcsock.h>
Scott Mayhew0751ddf2015-12-11 16:46:00 -050035#include <linux/sunrpc/svc_xprt.h>
NeilBrown24e36662006-10-02 02:17:45 -070036#include <net/ip.h>
Scott Mayhew0751ddf2015-12-11 16:46:00 -050037#include <net/addrconf.h>
38#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <linux/lockd/lockd.h>
40#include <linux/nfs.h>
41
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +040042#include "netns.h"
Jeff Laytond68e3c42014-09-12 16:40:20 -040043#include "procfs.h"
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +040044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define NLMDBG_FACILITY NLMDBG_SVC
46#define LOCKD_BUFSIZE (1024 + NLMSVC_XDRSIZE)
47#define ALLOWED_SIGS (sigmask(SIGKILL))
48
49static struct svc_program nlmsvc_program;
50
Julia Lawall2a297452015-12-23 22:25:13 +010051const struct nlmsvc_binding *nlmsvc_ops;
Trond Myklebust2de59872008-12-23 15:21:33 -050052EXPORT_SYMBOL_GPL(nlmsvc_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Ingo Molnar353ab6e2006-03-26 01:37:12 -080054static DEFINE_MUTEX(nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055static unsigned int nlmsvc_users;
Jeff Laytond751a7c2008-02-07 16:34:55 -050056static struct task_struct *nlmsvc_task;
Jeff Laytonabd1ec42008-06-11 10:03:12 -040057static struct svc_rqst *nlmsvc_rqst;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058unsigned long nlmsvc_timeout;
59
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +040060int lockd_net_id;
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062/*
63 * These can be set at insmod time (useful for NFS as root filesystem),
64 * and also changed through the sysctl interface. -- Jamie Lokier, Aug 2003
65 */
66static unsigned long nlm_grace_period;
67static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO;
68static int nlm_udpport, nlm_tcpport;
69
Jeff Laytonc72a4762008-10-20 11:51:58 -040070/* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
71static unsigned int nlm_max_connections = 1024;
72
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/*
74 * Constants needed for the sysctl interface.
75 */
76static const unsigned long nlm_grace_period_min = 0;
77static const unsigned long nlm_grace_period_max = 240;
78static const unsigned long nlm_timeout_min = 3;
79static const unsigned long nlm_timeout_max = 20;
80static const int nlm_port_min = 0, nlm_port_max = 65535;
81
Chuck Lever90d5b182008-03-14 14:18:30 -040082#ifdef CONFIG_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -070083static struct ctl_table_header * nlm_sysctl_table;
Chuck Lever90d5b182008-03-14 14:18:30 -040084#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Marc Eshel9a8db972007-07-17 04:04:35 -070086static unsigned long get_lockd_grace_period(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 /* Note: nlm_timeout should always be nonzero */
89 if (nlm_grace_period)
Marc Eshel9a8db972007-07-17 04:04:35 -070090 return roundup(nlm_grace_period, nlm_timeout) * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 else
Marc Eshel9a8db972007-07-17 04:04:35 -070092 return nlm_timeout * 5 * HZ;
93}
94
Stanislav Kinsbursky08d44a32012-07-25 16:56:50 +040095static void grace_ender(struct work_struct *grace)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
Geliang Tangea444632016-01-01 22:06:29 +080097 struct delayed_work *dwork = to_delayed_work(grace);
Stanislav Kinsbursky08d44a32012-07-25 16:56:50 +040098 struct lockd_net *ln = container_of(dwork, struct lockd_net,
99 grace_period_end);
100
101 locks_end_grace(&ln->lockd_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102}
103
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +0400104static void set_grace_period(struct net *net)
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400105{
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -0400106 unsigned long grace_period = get_lockd_grace_period();
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +0400107 struct lockd_net *ln = net_generic(net, lockd_net_id);
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400108
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +0400109 locks_start_grace(net, &ln->lockd_manager);
Stanislav Kinsbursky66547b02012-07-25 16:56:43 +0400110 cancel_delayed_work_sync(&ln->grace_period_end);
111 schedule_delayed_work(&ln->grace_period_end, grace_period);
J. Bruce Fieldsc8ab5f22008-03-18 19:00:19 -0400112}
113
J. Bruce Fields89996df2009-05-06 16:32:54 -0400114static void restart_grace(void)
115{
116 if (nlmsvc_ops) {
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +0400117 struct net *net = &init_net;
118 struct lockd_net *ln = net_generic(net, lockd_net_id);
Stanislav Kinsbursky66547b02012-07-25 16:56:43 +0400119
120 cancel_delayed_work_sync(&ln->grace_period_end);
Stanislav Kinsbursky08d44a32012-07-25 16:56:50 +0400121 locks_end_grace(&ln->lockd_manager);
J. Bruce Fields89996df2009-05-06 16:32:54 -0400122 nlmsvc_invalidate_all();
Stanislav Kinsbursky5ccb0062012-07-25 16:57:22 +0400123 set_grace_period(net);
J. Bruce Fields89996df2009-05-06 16:32:54 -0400124 }
125}
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127/*
128 * This is the lockd kernel thread
129 */
Jeff Laytond751a7c2008-02-07 16:34:55 -0500130static int
131lockd(void *vrqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
J. Bruce Fields5b444cc2012-08-17 21:47:53 -0400133 int err = 0;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500134 struct svc_rqst *rqstp = vrqstp;
J. Bruce Fields75d34f12017-03-28 21:25:08 -0400135 struct net *net = &init_net;
136 struct lockd_net *ln = net_generic(net, lockd_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Jeff Laytond751a7c2008-02-07 16:34:55 -0500138 /* try_to_freeze() is called from svc_recv() */
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700139 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Jeff Laytond751a7c2008-02-07 16:34:55 -0500141 /* Allow SIGKILL to tell lockd to drop all of its locks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 allow_signal(SIGKILL);
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 /*
147 * The main request loop. We don't terminate until the last
Jeff Laytond751a7c2008-02-07 16:34:55 -0500148 * NFS mount or NFS daemon has gone away.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 */
Jeff Laytond751a7c2008-02-07 16:34:55 -0500150 while (!kthread_should_stop()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 long timeout = MAX_SCHEDULE_TIMEOUT;
Pavel Emelyanov5216a8e2008-02-21 10:57:45 +0300152 RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Jeff Laytonc72a4762008-10-20 11:51:58 -0400154 /* update sv_maxconn if it has changed */
155 rqstp->rq_server->sv_maxconn = nlm_max_connections;
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (signalled()) {
158 flush_signals(current);
J. Bruce Fields89996df2009-05-06 16:32:54 -0400159 restart_grace();
Jeff Laytond751a7c2008-02-07 16:34:55 -0500160 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 }
162
J. Bruce Fields8fafa902008-01-24 11:11:34 -0500163 timeout = nlmsvc_retry_blocked();
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 /*
166 * Find a socket with data available and call its
167 * recvfrom routine.
168 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700169 err = svc_recv(rqstp, timeout);
J. Bruce Fields5b444cc2012-08-17 21:47:53 -0400170 if (err == -EAGAIN || err == -EINTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 continue;
Chuck Leverad06e4b2007-02-12 00:53:32 -0800172 dprintk("lockd: request from %s\n",
173 svc_print_addr(rqstp, buf, sizeof(buf)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
NeilBrown6fb2b472006-10-02 02:17:50 -0700175 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
Trond Myklebust2bd61572006-01-03 09:55:19 +0100177 flush_signals(current);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500178 if (nlmsvc_ops)
179 nlmsvc_invalidate_all();
180 nlm_shutdown_hosts();
J. Bruce Fields75d34f12017-03-28 21:25:08 -0400181 cancel_delayed_work_sync(&ln->grace_period_end);
182 locks_end_grace(&ln->lockd_manager);
Jeff Laytond751a7c2008-02-07 16:34:55 -0500183 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184}
185
Chuck Levereb16e902009-03-18 20:47:59 -0400186static int create_lockd_listener(struct svc_serv *serv, const char *name,
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400187 struct net *net, const int family,
188 const unsigned short port)
Chuck Leverd3fe5ea2008-12-31 16:06:04 -0500189{
190 struct svc_xprt *xprt;
191
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400192 xprt = svc_find_xprt(serv, name, net, family, 0);
Chuck Leverd3fe5ea2008-12-31 16:06:04 -0500193 if (xprt == NULL)
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400194 return svc_create_xprt(serv, name, net, family, port,
Chuck Levereb16e902009-03-18 20:47:59 -0400195 SVC_SOCK_DEFAULTS);
Chuck Leverd3fe5ea2008-12-31 16:06:04 -0500196 svc_xprt_put(xprt);
197 return 0;
198}
199
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400200static int create_lockd_family(struct svc_serv *serv, struct net *net,
201 const int family)
Chuck Levereb16e902009-03-18 20:47:59 -0400202{
203 int err;
204
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400205 err = create_lockd_listener(serv, "udp", net, family, nlm_udpport);
Chuck Levereb16e902009-03-18 20:47:59 -0400206 if (err < 0)
207 return err;
208
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400209 return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport);
Chuck Levereb16e902009-03-18 20:47:59 -0400210}
211
Chuck Lever482fb942007-02-12 00:53:29 -0800212/*
Chuck Lever8c3916f2008-10-03 17:15:23 -0400213 * Ensure there are active UDP and TCP listeners for lockd.
214 *
215 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
216 * local services (such as rpc.statd) still require UDP, and
217 * some NFS servers do not yet support NLM over TCP.
218 *
219 * Returns zero if all listeners are available; otherwise a
220 * negative errno value is returned.
Chuck Lever482fb942007-02-12 00:53:29 -0800221 */
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400222static int make_socks(struct svc_serv *serv, struct net *net)
NeilBrown24e36662006-10-02 02:17:45 -0700223{
Chuck Lever482fb942007-02-12 00:53:29 -0800224 static int warned;
Chuck Lever0dba7c22008-12-31 16:06:11 -0500225 int err;
Chuck Lever482fb942007-02-12 00:53:29 -0800226
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400227 err = create_lockd_family(serv, net, PF_INET);
Chuck Lever0dba7c22008-12-31 16:06:11 -0500228 if (err < 0)
229 goto out_err;
230
Stanislav Kinsburskyc228fa22012-01-31 15:07:48 +0400231 err = create_lockd_family(serv, net, PF_INET6);
Chuck Levereb16e902009-03-18 20:47:59 -0400232 if (err < 0 && err != -EAFNOSUPPORT)
Chuck Lever0dba7c22008-12-31 16:06:11 -0500233 goto out_err;
234
235 warned = 0;
236 return 0;
237
238out_err:
239 if (warned++ == 0)
NeilBrown7dcf91e2006-10-02 02:17:52 -0700240 printk(KERN_WARNING
Chuck Lever0dba7c22008-12-31 16:06:11 -0500241 "lockd_up: makesock failed, error=%d\n", err);
Jeff Layton679b0332014-03-25 11:55:26 -0700242 svc_shutdown_net(serv, net);
NeilBrown24e36662006-10-02 02:17:45 -0700243 return err;
244}
245
Stanislav Kinsbursky4db77692012-04-25 18:22:40 +0400246static int lockd_up_net(struct svc_serv *serv, struct net *net)
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400247{
248 struct lockd_net *ln = net_generic(net, lockd_net_id);
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400249 int error;
250
Stanislav Kinsbursky786185b2012-05-04 12:49:41 +0400251 if (ln->nlmsvc_users++)
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400252 return 0;
253
Stanislav Kinsburskydbf9b5d72012-04-25 18:22:47 +0400254 error = svc_bind(serv, net);
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400255 if (error)
Stanislav Kinsburskydbf9b5d72012-04-25 18:22:47 +0400256 goto err_bind;
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400257
258 error = make_socks(serv, net);
259 if (error < 0)
J. Bruce Fields7c177052014-08-29 16:25:50 -0400260 goto err_bind;
Stanislav Kinsbursky5630f7f2012-07-25 16:57:29 +0400261 set_grace_period(net);
Stanislav Kinsbursky8dbf28e2012-04-25 18:23:16 +0400262 dprintk("lockd_up_net: per-net data created; net=%p\n", net);
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400263 return 0;
264
Stanislav Kinsburskydbf9b5d72012-04-25 18:22:47 +0400265err_bind:
Stanislav Kinsbursky786185b2012-05-04 12:49:41 +0400266 ln->nlmsvc_users--;
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400267 return error;
268}
269
Stanislav Kinsbursky4db77692012-04-25 18:22:40 +0400270static void lockd_down_net(struct svc_serv *serv, struct net *net)
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400271{
272 struct lockd_net *ln = net_generic(net, lockd_net_id);
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400273
274 if (ln->nlmsvc_users) {
Stanislav Kinsbursky3b647392012-01-31 15:08:29 +0400275 if (--ln->nlmsvc_users == 0) {
276 nlm_shutdown_hosts_net(net);
Vasily Averin117dd212017-11-02 13:03:42 +0300277 cancel_delayed_work_sync(&ln->grace_period_end);
278 locks_end_grace(&ln->lockd_manager);
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400279 svc_shutdown_net(serv, net);
Stanislav Kinsbursky8dbf28e2012-04-25 18:23:16 +0400280 dprintk("lockd_down_net: per-net data destroyed; net=%p\n", net);
Stanislav Kinsbursky3b647392012-01-31 15:08:29 +0400281 }
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400282 } else {
283 printk(KERN_ERR "lockd_down_net: no users! task=%p, net=%p\n",
284 nlmsvc_task, net);
285 BUG();
286 }
287}
288
Scott Mayhew0751ddf2015-12-11 16:46:00 -0500289static int lockd_inetaddr_event(struct notifier_block *this,
290 unsigned long event, void *ptr)
291{
292 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
293 struct sockaddr_in sin;
294
295 if (event != NETDEV_DOWN)
296 goto out;
297
298 if (nlmsvc_rqst) {
299 dprintk("lockd_inetaddr_event: removed %pI4\n",
300 &ifa->ifa_local);
301 sin.sin_family = AF_INET;
302 sin.sin_addr.s_addr = ifa->ifa_local;
303 svc_age_temp_xprts_now(nlmsvc_rqst->rq_server,
304 (struct sockaddr *)&sin);
305 }
306
307out:
308 return NOTIFY_DONE;
309}
310
311static struct notifier_block lockd_inetaddr_notifier = {
312 .notifier_call = lockd_inetaddr_event,
313};
314
315#if IS_ENABLED(CONFIG_IPV6)
316static int lockd_inet6addr_event(struct notifier_block *this,
317 unsigned long event, void *ptr)
318{
319 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
320 struct sockaddr_in6 sin6;
321
322 if (event != NETDEV_DOWN)
323 goto out;
324
325 if (nlmsvc_rqst) {
326 dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr);
327 sin6.sin6_family = AF_INET6;
328 sin6.sin6_addr = ifa->addr;
329 svc_age_temp_xprts_now(nlmsvc_rqst->rq_server,
330 (struct sockaddr *)&sin6);
331 }
332
333out:
334 return NOTIFY_DONE;
335}
336
337static struct notifier_block lockd_inet6addr_notifier = {
338 .notifier_call = lockd_inet6addr_event,
339};
340#endif
341
Scott Mayhewcb7d224f2016-06-30 10:39:32 -0400342static void lockd_unregister_notifiers(void)
Scott Mayhew0751ddf2015-12-11 16:46:00 -0500343{
344 unregister_inetaddr_notifier(&lockd_inetaddr_notifier);
345#if IS_ENABLED(CONFIG_IPV6)
346 unregister_inet6addr_notifier(&lockd_inet6addr_notifier);
347#endif
Scott Mayhewcb7d224f2016-06-30 10:39:32 -0400348}
349
350static void lockd_svc_exit_thread(void)
351{
352 lockd_unregister_notifiers();
Scott Mayhew0751ddf2015-12-11 16:46:00 -0500353 svc_exit_thread(nlmsvc_rqst);
354}
355
Stanislav Kinsbursky3d1221d2012-04-25 18:23:09 +0400356static int lockd_start_svc(struct svc_serv *serv)
357{
358 int error;
359
360 if (nlmsvc_rqst)
361 return 0;
362
363 /*
364 * Create the kernel thread and wait for it to start.
365 */
366 nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
367 if (IS_ERR(nlmsvc_rqst)) {
368 error = PTR_ERR(nlmsvc_rqst);
369 printk(KERN_WARNING
370 "lockd_up: svc_rqst allocation failed, error=%d\n",
371 error);
Vasily Averin3df31272017-10-20 17:33:18 +0300372 lockd_unregister_notifiers();
Stanislav Kinsbursky3d1221d2012-04-25 18:23:09 +0400373 goto out_rqst;
374 }
375
376 svc_sock_update_bufs(serv);
377 serv->sv_maxconn = nlm_max_connections;
378
Trond Myklebustd4e89902014-09-02 13:58:57 -0400379 nlmsvc_task = kthread_create(lockd, nlmsvc_rqst, "%s", serv->sv_name);
Stanislav Kinsbursky3d1221d2012-04-25 18:23:09 +0400380 if (IS_ERR(nlmsvc_task)) {
381 error = PTR_ERR(nlmsvc_task);
382 printk(KERN_WARNING
383 "lockd_up: kthread_run failed, error=%d\n", error);
384 goto out_task;
385 }
Trond Myklebustd6a7ce42014-08-03 13:03:07 -0400386 nlmsvc_rqst->rq_task = nlmsvc_task;
Trond Myklebustd4e89902014-09-02 13:58:57 -0400387 wake_up_process(nlmsvc_task);
Trond Myklebustd6a7ce42014-08-03 13:03:07 -0400388
Stanislav Kinsbursky3d1221d2012-04-25 18:23:09 +0400389 dprintk("lockd_up: service started\n");
390 return 0;
391
392out_task:
Scott Mayhew0751ddf2015-12-11 16:46:00 -0500393 lockd_svc_exit_thread();
Stanislav Kinsbursky3d1221d2012-04-25 18:23:09 +0400394 nlmsvc_task = NULL;
395out_rqst:
396 nlmsvc_rqst = NULL;
397 return error;
398}
399
Jeff Laytonea126e72015-06-08 12:03:32 -0700400static struct svc_serv_ops lockd_sv_ops = {
Jeff Laytonb9e13cd2015-06-08 12:06:51 -0700401 .svo_shutdown = svc_rpcb_cleanup,
402 .svo_enqueue_xprt = svc_xprt_do_enqueue,
Jeff Laytonea126e72015-06-08 12:03:32 -0700403};
404
Stanislav Kinsbursky24452232012-04-25 18:22:54 +0400405static struct svc_serv *lockd_create_svc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
Jeff Laytond751a7c2008-02-07 16:34:55 -0500407 struct svc_serv *serv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 * Check whether we're already up and running.
411 */
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400412 if (nlmsvc_rqst) {
Stanislav Kinsbursky24452232012-04-25 18:22:54 +0400413 /*
414 * Note: increase service usage, because later in case of error
415 * svc_destroy() will be called.
416 */
417 svc_get(nlmsvc_rqst->rq_server);
418 return nlmsvc_rqst->rq_server;
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 /*
422 * Sanity check: if there's no pid,
423 * we should be the first user ...
424 */
NeilBrown4a3ae422006-10-02 02:17:53 -0700425 if (nlmsvc_users)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 printk(KERN_WARNING
427 "lockd_up: no pid, %d users??\n", nlmsvc_users);
428
Trond Myklebust06bed7d2015-01-02 15:05:25 -0500429 if (!nlm_timeout)
430 nlm_timeout = LOCKD_DFLT_TIMEO;
431 nlmsvc_timeout = nlm_timeout * HZ;
432
Jeff Laytonea126e72015-06-08 12:03:32 -0700433 serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, &lockd_sv_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (!serv) {
435 printk(KERN_WARNING "lockd_up: create service failed\n");
Stanislav Kinsbursky24452232012-04-25 18:22:54 +0400436 return ERR_PTR(-ENOMEM);
437 }
Scott Mayhew0751ddf2015-12-11 16:46:00 -0500438 register_inetaddr_notifier(&lockd_inetaddr_notifier);
439#if IS_ENABLED(CONFIG_IPV6)
440 register_inet6addr_notifier(&lockd_inet6addr_notifier);
441#endif
Stanislav Kinsbursky8dbf28e2012-04-25 18:23:16 +0400442 dprintk("lockd_up: service created\n");
Stanislav Kinsbursky24452232012-04-25 18:22:54 +0400443 return serv;
444}
445
446/*
447 * Bring up the lockd process if it's not already up.
448 */
449int lockd_up(struct net *net)
450{
451 struct svc_serv *serv;
Stanislav Kinsbursky7d13ec72012-04-25 18:23:02 +0400452 int error;
Stanislav Kinsbursky24452232012-04-25 18:22:54 +0400453
454 mutex_lock(&nlmsvc_mutex);
455
456 serv = lockd_create_svc();
457 if (IS_ERR(serv)) {
458 error = PTR_ERR(serv);
459 goto err_create;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 }
461
Stanislav Kinsburskydbf9b5d72012-04-25 18:22:47 +0400462 error = lockd_up_net(serv, net);
Vasily Averin3df31272017-10-20 17:33:18 +0300463 if (error < 0) {
464 lockd_unregister_notifiers();
465 goto err_put;
466 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Stanislav Kinsbursky3d1221d2012-04-25 18:23:09 +0400468 error = lockd_start_svc(serv);
Vasily Averin3df31272017-10-20 17:33:18 +0300469 if (error < 0) {
470 lockd_down_net(serv, net);
471 goto err_put;
472 }
Stanislav Kinsbursky7d13ec72012-04-25 18:23:02 +0400473 nlmsvc_users++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 /*
475 * Note: svc_serv structures have an initial use count of 1,
476 * so we exit through here on both success and failure.
477 */
Scott Mayhewcb7d224f2016-06-30 10:39:32 -0400478err_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 svc_destroy(serv);
Stanislav Kinsbursky24452232012-04-25 18:22:54 +0400480err_create:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800481 mutex_unlock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return error;
483}
Trond Myklebust2de59872008-12-23 15:21:33 -0500484EXPORT_SYMBOL_GPL(lockd_up);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486/*
487 * Decrement the user count and bring down lockd if we're the last.
488 */
489void
Stanislav Kinsburskye3f70ea2012-03-29 18:54:33 +0400490lockd_down(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800492 mutex_lock(&nlmsvc_mutex);
Stanislav Kinsbursky4db77692012-04-25 18:22:40 +0400493 lockd_down_net(nlmsvc_rqst->rq_server, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (nlmsvc_users) {
Stanislav Kinsbursky786185b2012-05-04 12:49:41 +0400495 if (--nlmsvc_users)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 goto out;
Jeff Laytond751a7c2008-02-07 16:34:55 -0500497 } else {
498 printk(KERN_ERR "lockd_down: no users! task=%p\n",
499 nlmsvc_task);
500 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Jeff Laytond751a7c2008-02-07 16:34:55 -0500503 if (!nlmsvc_task) {
504 printk(KERN_ERR "lockd_down: no lockd running.\n");
505 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
Jeff Laytond751a7c2008-02-07 16:34:55 -0500507 kthread_stop(nlmsvc_task);
Stanislav Kinsbursky8dbf28e2012-04-25 18:23:16 +0400508 dprintk("lockd_down: service stopped\n");
Scott Mayhew0751ddf2015-12-11 16:46:00 -0500509 lockd_svc_exit_thread();
Stanislav Kinsbursky8dbf28e2012-04-25 18:23:16 +0400510 dprintk("lockd_down: service destroyed\n");
Jeff Laytonabd1ec42008-06-11 10:03:12 -0400511 nlmsvc_task = NULL;
512 nlmsvc_rqst = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800514 mutex_unlock(&nlmsvc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515}
Trond Myklebust2de59872008-12-23 15:21:33 -0500516EXPORT_SYMBOL_GPL(lockd_down);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Chuck Lever90d5b182008-03-14 14:18:30 -0400518#ifdef CONFIG_SYSCTL
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520/*
521 * Sysctl parameters (same as module parameters, different interface).
522 */
523
Joe Perches7ac9fe52014-06-06 14:38:02 -0700524static struct ctl_table nlm_sysctls[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 .procname = "nlm_grace_period",
527 .data = &nlm_grace_period,
Steve Dickson7ee91ec2005-07-13 01:10:47 -0700528 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800530 .proc_handler = proc_doulongvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 .extra1 = (unsigned long *) &nlm_grace_period_min,
532 .extra2 = (unsigned long *) &nlm_grace_period_max,
533 },
534 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 .procname = "nlm_timeout",
536 .data = &nlm_timeout,
Steve Dickson7ee91ec2005-07-13 01:10:47 -0700537 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800539 .proc_handler = proc_doulongvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 .extra1 = (unsigned long *) &nlm_timeout_min,
541 .extra2 = (unsigned long *) &nlm_timeout_max,
542 },
543 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 .procname = "nlm_udpport",
545 .data = &nlm_udpport,
546 .maxlen = sizeof(int),
547 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800548 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 .extra1 = (int *) &nlm_port_min,
550 .extra2 = (int *) &nlm_port_max,
551 },
552 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 .procname = "nlm_tcpport",
554 .data = &nlm_tcpport,
555 .maxlen = sizeof(int),
556 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800557 .proc_handler = proc_dointvec_minmax,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 .extra1 = (int *) &nlm_port_min,
559 .extra2 = (int *) &nlm_port_max,
560 },
Olaf Kirchabd1f502006-10-04 02:16:01 -0700561 {
Olaf Kirchabd1f502006-10-04 02:16:01 -0700562 .procname = "nsm_use_hostnames",
563 .data = &nsm_use_hostnames,
564 .maxlen = sizeof(int),
565 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800566 .proc_handler = proc_dointvec,
Olaf Kirchabd1f502006-10-04 02:16:01 -0700567 },
Olaf Kirch460f5ca2006-10-04 02:16:03 -0700568 {
Olaf Kirch460f5ca2006-10-04 02:16:03 -0700569 .procname = "nsm_local_state",
570 .data = &nsm_local_state,
571 .maxlen = sizeof(int),
572 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800573 .proc_handler = proc_dointvec,
Olaf Kirch460f5ca2006-10-04 02:16:03 -0700574 },
Eric W. Biedermanab092032009-11-05 14:25:10 -0800575 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576};
577
Joe Perches7ac9fe52014-06-06 14:38:02 -0700578static struct ctl_table nlm_sysctl_dir[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 .procname = "nfs",
581 .mode = 0555,
582 .child = nlm_sysctls,
583 },
Eric W. Biedermanab092032009-11-05 14:25:10 -0800584 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585};
586
Joe Perches7ac9fe52014-06-06 14:38:02 -0700587static struct ctl_table nlm_sysctl_root[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 .procname = "fs",
590 .mode = 0555,
591 .child = nlm_sysctl_dir,
592 },
Eric W. Biedermanab092032009-11-05 14:25:10 -0800593 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594};
595
Chuck Lever90d5b182008-03-14 14:18:30 -0400596#endif /* CONFIG_SYSCTL */
597
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598/*
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100599 * Module (and sysfs) parameters.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 */
601
602#define param_set_min_max(name, type, which_strtol, min, max) \
603static int param_set_##name(const char *val, struct kernel_param *kp) \
604{ \
605 char *endp; \
606 __typeof__(type) num = which_strtol(val, &endp, 0); \
607 if (endp == val || *endp || num < (min) || num > (max)) \
608 return -EINVAL; \
NeilBrownde5b8e82012-02-07 15:35:42 +1100609 *((type *) kp->arg) = num; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 return 0; \
611}
612
613static inline int is_callback(u32 proc)
614{
615 return proc == NLMPROC_GRANTED
616 || proc == NLMPROC_GRANTED_MSG
617 || proc == NLMPROC_TEST_RES
618 || proc == NLMPROC_LOCK_RES
619 || proc == NLMPROC_CANCEL_RES
620 || proc == NLMPROC_UNLOCK_RES
621 || proc == NLMPROC_NSM_NOTIFY;
622}
623
624
625static int lockd_authenticate(struct svc_rqst *rqstp)
626{
627 rqstp->rq_client = NULL;
628 switch (rqstp->rq_authop->flavour) {
629 case RPC_AUTH_NULL:
630 case RPC_AUTH_UNIX:
631 if (rqstp->rq_proc == 0)
632 return SVC_OK;
633 if (is_callback(rqstp->rq_proc)) {
634 /* Leave it to individual procedures to
635 * call nlmsvc_lookup_host(rqstp)
636 */
637 return SVC_OK;
638 }
639 return svc_set_client(rqstp);
640 }
641 return SVC_DENIED;
642}
643
644
645param_set_min_max(port, int, simple_strtol, 0, 65535)
646param_set_min_max(grace_period, unsigned long, simple_strtoul,
647 nlm_grace_period_min, nlm_grace_period_max)
648param_set_min_max(timeout, unsigned long, simple_strtoul,
649 nlm_timeout_min, nlm_timeout_max)
650
651MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
652MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
653MODULE_LICENSE("GPL");
654
655module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
656 &nlm_grace_period, 0644);
657module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
658 &nlm_timeout, 0644);
659module_param_call(nlm_udpport, param_set_port, param_get_int,
660 &nlm_udpport, 0644);
661module_param_call(nlm_tcpport, param_set_port, param_get_int,
662 &nlm_tcpport, 0644);
Olaf Kirchabd1f502006-10-04 02:16:01 -0700663module_param(nsm_use_hostnames, bool, 0644);
Jeff Laytonc72a4762008-10-20 11:51:58 -0400664module_param(nlm_max_connections, uint, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400666static int lockd_init_net(struct net *net)
667{
Stanislav Kinsbursky66547b02012-07-25 16:56:43 +0400668 struct lockd_net *ln = net_generic(net, lockd_net_id);
669
670 INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
Jeff Laytonf7790022014-09-12 16:40:20 -0400671 INIT_LIST_HEAD(&ln->lockd_manager.list);
J. Bruce Fieldsc87fb4a2015-08-06 12:47:02 -0400672 ln->lockd_manager.block_opens = false;
Andrey Ryabinin0ad95472015-09-23 15:49:29 +0300673 INIT_LIST_HEAD(&ln->nsm_handles);
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400674 return 0;
675}
676
677static void lockd_exit_net(struct net *net)
678{
679}
680
681static struct pernet_operations lockd_net_ops = {
682 .init = lockd_init_net,
683 .exit = lockd_exit_net,
684 .id = &lockd_net_id,
685 .size = sizeof(struct lockd_net),
686};
687
688
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689/*
690 * Initialising and terminating the module.
691 */
692
693static int __init init_nlm(void)
694{
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400695 int err;
696
Chuck Lever90d5b182008-03-14 14:18:30 -0400697#ifdef CONFIG_SYSCTL
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400698 err = -ENOMEM;
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800699 nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400700 if (nlm_sysctl_table == NULL)
701 goto err_sysctl;
Chuck Lever90d5b182008-03-14 14:18:30 -0400702#endif
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400703 err = register_pernet_subsys(&lockd_net_ops);
704 if (err)
705 goto err_pernet;
Jeff Laytond68e3c42014-09-12 16:40:20 -0400706
707 err = lockd_create_procfs();
708 if (err)
709 goto err_procfs;
710
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400711 return 0;
712
Jeff Laytond68e3c42014-09-12 16:40:20 -0400713err_procfs:
714 unregister_pernet_subsys(&lockd_net_ops);
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400715err_pernet:
716#ifdef CONFIG_SYSCTL
717 unregister_sysctl_table(nlm_sysctl_table);
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400718err_sysctl:
Kees Cook12dd7ec2014-05-01 14:15:02 -0700719#endif
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400720 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721}
722
723static void __exit exit_nlm(void)
724{
725 /* FIXME: delete all NLM clients */
726 nlm_shutdown_hosts();
Jeff Laytond68e3c42014-09-12 16:40:20 -0400727 lockd_remove_procfs();
Stanislav Kinsburskya9c5d732012-01-31 15:07:57 +0400728 unregister_pernet_subsys(&lockd_net_ops);
Chuck Lever90d5b182008-03-14 14:18:30 -0400729#ifdef CONFIG_SYSCTL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 unregister_sysctl_table(nlm_sysctl_table);
Chuck Lever90d5b182008-03-14 14:18:30 -0400731#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732}
733
734module_init(init_nlm);
735module_exit(exit_nlm);
736
737/*
738 * Define NLM program and procedures
739 */
740static struct svc_version nlmsvc_version1 = {
741 .vs_vers = 1,
742 .vs_nproc = 17,
743 .vs_proc = nlmsvc_procedures,
744 .vs_xdrsize = NLMSVC_XDRSIZE,
745};
746static struct svc_version nlmsvc_version3 = {
747 .vs_vers = 3,
748 .vs_nproc = 24,
749 .vs_proc = nlmsvc_procedures,
750 .vs_xdrsize = NLMSVC_XDRSIZE,
751};
752#ifdef CONFIG_LOCKD_V4
753static struct svc_version nlmsvc_version4 = {
754 .vs_vers = 4,
755 .vs_nproc = 24,
756 .vs_proc = nlmsvc_procedures4,
757 .vs_xdrsize = NLMSVC_XDRSIZE,
758};
759#endif
760static struct svc_version * nlmsvc_version[] = {
761 [1] = &nlmsvc_version1,
762 [3] = &nlmsvc_version3,
763#ifdef CONFIG_LOCKD_V4
764 [4] = &nlmsvc_version4,
765#endif
766};
767
768static struct svc_stat nlmsvc_stats;
769
Tobias Klausere8c96f82006-03-24 03:15:34 -0800770#define NLM_NRVERS ARRAY_SIZE(nlmsvc_version)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771static struct svc_program nlmsvc_program = {
772 .pg_prog = NLM_PROGRAM, /* program number */
773 .pg_nvers = NLM_NRVERS, /* number of entries in nlmsvc_version */
774 .pg_vers = nlmsvc_version, /* version table */
775 .pg_name = "lockd", /* service name */
776 .pg_class = "nfsd", /* share authentication with nfsd */
777 .pg_stats = &nlmsvc_stats, /* stats table */
778 .pg_authenticate = &lockd_authenticate /* export authentication */
779};