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 *genl_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, genl_rqstp->rq_xid) || 1450 nla_put_u32(skb, NFSD_A_RPC_STATUS_FLAGS, genl_rqstp->rq_flags) || 1451 nla_put_u32(skb, NFSD_A_RPC_STATUS_PROG, genl_rqstp->rq_prog) || 1452 nla_put_u32(skb, NFSD_A_RPC_STATUS_PROC, genl_rqstp->rq_proc) || 1453 nla_put_u8(skb, NFSD_A_RPC_STATUS_VERSION, genl_rqstp->rq_vers) || 1454 nla_put_s64(skb, NFSD_A_RPC_STATUS_SERVICE_TIME, 1455 ktime_to_us(genl_rqstp->rq_stime), 1456 NFSD_A_RPC_STATUS_PAD)) 1457 return -ENOBUFS; 1458 1459 switch (genl_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 *)&genl_rqstp->rq_saddr; 1464 d_in = (const struct sockaddr_in *)&genl_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 *)&genl_rqstp->rq_saddr; 1480 d_in = (const struct sockaddr_in6 *)&genl_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 < genl_rqstp->rq_opcnt; i++) 1495 if (nla_put_u32(skb, NFSD_A_RPC_STATUS_COMPOUND_OPS, 1496 genl_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 = min_t(u32, args->opcnt, 1573 ARRAY_SIZE(genl_rqstp.rq_opnum)); 1574 for (j = 0; j < genl_rqstp.rq_opcnt; j++) 1575 genl_rqstp.rq_opnum[j] = 1576 args->ops[j].opnum; 1577 } 1578 #endif /* CONFIG_NFSD_V4 */ 1579 1580 /* 1581 * Acquire rq_status_counter before reporting the rqst 1582 * fields to the user. 1583 */ 1584 if (smp_load_acquire(&rqstp->rq_status_counter) != 1585 status_counter) 1586 continue; 1587 1588 ret = nfsd_genl_rpc_status_compose_msg(skb, cb, 1589 &genl_rqstp); 1590 if (ret) 1591 goto out; 1592 } 1593 } 1594 1595 cb->args[0] = i; 1596 cb->args[1] = rqstp_index; 1597 ret = skb->len; 1598 out: 1599 rcu_read_unlock(); 1600 out_unlock: 1601 mutex_unlock(&nfsd_mutex); 1602 1603 return ret; 1604 } 1605 1606 /** 1607 * nfsd_nl_threads_set_doit - set the number of running threads 1608 * @skb: reply buffer 1609 * @info: netlink metadata and command arguments 1610 * 1611 * Return 0 on success or a negative errno. 1612 */ 1613 int nfsd_nl_threads_set_doit(struct sk_buff *skb, struct genl_info *info) 1614 { 1615 int *nthreads, nrpools = 0, i, ret = -EOPNOTSUPP, rem; 1616 struct net *net = genl_info_net(info); 1617 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1618 const struct nlattr *attr; 1619 const char *scope = NULL; 1620 1621 if (GENL_REQ_ATTR_CHECK(info, NFSD_A_SERVER_THREADS)) 1622 return -EINVAL; 1623 1624 /* count number of SERVER_THREADS values */ 1625 nlmsg_for_each_attr_type(attr, NFSD_A_SERVER_THREADS, info->nlhdr, 1626 GENL_HDRLEN, rem) 1627 nrpools++; 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_type(attr, NFSD_A_SERVER_THREADS, info->nlhdr, 1639 GENL_HDRLEN, rem) { 1640 nthreads[i++] = nla_get_u32(attr); 1641 if (i >= nrpools) 1642 break; 1643 } 1644 1645 if (info->attrs[NFSD_A_SERVER_GRACETIME] || 1646 info->attrs[NFSD_A_SERVER_LEASETIME] || 1647 info->attrs[NFSD_A_SERVER_SCOPE]) { 1648 ret = -EBUSY; 1649 if (nn->nfsd_serv && nn->nfsd_serv->sv_nrthreads) 1650 goto out_unlock; 1651 1652 ret = -EINVAL; 1653 attr = info->attrs[NFSD_A_SERVER_GRACETIME]; 1654 if (attr) { 1655 u32 gracetime = nla_get_u32(attr); 1656 1657 if (gracetime < 10 || gracetime > 3600) 1658 goto out_unlock; 1659 1660 nn->nfsd4_grace = gracetime; 1661 } 1662 1663 attr = info->attrs[NFSD_A_SERVER_LEASETIME]; 1664 if (attr) { 1665 u32 leasetime = nla_get_u32(attr); 1666 1667 if (leasetime < 10 || leasetime > 3600) 1668 goto out_unlock; 1669 1670 nn->nfsd4_lease = leasetime; 1671 } 1672 1673 attr = info->attrs[NFSD_A_SERVER_SCOPE]; 1674 if (attr) 1675 scope = nla_data(attr); 1676 } 1677 1678 ret = nfsd_svc(nrpools, nthreads, net, get_current_cred(), scope); 1679 if (ret > 0) 1680 ret = 0; 1681 out_unlock: 1682 mutex_unlock(&nfsd_mutex); 1683 kfree(nthreads); 1684 return ret; 1685 } 1686 1687 /** 1688 * nfsd_nl_threads_get_doit - get the number of running threads 1689 * @skb: reply buffer 1690 * @info: netlink metadata and command arguments 1691 * 1692 * Return 0 on success or a negative errno. 1693 */ 1694 int nfsd_nl_threads_get_doit(struct sk_buff *skb, struct genl_info *info) 1695 { 1696 struct net *net = genl_info_net(info); 1697 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1698 void *hdr; 1699 int err; 1700 1701 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 1702 if (!skb) 1703 return -ENOMEM; 1704 1705 hdr = genlmsg_iput(skb, info); 1706 if (!hdr) { 1707 err = -EMSGSIZE; 1708 goto err_free_msg; 1709 } 1710 1711 mutex_lock(&nfsd_mutex); 1712 1713 err = nla_put_u32(skb, NFSD_A_SERVER_GRACETIME, 1714 nn->nfsd4_grace) || 1715 nla_put_u32(skb, NFSD_A_SERVER_LEASETIME, 1716 nn->nfsd4_lease) || 1717 nla_put_string(skb, NFSD_A_SERVER_SCOPE, 1718 nn->nfsd_name); 1719 if (err) 1720 goto err_unlock; 1721 1722 if (nn->nfsd_serv) { 1723 int i; 1724 1725 for (i = 0; i < nfsd_nrpools(net); ++i) { 1726 struct svc_pool *sp = &nn->nfsd_serv->sv_pools[i]; 1727 1728 err = nla_put_u32(skb, NFSD_A_SERVER_THREADS, 1729 sp->sp_nrthreads); 1730 if (err) 1731 goto err_unlock; 1732 } 1733 } else { 1734 err = nla_put_u32(skb, NFSD_A_SERVER_THREADS, 0); 1735 if (err) 1736 goto err_unlock; 1737 } 1738 1739 mutex_unlock(&nfsd_mutex); 1740 1741 genlmsg_end(skb, hdr); 1742 1743 return genlmsg_reply(skb, info); 1744 1745 err_unlock: 1746 mutex_unlock(&nfsd_mutex); 1747 err_free_msg: 1748 nlmsg_free(skb); 1749 1750 return err; 1751 } 1752 1753 /** 1754 * nfsd_nl_version_set_doit - set the nfs enabled versions 1755 * @skb: reply buffer 1756 * @info: netlink metadata and command arguments 1757 * 1758 * Return 0 on success or a negative errno. 1759 */ 1760 int nfsd_nl_version_set_doit(struct sk_buff *skb, struct genl_info *info) 1761 { 1762 const struct nlattr *attr; 1763 struct nfsd_net *nn; 1764 int i, rem; 1765 1766 if (GENL_REQ_ATTR_CHECK(info, NFSD_A_SERVER_PROTO_VERSION)) 1767 return -EINVAL; 1768 1769 mutex_lock(&nfsd_mutex); 1770 1771 nn = net_generic(genl_info_net(info), nfsd_net_id); 1772 if (nn->nfsd_serv) { 1773 mutex_unlock(&nfsd_mutex); 1774 return -EBUSY; 1775 } 1776 1777 /* clear current supported versions. */ 1778 nfsd_vers(nn, 2, NFSD_CLEAR); 1779 nfsd_vers(nn, 3, NFSD_CLEAR); 1780 for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++) 1781 nfsd_minorversion(nn, i, NFSD_CLEAR); 1782 1783 nlmsg_for_each_attr_type(attr, NFSD_A_SERVER_PROTO_VERSION, info->nlhdr, 1784 GENL_HDRLEN, rem) { 1785 struct nlattr *tb[NFSD_A_VERSION_MAX + 1]; 1786 u32 major, minor = 0; 1787 bool enabled; 1788 1789 if (nla_parse_nested(tb, NFSD_A_VERSION_MAX, attr, 1790 nfsd_version_nl_policy, info->extack) < 0) 1791 continue; 1792 1793 if (!tb[NFSD_A_VERSION_MAJOR]) 1794 continue; 1795 1796 major = nla_get_u32(tb[NFSD_A_VERSION_MAJOR]); 1797 if (tb[NFSD_A_VERSION_MINOR]) 1798 minor = nla_get_u32(tb[NFSD_A_VERSION_MINOR]); 1799 1800 enabled = nla_get_flag(tb[NFSD_A_VERSION_ENABLED]); 1801 1802 switch (major) { 1803 case 4: 1804 nfsd_minorversion(nn, minor, enabled ? NFSD_SET : NFSD_CLEAR); 1805 break; 1806 case 3: 1807 case 2: 1808 if (!minor) 1809 nfsd_vers(nn, major, enabled ? NFSD_SET : NFSD_CLEAR); 1810 break; 1811 default: 1812 break; 1813 } 1814 } 1815 1816 mutex_unlock(&nfsd_mutex); 1817 1818 return 0; 1819 } 1820 1821 /** 1822 * nfsd_nl_version_get_doit - get the enabled status for all supported nfs versions 1823 * @skb: reply buffer 1824 * @info: netlink metadata and command arguments 1825 * 1826 * Return 0 on success or a negative errno. 1827 */ 1828 int nfsd_nl_version_get_doit(struct sk_buff *skb, struct genl_info *info) 1829 { 1830 struct nfsd_net *nn; 1831 int i, err; 1832 void *hdr; 1833 1834 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 1835 if (!skb) 1836 return -ENOMEM; 1837 1838 hdr = genlmsg_iput(skb, info); 1839 if (!hdr) { 1840 err = -EMSGSIZE; 1841 goto err_free_msg; 1842 } 1843 1844 mutex_lock(&nfsd_mutex); 1845 nn = net_generic(genl_info_net(info), nfsd_net_id); 1846 1847 for (i = 2; i <= 4; i++) { 1848 int j; 1849 1850 for (j = 0; j <= NFSD_SUPPORTED_MINOR_VERSION; j++) { 1851 struct nlattr *attr; 1852 1853 /* Don't record any versions the kernel doesn't have 1854 * compiled in 1855 */ 1856 if (!nfsd_support_version(i)) 1857 continue; 1858 1859 /* NFSv{2,3} does not support minor numbers */ 1860 if (i < 4 && j) 1861 continue; 1862 1863 attr = nla_nest_start(skb, 1864 NFSD_A_SERVER_PROTO_VERSION); 1865 if (!attr) { 1866 err = -EINVAL; 1867 goto err_nfsd_unlock; 1868 } 1869 1870 if (nla_put_u32(skb, NFSD_A_VERSION_MAJOR, i) || 1871 nla_put_u32(skb, NFSD_A_VERSION_MINOR, j)) { 1872 err = -EINVAL; 1873 goto err_nfsd_unlock; 1874 } 1875 1876 /* Set the enabled flag if the version is enabled */ 1877 if (nfsd_vers(nn, i, NFSD_TEST) && 1878 (i < 4 || nfsd_minorversion(nn, j, NFSD_TEST)) && 1879 nla_put_flag(skb, NFSD_A_VERSION_ENABLED)) { 1880 err = -EINVAL; 1881 goto err_nfsd_unlock; 1882 } 1883 1884 nla_nest_end(skb, attr); 1885 } 1886 } 1887 1888 mutex_unlock(&nfsd_mutex); 1889 genlmsg_end(skb, hdr); 1890 1891 return genlmsg_reply(skb, info); 1892 1893 err_nfsd_unlock: 1894 mutex_unlock(&nfsd_mutex); 1895 err_free_msg: 1896 nlmsg_free(skb); 1897 1898 return err; 1899 } 1900 1901 /** 1902 * nfsd_nl_listener_set_doit - set the nfs running sockets 1903 * @skb: reply buffer 1904 * @info: netlink metadata and command arguments 1905 * 1906 * Return 0 on success or a negative errno. 1907 */ 1908 int nfsd_nl_listener_set_doit(struct sk_buff *skb, struct genl_info *info) 1909 { 1910 struct net *net = genl_info_net(info); 1911 struct svc_xprt *xprt, *tmp; 1912 const struct nlattr *attr; 1913 struct svc_serv *serv; 1914 LIST_HEAD(permsocks); 1915 struct nfsd_net *nn; 1916 bool delete = false; 1917 int err, rem; 1918 1919 mutex_lock(&nfsd_mutex); 1920 1921 err = nfsd_create_serv(net); 1922 if (err) { 1923 mutex_unlock(&nfsd_mutex); 1924 return err; 1925 } 1926 1927 nn = net_generic(net, nfsd_net_id); 1928 serv = nn->nfsd_serv; 1929 1930 spin_lock_bh(&serv->sv_lock); 1931 1932 /* Move all of the old listener sockets to a temp list */ 1933 list_splice_init(&serv->sv_permsocks, &permsocks); 1934 1935 /* 1936 * Walk the list of server_socks from userland and move any that match 1937 * back to sv_permsocks 1938 */ 1939 nlmsg_for_each_attr_type(attr, NFSD_A_SERVER_SOCK_ADDR, info->nlhdr, 1940 GENL_HDRLEN, rem) { 1941 struct nlattr *tb[NFSD_A_SOCK_MAX + 1]; 1942 const char *xcl_name; 1943 struct sockaddr *sa; 1944 1945 if (nla_parse_nested(tb, NFSD_A_SOCK_MAX, attr, 1946 nfsd_sock_nl_policy, info->extack) < 0) 1947 continue; 1948 1949 if (!tb[NFSD_A_SOCK_ADDR] || !tb[NFSD_A_SOCK_TRANSPORT_NAME]) 1950 continue; 1951 1952 if (nla_len(tb[NFSD_A_SOCK_ADDR]) < sizeof(*sa)) 1953 continue; 1954 1955 xcl_name = nla_data(tb[NFSD_A_SOCK_TRANSPORT_NAME]); 1956 sa = nla_data(tb[NFSD_A_SOCK_ADDR]); 1957 1958 /* Put back any matching sockets */ 1959 list_for_each_entry_safe(xprt, tmp, &permsocks, xpt_list) { 1960 /* This shouldn't be possible */ 1961 if (WARN_ON_ONCE(xprt->xpt_net != net)) { 1962 list_move(&xprt->xpt_list, &serv->sv_permsocks); 1963 continue; 1964 } 1965 1966 /* If everything matches, put it back */ 1967 if (!strcmp(xprt->xpt_class->xcl_name, xcl_name) && 1968 rpc_cmp_addr_port(sa, (struct sockaddr *)&xprt->xpt_local)) { 1969 list_move(&xprt->xpt_list, &serv->sv_permsocks); 1970 break; 1971 } 1972 } 1973 } 1974 1975 /* 1976 * If there are listener transports remaining on the permsocks list, 1977 * it means we were asked to remove a listener. 1978 */ 1979 if (!list_empty(&permsocks)) { 1980 list_splice_init(&permsocks, &serv->sv_permsocks); 1981 delete = true; 1982 } 1983 spin_unlock_bh(&serv->sv_lock); 1984 1985 /* Do not remove listeners while there are active threads. */ 1986 if (serv->sv_nrthreads) { 1987 err = -EBUSY; 1988 goto out_unlock_mtx; 1989 } 1990 1991 /* 1992 * Since we can't delete an arbitrary llist entry, destroy the 1993 * remaining listeners and recreate the list. 1994 */ 1995 if (delete) 1996 svc_xprt_destroy_all(serv, net); 1997 1998 /* walk list of addrs again, open any that still don't exist */ 1999 nlmsg_for_each_attr_type(attr, NFSD_A_SERVER_SOCK_ADDR, info->nlhdr, 2000 GENL_HDRLEN, rem) { 2001 struct nlattr *tb[NFSD_A_SOCK_MAX + 1]; 2002 const char *xcl_name; 2003 struct sockaddr *sa; 2004 int ret; 2005 2006 if (nla_parse_nested(tb, NFSD_A_SOCK_MAX, attr, 2007 nfsd_sock_nl_policy, info->extack) < 0) 2008 continue; 2009 2010 if (!tb[NFSD_A_SOCK_ADDR] || !tb[NFSD_A_SOCK_TRANSPORT_NAME]) 2011 continue; 2012 2013 if (nla_len(tb[NFSD_A_SOCK_ADDR]) < sizeof(*sa)) 2014 continue; 2015 2016 xcl_name = nla_data(tb[NFSD_A_SOCK_TRANSPORT_NAME]); 2017 sa = nla_data(tb[NFSD_A_SOCK_ADDR]); 2018 2019 xprt = svc_find_listener(serv, xcl_name, net, sa); 2020 if (xprt) { 2021 if (delete) 2022 WARN_ONCE(1, "Transport type=%s already exists\n", 2023 xcl_name); 2024 svc_xprt_put(xprt); 2025 continue; 2026 } 2027 2028 ret = svc_xprt_create_from_sa(serv, xcl_name, net, sa, 0, 2029 get_current_cred()); 2030 /* always save the latest error */ 2031 if (ret < 0) 2032 err = ret; 2033 } 2034 2035 if (!serv->sv_nrthreads && list_empty(&nn->nfsd_serv->sv_permsocks)) 2036 nfsd_destroy_serv(net); 2037 2038 out_unlock_mtx: 2039 mutex_unlock(&nfsd_mutex); 2040 2041 return err; 2042 } 2043 2044 /** 2045 * nfsd_nl_listener_get_doit - get the nfs running listeners 2046 * @skb: reply buffer 2047 * @info: netlink metadata and command arguments 2048 * 2049 * Return 0 on success or a negative errno. 2050 */ 2051 int nfsd_nl_listener_get_doit(struct sk_buff *skb, struct genl_info *info) 2052 { 2053 struct svc_xprt *xprt; 2054 struct svc_serv *serv; 2055 struct nfsd_net *nn; 2056 void *hdr; 2057 int err; 2058 2059 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 2060 if (!skb) 2061 return -ENOMEM; 2062 2063 hdr = genlmsg_iput(skb, info); 2064 if (!hdr) { 2065 err = -EMSGSIZE; 2066 goto err_free_msg; 2067 } 2068 2069 mutex_lock(&nfsd_mutex); 2070 nn = net_generic(genl_info_net(info), nfsd_net_id); 2071 2072 /* no nfs server? Just send empty socket list */ 2073 if (!nn->nfsd_serv) 2074 goto out_unlock_mtx; 2075 2076 serv = nn->nfsd_serv; 2077 spin_lock_bh(&serv->sv_lock); 2078 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) { 2079 struct nlattr *attr; 2080 2081 attr = nla_nest_start(skb, NFSD_A_SERVER_SOCK_ADDR); 2082 if (!attr) { 2083 err = -EINVAL; 2084 goto err_serv_unlock; 2085 } 2086 2087 if (nla_put_string(skb, NFSD_A_SOCK_TRANSPORT_NAME, 2088 xprt->xpt_class->xcl_name) || 2089 nla_put(skb, NFSD_A_SOCK_ADDR, 2090 sizeof(struct sockaddr_storage), 2091 &xprt->xpt_local)) { 2092 err = -EINVAL; 2093 goto err_serv_unlock; 2094 } 2095 2096 nla_nest_end(skb, attr); 2097 } 2098 spin_unlock_bh(&serv->sv_lock); 2099 out_unlock_mtx: 2100 mutex_unlock(&nfsd_mutex); 2101 genlmsg_end(skb, hdr); 2102 2103 return genlmsg_reply(skb, info); 2104 2105 err_serv_unlock: 2106 spin_unlock_bh(&serv->sv_lock); 2107 mutex_unlock(&nfsd_mutex); 2108 err_free_msg: 2109 nlmsg_free(skb); 2110 2111 return err; 2112 } 2113 2114 /** 2115 * nfsd_nl_pool_mode_set_doit - set the number of running threads 2116 * @skb: reply buffer 2117 * @info: netlink metadata and command arguments 2118 * 2119 * Return 0 on success or a negative errno. 2120 */ 2121 int nfsd_nl_pool_mode_set_doit(struct sk_buff *skb, struct genl_info *info) 2122 { 2123 const struct nlattr *attr; 2124 2125 if (GENL_REQ_ATTR_CHECK(info, NFSD_A_POOL_MODE_MODE)) 2126 return -EINVAL; 2127 2128 attr = info->attrs[NFSD_A_POOL_MODE_MODE]; 2129 return sunrpc_set_pool_mode(nla_data(attr)); 2130 } 2131 2132 /** 2133 * nfsd_nl_pool_mode_get_doit - get info about pool_mode 2134 * @skb: reply buffer 2135 * @info: netlink metadata and command arguments 2136 * 2137 * Return 0 on success or a negative errno. 2138 */ 2139 int nfsd_nl_pool_mode_get_doit(struct sk_buff *skb, struct genl_info *info) 2140 { 2141 struct net *net = genl_info_net(info); 2142 char buf[16]; 2143 void *hdr; 2144 int err; 2145 2146 if (sunrpc_get_pool_mode(buf, ARRAY_SIZE(buf)) >= ARRAY_SIZE(buf)) 2147 return -ERANGE; 2148 2149 skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 2150 if (!skb) 2151 return -ENOMEM; 2152 2153 err = -EMSGSIZE; 2154 hdr = genlmsg_iput(skb, info); 2155 if (!hdr) 2156 goto err_free_msg; 2157 2158 err = nla_put_string(skb, NFSD_A_POOL_MODE_MODE, buf) | 2159 nla_put_u32(skb, NFSD_A_POOL_MODE_NPOOLS, nfsd_nrpools(net)); 2160 if (err) 2161 goto err_free_msg; 2162 2163 genlmsg_end(skb, hdr); 2164 return genlmsg_reply(skb, info); 2165 2166 err_free_msg: 2167 nlmsg_free(skb); 2168 return err; 2169 } 2170 2171 /** 2172 * nfsd_net_init - Prepare the nfsd_net portion of a new net namespace 2173 * @net: a freshly-created network namespace 2174 * 2175 * This information stays around as long as the network namespace is 2176 * alive whether or not there is an NFSD instance running in the 2177 * namespace. 2178 * 2179 * Returns zero on success, or a negative errno otherwise. 2180 */ 2181 static __net_init int nfsd_net_init(struct net *net) 2182 { 2183 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2184 int retval; 2185 int i; 2186 2187 retval = nfsd_export_init(net); 2188 if (retval) 2189 goto out_export_error; 2190 retval = nfsd_idmap_init(net); 2191 if (retval) 2192 goto out_idmap_error; 2193 retval = percpu_counter_init_many(nn->counter, 0, GFP_KERNEL, 2194 NFSD_STATS_COUNTERS_NUM); 2195 if (retval) 2196 goto out_repcache_error; 2197 2198 memset(&nn->nfsd_svcstats, 0, sizeof(nn->nfsd_svcstats)); 2199 nn->nfsd_svcstats.program = &nfsd_programs[0]; 2200 if (!nfsd_proc_stat_init(net)) { 2201 retval = -ENOMEM; 2202 goto out_proc_error; 2203 } 2204 2205 for (i = 0; i < sizeof(nn->nfsd_versions); i++) 2206 nn->nfsd_versions[i] = nfsd_support_version(i); 2207 for (i = 0; i < sizeof(nn->nfsd4_minorversions); i++) 2208 nn->nfsd4_minorversions[i] = nfsd_support_version(4); 2209 nn->nfsd_info.mutex = &nfsd_mutex; 2210 nn->nfsd_serv = NULL; 2211 nfsd4_init_leases_net(nn); 2212 get_random_bytes(&nn->siphash_key, sizeof(nn->siphash_key)); 2213 seqlock_init(&nn->writeverf_lock); 2214 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2215 spin_lock_init(&nn->local_clients_lock); 2216 INIT_LIST_HEAD(&nn->local_clients); 2217 #endif 2218 return 0; 2219 2220 out_proc_error: 2221 percpu_counter_destroy_many(nn->counter, NFSD_STATS_COUNTERS_NUM); 2222 out_repcache_error: 2223 nfsd_idmap_shutdown(net); 2224 out_idmap_error: 2225 nfsd_export_shutdown(net); 2226 out_export_error: 2227 return retval; 2228 } 2229 2230 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2231 /** 2232 * nfsd_net_pre_exit - Disconnect localio clients from net namespace 2233 * @net: a network namespace that is about to be destroyed 2234 * 2235 * This invalidates ->net pointers held by localio clients 2236 * while they can still safely access nn->counter. 2237 */ 2238 static __net_exit void nfsd_net_pre_exit(struct net *net) 2239 { 2240 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2241 2242 nfs_localio_invalidate_clients(&nn->local_clients, 2243 &nn->local_clients_lock); 2244 } 2245 #endif 2246 2247 /** 2248 * nfsd_net_exit - Release the nfsd_net portion of a net namespace 2249 * @net: a network namespace that is about to be destroyed 2250 * 2251 */ 2252 static __net_exit void nfsd_net_exit(struct net *net) 2253 { 2254 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2255 2256 nfsd_proc_stat_shutdown(net); 2257 percpu_counter_destroy_many(nn->counter, NFSD_STATS_COUNTERS_NUM); 2258 nfsd_idmap_shutdown(net); 2259 nfsd_export_shutdown(net); 2260 } 2261 2262 static struct pernet_operations nfsd_net_ops = { 2263 .init = nfsd_net_init, 2264 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 2265 .pre_exit = nfsd_net_pre_exit, 2266 #endif 2267 .exit = nfsd_net_exit, 2268 .id = &nfsd_net_id, 2269 .size = sizeof(struct nfsd_net), 2270 }; 2271 2272 static int __init init_nfsd(void) 2273 { 2274 int retval; 2275 2276 nfsd_debugfs_init(); 2277 2278 retval = nfsd4_init_slabs(); 2279 if (retval) 2280 return retval; 2281 retval = nfsd4_init_pnfs(); 2282 if (retval) 2283 goto out_free_slabs; 2284 retval = nfsd_drc_slab_create(); 2285 if (retval) 2286 goto out_free_pnfs; 2287 nfsd_lockd_init(); /* lockd->nfsd callbacks */ 2288 retval = register_pernet_subsys(&nfsd_net_ops); 2289 if (retval < 0) 2290 goto out_free_lockd; 2291 retval = register_cld_notifier(); 2292 if (retval) 2293 goto out_free_subsys; 2294 retval = nfsd4_create_laundry_wq(); 2295 if (retval) 2296 goto out_free_cld; 2297 retval = register_filesystem(&nfsd_fs_type); 2298 if (retval) 2299 goto out_free_nfsd4; 2300 retval = genl_register_family(&nfsd_nl_family); 2301 if (retval) 2302 goto out_free_filesystem; 2303 retval = create_proc_exports_entry(); 2304 if (retval) 2305 goto out_free_all; 2306 nfsd_localio_ops_init(); 2307 2308 return 0; 2309 out_free_all: 2310 genl_unregister_family(&nfsd_nl_family); 2311 out_free_filesystem: 2312 unregister_filesystem(&nfsd_fs_type); 2313 out_free_nfsd4: 2314 nfsd4_destroy_laundry_wq(); 2315 out_free_cld: 2316 unregister_cld_notifier(); 2317 out_free_subsys: 2318 unregister_pernet_subsys(&nfsd_net_ops); 2319 out_free_lockd: 2320 nfsd_lockd_shutdown(); 2321 nfsd_drc_slab_free(); 2322 out_free_pnfs: 2323 nfsd4_exit_pnfs(); 2324 out_free_slabs: 2325 nfsd4_free_slabs(); 2326 nfsd_debugfs_exit(); 2327 return retval; 2328 } 2329 2330 static void __exit exit_nfsd(void) 2331 { 2332 remove_proc_entry("fs/nfs/exports", NULL); 2333 remove_proc_entry("fs/nfs", NULL); 2334 genl_unregister_family(&nfsd_nl_family); 2335 unregister_filesystem(&nfsd_fs_type); 2336 nfsd4_destroy_laundry_wq(); 2337 unregister_cld_notifier(); 2338 unregister_pernet_subsys(&nfsd_net_ops); 2339 nfsd_drc_slab_free(); 2340 nfsd_lockd_shutdown(); 2341 nfsd4_free_slabs(); 2342 nfsd4_exit_pnfs(); 2343 nfsd_debugfs_exit(); 2344 } 2345 2346 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 2347 MODULE_DESCRIPTION("In-kernel NFS server"); 2348 MODULE_LICENSE("GPL"); 2349 module_init(init_nfsd) 2350 module_exit(exit_nfsd) 2351