1 /* 2 * linux/fs/nfsd/nfssvc.c 3 * 4 * Central processing for nfsd. 5 * 6 * Authors: Olaf Kirch (okir@monad.swb.de) 7 * 8 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> 9 */ 10 11 #include <linux/module.h> 12 #include <linux/sched.h> 13 #include <linux/time.h> 14 #include <linux/errno.h> 15 #include <linux/nfs.h> 16 #include <linux/in.h> 17 #include <linux/uio.h> 18 #include <linux/unistd.h> 19 #include <linux/slab.h> 20 #include <linux/smp.h> 21 #include <linux/smp_lock.h> 22 #include <linux/freezer.h> 23 #include <linux/fs_struct.h> 24 #include <linux/kthread.h> 25 26 #include <linux/sunrpc/types.h> 27 #include <linux/sunrpc/stats.h> 28 #include <linux/sunrpc/svc.h> 29 #include <linux/sunrpc/svcsock.h> 30 #include <linux/sunrpc/cache.h> 31 #include <linux/nfsd/nfsd.h> 32 #include <linux/nfsd/stats.h> 33 #include <linux/nfsd/cache.h> 34 #include <linux/nfsd/syscall.h> 35 #include <linux/lockd/bind.h> 36 #include <linux/nfsacl.h> 37 38 #define NFSDDBG_FACILITY NFSDDBG_SVC 39 40 extern struct svc_program nfsd_program; 41 static int nfsd(void *vrqstp); 42 struct timeval nfssvc_boot; 43 static atomic_t nfsd_busy; 44 static unsigned long nfsd_last_call; 45 static DEFINE_SPINLOCK(nfsd_call_lock); 46 47 /* 48 * nfsd_mutex protects nfsd_serv -- both the pointer itself and the members 49 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some 50 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt 51 * 52 * If (out side the lock) nfsd_serv is non-NULL, then it must point to a 53 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number 54 * of nfsd threads must exist and each must listed in ->sp_all_threads in each 55 * entry of ->sv_pools[]. 56 * 57 * Transitions of the thread count between zero and non-zero are of particular 58 * interest since the svc_serv needs to be created and initialized at that 59 * point, or freed. 60 * 61 * Finally, the nfsd_mutex also protects some of the global variables that are 62 * accessed when nfsd starts and that are settable via the write_* routines in 63 * nfsctl.c. In particular: 64 * 65 * user_recovery_dirname 66 * user_lease_time 67 * nfsd_versions 68 */ 69 DEFINE_MUTEX(nfsd_mutex); 70 struct svc_serv *nfsd_serv; 71 72 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 73 static struct svc_stat nfsd_acl_svcstats; 74 static struct svc_version * nfsd_acl_version[] = { 75 [2] = &nfsd_acl_version2, 76 [3] = &nfsd_acl_version3, 77 }; 78 79 #define NFSD_ACL_MINVERS 2 80 #define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version) 81 static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS]; 82 83 static struct svc_program nfsd_acl_program = { 84 .pg_prog = NFS_ACL_PROGRAM, 85 .pg_nvers = NFSD_ACL_NRVERS, 86 .pg_vers = nfsd_acl_versions, 87 .pg_name = "nfsacl", 88 .pg_class = "nfsd", 89 .pg_stats = &nfsd_acl_svcstats, 90 .pg_authenticate = &svc_set_client, 91 }; 92 93 static struct svc_stat nfsd_acl_svcstats = { 94 .program = &nfsd_acl_program, 95 }; 96 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */ 97 98 static struct svc_version * nfsd_version[] = { 99 [2] = &nfsd_version2, 100 #if defined(CONFIG_NFSD_V3) 101 [3] = &nfsd_version3, 102 #endif 103 #if defined(CONFIG_NFSD_V4) 104 [4] = &nfsd_version4, 105 #endif 106 }; 107 108 #define NFSD_MINVERS 2 109 #define NFSD_NRVERS ARRAY_SIZE(nfsd_version) 110 static struct svc_version *nfsd_versions[NFSD_NRVERS]; 111 112 struct svc_program nfsd_program = { 113 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 114 .pg_next = &nfsd_acl_program, 115 #endif 116 .pg_prog = NFS_PROGRAM, /* program number */ 117 .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */ 118 .pg_vers = nfsd_versions, /* version table */ 119 .pg_name = "nfsd", /* program name */ 120 .pg_class = "nfsd", /* authentication class */ 121 .pg_stats = &nfsd_svcstats, /* version table */ 122 .pg_authenticate = &svc_set_client, /* export authentication */ 123 124 }; 125 126 int nfsd_vers(int vers, enum vers_op change) 127 { 128 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS) 129 return -1; 130 switch(change) { 131 case NFSD_SET: 132 nfsd_versions[vers] = nfsd_version[vers]; 133 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 134 if (vers < NFSD_ACL_NRVERS) 135 nfsd_acl_versions[vers] = nfsd_acl_version[vers]; 136 #endif 137 break; 138 case NFSD_CLEAR: 139 nfsd_versions[vers] = NULL; 140 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 141 if (vers < NFSD_ACL_NRVERS) 142 nfsd_acl_versions[vers] = NULL; 143 #endif 144 break; 145 case NFSD_TEST: 146 return nfsd_versions[vers] != NULL; 147 case NFSD_AVAIL: 148 return nfsd_version[vers] != NULL; 149 } 150 return 0; 151 } 152 /* 153 * Maximum number of nfsd processes 154 */ 155 #define NFSD_MAXSERVS 8192 156 157 int nfsd_nrthreads(void) 158 { 159 int rv = 0; 160 mutex_lock(&nfsd_mutex); 161 if (nfsd_serv) 162 rv = nfsd_serv->sv_nrthreads; 163 mutex_unlock(&nfsd_mutex); 164 return rv; 165 } 166 167 static void nfsd_last_thread(struct svc_serv *serv) 168 { 169 /* When last nfsd thread exits we need to do some clean-up */ 170 struct svc_xprt *xprt; 171 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) 172 lockd_down(); 173 nfsd_serv = NULL; 174 nfsd_racache_shutdown(); 175 nfs4_state_shutdown(); 176 177 printk(KERN_WARNING "nfsd: last server has exited, flushing export " 178 "cache\n"); 179 nfsd_export_flush(); 180 } 181 182 void nfsd_reset_versions(void) 183 { 184 int found_one = 0; 185 int i; 186 187 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) { 188 if (nfsd_program.pg_vers[i]) 189 found_one = 1; 190 } 191 192 if (!found_one) { 193 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) 194 nfsd_program.pg_vers[i] = nfsd_version[i]; 195 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 196 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++) 197 nfsd_acl_program.pg_vers[i] = 198 nfsd_acl_version[i]; 199 #endif 200 } 201 } 202 203 204 int nfsd_create_serv(void) 205 { 206 int err = 0; 207 208 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 209 if (nfsd_serv) { 210 svc_get(nfsd_serv); 211 return 0; 212 } 213 if (nfsd_max_blksize == 0) { 214 /* choose a suitable default */ 215 struct sysinfo i; 216 si_meminfo(&i); 217 /* Aim for 1/4096 of memory per thread 218 * This gives 1MB on 4Gig machines 219 * But only uses 32K on 128M machines. 220 * Bottom out at 8K on 32M and smaller. 221 * Of course, this is only a default. 222 */ 223 nfsd_max_blksize = NFSSVC_MAXBLKSIZE; 224 i.totalram <<= PAGE_SHIFT - 12; 225 while (nfsd_max_blksize > i.totalram && 226 nfsd_max_blksize >= 8*1024*2) 227 nfsd_max_blksize /= 2; 228 } 229 230 atomic_set(&nfsd_busy, 0); 231 nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize, 232 nfsd_last_thread, nfsd, THIS_MODULE); 233 if (nfsd_serv == NULL) 234 err = -ENOMEM; 235 236 do_gettimeofday(&nfssvc_boot); /* record boot time */ 237 return err; 238 } 239 240 static int nfsd_init_socks(int port) 241 { 242 int error; 243 if (!list_empty(&nfsd_serv->sv_permsocks)) 244 return 0; 245 246 error = lockd_up(IPPROTO_UDP); 247 if (error >= 0) { 248 error = svc_create_xprt(nfsd_serv, "udp", port, 249 SVC_SOCK_DEFAULTS); 250 if (error < 0) 251 lockd_down(); 252 } 253 if (error < 0) 254 return error; 255 256 error = lockd_up(IPPROTO_TCP); 257 if (error >= 0) { 258 error = svc_create_xprt(nfsd_serv, "tcp", port, 259 SVC_SOCK_DEFAULTS); 260 if (error < 0) 261 lockd_down(); 262 } 263 if (error < 0) 264 return error; 265 return 0; 266 } 267 268 int nfsd_nrpools(void) 269 { 270 if (nfsd_serv == NULL) 271 return 0; 272 else 273 return nfsd_serv->sv_nrpools; 274 } 275 276 int nfsd_get_nrthreads(int n, int *nthreads) 277 { 278 int i = 0; 279 280 if (nfsd_serv != NULL) { 281 for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++) 282 nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads; 283 } 284 285 return 0; 286 } 287 288 int nfsd_set_nrthreads(int n, int *nthreads) 289 { 290 int i = 0; 291 int tot = 0; 292 int err = 0; 293 294 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 295 296 if (nfsd_serv == NULL || n <= 0) 297 return 0; 298 299 if (n > nfsd_serv->sv_nrpools) 300 n = nfsd_serv->sv_nrpools; 301 302 /* enforce a global maximum number of threads */ 303 tot = 0; 304 for (i = 0; i < n; i++) { 305 if (nthreads[i] > NFSD_MAXSERVS) 306 nthreads[i] = NFSD_MAXSERVS; 307 tot += nthreads[i]; 308 } 309 if (tot > NFSD_MAXSERVS) { 310 /* total too large: scale down requested numbers */ 311 for (i = 0; i < n && tot > 0; i++) { 312 int new = nthreads[i] * NFSD_MAXSERVS / tot; 313 tot -= (nthreads[i] - new); 314 nthreads[i] = new; 315 } 316 for (i = 0; i < n && tot > 0; i++) { 317 nthreads[i]--; 318 tot--; 319 } 320 } 321 322 /* 323 * There must always be a thread in pool 0; the admin 324 * can't shut down NFS completely using pool_threads. 325 */ 326 if (nthreads[0] == 0) 327 nthreads[0] = 1; 328 329 /* apply the new numbers */ 330 svc_get(nfsd_serv); 331 for (i = 0; i < n; i++) { 332 err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i], 333 nthreads[i]); 334 if (err) 335 break; 336 } 337 svc_destroy(nfsd_serv); 338 339 return err; 340 } 341 342 int 343 nfsd_svc(unsigned short port, int nrservs) 344 { 345 int error; 346 347 mutex_lock(&nfsd_mutex); 348 dprintk("nfsd: creating service\n"); 349 error = -EINVAL; 350 if (nrservs <= 0) 351 nrservs = 0; 352 if (nrservs > NFSD_MAXSERVS) 353 nrservs = NFSD_MAXSERVS; 354 355 /* Readahead param cache - will no-op if it already exists */ 356 error = nfsd_racache_init(2*nrservs); 357 if (error<0) 358 goto out; 359 nfs4_state_start(); 360 361 nfsd_reset_versions(); 362 363 error = nfsd_create_serv(); 364 365 if (error) 366 goto out; 367 error = nfsd_init_socks(port); 368 if (error) 369 goto failure; 370 371 error = svc_set_num_threads(nfsd_serv, NULL, nrservs); 372 failure: 373 svc_destroy(nfsd_serv); /* Release server */ 374 out: 375 mutex_unlock(&nfsd_mutex); 376 return error; 377 } 378 379 static inline void 380 update_thread_usage(int busy_threads) 381 { 382 unsigned long prev_call; 383 unsigned long diff; 384 int decile; 385 386 spin_lock(&nfsd_call_lock); 387 prev_call = nfsd_last_call; 388 nfsd_last_call = jiffies; 389 decile = busy_threads*10/nfsdstats.th_cnt; 390 if (decile>0 && decile <= 10) { 391 diff = nfsd_last_call - prev_call; 392 if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP) 393 nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP; 394 if (decile == 10) 395 nfsdstats.th_fullcnt++; 396 } 397 spin_unlock(&nfsd_call_lock); 398 } 399 400 /* 401 * This is the NFS server kernel thread 402 */ 403 static int 404 nfsd(void *vrqstp) 405 { 406 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp; 407 struct fs_struct *fsp; 408 int err, preverr = 0; 409 410 /* Lock module and set up kernel thread */ 411 mutex_lock(&nfsd_mutex); 412 413 /* At this point, the thread shares current->fs 414 * with the init process. We need to create files with a 415 * umask of 0 instead of init's umask. */ 416 fsp = copy_fs_struct(current->fs); 417 if (!fsp) { 418 printk("Unable to start nfsd thread: out of memory\n"); 419 goto out; 420 } 421 exit_fs(current); 422 current->fs = fsp; 423 current->fs->umask = 0; 424 425 /* 426 * thread is spawned with all signals set to SIG_IGN, re-enable 427 * the ones that will bring down the thread 428 */ 429 allow_signal(SIGKILL); 430 allow_signal(SIGHUP); 431 allow_signal(SIGINT); 432 allow_signal(SIGQUIT); 433 434 nfsdstats.th_cnt++; 435 mutex_unlock(&nfsd_mutex); 436 437 /* 438 * We want less throttling in balance_dirty_pages() so that nfs to 439 * localhost doesn't cause nfsd to lock up due to all the client's 440 * dirty pages. 441 */ 442 current->flags |= PF_LESS_THROTTLE; 443 set_freezable(); 444 445 /* 446 * The main request loop 447 */ 448 for (;;) { 449 /* 450 * Find a socket with data available and call its 451 * recvfrom routine. 452 */ 453 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN) 454 ; 455 if (err == -EINTR) 456 break; 457 else if (err < 0) { 458 if (err != preverr) { 459 printk(KERN_WARNING "%s: unexpected error " 460 "from svc_recv (%d)\n", __func__, -err); 461 preverr = err; 462 } 463 schedule_timeout_uninterruptible(HZ); 464 continue; 465 } 466 467 update_thread_usage(atomic_read(&nfsd_busy)); 468 atomic_inc(&nfsd_busy); 469 470 /* Lock the export hash tables for reading. */ 471 exp_readlock(); 472 473 svc_process(rqstp); 474 475 /* Unlock export hash tables */ 476 exp_readunlock(); 477 update_thread_usage(atomic_read(&nfsd_busy)); 478 atomic_dec(&nfsd_busy); 479 } 480 481 /* Clear signals before calling svc_exit_thread() */ 482 flush_signals(current); 483 484 mutex_lock(&nfsd_mutex); 485 nfsdstats.th_cnt --; 486 487 out: 488 /* Release the thread */ 489 svc_exit_thread(rqstp); 490 491 /* Release module */ 492 mutex_unlock(&nfsd_mutex); 493 module_put_and_exit(0); 494 return 0; 495 } 496 497 static __be32 map_new_errors(u32 vers, __be32 nfserr) 498 { 499 if (nfserr == nfserr_jukebox && vers == 2) 500 return nfserr_dropit; 501 if (nfserr == nfserr_wrongsec && vers < 4) 502 return nfserr_acces; 503 return nfserr; 504 } 505 506 int 507 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp) 508 { 509 struct svc_procedure *proc; 510 kxdrproc_t xdr; 511 __be32 nfserr; 512 __be32 *nfserrp; 513 514 dprintk("nfsd_dispatch: vers %d proc %d\n", 515 rqstp->rq_vers, rqstp->rq_proc); 516 proc = rqstp->rq_procinfo; 517 518 /* Check whether we have this call in the cache. */ 519 switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) { 520 case RC_INTR: 521 case RC_DROPIT: 522 return 0; 523 case RC_REPLY: 524 return 1; 525 case RC_DOIT:; 526 /* do it */ 527 } 528 529 /* Decode arguments */ 530 xdr = proc->pc_decode; 531 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base, 532 rqstp->rq_argp)) { 533 dprintk("nfsd: failed to decode arguments!\n"); 534 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 535 *statp = rpc_garbage_args; 536 return 1; 537 } 538 539 /* need to grab the location to store the status, as 540 * nfsv4 does some encoding while processing 541 */ 542 nfserrp = rqstp->rq_res.head[0].iov_base 543 + rqstp->rq_res.head[0].iov_len; 544 rqstp->rq_res.head[0].iov_len += sizeof(__be32); 545 546 /* Now call the procedure handler, and encode NFS status. */ 547 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp); 548 nfserr = map_new_errors(rqstp->rq_vers, nfserr); 549 if (nfserr == nfserr_dropit) { 550 dprintk("nfsd: Dropping request; may be revisited later\n"); 551 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 552 return 0; 553 } 554 555 if (rqstp->rq_proc != 0) 556 *nfserrp++ = nfserr; 557 558 /* Encode result. 559 * For NFSv2, additional info is never returned in case of an error. 560 */ 561 if (!(nfserr && rqstp->rq_vers == 2)) { 562 xdr = proc->pc_encode; 563 if (xdr && !xdr(rqstp, nfserrp, 564 rqstp->rq_resp)) { 565 /* Failed to encode result. Release cache entry */ 566 dprintk("nfsd: failed to encode result!\n"); 567 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 568 *statp = rpc_system_err; 569 return 1; 570 } 571 } 572 573 /* Store reply in cache. */ 574 nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1); 575 return 1; 576 } 577