xref: /linux/fs/nfsd/nfssvc.c (revision b88fe2b5dd018c2b856fd6c32b82f25033e908d4)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Central processing for nfsd.
4  *
5  * Authors:	Olaf Kirch (okir@monad.swb.de)
6  *
7  * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
8  */
9 
10 #include <linux/sched/signal.h>
11 #include <linux/freezer.h>
12 #include <linux/module.h>
13 #include <linux/fs_struct.h>
14 #include <linux/swap.h>
15 #include <linux/siphash.h>
16 
17 #include <linux/sunrpc/stats.h>
18 #include <linux/sunrpc/svcsock.h>
19 #include <linux/sunrpc/svc_xprt.h>
20 #include <linux/lockd/bind.h>
21 #include <linux/nfsacl.h>
22 #include <linux/nfslocalio.h>
23 #include <linux/seq_file.h>
24 #include <linux/inetdevice.h>
25 #include <net/addrconf.h>
26 #include <net/ipv6.h>
27 #include <net/net_namespace.h>
28 #include "nfsd.h"
29 #include "cache.h"
30 #include "vfs.h"
31 #include "netns.h"
32 #include "filecache.h"
33 
34 #include "trace.h"
35 
36 #define NFSDDBG_FACILITY	NFSDDBG_SVC
37 
38 atomic_t			nfsd_th_cnt = ATOMIC_INIT(0);
39 static int			nfsd(void *vrqstp);
40 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
41 static int			nfsd_acl_rpcbind_set(struct net *,
42 						     const struct svc_program *,
43 						     u32, int,
44 						     unsigned short,
45 						     unsigned short);
46 static __be32			nfsd_acl_init_request(struct svc_rqst *,
47 						const struct svc_program *,
48 						struct svc_process_info *);
49 #endif
50 static int			nfsd_rpcbind_set(struct net *,
51 						 const struct svc_program *,
52 						 u32, int,
53 						 unsigned short,
54 						 unsigned short);
55 static __be32			nfsd_init_request(struct svc_rqst *,
56 						const struct svc_program *,
57 						struct svc_process_info *);
58 
59 /*
60  * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and some members
61  * of the svc_serv struct such as ->sv_temp_socks and ->sv_permsocks.
62  *
63  * Finally, the nfsd_mutex also protects some of the global variables that are
64  * accessed when nfsd starts and that are settable via the write_* routines in
65  * nfsctl.c. In particular:
66  *
67  *	user_recovery_dirname
68  *	user_lease_time
69  *	nfsd_versions
70  */
71 DEFINE_MUTEX(nfsd_mutex);
72 
73 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
74 static const struct svc_version *localio_versions[] = {
75 	[1] = &localio_version1,
76 };
77 
78 #define NFSD_LOCALIO_NRVERS		ARRAY_SIZE(localio_versions)
79 
80 #endif /* CONFIG_NFS_LOCALIO */
81 
82 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
83 static const struct svc_version *nfsd_acl_version[] = {
84 # if defined(CONFIG_NFSD_V2_ACL)
85 	[2] = &nfsd_acl_version2,
86 # endif
87 # if defined(CONFIG_NFSD_V3_ACL)
88 	[3] = &nfsd_acl_version3,
89 # endif
90 };
91 
92 #define NFSD_ACL_MINVERS	2
93 #define NFSD_ACL_NRVERS		ARRAY_SIZE(nfsd_acl_version)
94 
95 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
96 
97 static const struct svc_version *nfsd_version[NFSD_MAXVERS+1] = {
98 #if defined(CONFIG_NFSD_V2)
99 	[2] = &nfsd_version2,
100 #endif
101 	[3] = &nfsd_version3,
102 #if defined(CONFIG_NFSD_V4)
103 	[4] = &nfsd_version4,
104 #endif
105 };
106 
107 struct svc_program		nfsd_programs[] = {
108 	{
109 	.pg_prog		= NFS_PROGRAM,		/* program number */
110 	.pg_nvers		= NFSD_MAXVERS+1,	/* nr of entries in nfsd_version */
111 	.pg_vers		= nfsd_version,		/* version table */
112 	.pg_name		= "nfsd",		/* program name */
113 	.pg_class		= "nfsd",		/* authentication class */
114 	.pg_authenticate	= svc_set_client,	/* export authentication */
115 	.pg_init_request	= nfsd_init_request,
116 	.pg_rpcbind_set		= nfsd_rpcbind_set,
117 	},
118 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
119 	{
120 	.pg_prog		= NFS_ACL_PROGRAM,
121 	.pg_nvers		= NFSD_ACL_NRVERS,
122 	.pg_vers		= nfsd_acl_version,
123 	.pg_name		= "nfsacl",
124 	.pg_class		= "nfsd",
125 	.pg_authenticate	= svc_set_client,
126 	.pg_init_request	= nfsd_acl_init_request,
127 	.pg_rpcbind_set		= nfsd_acl_rpcbind_set,
128 	},
129 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
130 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
131 	{
132 	.pg_prog		= NFS_LOCALIO_PROGRAM,
133 	.pg_nvers		= NFSD_LOCALIO_NRVERS,
134 	.pg_vers		= localio_versions,
135 	.pg_name		= "nfslocalio",
136 	.pg_class		= "nfsd",
137 	.pg_authenticate	= svc_set_client,
138 	.pg_init_request	= svc_generic_init_request,
139 	.pg_rpcbind_set		= svc_generic_rpcbind_set,
140 	}
141 #endif /* CONFIG_NFS_LOCALIO */
142 };
143 
144 bool nfsd_support_version(int vers)
145 {
146 	if (vers >= NFSD_MINVERS && vers <= NFSD_MAXVERS)
147 		return nfsd_version[vers] != NULL;
148 	return false;
149 }
150 
151 int nfsd_vers(struct nfsd_net *nn, int vers, enum vers_op change)
152 {
153 	if (vers < NFSD_MINVERS || vers > NFSD_MAXVERS)
154 		return 0;
155 	switch(change) {
156 	case NFSD_SET:
157 		nn->nfsd_versions[vers] = nfsd_support_version(vers);
158 		break;
159 	case NFSD_CLEAR:
160 		nn->nfsd_versions[vers] = false;
161 		break;
162 	case NFSD_TEST:
163 		return nn->nfsd_versions[vers];
164 	case NFSD_AVAIL:
165 		return nfsd_support_version(vers);
166 	}
167 	return 0;
168 }
169 
170 static void
171 nfsd_adjust_nfsd_versions4(struct nfsd_net *nn)
172 {
173 	unsigned i;
174 
175 	for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++) {
176 		if (nn->nfsd4_minorversions[i])
177 			return;
178 	}
179 	nfsd_vers(nn, 4, NFSD_CLEAR);
180 }
181 
182 int nfsd_minorversion(struct nfsd_net *nn, u32 minorversion, enum vers_op change)
183 {
184 	if (minorversion > NFSD_SUPPORTED_MINOR_VERSION &&
185 	    change != NFSD_AVAIL)
186 		return -1;
187 
188 	switch(change) {
189 	case NFSD_SET:
190 		nfsd_vers(nn, 4, NFSD_SET);
191 		nn->nfsd4_minorversions[minorversion] =
192 			nfsd_vers(nn, 4, NFSD_TEST);
193 		break;
194 	case NFSD_CLEAR:
195 		nn->nfsd4_minorversions[minorversion] = false;
196 		nfsd_adjust_nfsd_versions4(nn);
197 		break;
198 	case NFSD_TEST:
199 		return nn->nfsd4_minorversions[minorversion];
200 	case NFSD_AVAIL:
201 		return minorversion <= NFSD_SUPPORTED_MINOR_VERSION &&
202 			nfsd_vers(nn, 4, NFSD_AVAIL);
203 	}
204 	return 0;
205 }
206 
207 bool nfsd_net_try_get(struct net *net) __must_hold(rcu)
208 {
209 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
210 
211 	return (nn && percpu_ref_tryget_live(&nn->nfsd_net_ref));
212 }
213 
214 void nfsd_net_put(struct net *net) __must_hold(rcu)
215 {
216 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
217 
218 	percpu_ref_put(&nn->nfsd_net_ref);
219 }
220 
221 static void nfsd_net_done(struct percpu_ref *ref)
222 {
223 	struct nfsd_net *nn = container_of(ref, struct nfsd_net, nfsd_net_ref);
224 
225 	complete(&nn->nfsd_net_confirm_done);
226 }
227 
228 static void nfsd_net_free(struct percpu_ref *ref)
229 {
230 	struct nfsd_net *nn = container_of(ref, struct nfsd_net, nfsd_net_ref);
231 
232 	complete(&nn->nfsd_net_free_done);
233 }
234 
235 /*
236  * Maximum number of nfsd processes
237  */
238 #define	NFSD_MAXSERVS		8192
239 
240 int nfsd_nrthreads(struct net *net)
241 {
242 	int rv = 0;
243 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
244 
245 	mutex_lock(&nfsd_mutex);
246 	if (nn->nfsd_serv)
247 		rv = nn->nfsd_serv->sv_nrthreads;
248 	mutex_unlock(&nfsd_mutex);
249 	return rv;
250 }
251 
252 static int nfsd_init_socks(struct net *net, const struct cred *cred)
253 {
254 	int error;
255 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
256 
257 	if (!list_empty(&nn->nfsd_serv->sv_permsocks))
258 		return 0;
259 
260 	error = svc_xprt_create(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT,
261 				SVC_SOCK_DEFAULTS, cred);
262 	if (error < 0)
263 		return error;
264 
265 	error = svc_xprt_create(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
266 				SVC_SOCK_DEFAULTS, cred);
267 	if (error < 0)
268 		return error;
269 
270 	return 0;
271 }
272 
273 static int nfsd_users = 0;
274 
275 static int nfsd_startup_generic(void)
276 {
277 	int ret;
278 
279 	if (nfsd_users++)
280 		return 0;
281 
282 	ret = nfsd_file_cache_init();
283 	if (ret)
284 		goto dec_users;
285 
286 	ret = nfs4_state_start();
287 	if (ret)
288 		goto out_file_cache;
289 	return 0;
290 
291 out_file_cache:
292 	nfsd_file_cache_shutdown();
293 dec_users:
294 	nfsd_users--;
295 	return ret;
296 }
297 
298 static void nfsd_shutdown_generic(void)
299 {
300 	if (--nfsd_users)
301 		return;
302 
303 	nfs4_state_shutdown();
304 	nfsd_file_cache_shutdown();
305 }
306 
307 static bool nfsd_needs_lockd(struct nfsd_net *nn)
308 {
309 	return nfsd_vers(nn, 2, NFSD_TEST) || nfsd_vers(nn, 3, NFSD_TEST);
310 }
311 
312 /**
313  * nfsd_copy_write_verifier - Atomically copy a write verifier
314  * @verf: buffer in which to receive the verifier cookie
315  * @nn: NFS net namespace
316  *
317  * This function provides a wait-free mechanism for copying the
318  * namespace's write verifier without tearing it.
319  */
320 void nfsd_copy_write_verifier(__be32 verf[2], struct nfsd_net *nn)
321 {
322 	unsigned int seq;
323 
324 	do {
325 		seq = read_seqbegin(&nn->writeverf_lock);
326 		memcpy(verf, nn->writeverf, sizeof(nn->writeverf));
327 	} while (read_seqretry(&nn->writeverf_lock, seq));
328 }
329 
330 static void nfsd_reset_write_verifier_locked(struct nfsd_net *nn)
331 {
332 	struct timespec64 now;
333 	u64 verf;
334 
335 	/*
336 	 * Because the time value is hashed, y2038 time_t overflow
337 	 * is irrelevant in this usage.
338 	 */
339 	ktime_get_raw_ts64(&now);
340 	verf = siphash_2u64(now.tv_sec, now.tv_nsec, &nn->siphash_key);
341 	memcpy(nn->writeverf, &verf, sizeof(nn->writeverf));
342 }
343 
344 /**
345  * nfsd_reset_write_verifier - Generate a new write verifier
346  * @nn: NFS net namespace
347  *
348  * This function updates the ->writeverf field of @nn. This field
349  * contains an opaque cookie that, according to Section 18.32.3 of
350  * RFC 8881, "the client can use to determine whether a server has
351  * changed instance state (e.g., server restart) between a call to
352  * WRITE and a subsequent call to either WRITE or COMMIT.  This
353  * cookie MUST be unchanged during a single instance of the NFSv4.1
354  * server and MUST be unique between instances of the NFSv4.1
355  * server."
356  */
357 void nfsd_reset_write_verifier(struct nfsd_net *nn)
358 {
359 	write_seqlock(&nn->writeverf_lock);
360 	nfsd_reset_write_verifier_locked(nn);
361 	write_sequnlock(&nn->writeverf_lock);
362 }
363 
364 /*
365  * Crank up a set of per-namespace resources for a new NFSD instance,
366  * including lockd, a duplicate reply cache, an open file cache
367  * instance, and a cache of NFSv4 state objects.
368  */
369 static int nfsd_startup_net(struct net *net, const struct cred *cred)
370 {
371 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
372 	int ret;
373 
374 	if (nn->nfsd_net_up)
375 		return 0;
376 
377 	ret = nfsd_startup_generic();
378 	if (ret)
379 		return ret;
380 	ret = nfsd_init_socks(net, cred);
381 	if (ret)
382 		goto out_socks;
383 
384 	if (nfsd_needs_lockd(nn) && !nn->lockd_up) {
385 		ret = lockd_up(net, cred);
386 		if (ret)
387 			goto out_socks;
388 		nn->lockd_up = true;
389 	}
390 
391 	ret = nfsd_file_cache_start_net(net);
392 	if (ret)
393 		goto out_lockd;
394 
395 	ret = nfsd_reply_cache_init(nn);
396 	if (ret)
397 		goto out_filecache;
398 
399 	ret = nfs4_state_start_net(net);
400 	if (ret)
401 		goto out_reply_cache;
402 
403 #ifdef CONFIG_NFSD_V4_2_INTER_SSC
404 	nfsd4_ssc_init_umount_work(nn);
405 #endif
406 	nn->nfsd_net_up = true;
407 	return 0;
408 
409 out_reply_cache:
410 	nfsd_reply_cache_shutdown(nn);
411 out_filecache:
412 	nfsd_file_cache_shutdown_net(net);
413 out_lockd:
414 	if (nn->lockd_up) {
415 		lockd_down(net);
416 		nn->lockd_up = false;
417 	}
418 out_socks:
419 	nfsd_shutdown_generic();
420 	return ret;
421 }
422 
423 static void nfsd_shutdown_net(struct net *net)
424 {
425 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
426 
427 	if (!nn->nfsd_net_up)
428 		return;
429 
430 	percpu_ref_kill_and_confirm(&nn->nfsd_net_ref, nfsd_net_done);
431 	wait_for_completion(&nn->nfsd_net_confirm_done);
432 
433 	nfsd_export_flush(net);
434 	nfs4_state_shutdown_net(net);
435 	nfsd_reply_cache_shutdown(nn);
436 	nfsd_file_cache_shutdown_net(net);
437 	if (nn->lockd_up) {
438 		lockd_down(net);
439 		nn->lockd_up = false;
440 	}
441 
442 	wait_for_completion(&nn->nfsd_net_free_done);
443 	percpu_ref_exit(&nn->nfsd_net_ref);
444 
445 	nn->nfsd_net_up = false;
446 	nfsd_shutdown_generic();
447 }
448 
449 static DEFINE_SPINLOCK(nfsd_notifier_lock);
450 static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event,
451 	void *ptr)
452 {
453 	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
454 	struct net_device *dev = ifa->ifa_dev->dev;
455 	struct net *net = dev_net(dev);
456 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
457 	struct sockaddr_in sin;
458 
459 	if (event != NETDEV_DOWN || !nn->nfsd_serv)
460 		goto out;
461 
462 	spin_lock(&nfsd_notifier_lock);
463 	if (nn->nfsd_serv) {
464 		dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local);
465 		sin.sin_family = AF_INET;
466 		sin.sin_addr.s_addr = ifa->ifa_local;
467 		svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin);
468 	}
469 	spin_unlock(&nfsd_notifier_lock);
470 
471 out:
472 	return NOTIFY_DONE;
473 }
474 
475 static struct notifier_block nfsd_inetaddr_notifier = {
476 	.notifier_call = nfsd_inetaddr_event,
477 };
478 
479 #if IS_ENABLED(CONFIG_IPV6)
480 static int nfsd_inet6addr_event(struct notifier_block *this,
481 	unsigned long event, void *ptr)
482 {
483 	struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
484 	struct net_device *dev = ifa->idev->dev;
485 	struct net *net = dev_net(dev);
486 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
487 	struct sockaddr_in6 sin6;
488 
489 	if (event != NETDEV_DOWN || !nn->nfsd_serv)
490 		goto out;
491 
492 	spin_lock(&nfsd_notifier_lock);
493 	if (nn->nfsd_serv) {
494 		dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr);
495 		sin6.sin6_family = AF_INET6;
496 		sin6.sin6_addr = ifa->addr;
497 		if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
498 			sin6.sin6_scope_id = ifa->idev->dev->ifindex;
499 		svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6);
500 	}
501 	spin_unlock(&nfsd_notifier_lock);
502 
503 out:
504 	return NOTIFY_DONE;
505 }
506 
507 static struct notifier_block nfsd_inet6addr_notifier = {
508 	.notifier_call = nfsd_inet6addr_event,
509 };
510 #endif
511 
512 /* Only used under nfsd_mutex, so this atomic may be overkill: */
513 static atomic_t nfsd_notifier_refcount = ATOMIC_INIT(0);
514 
515 /**
516  * nfsd_destroy_serv - tear down NFSD's svc_serv for a namespace
517  * @net: network namespace the NFS service is associated with
518  */
519 void nfsd_destroy_serv(struct net *net)
520 {
521 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
522 	struct svc_serv *serv = nn->nfsd_serv;
523 
524 	lockdep_assert_held(&nfsd_mutex);
525 
526 	spin_lock(&nfsd_notifier_lock);
527 	nn->nfsd_serv = NULL;
528 	spin_unlock(&nfsd_notifier_lock);
529 
530 	/* check if the notifier still has clients */
531 	if (atomic_dec_return(&nfsd_notifier_refcount) == 0) {
532 		unregister_inetaddr_notifier(&nfsd_inetaddr_notifier);
533 #if IS_ENABLED(CONFIG_IPV6)
534 		unregister_inet6addr_notifier(&nfsd_inet6addr_notifier);
535 #endif
536 	}
537 
538 	svc_xprt_destroy_all(serv, net);
539 
540 	/*
541 	 * write_ports can create the server without actually starting
542 	 * any threads--if we get shut down before any threads are
543 	 * started, then nfsd_destroy_serv will be run before any of this
544 	 * other initialization has been done except the rpcb information.
545 	 */
546 	svc_rpcb_cleanup(serv, net);
547 
548 	nfsd_shutdown_net(net);
549 	svc_destroy(&serv);
550 }
551 
552 void nfsd_reset_versions(struct nfsd_net *nn)
553 {
554 	int i;
555 
556 	for (i = 0; i <= NFSD_MAXVERS; i++)
557 		if (nfsd_vers(nn, i, NFSD_TEST))
558 			return;
559 
560 	for (i = 0; i <= NFSD_MAXVERS; i++)
561 		if (i != 4)
562 			nfsd_vers(nn, i, NFSD_SET);
563 		else {
564 			int minor = 0;
565 			while (nfsd_minorversion(nn, minor, NFSD_SET) >= 0)
566 				minor++;
567 		}
568 }
569 
570 static int nfsd_get_default_max_blksize(void)
571 {
572 	struct sysinfo i;
573 	unsigned long long target;
574 	unsigned long ret;
575 
576 	si_meminfo(&i);
577 	target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
578 	/*
579 	 * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
580 	 * machines, but only uses 32K on 128M machines.  Bottom out at
581 	 * 8K on 32M and smaller.  Of course, this is only a default.
582 	 */
583 	target >>= 12;
584 
585 	ret = NFSSVC_MAXBLKSIZE;
586 	while (ret > target && ret >= 8*1024*2)
587 		ret /= 2;
588 	return ret;
589 }
590 
591 void nfsd_shutdown_threads(struct net *net)
592 {
593 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
594 	struct svc_serv *serv;
595 
596 	mutex_lock(&nfsd_mutex);
597 	serv = nn->nfsd_serv;
598 	if (serv == NULL) {
599 		mutex_unlock(&nfsd_mutex);
600 		return;
601 	}
602 
603 	/* Kill outstanding nfsd threads */
604 	svc_set_num_threads(serv, NULL, 0);
605 	nfsd_destroy_serv(net);
606 	mutex_unlock(&nfsd_mutex);
607 }
608 
609 struct svc_rqst *nfsd_current_rqst(void)
610 {
611 	if (kthread_func(current) == nfsd)
612 		return kthread_data(current);
613 	return NULL;
614 }
615 
616 int nfsd_create_serv(struct net *net)
617 {
618 	int error;
619 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
620 	struct svc_serv *serv;
621 
622 	WARN_ON(!mutex_is_locked(&nfsd_mutex));
623 	if (nn->nfsd_serv)
624 		return 0;
625 
626 	error = percpu_ref_init(&nn->nfsd_net_ref, nfsd_net_free,
627 				0, GFP_KERNEL);
628 	if (error)
629 		return error;
630 	init_completion(&nn->nfsd_net_free_done);
631 	init_completion(&nn->nfsd_net_confirm_done);
632 
633 	if (nfsd_max_blksize == 0)
634 		nfsd_max_blksize = nfsd_get_default_max_blksize();
635 	nfsd_reset_versions(nn);
636 	serv = svc_create_pooled(nfsd_programs, ARRAY_SIZE(nfsd_programs),
637 				 &nn->nfsd_svcstats,
638 				 nfsd_max_blksize, nfsd);
639 	if (serv == NULL)
640 		return -ENOMEM;
641 
642 	error = svc_bind(serv, net);
643 	if (error < 0) {
644 		svc_destroy(&serv);
645 		return error;
646 	}
647 	spin_lock(&nfsd_notifier_lock);
648 	nn->nfsd_serv = serv;
649 	spin_unlock(&nfsd_notifier_lock);
650 
651 	/* check if the notifier is already set */
652 	if (atomic_inc_return(&nfsd_notifier_refcount) == 1) {
653 		register_inetaddr_notifier(&nfsd_inetaddr_notifier);
654 #if IS_ENABLED(CONFIG_IPV6)
655 		register_inet6addr_notifier(&nfsd_inet6addr_notifier);
656 #endif
657 	}
658 	nfsd_reset_write_verifier(nn);
659 	return 0;
660 }
661 
662 int nfsd_nrpools(struct net *net)
663 {
664 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
665 
666 	if (nn->nfsd_serv == NULL)
667 		return 0;
668 	else
669 		return nn->nfsd_serv->sv_nrpools;
670 }
671 
672 int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
673 {
674 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
675 	struct svc_serv *serv = nn->nfsd_serv;
676 	int i;
677 
678 	if (serv)
679 		for (i = 0; i < serv->sv_nrpools && i < n; i++)
680 			nthreads[i] = serv->sv_pools[i].sp_nrthreads;
681 	return 0;
682 }
683 
684 /**
685  * nfsd_set_nrthreads - set the number of running threads in the net's service
686  * @n: number of array members in @nthreads
687  * @nthreads: array of thread counts for each pool
688  * @net: network namespace to operate within
689  *
690  * This function alters the number of running threads for the given network
691  * namespace in each pool. If passed an array longer then the number of pools
692  * the extra pool settings are ignored. If passed an array shorter than the
693  * number of pools, the missing values are interpreted as 0's.
694  *
695  * Returns 0 on success or a negative errno on error.
696  */
697 int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
698 {
699 	int i = 0;
700 	int tot = 0;
701 	int err = 0;
702 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
703 
704 	lockdep_assert_held(&nfsd_mutex);
705 
706 	if (nn->nfsd_serv == NULL || n <= 0)
707 		return 0;
708 
709 	/*
710 	 * Special case: When n == 1, pass in NULL for the pool, so that the
711 	 * change is distributed equally among them.
712 	 */
713 	if (n == 1)
714 		return svc_set_num_threads(nn->nfsd_serv, NULL, nthreads[0]);
715 
716 	if (n > nn->nfsd_serv->sv_nrpools)
717 		n = nn->nfsd_serv->sv_nrpools;
718 
719 	/* enforce a global maximum number of threads */
720 	tot = 0;
721 	for (i = 0; i < n; i++) {
722 		nthreads[i] = min(nthreads[i], NFSD_MAXSERVS);
723 		tot += nthreads[i];
724 	}
725 	if (tot > NFSD_MAXSERVS) {
726 		/* total too large: scale down requested numbers */
727 		for (i = 0; i < n && tot > 0; i++) {
728 			int new = nthreads[i] * NFSD_MAXSERVS / tot;
729 			tot -= (nthreads[i] - new);
730 			nthreads[i] = new;
731 		}
732 		for (i = 0; i < n && tot > 0; i++) {
733 			nthreads[i]--;
734 			tot--;
735 		}
736 	}
737 
738 	/* apply the new numbers */
739 	for (i = 0; i < n; i++) {
740 		err = svc_set_num_threads(nn->nfsd_serv,
741 					  &nn->nfsd_serv->sv_pools[i],
742 					  nthreads[i]);
743 		if (err)
744 			goto out;
745 	}
746 
747 	/* Anything undefined in array is considered to be 0 */
748 	for (i = n; i < nn->nfsd_serv->sv_nrpools; ++i) {
749 		err = svc_set_num_threads(nn->nfsd_serv,
750 					  &nn->nfsd_serv->sv_pools[i],
751 					  0);
752 		if (err)
753 			goto out;
754 	}
755 out:
756 	return err;
757 }
758 
759 /**
760  * nfsd_svc: start up or shut down the nfsd server
761  * @n: number of array members in @nthreads
762  * @nthreads: array of thread counts for each pool
763  * @net: network namespace to operate within
764  * @cred: credentials to use for xprt creation
765  * @scope: server scope value (defaults to nodename)
766  *
767  * Adjust the number of threads in each pool and return the new
768  * total number of threads in the service.
769  */
770 int
771 nfsd_svc(int n, int *nthreads, struct net *net, const struct cred *cred, const char *scope)
772 {
773 	int	error;
774 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
775 	struct svc_serv *serv;
776 
777 	lockdep_assert_held(&nfsd_mutex);
778 
779 	dprintk("nfsd: creating service\n");
780 
781 	strscpy(nn->nfsd_name, scope ? scope : utsname()->nodename,
782 		sizeof(nn->nfsd_name));
783 
784 	error = nfsd_create_serv(net);
785 	if (error)
786 		goto out;
787 	serv = nn->nfsd_serv;
788 
789 	error = nfsd_startup_net(net, cred);
790 	if (error)
791 		goto out_put;
792 	error = nfsd_set_nrthreads(n, nthreads, net);
793 	if (error)
794 		goto out_put;
795 	error = serv->sv_nrthreads;
796 out_put:
797 	if (serv->sv_nrthreads == 0)
798 		nfsd_destroy_serv(net);
799 out:
800 	return error;
801 }
802 
803 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
804 static bool
805 nfsd_support_acl_version(int vers)
806 {
807 	if (vers >= NFSD_ACL_MINVERS && vers < NFSD_ACL_NRVERS)
808 		return nfsd_acl_version[vers] != NULL;
809 	return false;
810 }
811 
812 static int
813 nfsd_acl_rpcbind_set(struct net *net, const struct svc_program *progp,
814 		     u32 version, int family, unsigned short proto,
815 		     unsigned short port)
816 {
817 	if (!nfsd_support_acl_version(version) ||
818 	    !nfsd_vers(net_generic(net, nfsd_net_id), version, NFSD_TEST))
819 		return 0;
820 	return svc_generic_rpcbind_set(net, progp, version, family,
821 			proto, port);
822 }
823 
824 static __be32
825 nfsd_acl_init_request(struct svc_rqst *rqstp,
826 		      const struct svc_program *progp,
827 		      struct svc_process_info *ret)
828 {
829 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
830 	int i;
831 
832 	if (likely(nfsd_support_acl_version(rqstp->rq_vers) &&
833 	    nfsd_vers(nn, rqstp->rq_vers, NFSD_TEST)))
834 		return svc_generic_init_request(rqstp, progp, ret);
835 
836 	ret->mismatch.lovers = NFSD_ACL_NRVERS;
837 	for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++) {
838 		if (nfsd_support_acl_version(rqstp->rq_vers) &&
839 		    nfsd_vers(nn, i, NFSD_TEST)) {
840 			ret->mismatch.lovers = i;
841 			break;
842 		}
843 	}
844 	if (ret->mismatch.lovers == NFSD_ACL_NRVERS)
845 		return rpc_prog_unavail;
846 	ret->mismatch.hivers = NFSD_ACL_MINVERS;
847 	for (i = NFSD_ACL_NRVERS - 1; i >= NFSD_ACL_MINVERS; i--) {
848 		if (nfsd_support_acl_version(rqstp->rq_vers) &&
849 		    nfsd_vers(nn, i, NFSD_TEST)) {
850 			ret->mismatch.hivers = i;
851 			break;
852 		}
853 	}
854 	return rpc_prog_mismatch;
855 }
856 #endif
857 
858 static int
859 nfsd_rpcbind_set(struct net *net, const struct svc_program *progp,
860 		 u32 version, int family, unsigned short proto,
861 		 unsigned short port)
862 {
863 	if (!nfsd_vers(net_generic(net, nfsd_net_id), version, NFSD_TEST))
864 		return 0;
865 	return svc_generic_rpcbind_set(net, progp, version, family,
866 			proto, port);
867 }
868 
869 static __be32
870 nfsd_init_request(struct svc_rqst *rqstp,
871 		  const struct svc_program *progp,
872 		  struct svc_process_info *ret)
873 {
874 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
875 	int i;
876 
877 	if (likely(nfsd_vers(nn, rqstp->rq_vers, NFSD_TEST)))
878 		return svc_generic_init_request(rqstp, progp, ret);
879 
880 	ret->mismatch.lovers = NFSD_MAXVERS + 1;
881 	for (i = NFSD_MINVERS; i <= NFSD_MAXVERS; i++) {
882 		if (nfsd_vers(nn, i, NFSD_TEST)) {
883 			ret->mismatch.lovers = i;
884 			break;
885 		}
886 	}
887 	if (ret->mismatch.lovers > NFSD_MAXVERS)
888 		return rpc_prog_unavail;
889 	ret->mismatch.hivers = NFSD_MINVERS;
890 	for (i = NFSD_MAXVERS; i >= NFSD_MINVERS; i--) {
891 		if (nfsd_vers(nn, i, NFSD_TEST)) {
892 			ret->mismatch.hivers = i;
893 			break;
894 		}
895 	}
896 	return rpc_prog_mismatch;
897 }
898 
899 /*
900  * This is the NFS server kernel thread
901  */
902 static int
903 nfsd(void *vrqstp)
904 {
905 	struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
906 	struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
907 	struct net *net = perm_sock->xpt_net;
908 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
909 
910 	/* At this point, the thread shares current->fs
911 	 * with the init process. We need to create files with the
912 	 * umask as defined by the client instead of init's umask.
913 	 */
914 	svc_thread_init_status(rqstp, unshare_fs_struct());
915 
916 	current->fs->umask = 0;
917 
918 	atomic_inc(&nfsd_th_cnt);
919 
920 	set_freezable();
921 
922 	/*
923 	 * The main request loop
924 	 */
925 	while (!svc_thread_should_stop(rqstp)) {
926 		svc_recv(rqstp);
927 		nfsd_file_net_dispose(nn);
928 	}
929 
930 	atomic_dec(&nfsd_th_cnt);
931 
932 	/* Release the thread */
933 	svc_exit_thread(rqstp);
934 	return 0;
935 }
936 
937 /**
938  * nfsd_dispatch - Process an NFS or NFSACL or LOCALIO Request
939  * @rqstp: incoming request
940  *
941  * This RPC dispatcher integrates the NFS server's duplicate reply cache.
942  *
943  * Return values:
944  *  %0: Processing complete; do not send a Reply
945  *  %1: Processing complete; send Reply in rqstp->rq_res
946  */
947 int nfsd_dispatch(struct svc_rqst *rqstp)
948 {
949 	const struct svc_procedure *proc = rqstp->rq_procinfo;
950 	__be32 *statp = rqstp->rq_accept_statp;
951 	struct nfsd_cacherep *rp;
952 	unsigned int start, len;
953 	__be32 *nfs_reply;
954 
955 	/*
956 	 * Give the xdr decoder a chance to change this if it wants
957 	 * (necessary in the NFSv4.0 compound case)
958 	 */
959 	rqstp->rq_cachetype = proc->pc_cachetype;
960 
961 	/*
962 	 * ->pc_decode advances the argument stream past the NFS
963 	 * Call header, so grab the header's starting location and
964 	 * size now for the call to nfsd_cache_lookup().
965 	 */
966 	start = xdr_stream_pos(&rqstp->rq_arg_stream);
967 	len = xdr_stream_remaining(&rqstp->rq_arg_stream);
968 	if (!proc->pc_decode(rqstp, &rqstp->rq_arg_stream))
969 		goto out_decode_err;
970 
971 	/*
972 	 * Release rq_status_counter setting it to an odd value after the rpc
973 	 * request has been properly parsed. rq_status_counter is used to
974 	 * notify the consumers if the rqstp fields are stable
975 	 * (rq_status_counter is odd) or not meaningful (rq_status_counter
976 	 * is even).
977 	 */
978 	smp_store_release(&rqstp->rq_status_counter, rqstp->rq_status_counter | 1);
979 
980 	rp = NULL;
981 	switch (nfsd_cache_lookup(rqstp, start, len, &rp)) {
982 	case RC_DOIT:
983 		break;
984 	case RC_REPLY:
985 		goto out_cached_reply;
986 	case RC_DROPIT:
987 		goto out_dropit;
988 	}
989 
990 	nfs_reply = xdr_inline_decode(&rqstp->rq_res_stream, 0);
991 	*statp = proc->pc_func(rqstp);
992 	if (test_bit(RQ_DROPME, &rqstp->rq_flags))
993 		goto out_update_drop;
994 
995 	if (!proc->pc_encode(rqstp, &rqstp->rq_res_stream))
996 		goto out_encode_err;
997 
998 	/*
999 	 * Release rq_status_counter setting it to an even value after the rpc
1000 	 * request has been properly processed.
1001 	 */
1002 	smp_store_release(&rqstp->rq_status_counter, rqstp->rq_status_counter + 1);
1003 
1004 	nfsd_cache_update(rqstp, rp, rqstp->rq_cachetype, nfs_reply);
1005 out_cached_reply:
1006 	return 1;
1007 
1008 out_decode_err:
1009 	trace_nfsd_garbage_args_err(rqstp);
1010 	*statp = rpc_garbage_args;
1011 	return 1;
1012 
1013 out_update_drop:
1014 	nfsd_cache_update(rqstp, rp, RC_NOCACHE, NULL);
1015 out_dropit:
1016 	return 0;
1017 
1018 out_encode_err:
1019 	trace_nfsd_cant_encode_err(rqstp);
1020 	nfsd_cache_update(rqstp, rp, RC_NOCACHE, NULL);
1021 	*statp = rpc_system_err;
1022 	return 1;
1023 }
1024 
1025 /**
1026  * nfssvc_decode_voidarg - Decode void arguments
1027  * @rqstp: Server RPC transaction context
1028  * @xdr: XDR stream positioned at arguments to decode
1029  *
1030  * Return values:
1031  *   %false: Arguments were not valid
1032  *   %true: Decoding was successful
1033  */
1034 bool nfssvc_decode_voidarg(struct svc_rqst *rqstp, struct xdr_stream *xdr)
1035 {
1036 	return true;
1037 }
1038 
1039 /**
1040  * nfssvc_encode_voidres - Encode void results
1041  * @rqstp: Server RPC transaction context
1042  * @xdr: XDR stream into which to encode results
1043  *
1044  * Return values:
1045  *   %false: Local error while encoding
1046  *   %true: Encoding was successful
1047  */
1048 bool nfssvc_encode_voidres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
1049 {
1050 	return true;
1051 }
1052