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 AF_INET, 233 nfsd_last_thread, nfsd, THIS_MODULE); 234 if (nfsd_serv == NULL) 235 err = -ENOMEM; 236 237 do_gettimeofday(&nfssvc_boot); /* record boot time */ 238 return err; 239 } 240 241 static int nfsd_init_socks(int port) 242 { 243 int error; 244 if (!list_empty(&nfsd_serv->sv_permsocks)) 245 return 0; 246 247 error = svc_create_xprt(nfsd_serv, "udp", port, 248 SVC_SOCK_DEFAULTS); 249 if (error < 0) 250 return error; 251 252 error = svc_create_xprt(nfsd_serv, "tcp", port, 253 SVC_SOCK_DEFAULTS); 254 if (error < 0) 255 return error; 256 257 error = lockd_up(); 258 if (error < 0) 259 return error; 260 261 return 0; 262 } 263 264 int nfsd_nrpools(void) 265 { 266 if (nfsd_serv == NULL) 267 return 0; 268 else 269 return nfsd_serv->sv_nrpools; 270 } 271 272 int nfsd_get_nrthreads(int n, int *nthreads) 273 { 274 int i = 0; 275 276 if (nfsd_serv != NULL) { 277 for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++) 278 nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads; 279 } 280 281 return 0; 282 } 283 284 int nfsd_set_nrthreads(int n, int *nthreads) 285 { 286 int i = 0; 287 int tot = 0; 288 int err = 0; 289 290 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 291 292 if (nfsd_serv == NULL || n <= 0) 293 return 0; 294 295 if (n > nfsd_serv->sv_nrpools) 296 n = nfsd_serv->sv_nrpools; 297 298 /* enforce a global maximum number of threads */ 299 tot = 0; 300 for (i = 0; i < n; i++) { 301 if (nthreads[i] > NFSD_MAXSERVS) 302 nthreads[i] = NFSD_MAXSERVS; 303 tot += nthreads[i]; 304 } 305 if (tot > NFSD_MAXSERVS) { 306 /* total too large: scale down requested numbers */ 307 for (i = 0; i < n && tot > 0; i++) { 308 int new = nthreads[i] * NFSD_MAXSERVS / tot; 309 tot -= (nthreads[i] - new); 310 nthreads[i] = new; 311 } 312 for (i = 0; i < n && tot > 0; i++) { 313 nthreads[i]--; 314 tot--; 315 } 316 } 317 318 /* 319 * There must always be a thread in pool 0; the admin 320 * can't shut down NFS completely using pool_threads. 321 */ 322 if (nthreads[0] == 0) 323 nthreads[0] = 1; 324 325 /* apply the new numbers */ 326 svc_get(nfsd_serv); 327 for (i = 0; i < n; i++) { 328 err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i], 329 nthreads[i]); 330 if (err) 331 break; 332 } 333 svc_destroy(nfsd_serv); 334 335 return err; 336 } 337 338 int 339 nfsd_svc(unsigned short port, int nrservs) 340 { 341 int error; 342 343 mutex_lock(&nfsd_mutex); 344 dprintk("nfsd: creating service\n"); 345 error = -EINVAL; 346 if (nrservs <= 0) 347 nrservs = 0; 348 if (nrservs > NFSD_MAXSERVS) 349 nrservs = NFSD_MAXSERVS; 350 351 /* Readahead param cache - will no-op if it already exists */ 352 error = nfsd_racache_init(2*nrservs); 353 if (error<0) 354 goto out; 355 nfs4_state_start(); 356 357 nfsd_reset_versions(); 358 359 error = nfsd_create_serv(); 360 361 if (error) 362 goto out; 363 error = nfsd_init_socks(port); 364 if (error) 365 goto failure; 366 367 error = svc_set_num_threads(nfsd_serv, NULL, nrservs); 368 failure: 369 svc_destroy(nfsd_serv); /* Release server */ 370 out: 371 mutex_unlock(&nfsd_mutex); 372 return error; 373 } 374 375 static inline void 376 update_thread_usage(int busy_threads) 377 { 378 unsigned long prev_call; 379 unsigned long diff; 380 int decile; 381 382 spin_lock(&nfsd_call_lock); 383 prev_call = nfsd_last_call; 384 nfsd_last_call = jiffies; 385 decile = busy_threads*10/nfsdstats.th_cnt; 386 if (decile>0 && decile <= 10) { 387 diff = nfsd_last_call - prev_call; 388 if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP) 389 nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP; 390 if (decile == 10) 391 nfsdstats.th_fullcnt++; 392 } 393 spin_unlock(&nfsd_call_lock); 394 } 395 396 /* 397 * This is the NFS server kernel thread 398 */ 399 static int 400 nfsd(void *vrqstp) 401 { 402 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp; 403 struct fs_struct *fsp; 404 int err, preverr = 0; 405 406 /* Lock module and set up kernel thread */ 407 mutex_lock(&nfsd_mutex); 408 409 /* At this point, the thread shares current->fs 410 * with the init process. We need to create files with a 411 * umask of 0 instead of init's umask. */ 412 fsp = copy_fs_struct(current->fs); 413 if (!fsp) { 414 printk("Unable to start nfsd thread: out of memory\n"); 415 goto out; 416 } 417 exit_fs(current); 418 current->fs = fsp; 419 current->fs->umask = 0; 420 421 /* 422 * thread is spawned with all signals set to SIG_IGN, re-enable 423 * the ones that will bring down the thread 424 */ 425 allow_signal(SIGKILL); 426 allow_signal(SIGHUP); 427 allow_signal(SIGINT); 428 allow_signal(SIGQUIT); 429 430 nfsdstats.th_cnt++; 431 mutex_unlock(&nfsd_mutex); 432 433 /* 434 * We want less throttling in balance_dirty_pages() so that nfs to 435 * localhost doesn't cause nfsd to lock up due to all the client's 436 * dirty pages. 437 */ 438 current->flags |= PF_LESS_THROTTLE; 439 set_freezable(); 440 441 /* 442 * The main request loop 443 */ 444 for (;;) { 445 /* 446 * Find a socket with data available and call its 447 * recvfrom routine. 448 */ 449 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN) 450 ; 451 if (err == -EINTR) 452 break; 453 else if (err < 0) { 454 if (err != preverr) { 455 printk(KERN_WARNING "%s: unexpected error " 456 "from svc_recv (%d)\n", __func__, -err); 457 preverr = err; 458 } 459 schedule_timeout_uninterruptible(HZ); 460 continue; 461 } 462 463 update_thread_usage(atomic_read(&nfsd_busy)); 464 atomic_inc(&nfsd_busy); 465 466 /* Lock the export hash tables for reading. */ 467 exp_readlock(); 468 469 svc_process(rqstp); 470 471 /* Unlock export hash tables */ 472 exp_readunlock(); 473 update_thread_usage(atomic_read(&nfsd_busy)); 474 atomic_dec(&nfsd_busy); 475 } 476 477 /* Clear signals before calling svc_exit_thread() */ 478 flush_signals(current); 479 480 mutex_lock(&nfsd_mutex); 481 nfsdstats.th_cnt --; 482 483 out: 484 /* Release the thread */ 485 svc_exit_thread(rqstp); 486 487 /* Release module */ 488 mutex_unlock(&nfsd_mutex); 489 module_put_and_exit(0); 490 return 0; 491 } 492 493 static __be32 map_new_errors(u32 vers, __be32 nfserr) 494 { 495 if (nfserr == nfserr_jukebox && vers == 2) 496 return nfserr_dropit; 497 if (nfserr == nfserr_wrongsec && vers < 4) 498 return nfserr_acces; 499 return nfserr; 500 } 501 502 int 503 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp) 504 { 505 struct svc_procedure *proc; 506 kxdrproc_t xdr; 507 __be32 nfserr; 508 __be32 *nfserrp; 509 510 dprintk("nfsd_dispatch: vers %d proc %d\n", 511 rqstp->rq_vers, rqstp->rq_proc); 512 proc = rqstp->rq_procinfo; 513 514 /* Check whether we have this call in the cache. */ 515 switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) { 516 case RC_INTR: 517 case RC_DROPIT: 518 return 0; 519 case RC_REPLY: 520 return 1; 521 case RC_DOIT:; 522 /* do it */ 523 } 524 525 /* Decode arguments */ 526 xdr = proc->pc_decode; 527 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base, 528 rqstp->rq_argp)) { 529 dprintk("nfsd: failed to decode arguments!\n"); 530 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 531 *statp = rpc_garbage_args; 532 return 1; 533 } 534 535 /* need to grab the location to store the status, as 536 * nfsv4 does some encoding while processing 537 */ 538 nfserrp = rqstp->rq_res.head[0].iov_base 539 + rqstp->rq_res.head[0].iov_len; 540 rqstp->rq_res.head[0].iov_len += sizeof(__be32); 541 542 /* Now call the procedure handler, and encode NFS status. */ 543 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp); 544 nfserr = map_new_errors(rqstp->rq_vers, nfserr); 545 if (nfserr == nfserr_dropit) { 546 dprintk("nfsd: Dropping request; may be revisited later\n"); 547 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 548 return 0; 549 } 550 551 if (rqstp->rq_proc != 0) 552 *nfserrp++ = nfserr; 553 554 /* Encode result. 555 * For NFSv2, additional info is never returned in case of an error. 556 */ 557 if (!(nfserr && rqstp->rq_vers == 2)) { 558 xdr = proc->pc_encode; 559 if (xdr && !xdr(rqstp, nfserrp, 560 rqstp->rq_resp)) { 561 /* Failed to encode result. Release cache entry */ 562 dprintk("nfsd: failed to encode result!\n"); 563 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 564 *statp = rpc_system_err; 565 return 1; 566 } 567 } 568 569 /* Store reply in cache. */ 570 nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1); 571 return 1; 572 } 573