1 /* 2 * linux/fs/nfsd/nfsctl.c 3 * 4 * Syscall interface to knfsd. 5 * 6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 7 */ 8 9 #include <linux/module.h> 10 11 #include <linux/linkage.h> 12 #include <linux/time.h> 13 #include <linux/errno.h> 14 #include <linux/fs.h> 15 #include <linux/fcntl.h> 16 #include <linux/net.h> 17 #include <linux/in.h> 18 #include <linux/syscalls.h> 19 #include <linux/unistd.h> 20 #include <linux/slab.h> 21 #include <linux/proc_fs.h> 22 #include <linux/seq_file.h> 23 #include <linux/pagemap.h> 24 #include <linux/init.h> 25 #include <linux/inet.h> 26 #include <linux/string.h> 27 #include <linux/smp_lock.h> 28 #include <linux/ctype.h> 29 30 #include <linux/nfs.h> 31 #include <linux/nfsd_idmap.h> 32 #include <linux/lockd/bind.h> 33 #include <linux/sunrpc/svc.h> 34 #include <linux/sunrpc/svcsock.h> 35 #include <linux/nfsd/nfsd.h> 36 #include <linux/nfsd/cache.h> 37 #include <linux/nfsd/xdr.h> 38 #include <linux/nfsd/syscall.h> 39 #include <linux/lockd/lockd.h> 40 41 #include <asm/uaccess.h> 42 #include <net/ipv6.h> 43 44 /* 45 * We have a single directory with 9 nodes in it. 46 */ 47 enum { 48 NFSD_Root = 1, 49 NFSD_Svc, 50 NFSD_Add, 51 NFSD_Del, 52 NFSD_Export, 53 NFSD_Unexport, 54 NFSD_Getfd, 55 NFSD_Getfs, 56 NFSD_List, 57 NFSD_Fh, 58 NFSD_FO_UnlockIP, 59 NFSD_FO_UnlockFS, 60 NFSD_Threads, 61 NFSD_Pool_Threads, 62 NFSD_Versions, 63 NFSD_Ports, 64 NFSD_MaxBlkSize, 65 /* 66 * The below MUST come last. Otherwise we leave a hole in nfsd_files[] 67 * with !CONFIG_NFSD_V4 and simple_fill_super() goes oops 68 */ 69 #ifdef CONFIG_NFSD_V4 70 NFSD_Leasetime, 71 NFSD_RecoveryDir, 72 #endif 73 }; 74 75 /* 76 * write() for these nodes. 77 */ 78 static ssize_t write_svc(struct file *file, char *buf, size_t size); 79 static ssize_t write_add(struct file *file, char *buf, size_t size); 80 static ssize_t write_del(struct file *file, char *buf, size_t size); 81 static ssize_t write_export(struct file *file, char *buf, size_t size); 82 static ssize_t write_unexport(struct file *file, char *buf, size_t size); 83 static ssize_t write_getfd(struct file *file, char *buf, size_t size); 84 static ssize_t write_getfs(struct file *file, char *buf, size_t size); 85 static ssize_t write_filehandle(struct file *file, char *buf, size_t size); 86 static ssize_t write_threads(struct file *file, char *buf, size_t size); 87 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size); 88 static ssize_t write_versions(struct file *file, char *buf, size_t size); 89 static ssize_t write_ports(struct file *file, char *buf, size_t size); 90 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size); 91 #ifdef CONFIG_NFSD_V4 92 static ssize_t write_leasetime(struct file *file, char *buf, size_t size); 93 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size); 94 #endif 95 96 static ssize_t failover_unlock_ip(struct file *file, char *buf, size_t size); 97 static ssize_t failover_unlock_fs(struct file *file, char *buf, size_t size); 98 99 static ssize_t (*write_op[])(struct file *, char *, size_t) = { 100 [NFSD_Svc] = write_svc, 101 [NFSD_Add] = write_add, 102 [NFSD_Del] = write_del, 103 [NFSD_Export] = write_export, 104 [NFSD_Unexport] = write_unexport, 105 [NFSD_Getfd] = write_getfd, 106 [NFSD_Getfs] = write_getfs, 107 [NFSD_Fh] = write_filehandle, 108 [NFSD_FO_UnlockIP] = failover_unlock_ip, 109 [NFSD_FO_UnlockFS] = failover_unlock_fs, 110 [NFSD_Threads] = write_threads, 111 [NFSD_Pool_Threads] = write_pool_threads, 112 [NFSD_Versions] = write_versions, 113 [NFSD_Ports] = write_ports, 114 [NFSD_MaxBlkSize] = write_maxblksize, 115 #ifdef CONFIG_NFSD_V4 116 [NFSD_Leasetime] = write_leasetime, 117 [NFSD_RecoveryDir] = write_recoverydir, 118 #endif 119 }; 120 121 static ssize_t nfsctl_transaction_write(struct file *file, const char __user *buf, size_t size, loff_t *pos) 122 { 123 ino_t ino = file->f_path.dentry->d_inode->i_ino; 124 char *data; 125 ssize_t rv; 126 127 if (ino >= ARRAY_SIZE(write_op) || !write_op[ino]) 128 return -EINVAL; 129 130 data = simple_transaction_get(file, buf, size); 131 if (IS_ERR(data)) 132 return PTR_ERR(data); 133 134 rv = write_op[ino](file, data, size); 135 if (rv >= 0) { 136 simple_transaction_set(file, rv); 137 rv = size; 138 } 139 return rv; 140 } 141 142 static ssize_t nfsctl_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos) 143 { 144 if (! file->private_data) { 145 /* An attempt to read a transaction file without writing 146 * causes a 0-byte write so that the file can return 147 * state information 148 */ 149 ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos); 150 if (rv < 0) 151 return rv; 152 } 153 return simple_transaction_read(file, buf, size, pos); 154 } 155 156 static const struct file_operations transaction_ops = { 157 .write = nfsctl_transaction_write, 158 .read = nfsctl_transaction_read, 159 .release = simple_transaction_release, 160 }; 161 162 static int exports_open(struct inode *inode, struct file *file) 163 { 164 return seq_open(file, &nfs_exports_op); 165 } 166 167 static const struct file_operations exports_operations = { 168 .open = exports_open, 169 .read = seq_read, 170 .llseek = seq_lseek, 171 .release = seq_release, 172 .owner = THIS_MODULE, 173 }; 174 175 /*----------------------------------------------------------------------------*/ 176 /* 177 * payload - write methods 178 * If the method has a response, the response should be put in buf, 179 * and the length returned. Otherwise return 0 or and -error. 180 */ 181 182 static ssize_t write_svc(struct file *file, char *buf, size_t size) 183 { 184 struct nfsctl_svc *data; 185 if (size < sizeof(*data)) 186 return -EINVAL; 187 data = (struct nfsctl_svc*) buf; 188 return nfsd_svc(data->svc_port, data->svc_nthreads); 189 } 190 191 static ssize_t write_add(struct file *file, char *buf, size_t size) 192 { 193 struct nfsctl_client *data; 194 if (size < sizeof(*data)) 195 return -EINVAL; 196 data = (struct nfsctl_client *)buf; 197 return exp_addclient(data); 198 } 199 200 static ssize_t write_del(struct file *file, char *buf, size_t size) 201 { 202 struct nfsctl_client *data; 203 if (size < sizeof(*data)) 204 return -EINVAL; 205 data = (struct nfsctl_client *)buf; 206 return exp_delclient(data); 207 } 208 209 static ssize_t write_export(struct file *file, char *buf, size_t size) 210 { 211 struct nfsctl_export *data; 212 if (size < sizeof(*data)) 213 return -EINVAL; 214 data = (struct nfsctl_export*)buf; 215 return exp_export(data); 216 } 217 218 static ssize_t write_unexport(struct file *file, char *buf, size_t size) 219 { 220 struct nfsctl_export *data; 221 222 if (size < sizeof(*data)) 223 return -EINVAL; 224 data = (struct nfsctl_export*)buf; 225 return exp_unexport(data); 226 } 227 228 static ssize_t write_getfs(struct file *file, char *buf, size_t size) 229 { 230 struct nfsctl_fsparm *data; 231 struct sockaddr_in *sin; 232 struct auth_domain *clp; 233 int err = 0; 234 struct knfsd_fh *res; 235 struct in6_addr in6; 236 237 if (size < sizeof(*data)) 238 return -EINVAL; 239 data = (struct nfsctl_fsparm*)buf; 240 err = -EPROTONOSUPPORT; 241 if (data->gd_addr.sa_family != AF_INET) 242 goto out; 243 sin = (struct sockaddr_in *)&data->gd_addr; 244 if (data->gd_maxlen > NFS3_FHSIZE) 245 data->gd_maxlen = NFS3_FHSIZE; 246 247 res = (struct knfsd_fh*)buf; 248 249 exp_readlock(); 250 251 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6); 252 253 clp = auth_unix_lookup(&in6); 254 if (!clp) 255 err = -EPERM; 256 else { 257 err = exp_rootfh(clp, data->gd_path, res, data->gd_maxlen); 258 auth_domain_put(clp); 259 } 260 exp_readunlock(); 261 if (err == 0) 262 err = res->fh_size + offsetof(struct knfsd_fh, fh_base); 263 out: 264 return err; 265 } 266 267 static ssize_t write_getfd(struct file *file, char *buf, size_t size) 268 { 269 struct nfsctl_fdparm *data; 270 struct sockaddr_in *sin; 271 struct auth_domain *clp; 272 int err = 0; 273 struct knfsd_fh fh; 274 char *res; 275 struct in6_addr in6; 276 277 if (size < sizeof(*data)) 278 return -EINVAL; 279 data = (struct nfsctl_fdparm*)buf; 280 err = -EPROTONOSUPPORT; 281 if (data->gd_addr.sa_family != AF_INET) 282 goto out; 283 err = -EINVAL; 284 if (data->gd_version < 2 || data->gd_version > NFSSVC_MAXVERS) 285 goto out; 286 287 res = buf; 288 sin = (struct sockaddr_in *)&data->gd_addr; 289 exp_readlock(); 290 291 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &in6); 292 293 clp = auth_unix_lookup(&in6); 294 if (!clp) 295 err = -EPERM; 296 else { 297 err = exp_rootfh(clp, data->gd_path, &fh, NFS_FHSIZE); 298 auth_domain_put(clp); 299 } 300 exp_readunlock(); 301 302 if (err == 0) { 303 memset(res,0, NFS_FHSIZE); 304 memcpy(res, &fh.fh_base, fh.fh_size); 305 err = NFS_FHSIZE; 306 } 307 out: 308 return err; 309 } 310 311 static ssize_t failover_unlock_ip(struct file *file, char *buf, size_t size) 312 { 313 __be32 server_ip; 314 char *fo_path, c; 315 int b1, b2, b3, b4; 316 317 /* sanity check */ 318 if (size == 0) 319 return -EINVAL; 320 321 if (buf[size-1] != '\n') 322 return -EINVAL; 323 324 fo_path = buf; 325 if (qword_get(&buf, fo_path, size) < 0) 326 return -EINVAL; 327 328 /* get ipv4 address */ 329 if (sscanf(fo_path, "%u.%u.%u.%u%c", &b1, &b2, &b3, &b4, &c) != 4) 330 return -EINVAL; 331 server_ip = htonl((((((b1<<8)|b2)<<8)|b3)<<8)|b4); 332 333 return nlmsvc_unlock_all_by_ip(server_ip); 334 } 335 336 static ssize_t failover_unlock_fs(struct file *file, char *buf, size_t size) 337 { 338 struct nameidata nd; 339 char *fo_path; 340 int error; 341 342 /* sanity check */ 343 if (size == 0) 344 return -EINVAL; 345 346 if (buf[size-1] != '\n') 347 return -EINVAL; 348 349 fo_path = buf; 350 if (qword_get(&buf, fo_path, size) < 0) 351 return -EINVAL; 352 353 error = path_lookup(fo_path, 0, &nd); 354 if (error) 355 return error; 356 357 error = nlmsvc_unlock_all_by_sb(nd.path.mnt->mnt_sb); 358 359 path_put(&nd.path); 360 return error; 361 } 362 363 static ssize_t write_filehandle(struct file *file, char *buf, size_t size) 364 { 365 /* request is: 366 * domain path maxsize 367 * response is 368 * filehandle 369 * 370 * qword quoting is used, so filehandle will be \x.... 371 */ 372 char *dname, *path; 373 int uninitialized_var(maxsize); 374 char *mesg = buf; 375 int len; 376 struct auth_domain *dom; 377 struct knfsd_fh fh; 378 379 if (size == 0) 380 return -EINVAL; 381 382 if (buf[size-1] != '\n') 383 return -EINVAL; 384 buf[size-1] = 0; 385 386 dname = mesg; 387 len = qword_get(&mesg, dname, size); 388 if (len <= 0) return -EINVAL; 389 390 path = dname+len+1; 391 len = qword_get(&mesg, path, size); 392 if (len <= 0) return -EINVAL; 393 394 len = get_int(&mesg, &maxsize); 395 if (len) 396 return len; 397 398 if (maxsize < NFS_FHSIZE) 399 return -EINVAL; 400 if (maxsize > NFS3_FHSIZE) 401 maxsize = NFS3_FHSIZE; 402 403 if (qword_get(&mesg, mesg, size)>0) 404 return -EINVAL; 405 406 /* we have all the words, they are in buf.. */ 407 dom = unix_domain_find(dname); 408 if (!dom) 409 return -ENOMEM; 410 411 len = exp_rootfh(dom, path, &fh, maxsize); 412 auth_domain_put(dom); 413 if (len) 414 return len; 415 416 mesg = buf; len = SIMPLE_TRANSACTION_LIMIT; 417 qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size); 418 mesg[-1] = '\n'; 419 return mesg - buf; 420 } 421 422 static ssize_t write_threads(struct file *file, char *buf, size_t size) 423 { 424 /* if size > 0, look for a number of threads and call nfsd_svc 425 * then write out number of threads as reply 426 */ 427 char *mesg = buf; 428 int rv; 429 if (size > 0) { 430 int newthreads; 431 rv = get_int(&mesg, &newthreads); 432 if (rv) 433 return rv; 434 if (newthreads <0) 435 return -EINVAL; 436 rv = nfsd_svc(2049, newthreads); 437 if (rv) 438 return rv; 439 } 440 sprintf(buf, "%d\n", nfsd_nrthreads()); 441 return strlen(buf); 442 } 443 444 static ssize_t write_pool_threads(struct file *file, char *buf, size_t size) 445 { 446 /* if size > 0, look for an array of number of threads per node 447 * and apply them then write out number of threads per node as reply 448 */ 449 char *mesg = buf; 450 int i; 451 int rv; 452 int len; 453 int npools = nfsd_nrpools(); 454 int *nthreads; 455 456 if (npools == 0) { 457 /* 458 * NFS is shut down. The admin can start it by 459 * writing to the threads file but NOT the pool_threads 460 * file, sorry. Report zero threads. 461 */ 462 strcpy(buf, "0\n"); 463 return strlen(buf); 464 } 465 466 nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL); 467 if (nthreads == NULL) 468 return -ENOMEM; 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 499 return (mesg-buf); 500 501 out_free: 502 kfree(nthreads); 503 return rv; 504 } 505 506 static ssize_t write_versions(struct file *file, char *buf, size_t size) 507 { 508 /* 509 * Format: 510 * [-/+]vers [-/+]vers ... 511 */ 512 char *mesg = buf; 513 char *vers, sign; 514 int len, num; 515 ssize_t tlen = 0; 516 char *sep; 517 518 if (size>0) { 519 if (nfsd_serv) 520 /* Cannot change versions without updating 521 * nfsd_serv->sv_xdrsize, and reallocing 522 * rq_argp and rq_resp 523 */ 524 return -EBUSY; 525 if (buf[size-1] != '\n') 526 return -EINVAL; 527 buf[size-1] = 0; 528 529 vers = mesg; 530 len = qword_get(&mesg, vers, size); 531 if (len <= 0) return -EINVAL; 532 do { 533 sign = *vers; 534 if (sign == '+' || sign == '-') 535 num = simple_strtol((vers+1), NULL, 0); 536 else 537 num = simple_strtol(vers, NULL, 0); 538 switch(num) { 539 case 2: 540 case 3: 541 case 4: 542 nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET); 543 break; 544 default: 545 return -EINVAL; 546 } 547 vers += len + 1; 548 tlen += len; 549 } while ((len = qword_get(&mesg, vers, size)) > 0); 550 /* If all get turned off, turn them back on, as 551 * having no versions is BAD 552 */ 553 nfsd_reset_versions(); 554 } 555 /* Now write current state into reply buffer */ 556 len = 0; 557 sep = ""; 558 for (num=2 ; num <= 4 ; num++) 559 if (nfsd_vers(num, NFSD_AVAIL)) { 560 len += sprintf(buf+len, "%s%c%d", sep, 561 nfsd_vers(num, NFSD_TEST)?'+':'-', 562 num); 563 sep = " "; 564 } 565 len += sprintf(buf+len, "\n"); 566 return len; 567 } 568 569 static ssize_t write_ports(struct file *file, char *buf, size_t size) 570 { 571 if (size == 0) { 572 int len = 0; 573 lock_kernel(); 574 if (nfsd_serv) 575 len = svc_xprt_names(nfsd_serv, buf, 0); 576 unlock_kernel(); 577 return len; 578 } 579 /* Either a single 'fd' number is written, in which 580 * case it must be for a socket of a supported family/protocol, 581 * and we use it as an nfsd socket, or 582 * A '-' followed by the 'name' of a socket in which case 583 * we close the socket. 584 */ 585 if (isdigit(buf[0])) { 586 char *mesg = buf; 587 int fd; 588 int err; 589 err = get_int(&mesg, &fd); 590 if (err) 591 return -EINVAL; 592 if (fd < 0) 593 return -EINVAL; 594 err = nfsd_create_serv(); 595 if (!err) { 596 int proto = 0; 597 err = svc_addsock(nfsd_serv, fd, buf, &proto); 598 if (err >= 0) { 599 err = lockd_up(proto); 600 if (err < 0) 601 svc_sock_names(buf+strlen(buf)+1, nfsd_serv, buf); 602 } 603 /* Decrease the count, but don't shutdown the 604 * the service 605 */ 606 lock_kernel(); 607 nfsd_serv->sv_nrthreads--; 608 unlock_kernel(); 609 } 610 return err < 0 ? err : 0; 611 } 612 if (buf[0] == '-' && isdigit(buf[1])) { 613 char *toclose = kstrdup(buf+1, GFP_KERNEL); 614 int len = 0; 615 if (!toclose) 616 return -ENOMEM; 617 lock_kernel(); 618 if (nfsd_serv) 619 len = svc_sock_names(buf, nfsd_serv, toclose); 620 unlock_kernel(); 621 if (len >= 0) 622 lockd_down(); 623 kfree(toclose); 624 return len; 625 } 626 /* 627 * Add a transport listener by writing it's transport name 628 */ 629 if (isalpha(buf[0])) { 630 int err; 631 char transport[16]; 632 int port; 633 if (sscanf(buf, "%15s %4d", transport, &port) == 2) { 634 err = nfsd_create_serv(); 635 if (!err) { 636 err = svc_create_xprt(nfsd_serv, 637 transport, port, 638 SVC_SOCK_ANONYMOUS); 639 if (err == -ENOENT) 640 /* Give a reasonable perror msg for 641 * bad transport string */ 642 err = -EPROTONOSUPPORT; 643 } 644 return err < 0 ? err : 0; 645 } 646 } 647 /* 648 * Remove a transport by writing it's transport name and port number 649 */ 650 if (buf[0] == '-' && isalpha(buf[1])) { 651 struct svc_xprt *xprt; 652 int err = -EINVAL; 653 char transport[16]; 654 int port; 655 if (sscanf(&buf[1], "%15s %4d", transport, &port) == 2) { 656 if (port == 0) 657 return -EINVAL; 658 lock_kernel(); 659 if (nfsd_serv) { 660 xprt = svc_find_xprt(nfsd_serv, transport, 661 AF_UNSPEC, port); 662 if (xprt) { 663 svc_close_xprt(xprt); 664 svc_xprt_put(xprt); 665 err = 0; 666 } else 667 err = -ENOTCONN; 668 } 669 unlock_kernel(); 670 return err < 0 ? err : 0; 671 } 672 } 673 return -EINVAL; 674 } 675 676 int nfsd_max_blksize; 677 678 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size) 679 { 680 char *mesg = buf; 681 if (size > 0) { 682 int bsize; 683 int rv = get_int(&mesg, &bsize); 684 if (rv) 685 return rv; 686 /* force bsize into allowed range and 687 * required alignment. 688 */ 689 if (bsize < 1024) 690 bsize = 1024; 691 if (bsize > NFSSVC_MAXBLKSIZE) 692 bsize = NFSSVC_MAXBLKSIZE; 693 bsize &= ~(1024-1); 694 lock_kernel(); 695 if (nfsd_serv && nfsd_serv->sv_nrthreads) { 696 unlock_kernel(); 697 return -EBUSY; 698 } 699 nfsd_max_blksize = bsize; 700 unlock_kernel(); 701 } 702 return sprintf(buf, "%d\n", nfsd_max_blksize); 703 } 704 705 #ifdef CONFIG_NFSD_V4 706 extern time_t nfs4_leasetime(void); 707 708 static ssize_t write_leasetime(struct file *file, char *buf, size_t size) 709 { 710 /* if size > 10 seconds, call 711 * nfs4_reset_lease() then write out the new lease (seconds) as reply 712 */ 713 char *mesg = buf; 714 int rv; 715 716 if (size > 0) { 717 int lease; 718 rv = get_int(&mesg, &lease); 719 if (rv) 720 return rv; 721 if (lease < 10 || lease > 3600) 722 return -EINVAL; 723 nfs4_reset_lease(lease); 724 } 725 sprintf(buf, "%ld\n", nfs4_lease_time()); 726 return strlen(buf); 727 } 728 729 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size) 730 { 731 char *mesg = buf; 732 char *recdir; 733 int len, status; 734 735 if (size == 0 || size > PATH_MAX || buf[size-1] != '\n') 736 return -EINVAL; 737 buf[size-1] = 0; 738 739 recdir = mesg; 740 len = qword_get(&mesg, recdir, size); 741 if (len <= 0) 742 return -EINVAL; 743 744 status = nfs4_reset_recoverydir(recdir); 745 return strlen(buf); 746 } 747 #endif 748 749 /*----------------------------------------------------------------------------*/ 750 /* 751 * populating the filesystem. 752 */ 753 754 static int nfsd_fill_super(struct super_block * sb, void * data, int silent) 755 { 756 static struct tree_descr nfsd_files[] = { 757 [NFSD_Svc] = {".svc", &transaction_ops, S_IWUSR}, 758 [NFSD_Add] = {".add", &transaction_ops, S_IWUSR}, 759 [NFSD_Del] = {".del", &transaction_ops, S_IWUSR}, 760 [NFSD_Export] = {".export", &transaction_ops, S_IWUSR}, 761 [NFSD_Unexport] = {".unexport", &transaction_ops, S_IWUSR}, 762 [NFSD_Getfd] = {".getfd", &transaction_ops, S_IWUSR|S_IRUSR}, 763 [NFSD_Getfs] = {".getfs", &transaction_ops, S_IWUSR|S_IRUSR}, 764 [NFSD_List] = {"exports", &exports_operations, S_IRUGO}, 765 [NFSD_FO_UnlockIP] = {"unlock_ip", 766 &transaction_ops, S_IWUSR|S_IRUSR}, 767 [NFSD_FO_UnlockFS] = {"unlock_filesystem", 768 &transaction_ops, S_IWUSR|S_IRUSR}, 769 [NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR|S_IRUSR}, 770 [NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR|S_IRUSR}, 771 [NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR|S_IRUSR}, 772 [NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR|S_IRUSR}, 773 [NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR|S_IRUGO}, 774 [NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR|S_IRUGO}, 775 #ifdef CONFIG_NFSD_V4 776 [NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR|S_IRUSR}, 777 [NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR|S_IRUSR}, 778 #endif 779 /* last one */ {""} 780 }; 781 return simple_fill_super(sb, 0x6e667364, nfsd_files); 782 } 783 784 static int nfsd_get_sb(struct file_system_type *fs_type, 785 int flags, const char *dev_name, void *data, struct vfsmount *mnt) 786 { 787 return get_sb_single(fs_type, flags, data, nfsd_fill_super, mnt); 788 } 789 790 static struct file_system_type nfsd_fs_type = { 791 .owner = THIS_MODULE, 792 .name = "nfsd", 793 .get_sb = nfsd_get_sb, 794 .kill_sb = kill_litter_super, 795 }; 796 797 #ifdef CONFIG_PROC_FS 798 static int create_proc_exports_entry(void) 799 { 800 struct proc_dir_entry *entry; 801 802 entry = proc_mkdir("fs/nfs", NULL); 803 if (!entry) 804 return -ENOMEM; 805 entry = proc_create("exports", 0, entry, &exports_operations); 806 if (!entry) 807 return -ENOMEM; 808 return 0; 809 } 810 #else /* CONFIG_PROC_FS */ 811 static int create_proc_exports_entry(void) 812 { 813 return 0; 814 } 815 #endif 816 817 static int __init init_nfsd(void) 818 { 819 int retval; 820 printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n"); 821 822 retval = nfs4_state_init(); /* nfs4 locking state */ 823 if (retval) 824 return retval; 825 nfsd_stat_init(); /* Statistics */ 826 retval = nfsd_reply_cache_init(); 827 if (retval) 828 goto out_free_stat; 829 retval = nfsd_export_init(); 830 if (retval) 831 goto out_free_cache; 832 nfsd_lockd_init(); /* lockd->nfsd callbacks */ 833 retval = nfsd_idmap_init(); 834 if (retval) 835 goto out_free_lockd; 836 retval = create_proc_exports_entry(); 837 if (retval) 838 goto out_free_idmap; 839 retval = register_filesystem(&nfsd_fs_type); 840 if (retval) 841 goto out_free_all; 842 return 0; 843 out_free_all: 844 remove_proc_entry("fs/nfs/exports", NULL); 845 remove_proc_entry("fs/nfs", NULL); 846 out_free_idmap: 847 nfsd_idmap_shutdown(); 848 out_free_lockd: 849 nfsd_lockd_shutdown(); 850 nfsd_export_shutdown(); 851 out_free_cache: 852 nfsd_reply_cache_shutdown(); 853 out_free_stat: 854 nfsd_stat_shutdown(); 855 nfsd4_free_slabs(); 856 return retval; 857 } 858 859 static void __exit exit_nfsd(void) 860 { 861 nfsd_export_shutdown(); 862 nfsd_reply_cache_shutdown(); 863 remove_proc_entry("fs/nfs/exports", NULL); 864 remove_proc_entry("fs/nfs", NULL); 865 nfsd_stat_shutdown(); 866 nfsd_lockd_shutdown(); 867 nfsd_idmap_shutdown(); 868 nfsd4_free_slabs(); 869 unregister_filesystem(&nfsd_fs_type); 870 } 871 872 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>"); 873 MODULE_LICENSE("GPL"); 874 module_init(init_nfsd) 875 module_exit(exit_nfsd) 876