1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Central processing for nfsd. 4 * 5 * Authors: Olaf Kirch (okir@monad.swb.de) 6 * 7 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> 8 */ 9 10 #include <linux/sched/signal.h> 11 #include <linux/freezer.h> 12 #include <linux/module.h> 13 #include <linux/fs_struct.h> 14 #include <linux/swap.h> 15 16 #include <linux/sunrpc/stats.h> 17 #include <linux/sunrpc/svcsock.h> 18 #include <linux/sunrpc/svc_xprt.h> 19 #include <linux/lockd/bind.h> 20 #include <linux/nfsacl.h> 21 #include <linux/seq_file.h> 22 #include <linux/inetdevice.h> 23 #include <net/addrconf.h> 24 #include <net/ipv6.h> 25 #include <net/net_namespace.h> 26 #include "nfsd.h" 27 #include "cache.h" 28 #include "vfs.h" 29 #include "netns.h" 30 #include "filecache.h" 31 32 #define NFSDDBG_FACILITY NFSDDBG_SVC 33 34 bool inter_copy_offload_enable; 35 EXPORT_SYMBOL_GPL(inter_copy_offload_enable); 36 module_param(inter_copy_offload_enable, bool, 0644); 37 MODULE_PARM_DESC(inter_copy_offload_enable, 38 "Enable inter server to server copy offload. Default: false"); 39 40 extern struct svc_program nfsd_program; 41 static int nfsd(void *vrqstp); 42 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 43 static int nfsd_acl_rpcbind_set(struct net *, 44 const struct svc_program *, 45 u32, int, 46 unsigned short, 47 unsigned short); 48 static __be32 nfsd_acl_init_request(struct svc_rqst *, 49 const struct svc_program *, 50 struct svc_process_info *); 51 #endif 52 static int nfsd_rpcbind_set(struct net *, 53 const struct svc_program *, 54 u32, int, 55 unsigned short, 56 unsigned short); 57 static __be32 nfsd_init_request(struct svc_rqst *, 58 const struct svc_program *, 59 struct svc_process_info *); 60 61 /* 62 * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members 63 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some 64 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt 65 * 66 * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a 67 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number 68 * of nfsd threads must exist and each must listed in ->sp_all_threads in each 69 * entry of ->sv_pools[]. 70 * 71 * Transitions of the thread count between zero and non-zero are of particular 72 * interest since the svc_serv needs to be created and initialized at that 73 * point, or freed. 74 * 75 * Finally, the nfsd_mutex also protects some of the global variables that are 76 * accessed when nfsd starts and that are settable via the write_* routines in 77 * nfsctl.c. In particular: 78 * 79 * user_recovery_dirname 80 * user_lease_time 81 * nfsd_versions 82 */ 83 DEFINE_MUTEX(nfsd_mutex); 84 85 /* 86 * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used. 87 * nfsd_drc_max_pages limits the total amount of memory available for 88 * version 4.1 DRC caches. 89 * nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage. 90 */ 91 spinlock_t nfsd_drc_lock; 92 unsigned long nfsd_drc_max_mem; 93 unsigned long nfsd_drc_mem_used; 94 95 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 96 static struct svc_stat nfsd_acl_svcstats; 97 static const struct svc_version *nfsd_acl_version[] = { 98 [2] = &nfsd_acl_version2, 99 [3] = &nfsd_acl_version3, 100 }; 101 102 #define NFSD_ACL_MINVERS 2 103 #define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version) 104 105 static struct svc_program nfsd_acl_program = { 106 .pg_prog = NFS_ACL_PROGRAM, 107 .pg_nvers = NFSD_ACL_NRVERS, 108 .pg_vers = nfsd_acl_version, 109 .pg_name = "nfsacl", 110 .pg_class = "nfsd", 111 .pg_stats = &nfsd_acl_svcstats, 112 .pg_authenticate = &svc_set_client, 113 .pg_init_request = nfsd_acl_init_request, 114 .pg_rpcbind_set = nfsd_acl_rpcbind_set, 115 }; 116 117 static struct svc_stat nfsd_acl_svcstats = { 118 .program = &nfsd_acl_program, 119 }; 120 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */ 121 122 static const struct svc_version *nfsd_version[] = { 123 [2] = &nfsd_version2, 124 #if defined(CONFIG_NFSD_V3) 125 [3] = &nfsd_version3, 126 #endif 127 #if defined(CONFIG_NFSD_V4) 128 [4] = &nfsd_version4, 129 #endif 130 }; 131 132 #define NFSD_MINVERS 2 133 #define NFSD_NRVERS ARRAY_SIZE(nfsd_version) 134 135 struct svc_program nfsd_program = { 136 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 137 .pg_next = &nfsd_acl_program, 138 #endif 139 .pg_prog = NFS_PROGRAM, /* program number */ 140 .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */ 141 .pg_vers = nfsd_version, /* version table */ 142 .pg_name = "nfsd", /* program name */ 143 .pg_class = "nfsd", /* authentication class */ 144 .pg_stats = &nfsd_svcstats, /* version table */ 145 .pg_authenticate = &svc_set_client, /* export authentication */ 146 .pg_init_request = nfsd_init_request, 147 .pg_rpcbind_set = nfsd_rpcbind_set, 148 }; 149 150 static bool 151 nfsd_support_version(int vers) 152 { 153 if (vers >= NFSD_MINVERS && vers < NFSD_NRVERS) 154 return nfsd_version[vers] != NULL; 155 return false; 156 } 157 158 static bool * 159 nfsd_alloc_versions(void) 160 { 161 bool *vers = kmalloc_array(NFSD_NRVERS, sizeof(bool), GFP_KERNEL); 162 unsigned i; 163 164 if (vers) { 165 /* All compiled versions are enabled by default */ 166 for (i = 0; i < NFSD_NRVERS; i++) 167 vers[i] = nfsd_support_version(i); 168 } 169 return vers; 170 } 171 172 static bool * 173 nfsd_alloc_minorversions(void) 174 { 175 bool *vers = kmalloc_array(NFSD_SUPPORTED_MINOR_VERSION + 1, 176 sizeof(bool), GFP_KERNEL); 177 unsigned i; 178 179 if (vers) { 180 /* All minor versions are enabled by default */ 181 for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++) 182 vers[i] = nfsd_support_version(4); 183 } 184 return vers; 185 } 186 187 void 188 nfsd_netns_free_versions(struct nfsd_net *nn) 189 { 190 kfree(nn->nfsd_versions); 191 kfree(nn->nfsd4_minorversions); 192 nn->nfsd_versions = NULL; 193 nn->nfsd4_minorversions = NULL; 194 } 195 196 static void 197 nfsd_netns_init_versions(struct nfsd_net *nn) 198 { 199 if (!nn->nfsd_versions) { 200 nn->nfsd_versions = nfsd_alloc_versions(); 201 nn->nfsd4_minorversions = nfsd_alloc_minorversions(); 202 if (!nn->nfsd_versions || !nn->nfsd4_minorversions) 203 nfsd_netns_free_versions(nn); 204 } 205 } 206 207 int nfsd_vers(struct nfsd_net *nn, int vers, enum vers_op change) 208 { 209 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS) 210 return 0; 211 switch(change) { 212 case NFSD_SET: 213 if (nn->nfsd_versions) 214 nn->nfsd_versions[vers] = nfsd_support_version(vers); 215 break; 216 case NFSD_CLEAR: 217 nfsd_netns_init_versions(nn); 218 if (nn->nfsd_versions) 219 nn->nfsd_versions[vers] = false; 220 break; 221 case NFSD_TEST: 222 if (nn->nfsd_versions) 223 return nn->nfsd_versions[vers]; 224 /* Fallthrough */ 225 case NFSD_AVAIL: 226 return nfsd_support_version(vers); 227 } 228 return 0; 229 } 230 231 static void 232 nfsd_adjust_nfsd_versions4(struct nfsd_net *nn) 233 { 234 unsigned i; 235 236 for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++) { 237 if (nn->nfsd4_minorversions[i]) 238 return; 239 } 240 nfsd_vers(nn, 4, NFSD_CLEAR); 241 } 242 243 int nfsd_minorversion(struct nfsd_net *nn, u32 minorversion, enum vers_op change) 244 { 245 if (minorversion > NFSD_SUPPORTED_MINOR_VERSION && 246 change != NFSD_AVAIL) 247 return -1; 248 249 switch(change) { 250 case NFSD_SET: 251 if (nn->nfsd4_minorversions) { 252 nfsd_vers(nn, 4, NFSD_SET); 253 nn->nfsd4_minorversions[minorversion] = 254 nfsd_vers(nn, 4, NFSD_TEST); 255 } 256 break; 257 case NFSD_CLEAR: 258 nfsd_netns_init_versions(nn); 259 if (nn->nfsd4_minorversions) { 260 nn->nfsd4_minorversions[minorversion] = false; 261 nfsd_adjust_nfsd_versions4(nn); 262 } 263 break; 264 case NFSD_TEST: 265 if (nn->nfsd4_minorversions) 266 return nn->nfsd4_minorversions[minorversion]; 267 return nfsd_vers(nn, 4, NFSD_TEST); 268 case NFSD_AVAIL: 269 return minorversion <= NFSD_SUPPORTED_MINOR_VERSION && 270 nfsd_vers(nn, 4, NFSD_AVAIL); 271 } 272 return 0; 273 } 274 275 /* 276 * Maximum number of nfsd processes 277 */ 278 #define NFSD_MAXSERVS 8192 279 280 int nfsd_nrthreads(struct net *net) 281 { 282 int rv = 0; 283 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 284 285 mutex_lock(&nfsd_mutex); 286 if (nn->nfsd_serv) 287 rv = nn->nfsd_serv->sv_nrthreads; 288 mutex_unlock(&nfsd_mutex); 289 return rv; 290 } 291 292 static int nfsd_init_socks(struct net *net, const struct cred *cred) 293 { 294 int error; 295 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 296 297 if (!list_empty(&nn->nfsd_serv->sv_permsocks)) 298 return 0; 299 300 error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT, 301 SVC_SOCK_DEFAULTS, cred); 302 if (error < 0) 303 return error; 304 305 error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT, 306 SVC_SOCK_DEFAULTS, cred); 307 if (error < 0) 308 return error; 309 310 return 0; 311 } 312 313 static int nfsd_users = 0; 314 315 static int nfsd_startup_generic(int nrservs) 316 { 317 int ret; 318 319 if (nfsd_users++) 320 return 0; 321 322 ret = nfsd_file_cache_init(); 323 if (ret) 324 goto dec_users; 325 326 ret = nfs4_state_start(); 327 if (ret) 328 goto out_file_cache; 329 return 0; 330 331 out_file_cache: 332 nfsd_file_cache_shutdown(); 333 dec_users: 334 nfsd_users--; 335 return ret; 336 } 337 338 static void nfsd_shutdown_generic(void) 339 { 340 if (--nfsd_users) 341 return; 342 343 nfs4_state_shutdown(); 344 nfsd_file_cache_shutdown(); 345 } 346 347 static bool nfsd_needs_lockd(struct nfsd_net *nn) 348 { 349 return nfsd_vers(nn, 2, NFSD_TEST) || nfsd_vers(nn, 3, NFSD_TEST); 350 } 351 352 void nfsd_copy_boot_verifier(__be32 verf[2], struct nfsd_net *nn) 353 { 354 int seq = 0; 355 356 do { 357 read_seqbegin_or_lock(&nn->boot_lock, &seq); 358 /* 359 * This is opaque to client, so no need to byte-swap. Use 360 * __force to keep sparse happy. y2038 time_t overflow is 361 * irrelevant in this usage 362 */ 363 verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec; 364 verf[1] = (__force __be32)nn->nfssvc_boot.tv_nsec; 365 } while (need_seqretry(&nn->boot_lock, seq)); 366 done_seqretry(&nn->boot_lock, seq); 367 } 368 369 static void nfsd_reset_boot_verifier_locked(struct nfsd_net *nn) 370 { 371 ktime_get_real_ts64(&nn->nfssvc_boot); 372 } 373 374 void nfsd_reset_boot_verifier(struct nfsd_net *nn) 375 { 376 write_seqlock(&nn->boot_lock); 377 nfsd_reset_boot_verifier_locked(nn); 378 write_sequnlock(&nn->boot_lock); 379 } 380 381 static int nfsd_startup_net(int nrservs, struct net *net, const struct cred *cred) 382 { 383 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 384 int ret; 385 386 if (nn->nfsd_net_up) 387 return 0; 388 389 ret = nfsd_startup_generic(nrservs); 390 if (ret) 391 return ret; 392 ret = nfsd_init_socks(net, cred); 393 if (ret) 394 goto out_socks; 395 396 if (nfsd_needs_lockd(nn) && !nn->lockd_up) { 397 ret = lockd_up(net, cred); 398 if (ret) 399 goto out_socks; 400 nn->lockd_up = true; 401 } 402 403 ret = nfsd_file_cache_start_net(net); 404 if (ret) 405 goto out_lockd; 406 ret = nfs4_state_start_net(net); 407 if (ret) 408 goto out_filecache; 409 410 nn->nfsd_net_up = true; 411 return 0; 412 413 out_filecache: 414 nfsd_file_cache_shutdown_net(net); 415 out_lockd: 416 if (nn->lockd_up) { 417 lockd_down(net); 418 nn->lockd_up = false; 419 } 420 out_socks: 421 nfsd_shutdown_generic(); 422 return ret; 423 } 424 425 static void nfsd_shutdown_net(struct net *net) 426 { 427 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 428 429 nfsd_file_cache_shutdown_net(net); 430 nfs4_state_shutdown_net(net); 431 if (nn->lockd_up) { 432 lockd_down(net); 433 nn->lockd_up = false; 434 } 435 nn->nfsd_net_up = false; 436 nfsd_shutdown_generic(); 437 } 438 439 static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event, 440 void *ptr) 441 { 442 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 443 struct net_device *dev = ifa->ifa_dev->dev; 444 struct net *net = dev_net(dev); 445 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 446 struct sockaddr_in sin; 447 448 if ((event != NETDEV_DOWN) || 449 !atomic_inc_not_zero(&nn->ntf_refcnt)) 450 goto out; 451 452 if (nn->nfsd_serv) { 453 dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local); 454 sin.sin_family = AF_INET; 455 sin.sin_addr.s_addr = ifa->ifa_local; 456 svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin); 457 } 458 atomic_dec(&nn->ntf_refcnt); 459 wake_up(&nn->ntf_wq); 460 461 out: 462 return NOTIFY_DONE; 463 } 464 465 static struct notifier_block nfsd_inetaddr_notifier = { 466 .notifier_call = nfsd_inetaddr_event, 467 }; 468 469 #if IS_ENABLED(CONFIG_IPV6) 470 static int nfsd_inet6addr_event(struct notifier_block *this, 471 unsigned long event, void *ptr) 472 { 473 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; 474 struct net_device *dev = ifa->idev->dev; 475 struct net *net = dev_net(dev); 476 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 477 struct sockaddr_in6 sin6; 478 479 if ((event != NETDEV_DOWN) || 480 !atomic_inc_not_zero(&nn->ntf_refcnt)) 481 goto out; 482 483 if (nn->nfsd_serv) { 484 dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr); 485 sin6.sin6_family = AF_INET6; 486 sin6.sin6_addr = ifa->addr; 487 if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL) 488 sin6.sin6_scope_id = ifa->idev->dev->ifindex; 489 svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6); 490 } 491 atomic_dec(&nn->ntf_refcnt); 492 wake_up(&nn->ntf_wq); 493 out: 494 return NOTIFY_DONE; 495 } 496 497 static struct notifier_block nfsd_inet6addr_notifier = { 498 .notifier_call = nfsd_inet6addr_event, 499 }; 500 #endif 501 502 /* Only used under nfsd_mutex, so this atomic may be overkill: */ 503 static atomic_t nfsd_notifier_refcount = ATOMIC_INIT(0); 504 505 static void nfsd_last_thread(struct svc_serv *serv, struct net *net) 506 { 507 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 508 509 atomic_dec(&nn->ntf_refcnt); 510 /* check if the notifier still has clients */ 511 if (atomic_dec_return(&nfsd_notifier_refcount) == 0) { 512 unregister_inetaddr_notifier(&nfsd_inetaddr_notifier); 513 #if IS_ENABLED(CONFIG_IPV6) 514 unregister_inet6addr_notifier(&nfsd_inet6addr_notifier); 515 #endif 516 } 517 wait_event(nn->ntf_wq, atomic_read(&nn->ntf_refcnt) == 0); 518 519 /* 520 * write_ports can create the server without actually starting 521 * any threads--if we get shut down before any threads are 522 * started, then nfsd_last_thread will be run before any of this 523 * other initialization has been done except the rpcb information. 524 */ 525 svc_rpcb_cleanup(serv, net); 526 if (!nn->nfsd_net_up) 527 return; 528 529 nfsd_shutdown_net(net); 530 printk(KERN_WARNING "nfsd: last server has exited, flushing export " 531 "cache\n"); 532 nfsd_export_flush(net); 533 } 534 535 void nfsd_reset_versions(struct nfsd_net *nn) 536 { 537 int i; 538 539 for (i = 0; i < NFSD_NRVERS; i++) 540 if (nfsd_vers(nn, i, NFSD_TEST)) 541 return; 542 543 for (i = 0; i < NFSD_NRVERS; i++) 544 if (i != 4) 545 nfsd_vers(nn, i, NFSD_SET); 546 else { 547 int minor = 0; 548 while (nfsd_minorversion(nn, minor, NFSD_SET) >= 0) 549 minor++; 550 } 551 } 552 553 /* 554 * Each session guarantees a negotiated per slot memory cache for replies 555 * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated 556 * NFSv4.1 server might want to use more memory for a DRC than a machine 557 * with mutiple services. 558 * 559 * Impose a hard limit on the number of pages for the DRC which varies 560 * according to the machines free pages. This is of course only a default. 561 * 562 * For now this is a #defined shift which could be under admin control 563 * in the future. 564 */ 565 static void set_max_drc(void) 566 { 567 #define NFSD_DRC_SIZE_SHIFT 7 568 nfsd_drc_max_mem = (nr_free_buffer_pages() 569 >> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE; 570 nfsd_drc_mem_used = 0; 571 spin_lock_init(&nfsd_drc_lock); 572 dprintk("%s nfsd_drc_max_mem %lu \n", __func__, nfsd_drc_max_mem); 573 } 574 575 static int nfsd_get_default_max_blksize(void) 576 { 577 struct sysinfo i; 578 unsigned long long target; 579 unsigned long ret; 580 581 si_meminfo(&i); 582 target = (i.totalram - i.totalhigh) << PAGE_SHIFT; 583 /* 584 * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig 585 * machines, but only uses 32K on 128M machines. Bottom out at 586 * 8K on 32M and smaller. Of course, this is only a default. 587 */ 588 target >>= 12; 589 590 ret = NFSSVC_MAXBLKSIZE; 591 while (ret > target && ret >= 8*1024*2) 592 ret /= 2; 593 return ret; 594 } 595 596 static const struct svc_serv_ops nfsd_thread_sv_ops = { 597 .svo_shutdown = nfsd_last_thread, 598 .svo_function = nfsd, 599 .svo_enqueue_xprt = svc_xprt_do_enqueue, 600 .svo_setup = svc_set_num_threads, 601 .svo_module = THIS_MODULE, 602 }; 603 604 int nfsd_create_serv(struct net *net) 605 { 606 int error; 607 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 608 609 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 610 if (nn->nfsd_serv) { 611 svc_get(nn->nfsd_serv); 612 return 0; 613 } 614 if (nfsd_max_blksize == 0) 615 nfsd_max_blksize = nfsd_get_default_max_blksize(); 616 nfsd_reset_versions(nn); 617 nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize, 618 &nfsd_thread_sv_ops); 619 if (nn->nfsd_serv == NULL) 620 return -ENOMEM; 621 622 nn->nfsd_serv->sv_maxconn = nn->max_connections; 623 error = svc_bind(nn->nfsd_serv, net); 624 if (error < 0) { 625 svc_destroy(nn->nfsd_serv); 626 return error; 627 } 628 629 set_max_drc(); 630 /* check if the notifier is already set */ 631 if (atomic_inc_return(&nfsd_notifier_refcount) == 1) { 632 register_inetaddr_notifier(&nfsd_inetaddr_notifier); 633 #if IS_ENABLED(CONFIG_IPV6) 634 register_inet6addr_notifier(&nfsd_inet6addr_notifier); 635 #endif 636 } 637 atomic_inc(&nn->ntf_refcnt); 638 nfsd_reset_boot_verifier(nn); 639 return 0; 640 } 641 642 int nfsd_nrpools(struct net *net) 643 { 644 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 645 646 if (nn->nfsd_serv == NULL) 647 return 0; 648 else 649 return nn->nfsd_serv->sv_nrpools; 650 } 651 652 int nfsd_get_nrthreads(int n, int *nthreads, struct net *net) 653 { 654 int i = 0; 655 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 656 657 if (nn->nfsd_serv != NULL) { 658 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++) 659 nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads; 660 } 661 662 return 0; 663 } 664 665 void nfsd_destroy(struct net *net) 666 { 667 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 668 int destroy = (nn->nfsd_serv->sv_nrthreads == 1); 669 670 if (destroy) 671 svc_shutdown_net(nn->nfsd_serv, net); 672 svc_destroy(nn->nfsd_serv); 673 if (destroy) 674 nn->nfsd_serv = NULL; 675 } 676 677 int nfsd_set_nrthreads(int n, int *nthreads, struct net *net) 678 { 679 int i = 0; 680 int tot = 0; 681 int err = 0; 682 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 683 684 WARN_ON(!mutex_is_locked(&nfsd_mutex)); 685 686 if (nn->nfsd_serv == NULL || n <= 0) 687 return 0; 688 689 if (n > nn->nfsd_serv->sv_nrpools) 690 n = nn->nfsd_serv->sv_nrpools; 691 692 /* enforce a global maximum number of threads */ 693 tot = 0; 694 for (i = 0; i < n; i++) { 695 nthreads[i] = min(nthreads[i], NFSD_MAXSERVS); 696 tot += nthreads[i]; 697 } 698 if (tot > NFSD_MAXSERVS) { 699 /* total too large: scale down requested numbers */ 700 for (i = 0; i < n && tot > 0; i++) { 701 int new = nthreads[i] * NFSD_MAXSERVS / tot; 702 tot -= (nthreads[i] - new); 703 nthreads[i] = new; 704 } 705 for (i = 0; i < n && tot > 0; i++) { 706 nthreads[i]--; 707 tot--; 708 } 709 } 710 711 /* 712 * There must always be a thread in pool 0; the admin 713 * can't shut down NFS completely using pool_threads. 714 */ 715 if (nthreads[0] == 0) 716 nthreads[0] = 1; 717 718 /* apply the new numbers */ 719 svc_get(nn->nfsd_serv); 720 for (i = 0; i < n; i++) { 721 err = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv, 722 &nn->nfsd_serv->sv_pools[i], nthreads[i]); 723 if (err) 724 break; 725 } 726 nfsd_destroy(net); 727 return err; 728 } 729 730 /* 731 * Adjust the number of threads and return the new number of threads. 732 * This is also the function that starts the server if necessary, if 733 * this is the first time nrservs is nonzero. 734 */ 735 int 736 nfsd_svc(int nrservs, struct net *net, const struct cred *cred) 737 { 738 int error; 739 bool nfsd_up_before; 740 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 741 742 mutex_lock(&nfsd_mutex); 743 dprintk("nfsd: creating service\n"); 744 745 nrservs = max(nrservs, 0); 746 nrservs = min(nrservs, NFSD_MAXSERVS); 747 error = 0; 748 749 if (nrservs == 0 && nn->nfsd_serv == NULL) 750 goto out; 751 752 strlcpy(nn->nfsd_name, utsname()->nodename, 753 sizeof(nn->nfsd_name)); 754 755 error = nfsd_create_serv(net); 756 if (error) 757 goto out; 758 759 nfsd_up_before = nn->nfsd_net_up; 760 761 error = nfsd_startup_net(nrservs, net, cred); 762 if (error) 763 goto out_destroy; 764 error = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv, 765 NULL, nrservs); 766 if (error) 767 goto out_shutdown; 768 /* We are holding a reference to nn->nfsd_serv which 769 * we don't want to count in the return value, 770 * so subtract 1 771 */ 772 error = nn->nfsd_serv->sv_nrthreads - 1; 773 out_shutdown: 774 if (error < 0 && !nfsd_up_before) 775 nfsd_shutdown_net(net); 776 out_destroy: 777 nfsd_destroy(net); /* Release server */ 778 out: 779 mutex_unlock(&nfsd_mutex); 780 return error; 781 } 782 783 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) 784 static bool 785 nfsd_support_acl_version(int vers) 786 { 787 if (vers >= NFSD_ACL_MINVERS && vers < NFSD_ACL_NRVERS) 788 return nfsd_acl_version[vers] != NULL; 789 return false; 790 } 791 792 static int 793 nfsd_acl_rpcbind_set(struct net *net, const struct svc_program *progp, 794 u32 version, int family, unsigned short proto, 795 unsigned short port) 796 { 797 if (!nfsd_support_acl_version(version) || 798 !nfsd_vers(net_generic(net, nfsd_net_id), version, NFSD_TEST)) 799 return 0; 800 return svc_generic_rpcbind_set(net, progp, version, family, 801 proto, port); 802 } 803 804 static __be32 805 nfsd_acl_init_request(struct svc_rqst *rqstp, 806 const struct svc_program *progp, 807 struct svc_process_info *ret) 808 { 809 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 810 int i; 811 812 if (likely(nfsd_support_acl_version(rqstp->rq_vers) && 813 nfsd_vers(nn, rqstp->rq_vers, NFSD_TEST))) 814 return svc_generic_init_request(rqstp, progp, ret); 815 816 ret->mismatch.lovers = NFSD_ACL_NRVERS; 817 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++) { 818 if (nfsd_support_acl_version(rqstp->rq_vers) && 819 nfsd_vers(nn, i, NFSD_TEST)) { 820 ret->mismatch.lovers = i; 821 break; 822 } 823 } 824 if (ret->mismatch.lovers == NFSD_ACL_NRVERS) 825 return rpc_prog_unavail; 826 ret->mismatch.hivers = NFSD_ACL_MINVERS; 827 for (i = NFSD_ACL_NRVERS - 1; i >= NFSD_ACL_MINVERS; i--) { 828 if (nfsd_support_acl_version(rqstp->rq_vers) && 829 nfsd_vers(nn, i, NFSD_TEST)) { 830 ret->mismatch.hivers = i; 831 break; 832 } 833 } 834 return rpc_prog_mismatch; 835 } 836 #endif 837 838 static int 839 nfsd_rpcbind_set(struct net *net, const struct svc_program *progp, 840 u32 version, int family, unsigned short proto, 841 unsigned short port) 842 { 843 if (!nfsd_vers(net_generic(net, nfsd_net_id), version, NFSD_TEST)) 844 return 0; 845 return svc_generic_rpcbind_set(net, progp, version, family, 846 proto, port); 847 } 848 849 static __be32 850 nfsd_init_request(struct svc_rqst *rqstp, 851 const struct svc_program *progp, 852 struct svc_process_info *ret) 853 { 854 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id); 855 int i; 856 857 if (likely(nfsd_vers(nn, rqstp->rq_vers, NFSD_TEST))) 858 return svc_generic_init_request(rqstp, progp, ret); 859 860 ret->mismatch.lovers = NFSD_NRVERS; 861 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) { 862 if (nfsd_vers(nn, i, NFSD_TEST)) { 863 ret->mismatch.lovers = i; 864 break; 865 } 866 } 867 if (ret->mismatch.lovers == NFSD_NRVERS) 868 return rpc_prog_unavail; 869 ret->mismatch.hivers = NFSD_MINVERS; 870 for (i = NFSD_NRVERS - 1; i >= NFSD_MINVERS; i--) { 871 if (nfsd_vers(nn, i, NFSD_TEST)) { 872 ret->mismatch.hivers = i; 873 break; 874 } 875 } 876 return rpc_prog_mismatch; 877 } 878 879 /* 880 * This is the NFS server kernel thread 881 */ 882 static int 883 nfsd(void *vrqstp) 884 { 885 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp; 886 struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list); 887 struct net *net = perm_sock->xpt_net; 888 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 889 int err; 890 891 /* Lock module and set up kernel thread */ 892 mutex_lock(&nfsd_mutex); 893 894 /* At this point, the thread shares current->fs 895 * with the init process. We need to create files with the 896 * umask as defined by the client instead of init's umask. */ 897 if (unshare_fs_struct() < 0) { 898 printk("Unable to start nfsd thread: out of memory\n"); 899 goto out; 900 } 901 902 current->fs->umask = 0; 903 904 /* 905 * thread is spawned with all signals set to SIG_IGN, re-enable 906 * the ones that will bring down the thread 907 */ 908 allow_signal(SIGKILL); 909 allow_signal(SIGHUP); 910 allow_signal(SIGINT); 911 allow_signal(SIGQUIT); 912 913 nfsdstats.th_cnt++; 914 mutex_unlock(&nfsd_mutex); 915 916 set_freezable(); 917 918 /* 919 * The main request loop 920 */ 921 for (;;) { 922 /* Update sv_maxconn if it has changed */ 923 rqstp->rq_server->sv_maxconn = nn->max_connections; 924 925 /* 926 * Find a socket with data available and call its 927 * recvfrom routine. 928 */ 929 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN) 930 ; 931 if (err == -EINTR) 932 break; 933 validate_process_creds(); 934 svc_process(rqstp); 935 validate_process_creds(); 936 } 937 938 /* Clear signals before calling svc_exit_thread() */ 939 flush_signals(current); 940 941 mutex_lock(&nfsd_mutex); 942 nfsdstats.th_cnt --; 943 944 out: 945 rqstp->rq_server = NULL; 946 947 /* Release the thread */ 948 svc_exit_thread(rqstp); 949 950 nfsd_destroy(net); 951 952 /* Release module */ 953 mutex_unlock(&nfsd_mutex); 954 module_put_and_exit(0); 955 return 0; 956 } 957 958 static __be32 map_new_errors(u32 vers, __be32 nfserr) 959 { 960 if (nfserr == nfserr_jukebox && vers == 2) 961 return nfserr_dropit; 962 if (nfserr == nfserr_wrongsec && vers < 4) 963 return nfserr_acces; 964 return nfserr; 965 } 966 967 /* 968 * A write procedure can have a large argument, and a read procedure can 969 * have a large reply, but no NFSv2 or NFSv3 procedure has argument and 970 * reply that can both be larger than a page. The xdr code has taken 971 * advantage of this assumption to be a sloppy about bounds checking in 972 * some cases. Pending a rewrite of the NFSv2/v3 xdr code to fix that 973 * problem, we enforce these assumptions here: 974 */ 975 static bool nfs_request_too_big(struct svc_rqst *rqstp, 976 const struct svc_procedure *proc) 977 { 978 /* 979 * The ACL code has more careful bounds-checking and is not 980 * susceptible to this problem: 981 */ 982 if (rqstp->rq_prog != NFS_PROGRAM) 983 return false; 984 /* 985 * Ditto NFSv4 (which can in theory have argument and reply both 986 * more than a page): 987 */ 988 if (rqstp->rq_vers >= 4) 989 return false; 990 /* The reply will be small, we're OK: */ 991 if (proc->pc_xdrressize > 0 && 992 proc->pc_xdrressize < XDR_QUADLEN(PAGE_SIZE)) 993 return false; 994 995 return rqstp->rq_arg.len > PAGE_SIZE; 996 } 997 998 int 999 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp) 1000 { 1001 const struct svc_procedure *proc; 1002 __be32 nfserr; 1003 __be32 *nfserrp; 1004 1005 dprintk("nfsd_dispatch: vers %d proc %d\n", 1006 rqstp->rq_vers, rqstp->rq_proc); 1007 proc = rqstp->rq_procinfo; 1008 1009 if (nfs_request_too_big(rqstp, proc)) { 1010 dprintk("nfsd: NFSv%d argument too large\n", rqstp->rq_vers); 1011 *statp = rpc_garbage_args; 1012 return 1; 1013 } 1014 /* 1015 * Give the xdr decoder a chance to change this if it wants 1016 * (necessary in the NFSv4.0 compound case) 1017 */ 1018 rqstp->rq_cachetype = proc->pc_cachetype; 1019 /* Decode arguments */ 1020 if (proc->pc_decode && 1021 !proc->pc_decode(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base)) { 1022 dprintk("nfsd: failed to decode arguments!\n"); 1023 *statp = rpc_garbage_args; 1024 return 1; 1025 } 1026 1027 /* Check whether we have this call in the cache. */ 1028 switch (nfsd_cache_lookup(rqstp)) { 1029 case RC_DROPIT: 1030 return 0; 1031 case RC_REPLY: 1032 return 1; 1033 case RC_DOIT:; 1034 /* do it */ 1035 } 1036 1037 /* need to grab the location to store the status, as 1038 * nfsv4 does some encoding while processing 1039 */ 1040 nfserrp = rqstp->rq_res.head[0].iov_base 1041 + rqstp->rq_res.head[0].iov_len; 1042 rqstp->rq_res.head[0].iov_len += sizeof(__be32); 1043 1044 /* Now call the procedure handler, and encode NFS status. */ 1045 nfserr = proc->pc_func(rqstp); 1046 nfserr = map_new_errors(rqstp->rq_vers, nfserr); 1047 if (nfserr == nfserr_dropit || test_bit(RQ_DROPME, &rqstp->rq_flags)) { 1048 dprintk("nfsd: Dropping request; may be revisited later\n"); 1049 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 1050 return 0; 1051 } 1052 1053 if (rqstp->rq_proc != 0) 1054 *nfserrp++ = nfserr; 1055 1056 /* Encode result. 1057 * For NFSv2, additional info is never returned in case of an error. 1058 */ 1059 if (!(nfserr && rqstp->rq_vers == 2)) { 1060 if (proc->pc_encode && !proc->pc_encode(rqstp, nfserrp)) { 1061 /* Failed to encode result. Release cache entry */ 1062 dprintk("nfsd: failed to encode result!\n"); 1063 nfsd_cache_update(rqstp, RC_NOCACHE, NULL); 1064 *statp = rpc_system_err; 1065 return 1; 1066 } 1067 } 1068 1069 /* Store reply in cache. */ 1070 nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1); 1071 return 1; 1072 } 1073 1074 int nfsd_pool_stats_open(struct inode *inode, struct file *file) 1075 { 1076 int ret; 1077 struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id); 1078 1079 mutex_lock(&nfsd_mutex); 1080 if (nn->nfsd_serv == NULL) { 1081 mutex_unlock(&nfsd_mutex); 1082 return -ENODEV; 1083 } 1084 /* bump up the psudo refcount while traversing */ 1085 svc_get(nn->nfsd_serv); 1086 ret = svc_pool_stats_open(nn->nfsd_serv, file); 1087 mutex_unlock(&nfsd_mutex); 1088 return ret; 1089 } 1090 1091 int nfsd_pool_stats_release(struct inode *inode, struct file *file) 1092 { 1093 int ret = seq_release(inode, file); 1094 struct net *net = inode->i_sb->s_fs_info; 1095 1096 mutex_lock(&nfsd_mutex); 1097 /* this function really, really should have been called svc_put() */ 1098 nfsd_destroy(net); 1099 mutex_unlock(&nfsd_mutex); 1100 return ret; 1101 } 1102