2 * Syscall interface to knfsd.
4 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7 #include <linux/slab.h>
8 #include <linux/namei.h>
9 #include <linux/ctype.h>
11 #include <linux/sunrpc/svcsock.h>
12 #include <linux/lockd/lockd.h>
13 #include <linux/sunrpc/addr.h>
14 #include <linux/sunrpc/gss_api.h>
15 #include <linux/sunrpc/gss_krb5_enctypes.h>
16 #include <linux/sunrpc/rpc_pipe_fs.h>
17 #include <linux/module.h>
27 * We have a single directory with several nodes in it.
39 NFSD_Reply_Cache_Stats
,
44 NFSD_SupportedEnctypes
,
46 * The below MUST come last. Otherwise we leave a hole in nfsd_files[]
47 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
58 * write() for these nodes.
60 static ssize_t
write_filehandle(struct file
*file
, char *buf
, size_t size
);
61 static ssize_t
write_unlock_ip(struct file
*file
, char *buf
, size_t size
);
62 static ssize_t
write_unlock_fs(struct file
*file
, char *buf
, size_t size
);
63 static ssize_t
write_threads(struct file
*file
, char *buf
, size_t size
);
64 static ssize_t
write_pool_threads(struct file
*file
, char *buf
, size_t size
);
65 static ssize_t
write_versions(struct file
*file
, char *buf
, size_t size
);
66 static ssize_t
write_ports(struct file
*file
, char *buf
, size_t size
);
67 static ssize_t
write_maxblksize(struct file
*file
, char *buf
, size_t size
);
68 static ssize_t
write_maxconn(struct file
*file
, char *buf
, size_t size
);
70 static ssize_t
write_leasetime(struct file
*file
, char *buf
, size_t size
);
71 static ssize_t
write_gracetime(struct file
*file
, char *buf
, size_t size
);
72 static ssize_t
write_recoverydir(struct file
*file
, char *buf
, size_t size
);
73 static ssize_t
write_v4_end_grace(struct file
*file
, char *buf
, size_t size
);
76 static ssize_t (*write_op
[])(struct file
*, char *, size_t) = {
77 [NFSD_Fh
] = write_filehandle
,
78 [NFSD_FO_UnlockIP
] = write_unlock_ip
,
79 [NFSD_FO_UnlockFS
] = write_unlock_fs
,
80 [NFSD_Threads
] = write_threads
,
81 [NFSD_Pool_Threads
] = write_pool_threads
,
82 [NFSD_Versions
] = write_versions
,
83 [NFSD_Ports
] = write_ports
,
84 [NFSD_MaxBlkSize
] = write_maxblksize
,
85 [NFSD_MaxConnections
] = write_maxconn
,
87 [NFSD_Leasetime
] = write_leasetime
,
88 [NFSD_Gracetime
] = write_gracetime
,
89 [NFSD_RecoveryDir
] = write_recoverydir
,
90 [NFSD_V4EndGrace
] = write_v4_end_grace
,
94 static ssize_t
nfsctl_transaction_write(struct file
*file
, const char __user
*buf
, size_t size
, loff_t
*pos
)
96 ino_t ino
= file_inode(file
)->i_ino
;
100 if (ino
>= ARRAY_SIZE(write_op
) || !write_op
[ino
])
103 data
= simple_transaction_get(file
, buf
, size
);
105 return PTR_ERR(data
);
107 rv
= write_op
[ino
](file
, data
, size
);
109 simple_transaction_set(file
, rv
);
115 static ssize_t
nfsctl_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
117 if (! file
->private_data
) {
118 /* An attempt to read a transaction file without writing
119 * causes a 0-byte write so that the file can return
122 ssize_t rv
= nfsctl_transaction_write(file
, buf
, 0, pos
);
126 return simple_transaction_read(file
, buf
, size
, pos
);
129 static const struct file_operations transaction_ops
= {
130 .write
= nfsctl_transaction_write
,
131 .read
= nfsctl_transaction_read
,
132 .release
= simple_transaction_release
,
133 .llseek
= default_llseek
,
136 static int exports_net_open(struct net
*net
, struct file
*file
)
139 struct seq_file
*seq
;
140 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
142 err
= seq_open(file
, &nfs_exports_op
);
146 seq
= file
->private_data
;
147 seq
->private = nn
->svc_export_cache
;
151 static int exports_proc_open(struct inode
*inode
, struct file
*file
)
153 return exports_net_open(current
->nsproxy
->net_ns
, file
);
156 static const struct file_operations exports_proc_operations
= {
157 .open
= exports_proc_open
,
160 .release
= seq_release
,
163 static int exports_nfsd_open(struct inode
*inode
, struct file
*file
)
165 return exports_net_open(inode
->i_sb
->s_fs_info
, file
);
168 static const struct file_operations exports_nfsd_operations
= {
169 .open
= exports_nfsd_open
,
172 .release
= seq_release
,
175 static int export_features_show(struct seq_file
*m
, void *v
)
177 seq_printf(m
, "0x%x 0x%x\n", NFSEXP_ALLFLAGS
, NFSEXP_SECINFO_FLAGS
);
181 static int export_features_open(struct inode
*inode
, struct file
*file
)
183 return single_open(file
, export_features_show
, NULL
);
186 static const struct file_operations export_features_operations
= {
187 .open
= export_features_open
,
190 .release
= single_release
,
193 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
194 static int supported_enctypes_show(struct seq_file
*m
, void *v
)
196 seq_printf(m
, KRB5_SUPPORTED_ENCTYPES
);
200 static int supported_enctypes_open(struct inode
*inode
, struct file
*file
)
202 return single_open(file
, supported_enctypes_show
, NULL
);
205 static const struct file_operations supported_enctypes_ops
= {
206 .open
= supported_enctypes_open
,
209 .release
= single_release
,
211 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
213 static const struct file_operations pool_stats_operations
= {
214 .open
= nfsd_pool_stats_open
,
217 .release
= nfsd_pool_stats_release
,
220 static const struct file_operations reply_cache_stats_operations
= {
221 .open
= nfsd_reply_cache_stats_open
,
224 .release
= single_release
,
227 /*----------------------------------------------------------------------------*/
229 * payload - write methods
232 static inline struct net
*netns(struct file
*file
)
234 return file_inode(file
)->i_sb
->s_fs_info
;
238 * write_unlock_ip - Release all locks used by a client
243 * buf: '\n'-terminated C string containing a
244 * presentation format IP address
245 * size: length of C string in @buf
247 * On success: returns zero if all specified locks were released;
248 * returns one if one or more locks were not released
249 * On error: return code is negative errno value
251 static ssize_t
write_unlock_ip(struct file
*file
, char *buf
, size_t size
)
253 struct sockaddr_storage address
;
254 struct sockaddr
*sap
= (struct sockaddr
*)&address
;
255 size_t salen
= sizeof(address
);
257 struct net
*net
= netns(file
);
263 if (buf
[size
-1] != '\n')
267 if (qword_get(&buf
, fo_path
, size
) < 0)
270 if (rpc_pton(net
, fo_path
, size
, sap
, salen
) == 0)
273 return nlmsvc_unlock_all_by_ip(sap
);
277 * write_unlock_fs - Release all locks on a local file system
282 * buf: '\n'-terminated C string containing the
283 * absolute pathname of a local file system
284 * size: length of C string in @buf
286 * On success: returns zero if all specified locks were released;
287 * returns one if one or more locks were not released
288 * On error: return code is negative errno value
290 static ssize_t
write_unlock_fs(struct file
*file
, char *buf
, size_t size
)
300 if (buf
[size
-1] != '\n')
304 if (qword_get(&buf
, fo_path
, size
) < 0)
307 error
= kern_path(fo_path
, 0, &path
);
312 * XXX: Needs better sanity checking. Otherwise we could end up
313 * releasing locks on the wrong file system.
316 * 1. Does the path refer to a directory?
317 * 2. Is that directory a mount point, or
318 * 3. Is that directory the root of an exported file system?
320 error
= nlmsvc_unlock_all_by_sb(path
.dentry
->d_sb
);
327 * write_filehandle - Get a variable-length NFS file handle by path
329 * On input, the buffer contains a '\n'-terminated C string comprised of
330 * three alphanumeric words separated by whitespace. The string may
331 * contain escape sequences.
335 * domain: client domain name
336 * path: export pathname
337 * maxsize: numeric maximum size of
339 * size: length of C string in @buf
341 * On success: passed-in buffer filled with '\n'-terminated C
342 * string containing a ASCII hex text version
343 * of the NFS file handle;
344 * return code is the size in bytes of the string
345 * On error: return code is negative errno value
347 static ssize_t
write_filehandle(struct file
*file
, char *buf
, size_t size
)
350 int uninitialized_var(maxsize
);
353 struct auth_domain
*dom
;
359 if (buf
[size
-1] != '\n')
364 len
= qword_get(&mesg
, dname
, size
);
369 len
= qword_get(&mesg
, path
, size
);
373 len
= get_int(&mesg
, &maxsize
);
377 if (maxsize
< NFS_FHSIZE
)
379 maxsize
= min(maxsize
, NFS3_FHSIZE
);
381 if (qword_get(&mesg
, mesg
, size
)>0)
384 /* we have all the words, they are in buf.. */
385 dom
= unix_domain_find(dname
);
389 len
= exp_rootfh(netns(file
), dom
, path
, &fh
, maxsize
);
390 auth_domain_put(dom
);
395 len
= SIMPLE_TRANSACTION_LIMIT
;
396 qword_addhex(&mesg
, &len
, (char*)&fh
.fh_base
, fh
.fh_size
);
402 * write_threads - Start NFSD, or report the current number of running threads
408 * On success: passed-in buffer filled with '\n'-terminated C
409 * string numeric value representing the number of
410 * running NFSD threads;
411 * return code is the size in bytes of the string
412 * On error: return code is zero
417 * buf: C string containing an unsigned
418 * integer value representing the
419 * number of NFSD threads to start
420 * size: non-zero length of C string in @buf
422 * On success: NFS service is started;
423 * passed-in buffer filled with '\n'-terminated C
424 * string numeric value representing the number of
425 * running NFSD threads;
426 * return code is the size in bytes of the string
427 * On error: return code is zero or a negative errno value
429 static ssize_t
write_threads(struct file
*file
, char *buf
, size_t size
)
433 struct net
*net
= netns(file
);
437 rv
= get_int(&mesg
, &newthreads
);
442 rv
= nfsd_svc(newthreads
, net
);
446 rv
= nfsd_nrthreads(net
);
448 return scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
, "%d\n", rv
);
452 * write_pool_threads - Set or report the current number of threads per pool
461 * buf: C string containing whitespace-
462 * separated unsigned integer values
463 * representing the number of NFSD
464 * threads to start in each pool
465 * size: non-zero length of C string in @buf
467 * On success: passed-in buffer filled with '\n'-terminated C
468 * string containing integer values representing the
469 * number of NFSD threads in each pool;
470 * return code is the size in bytes of the string
471 * On error: return code is zero or a negative errno value
473 static ssize_t
write_pool_threads(struct file
*file
, char *buf
, size_t size
)
475 /* if size > 0, look for an array of number of threads per node
476 * and apply them then write out number of threads per node as reply
484 struct net
*net
= netns(file
);
486 mutex_lock(&nfsd_mutex
);
487 npools
= nfsd_nrpools(net
);
490 * NFS is shut down. The admin can start it by
491 * writing to the threads file but NOT the pool_threads
492 * file, sorry. Report zero threads.
494 mutex_unlock(&nfsd_mutex
);
499 nthreads
= kcalloc(npools
, sizeof(int), GFP_KERNEL
);
501 if (nthreads
== NULL
)
505 for (i
= 0; i
< npools
; i
++) {
506 rv
= get_int(&mesg
, &nthreads
[i
]);
508 break; /* fewer numbers than pools */
510 goto out_free
; /* syntax error */
515 rv
= nfsd_set_nrthreads(i
, nthreads
, net
);
520 rv
= nfsd_get_nrthreads(npools
, nthreads
, net
);
525 size
= SIMPLE_TRANSACTION_LIMIT
;
526 for (i
= 0; i
< npools
&& size
> 0; i
++) {
527 snprintf(mesg
, size
, "%d%c", nthreads
[i
], (i
== npools
-1 ? '\n' : ' '));
535 mutex_unlock(&nfsd_mutex
);
540 nfsd_print_version_support(char *buf
, int remaining
, const char *sep
,
541 unsigned vers
, int minor
)
543 const char *format
= minor
< 0 ? "%s%c%u" : "%s%c%u.%u";
544 bool supported
= !!nfsd_vers(vers
, NFSD_TEST
);
546 if (vers
== 4 && minor
>= 0 &&
547 !nfsd_minorversion(minor
, NFSD_TEST
))
549 if (minor
== 0 && supported
)
551 * special case for backward compatability.
552 * +4.0 is never reported, it is implied by
553 * +4, unless -4.0 is present.
556 return snprintf(buf
, remaining
, format
, sep
,
557 supported
? '+' : '-', vers
, minor
);
560 static ssize_t
__write_versions(struct file
*file
, char *buf
, size_t size
)
563 char *vers
, *minorp
, sign
;
564 int len
, num
, remaining
;
567 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
571 /* Cannot change versions without updating
572 * nn->nfsd_serv->sv_xdrsize, and reallocing
573 * rq_argp and rq_resp
576 if (buf
[size
-1] != '\n')
581 len
= qword_get(&mesg
, vers
, size
);
582 if (len
<= 0) return -EINVAL
;
587 if (sign
== '+' || sign
== '-')
588 num
= simple_strtol((vers
+1), &minorp
, 0);
590 num
= simple_strtol(vers
, &minorp
, 0);
591 if (*minorp
== '.') {
594 if (kstrtouint(minorp
+1, 0, &minor
) < 0)
598 cmd
= sign
== '-' ? NFSD_CLEAR
: NFSD_SET
;
605 if (*minorp
== '.') {
606 if (nfsd_minorversion(minor
, cmd
) < 0)
608 } else if ((cmd
== NFSD_SET
) != nfsd_vers(num
, NFSD_TEST
)) {
610 * Either we have +4 and no minors are enabled,
611 * or we have -4 and at least one minor is enabled.
612 * In either case, propagate 'cmd' to all minors.
615 while (nfsd_minorversion(minor
, cmd
) >= 0)
623 } while ((len
= qword_get(&mesg
, vers
, size
)) > 0);
624 /* If all get turned off, turn them back on, as
625 * having no versions is BAD
627 nfsd_reset_versions();
630 /* Now write current state into reply buffer */
633 remaining
= SIMPLE_TRANSACTION_LIMIT
;
634 for (num
=2 ; num
<= 4 ; num
++) {
636 if (!nfsd_vers(num
, NFSD_AVAIL
))
641 len
= nfsd_print_version_support(buf
, remaining
,
643 if (len
>= remaining
)
651 } while (num
== 4 && minor
<= NFSD_SUPPORTED_MINOR_VERSION
);
654 len
= snprintf(buf
, remaining
, "\n");
655 if (len
>= remaining
)
661 * write_versions - Set or report the available NFS protocol versions
667 * On success: passed-in buffer filled with '\n'-terminated C
668 * string containing positive or negative integer
669 * values representing the current status of each
671 * return code is the size in bytes of the string
672 * On error: return code is zero or a negative errno value
677 * buf: C string containing whitespace-
678 * separated positive or negative
679 * integer values representing NFS
680 * protocol versions to enable ("+n")
682 * size: non-zero length of C string in @buf
684 * On success: status of zero or more protocol versions has
685 * been updated; passed-in buffer filled with
686 * '\n'-terminated C string containing positive
687 * or negative integer values representing the
688 * current status of each protocol version;
689 * return code is the size in bytes of the string
690 * On error: return code is zero or a negative errno value
692 static ssize_t
write_versions(struct file
*file
, char *buf
, size_t size
)
696 mutex_lock(&nfsd_mutex
);
697 rv
= __write_versions(file
, buf
, size
);
698 mutex_unlock(&nfsd_mutex
);
703 * Zero-length write. Return a list of NFSD's current listener
706 static ssize_t
__write_ports_names(char *buf
, struct net
*net
)
708 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
710 if (nn
->nfsd_serv
== NULL
)
712 return svc_xprt_names(nn
->nfsd_serv
, buf
, SIMPLE_TRANSACTION_LIMIT
);
716 * A single 'fd' number was written, in which case it must be for
717 * a socket of a supported family/protocol, and we use it as an
720 static ssize_t
__write_ports_addfd(char *buf
, struct net
*net
)
724 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
726 err
= get_int(&mesg
, &fd
);
727 if (err
!= 0 || fd
< 0)
730 if (svc_alien_sock(net
, fd
)) {
731 printk(KERN_ERR
"%s: socket net is different to NFSd's one\n", __func__
);
735 err
= nfsd_create_serv(net
);
739 err
= svc_addsock(nn
->nfsd_serv
, fd
, buf
, SIMPLE_TRANSACTION_LIMIT
);
745 /* Decrease the count, but don't shut down the service */
746 nn
->nfsd_serv
->sv_nrthreads
--;
751 * A transport listener is added by writing it's transport name and
754 static ssize_t
__write_ports_addxprt(char *buf
, struct net
*net
)
757 struct svc_xprt
*xprt
;
759 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
761 if (sscanf(buf
, "%15s %5u", transport
, &port
) != 2)
764 if (port
< 1 || port
> USHRT_MAX
)
767 err
= nfsd_create_serv(net
);
771 err
= svc_create_xprt(nn
->nfsd_serv
, transport
, net
,
772 PF_INET
, port
, SVC_SOCK_ANONYMOUS
);
776 err
= svc_create_xprt(nn
->nfsd_serv
, transport
, net
,
777 PF_INET6
, port
, SVC_SOCK_ANONYMOUS
);
778 if (err
< 0 && err
!= -EAFNOSUPPORT
)
781 /* Decrease the count, but don't shut down the service */
782 nn
->nfsd_serv
->sv_nrthreads
--;
785 xprt
= svc_find_xprt(nn
->nfsd_serv
, transport
, net
, PF_INET
, port
);
787 svc_close_xprt(xprt
);
795 static ssize_t
__write_ports(struct file
*file
, char *buf
, size_t size
,
799 return __write_ports_names(buf
, net
);
802 return __write_ports_addfd(buf
, net
);
805 return __write_ports_addxprt(buf
, net
);
811 * write_ports - Pass a socket file descriptor or transport name to listen on
817 * On success: passed-in buffer filled with a '\n'-terminated C
818 * string containing a whitespace-separated list of
819 * named NFSD listeners;
820 * return code is the size in bytes of the string
821 * On error: return code is zero or a negative errno value
826 * buf: C string containing an unsigned
827 * integer value representing a bound
828 * but unconnected socket that is to be
829 * used as an NFSD listener; listen(3)
830 * must be called for a SOCK_STREAM
831 * socket, otherwise it is ignored
832 * size: non-zero length of C string in @buf
834 * On success: NFS service is started;
835 * passed-in buffer filled with a '\n'-terminated C
836 * string containing a unique alphanumeric name of
838 * return code is the size in bytes of the string
839 * On error: return code is a negative errno value
844 * buf: C string containing a transport
845 * name and an unsigned integer value
846 * representing the port to listen on,
847 * separated by whitespace
848 * size: non-zero length of C string in @buf
850 * On success: returns zero; NFS service is started
851 * On error: return code is a negative errno value
853 static ssize_t
write_ports(struct file
*file
, char *buf
, size_t size
)
857 mutex_lock(&nfsd_mutex
);
858 rv
= __write_ports(file
, buf
, size
, netns(file
));
859 mutex_unlock(&nfsd_mutex
);
864 int nfsd_max_blksize
;
867 * write_maxblksize - Set or report the current NFS blksize
876 * buf: C string containing an unsigned
877 * integer value representing the new
879 * size: non-zero length of C string in @buf
881 * On success: passed-in buffer filled with '\n'-terminated C string
882 * containing numeric value of the current NFS blksize
884 * return code is the size in bytes of the string
885 * On error: return code is zero or a negative errno value
887 static ssize_t
write_maxblksize(struct file
*file
, char *buf
, size_t size
)
890 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
894 int rv
= get_int(&mesg
, &bsize
);
897 /* force bsize into allowed range and
898 * required alignment.
900 bsize
= max_t(int, bsize
, 1024);
901 bsize
= min_t(int, bsize
, NFSSVC_MAXBLKSIZE
);
903 mutex_lock(&nfsd_mutex
);
905 mutex_unlock(&nfsd_mutex
);
908 nfsd_max_blksize
= bsize
;
909 mutex_unlock(&nfsd_mutex
);
912 return scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
, "%d\n",
917 * write_maxconn - Set or report the current max number of connections
925 * buf: C string containing an unsigned
926 * integer value representing the new
927 * number of max connections
928 * size: non-zero length of C string in @buf
930 * On success: passed-in buffer filled with '\n'-terminated C string
931 * containing numeric value of max_connections setting
932 * for this net namespace;
933 * return code is the size in bytes of the string
934 * On error: return code is zero or a negative errno value
936 static ssize_t
write_maxconn(struct file
*file
, char *buf
, size_t size
)
939 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
940 unsigned int maxconn
= nn
->max_connections
;
943 int rv
= get_uint(&mesg
, &maxconn
);
947 nn
->max_connections
= maxconn
;
950 return scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
, "%u\n", maxconn
);
953 #ifdef CONFIG_NFSD_V4
954 static ssize_t
__nfsd4_write_time(struct file
*file
, char *buf
, size_t size
,
955 time_t *time
, struct nfsd_net
*nn
)
963 rv
= get_int(&mesg
, &i
);
967 * Some sanity checking. We don't have a reason for
968 * these particular numbers, but problems with the
970 * - Too short: the briefest network outage may
971 * cause clients to lose all their locks. Also,
972 * the frequent polling may be wasteful.
973 * - Too long: do you really want reboot recovery
974 * to take more than an hour? Or to make other
975 * clients wait an hour before being able to
976 * revoke a dead client's locks?
978 if (i
< 10 || i
> 3600)
983 return scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
, "%ld\n", *time
);
986 static ssize_t
nfsd4_write_time(struct file
*file
, char *buf
, size_t size
,
987 time_t *time
, struct nfsd_net
*nn
)
991 mutex_lock(&nfsd_mutex
);
992 rv
= __nfsd4_write_time(file
, buf
, size
, time
, nn
);
993 mutex_unlock(&nfsd_mutex
);
998 * write_leasetime - Set or report the current NFSv4 lease time
1007 * buf: C string containing an unsigned
1008 * integer value representing the new
1009 * NFSv4 lease expiry time
1010 * size: non-zero length of C string in @buf
1012 * On success: passed-in buffer filled with '\n'-terminated C
1013 * string containing unsigned integer value of the
1014 * current lease expiry time;
1015 * return code is the size in bytes of the string
1016 * On error: return code is zero or a negative errno value
1018 static ssize_t
write_leasetime(struct file
*file
, char *buf
, size_t size
)
1020 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
1021 return nfsd4_write_time(file
, buf
, size
, &nn
->nfsd4_lease
, nn
);
1025 * write_gracetime - Set or report current NFSv4 grace period time
1027 * As above, but sets the time of the NFSv4 grace period.
1029 * Note this should never be set to less than the *previous*
1030 * lease-period time, but we don't try to enforce this. (In the common
1031 * case (a new boot), we don't know what the previous lease time was
1034 static ssize_t
write_gracetime(struct file
*file
, char *buf
, size_t size
)
1036 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
1037 return nfsd4_write_time(file
, buf
, size
, &nn
->nfsd4_grace
, nn
);
1040 static ssize_t
__write_recoverydir(struct file
*file
, char *buf
, size_t size
,
1041 struct nfsd_net
*nn
)
1050 if (size
> PATH_MAX
|| buf
[size
-1] != '\n')
1055 len
= qword_get(&mesg
, recdir
, size
);
1059 status
= nfs4_reset_recoverydir(recdir
);
1064 return scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
, "%s\n",
1065 nfs4_recoverydir());
1069 * write_recoverydir - Set or report the pathname of the recovery directory
1078 * buf: C string containing the pathname
1079 * of the directory on a local file
1080 * system containing permanent NFSv4
1082 * size: non-zero length of C string in @buf
1084 * On success: passed-in buffer filled with '\n'-terminated C string
1085 * containing the current recovery pathname setting;
1086 * return code is the size in bytes of the string
1087 * On error: return code is zero or a negative errno value
1089 static ssize_t
write_recoverydir(struct file
*file
, char *buf
, size_t size
)
1092 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
1094 mutex_lock(&nfsd_mutex
);
1095 rv
= __write_recoverydir(file
, buf
, size
, nn
);
1096 mutex_unlock(&nfsd_mutex
);
1101 * write_v4_end_grace - release grace period for nfsd's v4.x lock manager
1110 * size: non-zero length of C string in @buf
1112 * passed-in buffer filled with "Y" or "N" with a newline
1113 * and NULL-terminated C string. This indicates whether
1114 * the grace period has ended in the current net
1115 * namespace. Return code is the size in bytes of the
1116 * string. Writing a string that starts with 'Y', 'y', or
1117 * '1' to the file will end the grace period for nfsd's v4
1120 static ssize_t
write_v4_end_grace(struct file
*file
, char *buf
, size_t size
)
1122 struct nfsd_net
*nn
= net_generic(netns(file
), nfsd_net_id
);
1129 nfsd4_end_grace(nn
);
1136 return scnprintf(buf
, SIMPLE_TRANSACTION_LIMIT
, "%c\n",
1137 nn
->grace_ended
? 'Y' : 'N');
1142 /*----------------------------------------------------------------------------*/
1144 * populating the filesystem.
1147 static int nfsd_fill_super(struct super_block
* sb
, void * data
, int silent
)
1149 static struct tree_descr nfsd_files
[] = {
1150 [NFSD_List
] = {"exports", &exports_nfsd_operations
, S_IRUGO
},
1151 [NFSD_Export_features
] = {"export_features",
1152 &export_features_operations
, S_IRUGO
},
1153 [NFSD_FO_UnlockIP
] = {"unlock_ip",
1154 &transaction_ops
, S_IWUSR
|S_IRUSR
},
1155 [NFSD_FO_UnlockFS
] = {"unlock_filesystem",
1156 &transaction_ops
, S_IWUSR
|S_IRUSR
},
1157 [NFSD_Fh
] = {"filehandle", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1158 [NFSD_Threads
] = {"threads", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1159 [NFSD_Pool_Threads
] = {"pool_threads", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1160 [NFSD_Pool_Stats
] = {"pool_stats", &pool_stats_operations
, S_IRUGO
},
1161 [NFSD_Reply_Cache_Stats
] = {"reply_cache_stats", &reply_cache_stats_operations
, S_IRUGO
},
1162 [NFSD_Versions
] = {"versions", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1163 [NFSD_Ports
] = {"portlist", &transaction_ops
, S_IWUSR
|S_IRUGO
},
1164 [NFSD_MaxBlkSize
] = {"max_block_size", &transaction_ops
, S_IWUSR
|S_IRUGO
},
1165 [NFSD_MaxConnections
] = {"max_connections", &transaction_ops
, S_IWUSR
|S_IRUGO
},
1166 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE)
1167 [NFSD_SupportedEnctypes
] = {"supported_krb5_enctypes", &supported_enctypes_ops
, S_IRUGO
},
1168 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
1169 #ifdef CONFIG_NFSD_V4
1170 [NFSD_Leasetime
] = {"nfsv4leasetime", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1171 [NFSD_Gracetime
] = {"nfsv4gracetime", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1172 [NFSD_RecoveryDir
] = {"nfsv4recoverydir", &transaction_ops
, S_IWUSR
|S_IRUSR
},
1173 [NFSD_V4EndGrace
] = {"v4_end_grace", &transaction_ops
, S_IWUSR
|S_IRUGO
},
1177 get_net(sb
->s_fs_info
);
1178 return simple_fill_super(sb
, 0x6e667364, nfsd_files
);
1181 static struct dentry
*nfsd_mount(struct file_system_type
*fs_type
,
1182 int flags
, const char *dev_name
, void *data
)
1184 struct net
*net
= current
->nsproxy
->net_ns
;
1185 return mount_ns(fs_type
, flags
, data
, net
, net
->user_ns
, nfsd_fill_super
);
1188 static void nfsd_umount(struct super_block
*sb
)
1190 struct net
*net
= sb
->s_fs_info
;
1192 kill_litter_super(sb
);
1196 static struct file_system_type nfsd_fs_type
= {
1197 .owner
= THIS_MODULE
,
1199 .mount
= nfsd_mount
,
1200 .kill_sb
= nfsd_umount
,
1202 MODULE_ALIAS_FS("nfsd");
1204 #ifdef CONFIG_PROC_FS
1205 static int create_proc_exports_entry(void)
1207 struct proc_dir_entry
*entry
;
1209 entry
= proc_mkdir("fs/nfs", NULL
);
1212 entry
= proc_create("exports", 0, entry
,
1213 &exports_proc_operations
);
1215 remove_proc_entry("fs/nfs", NULL
);
1220 #else /* CONFIG_PROC_FS */
1221 static int create_proc_exports_entry(void)
1227 unsigned int nfsd_net_id
;
1229 static __net_init
int nfsd_init_net(struct net
*net
)
1232 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
1234 retval
= nfsd_export_init(net
);
1236 goto out_export_error
;
1237 retval
= nfsd_idmap_init(net
);
1239 goto out_idmap_error
;
1240 nn
->nfsd4_lease
= 90; /* default lease time */
1241 nn
->nfsd4_grace
= 90;
1242 nn
->clverifier_counter
= prandom_u32();
1243 nn
->clientid_counter
= prandom_u32();
1247 nfsd_export_shutdown(net
);
1252 static __net_exit
void nfsd_exit_net(struct net
*net
)
1254 nfsd_idmap_shutdown(net
);
1255 nfsd_export_shutdown(net
);
1258 static struct pernet_operations nfsd_net_ops
= {
1259 .init
= nfsd_init_net
,
1260 .exit
= nfsd_exit_net
,
1262 .size
= sizeof(struct nfsd_net
),
1265 static int __init
init_nfsd(void)
1268 printk(KERN_INFO
"Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1270 retval
= register_pernet_subsys(&nfsd_net_ops
);
1273 retval
= register_cld_notifier();
1275 goto out_unregister_pernet
;
1276 retval
= nfsd4_init_slabs();
1278 goto out_unregister_notifier
;
1279 retval
= nfsd4_init_pnfs();
1281 goto out_free_slabs
;
1282 retval
= nfsd_fault_inject_init(); /* nfsd fault injection controls */
1285 nfsd_stat_init(); /* Statistics */
1286 retval
= nfsd_reply_cache_init();
1289 nfsd_lockd_init(); /* lockd->nfsd callbacks */
1290 retval
= create_proc_exports_entry();
1292 goto out_free_lockd
;
1293 retval
= register_filesystem(&nfsd_fs_type
);
1298 remove_proc_entry("fs/nfs/exports", NULL
);
1299 remove_proc_entry("fs/nfs", NULL
);
1301 nfsd_lockd_shutdown();
1302 nfsd_reply_cache_shutdown();
1304 nfsd_stat_shutdown();
1305 nfsd_fault_inject_cleanup();
1310 out_unregister_notifier
:
1311 unregister_cld_notifier();
1312 out_unregister_pernet
:
1313 unregister_pernet_subsys(&nfsd_net_ops
);
1317 static void __exit
exit_nfsd(void)
1319 nfsd_reply_cache_shutdown();
1320 remove_proc_entry("fs/nfs/exports", NULL
);
1321 remove_proc_entry("fs/nfs", NULL
);
1322 nfsd_stat_shutdown();
1323 nfsd_lockd_shutdown();
1326 nfsd_fault_inject_cleanup();
1327 unregister_filesystem(&nfsd_fs_type
);
1328 unregister_cld_notifier();
1329 unregister_pernet_subsys(&nfsd_net_ops
);
1332 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1333 MODULE_LICENSE("GPL");
1334 module_init(init_nfsd
)
1335 module_exit(exit_nfsd
)