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