nfssvc.c 20.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8
/*
 * Central processing for nfsd.
 *
 * Authors:	Olaf Kirch (okir@monad.swb.de)
 *
 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
 */

9
#include <linux/sched/signal.h>
10
#include <linux/freezer.h>
11
#include <linux/module.h>
L
Linus Torvalds 已提交
12
#include <linux/fs_struct.h>
A
Andy Adamson 已提交
13
#include <linux/swap.h>
L
Linus Torvalds 已提交
14 15 16

#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/svcsock.h>
17
#include <linux/sunrpc/svc_xprt.h>
L
Linus Torvalds 已提交
18
#include <linux/lockd/bind.h>
19
#include <linux/nfsacl.h>
20
#include <linux/seq_file.h>
21 22 23
#include <linux/inetdevice.h>
#include <net/addrconf.h>
#include <net/ipv6.h>
24
#include <net/net_namespace.h>
25 26
#include "nfsd.h"
#include "cache.h"
27
#include "vfs.h"
28
#include "netns.h"
L
Linus Torvalds 已提交
29 30 31 32

#define NFSDDBG_FACILITY	NFSDDBG_SVC

extern struct svc_program	nfsd_program;
33
static int			nfsd(void *vrqstp);
L
Linus Torvalds 已提交
34

35
/*
36
 * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members
37 38 39
 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some
 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
 *
40
 * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a
41 42 43 44 45 46 47
 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
 * of nfsd threads must exist and each must listed in ->sp_all_threads in each
 * entry of ->sv_pools[].
 *
 * Transitions of the thread count between zero and non-zero are of particular
 * interest since the svc_serv needs to be created and initialized at that
 * point, or freed.
48 49 50 51 52 53 54 55
 *
 * Finally, the nfsd_mutex also protects some of the global variables that are
 * accessed when nfsd starts and that are settable via the write_* routines in
 * nfsctl.c. In particular:
 *
 *	user_recovery_dirname
 *	user_lease_time
 *	nfsd_versions
56 57 58
 */
DEFINE_MUTEX(nfsd_mutex);

59 60 61 62 63 64 65
/*
 * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used.
 * nfsd_drc_max_pages limits the total amount of memory available for
 * version 4.1 DRC caches.
 * nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage.
 */
spinlock_t	nfsd_drc_lock;
66 67
unsigned long	nfsd_drc_max_mem;
unsigned long	nfsd_drc_mem_used;
68

69 70 71 72 73 74 75 76
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
static struct svc_stat	nfsd_acl_svcstats;
static struct svc_version *	nfsd_acl_version[] = {
	[2] = &nfsd_acl_version2,
	[3] = &nfsd_acl_version3,
};

#define NFSD_ACL_MINVERS            2
77
#define NFSD_ACL_NRVERS		ARRAY_SIZE(nfsd_acl_version)
78 79 80 81 82 83
static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];

static struct svc_program	nfsd_acl_program = {
	.pg_prog		= NFS_ACL_PROGRAM,
	.pg_nvers		= NFSD_ACL_NRVERS,
	.pg_vers		= nfsd_acl_versions,
84
	.pg_name		= "nfsacl",
85 86 87 88 89 90 91 92 93 94
	.pg_class		= "nfsd",
	.pg_stats		= &nfsd_acl_svcstats,
	.pg_authenticate	= &svc_set_client,
};

static struct svc_stat	nfsd_acl_svcstats = {
	.program	= &nfsd_acl_program,
};
#endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */

95 96 97 98 99 100 101 102 103 104 105
static struct svc_version *	nfsd_version[] = {
	[2] = &nfsd_version2,
#if defined(CONFIG_NFSD_V3)
	[3] = &nfsd_version3,
#endif
#if defined(CONFIG_NFSD_V4)
	[4] = &nfsd_version4,
#endif
};

#define NFSD_MINVERS    	2
106
#define NFSD_NRVERS		ARRAY_SIZE(nfsd_version)
107 108 109
static struct svc_version *nfsd_versions[NFSD_NRVERS];

struct svc_program		nfsd_program = {
110 111 112
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
	.pg_next		= &nfsd_acl_program,
#endif
113 114 115 116 117 118 119 120 121 122
	.pg_prog		= NFS_PROGRAM,		/* program number */
	.pg_nvers		= NFSD_NRVERS,		/* nr of entries in nfsd_version */
	.pg_vers		= nfsd_versions,	/* version table */
	.pg_name		= "nfsd",		/* program name */
	.pg_class		= "nfsd",		/* authentication class */
	.pg_stats		= &nfsd_svcstats,	/* version table */
	.pg_authenticate	= &svc_set_client,	/* export authentication */

};

123 124 125
static bool nfsd_supported_minorversions[NFSD_SUPPORTED_MINOR_VERSION + 1] = {
	[0] = 1,
	[1] = 1,
J
J. Bruce Fields 已提交
126
	[2] = 1,
127
};
128

129 130 131
int nfsd_vers(int vers, enum vers_op change)
{
	if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
132
		return 0;
133 134 135 136 137
	switch(change) {
	case NFSD_SET:
		nfsd_versions[vers] = nfsd_version[vers];
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
		if (vers < NFSD_ACL_NRVERS)
138
			nfsd_acl_versions[vers] = nfsd_acl_version[vers];
139
#endif
140
		break;
141 142 143 144
	case NFSD_CLEAR:
		nfsd_versions[vers] = NULL;
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
		if (vers < NFSD_ACL_NRVERS)
145
			nfsd_acl_versions[vers] = NULL;
146 147 148 149 150 151 152 153 154
#endif
		break;
	case NFSD_TEST:
		return nfsd_versions[vers] != NULL;
	case NFSD_AVAIL:
		return nfsd_version[vers] != NULL;
	}
	return 0;
}
155

156 157 158 159 160 161 162 163 164 165 166 167
static void
nfsd_adjust_nfsd_versions4(void)
{
	unsigned i;

	for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++) {
		if (nfsd_supported_minorversions[i])
			return;
	}
	nfsd_vers(4, NFSD_CLEAR);
}

168 169 170 171 172 173
int nfsd_minorversion(u32 minorversion, enum vers_op change)
{
	if (minorversion > NFSD_SUPPORTED_MINOR_VERSION)
		return -1;
	switch(change) {
	case NFSD_SET:
174
		nfsd_supported_minorversions[minorversion] = true;
175
		nfsd_vers(4, NFSD_SET);
176 177
		break;
	case NFSD_CLEAR:
178
		nfsd_supported_minorversions[minorversion] = false;
179
		nfsd_adjust_nfsd_versions4();
180 181
		break;
	case NFSD_TEST:
182
		return nfsd_supported_minorversions[minorversion];
183 184 185 186 187 188
	case NFSD_AVAIL:
		return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
	}
	return 0;
}

L
Linus Torvalds 已提交
189 190 191 192 193
/*
 * Maximum number of nfsd processes
 */
#define	NFSD_MAXSERVS		8192

194
int nfsd_nrthreads(struct net *net)
L
Linus Torvalds 已提交
195
{
N
Neil Brown 已提交
196
	int rv = 0;
197 198
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

N
Neil Brown 已提交
199
	mutex_lock(&nfsd_mutex);
200 201
	if (nn->nfsd_serv)
		rv = nn->nfsd_serv->sv_nrthreads;
N
Neil Brown 已提交
202 203
	mutex_unlock(&nfsd_mutex);
	return rv;
L
Linus Torvalds 已提交
204 205
}

206
static int nfsd_init_socks(struct net *net)
207 208
{
	int error;
209 210 211
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

	if (!list_empty(&nn->nfsd_serv->sv_permsocks))
212 213
		return 0;

214
	error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT,
215 216 217 218
					SVC_SOCK_DEFAULTS);
	if (error < 0)
		return error;

219
	error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
220 221 222 223 224 225 226
					SVC_SOCK_DEFAULTS);
	if (error < 0)
		return error;

	return 0;
}

227
static int nfsd_users = 0;
228

229 230 231 232
static int nfsd_startup_generic(int nrservs)
{
	int ret;

233
	if (nfsd_users++)
234 235 236 237 238 239 240 241 242
		return 0;

	/*
	 * Readahead param cache - will no-op if it already exists.
	 * (Note therefore results will be suboptimal if number of
	 * threads is modified after nfsd start.)
	 */
	ret = nfsd_racache_init(2*nrservs);
	if (ret)
243 244
		goto dec_users;

245 246 247 248 249 250 251
	ret = nfs4_state_start();
	if (ret)
		goto out_racache;
	return 0;

out_racache:
	nfsd_racache_shutdown();
252 253
dec_users:
	nfsd_users--;
254 255 256 257 258
	return ret;
}

static void nfsd_shutdown_generic(void)
{
259 260 261
	if (--nfsd_users)
		return;

262 263 264 265
	nfs4_state_shutdown();
	nfsd_racache_shutdown();
}

266 267
static bool nfsd_needs_lockd(void)
{
268
#if defined(CONFIG_NFSD_V3)
269
	return (nfsd_versions[2] != NULL) || (nfsd_versions[3] != NULL);
270 271 272
#else
	return (nfsd_versions[2] != NULL);
#endif
273 274
}

275
static int nfsd_startup_net(int nrservs, struct net *net)
276
{
277
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
278 279
	int ret;

280 281 282
	if (nn->nfsd_net_up)
		return 0;

283
	ret = nfsd_startup_generic(nrservs);
284 285
	if (ret)
		return ret;
286 287 288
	ret = nfsd_init_socks(net);
	if (ret)
		goto out_socks;
289 290 291 292 293 294 295 296

	if (nfsd_needs_lockd() && !nn->lockd_up) {
		ret = lockd_up(net);
		if (ret)
			goto out_socks;
		nn->lockd_up = 1;
	}

297 298 299 300
	ret = nfs4_state_start_net(net);
	if (ret)
		goto out_lockd;

301
	nn->nfsd_net_up = true;
302 303 304
	return 0;

out_lockd:
305 306 307 308
	if (nn->lockd_up) {
		lockd_down(net);
		nn->lockd_up = 0;
	}
309
out_socks:
310
	nfsd_shutdown_generic();
311 312 313
	return ret;
}

314 315
static void nfsd_shutdown_net(struct net *net)
{
316 317
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

318
	nfs4_state_shutdown_net(net);
319 320 321 322
	if (nn->lockd_up) {
		lockd_down(net);
		nn->lockd_up = 0;
	}
323
	nn->nfsd_net_up = false;
324
	nfsd_shutdown_generic();
325 326
}

327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event,
	void *ptr)
{
	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
	struct net_device *dev = ifa->ifa_dev->dev;
	struct net *net = dev_net(dev);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
	struct sockaddr_in sin;

	if (event != NETDEV_DOWN)
		goto out;

	if (nn->nfsd_serv) {
		dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local);
		sin.sin_family = AF_INET;
		sin.sin_addr.s_addr = ifa->ifa_local;
		svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin);
	}

out:
	return NOTIFY_DONE;
}

static struct notifier_block nfsd_inetaddr_notifier = {
	.notifier_call = nfsd_inetaddr_event,
};

#if IS_ENABLED(CONFIG_IPV6)
static int nfsd_inet6addr_event(struct notifier_block *this,
	unsigned long event, void *ptr)
{
	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
	struct net_device *dev = ifa->idev->dev;
	struct net *net = dev_net(dev);
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
	struct sockaddr_in6 sin6;

	if (event != NETDEV_DOWN)
		goto out;

	if (nn->nfsd_serv) {
		dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr);
		sin6.sin6_family = AF_INET6;
		sin6.sin6_addr = ifa->addr;
371 372
		if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
			sin6.sin6_scope_id = ifa->idev->dev->ifindex;
373 374 375 376 377 378 379 380 381 382 383 384
		svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6);
	}

out:
	return NOTIFY_DONE;
}

static struct notifier_block nfsd_inet6addr_notifier = {
	.notifier_call = nfsd_inet6addr_event,
};
#endif

385 386 387
/* Only used under nfsd_mutex, so this atomic may be overkill: */
static atomic_t nfsd_notifier_refcount = ATOMIC_INIT(0);

388
static void nfsd_last_thread(struct svc_serv *serv, struct net *net)
389
{
390 391
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

392 393 394
	/* check if the notifier still has clients */
	if (atomic_dec_return(&nfsd_notifier_refcount) == 0) {
		unregister_inetaddr_notifier(&nfsd_inetaddr_notifier);
395
#if IS_ENABLED(CONFIG_IPV6)
396
		unregister_inet6addr_notifier(&nfsd_inet6addr_notifier);
397
#endif
398 399
	}

400 401 402 403
	/*
	 * write_ports can create the server without actually starting
	 * any threads--if we get shut down before any threads are
	 * started, then nfsd_last_thread will be run before any of this
404
	 * other initialization has been done except the rpcb information.
405
	 */
406
	svc_rpcb_cleanup(serv, net);
407
	if (!nn->nfsd_net_up)
408
		return;
409

410
	nfsd_shutdown_net(net);
411 412
	printk(KERN_WARNING "nfsd: last server has exited, flushing export "
			    "cache\n");
413
	nfsd_export_flush(net);
414
}
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436

void nfsd_reset_versions(void)
{
	int found_one = 0;
	int i;

	for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
		if (nfsd_program.pg_vers[i])
			found_one = 1;
	}

	if (!found_one) {
		for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
			nfsd_program.pg_vers[i] = nfsd_version[i];
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
		for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
			nfsd_acl_program.pg_vers[i] =
				nfsd_acl_version[i];
#endif
	}
}

A
Andy Adamson 已提交
437 438 439 440 441 442 443 444 445 446 447 448 449 450
/*
 * Each session guarantees a negotiated per slot memory cache for replies
 * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated
 * NFSv4.1 server might want to use more memory for a DRC than a machine
 * with mutiple services.
 *
 * Impose a hard limit on the number of pages for the DRC which varies
 * according to the machines free pages. This is of course only a default.
 *
 * For now this is a #defined shift which could be under admin control
 * in the future.
 */
static void set_max_drc(void)
{
451
	#define NFSD_DRC_SIZE_SHIFT	10
452 453 454
	nfsd_drc_max_mem = (nr_free_buffer_pages()
					>> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE;
	nfsd_drc_mem_used = 0;
455
	spin_lock_init(&nfsd_drc_lock);
456
	dprintk("%s nfsd_drc_max_mem %lu \n", __func__, nfsd_drc_max_mem);
A
Andy Adamson 已提交
457
}
458

459
static int nfsd_get_default_max_blksize(void)
460
{
461 462 463
	struct sysinfo i;
	unsigned long long target;
	unsigned long ret;
464

465
	si_meminfo(&i);
466
	target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
467 468 469 470 471 472 473 474 475 476 477 478 479
	/*
	 * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
	 * machines, but only uses 32K on 128M machines.  Bottom out at
	 * 8K on 32M and smaller.  Of course, this is only a default.
	 */
	target >>= 12;

	ret = NFSSVC_MAXBLKSIZE;
	while (ret > target && ret >= 8*1024*2)
		ret /= 2;
	return ret;
}

480 481 482 483
static struct svc_serv_ops nfsd_thread_sv_ops = {
	.svo_shutdown		= nfsd_last_thread,
	.svo_function		= nfsd,
	.svo_enqueue_xprt	= svc_xprt_do_enqueue,
484
	.svo_setup		= svc_set_num_threads,
485
	.svo_module		= THIS_MODULE,
486 487
};

488
int nfsd_create_serv(struct net *net)
489
{
490
	int error;
491
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
492

493
	WARN_ON(!mutex_is_locked(&nfsd_mutex));
494 495
	if (nn->nfsd_serv) {
		svc_get(nn->nfsd_serv);
496 497
		return 0;
	}
498 499
	if (nfsd_max_blksize == 0)
		nfsd_max_blksize = nfsd_get_default_max_blksize();
500
	nfsd_reset_versions();
501
	nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
502
						&nfsd_thread_sv_ops);
503
	if (nn->nfsd_serv == NULL)
504
		return -ENOMEM;
505

506
	nn->nfsd_serv->sv_maxconn = nn->max_connections;
507
	error = svc_bind(nn->nfsd_serv, net);
508
	if (error < 0) {
509
		svc_destroy(nn->nfsd_serv);
510 511 512
		return error;
	}

513
	set_max_drc();
514 515 516
	/* check if the notifier is already set */
	if (atomic_inc_return(&nfsd_notifier_refcount) == 1) {
		register_inetaddr_notifier(&nfsd_inetaddr_notifier);
517
#if IS_ENABLED(CONFIG_IPV6)
518
		register_inet6addr_notifier(&nfsd_inet6addr_notifier);
519
#endif
520
	}
521
	do_gettimeofday(&nn->nfssvc_boot);		/* record boot time */
522
	return 0;
523 524
}

525
int nfsd_nrpools(struct net *net)
526
{
527 528 529
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);

	if (nn->nfsd_serv == NULL)
530 531
		return 0;
	else
532
		return nn->nfsd_serv->sv_nrpools;
533 534
}

535
int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
536 537
{
	int i = 0;
538
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
539

540 541 542
	if (nn->nfsd_serv != NULL) {
		for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++)
			nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads;
543 544 545 546 547
	}

	return 0;
}

548 549 550 551 552 553 554 555 556 557 558 559
void nfsd_destroy(struct net *net)
{
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
	int destroy = (nn->nfsd_serv->sv_nrthreads == 1);

	if (destroy)
		svc_shutdown_net(nn->nfsd_serv, net);
	svc_destroy(nn->nfsd_serv);
	if (destroy)
		nn->nfsd_serv = NULL;
}

560
int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
561 562 563 564
{
	int i = 0;
	int tot = 0;
	int err = 0;
565
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
566

567 568
	WARN_ON(!mutex_is_locked(&nfsd_mutex));

569
	if (nn->nfsd_serv == NULL || n <= 0)
570 571
		return 0;

572 573
	if (n > nn->nfsd_serv->sv_nrpools)
		n = nn->nfsd_serv->sv_nrpools;
574 575 576 577

	/* enforce a global maximum number of threads */
	tot = 0;
	for (i = 0; i < n; i++) {
578
		nthreads[i] = min(nthreads[i], NFSD_MAXSERVS);
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
		tot += nthreads[i];
	}
	if (tot > NFSD_MAXSERVS) {
		/* total too large: scale down requested numbers */
		for (i = 0; i < n && tot > 0; i++) {
		    	int new = nthreads[i] * NFSD_MAXSERVS / tot;
			tot -= (nthreads[i] - new);
			nthreads[i] = new;
		}
		for (i = 0; i < n && tot > 0; i++) {
			nthreads[i]--;
			tot--;
		}
	}

	/*
	 * There must always be a thread in pool 0; the admin
	 * can't shut down NFS completely using pool_threads.
	 */
	if (nthreads[0] == 0)
		nthreads[0] = 1;

	/* apply the new numbers */
602
	svc_get(nn->nfsd_serv);
603
	for (i = 0; i < n; i++) {
604 605
		err = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
				&nn->nfsd_serv->sv_pools[i], nthreads[i]);
606 607 608
		if (err)
			break;
	}
609
	nfsd_destroy(net);
610 611 612
	return err;
}

613 614 615 616 617
/*
 * Adjust the number of threads and return the new number of threads.
 * This is also the function that starts the server if necessary, if
 * this is the first time nrservs is nonzero.
 */
L
Linus Torvalds 已提交
618
int
619
nfsd_svc(int nrservs, struct net *net)
L
Linus Torvalds 已提交
620 621
{
	int	error;
622
	bool	nfsd_up_before;
623
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
624 625

	mutex_lock(&nfsd_mutex);
626
	dprintk("nfsd: creating service\n");
627 628 629

	nrservs = max(nrservs, 0);
	nrservs = min(nrservs, NFSD_MAXSERVS);
630
	error = 0;
631

632
	if (nrservs == 0 && nn->nfsd_serv == NULL)
633 634
		goto out;

635
	error = nfsd_create_serv(net);
636
	if (error)
637 638
		goto out;

639
	nfsd_up_before = nn->nfsd_net_up;
640

641
	error = nfsd_startup_net(nrservs, net);
J
J. Bruce Fields 已提交
642 643
	if (error)
		goto out_destroy;
644 645
	error = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
			NULL, nrservs);
646 647
	if (error)
		goto out_shutdown;
648
	/* We are holding a reference to nn->nfsd_serv which
J
J. Bruce Fields 已提交
649 650 651
	 * we don't want to count in the return value,
	 * so subtract 1
	 */
652
	error = nn->nfsd_serv->sv_nrthreads - 1;
653
out_shutdown:
654
	if (error < 0 && !nfsd_up_before)
655
		nfsd_shutdown_net(net);
656
out_destroy:
657
	nfsd_destroy(net);		/* Release server */
658
out:
659
	mutex_unlock(&nfsd_mutex);
L
Linus Torvalds 已提交
660 661 662 663 664 665 666
	return error;
}


/*
 * This is the NFS server kernel thread
 */
667 668
static int
nfsd(void *vrqstp)
L
Linus Torvalds 已提交
669
{
670
	struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
671 672
	struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
	struct net *net = perm_sock->xpt_net;
673
	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
674
	int err;
L
Linus Torvalds 已提交
675 676

	/* Lock module and set up kernel thread */
677
	mutex_lock(&nfsd_mutex);
L
Linus Torvalds 已提交
678

679
	/* At this point, the thread shares current->fs
680 681
	 * with the init process. We need to create files with the
	 * umask as defined by the client instead of init's umask. */
682
	if (unshare_fs_struct() < 0) {
L
Linus Torvalds 已提交
683 684 685
		printk("Unable to start nfsd thread: out of memory\n");
		goto out;
	}
686

L
Linus Torvalds 已提交
687 688
	current->fs->umask = 0;

689 690
	/*
	 * thread is spawned with all signals set to SIG_IGN, re-enable
691
	 * the ones that will bring down the thread
692
	 */
693 694 695 696
	allow_signal(SIGKILL);
	allow_signal(SIGHUP);
	allow_signal(SIGINT);
	allow_signal(SIGQUIT);
697

L
Linus Torvalds 已提交
698
	nfsdstats.th_cnt++;
699 700
	mutex_unlock(&nfsd_mutex);

701
	set_freezable();
L
Linus Torvalds 已提交
702 703 704 705 706

	/*
	 * The main request loop
	 */
	for (;;) {
707 708 709
		/* Update sv_maxconn if it has changed */
		rqstp->rq_server->sv_maxconn = nn->max_connections;

L
Linus Torvalds 已提交
710 711 712 713
		/*
		 * Find a socket with data available and call its
		 * recvfrom routine.
		 */
714
		while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
L
Linus Torvalds 已提交
715
			;
716
		if (err == -EINTR)
L
Linus Torvalds 已提交
717
			break;
718
		validate_process_creds();
719
		svc_process(rqstp);
720
		validate_process_creds();
L
Linus Torvalds 已提交
721 722
	}

723
	/* Clear signals before calling svc_exit_thread() */
724
	flush_signals(current);
L
Linus Torvalds 已提交
725

726
	mutex_lock(&nfsd_mutex);
L
Linus Torvalds 已提交
727 728 729
	nfsdstats.th_cnt --;

out:
730
	rqstp->rq_server = NULL;
731

L
Linus Torvalds 已提交
732 733 734
	/* Release the thread */
	svc_exit_thread(rqstp);

735
	nfsd_destroy(net);
736

L
Linus Torvalds 已提交
737
	/* Release module */
738
	mutex_unlock(&nfsd_mutex);
L
Linus Torvalds 已提交
739
	module_put_and_exit(0);
740
	return 0;
L
Linus Torvalds 已提交
741 742
}

743 744 745 746 747 748 749 750 751
static __be32 map_new_errors(u32 vers, __be32 nfserr)
{
	if (nfserr == nfserr_jukebox && vers == 2)
		return nfserr_dropit;
	if (nfserr == nfserr_wrongsec && vers < 4)
		return nfserr_acces;
	return nfserr;
}

L
Linus Torvalds 已提交
752
int
753
nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
L
Linus Torvalds 已提交
754 755 756
{
	struct svc_procedure	*proc;
	kxdrproc_t		xdr;
A
Al Viro 已提交
757 758
	__be32			nfserr;
	__be32			*nfserrp;
L
Linus Torvalds 已提交
759 760 761 762 763

	dprintk("nfsd_dispatch: vers %d proc %d\n",
				rqstp->rq_vers, rqstp->rq_proc);
	proc = rqstp->rq_procinfo;

764 765 766 767 768 769 770 771 772 773 774 775 776 777
	/*
	 * Give the xdr decoder a chance to change this if it wants
	 * (necessary in the NFSv4.0 compound case)
	 */
	rqstp->rq_cachetype = proc->pc_cachetype;
	/* Decode arguments */
	xdr = proc->pc_decode;
	if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
			rqstp->rq_argp)) {
		dprintk("nfsd: failed to decode arguments!\n");
		*statp = rpc_garbage_args;
		return 1;
	}

L
Linus Torvalds 已提交
778
	/* Check whether we have this call in the cache. */
779
	switch (nfsd_cache_lookup(rqstp)) {
L
Linus Torvalds 已提交
780 781 782 783 784 785 786 787 788 789 790 791 792
	case RC_DROPIT:
		return 0;
	case RC_REPLY:
		return 1;
	case RC_DOIT:;
		/* do it */
	}

	/* need to grab the location to store the status, as
	 * nfsv4 does some encoding while processing 
	 */
	nfserrp = rqstp->rq_res.head[0].iov_base
		+ rqstp->rq_res.head[0].iov_len;
A
Al Viro 已提交
793
	rqstp->rq_res.head[0].iov_len += sizeof(__be32);
L
Linus Torvalds 已提交
794 795 796

	/* Now call the procedure handler, and encode NFS status. */
	nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
797
	nfserr = map_new_errors(rqstp->rq_vers, nfserr);
798
	if (nfserr == nfserr_dropit || test_bit(RQ_DROPME, &rqstp->rq_flags)) {
799
		dprintk("nfsd: Dropping request; may be revisited later\n");
L
Linus Torvalds 已提交
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
		nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
		return 0;
	}

	if (rqstp->rq_proc != 0)
		*nfserrp++ = nfserr;

	/* Encode result.
	 * For NFSv2, additional info is never returned in case of an error.
	 */
	if (!(nfserr && rqstp->rq_vers == 2)) {
		xdr = proc->pc_encode;
		if (xdr && !xdr(rqstp, nfserrp,
				rqstp->rq_resp)) {
			/* Failed to encode result. Release cache entry */
			dprintk("nfsd: failed to encode result!\n");
			nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
			*statp = rpc_system_err;
			return 1;
		}
	}

	/* Store reply in cache. */
J
J. Bruce Fields 已提交
823
	nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
L
Linus Torvalds 已提交
824 825
	return 1;
}
826 827 828

int nfsd_pool_stats_open(struct inode *inode, struct file *file)
{
829
	int ret;
830
	struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id);
831

832
	mutex_lock(&nfsd_mutex);
833
	if (nn->nfsd_serv == NULL) {
834
		mutex_unlock(&nfsd_mutex);
835
		return -ENODEV;
836 837
	}
	/* bump up the psudo refcount while traversing */
838 839
	svc_get(nn->nfsd_serv);
	ret = svc_pool_stats_open(nn->nfsd_serv, file);
840 841 842 843 844 845 846
	mutex_unlock(&nfsd_mutex);
	return ret;
}

int nfsd_pool_stats_release(struct inode *inode, struct file *file)
{
	int ret = seq_release(inode, file);
847
	struct net *net = inode->i_sb->s_fs_info;
848

849 850
	mutex_lock(&nfsd_mutex);
	/* this function really, really should have been called svc_put() */
851
	nfsd_destroy(net);
852 853
	mutex_unlock(&nfsd_mutex);
	return ret;
854
}