svc.c 15.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * linux/fs/lockd/svc.c
 *
 * This is the central lockd service.
 *
 * FIXME: Separate the lockd NFS server functionality from the lockd NFS
 * 	  client functionality. Oh why didn't Sun create two separate
 *	  services in the first place?
 *
 * Authors:	Olaf Kirch (okir@monad.swb.de)
 *
 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sysctl.h>
#include <linux/moduleparam.h>

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/in.h>
#include <linux/uio.h>
#include <linux/smp.h>
I
Ingo Molnar 已提交
25
#include <linux/mutex.h>
J
Jeff Layton 已提交
26
#include <linux/kthread.h>
27
#include <linux/freezer.h>
L
Linus Torvalds 已提交
28 29 30 31 32 33

#include <linux/sunrpc/types.h>
#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/svcsock.h>
34
#include <net/ip.h>
L
Linus Torvalds 已提交
35 36 37
#include <linux/lockd/lockd.h>
#include <linux/nfs.h>

38 39
#include "netns.h"

L
Linus Torvalds 已提交
40 41 42 43 44 45 46
#define NLMDBG_FACILITY		NLMDBG_SVC
#define LOCKD_BUFSIZE		(1024 + NLMSVC_XDRSIZE)
#define ALLOWED_SIGS		(sigmask(SIGKILL))

static struct svc_program	nlmsvc_program;

struct nlmsvc_binding *		nlmsvc_ops;
47
EXPORT_SYMBOL_GPL(nlmsvc_ops);
L
Linus Torvalds 已提交
48

I
Ingo Molnar 已提交
49
static DEFINE_MUTEX(nlmsvc_mutex);
L
Linus Torvalds 已提交
50
static unsigned int		nlmsvc_users;
J
Jeff Layton 已提交
51
static struct task_struct	*nlmsvc_task;
52
static struct svc_rqst		*nlmsvc_rqst;
L
Linus Torvalds 已提交
53 54
unsigned long			nlmsvc_timeout;

55 56
int lockd_net_id;

L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64
/*
 * These can be set at insmod time (useful for NFS as root filesystem),
 * and also changed through the sysctl interface.  -- Jamie Lokier, Aug 2003
 */
static unsigned long		nlm_grace_period;
static unsigned long		nlm_timeout = LOCKD_DFLT_TIMEO;
static int			nlm_udpport, nlm_tcpport;

65 66 67
/* RLIM_NOFILE defaults to 1024. That seems like a reasonable default here. */
static unsigned int		nlm_max_connections = 1024;

L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76
/*
 * Constants needed for the sysctl interface.
 */
static const unsigned long	nlm_grace_period_min = 0;
static const unsigned long	nlm_grace_period_max = 240;
static const unsigned long	nlm_timeout_min = 3;
static const unsigned long	nlm_timeout_max = 20;
static const int		nlm_port_min = 0, nlm_port_max = 65535;

77
#ifdef CONFIG_SYSCTL
L
Linus Torvalds 已提交
78
static struct ctl_table_header * nlm_sysctl_table;
79
#endif
L
Linus Torvalds 已提交
80

81
static unsigned long get_lockd_grace_period(void)
L
Linus Torvalds 已提交
82 83 84
{
	/* Note: nlm_timeout should always be nonzero */
	if (nlm_grace_period)
85
		return roundup(nlm_grace_period, nlm_timeout) * HZ;
L
Linus Torvalds 已提交
86
	else
87 88 89
		return nlm_timeout * 5 * HZ;
}

90
static void grace_ender(struct work_struct *grace)
91
{
92 93 94 95 96 97
	struct delayed_work *dwork = container_of(grace, struct delayed_work,
						  work);
	struct lockd_net *ln = container_of(dwork, struct lockd_net,
					    grace_period_end);

	locks_end_grace(&ln->lockd_manager);
L
Linus Torvalds 已提交
98 99
}

100
static void set_grace_period(struct net *net)
L
Linus Torvalds 已提交
101
{
102
	unsigned long grace_period = get_lockd_grace_period();
103
	struct lockd_net *ln = net_generic(net, lockd_net_id);
104

105
	locks_start_grace(net, &ln->lockd_manager);
106 107
	cancel_delayed_work_sync(&ln->grace_period_end);
	schedule_delayed_work(&ln->grace_period_end, grace_period);
L
Linus Torvalds 已提交
108 109
}

110 111 112
static void restart_grace(void)
{
	if (nlmsvc_ops) {
113 114
		struct net *net = &init_net;
		struct lockd_net *ln = net_generic(net, lockd_net_id);
115 116

		cancel_delayed_work_sync(&ln->grace_period_end);
117
		locks_end_grace(&ln->lockd_manager);
118
		nlmsvc_invalidate_all();
119
		set_grace_period(net);
120 121 122
	}
}

L
Linus Torvalds 已提交
123 124 125
/*
 * This is the lockd kernel thread
 */
J
Jeff Layton 已提交
126 127
static int
lockd(void *vrqstp)
L
Linus Torvalds 已提交
128
{
129
	int		err = 0;
J
Jeff Layton 已提交
130
	struct svc_rqst *rqstp = vrqstp;
L
Linus Torvalds 已提交
131

J
Jeff Layton 已提交
132
	/* try_to_freeze() is called from svc_recv() */
133
	set_freezable();
L
Linus Torvalds 已提交
134

J
Jeff Layton 已提交
135
	/* Allow SIGKILL to tell lockd to drop all of its locks */
L
Linus Torvalds 已提交
136 137 138 139 140 141 142 143 144 145
	allow_signal(SIGKILL);

	dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");

	if (!nlm_timeout)
		nlm_timeout = LOCKD_DFLT_TIMEO;
	nlmsvc_timeout = nlm_timeout * HZ;

	/*
	 * The main request loop. We don't terminate until the last
J
Jeff Layton 已提交
146
	 * NFS mount or NFS daemon has gone away.
L
Linus Torvalds 已提交
147
	 */
J
Jeff Layton 已提交
148
	while (!kthread_should_stop()) {
L
Linus Torvalds 已提交
149
		long timeout = MAX_SCHEDULE_TIMEOUT;
150
		RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
L
Linus Torvalds 已提交
151

152 153 154
		/* update sv_maxconn if it has changed */
		rqstp->rq_server->sv_maxconn = nlm_max_connections;

L
Linus Torvalds 已提交
155 156
		if (signalled()) {
			flush_signals(current);
157
			restart_grace();
J
Jeff Layton 已提交
158
			continue;
L
Linus Torvalds 已提交
159 160
		}

161 162
		timeout = nlmsvc_retry_blocked();

L
Linus Torvalds 已提交
163 164 165 166
		/*
		 * Find a socket with data available and call its
		 * recvfrom routine.
		 */
167
		err = svc_recv(rqstp, timeout);
168
		if (err == -EAGAIN || err == -EINTR)
L
Linus Torvalds 已提交
169
			continue;
170 171
		dprintk("lockd: request from %s\n",
				svc_print_addr(rqstp, buf, sizeof(buf)));
L
Linus Torvalds 已提交
172

173
		svc_process(rqstp);
L
Linus Torvalds 已提交
174
	}
175
	flush_signals(current);
J
Jeff Layton 已提交
176 177 178 179
	if (nlmsvc_ops)
		nlmsvc_invalidate_all();
	nlm_shutdown_hosts();
	return 0;
L
Linus Torvalds 已提交
180 181
}

182
static int create_lockd_listener(struct svc_serv *serv, const char *name,
183 184
				 struct net *net, const int family,
				 const unsigned short port)
185 186 187
{
	struct svc_xprt *xprt;

188
	xprt = svc_find_xprt(serv, name, net, family, 0);
189
	if (xprt == NULL)
190
		return svc_create_xprt(serv, name, net, family, port,
191
						SVC_SOCK_DEFAULTS);
192 193 194 195
	svc_xprt_put(xprt);
	return 0;
}

196 197
static int create_lockd_family(struct svc_serv *serv, struct net *net,
			       const int family)
198 199 200
{
	int err;

201
	err = create_lockd_listener(serv, "udp", net, family, nlm_udpport);
202 203 204
	if (err < 0)
		return err;

205
	return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport);
206 207
}

208
/*
209 210 211 212 213 214 215 216
 * Ensure there are active UDP and TCP listeners for lockd.
 *
 * Even if we have only TCP NFS mounts and/or TCP NFSDs, some
 * local services (such as rpc.statd) still require UDP, and
 * some NFS servers do not yet support NLM over TCP.
 *
 * Returns zero if all listeners are available; otherwise a
 * negative errno value is returned.
217
 */
218
static int make_socks(struct svc_serv *serv, struct net *net)
219
{
220
	static int warned;
221
	int err;
222

223
	err = create_lockd_family(serv, net, PF_INET);
224 225 226
	if (err < 0)
		goto out_err;

227
	err = create_lockd_family(serv, net, PF_INET6);
228
	if (err < 0 && err != -EAFNOSUPPORT)
229 230 231 232 233 234 235
		goto out_err;

	warned = 0;
	return 0;

out_err:
	if (warned++ == 0)
236
		printk(KERN_WARNING
237
			"lockd_up: makesock failed, error=%d\n", err);
238
	svc_shutdown_net(serv, net);
239 240 241
	return err;
}

242
static int lockd_up_net(struct svc_serv *serv, struct net *net)
243 244 245 246
{
	struct lockd_net *ln = net_generic(net, lockd_net_id);
	int error;

247
	if (ln->nlmsvc_users++)
248 249
		return 0;

250
	error = svc_bind(serv, net);
251
	if (error)
252
		goto err_bind;
253 254 255 256

	error = make_socks(serv, net);
	if (error < 0)
		goto err_socks;
257
	set_grace_period(net);
258
	dprintk("lockd_up_net: per-net data created; net=%p\n", net);
259 260 261 262
	return 0;

err_socks:
	svc_rpcb_cleanup(serv, net);
263
err_bind:
264
	ln->nlmsvc_users--;
265 266 267
	return error;
}

268
static void lockd_down_net(struct svc_serv *serv, struct net *net)
269 270 271 272
{
	struct lockd_net *ln = net_generic(net, lockd_net_id);

	if (ln->nlmsvc_users) {
273 274
		if (--ln->nlmsvc_users == 0) {
			nlm_shutdown_hosts_net(net);
275 276
			cancel_delayed_work_sync(&ln->grace_period_end);
			locks_end_grace(&ln->lockd_manager);
277
			svc_shutdown_net(serv, net);
278
			dprintk("lockd_down_net: per-net data destroyed; net=%p\n", net);
279
		}
280 281 282 283 284 285 286
	} else {
		printk(KERN_ERR "lockd_down_net: no users! task=%p, net=%p\n",
				nlmsvc_task, net);
		BUG();
	}
}

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
static int lockd_start_svc(struct svc_serv *serv)
{
	int error;

	if (nlmsvc_rqst)
		return 0;

	/*
	 * Create the kernel thread and wait for it to start.
	 */
	nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
	if (IS_ERR(nlmsvc_rqst)) {
		error = PTR_ERR(nlmsvc_rqst);
		printk(KERN_WARNING
			"lockd_up: svc_rqst allocation failed, error=%d\n",
			error);
		goto out_rqst;
	}

	svc_sock_update_bufs(serv);
	serv->sv_maxconn = nlm_max_connections;

309
	nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, "%s", serv->sv_name);
310 311 312 313 314 315
	if (IS_ERR(nlmsvc_task)) {
		error = PTR_ERR(nlmsvc_task);
		printk(KERN_WARNING
			"lockd_up: kthread_run failed, error=%d\n", error);
		goto out_task;
	}
316 317
	nlmsvc_rqst->rq_task = nlmsvc_task;

318 319 320 321 322 323 324 325 326 327 328
	dprintk("lockd_up: service started\n");
	return 0;

out_task:
	svc_exit_thread(nlmsvc_rqst);
	nlmsvc_task = NULL;
out_rqst:
	nlmsvc_rqst = NULL;
	return error;
}

329
static struct svc_serv *lockd_create_svc(void)
L
Linus Torvalds 已提交
330
{
J
Jeff Layton 已提交
331
	struct svc_serv *serv;
L
Linus Torvalds 已提交
332 333 334 335

	/*
	 * Check whether we're already up and running.
	 */
336
	if (nlmsvc_rqst) {
337 338 339 340 341 342
		/*
		 * Note: increase service usage, because later in case of error
		 * svc_destroy() will be called.
		 */
		svc_get(nlmsvc_rqst->rq_server);
		return nlmsvc_rqst->rq_server;
343
	}
L
Linus Torvalds 已提交
344 345 346 347 348

	/*
	 * Sanity check: if there's no pid,
	 * we should be the first user ...
	 */
349
	if (nlmsvc_users)
L
Linus Torvalds 已提交
350 351 352
		printk(KERN_WARNING
			"lockd_up: no pid, %d users??\n", nlmsvc_users);

353
	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, NULL);
L
Linus Torvalds 已提交
354 355
	if (!serv) {
		printk(KERN_WARNING "lockd_up: create service failed\n");
356 357
		return ERR_PTR(-ENOMEM);
	}
358
	dprintk("lockd_up: service created\n");
359 360 361 362 363 364 365 366 367
	return serv;
}

/*
 * Bring up the lockd process if it's not already up.
 */
int lockd_up(struct net *net)
{
	struct svc_serv *serv;
368
	int error;
369 370 371 372 373 374 375

	mutex_lock(&nlmsvc_mutex);

	serv = lockd_create_svc();
	if (IS_ERR(serv)) {
		error = PTR_ERR(serv);
		goto err_create;
L
Linus Torvalds 已提交
376 377
	}

378
	error = lockd_up_net(serv, net);
379
	if (error < 0)
380
		goto err_net;
L
Linus Torvalds 已提交
381

382 383
	error = lockd_start_svc(serv);
	if (error < 0)
384
		goto err_start;
L
Linus Torvalds 已提交
385

386
	nlmsvc_users++;
L
Linus Torvalds 已提交
387 388 389 390
	/*
	 * Note: svc_serv structures have an initial use count of 1,
	 * so we exit through here on both success and failure.
	 */
391
err_net:
L
Linus Torvalds 已提交
392
	svc_destroy(serv);
393
err_create:
I
Ingo Molnar 已提交
394
	mutex_unlock(&nlmsvc_mutex);
L
Linus Torvalds 已提交
395
	return error;
396 397

err_start:
398
	lockd_down_net(serv, net);
399
	goto err_net;
L
Linus Torvalds 已提交
400
}
401
EXPORT_SYMBOL_GPL(lockd_up);
L
Linus Torvalds 已提交
402 403 404 405 406

/*
 * Decrement the user count and bring down lockd if we're the last.
 */
void
407
lockd_down(struct net *net)
L
Linus Torvalds 已提交
408
{
I
Ingo Molnar 已提交
409
	mutex_lock(&nlmsvc_mutex);
410
	lockd_down_net(nlmsvc_rqst->rq_server, net);
L
Linus Torvalds 已提交
411
	if (nlmsvc_users) {
412
		if (--nlmsvc_users)
L
Linus Torvalds 已提交
413
			goto out;
J
Jeff Layton 已提交
414 415 416 417
	} else {
		printk(KERN_ERR "lockd_down: no users! task=%p\n",
			nlmsvc_task);
		BUG();
L
Linus Torvalds 已提交
418 419
	}

J
Jeff Layton 已提交
420 421 422
	if (!nlmsvc_task) {
		printk(KERN_ERR "lockd_down: no lockd running.\n");
		BUG();
L
Linus Torvalds 已提交
423
	}
J
Jeff Layton 已提交
424
	kthread_stop(nlmsvc_task);
425
	dprintk("lockd_down: service stopped\n");
426
	svc_exit_thread(nlmsvc_rqst);
427
	dprintk("lockd_down: service destroyed\n");
428 429
	nlmsvc_task = NULL;
	nlmsvc_rqst = NULL;
L
Linus Torvalds 已提交
430
out:
I
Ingo Molnar 已提交
431
	mutex_unlock(&nlmsvc_mutex);
L
Linus Torvalds 已提交
432
}
433
EXPORT_SYMBOL_GPL(lockd_down);
L
Linus Torvalds 已提交
434

435 436
#ifdef CONFIG_SYSCTL

L
Linus Torvalds 已提交
437 438 439 440
/*
 * Sysctl parameters (same as module parameters, different interface).
 */

441
static struct ctl_table nlm_sysctls[] = {
L
Linus Torvalds 已提交
442 443 444
	{
		.procname	= "nlm_grace_period",
		.data		= &nlm_grace_period,
445
		.maxlen		= sizeof(unsigned long),
L
Linus Torvalds 已提交
446
		.mode		= 0644,
447
		.proc_handler	= proc_doulongvec_minmax,
L
Linus Torvalds 已提交
448 449 450 451 452 453
		.extra1		= (unsigned long *) &nlm_grace_period_min,
		.extra2		= (unsigned long *) &nlm_grace_period_max,
	},
	{
		.procname	= "nlm_timeout",
		.data		= &nlm_timeout,
454
		.maxlen		= sizeof(unsigned long),
L
Linus Torvalds 已提交
455
		.mode		= 0644,
456
		.proc_handler	= proc_doulongvec_minmax,
L
Linus Torvalds 已提交
457 458 459 460 461 462 463 464
		.extra1		= (unsigned long *) &nlm_timeout_min,
		.extra2		= (unsigned long *) &nlm_timeout_max,
	},
	{
		.procname	= "nlm_udpport",
		.data		= &nlm_udpport,
		.maxlen		= sizeof(int),
		.mode		= 0644,
465
		.proc_handler	= proc_dointvec_minmax,
L
Linus Torvalds 已提交
466 467 468 469 470 471 472 473
		.extra1		= (int *) &nlm_port_min,
		.extra2		= (int *) &nlm_port_max,
	},
	{
		.procname	= "nlm_tcpport",
		.data		= &nlm_tcpport,
		.maxlen		= sizeof(int),
		.mode		= 0644,
474
		.proc_handler	= proc_dointvec_minmax,
L
Linus Torvalds 已提交
475 476 477
		.extra1		= (int *) &nlm_port_min,
		.extra2		= (int *) &nlm_port_max,
	},
478 479 480 481 482
	{
		.procname	= "nsm_use_hostnames",
		.data		= &nsm_use_hostnames,
		.maxlen		= sizeof(int),
		.mode		= 0644,
483
		.proc_handler	= proc_dointvec,
484
	},
485 486 487 488 489
	{
		.procname	= "nsm_local_state",
		.data		= &nsm_local_state,
		.maxlen		= sizeof(int),
		.mode		= 0644,
490
		.proc_handler	= proc_dointvec,
491
	},
492
	{ }
L
Linus Torvalds 已提交
493 494
};

495
static struct ctl_table nlm_sysctl_dir[] = {
L
Linus Torvalds 已提交
496 497 498 499 500
	{
		.procname	= "nfs",
		.mode		= 0555,
		.child		= nlm_sysctls,
	},
501
	{ }
L
Linus Torvalds 已提交
502 503
};

504
static struct ctl_table nlm_sysctl_root[] = {
L
Linus Torvalds 已提交
505 506 507 508 509
	{
		.procname	= "fs",
		.mode		= 0555,
		.child		= nlm_sysctl_dir,
	},
510
	{ }
L
Linus Torvalds 已提交
511 512
};

513 514
#endif	/* CONFIG_SYSCTL */

L
Linus Torvalds 已提交
515
/*
516
 * Module (and sysfs) parameters.
L
Linus Torvalds 已提交
517 518 519 520 521 522 523 524 525
 */

#define param_set_min_max(name, type, which_strtol, min, max)		\
static int param_set_##name(const char *val, struct kernel_param *kp)	\
{									\
	char *endp;							\
	__typeof__(type) num = which_strtol(val, &endp, 0);		\
	if (endp == val || *endp || num < (min) || num > (max))		\
		return -EINVAL;						\
526
	*((type *) kp->arg) = num;					\
L
Linus Torvalds 已提交
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
	return 0;							\
}

static inline int is_callback(u32 proc)
{
	return proc == NLMPROC_GRANTED
		|| proc == NLMPROC_GRANTED_MSG
		|| proc == NLMPROC_TEST_RES
		|| proc == NLMPROC_LOCK_RES
		|| proc == NLMPROC_CANCEL_RES
		|| proc == NLMPROC_UNLOCK_RES
		|| proc == NLMPROC_NSM_NOTIFY;
}


static int lockd_authenticate(struct svc_rqst *rqstp)
{
	rqstp->rq_client = NULL;
	switch (rqstp->rq_authop->flavour) {
		case RPC_AUTH_NULL:
		case RPC_AUTH_UNIX:
			if (rqstp->rq_proc == 0)
				return SVC_OK;
			if (is_callback(rqstp->rq_proc)) {
				/* Leave it to individual procedures to
				 * call nlmsvc_lookup_host(rqstp)
				 */
				return SVC_OK;
			}
			return svc_set_client(rqstp);
	}
	return SVC_DENIED;
}


param_set_min_max(port, int, simple_strtol, 0, 65535)
param_set_min_max(grace_period, unsigned long, simple_strtoul,
		  nlm_grace_period_min, nlm_grace_period_max)
param_set_min_max(timeout, unsigned long, simple_strtoul,
		  nlm_timeout_min, nlm_timeout_max)

MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
MODULE_DESCRIPTION("NFS file locking service version " LOCKD_VERSION ".");
MODULE_LICENSE("GPL");

module_param_call(nlm_grace_period, param_set_grace_period, param_get_ulong,
		  &nlm_grace_period, 0644);
module_param_call(nlm_timeout, param_set_timeout, param_get_ulong,
		  &nlm_timeout, 0644);
module_param_call(nlm_udpport, param_set_port, param_get_int,
		  &nlm_udpport, 0644);
module_param_call(nlm_tcpport, param_set_port, param_get_int,
		  &nlm_tcpport, 0644);
580
module_param(nsm_use_hostnames, bool, 0644);
581
module_param(nlm_max_connections, uint, 0644);
L
Linus Torvalds 已提交
582

583 584
static int lockd_init_net(struct net *net)
{
585 586 587
	struct lockd_net *ln = net_generic(net, lockd_net_id);

	INIT_DELAYED_WORK(&ln->grace_period_end, grace_ender);
588
	INIT_LIST_HEAD(&ln->grace_list);
589
	spin_lock_init(&ln->nsm_clnt_lock);
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
	return 0;
}

static void lockd_exit_net(struct net *net)
{
}

static struct pernet_operations lockd_net_ops = {
	.init = lockd_init_net,
	.exit = lockd_exit_net,
	.id = &lockd_net_id,
	.size = sizeof(struct lockd_net),
};


L
Linus Torvalds 已提交
605 606 607 608 609 610
/*
 * Initialising and terminating the module.
 */

static int __init init_nlm(void)
{
611 612
	int err;

613
#ifdef CONFIG_SYSCTL
614
	err = -ENOMEM;
615
	nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
616 617 618 619 620 621
	if (nlm_sysctl_table == NULL)
		goto err_sysctl;
#endif
	err = register_pernet_subsys(&lockd_net_ops);
	if (err)
		goto err_pernet;
622
	return 0;
623 624 625 626 627

err_pernet:
#ifdef CONFIG_SYSCTL
	unregister_sysctl_table(nlm_sysctl_table);
err_sysctl:
628
#endif
629
	return err;
L
Linus Torvalds 已提交
630 631 632 633 634 635
}

static void __exit exit_nlm(void)
{
	/* FIXME: delete all NLM clients */
	nlm_shutdown_hosts();
636
	unregister_pernet_subsys(&lockd_net_ops);
637
#ifdef CONFIG_SYSCTL
L
Linus Torvalds 已提交
638
	unregister_sysctl_table(nlm_sysctl_table);
639
#endif
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
}

module_init(init_nlm);
module_exit(exit_nlm);

/*
 * Define NLM program and procedures
 */
static struct svc_version	nlmsvc_version1 = {
		.vs_vers	= 1,
		.vs_nproc	= 17,
		.vs_proc	= nlmsvc_procedures,
		.vs_xdrsize	= NLMSVC_XDRSIZE,
};
static struct svc_version	nlmsvc_version3 = {
		.vs_vers	= 3,
		.vs_nproc	= 24,
		.vs_proc	= nlmsvc_procedures,
		.vs_xdrsize	= NLMSVC_XDRSIZE,
};
#ifdef CONFIG_LOCKD_V4
static struct svc_version	nlmsvc_version4 = {
		.vs_vers	= 4,
		.vs_nproc	= 24,
		.vs_proc	= nlmsvc_procedures4,
		.vs_xdrsize	= NLMSVC_XDRSIZE,
};
#endif
static struct svc_version *	nlmsvc_version[] = {
	[1] = &nlmsvc_version1,
	[3] = &nlmsvc_version3,
#ifdef CONFIG_LOCKD_V4
	[4] = &nlmsvc_version4,
#endif
};

static struct svc_stat		nlmsvc_stats;

678
#define NLM_NRVERS	ARRAY_SIZE(nlmsvc_version)
L
Linus Torvalds 已提交
679 680 681 682 683 684 685 686 687
static struct svc_program	nlmsvc_program = {
	.pg_prog		= NLM_PROGRAM,		/* program number */
	.pg_nvers		= NLM_NRVERS,		/* number of entries in nlmsvc_version */
	.pg_vers		= nlmsvc_version,	/* version table */
	.pg_name		= "lockd",		/* service name */
	.pg_class		= "nfsd",		/* share authentication with nfsd */
	.pg_stats		= &nlmsvc_stats,	/* stats table */
	.pg_authenticate = &lockd_authenticate	/* export authentication */
};