1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Syscall interface to knfsd.
4	*
5	* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
6	*/
7
8	#include <linux/slab.h>
9	#include <linux/namei.h>
10	#include <linux/ctype.h>
11	#include <linux/fs_context.h>
12
13	#include <linux/sunrpc/svcsock.h>
14	#include <linux/lockd/lockd.h>
15	#include <linux/sunrpc/addr.h>
16	#include <linux/sunrpc/gss_api.h>
17	#include <linux/sunrpc/rpc_pipe_fs.h>
18	#include <linux/module.h>
19	#include <linux/fsnotify.h>
20
21	#include "idmap.h"
22	#include "nfsd.h"
23	#include "cache.h"
24	#include "state.h"
25	#include "netns.h"
26	#include "pnfs.h"
27	#include "filecache.h"
28	#include "trace.h"
29	#include "netlink.h"
30
31	/*
32	* We have a single directory with several nodes in it.
33	*/
34	enum {
35	NFSD_Root = 1,
36	NFSD_List,
37	NFSD_Export_Stats,
38	NFSD_Export_features,
39	NFSD_Fh,
40	NFSD_FO_UnlockIP,
41	NFSD_FO_UnlockFS,
42	NFSD_Threads,
43	NFSD_Pool_Threads,
44	NFSD_Pool_Stats,
45	NFSD_Reply_Cache_Stats,
46	NFSD_Versions,
47	NFSD_Ports,
48	NFSD_MaxBlkSize,
49	NFSD_MaxConnections,
50	NFSD_Filecache,
51	/*
52	* The below MUST come last. Otherwise we leave a hole in nfsd_files[]
53	* with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
54	*/
55	#ifdef CONFIG_NFSD_V4
56	NFSD_Leasetime,
57	NFSD_Gracetime,
58	NFSD_RecoveryDir,
59	NFSD_V4EndGrace,
60	#endif
61	NFSD_MaxReserved
62	};
63
64	/*
65	* write() for these nodes.
66	*/
67	static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
68	static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
69	static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
70	static ssize_t write_threads(struct file *file, char *buf, size_t size);
71	static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
72	static ssize_t write_versions(struct file *file, char *buf, size_t size);
73	static ssize_t write_ports(struct file *file, char *buf, size_t size);
74	static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
75	static ssize_t write_maxconn(struct file *file, char *buf, size_t size);
76	#ifdef CONFIG_NFSD_V4
77	static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
78	static ssize_t write_gracetime(struct file *file, char *buf, size_t size);
79	static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
80	static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size);
81	#endif
82
83	static ssize_t (*const write_op[])(struct file *, char *, size_t) = {
84	[NFSD_Fh] = write_filehandle,
85	[NFSD_FO_UnlockIP] = write_unlock_ip,
86	[NFSD_FO_UnlockFS] = write_unlock_fs,
87	[NFSD_Threads] = write_threads,
88	[NFSD_Pool_Threads] = write_pool_threads,
89	[NFSD_Versions] = write_versions,
90	[NFSD_Ports] = write_ports,
91	[NFSD_MaxBlkSize] = write_maxblksize,
92	[NFSD_MaxConnections] = write_maxconn,
93	#ifdef CONFIG_NFSD_V4
94	[NFSD_Leasetime] = write_leasetime,
95	[NFSD_Gracetime] = write_gracetime,
96	[NFSD_RecoveryDir] = write_recoverydir,
97	[NFSD_V4EndGrace] = write_v4_end_grace,
98	#endif
99	};
100
101	static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
102	{
103	ino_t ino = file_inode(f: file)->i_ino;
104	char *data;
105	ssize_t rv;
106
107	if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
108	return -EINVAL;
109
110	data = simple_transaction_get(file, buf, size);
111	if (IS_ERR(ptr: data))
112	return PTR_ERR(ptr: data);
113
114	rv = write_op[ino](file, data, size);
115	if (rv < 0)
116	return rv;
117
118	simple_transaction_set(file, n: rv);
119	return size;
120	}
121
122	static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
123	{
124	if (! file->private_data) {
125	/* An attempt to read a transaction file without writing
126	* causes a 0-byte write so that the file can return
127	* state information
128	*/
129	ssize_t rv = nfsctl_transaction_write(file, buf, size: 0, pos);
130	if (rv < 0)
131	return rv;
132	}
133	return simple_transaction_read(file, buf, size, pos);
134	}
135
136	static const struct file_operations transaction_ops = {
137	.write = nfsctl_transaction_write,
138	.read = nfsctl_transaction_read,
139	.release = simple_transaction_release,
140	.llseek = default_llseek,
141	};
142
143	static int exports_net_open(struct net *net, struct file *file)
144	{
145	int err;
146	struct seq_file *seq;
147	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
148
149	err = seq_open(file, &nfs_exports_op);
150	if (err)
151	return err;
152
153	seq = file->private_data;
154	seq->private = nn->svc_export_cache;
155	return 0;
156	}
157
158	static int exports_nfsd_open(struct inode *inode, struct file *file)
159	{
160	return exports_net_open(net: inode->i_sb->s_fs_info, file);
161	}
162
163	static const struct file_operations exports_nfsd_operations = {
164	.open = exports_nfsd_open,
165	.read = seq_read,
166	.llseek = seq_lseek,
167	.release = seq_release,
168	};
169
170	static int export_features_show(struct seq_file *m, void *v)
171	{
172	seq_printf(m, fmt: "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
173	return 0;
174	}
175
176	DEFINE_SHOW_ATTRIBUTE(export_features);
177
178	static const struct file_operations pool_stats_operations = {
179	.open = nfsd_pool_stats_open,
180	.read = seq_read,
181	.llseek = seq_lseek,
182	.release = nfsd_pool_stats_release,
183	};
184
185	DEFINE_SHOW_ATTRIBUTE(nfsd_reply_cache_stats);
186
187	DEFINE_SHOW_ATTRIBUTE(nfsd_file_cache_stats);
188
189	/*----------------------------------------------------------------------------*/
190	/*
191	* payload - write methods
192	*/
193
194	static inline struct net *netns(struct file *file)
195	{
196	return file_inode(f: file)->i_sb->s_fs_info;
197	}
198
199	/*
200	* write_unlock_ip - Release all locks used by a client
201	*
202	* Experimental.
203	*
204	* Input:
205	* buf: '\n'-terminated C string containing a
206	* presentation format IP address
207	* size: length of C string in @buf
208	* Output:
209	* On success: returns zero if all specified locks were released;
210	* returns one if one or more locks were not released
211	* On error: return code is negative errno value
212	*/
213	static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
214	{
215	struct sockaddr_storage address;
216	struct sockaddr *sap = (struct sockaddr *)&address;
217	size_t salen = sizeof(address);
218	char *fo_path;
219	struct net *net = netns(file);
220
221	/* sanity check */
222	if (size == 0)
223	return -EINVAL;
224
225	if (buf[size-1] != '\n')
226	return -EINVAL;
227
228	fo_path = buf;
229	if (qword_get(bpp: &buf, dest: fo_path, bufsize: size) < 0)
230	return -EINVAL;
231
232	if (rpc_pton(net, fo_path, size, sap, salen) == 0)
233	return -EINVAL;
234
235	trace_nfsd_ctl_unlock_ip(net, address: buf);
236	return nlmsvc_unlock_all_by_ip(server_addr: sap);
237	}
238
239	/*
240	* write_unlock_fs - Release all locks on a local file system
241	*
242	* Experimental.
243	*
244	* Input:
245	* buf: '\n'-terminated C string containing the
246	* absolute pathname of a local file system
247	* size: length of C string in @buf
248	* Output:
249	* On success: returns zero if all specified locks were released;
250	* returns one if one or more locks were not released
251	* On error: return code is negative errno value
252	*/
253	static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
254	{
255	struct path path;
256	char *fo_path;
257	int error;
258
259	/* sanity check */
260	if (size == 0)
261	return -EINVAL;
262
263	if (buf[size-1] != '\n')
264	return -EINVAL;
265
266	fo_path = buf;
267	if (qword_get(bpp: &buf, dest: fo_path, bufsize: size) < 0)
268	return -EINVAL;
269	trace_nfsd_ctl_unlock_fs(net: netns(file), path: fo_path);
270	error = kern_path(fo_path, 0, &path);
271	if (error)
272	return error;
273
274	/*
275	* XXX: Needs better sanity checking. Otherwise we could end up
276	* releasing locks on the wrong file system.
277	*
278	* For example:
279	* 1. Does the path refer to a directory?
280	* 2. Is that directory a mount point, or
281	* 3. Is that directory the root of an exported file system?
282	*/
283	error = nlmsvc_unlock_all_by_sb(sb: path.dentry->d_sb);
284
285	path_put(&path);
286	return error;
287	}
288
289	/*
290	* write_filehandle - Get a variable-length NFS file handle by path
291	*
292	* On input, the buffer contains a '\n'-terminated C string comprised of
293	* three alphanumeric words separated by whitespace. The string may
294	* contain escape sequences.
295	*
296	* Input:
297	* buf:
298	* domain: client domain name
299	* path: export pathname
300	* maxsize: numeric maximum size of
301	* @buf
302	* size: length of C string in @buf
303	* Output:
304	* On success: passed-in buffer filled with '\n'-terminated C
305	* string containing a ASCII hex text version
306	* of the NFS file handle;
307	* return code is the size in bytes of the string
308	* On error: return code is negative errno value
309	*/
310	static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
311	{
312	char *dname, *path;
313	int maxsize;
314	char *mesg = buf;
315	int len;
316	struct auth_domain *dom;
317	struct knfsd_fh fh;
318
319	if (size == 0)
320	return -EINVAL;
321
322	if (buf[size-1] != '\n')
323	return -EINVAL;
324	buf[size-1] = 0;
325
326	dname = mesg;
327	len = qword_get(bpp: &mesg, dest: dname, bufsize: size);
328	if (len <= 0)
329	return -EINVAL;
330
331	path = dname+len+1;
332	len = qword_get(bpp: &mesg, dest: path, bufsize: size);
333	if (len <= 0)
334	return -EINVAL;
335
336	len = get_int(bpp: &mesg, anint: &maxsize);
337	if (len)
338	return len;
339
340	if (maxsize < NFS_FHSIZE)
341	return -EINVAL;
342	maxsize = min(maxsize, NFS3_FHSIZE);
343
344	if (qword_get(bpp: &mesg, dest: mesg, bufsize: size) > 0)
345	return -EINVAL;
346
347	trace_nfsd_ctl_filehandle(net: netns(file), domain: dname, path, maxsize);
348
349	/* we have all the words, they are in buf.. */
350	dom = unix_domain_find(name: dname);
351	if (!dom)
352	return -ENOMEM;
353
354	len = exp_rootfh(netns(file), dom, path, &fh, maxsize);
355	auth_domain_put(item: dom);
356	if (len)
357	return len;
358
359	mesg = buf;
360	len = SIMPLE_TRANSACTION_LIMIT;
361	qword_addhex(bpp: &mesg, lp: &len, buf: fh.fh_raw, blen: fh.fh_size);
362	mesg[-1] = '\n';
363	return mesg - buf;
364	}
365
366	/*
367	* write_threads - Start NFSD, or report the current number of running threads
368	*
369	* Input:
370	* buf: ignored
371	* size: zero
372	* Output:
373	* On success: passed-in buffer filled with '\n'-terminated C
374	* string numeric value representing the number of
375	* running NFSD threads;
376	* return code is the size in bytes of the string
377	* On error: return code is zero
378	*
379	* OR
380	*
381	* Input:
382	* buf: C string containing an unsigned
383	* integer value representing the
384	* number of NFSD threads to start
385	* size: non-zero length of C string in @buf
386	* Output:
387	* On success: NFS service is started;
388	* passed-in buffer filled with '\n'-terminated C
389	* string numeric value representing the number of
390	* running NFSD threads;
391	* return code is the size in bytes of the string
392	* On error: return code is zero or a negative errno value
393	*/
394	static ssize_t write_threads(struct file *file, char *buf, size_t size)
395	{
396	char *mesg = buf;
397	int rv;
398	struct net *net = netns(file);
399
400	if (size > 0) {
401	int newthreads;
402	rv = get_int(bpp: &mesg, anint: &newthreads);
403	if (rv)
404	return rv;
405	if (newthreads < 0)
406	return -EINVAL;
407	trace_nfsd_ctl_threads(net, newthreads);
408	rv = nfsd_svc(nrservs: newthreads, net, cred: file->f_cred);
409	if (rv < 0)
410	return rv;
411	} else
412	rv = nfsd_nrthreads(net);
413
414	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, fmt: "%d\n", rv);
415	}
416
417	/*
418	* write_pool_threads - Set or report the current number of threads per pool
419	*
420	* Input:
421	* buf: ignored
422	* size: zero
423	*
424	* OR
425	*
426	* Input:
427	* buf: C string containing whitespace-
428	* separated unsigned integer values
429	* representing the number of NFSD
430	* threads to start in each pool
431	* size: non-zero length of C string in @buf
432	* Output:
433	* On success: passed-in buffer filled with '\n'-terminated C
434	* string containing integer values representing the
435	* number of NFSD threads in each pool;
436	* return code is the size in bytes of the string
437	* On error: return code is zero or a negative errno value
438	*/
439	static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
440	{
441	/* if size > 0, look for an array of number of threads per node
442	* and apply them then write out number of threads per node as reply
443	*/
444	char *mesg = buf;
445	int i;
446	int rv;
447	int len;
448	int npools;
449	int *nthreads;
450	struct net *net = netns(file);
451
452	mutex_lock(&nfsd_mutex);
453	npools = nfsd_nrpools(net);
454	if (npools == 0) {
455	/*
456	* NFS is shut down. The admin can start it by
457	* writing to the threads file but NOT the pool_threads
458	* file, sorry. Report zero threads.
459	*/
460	mutex_unlock(lock: &nfsd_mutex);
461	strcpy(p: buf, q: "0\n");
462	return strlen(buf);
463	}
464
465	nthreads = kcalloc(n: npools, size: sizeof(int), GFP_KERNEL);
466	rv = -ENOMEM;
467	if (nthreads == NULL)
468	goto out_free;
469
470	if (size > 0) {
471	for (i = 0; i < npools; i++) {
472	rv = get_int(bpp: &mesg, anint: &nthreads[i]);
473	if (rv == -ENOENT)
474	break; /* fewer numbers than pools */
475	if (rv)
476	goto out_free; /* syntax error */
477	rv = -EINVAL;
478	if (nthreads[i] < 0)
479	goto out_free;
480	trace_nfsd_ctl_pool_threads(net, pool: i, nrthreads: nthreads[i]);
481	}
482	rv = nfsd_set_nrthreads(n: i, nthreads, net);
483	if (rv)
484	goto out_free;
485	}
486
487	rv = nfsd_get_nrthreads(n: npools, nthreads, net);
488	if (rv)
489	goto out_free;
490
491	mesg = buf;
492	size = SIMPLE_TRANSACTION_LIMIT;
493	for (i = 0; i < npools && size > 0; i++) {
494	snprintf(buf: mesg, size, fmt: "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
495	len = strlen(mesg);
496	size -= len;
497	mesg += len;
498	}
499	rv = mesg - buf;
500	out_free:
501	kfree(objp: nthreads);
502	mutex_unlock(lock: &nfsd_mutex);
503	return rv;
504	}
505
506	static ssize_t
507	nfsd_print_version_support(struct nfsd_net *nn, char *buf, int remaining,
508	const char *sep, unsigned vers, int minor)
509	{
510	const char *format = minor < 0 ? "%s%c%u" : "%s%c%u.%u";
511	bool supported = !!nfsd_vers(nn, vers, change: NFSD_TEST);
512
513	if (vers == 4 && minor >= 0 &&
514	!nfsd_minorversion(nn, minorversion: minor, change: NFSD_TEST))
515	supported = false;
516	if (minor == 0 && supported)
517	/*
518	* special case for backward compatability.
519	* +4.0 is never reported, it is implied by
520	* +4, unless -4.0 is present.
521	*/
522	return 0;
523	return snprintf(buf, size: remaining, fmt: format, sep,
524	supported ? '+' : '-', vers, minor);
525	}
526
527	static ssize_t __write_versions(struct file *file, char *buf, size_t size)
528	{
529	char *mesg = buf;
530	char *vers, *minorp, sign;
531	int len, num, remaining;
532	ssize_t tlen = 0;
533	char *sep;
534	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
535
536	if (size > 0) {
537	if (nn->nfsd_serv)
538	/* Cannot change versions without updating
539	* nn->nfsd_serv->sv_xdrsize, and reallocing
540	* rq_argp and rq_resp
541	*/
542	return -EBUSY;
543	if (buf[size-1] != '\n')
544	return -EINVAL;
545	buf[size-1] = 0;
546	trace_nfsd_ctl_version(net: netns(file), mesg: buf);
547
548	vers = mesg;
549	len = qword_get(bpp: &mesg, dest: vers, bufsize: size);
550	if (len <= 0) return -EINVAL;
551	do {
552	enum vers_op cmd;
553	unsigned minor;
554	sign = *vers;
555	if (sign == '+' || sign == '-')
556	num = simple_strtol((vers+1), &minorp, 0);
557	else
558	num = simple_strtol(vers, &minorp, 0);
559	if (*minorp == '.') {
560	if (num != 4)
561	return -EINVAL;
562	if (kstrtouint(s: minorp+1, base: 0, res: &minor) < 0)
563	return -EINVAL;
564	}
565
566	cmd = sign == '-' ? NFSD_CLEAR : NFSD_SET;
567	switch(num) {
568	#ifdef CONFIG_NFSD_V2
569	case 2:
570	#endif
571	case 3:
572	nfsd_vers(nn, vers: num, change: cmd);
573	break;
574	case 4:
575	if (*minorp == '.') {
576	if (nfsd_minorversion(nn, minorversion: minor, change: cmd) < 0)
577	return -EINVAL;
578	} else if ((cmd == NFSD_SET) != nfsd_vers(nn, vers: num, change: NFSD_TEST)) {
579	/*
580	* Either we have +4 and no minors are enabled,
581	* or we have -4 and at least one minor is enabled.
582	* In either case, propagate 'cmd' to all minors.
583	*/
584	minor = 0;
585	while (nfsd_minorversion(nn, minorversion: minor, change: cmd) >= 0)
586	minor++;
587	}
588	break;
589	default:
590	/* Ignore requests to disable non-existent versions */
591	if (cmd == NFSD_SET)
592	return -EINVAL;
593	}
594	vers += len + 1;
595	} while ((len = qword_get(bpp: &mesg, dest: vers, bufsize: size)) > 0);
596	/* If all get turned off, turn them back on, as
597	* having no versions is BAD
598	*/
599	nfsd_reset_versions(nn);
600	}
601
602	/* Now write current state into reply buffer */
603	sep = "";
604	remaining = SIMPLE_TRANSACTION_LIMIT;
605	for (num=2 ; num <= 4 ; num++) {
606	int minor;
607	if (!nfsd_vers(nn, vers: num, change: NFSD_AVAIL))
608	continue;
609
610	minor = -1;
611	do {
612	len = nfsd_print_version_support(nn, buf, remaining,
613	sep, vers: num, minor);
614	if (len >= remaining)
615	goto out;
616	remaining -= len;
617	buf += len;
618	tlen += len;
619	minor++;
620	if (len)
621	sep = " ";
622	} while (num == 4 && minor <= NFSD_SUPPORTED_MINOR_VERSION);
623	}
624	out:
625	len = snprintf(buf, size: remaining, fmt: "\n");
626	if (len >= remaining)
627	return -EINVAL;
628	return tlen + len;
629	}
630
631	/*
632	* write_versions - Set or report the available NFS protocol versions
633	*
634	* Input:
635	* buf: ignored
636	* size: zero
637	* Output:
638	* On success: passed-in buffer filled with '\n'-terminated C
639	* string containing positive or negative integer
640	* values representing the current status of each
641	* protocol version;
642	* return code is the size in bytes of the string
643	* On error: return code is zero or a negative errno value
644	*
645	* OR
646	*
647	* Input:
648	* buf: C string containing whitespace-
649	* separated positive or negative
650	* integer values representing NFS
651	* protocol versions to enable ("+n")
652	* or disable ("-n")
653	* size: non-zero length of C string in @buf
654	* Output:
655	* On success: status of zero or more protocol versions has
656	* been updated; passed-in buffer filled with
657	* '\n'-terminated C string containing positive
658	* or negative integer values representing the
659	* current status of each protocol version;
660	* return code is the size in bytes of the string
661	* On error: return code is zero or a negative errno value
662	*/
663	static ssize_t write_versions(struct file *file, char *buf, size_t size)
664	{
665	ssize_t rv;
666
667	mutex_lock(&nfsd_mutex);
668	rv = __write_versions(file, buf, size);
669	mutex_unlock(lock: &nfsd_mutex);
670	return rv;
671	}
672
673	/*
674	* Zero-length write. Return a list of NFSD's current listener
675	* transports.
676	*/
677	static ssize_t __write_ports_names(char *buf, struct net *net)
678	{
679	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
680
681	if (nn->nfsd_serv == NULL)
682	return 0;
683	return svc_xprt_names(serv: nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
684	}
685
686	/*
687	* A single 'fd' number was written, in which case it must be for
688	* a socket of a supported family/protocol, and we use it as an
689	* nfsd listener.
690	*/
691	static ssize_t __write_ports_addfd(char *buf, struct net *net, const struct cred *cred)
692	{
693	char *mesg = buf;
694	int fd, err;
695	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
696
697	err = get_int(bpp: &mesg, anint: &fd);
698	if (err != 0 || fd < 0)
699	return -EINVAL;
700	trace_nfsd_ctl_ports_addfd(net, fd);
701
702	err = nfsd_create_serv(net);
703	if (err != 0)
704	return err;
705
706	err = svc_addsock(serv: nn->nfsd_serv, net, fd, name_return: buf, SIMPLE_TRANSACTION_LIMIT, cred);
707
708	if (err >= 0 &&
709	!nn->nfsd_serv->sv_nrthreads && !xchg(&nn->keep_active, 1))
710	svc_get(serv: nn->nfsd_serv);
711
712	nfsd_put(net);
713	return err;
714	}
715
716	/*
717	* A transport listener is added by writing its transport name and
718	* a port number.
719	*/
720	static ssize_t __write_ports_addxprt(char *buf, struct net *net, const struct cred *cred)
721	{
722	char transport[16];
723	struct svc_xprt *xprt;
724	int port, err;
725	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
726
727	if (sscanf(buf, "%15s %5u", transport, &port) != 2)
728	return -EINVAL;
729
730	if (port < 1 || port > USHRT_MAX)
731	return -EINVAL;
732	trace_nfsd_ctl_ports_addxprt(net, transport, port);
733
734	err = nfsd_create_serv(net);
735	if (err != 0)
736	return err;
737
738	err = svc_xprt_create(serv: nn->nfsd_serv, xprt_name: transport, net,
739	PF_INET, port, SVC_SOCK_ANONYMOUS, cred);
740	if (err < 0)
741	goto out_err;
742
743	err = svc_xprt_create(serv: nn->nfsd_serv, xprt_name: transport, net,
744	PF_INET6, port, SVC_SOCK_ANONYMOUS, cred);
745	if (err < 0 && err != -EAFNOSUPPORT)
746	goto out_close;
747
748	if (!nn->nfsd_serv->sv_nrthreads && !xchg(&nn->keep_active, 1))
749	svc_get(serv: nn->nfsd_serv);
750
751	nfsd_put(net);
752	return 0;
753	out_close:
754	xprt = svc_find_xprt(serv: nn->nfsd_serv, xcl_name: transport, net, PF_INET, port);
755	if (xprt != NULL) {
756	svc_xprt_close(xprt);
757	svc_xprt_put(xprt);
758	}
759	out_err:
760	nfsd_put(net);
761	return err;
762	}
763
764	static ssize_t __write_ports(struct file *file, char *buf, size_t size,
765	struct net *net)
766	{
767	if (size == 0)
768	return __write_ports_names(buf, net);
769
770	if (isdigit(c: buf[0]))
771	return __write_ports_addfd(buf, net, cred: file->f_cred);
772
773	if (isalpha(buf[0]))
774	return __write_ports_addxprt(buf, net, cred: file->f_cred);
775
776	return -EINVAL;
777	}
778
779	/*
780	* write_ports - Pass a socket file descriptor or transport name to listen on
781	*
782	* Input:
783	* buf: ignored
784	* size: zero
785	* Output:
786	* On success: passed-in buffer filled with a '\n'-terminated C
787	* string containing a whitespace-separated list of
788	* named NFSD listeners;
789	* return code is the size in bytes of the string
790	* On error: return code is zero or a negative errno value
791	*
792	* OR
793	*
794	* Input:
795	* buf: C string containing an unsigned
796	* integer value representing a bound
797	* but unconnected socket that is to be
798	* used as an NFSD listener; listen(3)
799	* must be called for a SOCK_STREAM
800	* socket, otherwise it is ignored
801	* size: non-zero length of C string in @buf
802	* Output:
803	* On success: NFS service is started;
804	* passed-in buffer filled with a '\n'-terminated C
805	* string containing a unique alphanumeric name of
806	* the listener;
807	* return code is the size in bytes of the string
808	* On error: return code is a negative errno value
809	*
810	* OR
811	*
812	* Input:
813	* buf: C string containing a transport
814	* name and an unsigned integer value
815	* representing the port to listen on,
816	* separated by whitespace
817	* size: non-zero length of C string in @buf
818	* Output:
819	* On success: returns zero; NFS service is started
820	* On error: return code is a negative errno value
821	*/
822	static ssize_t write_ports(struct file *file, char *buf, size_t size)
823	{
824	ssize_t rv;
825
826	mutex_lock(&nfsd_mutex);
827	rv = __write_ports(file, buf, size, net: netns(file));
828	mutex_unlock(lock: &nfsd_mutex);
829	return rv;
830	}
831
832
833	int nfsd_max_blksize;
834
835	/*
836	* write_maxblksize - Set or report the current NFS blksize
837	*
838	* Input:
839	* buf: ignored
840	* size: zero
841	*
842	* OR
843	*
844	* Input:
845	* buf: C string containing an unsigned
846	* integer value representing the new
847	* NFS blksize
848	* size: non-zero length of C string in @buf
849	* Output:
850	* On success: passed-in buffer filled with '\n'-terminated C string
851	* containing numeric value of the current NFS blksize
852	* setting;
853	* return code is the size in bytes of the string
854	* On error: return code is zero or a negative errno value
855	*/
856	static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
857	{
858	char *mesg = buf;
859	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
860
861	if (size > 0) {
862	int bsize;
863	int rv = get_int(bpp: &mesg, anint: &bsize);
864	if (rv)
865	return rv;
866	trace_nfsd_ctl_maxblksize(net: netns(file), bsize);
867
868	/* force bsize into allowed range and
869	* required alignment.
870	*/
871	bsize = max_t(int, bsize, 1024);
872	bsize = min_t(int, bsize, NFSSVC_MAXBLKSIZE);
873	bsize &= ~(1024-1);
874	mutex_lock(&nfsd_mutex);
875	if (nn->nfsd_serv) {
876	mutex_unlock(lock: &nfsd_mutex);
877	return -EBUSY;
878	}
879	nfsd_max_blksize = bsize;
880	mutex_unlock(lock: &nfsd_mutex);
881	}
882
883	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, fmt: "%d\n",
884	nfsd_max_blksize);
885	}
886
887	/*
888	* write_maxconn - Set or report the current max number of connections
889	*
890	* Input:
891	* buf: ignored
892	* size: zero
893	* OR
894	*
895	* Input:
896	* buf: C string containing an unsigned
897	* integer value representing the new
898	* number of max connections
899	* size: non-zero length of C string in @buf
900	* Output:
901	* On success: passed-in buffer filled with '\n'-terminated C string
902	* containing numeric value of max_connections setting
903	* for this net namespace;
904	* return code is the size in bytes of the string
905	* On error: return code is zero or a negative errno value
906	*/
907	static ssize_t write_maxconn(struct file *file, char *buf, size_t size)
908	{
909	char *mesg = buf;
910	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
911	unsigned int maxconn = nn->max_connections;
912
913	if (size > 0) {
914	int rv = get_uint(bpp: &mesg, anint: &maxconn);
915
916	if (rv)
917	return rv;
918	trace_nfsd_ctl_maxconn(net: netns(file), maxconn);
919	nn->max_connections = maxconn;
920	}
921
922	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, fmt: "%u\n", maxconn);
923	}
924
925	#ifdef CONFIG_NFSD_V4
926	static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size,
927	time64_t *time, struct nfsd_net *nn)
928	{
929	struct dentry *dentry = file_dentry(file);
930	char *mesg = buf;
931	int rv, i;
932
933	if (size > 0) {
934	if (nn->nfsd_serv)
935	return -EBUSY;
936	rv = get_int(bpp: &mesg, anint: &i);
937	if (rv)
938	return rv;
939	trace_nfsd_ctl_time(net: netns(file), name: dentry->d_name.name,
940	namelen: dentry->d_name.len, time: i);
941
942	/*
943	* Some sanity checking. We don't have a reason for
944	* these particular numbers, but problems with the
945	* extremes are:
946	* - Too short: the briefest network outage may
947	* cause clients to lose all their locks. Also,
948	* the frequent polling may be wasteful.
949	* - Too long: do you really want reboot recovery
950	* to take more than an hour? Or to make other
951	* clients wait an hour before being able to
952	* revoke a dead client's locks?
953	*/
954	if (i < 10 || i > 3600)
955	return -EINVAL;
956	*time = i;
957	}
958
959	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, fmt: "%lld\n", *time);
960	}
961
962	static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size,
963	time64_t *time, struct nfsd_net *nn)
964	{
965	ssize_t rv;
966
967	mutex_lock(&nfsd_mutex);
968	rv = __nfsd4_write_time(file, buf, size, time, nn);
969	mutex_unlock(lock: &nfsd_mutex);
970	return rv;
971	}
972
973	/*
974	* write_leasetime - Set or report the current NFSv4 lease time
975	*
976	* Input:
977	* buf: ignored
978	* size: zero
979	*
980	* OR
981	*
982	* Input:
983	* buf: C string containing an unsigned
984	* integer value representing the new
985	* NFSv4 lease expiry time
986	* size: non-zero length of C string in @buf
987	* Output:
988	* On success: passed-in buffer filled with '\n'-terminated C
989	* string containing unsigned integer value of the
990	* current lease expiry time;
991	* return code is the size in bytes of the string
992	* On error: return code is zero or a negative errno value
993	*/
994	static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
995	{
996	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
997	return nfsd4_write_time(file, buf, size, time: &nn->nfsd4_lease, nn);
998	}
999
1000	/*
1001	* write_gracetime - Set or report current NFSv4 grace period time
1002	*
1003	* As above, but sets the time of the NFSv4 grace period.
1004	*
1005	* Note this should never be set to less than the *previous*
1006	* lease-period time, but we don't try to enforce this. (In the common
1007	* case (a new boot), we don't know what the previous lease time was
1008	* anyway.)
1009	*/
1010	static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
1011	{
1012	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
1013	return nfsd4_write_time(file, buf, size, time: &nn->nfsd4_grace, nn);
1014	}
1015
1016	static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size,
1017	struct nfsd_net *nn)
1018	{
1019	char *mesg = buf;
1020	char *recdir;
1021	int len, status;
1022
1023	if (size > 0) {
1024	if (nn->nfsd_serv)
1025	return -EBUSY;
1026	if (size > PATH_MAX || buf[size-1] != '\n')
1027	return -EINVAL;
1028	buf[size-1] = 0;
1029
1030	recdir = mesg;
1031	len = qword_get(bpp: &mesg, dest: recdir, bufsize: size);
1032	if (len <= 0)
1033	return -EINVAL;
1034	trace_nfsd_ctl_recoverydir(net: netns(file), recdir);
1035
1036	status = nfs4_reset_recoverydir(recdir);
1037	if (status)
1038	return status;
1039	}
1040
1041	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, fmt: "%s\n",
1042	nfs4_recoverydir());
1043	}
1044
1045	/*
1046	* write_recoverydir - Set or report the pathname of the recovery directory
1047	*
1048	* Input:
1049	* buf: ignored
1050	* size: zero
1051	*
1052	* OR
1053	*
1054	* Input:
1055	* buf: C string containing the pathname
1056	* of the directory on a local file
1057	* system containing permanent NFSv4
1058	* recovery data
1059	* size: non-zero length of C string in @buf
1060	* Output:
1061	* On success: passed-in buffer filled with '\n'-terminated C string
1062	* containing the current recovery pathname setting;
1063	* return code is the size in bytes of the string
1064	* On error: return code is zero or a negative errno value
1065	*/
1066	static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1067	{
1068	ssize_t rv;
1069	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
1070
1071	mutex_lock(&nfsd_mutex);
1072	rv = __write_recoverydir(file, buf, size, nn);
1073	mutex_unlock(lock: &nfsd_mutex);
1074	return rv;
1075	}
1076
1077	/*
1078	* write_v4_end_grace - release grace period for nfsd's v4.x lock manager
1079	*
1080	* Input:
1081	* buf: ignored
1082	* size: zero
1083	* OR
1084	*
1085	* Input:
1086	* buf: any value
1087	* size: non-zero length of C string in @buf
1088	* Output:
1089	* passed-in buffer filled with "Y" or "N" with a newline
1090	* and NULL-terminated C string. This indicates whether
1091	* the grace period has ended in the current net
1092	* namespace. Return code is the size in bytes of the
1093	* string. Writing a string that starts with 'Y', 'y', or
1094	* '1' to the file will end the grace period for nfsd's v4
1095	* lock manager.
1096	*/
1097	static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size)
1098	{
1099	struct nfsd_net *nn = net_generic(net: netns(file), id: nfsd_net_id);
1100
1101	if (size > 0) {
1102	switch(buf[0]) {
1103	case 'Y':
1104	case 'y':
1105	case '1':
1106	if (!nn->nfsd_serv)
1107	return -EBUSY;
1108	trace_nfsd_end_grace(net: netns(file));
1109	nfsd4_end_grace(nn);
1110	break;
1111	default:
1112	return -EINVAL;
1113	}
1114	}
1115
1116	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, fmt: "%c\n",
1117	nn->grace_ended ? 'Y' : 'N');
1118	}
1119
1120	#endif
1121
1122	/*----------------------------------------------------------------------------*/
1123	/*
1124	* populating the filesystem.
1125	*/
1126
1127	/* Basically copying rpc_get_inode. */
1128	static struct inode *nfsd_get_inode(struct super_block *sb, umode_t mode)
1129	{
1130	struct inode *inode = new_inode(sb);
1131	if (!inode)
1132	return NULL;
1133	/* Following advice from simple_fill_super documentation: */
1134	inode->i_ino = iunique(sb, NFSD_MaxReserved);
1135	inode->i_mode = mode;
1136	simple_inode_init_ts(inode);
1137	switch (mode & S_IFMT) {
1138	case S_IFDIR:
1139	inode->i_fop = &simple_dir_operations;
1140	inode->i_op = &simple_dir_inode_operations;
1141	inc_nlink(inode);
1142	break;
1143	case S_IFLNK:
1144	inode->i_op = &simple_symlink_inode_operations;
1145	break;
1146	default:
1147	break;
1148	}
1149	return inode;
1150	}
1151
1152	static int __nfsd_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode, struct nfsdfs_client *ncl)
1153	{
1154	struct inode *inode;
1155
1156	inode = nfsd_get_inode(sb: dir->i_sb, mode);
1157	if (!inode)
1158	return -ENOMEM;
1159	if (ncl) {
1160	inode->i_private = ncl;
1161	kref_get(kref: &ncl->cl_ref);
1162	}
1163	d_add(dentry, inode);
1164	inc_nlink(inode: dir);
1165	fsnotify_mkdir(dir, dentry);
1166	return 0;
1167	}
1168
1169	static struct dentry *nfsd_mkdir(struct dentry *parent, struct nfsdfs_client *ncl, char *name)
1170	{
1171	struct inode *dir = parent->d_inode;
1172	struct dentry *dentry;
1173	int ret = -ENOMEM;
1174
1175	inode_lock(inode: dir);
1176	dentry = d_alloc_name(parent, name);
1177	if (!dentry)
1178	goto out_err;
1179	ret = __nfsd_mkdir(dir: d_inode(dentry: parent), dentry, S_IFDIR | 0600, ncl);
1180	if (ret)
1181	goto out_err;
1182	out:
1183	inode_unlock(inode: dir);
1184	return dentry;
1185	out_err:
1186	dput(dentry);
1187	dentry = ERR_PTR(error: ret);
1188	goto out;
1189	}
1190
1191	#if IS_ENABLED(CONFIG_SUNRPC_GSS)
1192	static int __nfsd_symlink(struct inode *dir, struct dentry *dentry,
1193	umode_t mode, const char *content)
1194	{
1195	struct inode *inode;
1196
1197	inode = nfsd_get_inode(sb: dir->i_sb, mode);
1198	if (!inode)
1199	return -ENOMEM;
1200
1201	inode->i_link = (char *)content;
1202	inode->i_size = strlen(content);
1203
1204	d_add(dentry, inode);
1205	inc_nlink(inode: dir);
1206	fsnotify_create(dir, dentry);
1207	return 0;
1208	}
1209
1210	/*
1211	* @content is assumed to be a NUL-terminated string that lives
1212	* longer than the symlink itself.
1213	*/
1214	static void _nfsd_symlink(struct dentry *parent, const char *name,
1215	const char *content)
1216	{
1217	struct inode *dir = parent->d_inode;
1218	struct dentry *dentry;
1219	int ret;
1220
1221	inode_lock(inode: dir);
1222	dentry = d_alloc_name(parent, name);
1223	if (!dentry)
1224	goto out;
1225	ret = __nfsd_symlink(dir: d_inode(dentry: parent), dentry, S_IFLNK | 0777, content);
1226	if (ret)
1227	dput(dentry);
1228	out:
1229	inode_unlock(inode: dir);
1230	}
1231	#else
1232	static inline void _nfsd_symlink(struct dentry *parent, const char *name,
1233	const char *content)
1234	{
1235	}
1236
1237	#endif
1238
1239	static void clear_ncl(struct inode *inode)
1240	{
1241	struct nfsdfs_client *ncl = inode->i_private;
1242
1243	inode->i_private = NULL;
1244	kref_put(kref: &ncl->cl_ref, release: ncl->cl_release);
1245	}
1246
1247	static struct nfsdfs_client *__get_nfsdfs_client(struct inode *inode)
1248	{
1249	struct nfsdfs_client *nc = inode->i_private;
1250
1251	if (nc)
1252	kref_get(kref: &nc->cl_ref);
1253	return nc;
1254	}
1255
1256	struct nfsdfs_client *get_nfsdfs_client(struct inode *inode)
1257	{
1258	struct nfsdfs_client *nc;
1259
1260	inode_lock_shared(inode);
1261	nc = __get_nfsdfs_client(inode);
1262	inode_unlock_shared(inode);
1263	return nc;
1264	}
1265	/* from __rpc_unlink */
1266	static void nfsdfs_remove_file(struct inode *dir, struct dentry *dentry)
1267	{
1268	int ret;
1269
1270	clear_ncl(inode: d_inode(dentry));
1271	dget(dentry);
1272	ret = simple_unlink(dir, dentry);
1273	d_drop(dentry);
1274	fsnotify_unlink(dir, dentry);
1275	dput(dentry);
1276	WARN_ON_ONCE(ret);
1277	}
1278
1279	static void nfsdfs_remove_files(struct dentry *root)
1280	{
1281	struct dentry *dentry, *tmp;
1282
1283	list_for_each_entry_safe(dentry, tmp, &root->d_subdirs, d_child) {
1284	if (!simple_positive(dentry)) {
1285	WARN_ON_ONCE(1); /* I think this can't happen? */
1286	continue;
1287	}
1288	nfsdfs_remove_file(dir: d_inode(dentry: root), dentry);
1289	}
1290	}
1291
1292	/* XXX: cut'n'paste from simple_fill_super; figure out if we could share
1293	* code instead. */
1294	static int nfsdfs_create_files(struct dentry *root,
1295	const struct tree_descr *files,
1296	struct dentry **fdentries)
1297	{
1298	struct inode *dir = d_inode(dentry: root);
1299	struct inode *inode;
1300	struct dentry *dentry;
1301	int i;
1302
1303	inode_lock(inode: dir);
1304	for (i = 0; files->name && files->name[0]; i++, files++) {
1305	dentry = d_alloc_name(root, files->name);
1306	if (!dentry)
1307	goto out;
1308	inode = nfsd_get_inode(sb: d_inode(dentry: root)->i_sb,
1309	S_IFREG | files->mode);
1310	if (!inode) {
1311	dput(dentry);
1312	goto out;
1313	}
1314	inode->i_fop = files->ops;
1315	inode->i_private = __get_nfsdfs_client(inode: dir);
1316	d_add(dentry, inode);
1317	fsnotify_create(dir, dentry);
1318	if (fdentries)
1319	fdentries[i] = dentry;
1320	}
1321	inode_unlock(inode: dir);
1322	return 0;
1323	out:
1324	nfsdfs_remove_files(root);
1325	inode_unlock(inode: dir);
1326	return -ENOMEM;
1327	}
1328
1329	/* on success, returns positive number unique to that client. */
1330	struct dentry *nfsd_client_mkdir(struct nfsd_net *nn,
1331	struct nfsdfs_client *ncl, u32 id,
1332	const struct tree_descr *files,
1333	struct dentry **fdentries)
1334	{
1335	struct dentry *dentry;
1336	char name[11];
1337	int ret;
1338
1339	sprintf(buf: name, fmt: "%u", id);
1340
1341	dentry = nfsd_mkdir(parent: nn->nfsd_client_dir, ncl, name);
1342	if (IS_ERR(ptr: dentry)) /* XXX: tossing errors? */
1343	return NULL;
1344	ret = nfsdfs_create_files(root: dentry, files, fdentries);
1345	if (ret) {
1346	nfsd_client_rmdir(dentry);
1347	return NULL;
1348	}
1349	return dentry;
1350	}
1351
1352	/* Taken from __rpc_rmdir: */
1353	void nfsd_client_rmdir(struct dentry *dentry)
1354	{
1355	struct inode *dir = d_inode(dentry: dentry->d_parent);
1356	struct inode *inode = d_inode(dentry);
1357	int ret;
1358
1359	inode_lock(inode: dir);
1360	nfsdfs_remove_files(root: dentry);
1361	clear_ncl(inode);
1362	dget(dentry);
1363	ret = simple_rmdir(dir, dentry);
1364	WARN_ON_ONCE(ret);
1365	d_drop(dentry);
1366	fsnotify_rmdir(dir, dentry);
1367	dput(dentry);
1368	inode_unlock(inode: dir);
1369	}
1370
1371	static int nfsd_fill_super(struct super_block *sb, struct fs_context *fc)
1372	{
1373	struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
1374	id: nfsd_net_id);
1375	struct dentry *dentry;
1376	int ret;
1377
1378	static const struct tree_descr nfsd_files[] = {
1379	[NFSD_List] = {"exports", &exports_nfsd_operations, S_IRUGO},
1380	/* Per-export io stats use same ops as exports file */
1381	[NFSD_Export_Stats] = {.name: "export_stats", .ops: &exports_nfsd_operations, S_IRUGO},
1382	[NFSD_Export_features] = {.name: "export_features",
1383	.ops: &export_features_fops, S_IRUGO},
1384	[NFSD_FO_UnlockIP] = {.name: "unlock_ip",
1385	.ops: &transaction_ops, S_IWUSR|S_IRUSR},
1386	[NFSD_FO_UnlockFS] = {.name: "unlock_filesystem",
1387	.ops: &transaction_ops, S_IWUSR|S_IRUSR},
1388	[NFSD_Fh] = {.name: "filehandle", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1389	[NFSD_Threads] = {.name: "threads", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1390	[NFSD_Pool_Threads] = {.name: "pool_threads", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1391	[NFSD_Pool_Stats] = {.name: "pool_stats", .ops: &pool_stats_operations, S_IRUGO},
1392	[NFSD_Reply_Cache_Stats] = {.name: "reply_cache_stats",
1393	.ops: &nfsd_reply_cache_stats_fops, S_IRUGO},
1394	[NFSD_Versions] = {.name: "versions", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1395	[NFSD_Ports] = {.name: "portlist", .ops: &transaction_ops, S_IWUSR|S_IRUGO},
1396	[NFSD_MaxBlkSize] = {.name: "max_block_size", .ops: &transaction_ops, S_IWUSR|S_IRUGO},
1397	[NFSD_MaxConnections] = {.name: "max_connections", .ops: &transaction_ops, S_IWUSR|S_IRUGO},
1398	[NFSD_Filecache] = {.name: "filecache", .ops: &nfsd_file_cache_stats_fops, S_IRUGO},
1399	#ifdef CONFIG_NFSD_V4
1400	[NFSD_Leasetime] = {.name: "nfsv4leasetime", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1401	[NFSD_Gracetime] = {.name: "nfsv4gracetime", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1402	[NFSD_RecoveryDir] = {.name: "nfsv4recoverydir", .ops: &transaction_ops, S_IWUSR|S_IRUSR},
1403	[NFSD_V4EndGrace] = {.name: "v4_end_grace", .ops: &transaction_ops, S_IWUSR|S_IRUGO},
1404	#endif
1405	/* last one */ {""}
1406	};
1407
1408	ret = simple_fill_super(sb, 0x6e667364, nfsd_files);
1409	if (ret)
1410	return ret;
1411	_nfsd_symlink(parent: sb->s_root, name: "supported_krb5_enctypes",
1412	content: "/proc/net/rpc/gss_krb5_enctypes");
1413	dentry = nfsd_mkdir(parent: sb->s_root, NULL, name: "clients");
1414	if (IS_ERR(ptr: dentry))
1415	return PTR_ERR(ptr: dentry);
1416	nn->nfsd_client_dir = dentry;
1417	return 0;
1418	}
1419
1420	static int nfsd_fs_get_tree(struct fs_context *fc)
1421	{
1422	return get_tree_keyed(fc, fill_super: nfsd_fill_super, key: get_net(net: fc->net_ns));
1423	}
1424
1425	static void nfsd_fs_free_fc(struct fs_context *fc)
1426	{
1427	if (fc->s_fs_info)
1428	put_net(net: fc->s_fs_info);
1429	}
1430
1431	static const struct fs_context_operations nfsd_fs_context_ops = {
1432	.free = nfsd_fs_free_fc,
1433	.get_tree = nfsd_fs_get_tree,
1434	};
1435
1436	static int nfsd_init_fs_context(struct fs_context *fc)
1437	{
1438	put_user_ns(ns: fc->user_ns);
1439	fc->user_ns = get_user_ns(ns: fc->net_ns->user_ns);
1440	fc->ops = &nfsd_fs_context_ops;
1441	return 0;
1442	}
1443
1444	static void nfsd_umount(struct super_block *sb)
1445	{
1446	struct net *net = sb->s_fs_info;
1447
1448	nfsd_shutdown_threads(net);
1449
1450	kill_litter_super(sb);
1451	put_net(net);
1452	}
1453
1454	static struct file_system_type nfsd_fs_type = {
1455	.owner = THIS_MODULE,
1456	.name = "nfsd",
1457	.init_fs_context = nfsd_init_fs_context,
1458	.kill_sb = nfsd_umount,
1459	};
1460	MODULE_ALIAS_FS("nfsd");
1461
1462	#ifdef CONFIG_PROC_FS
1463
1464	static int exports_proc_open(struct inode *inode, struct file *file)
1465	{
1466	return exports_net_open(current->nsproxy->net_ns, file);
1467	}
1468
1469	static const struct proc_ops exports_proc_ops = {
1470	.proc_open = exports_proc_open,
1471	.proc_read = seq_read,
1472	.proc_lseek = seq_lseek,
1473	.proc_release = seq_release,
1474	};
1475
1476	static int create_proc_exports_entry(void)
1477	{
1478	struct proc_dir_entry *entry;
1479
1480	entry = proc_mkdir("fs/nfs", NULL);
1481	if (!entry)
1482	return -ENOMEM;
1483	entry = proc_create(name: "exports", mode: 0, parent: entry, proc_ops: &exports_proc_ops);
1484	if (!entry) {
1485	remove_proc_entry("fs/nfs", NULL);
1486	return -ENOMEM;
1487	}
1488	return 0;
1489	}
1490	#else /* CONFIG_PROC_FS */
1491	static int create_proc_exports_entry(void)
1492	{
1493	return 0;
1494	}
1495	#endif
1496
1497	unsigned int nfsd_net_id;
1498
1499	/**
1500	* nfsd_nl_rpc_status_get_start - Prepare rpc_status_get dumpit
1501	* @cb: netlink metadata and command arguments
1502	*
1503	* Return values:
1504	* %0: The rpc_status_get command may proceed
1505	* %-ENODEV: There is no NFSD running in this namespace
1506	*/
1507	int nfsd_nl_rpc_status_get_start(struct netlink_callback *cb)
1508	{
1509	struct nfsd_net *nn = net_generic(net: sock_net(sk: cb->skb->sk), id: nfsd_net_id);
1510	int ret = -ENODEV;
1511
1512	mutex_lock(&nfsd_mutex);
1513	if (nn->nfsd_serv) {
1514	svc_get(serv: nn->nfsd_serv);
1515	ret = 0;
1516	}
1517	mutex_unlock(lock: &nfsd_mutex);
1518
1519	return ret;
1520	}
1521
1522	static int nfsd_genl_rpc_status_compose_msg(struct sk_buff *skb,
1523	struct netlink_callback *cb,
1524	struct nfsd_genl_rqstp *rqstp)
1525	{
1526	void *hdr;
1527	u32 i;
1528
1529	hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, seq: cb->nlh->nlmsg_seq,
1530	family: &nfsd_nl_family, flags: 0, cmd: NFSD_CMD_RPC_STATUS_GET);
1531	if (!hdr)
1532	return -ENOBUFS;
1533
1534	if (nla_put_be32(skb, attrtype: NFSD_A_RPC_STATUS_XID, value: rqstp->rq_xid) ||
1535	nla_put_u32(skb, attrtype: NFSD_A_RPC_STATUS_FLAGS, value: rqstp->rq_flags) ||
1536	nla_put_u32(skb, attrtype: NFSD_A_RPC_STATUS_PROG, value: rqstp->rq_prog) ||
1537	nla_put_u32(skb, attrtype: NFSD_A_RPC_STATUS_PROC, value: rqstp->rq_proc) ||
1538	nla_put_u8(skb, attrtype: NFSD_A_RPC_STATUS_VERSION, value: rqstp->rq_vers) ||
1539	nla_put_s64(skb, attrtype: NFSD_A_RPC_STATUS_SERVICE_TIME,
1540	value: ktime_to_us(kt: rqstp->rq_stime),
1541	padattr: NFSD_A_RPC_STATUS_PAD))
1542	return -ENOBUFS;
1543
1544	switch (rqstp->rq_saddr.sa_family) {
1545	case AF_INET: {
1546	const struct sockaddr_in *s_in, *d_in;
1547
1548	s_in = (const struct sockaddr_in *)&rqstp->rq_saddr;
1549	d_in = (const struct sockaddr_in *)&rqstp->rq_daddr;
1550	if (nla_put_in_addr(skb, attrtype: NFSD_A_RPC_STATUS_SADDR4,
1551	addr: s_in->sin_addr.s_addr) ||
1552	nla_put_in_addr(skb, attrtype: NFSD_A_RPC_STATUS_DADDR4,
1553	addr: d_in->sin_addr.s_addr) ||
1554	nla_put_be16(skb, attrtype: NFSD_A_RPC_STATUS_SPORT,
1555	value: s_in->sin_port) ||
1556	nla_put_be16(skb, attrtype: NFSD_A_RPC_STATUS_DPORT,
1557	value: d_in->sin_port))
1558	return -ENOBUFS;
1559	break;
1560	}
1561	case AF_INET6: {
1562	const struct sockaddr_in6 *s_in, *d_in;
1563
1564	s_in = (const struct sockaddr_in6 *)&rqstp->rq_saddr;
1565	d_in = (const struct sockaddr_in6 *)&rqstp->rq_daddr;
1566	if (nla_put_in6_addr(skb, attrtype: NFSD_A_RPC_STATUS_SADDR6,
1567	addr: &s_in->sin6_addr) ||
1568	nla_put_in6_addr(skb, attrtype: NFSD_A_RPC_STATUS_DADDR6,
1569	addr: &d_in->sin6_addr) ||
1570	nla_put_be16(skb, attrtype: NFSD_A_RPC_STATUS_SPORT,
1571	value: s_in->sin6_port) ||
1572	nla_put_be16(skb, attrtype: NFSD_A_RPC_STATUS_DPORT,
1573	value: d_in->sin6_port))
1574	return -ENOBUFS;
1575	break;
1576	}
1577	}
1578
1579	for (i = 0; i < rqstp->rq_opcnt; i++)
1580	if (nla_put_u32(skb, attrtype: NFSD_A_RPC_STATUS_COMPOUND_OPS,
1581	value: rqstp->rq_opnum[i]))
1582	return -ENOBUFS;
1583
1584	genlmsg_end(skb, hdr);
1585	return 0;
1586	}
1587
1588	/**
1589	* nfsd_nl_rpc_status_get_dumpit - Handle rpc_status_get dumpit
1590	* @skb: reply buffer
1591	* @cb: netlink metadata and command arguments
1592	*
1593	* Returns the size of the reply or a negative errno.
1594	*/
1595	int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
1596	struct netlink_callback *cb)
1597	{
1598	struct nfsd_net *nn = net_generic(net: sock_net(sk: skb->sk), id: nfsd_net_id);
1599	int i, ret, rqstp_index = 0;
1600
1601	rcu_read_lock();
1602
1603	for (i = 0; i < nn->nfsd_serv->sv_nrpools; i++) {
1604	struct svc_rqst *rqstp;
1605
1606	if (i < cb->args[0]) /* already consumed */
1607	continue;
1608
1609	rqstp_index = 0;
1610	list_for_each_entry_rcu(rqstp,
1611	&nn->nfsd_serv->sv_pools[i].sp_all_threads,
1612	rq_all) {
1613	struct nfsd_genl_rqstp genl_rqstp;
1614	unsigned int status_counter;
1615
1616	if (rqstp_index++ < cb->args[1]) /* already consumed */
1617	continue;
1618	/*
1619	* Acquire rq_status_counter before parsing the rqst
1620	* fields. rq_status_counter is set to an odd value in
1621	* order to notify the consumers the rqstp fields are
1622	* meaningful.
1623	*/
1624	status_counter =
1625	smp_load_acquire(&rqstp->rq_status_counter);
1626	if (!(status_counter & 1))
1627	continue;
1628
1629	genl_rqstp.rq_xid = rqstp->rq_xid;
1630	genl_rqstp.rq_flags = rqstp->rq_flags;
1631	genl_rqstp.rq_vers = rqstp->rq_vers;
1632	genl_rqstp.rq_prog = rqstp->rq_prog;
1633	genl_rqstp.rq_proc = rqstp->rq_proc;
1634	genl_rqstp.rq_stime = rqstp->rq_stime;
1635	genl_rqstp.rq_opcnt = 0;
1636	memcpy(&genl_rqstp.rq_daddr, svc_daddr(rqstp),
1637	sizeof(struct sockaddr));
1638	memcpy(&genl_rqstp.rq_saddr, svc_addr(rqstp),
1639	sizeof(struct sockaddr));
1640
1641	#ifdef CONFIG_NFSD_V4
1642	if (rqstp->rq_vers == NFS4_VERSION &&
1643	rqstp->rq_proc == NFSPROC4_COMPOUND) {
1644	/* NFSv4 compound */
1645	struct nfsd4_compoundargs *args;
1646	int j;
1647
1648	args = rqstp->rq_argp;
1649	genl_rqstp.rq_opcnt = args->opcnt;
1650	for (j = 0; j < genl_rqstp.rq_opcnt; j++)
1651	genl_rqstp.rq_opnum[j] =
1652	args->ops[j].opnum;
1653	}
1654	#endif /* CONFIG_NFSD_V4 */
1655
1656	/*
1657	* Acquire rq_status_counter before reporting the rqst
1658	* fields to the user.
1659	*/
1660	if (smp_load_acquire(&rqstp->rq_status_counter) !=
1661	status_counter)
1662	continue;
1663
1664	ret = nfsd_genl_rpc_status_compose_msg(skb, cb,
1665	rqstp: &genl_rqstp);
1666	if (ret)
1667	goto out;
1668	}
1669	}
1670
1671	cb->args[0] = i;
1672	cb->args[1] = rqstp_index;
1673	ret = skb->len;
1674	out:
1675	rcu_read_unlock();
1676
1677	return ret;
1678	}
1679
1680	/**
1681	* nfsd_nl_rpc_status_get_done - rpc_status_get dumpit post-processing
1682	* @cb: netlink metadata and command arguments
1683	*
1684	* Return values:
1685	* %0: Success
1686	*/
1687	int nfsd_nl_rpc_status_get_done(struct netlink_callback *cb)
1688	{
1689	mutex_lock(&nfsd_mutex);
1690	nfsd_put(net: sock_net(sk: cb->skb->sk));
1691	mutex_unlock(lock: &nfsd_mutex);
1692
1693	return 0;
1694	}
1695
1696	/**
1697	* nfsd_net_init - Prepare the nfsd_net portion of a new net namespace
1698	* @net: a freshly-created network namespace
1699	*
1700	* This information stays around as long as the network namespace is
1701	* alive whether or not there is an NFSD instance running in the
1702	* namespace.
1703	*
1704	* Returns zero on success, or a negative errno otherwise.
1705	*/
1706	static __net_init int nfsd_net_init(struct net *net)
1707	{
1708	int retval;
1709	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
1710
1711	retval = nfsd_export_init(net);
1712	if (retval)
1713	goto out_export_error;
1714	retval = nfsd_idmap_init(net);
1715	if (retval)
1716	goto out_idmap_error;
1717	retval = nfsd_net_reply_cache_init(nn);
1718	if (retval)
1719	goto out_repcache_error;
1720	nn->nfsd_versions = NULL;
1721	nn->nfsd4_minorversions = NULL;
1722	nfsd4_init_leases_net(nn);
1723	get_random_bytes(buf: &nn->siphash_key, len: sizeof(nn->siphash_key));
1724	seqlock_init(&nn->writeverf_lock);
1725
1726	return 0;
1727
1728	out_repcache_error:
1729	nfsd_idmap_shutdown(net);
1730	out_idmap_error:
1731	nfsd_export_shutdown(net);
1732	out_export_error:
1733	return retval;
1734	}
1735
1736	/**
1737	* nfsd_net_exit - Release the nfsd_net portion of a net namespace
1738	* @net: a network namespace that is about to be destroyed
1739	*
1740	*/
1741	static __net_exit void nfsd_net_exit(struct net *net)
1742	{
1743	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
1744
1745	nfsd_net_reply_cache_destroy(nn);
1746	nfsd_idmap_shutdown(net);
1747	nfsd_export_shutdown(net);
1748	nfsd_netns_free_versions(nn);
1749	}
1750
1751	static struct pernet_operations nfsd_net_ops = {
1752	.init = nfsd_net_init,
1753	.exit = nfsd_net_exit,
1754	.id = &nfsd_net_id,
1755	.size = sizeof(struct nfsd_net),
1756	};
1757
1758	static int __init init_nfsd(void)
1759	{
1760	int retval;
1761
1762	retval = nfsd4_init_slabs();
1763	if (retval)
1764	return retval;
1765	retval = nfsd4_init_pnfs();
1766	if (retval)
1767	goto out_free_slabs;
1768	retval = nfsd_stat_init(); /* Statistics */
1769	if (retval)
1770	goto out_free_pnfs;
1771	retval = nfsd_drc_slab_create();
1772	if (retval)
1773	goto out_free_stat;
1774	nfsd_lockd_init(); /* lockd->nfsd callbacks */
1775	retval = create_proc_exports_entry();
1776	if (retval)
1777	goto out_free_lockd;
1778	retval = register_pernet_subsys(&nfsd_net_ops);
1779	if (retval < 0)
1780	goto out_free_exports;
1781	retval = register_cld_notifier();
1782	if (retval)
1783	goto out_free_subsys;
1784	retval = nfsd4_create_laundry_wq();
1785	if (retval)
1786	goto out_free_cld;
1787	retval = register_filesystem(&nfsd_fs_type);
1788	if (retval)
1789	goto out_free_all;
1790	retval = genl_register_family(family: &nfsd_nl_family);
1791	if (retval)
1792	goto out_free_all;
1793
1794	return 0;
1795	out_free_all:
1796	nfsd4_destroy_laundry_wq();
1797	out_free_cld:
1798	unregister_cld_notifier();
1799	out_free_subsys:
1800	unregister_pernet_subsys(&nfsd_net_ops);
1801	out_free_exports:
1802	remove_proc_entry("fs/nfs/exports", NULL);
1803	remove_proc_entry("fs/nfs", NULL);
1804	out_free_lockd:
1805	nfsd_lockd_shutdown();
1806	nfsd_drc_slab_free();
1807	out_free_stat:
1808	nfsd_stat_shutdown();
1809	out_free_pnfs:
1810	nfsd4_exit_pnfs();
1811	out_free_slabs:
1812	nfsd4_free_slabs();
1813	return retval;
1814	}
1815
1816	static void __exit exit_nfsd(void)
1817	{
1818	genl_unregister_family(family: &nfsd_nl_family);
1819	unregister_filesystem(&nfsd_fs_type);
1820	nfsd4_destroy_laundry_wq();
1821	unregister_cld_notifier();
1822	unregister_pernet_subsys(&nfsd_net_ops);
1823	nfsd_drc_slab_free();
1824	remove_proc_entry("fs/nfs/exports", NULL);
1825	remove_proc_entry("fs/nfs", NULL);
1826	nfsd_stat_shutdown();
1827	nfsd_lockd_shutdown();
1828	nfsd4_free_slabs();
1829	nfsd4_exit_pnfs();
1830	}
1831
1832	MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1833	MODULE_DESCRIPTION("In-kernel NFS server");
1834	MODULE_LICENSE("GPL");
1835	module_init(init_nfsd)
1836	module_exit(exit_nfsd)
1837