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