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 proc_ops exports_proc_ops = { 161 .proc_open = exports_proc_open, 162 .proc_read = seq_read, 163 .proc_lseek = seq_lseek, 164 .proc_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 time64_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, "%lld\n", *time); 988 } 989 990 static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, 991 time64_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, struct nfsdfs_client *ncl) 1175 { 1176 struct inode *inode; 1177 1178 inode = nfsd_get_inode(dir->i_sb, mode); 1179 if (!inode) 1180 return -ENOMEM; 1181 if (ncl) { 1182 inode->i_private = ncl; 1183 kref_get(&ncl->cl_ref); 1184 } 1185 d_add(dentry, inode); 1186 inc_nlink(dir); 1187 fsnotify_mkdir(dir, dentry); 1188 return 0; 1189 } 1190 1191 static struct dentry *nfsd_mkdir(struct dentry *parent, struct nfsdfs_client *ncl, char *name) 1192 { 1193 struct inode *dir = parent->d_inode; 1194 struct dentry *dentry; 1195 int ret = -ENOMEM; 1196 1197 inode_lock(dir); 1198 dentry = d_alloc_name(parent, name); 1199 if (!dentry) 1200 goto out_err; 1201 ret = __nfsd_mkdir(d_inode(parent), dentry, S_IFDIR | 0600, ncl); 1202 if (ret) 1203 goto out_err; 1204 out: 1205 inode_unlock(dir); 1206 return dentry; 1207 out_err: 1208 dput(dentry); 1209 dentry = ERR_PTR(ret); 1210 goto out; 1211 } 1212 1213 static void clear_ncl(struct inode *inode) 1214 { 1215 struct nfsdfs_client *ncl = inode->i_private; 1216 1217 inode->i_private = NULL; 1218 kref_put(&ncl->cl_ref, ncl->cl_release); 1219 } 1220 1221 static struct nfsdfs_client *__get_nfsdfs_client(struct inode *inode) 1222 { 1223 struct nfsdfs_client *nc = inode->i_private; 1224 1225 if (nc) 1226 kref_get(&nc->cl_ref); 1227 return nc; 1228 } 1229 1230 struct nfsdfs_client *get_nfsdfs_client(struct inode *inode) 1231 { 1232 struct nfsdfs_client *nc; 1233 1234 inode_lock_shared(inode); 1235 nc = __get_nfsdfs_client(inode); 1236 inode_unlock_shared(inode); 1237 return nc; 1238 } 1239 /* from __rpc_unlink */ 1240 static void nfsdfs_remove_file(struct inode *dir, struct dentry *dentry) 1241 { 1242 int ret; 1243 1244 clear_ncl(d_inode(dentry)); 1245 dget(dentry); 1246 ret = simple_unlink(dir, dentry); 1247 d_delete(dentry); 1248 dput(dentry); 1249 WARN_ON_ONCE(ret); 1250 } 1251 1252 static void nfsdfs_remove_files(struct dentry *root) 1253 { 1254 struct dentry *dentry, *tmp; 1255 1256 list_for_each_entry_safe(dentry, tmp, &root->d_subdirs, d_child) { 1257 if (!simple_positive(dentry)) { 1258 WARN_ON_ONCE(1); /* I think this can't happen? */ 1259 continue; 1260 } 1261 nfsdfs_remove_file(d_inode(root), dentry); 1262 } 1263 } 1264 1265 /* XXX: cut'n'paste from simple_fill_super; figure out if we could share 1266 * code instead. */ 1267 static int nfsdfs_create_files(struct dentry *root, 1268 const struct tree_descr *files) 1269 { 1270 struct inode *dir = d_inode(root); 1271 struct inode *inode; 1272 struct dentry *dentry; 1273 int i; 1274 1275 inode_lock(dir); 1276 for (i = 0; files->name && files->name[0]; i++, files++) { 1277 if (!files->name) 1278 continue; 1279 dentry = d_alloc_name(root, files->name); 1280 if (!dentry) 1281 goto out; 1282 inode = nfsd_get_inode(d_inode(root)->i_sb, 1283 S_IFREG | files->mode); 1284 if (!inode) { 1285 dput(dentry); 1286 goto out; 1287 } 1288 inode->i_fop = files->ops; 1289 inode->i_private = __get_nfsdfs_client(dir); 1290 d_add(dentry, inode); 1291 fsnotify_create(dir, dentry); 1292 } 1293 inode_unlock(dir); 1294 return 0; 1295 out: 1296 nfsdfs_remove_files(root); 1297 inode_unlock(dir); 1298 return -ENOMEM; 1299 } 1300 1301 /* on success, returns positive number unique to that client. */ 1302 struct dentry *nfsd_client_mkdir(struct nfsd_net *nn, 1303 struct nfsdfs_client *ncl, u32 id, 1304 const struct tree_descr *files) 1305 { 1306 struct dentry *dentry; 1307 char name[11]; 1308 int ret; 1309 1310 sprintf(name, "%u", id); 1311 1312 dentry = nfsd_mkdir(nn->nfsd_client_dir, ncl, name); 1313 if (IS_ERR(dentry)) /* XXX: tossing errors? */ 1314 return NULL; 1315 ret = nfsdfs_create_files(dentry, files); 1316 if (ret) { 1317 nfsd_client_rmdir(dentry); 1318 return NULL; 1319 } 1320 return dentry; 1321 } 1322 1323 /* Taken from __rpc_rmdir: */ 1324 void nfsd_client_rmdir(struct dentry *dentry) 1325 { 1326 struct inode *dir = d_inode(dentry->d_parent); 1327 struct inode *inode = d_inode(dentry); 1328 int ret; 1329 1330 inode_lock(dir); 1331 nfsdfs_remove_files(dentry); 1332 clear_ncl(inode); 1333 dget(dentry); 1334 ret = simple_rmdir(dir, dentry); 1335 WARN_ON_ONCE(ret); 1336 d_delete(dentry); 1337 inode_unlock(dir); 1338 } 1339 1340 static int nfsd_fill_super(struct super_block *sb, struct fs_context *fc) 1341 { 1342 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, 1343 nfsd_net_id); 1344 struct dentry *dentry; 1345 int ret; 1346 1347 static const struct tree_descr nfsd_files[] = { 1348 [NFSD_List] = {"exports", &exports_nfsd_operations, S_IRUGO}, 1349 [NFSD_Export_features] = {"export_features", 1350 &export_features_operations, S_IRUGO}, 1351 [NFSD_FO_UnlockIP] = {"unlock_ip", 1352 &transaction_ops, S_IWUSR|S_IRUSR}, 1353 [NFSD_FO_UnlockFS] = {"unlock_filesystem", 1354 &transaction_ops, S_IWUSR|S_IRUSR}, 1355 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR}, 1356 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1357 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1358 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO}, 1359 [NFSD_Reply_Cache_Stats] = {"reply_cache_stats", &reply_cache_stats_operations, S_IRUGO}, 1360 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR}, 1361 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO}, 1362 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO}, 1363 [NFSD_MaxConnections] = {"max_connections", &transaction_ops, S_IWUSR|S_IRUGO}, 1364 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE) 1365 [NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO}, 1366 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */ 1367 #ifdef CONFIG_NFSD_V4 1368 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1369 [NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1370 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR}, 1371 [NFSD_V4EndGrace] = {"v4_end_grace", &transaction_ops, S_IWUSR|S_IRUGO}, 1372 #endif 1373 /* last one */ {""} 1374 }; 1375 1376 ret = simple_fill_super(sb, 0x6e667364, nfsd_files); 1377 if (ret) 1378 return ret; 1379 dentry = nfsd_mkdir(sb->s_root, NULL, "clients"); 1380 if (IS_ERR(dentry)) 1381 return PTR_ERR(dentry); 1382 nn->nfsd_client_dir = dentry; 1383 return 0; 1384 } 1385 1386 static int nfsd_fs_get_tree(struct fs_context *fc) 1387 { 1388 return get_tree_keyed(fc, nfsd_fill_super, get_net(fc->net_ns)); 1389 } 1390 1391 static void nfsd_fs_free_fc(struct fs_context *fc) 1392 { 1393 if (fc->s_fs_info) 1394 put_net(fc->s_fs_info); 1395 } 1396 1397 static const struct fs_context_operations nfsd_fs_context_ops = { 1398 .free = nfsd_fs_free_fc, 1399 .get_tree = nfsd_fs_get_tree, 1400 }; 1401 1402 static int nfsd_init_fs_context(struct fs_context *fc) 1403 { 1404 put_user_ns(fc->user_ns); 1405 fc->user_ns = get_user_ns(fc->net_ns->user_ns); 1406 fc->ops = &nfsd_fs_context_ops; 1407 return 0; 1408 } 1409 1410 static void nfsd_umount(struct super_block *sb) 1411 { 1412 struct net *net = sb->s_fs_info; 1413 1414 kill_litter_super(sb); 1415 put_net(net); 1416 } 1417 1418 static struct file_system_type nfsd_fs_type = { 1419 .owner = THIS_MODULE, 1420 .name = "nfsd", 1421 .init_fs_context = nfsd_init_fs_context, 1422 .kill_sb = nfsd_umount, 1423 }; 1424 MODULE_ALIAS_FS("nfsd"); 1425 1426 #ifdef CONFIG_PROC_FS 1427 static int create_proc_exports_entry(void) 1428 { 1429 struct proc_dir_entry *entry; 1430 1431 entry = proc_mkdir("fs/nfs", NULL); 1432 if (!entry) 1433 return -ENOMEM; 1434 entry = proc_create("exports", 0, entry, &exports_proc_ops); 1435 if (!entry) { 1436 remove_proc_entry("fs/nfs", NULL); 1437 return -ENOMEM; 1438 } 1439 return 0; 1440 } 1441 #else /* CONFIG_PROC_FS */ 1442 static int create_proc_exports_entry(void) 1443 { 1444 return 0; 1445 } 1446 #endif 1447 1448 unsigned int nfsd_net_id; 1449 1450 static __net_init int nfsd_init_net(struct net *net) 1451 { 1452 int retval; 1453 struct vfsmount *mnt; 1454 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1455 1456 retval = nfsd_export_init(net); 1457 if (retval) 1458 goto out_export_error; 1459 retval = nfsd_idmap_init(net); 1460 if (retval) 1461 goto out_idmap_error; 1462 nn->nfsd_versions = NULL; 1463 nn->nfsd4_minorversions = NULL; 1464 retval = nfsd_reply_cache_init(nn); 1465 if (retval) 1466 goto out_drc_error; 1467 nn->nfsd4_lease = 90; /* default lease time */ 1468 nn->nfsd4_grace = 90; 1469 nn->somebody_reclaimed = false; 1470 nn->track_reclaim_completes = false; 1471 nn->clverifier_counter = prandom_u32(); 1472 nn->clientid_base = prandom_u32(); 1473 nn->clientid_counter = nn->clientid_base + 1; 1474 nn->s2s_cp_cl_id = nn->clientid_counter++; 1475 1476 atomic_set(&nn->ntf_refcnt, 0); 1477 init_waitqueue_head(&nn->ntf_wq); 1478 seqlock_init(&nn->boot_lock); 1479 1480 mnt = vfs_kern_mount(&nfsd_fs_type, SB_KERNMOUNT, "nfsd", NULL); 1481 if (IS_ERR(mnt)) { 1482 retval = PTR_ERR(mnt); 1483 goto out_mount_err; 1484 } 1485 nn->nfsd_mnt = mnt; 1486 return 0; 1487 1488 out_mount_err: 1489 nfsd_reply_cache_shutdown(nn); 1490 out_drc_error: 1491 nfsd_idmap_shutdown(net); 1492 out_idmap_error: 1493 nfsd_export_shutdown(net); 1494 out_export_error: 1495 return retval; 1496 } 1497 1498 static __net_exit void nfsd_exit_net(struct net *net) 1499 { 1500 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1501 1502 mntput(nn->nfsd_mnt); 1503 nfsd_reply_cache_shutdown(nn); 1504 nfsd_idmap_shutdown(net); 1505 nfsd_export_shutdown(net); 1506 nfsd_netns_free_versions(net_generic(net, nfsd_net_id)); 1507 } 1508 1509 static struct pernet_operations nfsd_net_ops = { 1510 .init = nfsd_init_net, 1511 .exit = nfsd_exit_net, 1512 .id = &nfsd_net_id, 1513 .size = sizeof(struct nfsd_net), 1514 }; 1515 1516 static int __init init_nfsd(void) 1517 { 1518 int retval; 1519 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n"); 1520 1521 retval = register_pernet_subsys(&nfsd_net_ops); 1522 if (retval < 0) 1523 return retval; 1524 retval = register_cld_notifier(); 1525 if (retval) 1526 goto out_unregister_pernet; 1527 retval = nfsd4_init_slabs(); 1528 if (retval) 1529 goto out_unregister_notifier; 1530 retval = nfsd4_init_pnfs(); 1531 if (retval) 1532 goto out_free_slabs; 1533 nfsd_fault_inject_init(); /* nfsd fault injection controls */ 1534 nfsd_stat_init(); /* Statistics */ 1535 nfsd_lockd_init(); /* lockd->nfsd callbacks */ 1536 retval = create_proc_exports_entry(); 1537 if (retval) 1538 goto out_free_lockd; 1539 retval = register_filesystem(&nfsd_fs_type); 1540 if (retval) 1541 goto out_free_all; 1542 return 0; 1543 out_free_all: 1544 remove_proc_entry("fs/nfs/exports", NULL); 1545 remove_proc_entry("fs/nfs", NULL); 1546 out_free_lockd: 1547 nfsd_lockd_shutdown(); 1548 nfsd_stat_shutdown(); 1549 nfsd_fault_inject_cleanup(); 1550 nfsd4_exit_pnfs(); 1551 out_free_slabs: 1552 nfsd4_free_slabs(); 1553 out_unregister_notifier: 1554 unregister_cld_notifier(); 1555 out_unregister_pernet: 1556 unregister_pernet_subsys(&nfsd_net_ops); 1557 return retval; 1558 } 1559 1560 static void __exit exit_nfsd(void) 1561 { 1562 remove_proc_entry("fs/nfs/exports", NULL); 1563 remove_proc_entry("fs/nfs", NULL); 1564 nfsd_stat_shutdown(); 1565 nfsd_lockd_shutdown(); 1566 nfsd4_free_slabs(); 1567 nfsd4_exit_pnfs(); 1568 nfsd_fault_inject_cleanup(); 1569 unregister_filesystem(&nfsd_fs_type); 1570 unregister_cld_notifier(); 1571 unregister_pernet_subsys(&nfsd_net_ops); 1572 } 1573 1574 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1575 MODULE_LICENSE("GPL"); 1576 module_init(init_nfsd) 1577 module_exit(exit_nfsd) 1578