1 /* 2 * Central processing for nfsd. 3 * 4 * Authors: Olaf Kirch (okir@monad.swb.de) 5 * 6 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> 7 */ 8 9 #include <linux/sched.h> 10 #include <linux/freezer.h> 11 #include <linux/module.h> 12 #include <linux/fs_struct.h> 13 #include <linux/swap.h> 14 15 #include <linux/sunrpc/stats.h> 16 #include <linux/sunrpc/svcsock.h> 17 #include <linux/lockd/bind.h> 18 #include <linux/nfsacl.h> 19 #include <linux/seq_file.h> 20 #include <net/net_namespace.h> 21 #include "nfsd.h" 22 #include "cache.h" 23 #include "vfs.h" 24 #include "netns.h" 25 26 #define NFSDDBG_FACILITY NFSDDBG_SVC 27 28 extern struct svc_program nfsd_program; 29 static int nfsd(void *vrqstp); 30 31 /* 32 * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members 33 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some 34 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt 35 * 36 * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a 37 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number 38 * of nfsd threads must exist and each must listed in ->sp_all_threads in each 39 * entry of ->sv_pools[]. 40 * 41 * Transitions of the thread count between zero and non-zero are of particular 42 * interest since the svc_serv needs to be created and initialized at that 43 * point, or freed. 44 * 45 * Finally, the nfsd_mutex also protects some of the global variables that are 46 * accessed when nfsd starts and that are settable via the write_* routines in 47 * nfsctl.c. In particular: 48 * 49 * user_recovery_dirname 50 * user_lease_time 51 * nfsd_versions 52 */ 53 DEFINE_MUTEX(nfsd_mutex); 54 55 /* 56 * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used. 57 * nfsd_drc_max_pages limits the total amount of memory available for 58 * version 4.1 DRC caches. 59 * nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage. 60 */ 61 spinlock_t nfsd_drc_lock; 62 unsigned long nfsd_drc_max_mem; 63 unsigned long nfsd_drc_mem_used; 64 65 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 66 static struct svc_stat nfsd_acl_svcstats; 67 static struct svc_version * nfsd_acl_version[] = { 68 [2] = &nfsd_acl_version2, 69 [3] = &nfsd_acl_version3, 70 }; 71 72 #define NFSD_ACL_MINVERS 2 73 #define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version) 74 static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS]; 75 76 static struct svc_program nfsd_acl_program = { 77 .pg_prog = NFS_ACL_PROGRAM, 78 .pg_nvers = NFSD_ACL_NRVERS, 79 .pg_vers = nfsd_acl_versions, 80 .pg_name = "nfsacl", 81 .pg_class = "nfsd", 82 .pg_stats = &nfsd_acl_svcstats, 83 .pg_authenticate = &svc_set_client, 84 }; 85 86 static struct svc_stat nfsd_acl_svcstats = { 87 .program = &nfsd_acl_program, 88 }; 89 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */ 90 91 static struct svc_version * nfsd_version[] = { 92 [2] = &nfsd_version2, 93 #if defined(CONFIG_NFSD_V3) 94 [3] = &nfsd_version3, 95 #endif 96 #if defined(CONFIG_NFSD_V4) 97 [4] = &nfsd_version4, 98 #endif 99 }; 100 101 #define NFSD_MINVERS 2 102 #define NFSD_NRVERS ARRAY_SIZE(nfsd_version) 103 static struct svc_version *nfsd_versions[NFSD_NRVERS]; 104 105 struct svc_program nfsd_program = { 106 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 107 .pg_next = &nfsd_acl_program, 108 #endif 109 .pg_prog = NFS_PROGRAM, /* program number */ 110 .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */ 111 .pg_vers = nfsd_versions, /* version table */ 112 .pg_name = "nfsd", /* program name */ 113 .pg_class = "nfsd", /* authentication class */ 114 .pg_stats = &nfsd_svcstats, /* version table */ 115 .pg_authenticate = &svc_set_client, /* export authentication */ 116 117 }; 118 119 static bool nfsd_supported_minorversions[NFSD_SUPPORTED_MINOR_VERSION + 1] = { 120 [0] = 1, 121 [1] = 1, 122 [2] = 1, 123 }; 124 125 int nfsd_vers(int vers, enum vers_op change) 126 { 127 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS) 128 return 0; 129 switch(change) { 130 case NFSD_SET: 131 nfsd_versions[vers] = nfsd_version[vers]; 132 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 133 if (vers < NFSD_ACL_NRVERS) 134 nfsd_acl_versions[vers] = nfsd_acl_version[vers]; 135 #endif 136 break; 137 case NFSD_CLEAR: 138 nfsd_versions[vers] = NULL; 139 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 140 if (vers < NFSD_ACL_NRVERS) 141 nfsd_acl_versions[vers] = NULL; 142 #endif 143 break; 144 case NFSD_TEST: 145 return nfsd_versions[vers] != NULL; 146 case NFSD_AVAIL: 147 return nfsd_version[vers] != NULL; 148 } 149 return 0; 150 } 151 152 int nfsd_minorversion(u32 minorversion, enum vers_op change) 153 { 154 if (minorversion > NFSD_SUPPORTED_MINOR_VERSION) 155 return -1; 156 switch(change) { 157 case NFSD_SET: 158 nfsd_supported_minorversions[minorversion] = true; 159 break; 160 case NFSD_CLEAR: 161 nfsd_supported_minorversions[minorversion] = false; 162 break; 163 case NFSD_TEST: 164 return nfsd_supported_minorversions[minorversion]; 165 case NFSD_AVAIL: 166 return minorversion <= NFSD_SUPPORTED_MINOR_VERSION; 167 } 168 return 0; 169 } 170 171 /* 172 * Maximum number of nfsd processes 173 */ 174 #define NFSD_MAXSERVS 8192 175 176 int nfsd_nrthreads(struct net *net) 177 { 178 int rv = 0; 179 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 180 181 mutex_lock(&nfsd_mutex); 182 if (nn->nfsd_serv) 183 rv = nn->nfsd_serv->sv_nrthreads; 184 mutex_unlock(&nfsd_mutex); 185 return rv; 186 } 187 188 static int nfsd_init_socks(struct net *net) 189 { 190 int error; 191 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 192 193 if (!list_empty(&nn->nfsd_serv->sv_permsocks)) 194 return 0; 195 196 error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT, 197 SVC_SOCK_DEFAULTS); 198 if (error < 0) 199 return error; 200 201 error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT, 202 SVC_SOCK_DEFAULTS); 203 if (error < 0) 204 return error; 205 206 return 0; 207 } 208 209 static int nfsd_users = 0; 210 211 static int nfsd_startup_generic(int nrservs) 212 { 213 int ret; 214 215 if (nfsd_users++) 216 return 0; 217 218 /* 219 * Readahead param cache - will no-op if it already exists. 220 * (Note therefore results will be suboptimal if number of 221 * threads is modified after nfsd start.) 222 */ 223 ret = nfsd_racache_init(2*nrservs); 224 if (ret) 225 goto dec_users; 226 227 ret = nfs4_state_start(); 228 if (ret) 229 goto out_racache; 230 return 0; 231 232 out_racache: 233 nfsd_racache_shutdown(); 234 dec_users: 235 nfsd_users--; 236 return ret; 237 } 238 239 static void nfsd_shutdown_generic(void) 240 { 241 if (--nfsd_users) 242 return; 243 244 nfs4_state_shutdown(); 245 nfsd_racache_shutdown(); 246 } 247 248 static bool nfsd_needs_lockd(void) 249 { 250 #if defined(CONFIG_NFSD_V3) 251 return (nfsd_versions[2] != NULL) || (nfsd_versions[3] != NULL); 252 #else 253 return (nfsd_versions[2] != NULL); 254 #endif 255 } 256 257 static int nfsd_startup_net(int nrservs, struct net *net) 258 { 259 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 260 int ret; 261 262 if (nn->nfsd_net_up) 263 return 0; 264 265 ret = nfsd_startup_generic(nrservs); 266 if (ret) 267 return ret; 268 ret = nfsd_init_socks(net); 269 if (ret) 270 goto out_socks; 271 272 if (nfsd_needs_lockd() && !nn->lockd_up) { 273 ret = lockd_up(net); 274 if (ret) 275 goto out_socks; 276 nn->lockd_up = 1; 277 } 278 279 ret = nfs4_state_start_net(net); 280 if (ret) 281 goto out_lockd; 282 283 nn->nfsd_net_up = true; 284 return 0; 285 286 out_lockd: 287 if (nn->lockd_up) { 288 lockd_down(net); 289 nn->lockd_up = 0; 290 } 291 out_socks: 292 nfsd_shutdown_generic(); 293 return ret; 294 } 295 296 static void nfsd_shutdown_net(struct net *net) 297 { 298 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 299 300 nfs4_state_shutdown_net(net); 301 if (nn->lockd_up) { 302 lockd_down(net); 303 nn->lockd_up = 0; 304 } 305 nn->nfsd_net_up = false; 306 nfsd_shutdown_generic(); 307 } 308 309 static void nfsd_last_thread(struct svc_serv *serv, struct net *net) 310 { 311 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 312 313 /* 314 * write_ports can create the server without actually starting 315 * any threads--if we get shut down before any threads are 316 * started, then nfsd_last_thread will be run before any of this 317 * other initialization has been done. 318 */ 319 if (!nn->nfsd_net_up) 320 return; 321 nfsd_shutdown_net(net); 322 323 svc_rpcb_cleanup(serv, net); 324 325 printk(KERN_WARNING "nfsd: last server has exited, flushing export " 326 "cache\n"); 327 nfsd_export_flush(net); 328 } 329 330 void nfsd_reset_versions(void) 331 { 332 int found_one = 0; 333 int i; 334 335 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) { 336 if (nfsd_program.pg_vers[i]) 337 found_one = 1; 338 } 339 340 if (!found_one) { 341 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) 342 nfsd_program.pg_vers[i] = nfsd_version[i]; 343 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 344 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++) 345 nfsd_acl_program.pg_vers[i] = 346 nfsd_acl_version[i]; 347 #endif 348 } 349 } 350 351 /* 352 * Each session guarantees a negotiated per slot memory cache for replies 353 * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated 354 * NFSv4.1 server might want to use more memory for a DRC than a machine 355 * with mutiple services. 356 * 357 * Impose a hard limit on the number of pages for the DRC which varies 358 * according to the machines free pages. This is of course only a default. 359 * 360 * For now this is a #defined shift which could be under admin control 361 * in the future. 362 */ 363 static void set_max_drc(void) 364 { 365 #define NFSD_DRC_SIZE_SHIFT 10 366 nfsd_drc_max_mem = (nr_free_buffer_pages() 367 >> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE; 368 nfsd_drc_mem_used = 0; 369 spin_lock_init(&nfsd_drc_lock); 370 dprintk("%s nfsd_drc_max_mem %lu \n", __func__, nfsd_drc_max_mem); 371 } 372 373 static int nfsd_get_default_max_blksize(void) 374 { 375 struct sysinfo i; 376 unsigned long long target; 377 unsigned long ret; 378 379 si_meminfo(&i); 380 target = (i.totalram - i.totalhigh) << PAGE_SHIFT; 381 /* 382 * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig 383 * machines, but only uses 32K on 128M machines. Bottom out at 384 * 8K on 32M and smaller. Of course, this is only a default. 385 */ 386 target >>= 12; 387 388 ret = NFSSVC_MAXBLKSIZE; 389 while (ret > target && ret >= 8*1024*2) 390 ret /= 2; 391 return ret; 392 } 393 394 int nfsd_create_serv(struct net *net) 395 { 396 int error; 397 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 398 399 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 400 if (nn->nfsd_serv) { 401 svc_get(nn->nfsd_serv); 402 return 0; 403 } 404 if (nfsd_max_blksize == 0) 405 nfsd_max_blksize = nfsd_get_default_max_blksize(); 406 nfsd_reset_versions(); 407 nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize, 408 nfsd_last_thread, nfsd, THIS_MODULE); 409 if (nn->nfsd_serv == NULL) 410 return -ENOMEM; 411 412 nn->nfsd_serv->sv_maxconn = nn->max_connections; 413 error = svc_bind(nn->nfsd_serv, net); 414 if (error < 0) { 415 svc_destroy(nn->nfsd_serv); 416 return error; 417 } 418 419 set_max_drc(); 420 do_gettimeofday(&nn->nfssvc_boot); /* record boot time */ 421 return 0; 422 } 423 424 int nfsd_nrpools(struct net *net) 425 { 426 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 427 428 if (nn->nfsd_serv == NULL) 429 return 0; 430 else 431 return nn->nfsd_serv->sv_nrpools; 432 } 433 434 int nfsd_get_nrthreads(int n, int *nthreads, struct net *net) 435 { 436 int i = 0; 437 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 438 439 if (nn->nfsd_serv != NULL) { 440 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++) 441 nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads; 442 } 443 444 return 0; 445 } 446 447 void nfsd_destroy(struct net *net) 448 { 449 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 450 int destroy = (nn->nfsd_serv->sv_nrthreads == 1); 451 452 if (destroy) 453 svc_shutdown_net(nn->nfsd_serv, net); 454 svc_destroy(nn->nfsd_serv); 455 if (destroy) 456 nn->nfsd_serv = NULL; 457 } 458 459 int nfsd_set_nrthreads(int n, int *nthreads, struct net *net) 460 { 461 int i = 0; 462 int tot = 0; 463 int err = 0; 464 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 465 466 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 467 468 if (nn->nfsd_serv == NULL || n <= 0) 469 return 0; 470 471 if (n > nn->nfsd_serv->sv_nrpools) 472 n = nn->nfsd_serv->sv_nrpools; 473 474 /* enforce a global maximum number of threads */ 475 tot = 0; 476 for (i = 0; i < n; i++) { 477 nthreads[i] = min(nthreads[i], NFSD_MAXSERVS); 478 tot += nthreads[i]; 479 } 480 if (tot > NFSD_MAXSERVS) { 481 /* total too large: scale down requested numbers */ 482 for (i = 0; i < n && tot > 0; i++) { 483 int new = nthreads[i] * NFSD_MAXSERVS / tot; 484 tot -= (nthreads[i] - new); 485 nthreads[i] = new; 486 } 487 for (i = 0; i < n && tot > 0; i++) { 488 nthreads[i]--; 489 tot--; 490 } 491 } 492 493 /* 494 * There must always be a thread in pool 0; the admin 495 * can't shut down NFS completely using pool_threads. 496 */ 497 if (nthreads[0] == 0) 498 nthreads[0] = 1; 499 500 /* apply the new numbers */ 501 svc_get(nn->nfsd_serv); 502 for (i = 0; i < n; i++) { 503 err = svc_set_num_threads(nn->nfsd_serv, &nn->nfsd_serv->sv_pools[i], 504 nthreads[i]); 505 if (err) 506 break; 507 } 508 nfsd_destroy(net); 509 return err; 510 } 511 512 /* 513 * Adjust the number of threads and return the new number of threads. 514 * This is also the function that starts the server if necessary, if 515 * this is the first time nrservs is nonzero. 516 */ 517 int 518 nfsd_svc(int nrservs, struct net *net) 519 { 520 int error; 521 bool nfsd_up_before; 522 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 523 524 mutex_lock(&nfsd_mutex); 525 dprintk("nfsd: creating service\n"); 526 527 nrservs = max(nrservs, 0); 528 nrservs = min(nrservs, NFSD_MAXSERVS); 529 error = 0; 530 531 if (nrservs == 0 && nn->nfsd_serv == NULL) 532 goto out; 533 534 error = nfsd_create_serv(net); 535 if (error) 536 goto out; 537 538 nfsd_up_before = nn->nfsd_net_up; 539 540 error = nfsd_startup_net(nrservs, net); 541 if (error) 542 goto out_destroy; 543 error = svc_set_num_threads(nn->nfsd_serv, NULL, nrservs); 544 if (error) 545 goto out_shutdown; 546 /* We are holding a reference to nn->nfsd_serv which 547 * we don't want to count in the return value, 548 * so subtract 1 549 */ 550 error = nn->nfsd_serv->sv_nrthreads - 1; 551 out_shutdown: 552 if (error < 0 && !nfsd_up_before) 553 nfsd_shutdown_net(net); 554 out_destroy: 555 nfsd_destroy(net); /* Release server */ 556 out: 557 mutex_unlock(&nfsd_mutex); 558 return error; 559 } 560 561 562 /* 563 * This is the NFS server kernel thread 564 */ 565 static int 566 nfsd(void *vrqstp) 567 { 568 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp; 569 struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list); 570 struct net *net = perm_sock->xpt_net; 571 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 572 int err; 573 574 /* Lock module and set up kernel thread */ 575 mutex_lock(&nfsd_mutex); 576 577 /* At this point, the thread shares current->fs 578 * with the init process. We need to create files with a 579 * umask of 0 instead of init's umask. */ 580 if (unshare_fs_struct() < 0) { 581 printk("Unable to start nfsd thread: out of memory\n"); 582 goto out; 583 } 584 585 current->fs->umask = 0; 586 587 /* 588 * thread is spawned with all signals set to SIG_IGN, re-enable 589 * the ones that will bring down the thread 590 */ 591 allow_signal(SIGKILL); 592 allow_signal(SIGHUP); 593 allow_signal(SIGINT); 594 allow_signal(SIGQUIT); 595 596 nfsdstats.th_cnt++; 597 mutex_unlock(&nfsd_mutex); 598 599 set_freezable(); 600 601 /* 602 * The main request loop 603 */ 604 for (;;) { 605 /* Update sv_maxconn if it has changed */ 606 rqstp->rq_server->sv_maxconn = nn->max_connections; 607 608 /* 609 * Find a socket with data available and call its 610 * recvfrom routine. 611 */ 612 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN) 613 ; 614 if (err == -EINTR) 615 break; 616 validate_process_creds(); 617 svc_process(rqstp); 618 validate_process_creds(); 619 } 620 621 /* Clear signals before calling svc_exit_thread() */ 622 flush_signals(current); 623 624 mutex_lock(&nfsd_mutex); 625 nfsdstats.th_cnt --; 626 627 out: 628 rqstp->rq_server = NULL; 629 630 /* Release the thread */ 631 svc_exit_thread(rqstp); 632 633 nfsd_destroy(net); 634 635 /* Release module */ 636 mutex_unlock(&nfsd_mutex); 637 module_put_and_exit(0); 638 return 0; 639 } 640 641 static __be32 map_new_errors(u32 vers, __be32 nfserr) 642 { 643 if (nfserr == nfserr_jukebox && vers == 2) 644 return nfserr_dropit; 645 if (nfserr == nfserr_wrongsec && vers < 4) 646 return nfserr_acces; 647 return nfserr; 648 } 649 650 int 651 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp) 652 { 653 struct svc_procedure *proc; 654 kxdrproc_t xdr; 655 __be32 nfserr; 656 __be32 *nfserrp; 657 658 dprintk("nfsd_dispatch: vers %d proc %d\n", 659 rqstp->rq_vers, rqstp->rq_proc); 660 proc = rqstp->rq_procinfo; 661 662 /* 663 * Give the xdr decoder a chance to change this if it wants 664 * (necessary in the NFSv4.0 compound case) 665 */ 666 rqstp->rq_cachetype = proc->pc_cachetype; 667 /* Decode arguments */ 668 xdr = proc->pc_decode; 669 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base, 670 rqstp->rq_argp)) { 671 dprintk("nfsd: failed to decode arguments!\n"); 672 *statp = rpc_garbage_args; 673 return 1; 674 } 675 676 /* Check whether we have this call in the cache. */ 677 switch (nfsd_cache_lookup(rqstp)) { 678 case RC_DROPIT: 679 return 0; 680 case RC_REPLY: 681 return 1; 682 case RC_DOIT:; 683 /* do it */ 684 } 685 686 /* need to grab the location to store the status, as 687 * nfsv4 does some encoding while processing 688 */ 689 nfserrp = rqstp->rq_res.head[0].iov_base 690 + rqstp->rq_res.head[0].iov_len; 691 rqstp->rq_res.head[0].iov_len += sizeof(__be32); 692 693 /* Now call the procedure handler, and encode NFS status. */ 694 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp); 695 nfserr = map_new_errors(rqstp->rq_vers, nfserr); 696 if (nfserr == nfserr_dropit || test_bit(RQ_DROPME, &rqstp->rq_flags)) { 697 dprintk("nfsd: Dropping request; may be revisited later\n"); 698 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 699 return 0; 700 } 701 702 if (rqstp->rq_proc != 0) 703 *nfserrp++ = nfserr; 704 705 /* Encode result. 706 * For NFSv2, additional info is never returned in case of an error. 707 */ 708 if (!(nfserr && rqstp->rq_vers == 2)) { 709 xdr = proc->pc_encode; 710 if (xdr && !xdr(rqstp, nfserrp, 711 rqstp->rq_resp)) { 712 /* Failed to encode result. Release cache entry */ 713 dprintk("nfsd: failed to encode result!\n"); 714 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 715 *statp = rpc_system_err; 716 return 1; 717 } 718 } 719 720 /* Store reply in cache. */ 721 nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1); 722 return 1; 723 } 724 725 int nfsd_pool_stats_open(struct inode *inode, struct file *file) 726 { 727 int ret; 728 struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id); 729 730 mutex_lock(&nfsd_mutex); 731 if (nn->nfsd_serv == NULL) { 732 mutex_unlock(&nfsd_mutex); 733 return -ENODEV; 734 } 735 /* bump up the psudo refcount while traversing */ 736 svc_get(nn->nfsd_serv); 737 ret = svc_pool_stats_open(nn->nfsd_serv, file); 738 mutex_unlock(&nfsd_mutex); 739 return ret; 740 } 741 742 int nfsd_pool_stats_release(struct inode *inode, struct file *file) 743 { 744 int ret = seq_release(inode, file); 745 struct net *net = inode->i_sb->s_fs_info; 746 747 mutex_lock(&nfsd_mutex); 748 /* this function really, really should have been called svc_put() */ 749 nfsd_destroy(net); 750 mutex_unlock(&nfsd_mutex); 751 return ret; 752 } 753