fs/nfsd/nfsctl.c

   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)