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/gss_krb5_enctypes.h> 18 #include <linux/sunrpc/rpc_pipe_fs.h> 19 #include <linux/module.h> 20 #include <linux/fsnotify.h> 21 22 #include "idmap.h" 23 #include "nfsd.h" 24 #include "cache.h" 25 #include "state.h" 26 #include "netns.h" 27 #include "pnfs.h" 28 29 /* 30 * We have a single directory with several nodes in it. 31 */ 32 enum { 33 NFSD_Root = 1, 34 NFSD_List, 35 NFSD_Export_features, 36 NFSD_Fh, 37 NFSD_FO_UnlockIP, 38 NFSD_FO_UnlockFS, 39 NFSD_Threads, 40 NFSD_Pool_Threads, 41 NFSD_Pool_Stats, 42 NFSD_Reply_Cache_Stats, 43 NFSD_Versions, 44 NFSD_Ports, 45 NFSD_MaxBlkSize, 46 NFSD_MaxConnections, 47 NFSD_SupportedEnctypes, 48 /* 49 * The below MUST come last. Otherwise we leave a hole in nfsd_files[] 50 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops 51 */ 52 #ifdef CONFIG_NFSD_V4 53 NFSD_Leasetime, 54 NFSD_Gracetime, 55 NFSD_RecoveryDir, 56 NFSD_V4EndGrace, 57 #endif 58 NFSD_MaxReserved 59 }; 60 61 /* 62 * write() for these nodes. 63 */ 64 static ssize_t write_filehandle(struct file *file, char *buf, size_t size); 65 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size); 66 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size); 67 static ssize_t write_threads(struct file *file, char *buf, size_t size); 68 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size); 69 static ssize_t write_versions(struct file *file, char *buf, size_t size); 70 static ssize_t write_ports(struct file *file, char *buf, size_t size); 71 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size); 72 static ssize_t write_maxconn(struct file *file, char *buf, size_t size); 73 #ifdef CONFIG_NFSD_V4 74 static ssize_t write_leasetime(struct file *file, char *buf, size_t size); 75 static ssize_t write_gracetime(struct file *file, char *buf, size_t size); 76 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size); 77 static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size); 78 #endif 79 80 static ssize_t (*const write_op[])(struct file *, char *, size_t) = { 81 [NFSD_Fh] = write_filehandle, 82 [NFSD_FO_UnlockIP] = write_unlock_ip, 83 [NFSD_FO_UnlockFS] = write_unlock_fs, 84 [NFSD_Threads] = write_threads, 85 [NFSD_Pool_Threads] = write_pool_threads, 86 [NFSD_Versions] = write_versions, 87 [NFSD_Ports] = write_ports, 88 [NFSD_MaxBlkSize] = write_maxblksize, 89 [NFSD_MaxConnections] = write_maxconn, 90 #ifdef CONFIG_NFSD_V4 91 [NFSD_Leasetime] = write_leasetime, 92 [NFSD_Gracetime] = write_gracetime, 93 [NFSD_RecoveryDir] = write_recoverydir, 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 simple_transaction_set(file, rv); 114 rv = size; 115 } 116 return rv; 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_proc_open(struct inode *inode, struct file *file) 156 { 157 return exports_net_open(current->nsproxy->net_ns, file); 158 } 159 160 static const struct file_operations exports_proc_operations = { 161 .open = exports_proc_open, 162 .read = seq_read, 163 .llseek = seq_lseek, 164 .release = seq_release, 165 }; 166 167 static int exports_nfsd_open(struct inode *inode, struct file *file) 168 { 169 return exports_net_open(inode->i_sb->s_fs_info, file); 170 } 171 172 static const struct file_operations exports_nfsd_operations = { 173 .open = exports_nfsd_open, 174 .read = seq_read, 175 .llseek = seq_lseek, 176 .release = seq_release, 177 }; 178 179 static int export_features_show(struct seq_file *m, void *v) 180 { 181 seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS); 182 return 0; 183 } 184 185 static int export_features_open(struct inode *inode, struct file *file) 186 { 187 return single_open(file, export_features_show, NULL); 188 } 189 190 static const struct file_operations export_features_operations = { 191 .open = export_features_open, 192 .read = seq_read, 193 .llseek = seq_lseek, 194 .release = single_release, 195 }; 196 197 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE) 198 static int supported_enctypes_show(struct seq_file *m, void *v) 199 { 200 seq_printf(m, KRB5_SUPPORTED_ENCTYPES); 201 return 0; 202 } 203 204 static int supported_enctypes_open(struct inode *inode, struct file *file) 205 { 206 return single_open(file, supported_enctypes_show, NULL); 207 } 208 209 static const struct file_operations supported_enctypes_ops = { 210 .open = supported_enctypes_open, 211 .read = seq_read, 212 .llseek = seq_lseek, 213 .release = single_release, 214 }; 215 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */ 216 217 static const struct file_operations pool_stats_operations = { 218 .open = nfsd_pool_stats_open, 219 .read = seq_read, 220 .llseek = seq_lseek, 221 .release = nfsd_pool_stats_release, 222 }; 223 224 static const struct file_operations reply_cache_stats_operations = { 225 .open = nfsd_reply_cache_stats_open, 226 .read = seq_read, 227 .llseek = seq_lseek, 228 .release = single_release, 229 }; 230 231 /*----------------------------------------------------------------------------*/ 232 /* 233 * payload - write methods 234 */ 235 236 static inline struct net *netns(struct file *file) 237 { 238 return file_inode(file)->i_sb->s_fs_info; 239 } 240 241 /** 242 * write_unlock_ip - Release all locks used by a client 243 * 244 * Experimental. 245 * 246 * Input: 247 * buf: '\n'-terminated C string containing a 248 * presentation format IP address 249 * size: length of C string in @buf 250 * Output: 251 * On success: returns zero if all specified locks were released; 252 * returns one if one or more locks were not released 253 * On error: return code is negative errno value 254 */ 255 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size) 256 { 257 struct sockaddr_storage address; 258 struct sockaddr *sap = (struct sockaddr *)&address; 259 size_t salen = sizeof(address); 260 char *fo_path; 261 struct net *net = netns(file); 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 274 if (rpc_pton(net, fo_path, size, sap, salen) == 0) 275 return -EINVAL; 276 277 return nlmsvc_unlock_all_by_ip(sap); 278 } 279 280 /** 281 * write_unlock_fs - Release all locks on a local file system 282 * 283 * Experimental. 284 * 285 * Input: 286 * buf: '\n'-terminated C string containing the 287 * absolute pathname of a local file system 288 * size: length of C string in @buf 289 * Output: 290 * On success: returns zero if all specified locks were released; 291 * returns one if one or more locks were not released 292 * On error: return code is negative errno value 293 */ 294 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size) 295 { 296 struct path path; 297 char *fo_path; 298 int error; 299 300 /* sanity check */ 301 if (size == 0) 302 return -EINVAL; 303 304 if (buf[size-1] != '\n') 305 return -EINVAL; 306 307 fo_path = buf; 308 if (qword_get(&buf, fo_path, size) < 0) 309 return -EINVAL; 310 311 error = kern_path(fo_path, 0, &path); 312 if (error) 313 return error; 314 315 /* 316 * XXX: Needs better sanity checking. Otherwise we could end up 317 * releasing locks on the wrong file system. 318 * 319 * For example: 320 * 1. Does the path refer to a directory? 321 * 2. Is that directory a mount point, or 322 * 3. Is that directory the root of an exported file system? 323 */ 324 error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb); 325 326 path_put(&path); 327 return error; 328 } 329 330 /** 331 * write_filehandle - Get a variable-length NFS file handle by path 332 * 333 * On input, the buffer contains a '\n'-terminated C string comprised of 334 * three alphanumeric words separated by whitespace. The string may 335 * contain escape sequences. 336 * 337 * Input: 338 * buf: 339 * domain: client domain name 340 * path: export pathname 341 * maxsize: numeric maximum size of 342 * @buf 343 * size: length of C string in @buf 344 * Output: 345 * On success: passed-in buffer filled with '\n'-terminated C 346 * string containing a ASCII hex text version 347 * of the NFS file handle; 348 * return code is the size in bytes of the string 349 * On error: return code is negative errno value 350 */ 351 static ssize_t write_filehandle(struct file *file, char *buf, size_t size) 352 { 353 char *dname, *path; 354 int uninitialized_var(maxsize); 355 char *mesg = buf; 356 int len; 357 struct auth_domain *dom; 358 struct knfsd_fh fh; 359 360 if (size == 0) 361 return -EINVAL; 362 363 if (buf[size-1] != '\n') 364 return -EINVAL; 365 buf[size-1] = 0; 366 367 dname = mesg; 368 len = qword_get(&mesg, dname, size); 369 if (len <= 0) 370 return -EINVAL; 371 372 path = dname+len+1; 373 len = qword_get(&mesg, path, size); 374 if (len <= 0) 375 return -EINVAL; 376 377 len = get_int(&mesg, &maxsize); 378 if (len) 379 return len; 380 381 if (maxsize < NFS_FHSIZE) 382 return -EINVAL; 383 maxsize = min(maxsize, NFS3_FHSIZE); 384 385 if (qword_get(&mesg, mesg, size)>0) 386 return -EINVAL; 387 388 /* we have all the words, they are in buf.. */ 389 dom = unix_domain_find(dname); 390 if (!dom) 391 return -ENOMEM; 392 393 len = exp_rootfh(netns(file), dom, path, &fh, maxsize); 394 auth_domain_put(dom); 395 if (len) 396 return len; 397 398 mesg = buf; 399 len = SIMPLE_TRANSACTION_LIMIT; 400 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size); 401 mesg[-1] = '\n'; 402 return mesg - buf; 403 } 404 405 /** 406 * write_threads - Start NFSD, or report the current number of running threads 407 * 408 * Input: 409 * buf: ignored 410 * size: zero 411 * Output: 412 * On success: passed-in buffer filled with '\n'-terminated C 413 * string numeric value representing the number of 414 * running NFSD threads; 415 * return code is the size in bytes of the string 416 * On error: return code is zero 417 * 418 * OR 419 * 420 * Input: 421 * buf: C string containing an unsigned 422 * integer value representing the 423 * number of NFSD threads to start 424 * size: non-zero length of C string in @buf 425 * Output: 426 * On success: NFS service is started; 427 * passed-in buffer filled with '\n'-terminated C 428 * string numeric value representing the number of 429 * running NFSD threads; 430 * return code is the size in bytes of the string 431 * On error: return code is zero or a negative errno value 432 */ 433 static ssize_t write_threads(struct file *file, char *buf, size_t size) 434 { 435 char *mesg = buf; 436 int rv; 437 struct net *net = netns(file); 438 439 if (size > 0) { 440 int newthreads; 441 rv = get_int(&mesg, &newthreads); 442 if (rv) 443 return rv; 444 if (newthreads < 0) 445 return -EINVAL; 446 rv = nfsd_svc(newthreads, net, file->f_cred); 447 if (rv < 0) 448 return rv; 449 } else 450 rv = nfsd_nrthreads(net); 451 452 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv); 453 } 454 455 /** 456 * write_pool_threads - Set or report the current number of threads per pool 457 * 458 * Input: 459 * buf: ignored 460 * size: zero 461 * 462 * OR 463 * 464 * Input: 465 * buf: C string containing whitespace- 466 * separated unsigned integer values 467 * representing the number of NFSD 468 * threads to start in each pool 469 * size: non-zero length of C string in @buf 470 * Output: 471 * On success: passed-in buffer filled with '\n'-terminated C 472 * string containing integer values representing the 473 * number of NFSD threads in each pool; 474 * return code is the size in bytes of the string 475 * On error: return code is zero or a negative errno value 476 */ 477 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size) 478 { 479 /* if size > 0, look for an array of number of threads per node 480 * and apply them then write out number of threads per node as reply 481 */ 482 char *mesg = buf; 483 int i; 484 int rv; 485 int len; 486 int npools; 487 int *nthreads; 488 struct net *net = netns(file); 489 490 mutex_lock(&nfsd_mutex); 491 npools = nfsd_nrpools(net); 492 if (npools == 0) { 493 /* 494 * NFS is shut down. The admin can start it by 495 * writing to the threads file but NOT the pool_threads 496 * file, sorry. Report zero threads. 497 */ 498 mutex_unlock(&nfsd_mutex); 499 strcpy(buf, "0\n"); 500 return strlen(buf); 501 } 502 503 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL); 504 rv = -ENOMEM; 505 if (nthreads == NULL) 506 goto out_free; 507 508 if (size > 0) { 509 for (i = 0; i < npools; i++) { 510 rv = get_int(&mesg, &nthreads[i]); 511 if (rv == -ENOENT) 512 break; /* fewer numbers than pools */ 513 if (rv) 514 goto out_free; /* syntax error */ 515 rv = -EINVAL; 516 if (nthreads[i] < 0) 517 goto out_free; 518 } 519 rv = nfsd_set_nrthreads(i, nthreads, net); 520 if (rv) 521 goto out_free; 522 } 523 524 rv = nfsd_get_nrthreads(npools, nthreads, net); 525 if (rv) 526 goto out_free; 527 528 mesg = buf; 529 size = SIMPLE_TRANSACTION_LIMIT; 530 for (i = 0; i < npools && size > 0; i++) { 531 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' ')); 532 len = strlen(mesg); 533 size -= len; 534 mesg += len; 535 } 536 rv = mesg - buf; 537 out_free: 538 kfree(nthreads); 539 mutex_unlock(&nfsd_mutex); 540 return rv; 541 } 542 543 static ssize_t 544 nfsd_print_version_support(struct nfsd_net *nn, char *buf, int remaining, 545 const char *sep, unsigned vers, int minor) 546 { 547 const char *format = minor < 0 ? "%s%c%u" : "%s%c%u.%u"; 548 bool supported = !!nfsd_vers(nn, vers, NFSD_TEST); 549 550 if (vers == 4 && minor >= 0 && 551 !nfsd_minorversion(nn, minor, NFSD_TEST)) 552 supported = false; 553 if (minor == 0 && supported) 554 /* 555 * special case for backward compatability. 556 * +4.0 is never reported, it is implied by 557 * +4, unless -4.0 is present. 558 */ 559 return 0; 560 return snprintf(buf, remaining, format, sep, 561 supported ? '+' : '-', vers, minor); 562 } 563 564 static ssize_t __write_versions(struct file *file, char *buf, size_t size) 565 { 566 char *mesg = buf; 567 char *vers, *minorp, sign; 568 int len, num, remaining; 569 ssize_t tlen = 0; 570 char *sep; 571 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 572 573 if (size>0) { 574 if (nn->nfsd_serv) 575 /* Cannot change versions without updating 576 * nn->nfsd_serv->sv_xdrsize, and reallocing 577 * rq_argp and rq_resp 578 */ 579 return -EBUSY; 580 if (buf[size-1] != '\n') 581 return -EINVAL; 582 buf[size-1] = 0; 583 584 vers = mesg; 585 len = qword_get(&mesg, vers, size); 586 if (len <= 0) return -EINVAL; 587 do { 588 enum vers_op cmd; 589 unsigned minor; 590 sign = *vers; 591 if (sign == '+' || sign == '-') 592 num = simple_strtol((vers+1), &minorp, 0); 593 else 594 num = simple_strtol(vers, &minorp, 0); 595 if (*minorp == '.') { 596 if (num != 4) 597 return -EINVAL; 598 if (kstrtouint(minorp+1, 0, &minor) < 0) 599 return -EINVAL; 600 } 601 602 cmd = sign == '-' ? NFSD_CLEAR : NFSD_SET; 603 switch(num) { 604 case 2: 605 case 3: 606 nfsd_vers(nn, num, cmd); 607 break; 608 case 4: 609 if (*minorp == '.') { 610 if (nfsd_minorversion(nn, minor, cmd) < 0) 611 return -EINVAL; 612 } else if ((cmd == NFSD_SET) != nfsd_vers(nn, num, NFSD_TEST)) { 613 /* 614 * Either we have +4 and no minors are enabled, 615 * or we have -4 and at least one minor is enabled. 616 * In either case, propagate 'cmd' to all minors. 617 */ 618 minor = 0; 619 while (nfsd_minorversion(nn, minor, cmd) >= 0) 620 minor++; 621 } 622 break; 623 default: 624 return -EINVAL; 625 } 626 vers += len + 1; 627 } while ((len = qword_get(&mesg, vers, size)) > 0); 628 /* If all get turned off, turn them back on, as 629 * having no versions is BAD 630 */ 631 nfsd_reset_versions(nn); 632 } 633 634 /* Now write current state into reply buffer */ 635 len = 0; 636 sep = ""; 637 remaining = SIMPLE_TRANSACTION_LIMIT; 638 for (num=2 ; num <= 4 ; num++) { 639 int minor; 640 if (!nfsd_vers(nn, num, NFSD_AVAIL)) 641 continue; 642 643 minor = -1; 644 do { 645 len = nfsd_print_version_support(nn, buf, remaining, 646 sep, num, minor); 647 if (len >= remaining) 648 goto out; 649 remaining -= len; 650 buf += len; 651 tlen += len; 652 minor++; 653 if (len) 654 sep = " "; 655 } while (num == 4 && minor <= NFSD_SUPPORTED_MINOR_VERSION); 656 } 657 out: 658 len = snprintf(buf, remaining, "\n"); 659 if (len >= remaining) 660 return -EINVAL; 661 return tlen + len; 662 } 663 664 /** 665 * write_versions - Set or report the available NFS protocol versions 666 * 667 * Input: 668 * buf: ignored 669 * size: zero 670 * Output: 671 * On success: passed-in buffer filled with '\n'-terminated C 672 * string containing positive or negative integer 673 * values representing the current status of each 674 * 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 * OR 679 * 680 * Input: 681 * buf: C string containing whitespace- 682 * separated positive or negative 683 * integer values representing NFS 684 * protocol versions to enable ("+n") 685 * or disable ("-n") 686 * size: non-zero length of C string in @buf 687 * Output: 688 * On success: status of zero or more protocol versions has 689 * been updated; passed-in buffer filled with 690 * '\n'-terminated C string containing positive 691 * or negative integer values representing the 692 * current status of each protocol version; 693 * return code is the size in bytes of the string 694 * On error: return code is zero or a negative errno value 695 */ 696 static ssize_t write_versions(struct file *file, char *buf, size_t size) 697 { 698 ssize_t rv; 699 700 mutex_lock(&nfsd_mutex); 701 rv = __write_versions(file, buf, size); 702 mutex_unlock(&nfsd_mutex); 703 return rv; 704 } 705 706 /* 707 * Zero-length write. Return a list of NFSD's current listener 708 * transports. 709 */ 710 static ssize_t __write_ports_names(char *buf, struct net *net) 711 { 712 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 713 714 if (nn->nfsd_serv == NULL) 715 return 0; 716 return svc_xprt_names(nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT); 717 } 718 719 /* 720 * A single 'fd' number was written, in which case it must be for 721 * a socket of a supported family/protocol, and we use it as an 722 * nfsd listener. 723 */ 724 static ssize_t __write_ports_addfd(char *buf, struct net *net, const struct cred *cred) 725 { 726 char *mesg = buf; 727 int fd, err; 728 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 729 730 err = get_int(&mesg, &fd); 731 if (err != 0 || fd < 0) 732 return -EINVAL; 733 734 if (svc_alien_sock(net, fd)) { 735 printk(KERN_ERR "%s: socket net is different to NFSd's one\n", __func__); 736 return -EINVAL; 737 } 738 739 err = nfsd_create_serv(net); 740 if (err != 0) 741 return err; 742 743 err = svc_addsock(nn->nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT, cred); 744 if (err < 0) { 745 nfsd_destroy(net); 746 return err; 747 } 748 749 /* Decrease the count, but don't shut down the service */ 750 nn->nfsd_serv->sv_nrthreads--; 751 return err; 752 } 753 754 /* 755 * A transport listener is added by writing it's transport name and 756 * a port number. 757 */ 758 static ssize_t __write_ports_addxprt(char *buf, struct net *net, const struct cred *cred) 759 { 760 char transport[16]; 761 struct svc_xprt *xprt; 762 int port, err; 763 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 764 765 if (sscanf(buf, "%15s %5u", transport, &port) != 2) 766 return -EINVAL; 767 768 if (port < 1 || port > USHRT_MAX) 769 return -EINVAL; 770 771 err = nfsd_create_serv(net); 772 if (err != 0) 773 return err; 774 775 err = svc_create_xprt(nn->nfsd_serv, transport, net, 776 PF_INET, port, SVC_SOCK_ANONYMOUS, cred); 777 if (err < 0) 778 goto out_err; 779 780 err = svc_create_xprt(nn->nfsd_serv, transport, net, 781 PF_INET6, port, SVC_SOCK_ANONYMOUS, cred); 782 if (err < 0 && err != -EAFNOSUPPORT) 783 goto out_close; 784 785 /* Decrease the count, but don't shut down the service */ 786 nn->nfsd_serv->sv_nrthreads--; 787 return 0; 788 out_close: 789 xprt = svc_find_xprt(nn->nfsd_serv, transport, net, PF_INET, port); 790 if (xprt != NULL) { 791 svc_close_xprt(xprt); 792 svc_xprt_put(xprt); 793 } 794 out_err: 795 nfsd_destroy(net); 796 return err; 797 } 798 799 static ssize_t __write_ports(struct file *file, char *buf, size_t size, 800 struct net *net) 801 { 802 if (size == 0) 803 return __write_ports_names(buf, net); 804 805 if (isdigit(buf[0])) 806 return __write_ports_addfd(buf, net, file->f_cred); 807 808 if (isalpha(buf[0])) 809 return __write_ports_addxprt(buf, net, file->f_cred); 810 811 return -EINVAL; 812 } 813 814 /** 815 * write_ports - Pass a socket file descriptor or transport name to listen on 816 * 817 * Input: 818 * buf: ignored 819 * size: zero 820 * Output: 821 * On success: passed-in buffer filled with a '\n'-terminated C 822 * string containing a whitespace-separated list of 823 * named NFSD listeners; 824 * return code is the size in bytes of the string 825 * On error: return code is zero or a negative errno value 826 * 827 * OR 828 * 829 * Input: 830 * buf: C string containing an unsigned 831 * integer value representing a bound 832 * but unconnected socket that is to be 833 * used as an NFSD listener; listen(3) 834 * must be called for a SOCK_STREAM 835 * socket, otherwise it is ignored 836 * size: non-zero length of C string in @buf 837 * Output: 838 * On success: NFS service is started; 839 * passed-in buffer filled with a '\n'-terminated C 840 * string containing a unique alphanumeric name of 841 * the listener; 842 * return code is the size in bytes of the string 843 * On error: return code is a negative errno value 844 * 845 * OR 846 * 847 * Input: 848 * buf: C string containing a transport 849 * name and an unsigned integer value 850 * representing the port to listen on, 851 * separated by whitespace 852 * size: non-zero length of C string in @buf 853 * Output: 854 * On success: returns zero; NFS service is started 855 * On error: return code is a negative errno value 856 */ 857 static ssize_t write_ports(struct file *file, char *buf, size_t size) 858 { 859 ssize_t rv; 860 861 mutex_lock(&nfsd_mutex); 862 rv = __write_ports(file, buf, size, netns(file)); 863 mutex_unlock(&nfsd_mutex); 864 return rv; 865 } 866 867 868 int nfsd_max_blksize; 869 870 /** 871 * write_maxblksize - Set or report the current NFS blksize 872 * 873 * Input: 874 * buf: ignored 875 * size: zero 876 * 877 * OR 878 * 879 * Input: 880 * buf: C string containing an unsigned 881 * integer value representing the new 882 * NFS blksize 883 * size: non-zero length of C string in @buf 884 * Output: 885 * On success: passed-in buffer filled with '\n'-terminated C string 886 * containing numeric value of the current NFS blksize 887 * setting; 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 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size) 892 { 893 char *mesg = buf; 894 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 895 896 if (size > 0) { 897 int bsize; 898 int rv = get_int(&mesg, &bsize); 899 if (rv) 900 return rv; 901 /* force bsize into allowed range and 902 * required alignment. 903 */ 904 bsize = max_t(int, bsize, 1024); 905 bsize = min_t(int, bsize, NFSSVC_MAXBLKSIZE); 906 bsize &= ~(1024-1); 907 mutex_lock(&nfsd_mutex); 908 if (nn->nfsd_serv) { 909 mutex_unlock(&nfsd_mutex); 910 return -EBUSY; 911 } 912 nfsd_max_blksize = bsize; 913 mutex_unlock(&nfsd_mutex); 914 } 915 916 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", 917 nfsd_max_blksize); 918 } 919 920 /** 921 * write_maxconn - Set or report the current max number of connections 922 * 923 * Input: 924 * buf: ignored 925 * size: zero 926 * OR 927 * 928 * Input: 929 * buf: C string containing an unsigned 930 * integer value representing the new 931 * number of max connections 932 * size: non-zero length of C string in @buf 933 * Output: 934 * On success: passed-in buffer filled with '\n'-terminated C string 935 * containing numeric value of max_connections setting 936 * for this net namespace; 937 * return code is the size in bytes of the string 938 * On error: return code is zero or a negative errno value 939 */ 940 static ssize_t write_maxconn(struct file *file, char *buf, size_t size) 941 { 942 char *mesg = buf; 943 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 944 unsigned int maxconn = nn->max_connections; 945 946 if (size > 0) { 947 int rv = get_uint(&mesg, &maxconn); 948 949 if (rv) 950 return rv; 951 nn->max_connections = maxconn; 952 } 953 954 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%u\n", maxconn); 955 } 956 957 #ifdef CONFIG_NFSD_V4 958 static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size, 959 time_t *time, struct nfsd_net *nn) 960 { 961 char *mesg = buf; 962 int rv, i; 963 964 if (size > 0) { 965 if (nn->nfsd_serv) 966 return -EBUSY; 967 rv = get_int(&mesg, &i); 968 if (rv) 969 return rv; 970 /* 971 * Some sanity checking. We don't have a reason for 972 * these particular numbers, but problems with the 973 * extremes are: 974 * - Too short: the briefest network outage may 975 * cause clients to lose all their locks. Also, 976 * the frequent polling may be wasteful. 977 * - Too long: do you really want reboot recovery 978 * to take more than an hour? Or to make other 979 * clients wait an hour before being able to 980 * revoke a dead client's locks? 981 */ 982 if (i < 10 || i > 3600) 983 return -EINVAL; 984 *time = i; 985 } 986 987 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time); 988 } 989 990 static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, 991 time_t *time, struct nfsd_net *nn) 992 { 993 ssize_t rv; 994 995 mutex_lock(&nfsd_mutex); 996 rv = __nfsd4_write_time(file, buf, size, time, nn); 997 mutex_unlock(&nfsd_mutex); 998 return rv; 999 } 1000 1001 /** 1002 * write_leasetime - Set or report the current NFSv4 lease time 1003 * 1004 * Input: 1005 * buf: ignored 1006 * size: zero 1007 * 1008 * OR 1009 * 1010 * Input: 1011 * buf: C string containing an unsigned 1012 * integer value representing the new 1013 * NFSv4 lease expiry time 1014 * size: non-zero length of C string in @buf 1015 * Output: 1016 * On success: passed-in buffer filled with '\n'-terminated C 1017 * string containing unsigned integer value of the 1018 * current lease expiry time; 1019 * return code is the size in bytes of the string 1020 * On error: return code is zero or a negative errno value 1021 */ 1022 static ssize_t write_leasetime(struct file *file, char *buf, size_t size) 1023 { 1024 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 1025 return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn); 1026 } 1027 1028 /** 1029 * write_gracetime - Set or report current NFSv4 grace period time 1030 * 1031 * As above, but sets the time of the NFSv4 grace period. 1032 * 1033 * Note this should never be set to less than the *previous* 1034 * lease-period time, but we don't try to enforce this. (In the common 1035 * case (a new boot), we don't know what the previous lease time was 1036 * anyway.) 1037 */ 1038 static ssize_t write_gracetime(struct file *file, char *buf, size_t size) 1039 { 1040 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 1041 return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn); 1042 } 1043 1044 static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size, 1045 struct nfsd_net *nn) 1046 { 1047 char *mesg = buf; 1048 char *recdir; 1049 int len, status; 1050 1051 if (size > 0) { 1052 if (nn->nfsd_serv) 1053 return -EBUSY; 1054 if (size > PATH_MAX || buf[size-1] != '\n') 1055 return -EINVAL; 1056 buf[size-1] = 0; 1057 1058 recdir = mesg; 1059 len = qword_get(&mesg, recdir, size); 1060 if (len <= 0) 1061 return -EINVAL; 1062 1063 status = nfs4_reset_recoverydir(recdir); 1064 if (status) 1065 return status; 1066 } 1067 1068 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n", 1069 nfs4_recoverydir()); 1070 } 1071 1072 /** 1073 * write_recoverydir - Set or report the pathname of the recovery directory 1074 * 1075 * Input: 1076 * buf: ignored 1077 * size: zero 1078 * 1079 * OR 1080 * 1081 * Input: 1082 * buf: C string containing the pathname 1083 * of the directory on a local file 1084 * system containing permanent NFSv4 1085 * recovery data 1086 * size: non-zero length of C string in @buf 1087 * Output: 1088 * On success: passed-in buffer filled with '\n'-terminated C string 1089 * containing the current recovery pathname setting; 1090 * return code is the size in bytes of the string 1091 * On error: return code is zero or a negative errno value 1092 */ 1093 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size) 1094 { 1095 ssize_t rv; 1096 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 1097 1098 mutex_lock(&nfsd_mutex); 1099 rv = __write_recoverydir(file, buf, size, nn); 1100 mutex_unlock(&nfsd_mutex); 1101 return rv; 1102 } 1103 1104 /** 1105 * write_v4_end_grace - release grace period for nfsd's v4.x lock manager 1106 * 1107 * Input: 1108 * buf: ignored 1109 * size: zero 1110 * OR 1111 * 1112 * Input: 1113 * buf: any value 1114 * size: non-zero length of C string in @buf 1115 * Output: 1116 * passed-in buffer filled with "Y" or "N" with a newline 1117 * and NULL-terminated C string. This indicates whether 1118 * the grace period has ended in the current net 1119 * namespace. Return code is the size in bytes of the 1120 * string. Writing a string that starts with 'Y', 'y', or 1121 * '1' to the file will end the grace period for nfsd's v4 1122 * lock manager. 1123 */ 1124 static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size) 1125 { 1126 struct nfsd_net *nn = net_generic(netns(file), nfsd_net_id); 1127 1128 if (size > 0) { 1129 switch(buf[0]) { 1130 case 'Y': 1131 case 'y': 1132 case '1': 1133 if (!nn->nfsd_serv) 1134 return -EBUSY; 1135 nfsd4_end_grace(nn); 1136 break; 1137 default: 1138 return -EINVAL; 1139 } 1140 } 1141 1142 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%c\n", 1143 nn->grace_ended ? 'Y' : 'N'); 1144 } 1145 1146 #endif 1147 1148 /*----------------------------------------------------------------------------*/ 1149 /* 1150 * populating the filesystem. 1151 */ 1152 1153 /* Basically copying rpc_get_inode. */ 1154 static struct inode *nfsd_get_inode(struct super_block *sb, umode_t mode) 1155 { 1156 struct inode *inode = new_inode(sb); 1157 if (!inode) 1158 return NULL; 1159 /* Following advice from simple_fill_super documentation: */ 1160 inode->i_ino = iunique(sb, NFSD_MaxReserved); 1161 inode->i_mode = mode; 1162 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); 1163 switch (mode & S_IFMT) { 1164 case S_IFDIR: 1165 inode->i_fop = &simple_dir_operations; 1166 inode->i_op = &simple_dir_inode_operations; 1167 inc_nlink(inode); 1168 default: 1169 break; 1170 } 1171 return inode; 1172 } 1173 1174 static int __nfsd_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 1175 { 1176 struct inode *inode; 1177 1178 inode = nfsd_get_inode(dir->i_sb, mode); 1179 if (!inode) 1180 return -ENOMEM; 1181 d_add(dentry, inode); 1182 inc_nlink(dir); 1183 fsnotify_mkdir(dir, dentry); 1184 return 0; 1185 } 1186 1187 static struct dentry *nfsd_mkdir(struct dentry *parent, struct nfsdfs_client *ncl, char *name) 1188 { 1189 struct inode *dir = parent->d_inode; 1190 struct dentry *dentry; 1191 int ret = -ENOMEM; 1192 1193 inode_lock(dir); 1194 dentry = d_alloc_name(parent, name); 1195 if (!dentry) 1196 goto out_err; 1197 ret = __nfsd_mkdir(d_inode(parent), dentry, S_IFDIR | 0600); 1198 if (ret) 1199 goto out_err; 1200 if (ncl) { 1201 d_inode(dentry)->i_private = ncl; 1202 kref_get(&ncl->cl_ref); 1203 } 1204 out: 1205 inode_unlock(dir); 1206 return dentry; 1207 out_err: 1208 dentry = ERR_PTR(ret); 1209 goto out; 1210 } 1211 1212 static void clear_ncl(struct inode *inode) 1213 { 1214 struct nfsdfs_client *ncl = inode->i_private; 1215 1216 inode->i_private = NULL; 1217 synchronize_rcu(); 1218 kref_put(&ncl->cl_ref, ncl->cl_release); 1219 } 1220 1221 1222 static struct nfsdfs_client *__get_nfsdfs_client(struct inode *inode) 1223 { 1224 struct nfsdfs_client *nc = inode->i_private; 1225 1226 if (nc) 1227 kref_get(&nc->cl_ref); 1228 return nc; 1229 } 1230 1231 struct nfsdfs_client *get_nfsdfs_client(struct inode *inode) 1232 { 1233 struct nfsdfs_client *nc; 1234 1235 rcu_read_lock(); 1236 nc = __get_nfsdfs_client(inode); 1237 rcu_read_unlock(); 1238 return nc; 1239 } 1240 /* from __rpc_unlink */ 1241 static void nfsdfs_remove_file(struct inode *dir, struct dentry *dentry) 1242 { 1243 int ret; 1244 1245 clear_ncl(d_inode(dentry)); 1246 dget(dentry); 1247 ret = simple_unlink(dir, dentry); 1248 d_delete(dentry); 1249 dput(dentry); 1250 WARN_ON_ONCE(ret); 1251 } 1252 1253 static void nfsdfs_remove_files(struct dentry *root) 1254 { 1255 struct dentry *dentry, *tmp; 1256 1257 list_for_each_entry_safe(dentry, tmp, &root->d_subdirs, d_child) { 1258 if (!simple_positive(dentry)) { 1259 WARN_ON_ONCE(1); /* I think this can't happen? */ 1260 continue; 1261 } 1262 nfsdfs_remove_file(d_inode(root), dentry); 1263 } 1264 } 1265 1266 /* XXX: cut'n'paste from simple_fill_super; figure out if we could share 1267 * code instead. */ 1268 static int nfsdfs_create_files(struct dentry *root, 1269 const struct tree_descr *files) 1270 { 1271 struct inode *dir = d_inode(root); 1272 struct inode *inode; 1273 struct dentry *dentry; 1274 int i; 1275 1276 inode_lock(dir); 1277 for (i = 0; files->name && files->name[0]; i++, files++) { 1278 if (!files->name) 1279 continue; 1280 dentry = d_alloc_name(root, files->name); 1281 if (!dentry) 1282 goto out; 1283 inode = nfsd_get_inode(d_inode(root)->i_sb, 1284 S_IFREG | files->mode); 1285 if (!inode) { 1286 dput(dentry); 1287 goto out; 1288 } 1289 inode->i_fop = files->ops; 1290 inode->i_private = __get_nfsdfs_client(dir); 1291 d_add(dentry, inode); 1292 fsnotify_create(dir, dentry); 1293 } 1294 inode_unlock(dir); 1295 return 0; 1296 out: 1297 nfsdfs_remove_files(root); 1298 inode_unlock(dir); 1299 return -ENOMEM; 1300 } 1301 1302 /* on success, returns positive number unique to that client. */ 1303 struct dentry *nfsd_client_mkdir(struct nfsd_net *nn, 1304 struct nfsdfs_client *ncl, u32 id, 1305 const struct tree_descr *files) 1306 { 1307 struct dentry *dentry; 1308 char name[11]; 1309 int ret; 1310 1311 sprintf(name, "%u", id); 1312 1313 dentry = nfsd_mkdir(nn->nfsd_client_dir, ncl, name); 1314 if (IS_ERR(dentry)) /* XXX: tossing errors? */ 1315 return NULL; 1316 ret = nfsdfs_create_files(dentry, files); 1317 if (ret) { 1318 nfsd_client_rmdir(dentry); 1319 return NULL; 1320 } 1321 return dentry; 1322 } 1323 1324 /* Taken from __rpc_rmdir: */ 1325 void nfsd_client_rmdir(struct dentry *dentry) 1326 { 1327 struct inode *dir = d_inode(dentry->d_parent); 1328 struct inode *inode = d_inode(dentry); 1329 int ret; 1330 1331 inode_lock(dir); 1332 nfsdfs_remove_files(dentry); 1333 clear_ncl(inode); 1334 dget(dentry); 1335 ret = simple_rmdir(dir, dentry); 1336 WARN_ON_ONCE(ret); 1337 d_delete(dentry); 1338 inode_unlock(dir); 1339 } 1340 1341 static int nfsd_fill_super(struct super_block *sb, struct fs_context *fc) 1342 { 1343 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 1344 nfsd_net_id); 1345 struct dentry *dentry; 1346 int ret; 1347 1348 static const struct tree_descr nfsd_files[] = { 1349 [NFSD_List] = {"exports", &exports_nfsd_operations, S_IRUGO}, 1350 [NFSD_Export_features] = {"export_features", 1351 &export_features_operations, S_IRUGO}, 1352 [NFSD_FO_UnlockIP] = {"unlock_ip", 1353 &transaction_ops, S_IWUSR|S_IRUSR}, 1354 [NFSD_FO_UnlockFS] = {"unlock_filesystem", 1355 &transaction_ops, S_IWUSR|S_IRUSR}, 1356 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR}, 1357 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1358 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1359 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO}, 1360 [NFSD_Reply_Cache_Stats] = {"reply_cache_stats", &reply_cache_stats_operations, S_IRUGO}, 1361 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR}, 1362 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO}, 1363 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO}, 1364 [NFSD_MaxConnections] = {"max_connections", &transaction_ops, S_IWUSR|S_IRUGO}, 1365 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE) 1366 [NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO}, 1367 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */ 1368 #ifdef CONFIG_NFSD_V4 1369 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1370 [NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1371 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR}, 1372 [NFSD_V4EndGrace] = {"v4_end_grace", &transaction_ops, S_IWUSR|S_IRUGO}, 1373 #endif 1374 /* last one */ {""} 1375 }; 1376 1377 ret = simple_fill_super(sb, 0x6e667364, nfsd_files); 1378 if (ret) 1379 return ret; 1380 dentry = nfsd_mkdir(sb->s_root, NULL, "clients"); 1381 if (IS_ERR(dentry)) 1382 return PTR_ERR(dentry); 1383 nn->nfsd_client_dir = dentry; 1384 return 0; 1385 } 1386 1387 static int nfsd_fs_get_tree(struct fs_context *fc) 1388 { 1389 fc->s_fs_info = get_net(fc->net_ns); 1390 return vfs_get_super(fc, vfs_get_keyed_super, nfsd_fill_super); 1391 } 1392 1393 static void nfsd_fs_free_fc(struct fs_context *fc) 1394 { 1395 if (fc->s_fs_info) 1396 put_net(fc->s_fs_info); 1397 } 1398 1399 static const struct fs_context_operations nfsd_fs_context_ops = { 1400 .free = nfsd_fs_free_fc, 1401 .get_tree = nfsd_fs_get_tree, 1402 }; 1403 1404 static int nfsd_init_fs_context(struct fs_context *fc) 1405 { 1406 put_user_ns(fc->user_ns); 1407 fc->user_ns = get_user_ns(fc->net_ns->user_ns); 1408 fc->ops = &nfsd_fs_context_ops; 1409 return 0; 1410 } 1411 1412 static void nfsd_umount(struct super_block *sb) 1413 { 1414 struct net *net = sb->s_fs_info; 1415 1416 kill_litter_super(sb); 1417 put_net(net); 1418 } 1419 1420 static struct file_system_type nfsd_fs_type = { 1421 .owner = THIS_MODULE, 1422 .name = "nfsd", 1423 .init_fs_context = nfsd_init_fs_context, 1424 .kill_sb = nfsd_umount, 1425 }; 1426 MODULE_ALIAS_FS("nfsd"); 1427 1428 #ifdef CONFIG_PROC_FS 1429 static int create_proc_exports_entry(void) 1430 { 1431 struct proc_dir_entry *entry; 1432 1433 entry = proc_mkdir("fs/nfs", NULL); 1434 if (!entry) 1435 return -ENOMEM; 1436 entry = proc_create("exports", 0, entry, 1437 &exports_proc_operations); 1438 if (!entry) { 1439 remove_proc_entry("fs/nfs", NULL); 1440 return -ENOMEM; 1441 } 1442 return 0; 1443 } 1444 #else /* CONFIG_PROC_FS */ 1445 static int create_proc_exports_entry(void) 1446 { 1447 return 0; 1448 } 1449 #endif 1450 1451 unsigned int nfsd_net_id; 1452 1453 static __net_init int nfsd_init_net(struct net *net) 1454 { 1455 int retval; 1456 struct vfsmount *mnt; 1457 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1458 1459 retval = nfsd_export_init(net); 1460 if (retval) 1461 goto out_export_error; 1462 retval = nfsd_idmap_init(net); 1463 if (retval) 1464 goto out_idmap_error; 1465 nn->nfsd_versions = NULL; 1466 nn->nfsd4_minorversions = NULL; 1467 retval = nfsd_reply_cache_init(nn); 1468 if (retval) 1469 goto out_drc_error; 1470 nn->nfsd4_lease = 90; /* default lease time */ 1471 nn->nfsd4_grace = 90; 1472 nn->somebody_reclaimed = false; 1473 nn->track_reclaim_completes = false; 1474 nn->clverifier_counter = prandom_u32(); 1475 nn->clientid_base = prandom_u32(); 1476 nn->clientid_counter = nn->clientid_base + 1; 1477 nn->s2s_cp_cl_id = nn->clientid_counter++; 1478 1479 atomic_set(&nn->ntf_refcnt, 0); 1480 init_waitqueue_head(&nn->ntf_wq); 1481 1482 mnt = vfs_kern_mount(&nfsd_fs_type, SB_KERNMOUNT, "nfsd", NULL); 1483 if (IS_ERR(mnt)) { 1484 retval = PTR_ERR(mnt); 1485 goto out_mount_err; 1486 } 1487 nn->nfsd_mnt = mnt; 1488 return 0; 1489 1490 out_mount_err: 1491 nfsd_reply_cache_shutdown(nn); 1492 out_drc_error: 1493 nfsd_idmap_shutdown(net); 1494 out_idmap_error: 1495 nfsd_export_shutdown(net); 1496 out_export_error: 1497 return retval; 1498 } 1499 1500 static __net_exit void nfsd_exit_net(struct net *net) 1501 { 1502 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1503 1504 mntput(nn->nfsd_mnt); 1505 nfsd_reply_cache_shutdown(nn); 1506 nfsd_idmap_shutdown(net); 1507 nfsd_export_shutdown(net); 1508 nfsd_netns_free_versions(net_generic(net, nfsd_net_id)); 1509 } 1510 1511 static struct pernet_operations nfsd_net_ops = { 1512 .init = nfsd_init_net, 1513 .exit = nfsd_exit_net, 1514 .id = &nfsd_net_id, 1515 .size = sizeof(struct nfsd_net), 1516 }; 1517 1518 static int __init init_nfsd(void) 1519 { 1520 int retval; 1521 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n"); 1522 1523 retval = register_pernet_subsys(&nfsd_net_ops); 1524 if (retval < 0) 1525 return retval; 1526 retval = register_cld_notifier(); 1527 if (retval) 1528 goto out_unregister_pernet; 1529 retval = nfsd4_init_slabs(); 1530 if (retval) 1531 goto out_unregister_notifier; 1532 retval = nfsd4_init_pnfs(); 1533 if (retval) 1534 goto out_free_slabs; 1535 nfsd_fault_inject_init(); /* nfsd fault injection controls */ 1536 nfsd_stat_init(); /* Statistics */ 1537 nfsd_lockd_init(); /* lockd->nfsd callbacks */ 1538 retval = create_proc_exports_entry(); 1539 if (retval) 1540 goto out_free_lockd; 1541 retval = register_filesystem(&nfsd_fs_type); 1542 if (retval) 1543 goto out_free_all; 1544 return 0; 1545 out_free_all: 1546 remove_proc_entry("fs/nfs/exports", NULL); 1547 remove_proc_entry("fs/nfs", NULL); 1548 out_free_lockd: 1549 nfsd_lockd_shutdown(); 1550 nfsd_stat_shutdown(); 1551 nfsd_fault_inject_cleanup(); 1552 nfsd4_exit_pnfs(); 1553 out_free_slabs: 1554 nfsd4_free_slabs(); 1555 out_unregister_notifier: 1556 unregister_cld_notifier(); 1557 out_unregister_pernet: 1558 unregister_pernet_subsys(&nfsd_net_ops); 1559 return retval; 1560 } 1561 1562 static void __exit exit_nfsd(void) 1563 { 1564 remove_proc_entry("fs/nfs/exports", NULL); 1565 remove_proc_entry("fs/nfs", NULL); 1566 nfsd_stat_shutdown(); 1567 nfsd_lockd_shutdown(); 1568 nfsd4_free_slabs(); 1569 nfsd4_exit_pnfs(); 1570 nfsd_fault_inject_cleanup(); 1571 unregister_filesystem(&nfsd_fs_type); 1572 unregister_cld_notifier(); 1573 unregister_pernet_subsys(&nfsd_net_ops); 1574 } 1575 1576 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1577 MODULE_LICENSE("GPL"); 1578 module_init(init_nfsd) 1579 module_exit(exit_nfsd) 1580