1 /* 2 * Syscall interface to knfsd. 3 * 4 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 5 */ 6 7 #include <linux/slab.h> 8 #include <linux/namei.h> 9 #include <linux/ctype.h> 10 11 #include <linux/sunrpc/svcsock.h> 12 #include <linux/lockd/lockd.h> 13 #include <linux/sunrpc/clnt.h> 14 #include <linux/sunrpc/gss_api.h> 15 #include <linux/sunrpc/gss_krb5_enctypes.h> 16 #include <linux/sunrpc/rpc_pipe_fs.h> 17 #include <linux/module.h> 18 19 #include "idmap.h" 20 #include "nfsd.h" 21 #include "cache.h" 22 #include "fault_inject.h" 23 #include "netns.h" 24 25 /* 26 * We have a single directory with several nodes in it. 27 */ 28 enum { 29 NFSD_Root = 1, 30 NFSD_List, 31 NFSD_Export_features, 32 NFSD_Fh, 33 NFSD_FO_UnlockIP, 34 NFSD_FO_UnlockFS, 35 NFSD_Threads, 36 NFSD_Pool_Threads, 37 NFSD_Pool_Stats, 38 NFSD_Versions, 39 NFSD_Ports, 40 NFSD_MaxBlkSize, 41 NFSD_SupportedEnctypes, 42 /* 43 * The below MUST come last. Otherwise we leave a hole in nfsd_files[] 44 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops 45 */ 46 #ifdef CONFIG_NFSD_V4 47 NFSD_Leasetime, 48 NFSD_Gracetime, 49 NFSD_RecoveryDir, 50 #endif 51 }; 52 53 /* 54 * write() for these nodes. 55 */ 56 static ssize_t write_filehandle(struct file *file, char *buf, size_t size); 57 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size); 58 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size); 59 static ssize_t write_threads(struct file *file, char *buf, size_t size); 60 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size); 61 static ssize_t write_versions(struct file *file, char *buf, size_t size); 62 static ssize_t write_ports(struct file *file, char *buf, size_t size); 63 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size); 64 #ifdef CONFIG_NFSD_V4 65 static ssize_t write_leasetime(struct file *file, char *buf, size_t size); 66 static ssize_t write_gracetime(struct file *file, char *buf, size_t size); 67 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size); 68 #endif 69 70 static ssize_t (*write_op[])(struct file *, char *, size_t) = { 71 [NFSD_Fh] = write_filehandle, 72 [NFSD_FO_UnlockIP] = write_unlock_ip, 73 [NFSD_FO_UnlockFS] = write_unlock_fs, 74 [NFSD_Threads] = write_threads, 75 [NFSD_Pool_Threads] = write_pool_threads, 76 [NFSD_Versions] = write_versions, 77 [NFSD_Ports] = write_ports, 78 [NFSD_MaxBlkSize] = write_maxblksize, 79 #ifdef CONFIG_NFSD_V4 80 [NFSD_Leasetime] = write_leasetime, 81 [NFSD_Gracetime] = write_gracetime, 82 [NFSD_RecoveryDir] = write_recoverydir, 83 #endif 84 }; 85 86 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos) 87 { 88 ino_t ino = file->f_path.dentry->d_inode->i_ino; 89 char *data; 90 ssize_t rv; 91 92 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino]) 93 return -EINVAL; 94 95 data = simple_transaction_get(file, buf, size); 96 if (IS_ERR(data)) 97 return PTR_ERR(data); 98 99 rv = write_op[ino](file, data, size); 100 if (rv >= 0) { 101 simple_transaction_set(file, rv); 102 rv = size; 103 } 104 return rv; 105 } 106 107 static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 108 { 109 if (! file->private_data) { 110 /* An attempt to read a transaction file without writing 111 * causes a 0-byte write so that the file can return 112 * state information 113 */ 114 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos); 115 if (rv < 0) 116 return rv; 117 } 118 return simple_transaction_read(file, buf, size, pos); 119 } 120 121 static const struct file_operations transaction_ops = { 122 .write = nfsctl_transaction_write, 123 .read = nfsctl_transaction_read, 124 .release = simple_transaction_release, 125 .llseek = default_llseek, 126 }; 127 128 static int exports_open(struct inode *inode, struct file *file) 129 { 130 int err; 131 struct seq_file *seq; 132 struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id); 133 134 err = seq_open(file, &nfs_exports_op); 135 if (err) 136 return err; 137 138 seq = file->private_data; 139 seq->private = nn->svc_export_cache; 140 return 0; 141 } 142 143 static const struct file_operations exports_operations = { 144 .open = exports_open, 145 .read = seq_read, 146 .llseek = seq_lseek, 147 .release = seq_release, 148 .owner = THIS_MODULE, 149 }; 150 151 static int export_features_show(struct seq_file *m, void *v) 152 { 153 seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS); 154 return 0; 155 } 156 157 static int export_features_open(struct inode *inode, struct file *file) 158 { 159 return single_open(file, export_features_show, NULL); 160 } 161 162 static struct file_operations export_features_operations = { 163 .open = export_features_open, 164 .read = seq_read, 165 .llseek = seq_lseek, 166 .release = single_release, 167 }; 168 169 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE) 170 static int supported_enctypes_show(struct seq_file *m, void *v) 171 { 172 seq_printf(m, KRB5_SUPPORTED_ENCTYPES); 173 return 0; 174 } 175 176 static int supported_enctypes_open(struct inode *inode, struct file *file) 177 { 178 return single_open(file, supported_enctypes_show, NULL); 179 } 180 181 static struct file_operations supported_enctypes_ops = { 182 .open = supported_enctypes_open, 183 .read = seq_read, 184 .llseek = seq_lseek, 185 .release = single_release, 186 }; 187 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */ 188 189 extern int nfsd_pool_stats_open(struct inode *inode, struct file *file); 190 extern int nfsd_pool_stats_release(struct inode *inode, struct file *file); 191 192 static const struct file_operations pool_stats_operations = { 193 .open = nfsd_pool_stats_open, 194 .read = seq_read, 195 .llseek = seq_lseek, 196 .release = nfsd_pool_stats_release, 197 .owner = THIS_MODULE, 198 }; 199 200 /*----------------------------------------------------------------------------*/ 201 /* 202 * payload - write methods 203 */ 204 205 206 /** 207 * write_unlock_ip - Release all locks used by a client 208 * 209 * Experimental. 210 * 211 * Input: 212 * buf: '\n'-terminated C string containing a 213 * presentation format IP address 214 * size: length of C string in @buf 215 * Output: 216 * On success: returns zero if all specified locks were released; 217 * returns one if one or more locks were not released 218 * On error: return code is negative errno value 219 */ 220 static ssize_t write_unlock_ip(struct file *file, char *buf, size_t size) 221 { 222 struct sockaddr_storage address; 223 struct sockaddr *sap = (struct sockaddr *)&address; 224 size_t salen = sizeof(address); 225 char *fo_path; 226 227 /* sanity check */ 228 if (size == 0) 229 return -EINVAL; 230 231 if (buf[size-1] != '\n') 232 return -EINVAL; 233 234 fo_path = buf; 235 if (qword_get(&buf, fo_path, size) < 0) 236 return -EINVAL; 237 238 if (rpc_pton(&init_net, fo_path, size, sap, salen) == 0) 239 return -EINVAL; 240 241 return nlmsvc_unlock_all_by_ip(sap); 242 } 243 244 /** 245 * write_unlock_fs - Release all locks on a local file system 246 * 247 * Experimental. 248 * 249 * Input: 250 * buf: '\n'-terminated C string containing the 251 * absolute pathname of a local file system 252 * size: length of C string in @buf 253 * Output: 254 * On success: returns zero if all specified locks were released; 255 * returns one if one or more locks were not released 256 * On error: return code is negative errno value 257 */ 258 static ssize_t write_unlock_fs(struct file *file, char *buf, size_t size) 259 { 260 struct path path; 261 char *fo_path; 262 int error; 263 264 /* sanity check */ 265 if (size == 0) 266 return -EINVAL; 267 268 if (buf[size-1] != '\n') 269 return -EINVAL; 270 271 fo_path = buf; 272 if (qword_get(&buf, fo_path, size) < 0) 273 return -EINVAL; 274 275 error = kern_path(fo_path, 0, &path); 276 if (error) 277 return error; 278 279 /* 280 * XXX: Needs better sanity checking. Otherwise we could end up 281 * releasing locks on the wrong file system. 282 * 283 * For example: 284 * 1. Does the path refer to a directory? 285 * 2. Is that directory a mount point, or 286 * 3. Is that directory the root of an exported file system? 287 */ 288 error = nlmsvc_unlock_all_by_sb(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 uninitialized_var(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 if (maxsize > NFS3_FHSIZE) 348 maxsize = NFS3_FHSIZE; 349 350 if (qword_get(&mesg, mesg, size)>0) 351 return -EINVAL; 352 353 /* we have all the words, they are in buf.. */ 354 dom = unix_domain_find(dname); 355 if (!dom) 356 return -ENOMEM; 357 358 len = exp_rootfh(&init_net, dom, path, &fh, maxsize); 359 auth_domain_put(dom); 360 if (len) 361 return len; 362 363 mesg = buf; 364 len = SIMPLE_TRANSACTION_LIMIT; 365 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size); 366 mesg[-1] = '\n'; 367 return mesg - buf; 368 } 369 370 /** 371 * write_threads - Start NFSD, or report the current number of running threads 372 * 373 * Input: 374 * buf: ignored 375 * size: zero 376 * Output: 377 * On success: passed-in buffer filled with '\n'-terminated C 378 * string numeric value representing the number of 379 * running NFSD threads; 380 * return code is the size in bytes of the string 381 * On error: return code is zero 382 * 383 * OR 384 * 385 * Input: 386 * buf: C string containing an unsigned 387 * integer value representing the 388 * number of NFSD threads to start 389 * size: non-zero length of C string in @buf 390 * Output: 391 * On success: NFS service is started; 392 * passed-in buffer filled with '\n'-terminated C 393 * string numeric value representing the number of 394 * running NFSD threads; 395 * return code is the size in bytes of the string 396 * On error: return code is zero or a negative errno value 397 */ 398 static ssize_t write_threads(struct file *file, char *buf, size_t size) 399 { 400 char *mesg = buf; 401 int rv; 402 if (size > 0) { 403 int newthreads; 404 rv = get_int(&mesg, &newthreads); 405 if (rv) 406 return rv; 407 if (newthreads < 0) 408 return -EINVAL; 409 rv = nfsd_svc(NFS_PORT, newthreads); 410 if (rv < 0) 411 return rv; 412 } else 413 rv = nfsd_nrthreads(); 414 415 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv); 416 } 417 418 /** 419 * write_pool_threads - Set or report the current number of threads per pool 420 * 421 * Input: 422 * buf: ignored 423 * size: zero 424 * 425 * OR 426 * 427 * Input: 428 * buf: C string containing whitespace- 429 * separated unsigned integer values 430 * representing the number of NFSD 431 * threads to start in each pool 432 * size: non-zero length of C string in @buf 433 * Output: 434 * On success: passed-in buffer filled with '\n'-terminated C 435 * string containing integer values representing the 436 * number of NFSD threads in each pool; 437 * return code is the size in bytes of the string 438 * On error: return code is zero or a negative errno value 439 */ 440 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size) 441 { 442 /* if size > 0, look for an array of number of threads per node 443 * and apply them then write out number of threads per node as reply 444 */ 445 char *mesg = buf; 446 int i; 447 int rv; 448 int len; 449 int npools; 450 int *nthreads; 451 452 mutex_lock(&nfsd_mutex); 453 npools = nfsd_nrpools(); 454 if (npools == 0) { 455 /* 456 * NFS is shut down. The admin can start it by 457 * writing to the threads file but NOT the pool_threads 458 * file, sorry. Report zero threads. 459 */ 460 mutex_unlock(&nfsd_mutex); 461 strcpy(buf, "0\n"); 462 return strlen(buf); 463 } 464 465 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL); 466 rv = -ENOMEM; 467 if (nthreads == NULL) 468 goto out_free; 469 470 if (size > 0) { 471 for (i = 0; i < npools; i++) { 472 rv = get_int(&mesg, &nthreads[i]); 473 if (rv == -ENOENT) 474 break; /* fewer numbers than pools */ 475 if (rv) 476 goto out_free; /* syntax error */ 477 rv = -EINVAL; 478 if (nthreads[i] < 0) 479 goto out_free; 480 } 481 rv = nfsd_set_nrthreads(i, nthreads); 482 if (rv) 483 goto out_free; 484 } 485 486 rv = nfsd_get_nrthreads(npools, nthreads); 487 if (rv) 488 goto out_free; 489 490 mesg = buf; 491 size = SIMPLE_TRANSACTION_LIMIT; 492 for (i = 0; i < npools && size > 0; i++) { 493 snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' ')); 494 len = strlen(mesg); 495 size -= len; 496 mesg += len; 497 } 498 rv = mesg - buf; 499 out_free: 500 kfree(nthreads); 501 mutex_unlock(&nfsd_mutex); 502 return rv; 503 } 504 505 static ssize_t __write_versions(struct file *file, char *buf, size_t size) 506 { 507 char *mesg = buf; 508 char *vers, *minorp, sign; 509 int len, num, remaining; 510 unsigned minor; 511 ssize_t tlen = 0; 512 char *sep; 513 514 if (size>0) { 515 if (nfsd_serv) 516 /* Cannot change versions without updating 517 * nfsd_serv->sv_xdrsize, and reallocing 518 * rq_argp and rq_resp 519 */ 520 return -EBUSY; 521 if (buf[size-1] != '\n') 522 return -EINVAL; 523 buf[size-1] = 0; 524 525 vers = mesg; 526 len = qword_get(&mesg, vers, size); 527 if (len <= 0) return -EINVAL; 528 do { 529 sign = *vers; 530 if (sign == '+' || sign == '-') 531 num = simple_strtol((vers+1), &minorp, 0); 532 else 533 num = simple_strtol(vers, &minorp, 0); 534 if (*minorp == '.') { 535 if (num < 4) 536 return -EINVAL; 537 minor = simple_strtoul(minorp+1, NULL, 0); 538 if (minor == 0) 539 return -EINVAL; 540 if (nfsd_minorversion(minor, sign == '-' ? 541 NFSD_CLEAR : NFSD_SET) < 0) 542 return -EINVAL; 543 goto next; 544 } 545 switch(num) { 546 case 2: 547 case 3: 548 case 4: 549 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET); 550 break; 551 default: 552 return -EINVAL; 553 } 554 next: 555 vers += len + 1; 556 } while ((len = qword_get(&mesg, vers, size)) > 0); 557 /* If all get turned off, turn them back on, as 558 * having no versions is BAD 559 */ 560 nfsd_reset_versions(); 561 } 562 563 /* Now write current state into reply buffer */ 564 len = 0; 565 sep = ""; 566 remaining = SIMPLE_TRANSACTION_LIMIT; 567 for (num=2 ; num <= 4 ; num++) 568 if (nfsd_vers(num, NFSD_AVAIL)) { 569 len = snprintf(buf, remaining, "%s%c%d", sep, 570 nfsd_vers(num, NFSD_TEST)?'+':'-', 571 num); 572 sep = " "; 573 574 if (len > remaining) 575 break; 576 remaining -= len; 577 buf += len; 578 tlen += len; 579 } 580 if (nfsd_vers(4, NFSD_AVAIL)) 581 for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION; 582 minor++) { 583 len = snprintf(buf, remaining, " %c4.%u", 584 (nfsd_vers(4, NFSD_TEST) && 585 nfsd_minorversion(minor, NFSD_TEST)) ? 586 '+' : '-', 587 minor); 588 589 if (len > remaining) 590 break; 591 remaining -= len; 592 buf += len; 593 tlen += len; 594 } 595 596 len = snprintf(buf, remaining, "\n"); 597 if (len > remaining) 598 return -EINVAL; 599 return tlen + len; 600 } 601 602 /** 603 * write_versions - Set or report the available NFS protocol versions 604 * 605 * Input: 606 * buf: ignored 607 * size: zero 608 * Output: 609 * On success: passed-in buffer filled with '\n'-terminated C 610 * string containing positive or negative integer 611 * values representing the current status of each 612 * protocol version; 613 * return code is the size in bytes of the string 614 * On error: return code is zero or a negative errno value 615 * 616 * OR 617 * 618 * Input: 619 * buf: C string containing whitespace- 620 * separated positive or negative 621 * integer values representing NFS 622 * protocol versions to enable ("+n") 623 * or disable ("-n") 624 * size: non-zero length of C string in @buf 625 * Output: 626 * On success: status of zero or more protocol versions has 627 * been updated; passed-in buffer filled with 628 * '\n'-terminated C string containing positive 629 * or negative integer values representing the 630 * current status of each protocol version; 631 * return code is the size in bytes of the string 632 * On error: return code is zero or a negative errno value 633 */ 634 static ssize_t write_versions(struct file *file, char *buf, size_t size) 635 { 636 ssize_t rv; 637 638 mutex_lock(&nfsd_mutex); 639 rv = __write_versions(file, buf, size); 640 mutex_unlock(&nfsd_mutex); 641 return rv; 642 } 643 644 /* 645 * Zero-length write. Return a list of NFSD's current listener 646 * transports. 647 */ 648 static ssize_t __write_ports_names(char *buf) 649 { 650 if (nfsd_serv == NULL) 651 return 0; 652 return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT); 653 } 654 655 /* 656 * A single 'fd' number was written, in which case it must be for 657 * a socket of a supported family/protocol, and we use it as an 658 * nfsd listener. 659 */ 660 static ssize_t __write_ports_addfd(char *buf) 661 { 662 char *mesg = buf; 663 int fd, err; 664 struct net *net = &init_net; 665 666 err = get_int(&mesg, &fd); 667 if (err != 0 || fd < 0) 668 return -EINVAL; 669 670 err = nfsd_create_serv(); 671 if (err != 0) 672 return err; 673 674 err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT); 675 if (err < 0) { 676 if (nfsd_serv->sv_nrthreads == 1) 677 svc_shutdown_net(nfsd_serv, net); 678 svc_destroy(nfsd_serv); 679 return err; 680 } 681 682 /* Decrease the count, but don't shut down the service */ 683 nfsd_serv->sv_nrthreads--; 684 return err; 685 } 686 687 /* 688 * A '-' followed by the 'name' of a socket means we close the socket. 689 */ 690 static ssize_t __write_ports_delfd(char *buf) 691 { 692 char *toclose; 693 int len = 0; 694 695 toclose = kstrdup(buf + 1, GFP_KERNEL); 696 if (toclose == NULL) 697 return -ENOMEM; 698 699 if (nfsd_serv != NULL) 700 len = svc_sock_names(nfsd_serv, buf, 701 SIMPLE_TRANSACTION_LIMIT, toclose); 702 kfree(toclose); 703 return len; 704 } 705 706 /* 707 * A transport listener is added by writing it's transport name and 708 * a port number. 709 */ 710 static ssize_t __write_ports_addxprt(char *buf) 711 { 712 char transport[16]; 713 struct svc_xprt *xprt; 714 int port, err; 715 struct net *net = &init_net; 716 717 if (sscanf(buf, "%15s %4u", transport, &port) != 2) 718 return -EINVAL; 719 720 if (port < 1 || port > USHRT_MAX) 721 return -EINVAL; 722 723 err = nfsd_create_serv(); 724 if (err != 0) 725 return err; 726 727 err = svc_create_xprt(nfsd_serv, transport, net, 728 PF_INET, port, SVC_SOCK_ANONYMOUS); 729 if (err < 0) 730 goto out_err; 731 732 err = svc_create_xprt(nfsd_serv, transport, net, 733 PF_INET6, port, SVC_SOCK_ANONYMOUS); 734 if (err < 0 && err != -EAFNOSUPPORT) 735 goto out_close; 736 737 /* Decrease the count, but don't shut down the service */ 738 nfsd_serv->sv_nrthreads--; 739 return 0; 740 out_close: 741 xprt = svc_find_xprt(nfsd_serv, transport, net, PF_INET, port); 742 if (xprt != NULL) { 743 svc_close_xprt(xprt); 744 svc_xprt_put(xprt); 745 } 746 out_err: 747 if (nfsd_serv->sv_nrthreads == 1) 748 svc_shutdown_net(nfsd_serv, net); 749 svc_destroy(nfsd_serv); 750 return err; 751 } 752 753 /* 754 * A transport listener is removed by writing a "-", it's transport 755 * name, and it's port number. 756 */ 757 static ssize_t __write_ports_delxprt(char *buf) 758 { 759 struct svc_xprt *xprt; 760 char transport[16]; 761 int port; 762 763 if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2) 764 return -EINVAL; 765 766 if (port < 1 || port > USHRT_MAX || nfsd_serv == NULL) 767 return -EINVAL; 768 769 xprt = svc_find_xprt(nfsd_serv, transport, &init_net, AF_UNSPEC, port); 770 if (xprt == NULL) 771 return -ENOTCONN; 772 773 svc_close_xprt(xprt); 774 svc_xprt_put(xprt); 775 return 0; 776 } 777 778 static ssize_t __write_ports(struct file *file, char *buf, size_t size) 779 { 780 if (size == 0) 781 return __write_ports_names(buf); 782 783 if (isdigit(buf[0])) 784 return __write_ports_addfd(buf); 785 786 if (buf[0] == '-' && isdigit(buf[1])) 787 return __write_ports_delfd(buf); 788 789 if (isalpha(buf[0])) 790 return __write_ports_addxprt(buf); 791 792 if (buf[0] == '-' && isalpha(buf[1])) 793 return __write_ports_delxprt(buf); 794 795 return -EINVAL; 796 } 797 798 /** 799 * write_ports - Pass a socket file descriptor or transport name to listen on 800 * 801 * Input: 802 * buf: ignored 803 * size: zero 804 * Output: 805 * On success: passed-in buffer filled with a '\n'-terminated C 806 * string containing a whitespace-separated list of 807 * named NFSD listeners; 808 * return code is the size in bytes of the string 809 * On error: return code is zero or a negative errno value 810 * 811 * OR 812 * 813 * Input: 814 * buf: C string containing an unsigned 815 * integer value representing a bound 816 * but unconnected socket that is to be 817 * used as an NFSD listener; listen(3) 818 * must be called for a SOCK_STREAM 819 * socket, otherwise it is ignored 820 * size: non-zero length of C string in @buf 821 * Output: 822 * On success: NFS service is started; 823 * passed-in buffer filled with a '\n'-terminated C 824 * string containing a unique alphanumeric name of 825 * the listener; 826 * return code is the size in bytes of the string 827 * On error: return code is a negative errno value 828 * 829 * OR 830 * 831 * Input: 832 * buf: C string containing a "-" followed 833 * by an integer value representing a 834 * previously passed in socket file 835 * descriptor 836 * size: non-zero length of C string in @buf 837 * Output: 838 * On success: NFS service no longer listens on that socket; 839 * passed-in buffer filled with a '\n'-terminated C 840 * string containing a unique name of the listener; 841 * return code is the size in bytes of the string 842 * On error: return code is a negative errno value 843 * 844 * OR 845 * 846 * Input: 847 * buf: C string containing a transport 848 * name and an unsigned integer value 849 * representing the port to listen on, 850 * separated by whitespace 851 * size: non-zero length of C string in @buf 852 * Output: 853 * On success: returns zero; NFS service is started 854 * On error: return code is a negative errno value 855 * 856 * OR 857 * 858 * Input: 859 * buf: C string containing a "-" followed 860 * by a transport name and an unsigned 861 * integer value representing the port 862 * to listen on, separated by whitespace 863 * size: non-zero length of C string in @buf 864 * Output: 865 * On success: returns zero; NFS service no longer listens 866 * on that transport 867 * On error: return code is a negative errno value 868 */ 869 static ssize_t write_ports(struct file *file, char *buf, size_t size) 870 { 871 ssize_t rv; 872 873 mutex_lock(&nfsd_mutex); 874 rv = __write_ports(file, buf, size); 875 mutex_unlock(&nfsd_mutex); 876 return rv; 877 } 878 879 880 int nfsd_max_blksize; 881 882 /** 883 * write_maxblksize - Set or report the current NFS blksize 884 * 885 * Input: 886 * buf: ignored 887 * size: zero 888 * 889 * OR 890 * 891 * Input: 892 * buf: C string containing an unsigned 893 * integer value representing the new 894 * NFS blksize 895 * size: non-zero length of C string in @buf 896 * Output: 897 * On success: passed-in buffer filled with '\n'-terminated C string 898 * containing numeric value of the current NFS blksize 899 * setting; 900 * return code is the size in bytes of the string 901 * On error: return code is zero or a negative errno value 902 */ 903 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size) 904 { 905 char *mesg = buf; 906 if (size > 0) { 907 int bsize; 908 int rv = get_int(&mesg, &bsize); 909 if (rv) 910 return rv; 911 /* force bsize into allowed range and 912 * required alignment. 913 */ 914 if (bsize < 1024) 915 bsize = 1024; 916 if (bsize > NFSSVC_MAXBLKSIZE) 917 bsize = NFSSVC_MAXBLKSIZE; 918 bsize &= ~(1024-1); 919 mutex_lock(&nfsd_mutex); 920 if (nfsd_serv) { 921 mutex_unlock(&nfsd_mutex); 922 return -EBUSY; 923 } 924 nfsd_max_blksize = bsize; 925 mutex_unlock(&nfsd_mutex); 926 } 927 928 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", 929 nfsd_max_blksize); 930 } 931 932 #ifdef CONFIG_NFSD_V4 933 static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time) 934 { 935 char *mesg = buf; 936 int rv, i; 937 938 if (size > 0) { 939 if (nfsd_serv) 940 return -EBUSY; 941 rv = get_int(&mesg, &i); 942 if (rv) 943 return rv; 944 /* 945 * Some sanity checking. We don't have a reason for 946 * these particular numbers, but problems with the 947 * extremes are: 948 * - Too short: the briefest network outage may 949 * cause clients to lose all their locks. Also, 950 * the frequent polling may be wasteful. 951 * - Too long: do you really want reboot recovery 952 * to take more than an hour? Or to make other 953 * clients wait an hour before being able to 954 * revoke a dead client's locks? 955 */ 956 if (i < 10 || i > 3600) 957 return -EINVAL; 958 *time = i; 959 } 960 961 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time); 962 } 963 964 static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time) 965 { 966 ssize_t rv; 967 968 mutex_lock(&nfsd_mutex); 969 rv = __nfsd4_write_time(file, buf, size, time); 970 mutex_unlock(&nfsd_mutex); 971 return rv; 972 } 973 974 /** 975 * write_leasetime - Set or report the current NFSv4 lease time 976 * 977 * Input: 978 * buf: ignored 979 * size: zero 980 * 981 * OR 982 * 983 * Input: 984 * buf: C string containing an unsigned 985 * integer value representing the new 986 * NFSv4 lease expiry time 987 * size: non-zero length of C string in @buf 988 * Output: 989 * On success: passed-in buffer filled with '\n'-terminated C 990 * string containing unsigned integer value of the 991 * current lease expiry time; 992 * return code is the size in bytes of the string 993 * On error: return code is zero or a negative errno value 994 */ 995 static ssize_t write_leasetime(struct file *file, char *buf, size_t size) 996 { 997 return nfsd4_write_time(file, buf, size, &nfsd4_lease); 998 } 999 1000 /** 1001 * write_gracetime - Set or report current NFSv4 grace period time 1002 * 1003 * As above, but sets the time of the NFSv4 grace period. 1004 * 1005 * Note this should never be set to less than the *previous* 1006 * lease-period time, but we don't try to enforce this. (In the common 1007 * case (a new boot), we don't know what the previous lease time was 1008 * anyway.) 1009 */ 1010 static ssize_t write_gracetime(struct file *file, char *buf, size_t size) 1011 { 1012 return nfsd4_write_time(file, buf, size, &nfsd4_grace); 1013 } 1014 1015 extern char *nfs4_recoverydir(void); 1016 1017 static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size) 1018 { 1019 char *mesg = buf; 1020 char *recdir; 1021 int len, status; 1022 1023 if (size > 0) { 1024 if (nfsd_serv) 1025 return -EBUSY; 1026 if (size > PATH_MAX || buf[size-1] != '\n') 1027 return -EINVAL; 1028 buf[size-1] = 0; 1029 1030 recdir = mesg; 1031 len = qword_get(&mesg, recdir, size); 1032 if (len <= 0) 1033 return -EINVAL; 1034 1035 status = nfs4_reset_recoverydir(recdir); 1036 if (status) 1037 return status; 1038 } 1039 1040 return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n", 1041 nfs4_recoverydir()); 1042 } 1043 1044 /** 1045 * write_recoverydir - Set or report the pathname of the recovery directory 1046 * 1047 * Input: 1048 * buf: ignored 1049 * size: zero 1050 * 1051 * OR 1052 * 1053 * Input: 1054 * buf: C string containing the pathname 1055 * of the directory on a local file 1056 * system containing permanent NFSv4 1057 * recovery data 1058 * size: non-zero length of C string in @buf 1059 * Output: 1060 * On success: passed-in buffer filled with '\n'-terminated C string 1061 * containing the current recovery pathname setting; 1062 * return code is the size in bytes of the string 1063 * On error: return code is zero or a negative errno value 1064 */ 1065 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size) 1066 { 1067 ssize_t rv; 1068 1069 mutex_lock(&nfsd_mutex); 1070 rv = __write_recoverydir(file, buf, size); 1071 mutex_unlock(&nfsd_mutex); 1072 return rv; 1073 } 1074 1075 #endif 1076 1077 /*----------------------------------------------------------------------------*/ 1078 /* 1079 * populating the filesystem. 1080 */ 1081 1082 static int nfsd_fill_super(struct super_block * sb, void * data, int silent) 1083 { 1084 static struct tree_descr nfsd_files[] = { 1085 [NFSD_List] = {"exports", &exports_operations, S_IRUGO}, 1086 [NFSD_Export_features] = {"export_features", 1087 &export_features_operations, S_IRUGO}, 1088 [NFSD_FO_UnlockIP] = {"unlock_ip", 1089 &transaction_ops, S_IWUSR|S_IRUSR}, 1090 [NFSD_FO_UnlockFS] = {"unlock_filesystem", 1091 &transaction_ops, S_IWUSR|S_IRUSR}, 1092 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR}, 1093 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1094 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR}, 1095 [NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO}, 1096 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR}, 1097 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO}, 1098 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO}, 1099 #if defined(CONFIG_SUNRPC_GSS) || defined(CONFIG_SUNRPC_GSS_MODULE) 1100 [NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO}, 1101 #endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */ 1102 #ifdef CONFIG_NFSD_V4 1103 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1104 [NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR|S_IRUSR}, 1105 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR}, 1106 #endif 1107 /* last one */ {""} 1108 }; 1109 return simple_fill_super(sb, 0x6e667364, nfsd_files); 1110 } 1111 1112 static struct dentry *nfsd_mount(struct file_system_type *fs_type, 1113 int flags, const char *dev_name, void *data) 1114 { 1115 return mount_single(fs_type, flags, data, nfsd_fill_super); 1116 } 1117 1118 static struct file_system_type nfsd_fs_type = { 1119 .owner = THIS_MODULE, 1120 .name = "nfsd", 1121 .mount = nfsd_mount, 1122 .kill_sb = kill_litter_super, 1123 }; 1124 1125 #ifdef CONFIG_PROC_FS 1126 static int create_proc_exports_entry(void) 1127 { 1128 struct proc_dir_entry *entry; 1129 1130 entry = proc_mkdir("fs/nfs", NULL); 1131 if (!entry) 1132 return -ENOMEM; 1133 entry = proc_create("exports", 0, entry, &exports_operations); 1134 if (!entry) 1135 return -ENOMEM; 1136 return 0; 1137 } 1138 #else /* CONFIG_PROC_FS */ 1139 static int create_proc_exports_entry(void) 1140 { 1141 return 0; 1142 } 1143 #endif 1144 1145 int nfsd_net_id; 1146 1147 static __net_init int nfsd_init_net(struct net *net) 1148 { 1149 int retval; 1150 1151 retval = nfsd_export_init(net); 1152 if (retval) 1153 goto out_export_error; 1154 retval = nfsd_idmap_init(net); 1155 if (retval) 1156 goto out_idmap_error; 1157 return 0; 1158 1159 out_idmap_error: 1160 nfsd_export_shutdown(net); 1161 out_export_error: 1162 return retval; 1163 } 1164 1165 static __net_exit void nfsd_exit_net(struct net *net) 1166 { 1167 nfsd_idmap_shutdown(net); 1168 nfsd_export_shutdown(net); 1169 } 1170 1171 static struct pernet_operations nfsd_net_ops = { 1172 .init = nfsd_init_net, 1173 .exit = nfsd_exit_net, 1174 .id = &nfsd_net_id, 1175 .size = sizeof(struct nfsd_net), 1176 }; 1177 1178 static int __init init_nfsd(void) 1179 { 1180 int retval; 1181 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n"); 1182 1183 retval = register_cld_notifier(); 1184 if (retval) 1185 return retval; 1186 retval = register_pernet_subsys(&nfsd_net_ops); 1187 if (retval < 0) 1188 goto out_unregister_notifier; 1189 retval = nfsd4_init_slabs(); 1190 if (retval) 1191 goto out_unregister_pernet; 1192 nfs4_state_init(); 1193 retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */ 1194 if (retval) 1195 goto out_free_slabs; 1196 nfsd_stat_init(); /* Statistics */ 1197 retval = nfsd_reply_cache_init(); 1198 if (retval) 1199 goto out_free_stat; 1200 nfsd_lockd_init(); /* lockd->nfsd callbacks */ 1201 retval = create_proc_exports_entry(); 1202 if (retval) 1203 goto out_free_lockd; 1204 retval = register_filesystem(&nfsd_fs_type); 1205 if (retval) 1206 goto out_free_all; 1207 return 0; 1208 out_free_all: 1209 remove_proc_entry("fs/nfs/exports", NULL); 1210 remove_proc_entry("fs/nfs", NULL); 1211 out_free_lockd: 1212 nfsd_lockd_shutdown(); 1213 nfsd_reply_cache_shutdown(); 1214 out_free_stat: 1215 nfsd_stat_shutdown(); 1216 nfsd_fault_inject_cleanup(); 1217 out_free_slabs: 1218 nfsd4_free_slabs(); 1219 out_unregister_pernet: 1220 unregister_pernet_subsys(&nfsd_net_ops); 1221 out_unregister_notifier: 1222 unregister_cld_notifier(); 1223 return retval; 1224 } 1225 1226 static void __exit exit_nfsd(void) 1227 { 1228 nfsd_reply_cache_shutdown(); 1229 remove_proc_entry("fs/nfs/exports", NULL); 1230 remove_proc_entry("fs/nfs", NULL); 1231 nfsd_stat_shutdown(); 1232 nfsd_lockd_shutdown(); 1233 nfsd4_free_slabs(); 1234 nfsd_fault_inject_cleanup(); 1235 unregister_filesystem(&nfsd_fs_type); 1236 unregister_pernet_subsys(&nfsd_net_ops); 1237 unregister_cld_notifier(); 1238 } 1239 1240 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 1241 MODULE_LICENSE("GPL"); 1242 module_init(init_nfsd) 1243 module_exit(exit_nfsd) 1244