xref: /openbmc/linux/fs/nfsd/nfsctl.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
1 /*
2  * Syscall interface to knfsd.
3  *
4  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
5  */
6 
7 #include <linux/namei.h>
8 #include <linux/ctype.h>
9 
10 #include <linux/nfsd_idmap.h>
11 #include <linux/sunrpc/svcsock.h>
12 #include <linux/nfsd/syscall.h>
13 #include <linux/lockd/lockd.h>
14 #include <linux/sunrpc/clnt.h>
15 
16 #include "nfsd.h"
17 #include "cache.h"
18 
19 /*
20  *	We have a single directory with 9 nodes in it.
21  */
22 enum {
23 	NFSD_Root = 1,
24 	NFSD_Svc,
25 	NFSD_Add,
26 	NFSD_Del,
27 	NFSD_Export,
28 	NFSD_Unexport,
29 	NFSD_Getfd,
30 	NFSD_Getfs,
31 	NFSD_List,
32 	NFSD_Export_features,
33 	NFSD_Fh,
34 	NFSD_FO_UnlockIP,
35 	NFSD_FO_UnlockFS,
36 	NFSD_Threads,
37 	NFSD_Pool_Threads,
38 	NFSD_Pool_Stats,
39 	NFSD_Versions,
40 	NFSD_Ports,
41 	NFSD_MaxBlkSize,
42 	/*
43 	 * The below MUST come last.  Otherwise we leave a hole in nfsd_files[]
44 	 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
45 	 */
46 #ifdef CONFIG_NFSD_V4
47 	NFSD_Leasetime,
48 	NFSD_RecoveryDir,
49 #endif
50 };
51 
52 /*
53  * write() for these nodes.
54  */
55 static ssize_t write_svc(struct file *file, char *buf, size_t size);
56 static ssize_t write_add(struct file *file, char *buf, size_t size);
57 static ssize_t write_del(struct file *file, char *buf, size_t size);
58 static ssize_t write_export(struct file *file, char *buf, size_t size);
59 static ssize_t write_unexport(struct file *file, char *buf, size_t size);
60 static ssize_t write_getfd(struct file *file, char *buf, size_t size);
61 static ssize_t write_getfs(struct file *file, char *buf, size_t size);
62 static ssize_t write_filehandle(struct file *file, char *buf, size_t size);
63 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size);
64 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size);
65 static ssize_t write_threads(struct file *file, char *buf, size_t size);
66 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size);
67 static ssize_t write_versions(struct file *file, char *buf, size_t size);
68 static ssize_t write_ports(struct file *file, char *buf, size_t size);
69 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size);
70 #ifdef CONFIG_NFSD_V4
71 static ssize_t write_leasetime(struct file *file, char *buf, size_t size);
72 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
73 #endif
74 
75 static ssize_t (*write_op[])(struct file *, char *, size_t) = {
76 	[NFSD_Svc] = write_svc,
77 	[NFSD_Add] = write_add,
78 	[NFSD_Del] = write_del,
79 	[NFSD_Export] = write_export,
80 	[NFSD_Unexport] = write_unexport,
81 	[NFSD_Getfd] = write_getfd,
82 	[NFSD_Getfs] = write_getfs,
83 	[NFSD_Fh] = write_filehandle,
84 	[NFSD_FO_UnlockIP] = write_unlock_ip,
85 	[NFSD_FO_UnlockFS] = write_unlock_fs,
86 	[NFSD_Threads] = write_threads,
87 	[NFSD_Pool_Threads] = write_pool_threads,
88 	[NFSD_Versions] = write_versions,
89 	[NFSD_Ports] = write_ports,
90 	[NFSD_MaxBlkSize] = write_maxblksize,
91 #ifdef CONFIG_NFSD_V4
92 	[NFSD_Leasetime] = write_leasetime,
93 	[NFSD_RecoveryDir] = write_recoverydir,
94 #endif
95 };
96 
97 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
98 {
99 	ino_t ino =  file->f_path.dentry->d_inode->i_ino;
100 	char *data;
101 	ssize_t rv;
102 
103 	if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
104 		return -EINVAL;
105 
106 	data = simple_transaction_get(file, buf, size);
107 	if (IS_ERR(data))
108 		return PTR_ERR(data);
109 
110 	rv =  write_op[ino](file, data, size);
111 	if (rv >= 0) {
112 		simple_transaction_set(file, rv);
113 		rv = size;
114 	}
115 	return rv;
116 }
117 
118 static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
119 {
120 	if (! file->private_data) {
121 		/* An attempt to read a transaction file without writing
122 		 * causes a 0-byte write so that the file can return
123 		 * state information
124 		 */
125 		ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
126 		if (rv < 0)
127 			return rv;
128 	}
129 	return simple_transaction_read(file, buf, size, pos);
130 }
131 
132 static const struct file_operations transaction_ops = {
133 	.write		= nfsctl_transaction_write,
134 	.read		= nfsctl_transaction_read,
135 	.release	= simple_transaction_release,
136 };
137 
138 static int exports_open(struct inode *inode, struct file *file)
139 {
140 	return seq_open(file, &nfs_exports_op);
141 }
142 
143 static const struct file_operations exports_operations = {
144 	.open		= exports_open,
145 	.read		= seq_read,
146 	.llseek		= seq_lseek,
147 	.release	= seq_release,
148 	.owner		= THIS_MODULE,
149 };
150 
151 static int export_features_show(struct seq_file *m, void *v)
152 {
153 	seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
154 	return 0;
155 }
156 
157 static int export_features_open(struct inode *inode, struct file *file)
158 {
159 	return single_open(file, export_features_show, NULL);
160 }
161 
162 static struct file_operations export_features_operations = {
163 	.open		= export_features_open,
164 	.read		= seq_read,
165 	.llseek		= seq_lseek,
166 	.release	= single_release,
167 };
168 
169 extern int nfsd_pool_stats_open(struct inode *inode, struct file *file);
170 extern int nfsd_pool_stats_release(struct inode *inode, struct file *file);
171 
172 static const struct file_operations pool_stats_operations = {
173 	.open		= nfsd_pool_stats_open,
174 	.read		= seq_read,
175 	.llseek		= seq_lseek,
176 	.release	= nfsd_pool_stats_release,
177 	.owner		= THIS_MODULE,
178 };
179 
180 /*----------------------------------------------------------------------------*/
181 /*
182  * payload - write methods
183  */
184 
185 /**
186  * write_svc - Start kernel's NFSD server
187  *
188  * Deprecated.  /proc/fs/nfsd/threads is preferred.
189  * Function remains to support old versions of nfs-utils.
190  *
191  * Input:
192  *			buf:	struct nfsctl_svc
193  *				svc_port:	port number of this
194  *						server's listener
195  *				svc_nthreads:	number of threads to start
196  *			size:	size in bytes of passed in nfsctl_svc
197  * Output:
198  *	On success:	returns zero
199  *	On error:	return code is negative errno value
200  */
201 static ssize_t write_svc(struct file *file, char *buf, size_t size)
202 {
203 	struct nfsctl_svc *data;
204 	int err;
205 	if (size < sizeof(*data))
206 		return -EINVAL;
207 	data = (struct nfsctl_svc*) buf;
208 	err = nfsd_svc(data->svc_port, data->svc_nthreads);
209 	if (err < 0)
210 		return err;
211 	return 0;
212 }
213 
214 /**
215  * write_add - Add or modify client entry in auth unix cache
216  *
217  * Deprecated.  /proc/net/rpc/auth.unix.ip is preferred.
218  * Function remains to support old versions of nfs-utils.
219  *
220  * Input:
221  *			buf:	struct nfsctl_client
222  *				cl_ident:	'\0'-terminated C string
223  *						containing domain name
224  *						of client
225  *				cl_naddr:	no. of items in cl_addrlist
226  *				cl_addrlist:	array of client addresses
227  *				cl_fhkeytype:	ignored
228  *				cl_fhkeylen:	ignored
229  *				cl_fhkey:	ignored
230  *			size:	size in bytes of passed in nfsctl_client
231  * Output:
232  *	On success:	returns zero
233  *	On error:	return code is negative errno value
234  *
235  * Note: Only AF_INET client addresses are passed in, since
236  * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
237  */
238 static ssize_t write_add(struct file *file, char *buf, size_t size)
239 {
240 	struct nfsctl_client *data;
241 	if (size < sizeof(*data))
242 		return -EINVAL;
243 	data = (struct nfsctl_client *)buf;
244 	return exp_addclient(data);
245 }
246 
247 /**
248  * write_del - Remove client from auth unix cache
249  *
250  * Deprecated.  /proc/net/rpc/auth.unix.ip is preferred.
251  * Function remains to support old versions of nfs-utils.
252  *
253  * Input:
254  *			buf:	struct nfsctl_client
255  *				cl_ident:	'\0'-terminated C string
256  *						containing domain name
257  *						of client
258  *				cl_naddr:	ignored
259  *				cl_addrlist:	ignored
260  *				cl_fhkeytype:	ignored
261  *				cl_fhkeylen:	ignored
262  *				cl_fhkey:	ignored
263  *			size:	size in bytes of passed in nfsctl_client
264  * Output:
265  *	On success:	returns zero
266  *	On error:	return code is negative errno value
267  *
268  * Note: Only AF_INET client addresses are passed in, since
269  * nfsctl_client.cl_addrlist contains only in_addr fields for addresses.
270  */
271 static ssize_t write_del(struct file *file, char *buf, size_t size)
272 {
273 	struct nfsctl_client *data;
274 	if (size < sizeof(*data))
275 		return -EINVAL;
276 	data = (struct nfsctl_client *)buf;
277 	return exp_delclient(data);
278 }
279 
280 /**
281  * write_export - Export part or all of a local file system
282  *
283  * Deprecated.  /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
284  * Function remains to support old versions of nfs-utils.
285  *
286  * Input:
287  *			buf:	struct nfsctl_export
288  *				ex_client:	'\0'-terminated C string
289  *						containing domain name
290  *						of client allowed to access
291  *						this export
292  *				ex_path:	'\0'-terminated C string
293  *						containing pathname of
294  *						directory in local file system
295  *				ex_dev:		fsid to use for this export
296  *				ex_ino:		ignored
297  *				ex_flags:	export flags for this export
298  *				ex_anon_uid:	UID to use for anonymous
299  *						requests
300  *				ex_anon_gid:	GID to use for anonymous
301  *						requests
302  *			size:	size in bytes of passed in nfsctl_export
303  * Output:
304  *	On success:	returns zero
305  *	On error:	return code is negative errno value
306  */
307 static ssize_t write_export(struct file *file, char *buf, size_t size)
308 {
309 	struct nfsctl_export *data;
310 	if (size < sizeof(*data))
311 		return -EINVAL;
312 	data = (struct nfsctl_export*)buf;
313 	return exp_export(data);
314 }
315 
316 /**
317  * write_unexport - Unexport a previously exported file system
318  *
319  * Deprecated.  /proc/net/rpc/{nfsd.export,nfsd.fh} are preferred.
320  * Function remains to support old versions of nfs-utils.
321  *
322  * Input:
323  *			buf:	struct nfsctl_export
324  *				ex_client:	'\0'-terminated C string
325  *						containing domain name
326  *						of client no longer allowed
327  *						to access this export
328  *				ex_path:	'\0'-terminated C string
329  *						containing pathname of
330  *						directory in local file system
331  *				ex_dev:		ignored
332  *				ex_ino:		ignored
333  *				ex_flags:	ignored
334  *				ex_anon_uid:	ignored
335  *				ex_anon_gid:	ignored
336  *			size:	size in bytes of passed in nfsctl_export
337  * Output:
338  *	On success:	returns zero
339  *	On error:	return code is negative errno value
340  */
341 static ssize_t write_unexport(struct file *file, char *buf, size_t size)
342 {
343 	struct nfsctl_export *data;
344 
345 	if (size < sizeof(*data))
346 		return -EINVAL;
347 	data = (struct nfsctl_export*)buf;
348 	return exp_unexport(data);
349 }
350 
351 /**
352  * write_getfs - Get a variable-length NFS file handle by path
353  *
354  * Deprecated.  /proc/fs/nfsd/filehandle is preferred.
355  * Function remains to support old versions of nfs-utils.
356  *
357  * Input:
358  *			buf:	struct nfsctl_fsparm
359  *				gd_addr:	socket address of client
360  *				gd_path:	'\0'-terminated C string
361  *						containing pathname of
362  *						directory in local file system
363  *				gd_maxlen:	maximum size of returned file
364  *						handle
365  *			size:	size in bytes of passed in nfsctl_fsparm
366  * Output:
367  *	On success:	passed-in buffer filled with a knfsd_fh structure
368  *			(a variable-length raw NFS file handle);
369  *			return code is the size in bytes of the file handle
370  *	On error:	return code is negative errno value
371  *
372  * Note: Only AF_INET client addresses are passed in, since gd_addr
373  * is the same size as a struct sockaddr_in.
374  */
375 static ssize_t write_getfs(struct file *file, char *buf, size_t size)
376 {
377 	struct nfsctl_fsparm *data;
378 	struct sockaddr_in *sin;
379 	struct auth_domain *clp;
380 	int err = 0;
381 	struct knfsd_fh *res;
382 	struct in6_addr in6;
383 
384 	if (size < sizeof(*data))
385 		return -EINVAL;
386 	data = (struct nfsctl_fsparm*)buf;
387 	err = -EPROTONOSUPPORT;
388 	if (data->gd_addr.sa_family != AF_INET)
389 		goto out;
390 	sin = (struct sockaddr_in *)&data->gd_addr;
391 	if (data->gd_maxlen > NFS3_FHSIZE)
392 		data->gd_maxlen = NFS3_FHSIZE;
393 
394 	res = (struct knfsd_fh*)buf;
395 
396 	exp_readlock();
397 
398 	ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
399 
400 	clp = auth_unix_lookup(&in6);
401 	if (!clp)
402 		err = -EPERM;
403 	else {
404 		err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen);
405 		auth_domain_put(clp);
406 	}
407 	exp_readunlock();
408 	if (err == 0)
409 		err = res->fh_size + offsetof(struct knfsd_fh, fh_base);
410  out:
411 	return err;
412 }
413 
414 /**
415  * write_getfd - Get a fixed-length NFS file handle by path (used by mountd)
416  *
417  * Deprecated.  /proc/fs/nfsd/filehandle is preferred.
418  * Function remains to support old versions of nfs-utils.
419  *
420  * Input:
421  *			buf:	struct nfsctl_fdparm
422  *				gd_addr:	socket address of client
423  *				gd_path:	'\0'-terminated C string
424  *						containing pathname of
425  *						directory in local file system
426  *				gd_version:	fdparm structure version
427  *			size:	size in bytes of passed in nfsctl_fdparm
428  * Output:
429  *	On success:	passed-in buffer filled with nfsctl_res
430  *			(a fixed-length raw NFS file handle);
431  *			return code is the size in bytes of the file handle
432  *	On error:	return code is negative errno value
433  *
434  * Note: Only AF_INET client addresses are passed in, since gd_addr
435  * is the same size as a struct sockaddr_in.
436  */
437 static ssize_t write_getfd(struct file *file, char *buf, size_t size)
438 {
439 	struct nfsctl_fdparm *data;
440 	struct sockaddr_in *sin;
441 	struct auth_domain *clp;
442 	int err = 0;
443 	struct knfsd_fh fh;
444 	char *res;
445 	struct in6_addr in6;
446 
447 	if (size < sizeof(*data))
448 		return -EINVAL;
449 	data = (struct nfsctl_fdparm*)buf;
450 	err = -EPROTONOSUPPORT;
451 	if (data->gd_addr.sa_family != AF_INET)
452 		goto out;
453 	err = -EINVAL;
454 	if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS)
455 		goto out;
456 
457 	res = buf;
458 	sin = (struct sockaddr_in *)&data->gd_addr;
459 	exp_readlock();
460 
461 	ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6);
462 
463 	clp = auth_unix_lookup(&in6);
464 	if (!clp)
465 		err = -EPERM;
466 	else {
467 		err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE);
468 		auth_domain_put(clp);
469 	}
470 	exp_readunlock();
471 
472 	if (err == 0) {
473 		memset(res,0, NFS_FHSIZE);
474 		memcpy(res, &fh.fh_base, fh.fh_size);
475 		err = NFS_FHSIZE;
476 	}
477  out:
478 	return err;
479 }
480 
481 /**
482  * write_unlock_ip - Release all locks used by a client
483  *
484  * Experimental.
485  *
486  * Input:
487  *			buf:	'\n'-terminated C string containing a
488  *				presentation format IP address
489  *			size:	length of C string in @buf
490  * Output:
491  *	On success:	returns zero if all specified locks were released;
492  *			returns one if one or more locks were not released
493  *	On error:	return code is negative errno value
494  */
495 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
496 {
497 	struct sockaddr_storage address;
498 	struct sockaddr *sap = (struct sockaddr *)&address;
499 	size_t salen = sizeof(address);
500 	char *fo_path;
501 
502 	/* sanity check */
503 	if (size == 0)
504 		return -EINVAL;
505 
506 	if (buf[size-1] != '\n')
507 		return -EINVAL;
508 
509 	fo_path = buf;
510 	if (qword_get(&buf, fo_path, size) < 0)
511 		return -EINVAL;
512 
513 	if (rpc_pton(fo_path, size, sap, salen) == 0)
514 		return -EINVAL;
515 
516 	return nlmsvc_unlock_all_by_ip(sap);
517 }
518 
519 /**
520  * write_unlock_fs - Release all locks on a local file system
521  *
522  * Experimental.
523  *
524  * Input:
525  *			buf:	'\n'-terminated C string containing the
526  *				absolute pathname of a local file system
527  *			size:	length of C string in @buf
528  * Output:
529  *	On success:	returns zero if all specified locks were released;
530  *			returns one if one or more locks were not released
531  *	On error:	return code is negative errno value
532  */
533 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
534 {
535 	struct path path;
536 	char *fo_path;
537 	int error;
538 
539 	/* sanity check */
540 	if (size == 0)
541 		return -EINVAL;
542 
543 	if (buf[size-1] != '\n')
544 		return -EINVAL;
545 
546 	fo_path = buf;
547 	if (qword_get(&buf, fo_path, size) < 0)
548 		return -EINVAL;
549 
550 	error = kern_path(fo_path, 0, &path);
551 	if (error)
552 		return error;
553 
554 	/*
555 	 * XXX: Needs better sanity checking.  Otherwise we could end up
556 	 * releasing locks on the wrong file system.
557 	 *
558 	 * For example:
559 	 * 1.  Does the path refer to a directory?
560 	 * 2.  Is that directory a mount point, or
561 	 * 3.  Is that directory the root of an exported file system?
562 	 */
563 	error = nlmsvc_unlock_all_by_sb(path.mnt->mnt_sb);
564 
565 	path_put(&path);
566 	return error;
567 }
568 
569 /**
570  * write_filehandle - Get a variable-length NFS file handle by path
571  *
572  * On input, the buffer contains a '\n'-terminated C string comprised of
573  * three alphanumeric words separated by whitespace.  The string may
574  * contain escape sequences.
575  *
576  * Input:
577  *			buf:
578  *				domain:		client domain name
579  *				path:		export pathname
580  *				maxsize:	numeric maximum size of
581  *						@buf
582  *			size:	length of C string in @buf
583  * Output:
584  *	On success:	passed-in buffer filled with '\n'-terminated C
585  *			string containing a ASCII hex text version
586  *			of the NFS file handle;
587  *			return code is the size in bytes of the string
588  *	On error:	return code is negative errno value
589  */
590 static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
591 {
592 	char *dname, *path;
593 	int uninitialized_var(maxsize);
594 	char *mesg = buf;
595 	int len;
596 	struct auth_domain *dom;
597 	struct knfsd_fh fh;
598 
599 	if (size == 0)
600 		return -EINVAL;
601 
602 	if (buf[size-1] != '\n')
603 		return -EINVAL;
604 	buf[size-1] = 0;
605 
606 	dname = mesg;
607 	len = qword_get(&mesg, dname, size);
608 	if (len <= 0)
609 		return -EINVAL;
610 
611 	path = dname+len+1;
612 	len = qword_get(&mesg, path, size);
613 	if (len <= 0)
614 		return -EINVAL;
615 
616 	len = get_int(&mesg, &maxsize);
617 	if (len)
618 		return len;
619 
620 	if (maxsize < NFS_FHSIZE)
621 		return -EINVAL;
622 	if (maxsize > NFS3_FHSIZE)
623 		maxsize = NFS3_FHSIZE;
624 
625 	if (qword_get(&mesg, mesg, size)>0)
626 		return -EINVAL;
627 
628 	/* we have all the words, they are in buf.. */
629 	dom = unix_domain_find(dname);
630 	if (!dom)
631 		return -ENOMEM;
632 
633 	len = exp_rootfh(dom, path, &fh,  maxsize);
634 	auth_domain_put(dom);
635 	if (len)
636 		return len;
637 
638 	mesg = buf;
639 	len = SIMPLE_TRANSACTION_LIMIT;
640 	qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
641 	mesg[-1] = '\n';
642 	return mesg - buf;
643 }
644 
645 /**
646  * write_threads - Start NFSD, or report the current number of running threads
647  *
648  * Input:
649  *			buf:		ignored
650  *			size:		zero
651  * Output:
652  *	On success:	passed-in buffer filled with '\n'-terminated C
653  *			string numeric value representing the number of
654  *			running NFSD threads;
655  *			return code is the size in bytes of the string
656  *	On error:	return code is zero
657  *
658  * OR
659  *
660  * Input:
661  *			buf:		C string containing an unsigned
662  *					integer value representing the
663  *					number of NFSD threads to start
664  *			size:		non-zero length of C string in @buf
665  * Output:
666  *	On success:	NFS service is started;
667  *			passed-in buffer filled with '\n'-terminated C
668  *			string numeric value representing the number of
669  *			running NFSD threads;
670  *			return code is the size in bytes of the string
671  *	On error:	return code is zero or a negative errno value
672  */
673 static ssize_t write_threads(struct file *file, char *buf, size_t size)
674 {
675 	char *mesg = buf;
676 	int rv;
677 	if (size > 0) {
678 		int newthreads;
679 		rv = get_int(&mesg, &newthreads);
680 		if (rv)
681 			return rv;
682 		if (newthreads < 0)
683 			return -EINVAL;
684 		rv = nfsd_svc(NFS_PORT, newthreads);
685 		if (rv < 0)
686 			return rv;
687 	} else
688 		rv = nfsd_nrthreads();
689 
690 	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
691 }
692 
693 /**
694  * write_pool_threads - Set or report the current number of threads per pool
695  *
696  * Input:
697  *			buf:		ignored
698  *			size:		zero
699  *
700  * OR
701  *
702  * Input:
703  * 			buf:		C string containing whitespace-
704  * 					separated unsigned integer values
705  *					representing the number of NFSD
706  *					threads to start in each pool
707  *			size:		non-zero length of C string in @buf
708  * Output:
709  *	On success:	passed-in buffer filled with '\n'-terminated C
710  *			string containing integer values representing the
711  *			number of NFSD threads in each pool;
712  *			return code is the size in bytes of the string
713  *	On error:	return code is zero or a negative errno value
714  */
715 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
716 {
717 	/* if size > 0, look for an array of number of threads per node
718 	 * and apply them  then write out number of threads per node as reply
719 	 */
720 	char *mesg = buf;
721 	int i;
722 	int rv;
723 	int len;
724 	int npools;
725 	int *nthreads;
726 
727 	mutex_lock(&nfsd_mutex);
728 	npools = nfsd_nrpools();
729 	if (npools == 0) {
730 		/*
731 		 * NFS is shut down.  The admin can start it by
732 		 * writing to the threads file but NOT the pool_threads
733 		 * file, sorry.  Report zero threads.
734 		 */
735 		mutex_unlock(&nfsd_mutex);
736 		strcpy(buf, "0\n");
737 		return strlen(buf);
738 	}
739 
740 	nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
741 	rv = -ENOMEM;
742 	if (nthreads == NULL)
743 		goto out_free;
744 
745 	if (size > 0) {
746 		for (i = 0; i < npools; i++) {
747 			rv = get_int(&mesg, &nthreads[i]);
748 			if (rv == -ENOENT)
749 				break;		/* fewer numbers than pools */
750 			if (rv)
751 				goto out_free;	/* syntax error */
752 			rv = -EINVAL;
753 			if (nthreads[i] < 0)
754 				goto out_free;
755 		}
756 		rv = nfsd_set_nrthreads(i, nthreads);
757 		if (rv)
758 			goto out_free;
759 	}
760 
761 	rv = nfsd_get_nrthreads(npools, nthreads);
762 	if (rv)
763 		goto out_free;
764 
765 	mesg = buf;
766 	size = SIMPLE_TRANSACTION_LIMIT;
767 	for (i = 0; i < npools && size > 0; i++) {
768 		snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
769 		len = strlen(mesg);
770 		size -= len;
771 		mesg += len;
772 	}
773 	rv = mesg - buf;
774 out_free:
775 	kfree(nthreads);
776 	mutex_unlock(&nfsd_mutex);
777 	return rv;
778 }
779 
780 static ssize_t __write_versions(struct file *file, char *buf, size_t size)
781 {
782 	char *mesg = buf;
783 	char *vers, *minorp, sign;
784 	int len, num, remaining;
785 	unsigned minor;
786 	ssize_t tlen = 0;
787 	char *sep;
788 
789 	if (size>0) {
790 		if (nfsd_serv)
791 			/* Cannot change versions without updating
792 			 * nfsd_serv->sv_xdrsize, and reallocing
793 			 * rq_argp and rq_resp
794 			 */
795 			return -EBUSY;
796 		if (buf[size-1] != '\n')
797 			return -EINVAL;
798 		buf[size-1] = 0;
799 
800 		vers = mesg;
801 		len = qword_get(&mesg, vers, size);
802 		if (len <= 0) return -EINVAL;
803 		do {
804 			sign = *vers;
805 			if (sign == '+' || sign == '-')
806 				num = simple_strtol((vers+1), &minorp, 0);
807 			else
808 				num = simple_strtol(vers, &minorp, 0);
809 			if (*minorp == '.') {
810 				if (num < 4)
811 					return -EINVAL;
812 				minor = simple_strtoul(minorp+1, NULL, 0);
813 				if (minor == 0)
814 					return -EINVAL;
815 				if (nfsd_minorversion(minor, sign == '-' ?
816 						     NFSD_CLEAR : NFSD_SET) < 0)
817 					return -EINVAL;
818 				goto next;
819 			}
820 			switch(num) {
821 			case 2:
822 			case 3:
823 			case 4:
824 				nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
825 				break;
826 			default:
827 				return -EINVAL;
828 			}
829 		next:
830 			vers += len + 1;
831 		} while ((len = qword_get(&mesg, vers, size)) > 0);
832 		/* If all get turned off, turn them back on, as
833 		 * having no versions is BAD
834 		 */
835 		nfsd_reset_versions();
836 	}
837 
838 	/* Now write current state into reply buffer */
839 	len = 0;
840 	sep = "";
841 	remaining = SIMPLE_TRANSACTION_LIMIT;
842 	for (num=2 ; num <= 4 ; num++)
843 		if (nfsd_vers(num, NFSD_AVAIL)) {
844 			len = snprintf(buf, remaining, "%s%c%d", sep,
845 				       nfsd_vers(num, NFSD_TEST)?'+':'-',
846 				       num);
847 			sep = " ";
848 
849 			if (len > remaining)
850 				break;
851 			remaining -= len;
852 			buf += len;
853 			tlen += len;
854 		}
855 	if (nfsd_vers(4, NFSD_AVAIL))
856 		for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
857 		     minor++) {
858 			len = snprintf(buf, remaining, " %c4.%u",
859 					(nfsd_vers(4, NFSD_TEST) &&
860 					 nfsd_minorversion(minor, NFSD_TEST)) ?
861 						'+' : '-',
862 					minor);
863 
864 			if (len > remaining)
865 				break;
866 			remaining -= len;
867 			buf += len;
868 			tlen += len;
869 		}
870 
871 	len = snprintf(buf, remaining, "\n");
872 	if (len > remaining)
873 		return -EINVAL;
874 	return tlen + len;
875 }
876 
877 /**
878  * write_versions - Set or report the available NFS protocol versions
879  *
880  * Input:
881  *			buf:		ignored
882  *			size:		zero
883  * Output:
884  *	On success:	passed-in buffer filled with '\n'-terminated C
885  *			string containing positive or negative integer
886  *			values representing the current status of each
887  *			protocol version;
888  *			return code is the size in bytes of the string
889  *	On error:	return code is zero or a negative errno value
890  *
891  * OR
892  *
893  * Input:
894  * 			buf:		C string containing whitespace-
895  * 					separated positive or negative
896  * 					integer values representing NFS
897  * 					protocol versions to enable ("+n")
898  * 					or disable ("-n")
899  *			size:		non-zero length of C string in @buf
900  * Output:
901  *	On success:	status of zero or more protocol versions has
902  *			been updated; passed-in buffer filled with
903  *			'\n'-terminated C string containing positive
904  *			or negative integer values representing the
905  *			current status of each protocol version;
906  *			return code is the size in bytes of the string
907  *	On error:	return code is zero or a negative errno value
908  */
909 static ssize_t write_versions(struct file *file, char *buf, size_t size)
910 {
911 	ssize_t rv;
912 
913 	mutex_lock(&nfsd_mutex);
914 	rv = __write_versions(file, buf, size);
915 	mutex_unlock(&nfsd_mutex);
916 	return rv;
917 }
918 
919 /*
920  * Zero-length write.  Return a list of NFSD's current listener
921  * transports.
922  */
923 static ssize_t __write_ports_names(char *buf)
924 {
925 	if (nfsd_serv == NULL)
926 		return 0;
927 	return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
928 }
929 
930 /*
931  * A single 'fd' number was written, in which case it must be for
932  * a socket of a supported family/protocol, and we use it as an
933  * nfsd listener.
934  */
935 static ssize_t __write_ports_addfd(char *buf)
936 {
937 	char *mesg = buf;
938 	int fd, err;
939 
940 	err = get_int(&mesg, &fd);
941 	if (err != 0 || fd < 0)
942 		return -EINVAL;
943 
944 	err = nfsd_create_serv();
945 	if (err != 0)
946 		return err;
947 
948 	err = lockd_up();
949 	if (err != 0)
950 		goto out;
951 
952 	err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
953 	if (err < 0)
954 		lockd_down();
955 
956 out:
957 	/* Decrease the count, but don't shut down the service */
958 	nfsd_serv->sv_nrthreads--;
959 	return err;
960 }
961 
962 /*
963  * A '-' followed by the 'name' of a socket means we close the socket.
964  */
965 static ssize_t __write_ports_delfd(char *buf)
966 {
967 	char *toclose;
968 	int len = 0;
969 
970 	toclose = kstrdup(buf + 1, GFP_KERNEL);
971 	if (toclose == NULL)
972 		return -ENOMEM;
973 
974 	if (nfsd_serv != NULL)
975 		len = svc_sock_names(nfsd_serv, buf,
976 					SIMPLE_TRANSACTION_LIMIT, toclose);
977 	if (len >= 0)
978 		lockd_down();
979 
980 	kfree(toclose);
981 	return len;
982 }
983 
984 /*
985  * A transport listener is added by writing it's transport name and
986  * a port number.
987  */
988 static ssize_t __write_ports_addxprt(char *buf)
989 {
990 	char transport[16];
991 	int port, err;
992 
993 	if (sscanf(buf, "%15s %4u", transport, &port) != 2)
994 		return -EINVAL;
995 
996 	if (port < 1 || port > USHORT_MAX)
997 		return -EINVAL;
998 
999 	err = nfsd_create_serv();
1000 	if (err != 0)
1001 		return err;
1002 
1003 	err = svc_create_xprt(nfsd_serv, transport,
1004 				PF_INET, port, SVC_SOCK_ANONYMOUS);
1005 	if (err < 0) {
1006 		/* Give a reasonable perror msg for bad transport string */
1007 		if (err == -ENOENT)
1008 			err = -EPROTONOSUPPORT;
1009 		return err;
1010 	}
1011 	return 0;
1012 }
1013 
1014 /*
1015  * A transport listener is removed by writing a "-", it's transport
1016  * name, and it's port number.
1017  */
1018 static ssize_t __write_ports_delxprt(char *buf)
1019 {
1020 	struct svc_xprt *xprt;
1021 	char transport[16];
1022 	int port;
1023 
1024 	if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
1025 		return -EINVAL;
1026 
1027 	if (port < 1 || port > USHORT_MAX || nfsd_serv == NULL)
1028 		return -EINVAL;
1029 
1030 	xprt = svc_find_xprt(nfsd_serv, transport, AF_UNSPEC, port);
1031 	if (xprt == NULL)
1032 		return -ENOTCONN;
1033 
1034 	svc_close_xprt(xprt);
1035 	svc_xprt_put(xprt);
1036 	return 0;
1037 }
1038 
1039 static ssize_t __write_ports(struct file *file, char *buf, size_t size)
1040 {
1041 	if (size == 0)
1042 		return __write_ports_names(buf);
1043 
1044 	if (isdigit(buf[0]))
1045 		return __write_ports_addfd(buf);
1046 
1047 	if (buf[0] == '-' && isdigit(buf[1]))
1048 		return __write_ports_delfd(buf);
1049 
1050 	if (isalpha(buf[0]))
1051 		return __write_ports_addxprt(buf);
1052 
1053 	if (buf[0] == '-' && isalpha(buf[1]))
1054 		return __write_ports_delxprt(buf);
1055 
1056 	return -EINVAL;
1057 }
1058 
1059 /**
1060  * write_ports - Pass a socket file descriptor or transport name to listen on
1061  *
1062  * Input:
1063  *			buf:		ignored
1064  *			size:		zero
1065  * Output:
1066  *	On success:	passed-in buffer filled with a '\n'-terminated C
1067  *			string containing a whitespace-separated list of
1068  *			named NFSD listeners;
1069  *			return code is the size in bytes of the string
1070  *	On error:	return code is zero or a negative errno value
1071  *
1072  * OR
1073  *
1074  * Input:
1075  *			buf:		C string containing an unsigned
1076  *					integer value representing a bound
1077  *					but unconnected socket that is to be
1078  *					used as an NFSD listener; listen(3)
1079  *					must be called for a SOCK_STREAM
1080  *					socket, otherwise it is ignored
1081  *			size:		non-zero length of C string in @buf
1082  * Output:
1083  *	On success:	NFS service is started;
1084  *			passed-in buffer filled with a '\n'-terminated C
1085  *			string containing a unique alphanumeric name of
1086  *			the listener;
1087  *			return code is the size in bytes of the string
1088  *	On error:	return code is a negative errno value
1089  *
1090  * OR
1091  *
1092  * Input:
1093  *			buf:		C string containing a "-" followed
1094  *					by an integer value representing a
1095  *					previously passed in socket file
1096  *					descriptor
1097  *			size:		non-zero length of C string in @buf
1098  * Output:
1099  *	On success:	NFS service no longer listens on that socket;
1100  *			passed-in buffer filled with a '\n'-terminated C
1101  *			string containing a unique name of the listener;
1102  *			return code is the size in bytes of the string
1103  *	On error:	return code is a negative errno value
1104  *
1105  * OR
1106  *
1107  * Input:
1108  *			buf:		C string containing a transport
1109  *					name and an unsigned integer value
1110  *					representing the port to listen on,
1111  *					separated by whitespace
1112  *			size:		non-zero length of C string in @buf
1113  * Output:
1114  *	On success:	returns zero; NFS service is started
1115  *	On error:	return code is a negative errno value
1116  *
1117  * OR
1118  *
1119  * Input:
1120  *			buf:		C string containing a "-" followed
1121  *					by a transport name and an unsigned
1122  *					integer value representing the port
1123  *					to listen on, separated by whitespace
1124  *			size:		non-zero length of C string in @buf
1125  * Output:
1126  *	On success:	returns zero; NFS service no longer listens
1127  *			on that transport
1128  *	On error:	return code is a negative errno value
1129  */
1130 static ssize_t write_ports(struct file *file, char *buf, size_t size)
1131 {
1132 	ssize_t rv;
1133 
1134 	mutex_lock(&nfsd_mutex);
1135 	rv = __write_ports(file, buf, size);
1136 	mutex_unlock(&nfsd_mutex);
1137 	return rv;
1138 }
1139 
1140 
1141 int nfsd_max_blksize;
1142 
1143 /**
1144  * write_maxblksize - Set or report the current NFS blksize
1145  *
1146  * Input:
1147  *			buf:		ignored
1148  *			size:		zero
1149  *
1150  * OR
1151  *
1152  * Input:
1153  * 			buf:		C string containing an unsigned
1154  * 					integer value representing the new
1155  * 					NFS blksize
1156  *			size:		non-zero length of C string in @buf
1157  * Output:
1158  *	On success:	passed-in buffer filled with '\n'-terminated C string
1159  *			containing numeric value of the current NFS blksize
1160  *			setting;
1161  *			return code is the size in bytes of the string
1162  *	On error:	return code is zero or a negative errno value
1163  */
1164 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
1165 {
1166 	char *mesg = buf;
1167 	if (size > 0) {
1168 		int bsize;
1169 		int rv = get_int(&mesg, &bsize);
1170 		if (rv)
1171 			return rv;
1172 		/* force bsize into allowed range and
1173 		 * required alignment.
1174 		 */
1175 		if (bsize < 1024)
1176 			bsize = 1024;
1177 		if (bsize > NFSSVC_MAXBLKSIZE)
1178 			bsize = NFSSVC_MAXBLKSIZE;
1179 		bsize &= ~(1024-1);
1180 		mutex_lock(&nfsd_mutex);
1181 		if (nfsd_serv && nfsd_serv->sv_nrthreads) {
1182 			mutex_unlock(&nfsd_mutex);
1183 			return -EBUSY;
1184 		}
1185 		nfsd_max_blksize = bsize;
1186 		mutex_unlock(&nfsd_mutex);
1187 	}
1188 
1189 	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
1190 							nfsd_max_blksize);
1191 }
1192 
1193 #ifdef CONFIG_NFSD_V4
1194 extern time_t nfs4_leasetime(void);
1195 
1196 static ssize_t __write_leasetime(struct file *file, char *buf, size_t size)
1197 {
1198 	/* if size > 10 seconds, call
1199 	 * nfs4_reset_lease() then write out the new lease (seconds) as reply
1200 	 */
1201 	char *mesg = buf;
1202 	int rv, lease;
1203 
1204 	if (size > 0) {
1205 		if (nfsd_serv)
1206 			return -EBUSY;
1207 		rv = get_int(&mesg, &lease);
1208 		if (rv)
1209 			return rv;
1210 		if (lease < 10 || lease > 3600)
1211 			return -EINVAL;
1212 		nfs4_reset_lease(lease);
1213 	}
1214 
1215 	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n",
1216 							nfs4_lease_time());
1217 }
1218 
1219 /**
1220  * write_leasetime - Set or report the current NFSv4 lease time
1221  *
1222  * Input:
1223  *			buf:		ignored
1224  *			size:		zero
1225  *
1226  * OR
1227  *
1228  * Input:
1229  *			buf:		C string containing an unsigned
1230  *					integer value representing the new
1231  *					NFSv4 lease expiry time
1232  *			size:		non-zero length of C string in @buf
1233  * Output:
1234  *	On success:	passed-in buffer filled with '\n'-terminated C
1235  *			string containing unsigned integer value of the
1236  *			current lease expiry time;
1237  *			return code is the size in bytes of the string
1238  *	On error:	return code is zero or a negative errno value
1239  */
1240 static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
1241 {
1242 	ssize_t rv;
1243 
1244 	mutex_lock(&nfsd_mutex);
1245 	rv = __write_leasetime(file, buf, size);
1246 	mutex_unlock(&nfsd_mutex);
1247 	return rv;
1248 }
1249 
1250 extern char *nfs4_recoverydir(void);
1251 
1252 static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
1253 {
1254 	char *mesg = buf;
1255 	char *recdir;
1256 	int len, status;
1257 
1258 	if (size > 0) {
1259 		if (nfsd_serv)
1260 			return -EBUSY;
1261 		if (size > PATH_MAX || buf[size-1] != '\n')
1262 			return -EINVAL;
1263 		buf[size-1] = 0;
1264 
1265 		recdir = mesg;
1266 		len = qword_get(&mesg, recdir, size);
1267 		if (len <= 0)
1268 			return -EINVAL;
1269 
1270 		status = nfs4_reset_recoverydir(recdir);
1271 	}
1272 
1273 	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1274 							nfs4_recoverydir());
1275 }
1276 
1277 /**
1278  * write_recoverydir - Set or report the pathname of the recovery directory
1279  *
1280  * Input:
1281  *			buf:		ignored
1282  *			size:		zero
1283  *
1284  * OR
1285  *
1286  * Input:
1287  *			buf:		C string containing the pathname
1288  *					of the directory on a local file
1289  *					system containing permanent NFSv4
1290  *					recovery data
1291  *			size:		non-zero length of C string in @buf
1292  * Output:
1293  *	On success:	passed-in buffer filled with '\n'-terminated C string
1294  *			containing the current recovery pathname setting;
1295  *			return code is the size in bytes of the string
1296  *	On error:	return code is zero or a negative errno value
1297  */
1298 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1299 {
1300 	ssize_t rv;
1301 
1302 	mutex_lock(&nfsd_mutex);
1303 	rv = __write_recoverydir(file, buf, size);
1304 	mutex_unlock(&nfsd_mutex);
1305 	return rv;
1306 }
1307 
1308 #endif
1309 
1310 /*----------------------------------------------------------------------------*/
1311 /*
1312  *	populating the filesystem.
1313  */
1314 
1315 static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1316 {
1317 	static struct tree_descr nfsd_files[] = {
1318 		[NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR},
1319 		[NFSD_Add] = {".add", &transaction_ops, S_IWUSR},
1320 		[NFSD_Del] = {".del", &transaction_ops, S_IWUSR},
1321 		[NFSD_Export] = {".export", &transaction_ops, S_IWUSR},
1322 		[NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR},
1323 		[NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR},
1324 		[NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR},
1325 		[NFSD_List] = {"exports", &exports_operations, S_IRUGO},
1326 		[NFSD_Export_features] = {"export_features",
1327 					&export_features_operations, S_IRUGO},
1328 		[NFSD_FO_UnlockIP] = {"unlock_ip",
1329 					&transaction_ops, S_IWUSR|S_IRUSR},
1330 		[NFSD_FO_UnlockFS] = {"unlock_filesystem",
1331 					&transaction_ops, S_IWUSR|S_IRUSR},
1332 		[NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1333 		[NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
1334 		[NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
1335 		[NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
1336 		[NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
1337 		[NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
1338 		[NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
1339 #ifdef CONFIG_NFSD_V4
1340 		[NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
1341 		[NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
1342 #endif
1343 		/* last one */ {""}
1344 	};
1345 	return simple_fill_super(sb, 0x6e667364, nfsd_files);
1346 }
1347 
1348 static int nfsd_get_sb(struct file_system_type *fs_type,
1349 	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1350 {
1351 	return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt);
1352 }
1353 
1354 static struct file_system_type nfsd_fs_type = {
1355 	.owner		= THIS_MODULE,
1356 	.name		= "nfsd",
1357 	.get_sb		= nfsd_get_sb,
1358 	.kill_sb	= kill_litter_super,
1359 };
1360 
1361 #ifdef CONFIG_PROC_FS
1362 static int create_proc_exports_entry(void)
1363 {
1364 	struct proc_dir_entry *entry;
1365 
1366 	entry = proc_mkdir("fs/nfs", NULL);
1367 	if (!entry)
1368 		return -ENOMEM;
1369 	entry = proc_create("exports", 0, entry, &exports_operations);
1370 	if (!entry)
1371 		return -ENOMEM;
1372 	return 0;
1373 }
1374 #else /* CONFIG_PROC_FS */
1375 static int create_proc_exports_entry(void)
1376 {
1377 	return 0;
1378 }
1379 #endif
1380 
1381 static int __init init_nfsd(void)
1382 {
1383 	int retval;
1384 	printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1385 
1386 	retval = nfs4_state_init(); /* nfs4 locking state */
1387 	if (retval)
1388 		return retval;
1389 	nfsd_stat_init();	/* Statistics */
1390 	retval = nfsd_reply_cache_init();
1391 	if (retval)
1392 		goto out_free_stat;
1393 	retval = nfsd_export_init();
1394 	if (retval)
1395 		goto out_free_cache;
1396 	nfsd_lockd_init();	/* lockd->nfsd callbacks */
1397 	retval = nfsd_idmap_init();
1398 	if (retval)
1399 		goto out_free_lockd;
1400 	retval = create_proc_exports_entry();
1401 	if (retval)
1402 		goto out_free_idmap;
1403 	retval = register_filesystem(&nfsd_fs_type);
1404 	if (retval)
1405 		goto out_free_all;
1406 	return 0;
1407 out_free_all:
1408 	remove_proc_entry("fs/nfs/exports", NULL);
1409 	remove_proc_entry("fs/nfs", NULL);
1410 out_free_idmap:
1411 	nfsd_idmap_shutdown();
1412 out_free_lockd:
1413 	nfsd_lockd_shutdown();
1414 	nfsd_export_shutdown();
1415 out_free_cache:
1416 	nfsd_reply_cache_shutdown();
1417 out_free_stat:
1418 	nfsd_stat_shutdown();
1419 	nfsd4_free_slabs();
1420 	return retval;
1421 }
1422 
1423 static void __exit exit_nfsd(void)
1424 {
1425 	nfsd_export_shutdown();
1426 	nfsd_reply_cache_shutdown();
1427 	remove_proc_entry("fs/nfs/exports", NULL);
1428 	remove_proc_entry("fs/nfs", NULL);
1429 	nfsd_stat_shutdown();
1430 	nfsd_lockd_shutdown();
1431 	nfsd_idmap_shutdown();
1432 	nfsd4_free_slabs();
1433 	unregister_filesystem(&nfsd_fs_type);
1434 }
1435 
1436 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1437 MODULE_LICENSE("GPL");
1438 module_init(init_nfsd)
1439 module_exit(exit_nfsd)
1440