fs/nfsd/nfsctl.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Syscall interface to knfsd.
   4  *
   5  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
   6  */
   7
   8 #include <linux/slab.h>
   9 #include <linux/namei.h>
  10 #include <linux/ctype.h>
  11 #include <linux/fs_context.h>
  12
  13 #include <linux/sunrpc/svcsock.h>
  14 #include <linux/lockd/lockd.h>
  15 #include <linux/sunrpc/addr.h>
  16 #include <linux/sunrpc/gss_api.h>
  17 #include <linux/sunrpc/rpc_pipe_fs.h>
  18 #include <linux/sunrpc/svc.h>
  19 #include <linux/module.h>
  20 #include <linux/fsnotify.h>
  21 #include <linux/nfslocalio.h>
  22
  23 #include "idmap.h"
  24 #include "nfsd.h"
  25 #include "cache.h"
  26 #include "state.h"
  27 #include "netns.h"
  28 #include "pnfs.h"
  29 #include "filecache.h"
  30 #include "trace.h"
  31 #include "netlink.h"
  32
  33 /*
  34  *      We have a single directory with several nodes in it.
  35  */
  36 enum {
  37         NFSD_Root = 1,
  38         NFSD_List,
  39         NFSD_Export_Stats,
  40         NFSD_Export_features,
  41         NFSD_Fh,
  42         NFSD_FO_UnlockIP,
  43         NFSD_FO_UnlockFS,
  44         NFSD_Threads,
  45         NFSD_Pool_Threads,
  46         NFSD_Pool_Stats,
  47         NFSD_Reply_Cache_Stats,
  48         NFSD_Versions,
  49         NFSD_Ports,
  50         NFSD_MaxBlkSize,
  51         NFSD_Filecache,
  52         NFSD_Leasetime,
  53         NFSD_Gracetime,
  54         NFSD_RecoveryDir,
  55         NFSD_V4EndGrace,
  56         NFSD_MaxReserved
  57 };
  58
  59 /*
  60  * write() for these nodes.
  61  */
  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_gracetime(struct file *file, char *buf, size_t size);
  73 #ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
  74 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size);
  75 #endif
  76 static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size);
  77 #endif
  78
  79 static ssize_t (*const write_op[])(struct file *, char *, size_t) = {
  80         [NFSD_Fh] = write_filehandle,
  81         [NFSD_FO_UnlockIP] = write_unlock_ip,
  82         [NFSD_FO_UnlockFS] = write_unlock_fs,
  83         [NFSD_Threads] = write_threads,
  84         [NFSD_Pool_Threads] = write_pool_threads,
  85         [NFSD_Versions] = write_versions,
  86         [NFSD_Ports] = write_ports,
  87         [NFSD_MaxBlkSize] = write_maxblksize,
  88 #ifdef CONFIG_NFSD_V4
  89         [NFSD_Leasetime] = write_leasetime,
  90         [NFSD_Gracetime] = write_gracetime,
  91 #ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
  92         [NFSD_RecoveryDir] = write_recoverydir,
  93 #endif
  94         [NFSD_V4EndGrace] = write_v4_end_grace,
  95 #endif
  96 };
  97
  98 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos)
  99 {
 100         ino_t ino =  file_inode(file)->i_ino;
 101         char *data;
 102         ssize_t rv;
 103
 104         if (ino >= ARRAY_SIZE(write_op) || !write_op[ino])
 105                 return -EINVAL;
 106
 107         data = simple_transaction_get(file, buf, size);
 108         if (IS_ERR(data))
 109                 return PTR_ERR(data);
 110
 111         rv = write_op[ino](file, data, size);
 112         if (rv < 0)
 113                 return rv;
 114
 115         simple_transaction_set(file, rv);
 116         return size;
 117 }
 118
 119 static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
 120 {
 121         if (! file->private_data) {
 122                 /* An attempt to read a transaction file without writing
 123                  * causes a 0-byte write so that the file can return
 124                  * state information
 125                  */
 126                 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
 127                 if (rv < 0)
 128                         return rv;
 129         }
 130         return simple_transaction_read(file, buf, size, pos);
 131 }
 132
 133 static const struct file_operations transaction_ops = {
 134         .write          = nfsctl_transaction_write,
 135         .read           = nfsctl_transaction_read,
 136         .release        = simple_transaction_release,
 137         .llseek         = default_llseek,
 138 };
 139
 140 static int exports_net_open(struct net *net, struct file *file)
 141 {
 142         int err;
 143         struct seq_file *seq;
 144         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 145
 146         err = seq_open(file, &nfs_exports_op);
 147         if (err)
 148                 return err;
 149
 150         seq = file->private_data;
 151         seq->private = nn->svc_export_cache;
 152         return 0;
 153 }
 154
 155 static int exports_nfsd_open(struct inode *inode, struct file *file)
 156 {
 157         return exports_net_open(inode->i_sb->s_fs_info, file);
 158 }
 159
 160 static const struct file_operations exports_nfsd_operations = {
 161         .open           = exports_nfsd_open,
 162         .read           = seq_read,
 163         .llseek         = seq_lseek,
 164         .release        = seq_release,
 165 };
 166
 167 static int export_features_show(struct seq_file *m, void *v)
 168 {
 169         seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
 170         return 0;
 171 }
 172
 173 DEFINE_SHOW_ATTRIBUTE(export_features);
 174
 175 static int nfsd_pool_stats_open(struct inode *inode, struct file *file)
 176 {
 177         struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id);
 178
 179         return svc_pool_stats_open(&nn->nfsd_info, file);
 180 }
 181
 182 static const struct file_operations pool_stats_operations = {
 183         .open           = nfsd_pool_stats_open,
 184         .read           = seq_read,
 185         .llseek         = seq_lseek,
 186         .release        = seq_release,
 187 };
 188
 189 DEFINE_SHOW_ATTRIBUTE(nfsd_reply_cache_stats);
 190
 191 DEFINE_SHOW_ATTRIBUTE(nfsd_file_cache_stats);
 192
 193 /*----------------------------------------------------------------------------*/
 194 /*
 195  * payload - write methods
 196  */
 197
 198 static inline struct net *netns(struct file *file)
 199 {
 200         return file_inode(file)->i_sb->s_fs_info;
 201 }
 202
 203 /*
 204  * write_unlock_ip - Release all locks used by a client
 205  *
 206  * Experimental.
 207  *
 208  * Input:
 209  *                      buf:    '\n'-terminated C string containing a
 210  *                              presentation format IP address
 211  *                      size:   length of C string in @buf
 212  * Output:
 213  *      On success:     returns zero if all specified locks were released;
 214  *                      returns one if one or more locks were not released
 215  *      On error:       return code is negative errno value
 216  */
 217 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size)
 218 {
 219         struct sockaddr_storage address;
 220         struct sockaddr *sap = (struct sockaddr *)&address;
 221         size_t salen = sizeof(address);
 222         char *fo_path;
 223         struct net *net = netns(file);
 224
 225         /* sanity check */
 226         if (size == 0)
 227                 return -EINVAL;
 228
 229         if (buf[size-1] != '\n')
 230                 return -EINVAL;
 231
 232         fo_path = buf;
 233         if (qword_get(&buf, fo_path, size) < 0)
 234                 return -EINVAL;
 235
 236         if (rpc_pton(net, fo_path, size, sap, salen) == 0)
 237                 return -EINVAL;
 238
 239         trace_nfsd_ctl_unlock_ip(net, buf);
 240         return nlmsvc_unlock_all_by_ip(sap);
 241 }
 242
 243 /*
 244  * write_unlock_fs - Release all locks on a local file system
 245  *
 246  * Experimental.
 247  *
 248  * Input:
 249  *                      buf:    '\n'-terminated C string containing the
 250  *                              absolute pathname of a local file system
 251  *                      size:   length of C string in @buf
 252  * Output:
 253  *      On success:     returns zero if all specified locks were released;
 254  *                      returns one if one or more locks were not released
 255  *      On error:       return code is negative errno value
 256  */
 257 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size)
 258 {
 259         struct path path;
 260         char *fo_path;
 261         int error;
 262
 263         /* sanity check */
 264         if (size == 0)
 265                 return -EINVAL;
 266
 267         if (buf[size-1] != '\n')
 268                 return -EINVAL;
 269
 270         fo_path = buf;
 271         if (qword_get(&buf, fo_path, size) < 0)
 272                 return -EINVAL;
 273         trace_nfsd_ctl_unlock_fs(netns(file), fo_path);
 274         error = kern_path(fo_path, 0, &path);
 275         if (error)
 276                 return error;
 277
 278         /*
 279          * XXX: Needs better sanity checking.  Otherwise we could end up
 280          * releasing locks on the wrong file system.
 281          *
 282          * For example:
 283          * 1.  Does the path refer to a directory?
 284          * 2.  Is that directory a mount point, or
 285          * 3.  Is that directory the root of an exported file system?
 286          */
 287         error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);
 288         nfsd4_revoke_states(netns(file), path.dentry->d_sb);
 289
 290         path_put(&path);
 291         return error;
 292 }
 293
 294 /*
 295  * write_filehandle - Get a variable-length NFS file handle by path
 296  *
 297  * On input, the buffer contains a '\n'-terminated C string comprised of
 298  * three alphanumeric words separated by whitespace.  The string may
 299  * contain escape sequences.
 300  *
 301  * Input:
 302  *                      buf:
 303  *                              domain:         client domain name
 304  *                              path:           export pathname
 305  *                              maxsize:        numeric maximum size of
 306  *                                              @buf
 307  *                      size:   length of C string in @buf
 308  * Output:
 309  *      On success:     passed-in buffer filled with '\n'-terminated C
 310  *                      string containing a ASCII hex text version
 311  *                      of the NFS file handle;
 312  *                      return code is the size in bytes of the string
 313  *      On error:       return code is negative errno value
 314  */
 315 static ssize_t write_filehandle(struct file *file, char *buf, size_t size)
 316 {
 317         char *dname, *path;
 318         int maxsize;
 319         char *mesg = buf;
 320         int len;
 321         struct auth_domain *dom;
 322         struct knfsd_fh fh;
 323
 324         if (size == 0)
 325                 return -EINVAL;
 326
 327         if (buf[size-1] != '\n')
 328                 return -EINVAL;
 329         buf[size-1] = 0;
 330
 331         dname = mesg;
 332         len = qword_get(&mesg, dname, size);
 333         if (len <= 0)
 334                 return -EINVAL;
 335
 336         path = dname+len+1;
 337         len = qword_get(&mesg, path, size);
 338         if (len <= 0)
 339                 return -EINVAL;
 340
 341         len = get_int(&mesg, &maxsize);
 342         if (len)
 343                 return len;
 344
 345         if (maxsize < NFS_FHSIZE)
 346                 return -EINVAL;
 347         maxsize = min(maxsize, NFS3_FHSIZE);
 348
 349         if (qword_get(&mesg, mesg, size) > 0)
 350                 return -EINVAL;
 351
 352         trace_nfsd_ctl_filehandle(netns(file), dname, path, maxsize);
 353
 354         /* we have all the words, they are in buf.. */
 355         dom = unix_domain_find(dname);
 356         if (!dom)
 357                 return -ENOMEM;
 358
 359         len = exp_rootfh(netns(file), dom, path, &fh, maxsize);
 360         auth_domain_put(dom);
 361         if (len)
 362                 return len;
 363
 364         mesg = buf;
 365         len = SIMPLE_TRANSACTION_LIMIT;
 366         qword_addhex(&mesg, &len, fh.fh_raw, fh.fh_size);
 367         mesg[-1] = '\n';
 368         return mesg - buf;
 369 }
 370
 371 /*
 372  * write_threads - Start NFSD, or report the current number of running threads
 373  *
 374  * Input:
 375  *                      buf:            ignored
 376  *                      size:           zero
 377  * Output:
 378  *      On success:     passed-in buffer filled with '\n'-terminated C
 379  *                      string numeric value representing the number of
 380  *                      running NFSD threads;
 381  *                      return code is the size in bytes of the string
 382  *      On error:       return code is zero
 383  *
 384  * OR
 385  *
 386  * Input:
 387  *                      buf:            C string containing an unsigned
 388  *                                      integer value representing the
 389  *                                      number of NFSD threads to start
 390  *                      size:           non-zero length of C string in @buf
 391  * Output:
 392  *      On success:     NFS service is started;
 393  *                      passed-in buffer filled with '\n'-terminated C
 394  *                      string numeric value representing the number of
 395  *                      running NFSD threads;
 396  *                      return code is the size in bytes of the string
 397  *      On error:       return code is zero or a negative errno value
 398  */
 399 static ssize_t write_threads(struct file *file, char *buf, size_t size)
 400 {
 401         char *mesg = buf;
 402         int rv;
 403         struct net *net = netns(file);
 404
 405         if (size > 0) {
 406                 int newthreads;
 407                 rv = get_int(&mesg, &newthreads);
 408                 if (rv)
 409                         return rv;
 410                 if (newthreads < 0)
 411                         return -EINVAL;
 412                 trace_nfsd_ctl_threads(net, newthreads);
 413                 mutex_lock(&nfsd_mutex);
 414                 rv = nfsd_svc(1, &newthreads, net, file->f_cred, NULL);
 415                 mutex_unlock(&nfsd_mutex);
 416                 if (rv < 0)
 417                         return rv;
 418         } else
 419                 rv = nfsd_nrthreads(net);
 420
 421         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
 422 }
 423
 424 /*
 425  * write_pool_threads - Set or report the current number of threads per pool
 426  *
 427  * Input:
 428  *                      buf:            ignored
 429  *                      size:           zero
 430  *
 431  * OR
 432  *
 433  * Input:
 434  *                      buf:            C string containing whitespace-
 435  *                                      separated unsigned integer values
 436  *                                      representing the number of NFSD
 437  *                                      threads to start in each pool
 438  *                      size:           non-zero length of C string in @buf
 439  * Output:
 440  *      On success:     passed-in buffer filled with '\n'-terminated C
 441  *                      string containing integer values representing the
 442  *                      number of NFSD threads in each pool;
 443  *                      return code is the size in bytes of the string
 444  *      On error:       return code is zero or a negative errno value
 445  */
 446 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
 447 {
 448         /* if size > 0, look for an array of number of threads per node
 449          * and apply them  then write out number of threads per node as reply
 450          */
 451         char *mesg = buf;
 452         int i;
 453         int rv;
 454         int len;
 455         int npools;
 456         int *nthreads;
 457         struct net *net = netns(file);
 458
 459         mutex_lock(&nfsd_mutex);
 460         npools = nfsd_nrpools(net);
 461         if (npools == 0) {
 462                 /*
 463                  * NFS is shut down.  The admin can start it by
 464                  * writing to the threads file but NOT the pool_threads
 465                  * file, sorry.  Report zero threads.
 466                  */
 467                 mutex_unlock(&nfsd_mutex);
 468                 strcpy(buf, "0\n");
 469                 return strlen(buf);
 470         }
 471
 472         nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
 473         rv = -ENOMEM;
 474         if (nthreads == NULL)
 475                 goto out_free;
 476
 477         if (size > 0) {
 478                 for (i = 0; i < npools; i++) {
 479                         rv = get_int(&mesg, &nthreads[i]);
 480                         if (rv == -ENOENT)
 481                                 break;          /* fewer numbers than pools */
 482                         if (rv)
 483                                 goto out_free;  /* syntax error */
 484                         rv = -EINVAL;
 485                         if (nthreads[i] < 0)
 486                                 goto out_free;
 487                         trace_nfsd_ctl_pool_threads(net, i, nthreads[i]);
 488                 }
 489
 490                 /*
 491                  * There must always be a thread in pool 0; the admin
 492                  * can't shut down NFS completely using pool_threads.
 493                  */
 494                 if (nthreads[0] == 0)
 495                         nthreads[0] = 1;
 496
 497                 rv = nfsd_set_nrthreads(i, nthreads, net);
 498                 if (rv)
 499                         goto out_free;
 500         }
 501
 502         rv = nfsd_get_nrthreads(npools, nthreads, net);
 503         if (rv)
 504                 goto out_free;
 505
 506         mesg = buf;
 507         size = SIMPLE_TRANSACTION_LIMIT;
 508         for (i = 0; i < npools && size > 0; i++) {
 509                 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
 510                 len = strlen(mesg);
 511                 size -= len;
 512                 mesg += len;
 513         }
 514         rv = mesg - buf;
 515 out_free:
 516         kfree(nthreads);
 517         mutex_unlock(&nfsd_mutex);
 518         return rv;
 519 }
 520
 521 static ssize_t
 522 nfsd_print_version_support(struct nfsd_net *nn, char *buf, int remaining,
 523                 const char *sep, unsigned vers, int minor)
 524 {
 525         const char *format = minor < 0 ? "%s%c%u" : "%s%c%u.%u";
 526         bool supported = !!nfsd_vers(nn, vers, NFSD_TEST);
 527
 528         if (vers == 4 && minor >= 0 &&
 529             !nfsd_minorversion(nn, minor, NFSD_TEST))
 530                 supported = false;
 531         if (minor == 0 && supported)
 532                 /*
 533                  * special case for backward compatability.
 534                  * +4.0 is never reported, it is implied by
 535                  * +4, unless -4.0 is present.
 536                  */
 537                 return 0;
 538         return snprintf(buf, remaining, format, sep,
 539                         supported ? '+' : '-', vers, minor);
 540 }
 541
 542 static ssize_t __write_versions(struct file *file, char *buf, size_t size)
 543 {
 544         char *mesg = buf;
 545         char *vers, *minorp, sign;
 546         int len, num, remaining;
 547         ssize_t tlen = 0;
 548         char *sep;
 549         struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 550
 551         if (size > 0) {
 552                 if (nn->nfsd_serv)
 553                         /* Cannot change versions without updating
 554                          * nn->nfsd_serv->sv_xdrsize, and reallocing
 555                          * rq_argp and rq_resp
 556                          */
 557                         return -EBUSY;
 558                 if (buf[size-1] != '\n')
 559                         return -EINVAL;
 560                 buf[size-1] = 0;
 561                 trace_nfsd_ctl_version(netns(file), buf);
 562
 563                 vers = mesg;
 564                 len = qword_get(&mesg, vers, size);
 565                 if (len <= 0) return -EINVAL;
 566                 do {
 567                         enum vers_op cmd;
 568                         unsigned minor;
 569                         sign = *vers;
 570                         if (sign == '+' || sign == '-')
 571                                 num = simple_strtol((vers+1), &minorp, 0);
 572                         else
 573                                 num = simple_strtol(vers, &minorp, 0);
 574                         if (*minorp == '.') {
 575                                 if (num != 4)
 576                                         return -EINVAL;
 577                                 if (kstrtouint(minorp+1, 0, &minor) < 0)
 578                                         return -EINVAL;
 579                         }
 580
 581                         cmd = sign == '-' ? NFSD_CLEAR : NFSD_SET;
 582                         switch(num) {
 583 #ifdef CONFIG_NFSD_V2
 584                         case 2:
 585 #endif
 586                         case 3:
 587                                 nfsd_vers(nn, num, cmd);
 588                                 break;
 589                         case 4:
 590                                 if (*minorp == '.') {
 591                                         if (nfsd_minorversion(nn, minor, cmd) < 0)
 592                                                 return -EINVAL;
 593                                 } else if ((cmd == NFSD_SET) != nfsd_vers(nn, num, NFSD_TEST)) {
 594                                         /*
 595                                          * Either we have +4 and no minors are enabled,
 596                                          * or we have -4 and at least one minor is enabled.
 597                                          * In either case, propagate 'cmd' to all minors.
 598                                          */
 599                                         minor = 0;
 600                                         while (nfsd_minorversion(nn, minor, cmd) >= 0)
 601                                                 minor++;
 602                                 }
 603                                 break;
 604                         default:
 605                                 /* Ignore requests to disable non-existent versions */
 606                                 if (cmd == NFSD_SET)
 607                                         return -EINVAL;
 608                         }
 609                         vers += len + 1;
 610                 } while ((len = qword_get(&mesg, vers, size)) > 0);
 611                 /* If all get turned off, turn them back on, as
 612                  * having no versions is BAD
 613                  */
 614                 nfsd_reset_versions(nn);
 615         }
 616
 617         /* Now write current state into reply buffer */
 618         sep = "";
 619         remaining = SIMPLE_TRANSACTION_LIMIT;
 620         for (num=2 ; num <= 4 ; num++) {
 621                 int minor;
 622                 if (!nfsd_vers(nn, num, NFSD_AVAIL))
 623                         continue;
 624
 625                 minor = -1;
 626                 do {
 627                         len = nfsd_print_version_support(nn, buf, remaining,
 628                                         sep, num, minor);
 629                         if (len >= remaining)
 630                                 goto out;
 631                         remaining -= len;
 632                         buf += len;
 633                         tlen += len;
 634                         minor++;
 635                         if (len)
 636                                 sep = " ";
 637                 } while (num == 4 && minor <= NFSD_SUPPORTED_MINOR_VERSION);
 638         }
 639 out:
 640         len = snprintf(buf, remaining, "\n");
 641         if (len >= remaining)
 642                 return -EINVAL;
 643         return tlen + len;
 644 }
 645
 646 /*
 647  * write_versions - Set or report the available NFS protocol versions
 648  *
 649  * Input:
 650  *                      buf:            ignored
 651  *                      size:           zero
 652  * Output:
 653  *      On success:     passed-in buffer filled with '\n'-terminated C
 654  *                      string containing positive or negative integer
 655  *                      values representing the current status of each
 656  *                      protocol version;
 657  *                      return code is the size in bytes of the string
 658  *      On error:       return code is zero or a negative errno value
 659  *
 660  * OR
 661  *
 662  * Input:
 663  *                      buf:            C string containing whitespace-
 664  *                                      separated positive or negative
 665  *                                      integer values representing NFS
 666  *                                      protocol versions to enable ("+n")
 667  *                                      or disable ("-n")
 668  *                      size:           non-zero length of C string in @buf
 669  * Output:
 670  *      On success:     status of zero or more protocol versions has
 671  *                      been updated; passed-in buffer filled with
 672  *                      '\n'-terminated C string containing positive
 673  *                      or negative integer values representing the
 674  *                      current status of each protocol version;
 675  *                      return code is the size in bytes of the string
 676  *      On error:       return code is zero or a negative errno value
 677  */
 678 static ssize_t write_versions(struct file *file, char *buf, size_t size)
 679 {
 680         ssize_t rv;
 681
 682         mutex_lock(&nfsd_mutex);
 683         rv = __write_versions(file, buf, size);
 684         mutex_unlock(&nfsd_mutex);
 685         return rv;
 686 }
 687
 688 /*
 689  * Zero-length write.  Return a list of NFSD's current listener
 690  * transports.
 691  */
 692 static ssize_t __write_ports_names(char *buf, struct net *net)
 693 {
 694         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 695
 696         if (nn->nfsd_serv == NULL)
 697                 return 0;
 698         return svc_xprt_names(nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
 699 }
 700
 701 /*
 702  * A single 'fd' number was written, in which case it must be for
 703  * a socket of a supported family/protocol, and we use it as an
 704  * nfsd listener.
 705  */
 706 static ssize_t __write_ports_addfd(char *buf, struct net *net, const struct cred *cred)
 707 {
 708         char *mesg = buf;
 709         int fd, err;
 710         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 711         struct svc_serv *serv;
 712
 713         err = get_int(&mesg, &fd);
 714         if (err != 0 || fd < 0)
 715                 return -EINVAL;
 716         trace_nfsd_ctl_ports_addfd(net, fd);
 717
 718         err = nfsd_create_serv(net);
 719         if (err != 0)
 720                 return err;
 721
 722         serv = nn->nfsd_serv;
 723         err = svc_addsock(serv, net, fd, buf, SIMPLE_TRANSACTION_LIMIT, cred);
 724
 725         if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks))
 726                 nfsd_destroy_serv(net);
 727
 728         return err;
 729 }
 730
 731 /*
 732  * A transport listener is added by writing its transport name and
 733  * a port number.
 734  */
 735 static ssize_t __write_ports_addxprt(char *buf, struct net *net, const struct cred *cred)
 736 {
 737         char transport[16];
 738         struct svc_xprt *xprt;
 739         int port, err;
 740         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 741         struct svc_serv *serv;
 742
 743         if (sscanf(buf, "%15s %5u", transport, &port) != 2)
 744                 return -EINVAL;
 745
 746         if (port < 1 || port > USHRT_MAX)
 747                 return -EINVAL;
 748         trace_nfsd_ctl_ports_addxprt(net, transport, port);
 749
 750         err = nfsd_create_serv(net);
 751         if (err != 0)
 752                 return err;
 753
 754         serv = nn->nfsd_serv;
 755         err = svc_xprt_create(serv, transport, net,
 756                               PF_INET, port, SVC_SOCK_ANONYMOUS, cred);
 757         if (err < 0)
 758                 goto out_err;
 759
 760         err = svc_xprt_create(serv, transport, net,
 761                               PF_INET6, port, SVC_SOCK_ANONYMOUS, cred);
 762         if (err < 0 && err != -EAFNOSUPPORT)
 763                 goto out_close;
 764
 765         return 0;
 766 out_close:
 767         xprt = svc_find_xprt(serv, transport, net, PF_INET, port);
 768         if (xprt != NULL) {
 769                 svc_xprt_close(xprt);
 770                 svc_xprt_put(xprt);
 771         }
 772 out_err:
 773         if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks))
 774                 nfsd_destroy_serv(net);
 775
 776         return err;
 777 }
 778
 779 static ssize_t __write_ports(struct file *file, char *buf, size_t size,
 780                              struct net *net)
 781 {
 782         if (size == 0)
 783                 return __write_ports_names(buf, net);
 784
 785         if (isdigit(buf[0]))
 786                 return __write_ports_addfd(buf, net, file->f_cred);
 787
 788         if (isalpha(buf[0]))
 789                 return __write_ports_addxprt(buf, net, file->f_cred);
 790
 791         return -EINVAL;
 792 }
 793
 794 /*
 795  * write_ports - Pass a socket file descriptor or transport name to listen on
 796  *
 797  * Input:
 798  *                      buf:            ignored
 799  *                      size:           zero
 800  * Output:
 801  *      On success:     passed-in buffer filled with a '\n'-terminated C
 802  *                      string containing a whitespace-separated list of
 803  *                      named NFSD listeners;
 804  *                      return code is the size in bytes of the string
 805  *      On error:       return code is zero or a negative errno value
 806  *
 807  * OR
 808  *
 809  * Input:
 810  *                      buf:            C string containing an unsigned
 811  *                                      integer value representing a bound
 812  *                                      but unconnected socket that is to be
 813  *                                      used as an NFSD listener; listen(3)
 814  *                                      must be called for a SOCK_STREAM
 815  *                                      socket, otherwise it is ignored
 816  *                      size:           non-zero length of C string in @buf
 817  * Output:
 818  *      On success:     NFS service is started;
 819  *                      passed-in buffer filled with a '\n'-terminated C
 820  *                      string containing a unique alphanumeric name of
 821  *                      the listener;
 822  *                      return code is the size in bytes of the string
 823  *      On error:       return code is a negative errno value
 824  *
 825  * OR
 826  *
 827  * Input:
 828  *                      buf:            C string containing a transport
 829  *                                      name and an unsigned integer value
 830  *                                      representing the port to listen on,
 831  *                                      separated by whitespace
 832  *                      size:           non-zero length of C string in @buf
 833  * Output:
 834  *      On success:     returns zero; NFS service is started
 835  *      On error:       return code is a negative errno value
 836  */
 837 static ssize_t write_ports(struct file *file, char *buf, size_t size)
 838 {
 839         ssize_t rv;
 840
 841         mutex_lock(&nfsd_mutex);
 842         rv = __write_ports(file, buf, size, netns(file));
 843         mutex_unlock(&nfsd_mutex);
 844         return rv;
 845 }
 846
 847
 848 int nfsd_max_blksize;
 849
 850 /*
 851  * write_maxblksize - Set or report the current NFS blksize
 852  *
 853  * Input:
 854  *                      buf:            ignored
 855  *                      size:           zero
 856  *
 857  * OR
 858  *
 859  * Input:
 860  *                      buf:            C string containing an unsigned
 861  *                                      integer value representing the new
 862  *                                      NFS blksize
 863  *                      size:           non-zero length of C string in @buf
 864  * Output:
 865  *      On success:     passed-in buffer filled with '\n'-terminated C string
 866  *                      containing numeric value of the current NFS blksize
 867  *                      setting;
 868  *                      return code is the size in bytes of the string
 869  *      On error:       return code is zero or a negative errno value
 870  */
 871 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
 872 {
 873         char *mesg = buf;
 874         struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 875
 876         if (size > 0) {
 877                 int bsize;
 878                 int rv = get_int(&mesg, &bsize);
 879                 if (rv)
 880                         return rv;
 881                 trace_nfsd_ctl_maxblksize(netns(file), bsize);
 882
 883                 /* force bsize into allowed range and
 884                  * required alignment.
 885                  */
 886                 bsize = max_t(int, bsize, 1024);
 887                 bsize = min_t(int, bsize, NFSSVC_MAXBLKSIZE);
 888                 bsize &= ~(1024-1);
 889                 mutex_lock(&nfsd_mutex);
 890                 if (nn->nfsd_serv) {
 891                         mutex_unlock(&nfsd_mutex);
 892                         return -EBUSY;
 893                 }
 894                 nfsd_max_blksize = bsize;
 895                 mutex_unlock(&nfsd_mutex);
 896         }
 897
 898         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
 899                                                         nfsd_max_blksize);
 900 }
 901
 902 #ifdef CONFIG_NFSD_V4
 903 static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size,
 904                                   time64_t *time, struct nfsd_net *nn)
 905 {
 906         struct dentry *dentry = file_dentry(file);
 907         char *mesg = buf;
 908         int rv, i;
 909
 910         if (size > 0) {
 911                 if (nn->nfsd_serv)
 912                         return -EBUSY;
 913                 rv = get_int(&mesg, &i);
 914                 if (rv)
 915                         return rv;
 916                 trace_nfsd_ctl_time(netns(file), dentry->d_name.name,
 917                                     dentry->d_name.len, i);
 918
 919                 /*
 920                  * Some sanity checking.  We don't have a reason for
 921                  * these particular numbers, but problems with the
 922                  * extremes are:
 923                  *      - Too short: the briefest network outage may
 924                  *        cause clients to lose all their locks.  Also,
 925                  *        the frequent polling may be wasteful.
 926                  *      - Too long: do you really want reboot recovery
 927                  *        to take more than an hour?  Or to make other
 928                  *        clients wait an hour before being able to
 929                  *        revoke a dead client's locks?
 930                  */
 931                 if (i < 10 || i > 3600)
 932                         return -EINVAL;
 933                 *time = i;
 934         }
 935
 936         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%lld\n", *time);
 937 }
 938
 939 static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size,
 940                                 time64_t *time, struct nfsd_net *nn)
 941 {
 942         ssize_t rv;
 943
 944         mutex_lock(&nfsd_mutex);
 945         rv = __nfsd4_write_time(file, buf, size, time, nn);
 946         mutex_unlock(&nfsd_mutex);
 947         return rv;
 948 }
 949
 950 /*
 951  * write_leasetime - Set or report the current NFSv4 lease time
 952  *
 953  * Input:
 954  *                      buf:            ignored
 955  *                      size:           zero
 956  *
 957  * OR
 958  *
 959  * Input:
 960  *                      buf:            C string containing an unsigned
 961  *                                      integer value representing the new
 962  *                                      NFSv4 lease expiry time
 963  *                      size:           non-zero length of C string in @buf
 964  * Output:
 965  *      On success:     passed-in buffer filled with '\n'-terminated C
 966  *                      string containing unsigned integer value of the
 967  *                      current lease expiry time;
 968  *                      return code is the size in bytes of the string
 969  *      On error:       return code is zero or a negative errno value
 970  */
 971 static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
 972 {
 973         struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 974         return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn);
 975 }
 976
 977 /*
 978  * write_gracetime - Set or report current NFSv4 grace period time
 979  *
 980  * As above, but sets the time of the NFSv4 grace period.
 981  *
 982  * Note this should never be set to less than the *previous*
 983  * lease-period time, but we don't try to enforce this.  (In the common
 984  * case (a new boot), we don't know what the previous lease time was
 985  * anyway.)
 986  */
 987 static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
 988 {
 989         struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
 990         return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn);
 991 }
 992
 993 #ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
 994 static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size,
 995                                    struct nfsd_net *nn)
 996 {
 997         char *mesg = buf;
 998         char *recdir;
 999         int len, status;
1000
1001         if (size > 0) {
1002                 if (nn->nfsd_serv)
1003                         return -EBUSY;
1004                 if (size > PATH_MAX || buf[size-1] != '\n')
1005                         return -EINVAL;
1006                 buf[size-1] = 0;
1007
1008                 recdir = mesg;
1009                 len = qword_get(&mesg, recdir, size);
1010                 if (len <= 0)
1011                         return -EINVAL;
1012                 trace_nfsd_ctl_recoverydir(netns(file), recdir);
1013
1014                 status = nfs4_reset_recoverydir(recdir);
1015                 if (status)
1016                         return status;
1017         }
1018
1019         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1020                                                         nfs4_recoverydir());
1021 }
1022
1023 /*
1024  * write_recoverydir - Set or report the pathname of the recovery directory
1025  *
1026  * Input:
1027  *                      buf:            ignored
1028  *                      size:           zero
1029  *
1030  * OR
1031  *
1032  * Input:
1033  *                      buf:            C string containing the pathname
1034  *                                      of the directory on a local file
1035  *                                      system containing permanent NFSv4
1036  *                                      recovery data
1037  *                      size:           non-zero length of C string in @buf
1038  * Output:
1039  *      On success:     passed-in buffer filled with '\n'-terminated C string
1040  *                      containing the current recovery pathname setting;
1041  *                      return code is the size in bytes of the string
1042  *      On error:       return code is zero or a negative errno value
1043  */
1044 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
1045 {
1046         ssize_t rv;
1047         struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
1048
1049         mutex_lock(&nfsd_mutex);
1050         rv = __write_recoverydir(file, buf, size, nn);
1051         mutex_unlock(&nfsd_mutex);
1052         return rv;
1053 }
1054 #endif
1055
1056 /*
1057  * write_v4_end_grace - release grace period for nfsd's v4.x lock manager
1058  *
1059  * Input:
1060  *                      buf:            ignored
1061  *                      size:           zero
1062  * OR
1063  *
1064  * Input:
1065  *                      buf:            any value
1066  *                      size:           non-zero length of C string in @buf
1067  * Output:
1068  *                      passed-in buffer filled with "Y" or "N" with a newline
1069  *                      and NULL-terminated C string. This indicates whether
1070  *                      the grace period has ended in the current net
1071  *                      namespace. Return code is the size in bytes of the
1072  *                      string. Writing a string that starts with 'Y', 'y', or
1073  *                      '1' to the file will end the grace period for nfsd's v4
1074  *                      lock manager.
1075  */
1076 static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size)
1077 {
1078         struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id);
1079
1080         if (size > 0) {
1081                 switch(buf[0]) {
1082                 case 'Y':
1083                 case 'y':
1084                 case '1':
1085                         if (!nn->nfsd_serv)
1086                                 return -EBUSY;
1087                         trace_nfsd_end_grace(netns(file));
1088                         nfsd4_end_grace(nn);
1089                         break;
1090                 default:
1091                         return -EINVAL;
1092                 }
1093         }
1094
1095         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%c\n",
1096                          nn->grace_ended ? 'Y' : 'N');
1097 }
1098
1099 #endif
1100
1101 /*----------------------------------------------------------------------------*/
1102 /*
1103  *      populating the filesystem.
1104  */
1105
1106 /* Basically copying rpc_get_inode. */
1107 static struct inode *nfsd_get_inode(struct super_block *sb, umode_t mode)
1108 {
1109         struct inode *inode = new_inode(sb);
1110         if (!inode)
1111                 return NULL;
1112         /* Following advice from simple_fill_super documentation: */
1113         inode->i_ino = iunique(sb, NFSD_MaxReserved);
1114         inode->i_mode = mode;
1115         simple_inode_init_ts(inode);
1116         switch (mode & S_IFMT) {
1117         case S_IFDIR:
1118                 inode->i_fop = &simple_dir_operations;
1119                 inode->i_op = &simple_dir_inode_operations;
1120                 inc_nlink(inode);
1121                 break;
1122         case S_IFLNK:
1123                 inode->i_op = &simple_symlink_inode_operations;
1124                 break;
1125         default:
1126                 break;
1127         }
1128         return inode;
1129 }
1130
1131 static int __nfsd_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode, struct nfsdfs_client *ncl)
1132 {
1133         struct inode *inode;
1134
1135         inode = nfsd_get_inode(dir->i_sb, mode);
1136         if (!inode)
1137                 return -ENOMEM;
1138         if (ncl) {
1139                 inode->i_private = ncl;
1140                 kref_get(&ncl->cl_ref);
1141         }
1142         d_add(dentry, inode);
1143         inc_nlink(dir);
1144         fsnotify_mkdir(dir, dentry);
1145         return 0;
1146 }
1147
1148 static struct dentry *nfsd_mkdir(struct dentry *parent, struct nfsdfs_client *ncl, char *name)
1149 {
1150         struct inode *dir = parent->d_inode;
1151         struct dentry *dentry;
1152         int ret = -ENOMEM;
1153
1154         inode_lock(dir);
1155         dentry = d_alloc_name(parent, name);
1156         if (!dentry)
1157                 goto out_err;
1158         ret = __nfsd_mkdir(d_inode(parent), dentry, S_IFDIR | 0600, ncl);
1159         if (ret)
1160                 goto out_err;
1161 out:
1162         inode_unlock(dir);
1163         return dentry;
1164 out_err:
1165         dput(dentry);
1166         dentry = ERR_PTR(ret);
1167         goto out;
1168 }
1169
1170 #if IS_ENABLED(CONFIG_SUNRPC_GSS)
1171 static int __nfsd_symlink(struct inode *dir, struct dentry *dentry,
1172                           umode_t mode, const char *content)
1173 {
1174         struct inode *inode;
1175
1176         inode = nfsd_get_inode(dir->i_sb, mode);
1177         if (!inode)
1178                 return -ENOMEM;
1179
1180         inode->i_link = (char *)content;
1181         inode->i_size = strlen(content);
1182
1183         d_add(dentry, inode);
1184         inc_nlink(dir);
1185         fsnotify_create(dir, dentry);
1186         return 0;
1187 }
1188
1189 /*
1190  * @content is assumed to be a NUL-terminated string that lives
1191  * longer than the symlink itself.
1192  */
1193 static void _nfsd_symlink(struct dentry *parent, const char *name,
1194                           const char *content)
1195 {
1196         struct inode *dir = parent->d_inode;
1197         struct dentry *dentry;
1198         int ret;
1199
1200         inode_lock(dir);
1201         dentry = d_alloc_name(parent, name);
1202         if (!dentry)
1203                 goto out;
1204         ret = __nfsd_symlink(d_inode(parent), dentry, S_IFLNK | 0777, content);
1205         if (ret)
1206                 dput(dentry);
1207 out:
1208         inode_unlock(dir);
1209 }
1210 #else
1211 static inline void _nfsd_symlink(struct dentry *parent, const char *name,
1212                                  const char *content)
1213 {
1214 }
1215
1216 #endif
1217
1218 static void clear_ncl(struct dentry *dentry)
1219 {
1220         struct inode *inode = d_inode(dentry);
1221         struct nfsdfs_client *ncl = inode->i_private;
1222
1223         spin_lock(&inode->i_lock);
1224         inode->i_private = NULL;
1225         spin_unlock(&inode->i_lock);
1226         kref_put(&ncl->cl_ref, ncl->cl_release);
1227 }
1228
1229 struct nfsdfs_client *get_nfsdfs_client(struct inode *inode)
1230 {
1231         struct nfsdfs_client *nc;
1232
1233         spin_lock(&inode->i_lock);
1234         nc = inode->i_private;
1235         if (nc)
1236                 kref_get(&nc->cl_ref);
1237         spin_unlock(&inode->i_lock);
1238         return nc;
1239 }
1240
1241 /* XXX: cut'n'paste from simple_fill_super; figure out if we could share
1242  * code instead. */
1243 static  int nfsdfs_create_files(struct dentry *root,
1244                                 const struct tree_descr *files,
1245                                 struct nfsdfs_client *ncl,
1246                                 struct dentry **fdentries)
1247 {
1248         struct inode *dir = d_inode(root);
1249         struct inode *inode;
1250         struct dentry *dentry;
1251         int i;
1252
1253         inode_lock(dir);
1254         for (i = 0; files->name && files->name[0]; i++, files++) {
1255                 dentry = d_alloc_name(root, files->name);
1256                 if (!dentry)
1257                         goto out;
1258                 inode = nfsd_get_inode(d_inode(root)->i_sb,
1259                                         S_IFREG | files->mode);
1260                 if (!inode) {
1261                         dput(dentry);
1262                         goto out;
1263                 }
1264                 kref_get(&ncl->cl_ref);
1265                 inode->i_fop = files->ops;
1266                 inode->i_private = ncl;
1267                 d_add(dentry, inode);
1268                 fsnotify_create(dir, dentry);
1269                 if (fdentries)
1270                         fdentries[i] = dentry;
1271         }
1272         inode_unlock(dir);
1273         return 0;
1274 out:
1275         inode_unlock(dir);
1276         return -ENOMEM;
1277 }
1278
1279 /* on success, returns positive number unique to that client. */
1280 struct dentry *nfsd_client_mkdir(struct nfsd_net *nn,
1281                                  struct nfsdfs_client *ncl, u32 id,
1282                                  const struct tree_descr *files,
1283                                  struct dentry **fdentries)
1284 {
1285         struct dentry *dentry;
1286         char name[11];
1287         int ret;
1288
1289         sprintf(name, "%u", id);
1290
1291         dentry = nfsd_mkdir(nn->nfsd_client_dir, ncl, name);
1292         if (IS_ERR(dentry)) /* XXX: tossing errors? */
1293                 return NULL;
1294         ret = nfsdfs_create_files(dentry, files, ncl, fdentries);
1295         if (ret) {
1296                 nfsd_client_rmdir(dentry);
1297                 return NULL;
1298         }
1299         return dentry;
1300 }
1301
1302 /* Taken from __rpc_rmdir: */
1303 void nfsd_client_rmdir(struct dentry *dentry)
1304 {
1305         simple_recursive_removal(dentry, clear_ncl);
1306 }
1307
1308 static int nfsd_fill_super(struct super_block *sb, struct fs_context *fc)
1309 {
1310         struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
1311                                                         nfsd_net_id);
1312         struct dentry *dentry;
1313         int ret;
1314
1315         static const struct tree_descr nfsd_files[] = {
1316                 [NFSD_List] = {"exports", &exports_nfsd_operations, S_IRUGO},
1317                 /* Per-export io stats use same ops as exports file */
1318                 [NFSD_Export_Stats] = {"export_stats", &exports_nfsd_operations, S_IRUGO},
1319                 [NFSD_Export_features] = {"export_features",
1320                                         &export_features_fops, S_IRUGO},
1321                 [NFSD_FO_UnlockIP] = {"unlock_ip",
1322                                         &transaction_ops, S_IWUSR|S_IRUSR},
1323                 [NFSD_FO_UnlockFS] = {"unlock_filesystem",
1324                                         &transaction_ops, S_IWUSR|S_IRUSR},
1325                 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR},
1326                 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR},
1327                 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR},
1328                 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
1329                 [NFSD_Reply_Cache_Stats] = {"reply_cache_stats",
1330                                         &nfsd_reply_cache_stats_fops, S_IRUGO},
1331                 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR},
1332                 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO},
1333                 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO},
1334                 [NFSD_Filecache] = {"filecache", &nfsd_file_cache_stats_fops, S_IRUGO},
1335 #ifdef CONFIG_NFSD_V4
1336                 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR},
1337                 [NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR},
1338 #ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
1339                 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR},
1340 #endif
1341                 [NFSD_V4EndGrace] = {"v4_end_grace", &transaction_ops, S_IWUSR|S_IRUGO},
1342 #endif
1343                 /* last one */ {""}
1344         };
1345
1346         ret = simple_fill_super(sb, 0x6e667364, nfsd_files);
1347         if (ret)
1348                 return ret;
1349         _nfsd_symlink(sb->s_root, "supported_krb5_enctypes",
1350                       "/proc/net/rpc/gss_krb5_enctypes");
1351         dentry = nfsd_mkdir(sb->s_root, NULL, "clients");
1352         if (IS_ERR(dentry))
1353                 return PTR_ERR(dentry);
1354         nn->nfsd_client_dir = dentry;
1355         return 0;
1356 }
1357
1358 static int nfsd_fs_get_tree(struct fs_context *fc)
1359 {
1360         return get_tree_keyed(fc, nfsd_fill_super, get_net(fc->net_ns));
1361 }
1362
1363 static void nfsd_fs_free_fc(struct fs_context *fc)
1364 {
1365         if (fc->s_fs_info)
1366                 put_net(fc->s_fs_info);
1367 }
1368
1369 static const struct fs_context_operations nfsd_fs_context_ops = {
1370         .free           = nfsd_fs_free_fc,
1371         .get_tree       = nfsd_fs_get_tree,
1372 };
1373
1374 static int nfsd_init_fs_context(struct fs_context *fc)
1375 {
1376         put_user_ns(fc->user_ns);
1377         fc->user_ns = get_user_ns(fc->net_ns->user_ns);
1378         fc->ops = &nfsd_fs_context_ops;
1379         return 0;
1380 }
1381
1382 static void nfsd_umount(struct super_block *sb)
1383 {
1384         struct net *net = sb->s_fs_info;
1385
1386         nfsd_shutdown_threads(net);
1387
1388         kill_litter_super(sb);
1389         put_net(net);
1390 }
1391
1392 static struct file_system_type nfsd_fs_type = {
1393         .owner          = THIS_MODULE,
1394         .name           = "nfsd",
1395         .init_fs_context = nfsd_init_fs_context,
1396         .kill_sb        = nfsd_umount,
1397 };
1398 MODULE_ALIAS_FS("nfsd");
1399
1400 #ifdef CONFIG_PROC_FS
1401
1402 static int exports_proc_open(struct inode *inode, struct file *file)
1403 {
1404         return exports_net_open(current->nsproxy->net_ns, file);
1405 }
1406
1407 static const struct proc_ops exports_proc_ops = {
1408         .proc_open      = exports_proc_open,
1409         .proc_read      = seq_read,
1410         .proc_lseek     = seq_lseek,
1411         .proc_release   = seq_release,
1412 };
1413
1414 static int create_proc_exports_entry(void)
1415 {
1416         struct proc_dir_entry *entry;
1417
1418         entry = proc_mkdir("fs/nfs", NULL);
1419         if (!entry)
1420                 return -ENOMEM;
1421         entry = proc_create("exports", 0, entry, &exports_proc_ops);
1422         if (!entry) {
1423                 remove_proc_entry("fs/nfs", NULL);
1424                 return -ENOMEM;
1425         }
1426         return 0;
1427 }
1428 #else /* CONFIG_PROC_FS */
1429 static int create_proc_exports_entry(void)
1430 {
1431         return 0;
1432 }
1433 #endif
1434
1435 unsigned int nfsd_net_id;
1436
1437 static int nfsd_genl_rpc_status_compose_msg(struct sk_buff *skb,
1438                                             struct netlink_callback *cb,
1439                                             struct nfsd_genl_rqstp *rqstp)
1440 {
1441         void *hdr;
1442         u32 i;
1443
1444         hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
1445                           &nfsd_nl_family, 0, NFSD_CMD_RPC_STATUS_GET);
1446         if (!hdr)
1447                 return -ENOBUFS;
1448
1449         if (nla_put_be32(skb, NFSD_A_RPC_STATUS_XID, rqstp->rq_xid) ||
1450             nla_put_u32(skb, NFSD_A_RPC_STATUS_FLAGS, rqstp->rq_flags) ||
1451             nla_put_u32(skb, NFSD_A_RPC_STATUS_PROG, rqstp->rq_prog) ||
1452             nla_put_u32(skb, NFSD_A_RPC_STATUS_PROC, rqstp->rq_proc) ||
1453             nla_put_u8(skb, NFSD_A_RPC_STATUS_VERSION, rqstp->rq_vers) ||
1454             nla_put_s64(skb, NFSD_A_RPC_STATUS_SERVICE_TIME,
1455                         ktime_to_us(rqstp->rq_stime),
1456                         NFSD_A_RPC_STATUS_PAD))
1457                 return -ENOBUFS;
1458
1459         switch (rqstp->rq_saddr.sa_family) {
1460         case AF_INET: {
1461                 const struct sockaddr_in *s_in, *d_in;
1462
1463                 s_in = (const struct sockaddr_in *)&rqstp->rq_saddr;
1464                 d_in = (const struct sockaddr_in *)&rqstp->rq_daddr;
1465                 if (nla_put_in_addr(skb, NFSD_A_RPC_STATUS_SADDR4,
1466                                     s_in->sin_addr.s_addr) ||
1467                     nla_put_in_addr(skb, NFSD_A_RPC_STATUS_DADDR4,
1468                                     d_in->sin_addr.s_addr) ||
1469                     nla_put_be16(skb, NFSD_A_RPC_STATUS_SPORT,
1470                                  s_in->sin_port) ||
1471                     nla_put_be16(skb, NFSD_A_RPC_STATUS_DPORT,
1472                                  d_in->sin_port))
1473                         return -ENOBUFS;
1474                 break;
1475         }
1476         case AF_INET6: {
1477                 const struct sockaddr_in6 *s_in, *d_in;
1478
1479                 s_in = (const struct sockaddr_in6 *)&rqstp->rq_saddr;
1480                 d_in = (const struct sockaddr_in6 *)&rqstp->rq_daddr;
1481                 if (nla_put_in6_addr(skb, NFSD_A_RPC_STATUS_SADDR6,
1482                                      &s_in->sin6_addr) ||
1483                     nla_put_in6_addr(skb, NFSD_A_RPC_STATUS_DADDR6,
1484                                      &d_in->sin6_addr) ||
1485                     nla_put_be16(skb, NFSD_A_RPC_STATUS_SPORT,
1486                                  s_in->sin6_port) ||
1487                     nla_put_be16(skb, NFSD_A_RPC_STATUS_DPORT,
1488                                  d_in->sin6_port))
1489                         return -ENOBUFS;
1490                 break;
1491         }
1492         }
1493
1494         for (i = 0; i < rqstp->rq_opcnt; i++)
1495                 if (nla_put_u32(skb, NFSD_A_RPC_STATUS_COMPOUND_OPS,
1496                                 rqstp->rq_opnum[i]))
1497                         return -ENOBUFS;
1498
1499         genlmsg_end(skb, hdr);
1500         return 0;
1501 }
1502
1503 /**
1504  * nfsd_nl_rpc_status_get_dumpit - Handle rpc_status_get dumpit
1505  * @skb: reply buffer
1506  * @cb: netlink metadata and command arguments
1507  *
1508  * Returns the size of the reply or a negative errno.
1509  */
1510 int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
1511                                   struct netlink_callback *cb)
1512 {
1513         int i, ret, rqstp_index = 0;
1514         struct nfsd_net *nn;
1515
1516         mutex_lock(&nfsd_mutex);
1517
1518         nn = net_generic(sock_net(skb->sk), nfsd_net_id);
1519         if (!nn->nfsd_serv) {
1520                 ret = -ENODEV;
1521                 goto out_unlock;
1522         }
1523
1524         rcu_read_lock();
1525
1526         for (i = 0; i < nn->nfsd_serv->sv_nrpools; i++) {
1527                 struct svc_rqst *rqstp;
1528
1529                 if (i < cb->args[0]) /* already consumed */
1530                         continue;
1531
1532                 rqstp_index = 0;
1533                 list_for_each_entry_rcu(rqstp,
1534                                 &nn->nfsd_serv->sv_pools[i].sp_all_threads,
1535                                 rq_all) {
1536                         struct nfsd_genl_rqstp genl_rqstp;
1537                         unsigned int status_counter;
1538
1539                         if (rqstp_index++ < cb->args[1]) /* already consumed */
1540                                 continue;
1541                         /*
1542                          * Acquire rq_status_counter before parsing the rqst
1543                          * fields. rq_status_counter is set to an odd value in
1544                          * order to notify the consumers the rqstp fields are
1545                          * meaningful.
1546                          */
1547                         status_counter =
1548                                 smp_load_acquire(&rqstp->rq_status_counter);
1549                         if (!(status_counter & 1))
1550                                 continue;
1551
1552                         genl_rqstp.rq_xid = rqstp->rq_xid;
1553                         genl_rqstp.rq_flags = rqstp->rq_flags;
1554                         genl_rqstp.rq_vers = rqstp->rq_vers;
1555                         genl_rqstp.rq_prog = rqstp->rq_prog;
1556                         genl_rqstp.rq_proc = rqstp->rq_proc;
1557                         genl_rqstp.rq_stime = rqstp->rq_stime;
1558                         genl_rqstp.rq_opcnt = 0;
1559                         memcpy(&genl_rqstp.rq_daddr, svc_daddr(rqstp),
1560                                sizeof(struct sockaddr));
1561                         memcpy(&genl_rqstp.rq_saddr, svc_addr(rqstp),
1562                                sizeof(struct sockaddr));
1563
1564 #ifdef CONFIG_NFSD_V4
1565                         if (rqstp->rq_vers == NFS4_VERSION &&
1566                             rqstp->rq_proc == NFSPROC4_COMPOUND) {
1567                                 /* NFSv4 compound */
1568                                 struct nfsd4_compoundargs *args;
1569                                 int j;
1570
1571                                 args = rqstp->rq_argp;
1572                                 genl_rqstp.rq_opcnt = args->opcnt;
1573                                 for (j = 0; j < genl_rqstp.rq_opcnt; j++)
1574                                         genl_rqstp.rq_opnum[j] =
1575                                                 args->ops[j].opnum;
1576                         }
1577 #endif /* CONFIG_NFSD_V4 */
1578
1579                         /*
1580                          * Acquire rq_status_counter before reporting the rqst
1581                          * fields to the user.
1582                          */
1583                         if (smp_load_acquire(&rqstp->rq_status_counter) !=
1584                             status_counter)
1585                                 continue;
1586
1587                         ret = nfsd_genl_rpc_status_compose_msg(skb, cb,
1588                                                                &genl_rqstp);
1589                         if (ret)
1590                                 goto out;
1591                 }
1592         }
1593
1594         cb->args[0] = i;
1595         cb->args[1] = rqstp_index;
1596         ret = skb->len;
1597 out:
1598         rcu_read_unlock();
1599 out_unlock:
1600         mutex_unlock(&nfsd_mutex);
1601
1602         return ret;
1603 }
1604
1605 /**
1606  * nfsd_nl_threads_set_doit - set the number of running threads
1607  * @skb: reply buffer
1608  * @info: netlink metadata and command arguments
1609  *
1610  * Return 0 on success or a negative errno.
1611  */
1612 int nfsd_nl_threads_set_doit(struct sk_buff *skb, struct genl_info *info)
1613 {
1614         int *nthreads, nrpools = 0, i, ret = -EOPNOTSUPP, rem;
1615         struct net *net = genl_info_net(info);
1616         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1617         const struct nlattr *attr;
1618         const char *scope = NULL;
1619
1620         if (GENL_REQ_ATTR_CHECK(info, NFSD_A_SERVER_THREADS))
1621                 return -EINVAL;
1622
1623         /* count number of SERVER_THREADS values */
1624         nlmsg_for_each_attr(attr, info->nlhdr, GENL_HDRLEN, rem) {
1625                 if (nla_type(attr) == NFSD_A_SERVER_THREADS)
1626                         nrpools++;
1627         }
1628
1629         mutex_lock(&nfsd_mutex);
1630
1631         nthreads = kcalloc(nrpools, sizeof(int), GFP_KERNEL);
1632         if (!nthreads) {
1633                 ret = -ENOMEM;
1634                 goto out_unlock;
1635         }
1636
1637         i = 0;
1638         nlmsg_for_each_attr(attr, info->nlhdr, GENL_HDRLEN, rem) {
1639                 if (nla_type(attr) == NFSD_A_SERVER_THREADS) {
1640                         nthreads[i++] = nla_get_u32(attr);
1641                         if (i >= nrpools)
1642                                 break;
1643                 }
1644         }
1645
1646         if (info->attrs[NFSD_A_SERVER_GRACETIME] ||
1647             info->attrs[NFSD_A_SERVER_LEASETIME] ||
1648             info->attrs[NFSD_A_SERVER_SCOPE]) {
1649                 ret = -EBUSY;
1650                 if (nn->nfsd_serv && nn->nfsd_serv->sv_nrthreads)
1651                         goto out_unlock;
1652
1653                 ret = -EINVAL;
1654                 attr = info->attrs[NFSD_A_SERVER_GRACETIME];
1655                 if (attr) {
1656                         u32 gracetime = nla_get_u32(attr);
1657
1658                         if (gracetime < 10 || gracetime > 3600)
1659                                 goto out_unlock;
1660
1661                         nn->nfsd4_grace = gracetime;
1662                 }
1663
1664                 attr = info->attrs[NFSD_A_SERVER_LEASETIME];
1665                 if (attr) {
1666                         u32 leasetime = nla_get_u32(attr);
1667
1668                         if (leasetime < 10 || leasetime > 3600)
1669                                 goto out_unlock;
1670
1671                         nn->nfsd4_lease = leasetime;
1672                 }
1673
1674                 attr = info->attrs[NFSD_A_SERVER_SCOPE];
1675                 if (attr)
1676                         scope = nla_data(attr);
1677         }
1678
1679         ret = nfsd_svc(nrpools, nthreads, net, get_current_cred(), scope);
1680         if (ret > 0)
1681                 ret = 0;
1682 out_unlock:
1683         mutex_unlock(&nfsd_mutex);
1684         kfree(nthreads);
1685         return ret;
1686 }
1687
1688 /**
1689  * nfsd_nl_threads_get_doit - get the number of running threads
1690  * @skb: reply buffer
1691  * @info: netlink metadata and command arguments
1692  *
1693  * Return 0 on success or a negative errno.
1694  */
1695 int nfsd_nl_threads_get_doit(struct sk_buff *skb, struct genl_info *info)
1696 {
1697         struct net *net = genl_info_net(info);
1698         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1699         void *hdr;
1700         int err;
1701
1702         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
1703         if (!skb)
1704                 return -ENOMEM;
1705
1706         hdr = genlmsg_iput(skb, info);
1707         if (!hdr) {
1708                 err = -EMSGSIZE;
1709                 goto err_free_msg;
1710         }
1711
1712         mutex_lock(&nfsd_mutex);
1713
1714         err = nla_put_u32(skb, NFSD_A_SERVER_GRACETIME,
1715                           nn->nfsd4_grace) ||
1716               nla_put_u32(skb, NFSD_A_SERVER_LEASETIME,
1717                           nn->nfsd4_lease) ||
1718               nla_put_string(skb, NFSD_A_SERVER_SCOPE,
1719                           nn->nfsd_name);
1720         if (err)
1721                 goto err_unlock;
1722
1723         if (nn->nfsd_serv) {
1724                 int i;
1725
1726                 for (i = 0; i < nfsd_nrpools(net); ++i) {
1727                         struct svc_pool *sp = &nn->nfsd_serv->sv_pools[i];
1728
1729                         err = nla_put_u32(skb, NFSD_A_SERVER_THREADS,
1730                                           sp->sp_nrthreads);
1731                         if (err)
1732                                 goto err_unlock;
1733                 }
1734         } else {
1735                 err = nla_put_u32(skb, NFSD_A_SERVER_THREADS, 0);
1736                 if (err)
1737                         goto err_unlock;
1738         }
1739
1740         mutex_unlock(&nfsd_mutex);
1741
1742         genlmsg_end(skb, hdr);
1743
1744         return genlmsg_reply(skb, info);
1745
1746 err_unlock:
1747         mutex_unlock(&nfsd_mutex);
1748 err_free_msg:
1749         nlmsg_free(skb);
1750
1751         return err;
1752 }
1753
1754 /**
1755  * nfsd_nl_version_set_doit - set the nfs enabled versions
1756  * @skb: reply buffer
1757  * @info: netlink metadata and command arguments
1758  *
1759  * Return 0 on success or a negative errno.
1760  */
1761 int nfsd_nl_version_set_doit(struct sk_buff *skb, struct genl_info *info)
1762 {
1763         const struct nlattr *attr;
1764         struct nfsd_net *nn;
1765         int i, rem;
1766
1767         if (GENL_REQ_ATTR_CHECK(info, NFSD_A_SERVER_PROTO_VERSION))
1768                 return -EINVAL;
1769
1770         mutex_lock(&nfsd_mutex);
1771
1772         nn = net_generic(genl_info_net(info), nfsd_net_id);
1773         if (nn->nfsd_serv) {
1774                 mutex_unlock(&nfsd_mutex);
1775                 return -EBUSY;
1776         }
1777
1778         /* clear current supported versions. */
1779         nfsd_vers(nn, 2, NFSD_CLEAR);
1780         nfsd_vers(nn, 3, NFSD_CLEAR);
1781         for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++)
1782                 nfsd_minorversion(nn, i, NFSD_CLEAR);
1783
1784         nlmsg_for_each_attr(attr, info->nlhdr, GENL_HDRLEN, rem) {
1785                 struct nlattr *tb[NFSD_A_VERSION_MAX + 1];
1786                 u32 major, minor = 0;
1787                 bool enabled;
1788
1789                 if (nla_type(attr) != NFSD_A_SERVER_PROTO_VERSION)
1790                         continue;
1791
1792                 if (nla_parse_nested(tb, NFSD_A_VERSION_MAX, attr,
1793                                      nfsd_version_nl_policy, info->extack) < 0)
1794                         continue;
1795
1796                 if (!tb[NFSD_A_VERSION_MAJOR])
1797                         continue;
1798
1799                 major = nla_get_u32(tb[NFSD_A_VERSION_MAJOR]);
1800                 if (tb[NFSD_A_VERSION_MINOR])
1801                         minor = nla_get_u32(tb[NFSD_A_VERSION_MINOR]);
1802
1803                 enabled = nla_get_flag(tb[NFSD_A_VERSION_ENABLED]);
1804
1805                 switch (major) {
1806                 case 4:
1807                         nfsd_minorversion(nn, minor, enabled ? NFSD_SET : NFSD_CLEAR);
1808                         break;
1809                 case 3:
1810                 case 2:
1811                         if (!minor)
1812                                 nfsd_vers(nn, major, enabled ? NFSD_SET : NFSD_CLEAR);
1813                         break;
1814                 default:
1815                         break;
1816                 }
1817         }
1818
1819         mutex_unlock(&nfsd_mutex);
1820
1821         return 0;
1822 }
1823
1824 /**
1825  * nfsd_nl_version_get_doit - get the enabled status for all supported nfs versions
1826  * @skb: reply buffer
1827  * @info: netlink metadata and command arguments
1828  *
1829  * Return 0 on success or a negative errno.
1830  */
1831 int nfsd_nl_version_get_doit(struct sk_buff *skb, struct genl_info *info)
1832 {
1833         struct nfsd_net *nn;
1834         int i, err;
1835         void *hdr;
1836
1837         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
1838         if (!skb)
1839                 return -ENOMEM;
1840
1841         hdr = genlmsg_iput(skb, info);
1842         if (!hdr) {
1843                 err = -EMSGSIZE;
1844                 goto err_free_msg;
1845         }
1846
1847         mutex_lock(&nfsd_mutex);
1848         nn = net_generic(genl_info_net(info), nfsd_net_id);
1849
1850         for (i = 2; i <= 4; i++) {
1851                 int j;
1852
1853                 for (j = 0; j <= NFSD_SUPPORTED_MINOR_VERSION; j++) {
1854                         struct nlattr *attr;
1855
1856                         /* Don't record any versions the kernel doesn't have
1857                          * compiled in
1858                          */
1859                         if (!nfsd_support_version(i))
1860                                 continue;
1861
1862                         /* NFSv{2,3} does not support minor numbers */
1863                         if (i < 4 && j)
1864                                 continue;
1865
1866                         attr = nla_nest_start(skb,
1867                                               NFSD_A_SERVER_PROTO_VERSION);
1868                         if (!attr) {
1869                                 err = -EINVAL;
1870                                 goto err_nfsd_unlock;
1871                         }
1872
1873                         if (nla_put_u32(skb, NFSD_A_VERSION_MAJOR, i) ||
1874                             nla_put_u32(skb, NFSD_A_VERSION_MINOR, j)) {
1875                                 err = -EINVAL;
1876                                 goto err_nfsd_unlock;
1877                         }
1878
1879                         /* Set the enabled flag if the version is enabled */
1880                         if (nfsd_vers(nn, i, NFSD_TEST) &&
1881                             (i < 4 || nfsd_minorversion(nn, j, NFSD_TEST)) &&
1882                             nla_put_flag(skb, NFSD_A_VERSION_ENABLED)) {
1883                                 err = -EINVAL;
1884                                 goto err_nfsd_unlock;
1885                         }
1886
1887                         nla_nest_end(skb, attr);
1888                 }
1889         }
1890
1891         mutex_unlock(&nfsd_mutex);
1892         genlmsg_end(skb, hdr);
1893
1894         return genlmsg_reply(skb, info);
1895
1896 err_nfsd_unlock:
1897         mutex_unlock(&nfsd_mutex);
1898 err_free_msg:
1899         nlmsg_free(skb);
1900
1901         return err;
1902 }
1903
1904 /**
1905  * nfsd_nl_listener_set_doit - set the nfs running sockets
1906  * @skb: reply buffer
1907  * @info: netlink metadata and command arguments
1908  *
1909  * Return 0 on success or a negative errno.
1910  */
1911 int nfsd_nl_listener_set_doit(struct sk_buff *skb, struct genl_info *info)
1912 {
1913         struct net *net = genl_info_net(info);
1914         struct svc_xprt *xprt, *tmp;
1915         const struct nlattr *attr;
1916         struct svc_serv *serv;
1917         LIST_HEAD(permsocks);
1918         struct nfsd_net *nn;
1919         bool delete = false;
1920         int err, rem;
1921
1922         mutex_lock(&nfsd_mutex);
1923
1924         err = nfsd_create_serv(net);
1925         if (err) {
1926                 mutex_unlock(&nfsd_mutex);
1927                 return err;
1928         }
1929
1930         nn = net_generic(net, nfsd_net_id);
1931         serv = nn->nfsd_serv;
1932
1933         spin_lock_bh(&serv->sv_lock);
1934
1935         /* Move all of the old listener sockets to a temp list */
1936         list_splice_init(&serv->sv_permsocks, &permsocks);
1937
1938         /*
1939          * Walk the list of server_socks from userland and move any that match
1940          * back to sv_permsocks
1941          */
1942         nlmsg_for_each_attr(attr, info->nlhdr, GENL_HDRLEN, rem) {
1943                 struct nlattr *tb[NFSD_A_SOCK_MAX + 1];
1944                 const char *xcl_name;
1945                 struct sockaddr *sa;
1946
1947                 if (nla_type(attr) != NFSD_A_SERVER_SOCK_ADDR)
1948                         continue;
1949
1950                 if (nla_parse_nested(tb, NFSD_A_SOCK_MAX, attr,
1951                                      nfsd_sock_nl_policy, info->extack) < 0)
1952                         continue;
1953
1954                 if (!tb[NFSD_A_SOCK_ADDR] || !tb[NFSD_A_SOCK_TRANSPORT_NAME])
1955                         continue;
1956
1957                 if (nla_len(tb[NFSD_A_SOCK_ADDR]) < sizeof(*sa))
1958                         continue;
1959
1960                 xcl_name = nla_data(tb[NFSD_A_SOCK_TRANSPORT_NAME]);
1961                 sa = nla_data(tb[NFSD_A_SOCK_ADDR]);
1962
1963                 /* Put back any matching sockets */
1964                 list_for_each_entry_safe(xprt, tmp, &permsocks, xpt_list) {
1965                         /* This shouldn't be possible */
1966                         if (WARN_ON_ONCE(xprt->xpt_net != net)) {
1967                                 list_move(&xprt->xpt_list, &serv->sv_permsocks);
1968                                 continue;
1969                         }
1970
1971                         /* If everything matches, put it back */
1972                         if (!strcmp(xprt->xpt_class->xcl_name, xcl_name) &&
1973                             rpc_cmp_addr_port(sa, (struct sockaddr *)&xprt->xpt_local)) {
1974                                 list_move(&xprt->xpt_list, &serv->sv_permsocks);
1975                                 break;
1976                         }
1977                 }
1978         }
1979
1980         /*
1981          * If there are listener transports remaining on the permsocks list,
1982          * it means we were asked to remove a listener.
1983          */
1984         if (!list_empty(&permsocks)) {
1985                 list_splice_init(&permsocks, &serv->sv_permsocks);
1986                 delete = true;
1987         }
1988         spin_unlock_bh(&serv->sv_lock);
1989
1990         /* Do not remove listeners while there are active threads. */
1991         if (serv->sv_nrthreads) {
1992                 err = -EBUSY;
1993                 goto out_unlock_mtx;
1994         }
1995
1996         /*
1997          * Since we can't delete an arbitrary llist entry, destroy the
1998          * remaining listeners and recreate the list.
1999          */
2000         if (delete)
2001                 svc_xprt_destroy_all(serv, net);
2002
2003         /* walk list of addrs again, open any that still don't exist */
2004         nlmsg_for_each_attr(attr, info->nlhdr, GENL_HDRLEN, rem) {
2005                 struct nlattr *tb[NFSD_A_SOCK_MAX + 1];
2006                 const char *xcl_name;
2007                 struct sockaddr *sa;
2008                 int ret;
2009
2010                 if (nla_type(attr) != NFSD_A_SERVER_SOCK_ADDR)
2011                         continue;
2012
2013                 if (nla_parse_nested(tb, NFSD_A_SOCK_MAX, attr,
2014                                      nfsd_sock_nl_policy, info->extack) < 0)
2015                         continue;
2016
2017                 if (!tb[NFSD_A_SOCK_ADDR] || !tb[NFSD_A_SOCK_TRANSPORT_NAME])
2018                         continue;
2019
2020                 if (nla_len(tb[NFSD_A_SOCK_ADDR]) < sizeof(*sa))
2021                         continue;
2022
2023                 xcl_name = nla_data(tb[NFSD_A_SOCK_TRANSPORT_NAME]);
2024                 sa = nla_data(tb[NFSD_A_SOCK_ADDR]);
2025
2026                 xprt = svc_find_listener(serv, xcl_name, net, sa);
2027                 if (xprt) {
2028                         if (delete)
2029                                 WARN_ONCE(1, "Transport type=%s already exists\n",
2030                                           xcl_name);
2031                         svc_xprt_put(xprt);
2032                         continue;
2033                 }
2034
2035                 ret = svc_xprt_create_from_sa(serv, xcl_name, net, sa, 0,
2036                                               get_current_cred());
2037                 /* always save the latest error */
2038                 if (ret < 0)
2039                         err = ret;
2040         }
2041
2042         if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks))
2043                 nfsd_destroy_serv(net);
2044
2045 out_unlock_mtx:
2046         mutex_unlock(&nfsd_mutex);
2047
2048         return err;
2049 }
2050
2051 /**
2052  * nfsd_nl_listener_get_doit - get the nfs running listeners
2053  * @skb: reply buffer
2054  * @info: netlink metadata and command arguments
2055  *
2056  * Return 0 on success or a negative errno.
2057  */
2058 int nfsd_nl_listener_get_doit(struct sk_buff *skb, struct genl_info *info)
2059 {
2060         struct svc_xprt *xprt;
2061         struct svc_serv *serv;
2062         struct nfsd_net *nn;
2063         void *hdr;
2064         int err;
2065
2066         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2067         if (!skb)
2068                 return -ENOMEM;
2069
2070         hdr = genlmsg_iput(skb, info);
2071         if (!hdr) {
2072                 err = -EMSGSIZE;
2073                 goto err_free_msg;
2074         }
2075
2076         mutex_lock(&nfsd_mutex);
2077         nn = net_generic(genl_info_net(info), nfsd_net_id);
2078
2079         /* no nfs server? Just send empty socket list */
2080         if (!nn->nfsd_serv)
2081                 goto out_unlock_mtx;
2082
2083         serv = nn->nfsd_serv;
2084         spin_lock_bh(&serv->sv_lock);
2085         list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
2086                 struct nlattr *attr;
2087
2088                 attr = nla_nest_start(skb, NFSD_A_SERVER_SOCK_ADDR);
2089                 if (!attr) {
2090                         err = -EINVAL;
2091                         goto err_serv_unlock;
2092                 }
2093
2094                 if (nla_put_string(skb, NFSD_A_SOCK_TRANSPORT_NAME,
2095                                    xprt->xpt_class->xcl_name) ||
2096                     nla_put(skb, NFSD_A_SOCK_ADDR,
2097                             sizeof(struct sockaddr_storage),
2098                             &xprt->xpt_local)) {
2099                         err = -EINVAL;
2100                         goto err_serv_unlock;
2101                 }
2102
2103                 nla_nest_end(skb, attr);
2104         }
2105         spin_unlock_bh(&serv->sv_lock);
2106 out_unlock_mtx:
2107         mutex_unlock(&nfsd_mutex);
2108         genlmsg_end(skb, hdr);
2109
2110         return genlmsg_reply(skb, info);
2111
2112 err_serv_unlock:
2113         spin_unlock_bh(&serv->sv_lock);
2114         mutex_unlock(&nfsd_mutex);
2115 err_free_msg:
2116         nlmsg_free(skb);
2117
2118         return err;
2119 }
2120
2121 /**
2122  * nfsd_nl_pool_mode_set_doit - set the number of running threads
2123  * @skb: reply buffer
2124  * @info: netlink metadata and command arguments
2125  *
2126  * Return 0 on success or a negative errno.
2127  */
2128 int nfsd_nl_pool_mode_set_doit(struct sk_buff *skb, struct genl_info *info)
2129 {
2130         const struct nlattr *attr;
2131
2132         if (GENL_REQ_ATTR_CHECK(info, NFSD_A_POOL_MODE_MODE))
2133                 return -EINVAL;
2134
2135         attr = info->attrs[NFSD_A_POOL_MODE_MODE];
2136         return sunrpc_set_pool_mode(nla_data(attr));
2137 }
2138
2139 /**
2140  * nfsd_nl_pool_mode_get_doit - get info about pool_mode
2141  * @skb: reply buffer
2142  * @info: netlink metadata and command arguments
2143  *
2144  * Return 0 on success or a negative errno.
2145  */
2146 int nfsd_nl_pool_mode_get_doit(struct sk_buff *skb, struct genl_info *info)
2147 {
2148         struct net *net = genl_info_net(info);
2149         char buf[16];
2150         void *hdr;
2151         int err;
2152
2153         if (sunrpc_get_pool_mode(buf, ARRAY_SIZE(buf)) >= ARRAY_SIZE(buf))
2154                 return -ERANGE;
2155
2156         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2157         if (!skb)
2158                 return -ENOMEM;
2159
2160         err = -EMSGSIZE;
2161         hdr = genlmsg_iput(skb, info);
2162         if (!hdr)
2163                 goto err_free_msg;
2164
2165         err = nla_put_string(skb, NFSD_A_POOL_MODE_MODE, buf) |
2166               nla_put_u32(skb, NFSD_A_POOL_MODE_NPOOLS, nfsd_nrpools(net));
2167         if (err)
2168                 goto err_free_msg;
2169
2170         genlmsg_end(skb, hdr);
2171         return genlmsg_reply(skb, info);
2172
2173 err_free_msg:
2174         nlmsg_free(skb);
2175         return err;
2176 }
2177
2178 /**
2179  * nfsd_net_init - Prepare the nfsd_net portion of a new net namespace
2180  * @net: a freshly-created network namespace
2181  *
2182  * This information stays around as long as the network namespace is
2183  * alive whether or not there is an NFSD instance running in the
2184  * namespace.
2185  *
2186  * Returns zero on success, or a negative errno otherwise.
2187  */
2188 static __net_init int nfsd_net_init(struct net *net)
2189 {
2190         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2191         int retval;
2192         int i;
2193
2194         retval = nfsd_export_init(net);
2195         if (retval)
2196                 goto out_export_error;
2197         retval = nfsd_idmap_init(net);
2198         if (retval)
2199                 goto out_idmap_error;
2200         retval = percpu_counter_init_many(nn->counter, 0, GFP_KERNEL,
2201                                           NFSD_STATS_COUNTERS_NUM);
2202         if (retval)
2203                 goto out_repcache_error;
2204
2205         memset(&nn->nfsd_svcstats, 0, sizeof(nn->nfsd_svcstats));
2206         nn->nfsd_svcstats.program = &nfsd_programs[0];
2207         if (!nfsd_proc_stat_init(net)) {
2208                 retval = -ENOMEM;
2209                 goto out_proc_error;
2210         }
2211
2212         for (i = 0; i < sizeof(nn->nfsd_versions); i++)
2213                 nn->nfsd_versions[i] = nfsd_support_version(i);
2214         for (i = 0; i < sizeof(nn->nfsd4_minorversions); i++)
2215                 nn->nfsd4_minorversions[i] = nfsd_support_version(4);
2216         nn->nfsd_info.mutex = &nfsd_mutex;
2217         nn->nfsd_serv = NULL;
2218         nfsd4_init_leases_net(nn);
2219         get_random_bytes(&nn->siphash_key, sizeof(nn->siphash_key));
2220         seqlock_init(&nn->writeverf_lock);
2221 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
2222         spin_lock_init(&nn->local_clients_lock);
2223         INIT_LIST_HEAD(&nn->local_clients);
2224 #endif
2225         return 0;
2226
2227 out_proc_error:
2228         percpu_counter_destroy_many(nn->counter, NFSD_STATS_COUNTERS_NUM);
2229 out_repcache_error:
2230         nfsd_idmap_shutdown(net);
2231 out_idmap_error:
2232         nfsd_export_shutdown(net);
2233 out_export_error:
2234         return retval;
2235 }
2236
2237 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
2238 /**
2239  * nfsd_net_pre_exit - Disconnect localio clients from net namespace
2240  * @net: a network namespace that is about to be destroyed
2241  *
2242  * This invalidates ->net pointers held by localio clients
2243  * while they can still safely access nn->counter.
2244  */
2245 static __net_exit void nfsd_net_pre_exit(struct net *net)
2246 {
2247         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2248
2249         nfs_localio_invalidate_clients(&nn->local_clients,
2250                                        &nn->local_clients_lock);
2251 }
2252 #endif
2253
2254 /**
2255  * nfsd_net_exit - Release the nfsd_net portion of a net namespace
2256  * @net: a network namespace that is about to be destroyed
2257  *
2258  */
2259 static __net_exit void nfsd_net_exit(struct net *net)
2260 {
2261         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2262
2263         nfsd_proc_stat_shutdown(net);
2264         percpu_counter_destroy_many(nn->counter, NFSD_STATS_COUNTERS_NUM);
2265         nfsd_idmap_shutdown(net);
2266         nfsd_export_shutdown(net);
2267 }
2268
2269 static struct pernet_operations nfsd_net_ops = {
2270         .init = nfsd_net_init,
2271 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
2272         .pre_exit = nfsd_net_pre_exit,
2273 #endif
2274         .exit = nfsd_net_exit,
2275         .id   = &nfsd_net_id,
2276         .size = sizeof(struct nfsd_net),
2277 };
2278
2279 static int __init init_nfsd(void)
2280 {
2281         int retval;
2282
2283         nfsd_debugfs_init();
2284
2285         retval = nfsd4_init_slabs();
2286         if (retval)
2287                 return retval;
2288         retval = nfsd4_init_pnfs();
2289         if (retval)
2290                 goto out_free_slabs;
2291         retval = nfsd_drc_slab_create();
2292         if (retval)
2293                 goto out_free_pnfs;
2294         nfsd_lockd_init();      /* lockd->nfsd callbacks */
2295         retval = register_pernet_subsys(&nfsd_net_ops);
2296         if (retval < 0)
2297                 goto out_free_lockd;
2298         retval = register_cld_notifier();
2299         if (retval)
2300                 goto out_free_subsys;
2301         retval = nfsd4_create_laundry_wq();
2302         if (retval)
2303                 goto out_free_cld;
2304         retval = register_filesystem(&nfsd_fs_type);
2305         if (retval)
2306                 goto out_free_nfsd4;
2307         retval = genl_register_family(&nfsd_nl_family);
2308         if (retval)
2309                 goto out_free_filesystem;
2310         retval = create_proc_exports_entry();
2311         if (retval)
2312                 goto out_free_all;
2313         nfsd_localio_ops_init();
2314
2315         return 0;
2316 out_free_all:
2317         genl_unregister_family(&nfsd_nl_family);
2318 out_free_filesystem:
2319         unregister_filesystem(&nfsd_fs_type);
2320 out_free_nfsd4:
2321         nfsd4_destroy_laundry_wq();
2322 out_free_cld:
2323         unregister_cld_notifier();
2324 out_free_subsys:
2325         unregister_pernet_subsys(&nfsd_net_ops);
2326 out_free_lockd:
2327         nfsd_lockd_shutdown();
2328         nfsd_drc_slab_free();
2329 out_free_pnfs:
2330         nfsd4_exit_pnfs();
2331 out_free_slabs:
2332         nfsd4_free_slabs();
2333         nfsd_debugfs_exit();
2334         return retval;
2335 }
2336
2337 static void __exit exit_nfsd(void)
2338 {
2339         remove_proc_entry("fs/nfs/exports", NULL);
2340         remove_proc_entry("fs/nfs", NULL);
2341         genl_unregister_family(&nfsd_nl_family);
2342         unregister_filesystem(&nfsd_fs_type);
2343         nfsd4_destroy_laundry_wq();
2344         unregister_cld_notifier();
2345         unregister_pernet_subsys(&nfsd_net_ops);
2346         nfsd_drc_slab_free();
2347         nfsd_lockd_shutdown();
2348         nfsd4_free_slabs();
2349         nfsd4_exit_pnfs();
2350         nfsd_debugfs_exit();
2351 }
2352
2353 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2354 MODULE_DESCRIPTION("In-kernel NFS server");
2355 MODULE_LICENSE("GPL");
2356 module_init(init_nfsd)
2357 module_exit(exit_nfsd)