nfssvc.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566
  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. #include <linux/module.h>
  11. #include <linux/time.h>
  12. #include <linux/errno.h>
  13. #include <linux/nfs.h>
  14. #include <linux/in.h>
  15. #include <linux/uio.h>
  16. #include <linux/unistd.h>
  17. #include <linux/slab.h>
  18. #include <linux/smp.h>
  19. #include <linux/smp_lock.h>
  20. #include <linux/fs_struct.h>
  21. #include <linux/sunrpc/types.h>
  22. #include <linux/sunrpc/stats.h>
  23. #include <linux/sunrpc/svc.h>
  24. #include <linux/sunrpc/svcsock.h>
  25. #include <linux/sunrpc/cache.h>
  26. #include <linux/nfsd/nfsd.h>
  27. #include <linux/nfsd/stats.h>
  28. #include <linux/nfsd/cache.h>
  29. #include <linux/nfsd/syscall.h>
  30. #include <linux/lockd/bind.h>
  31. #include <linux/nfsacl.h>
  32. #define NFSDDBG_FACILITY NFSDDBG_SVC
  33. /* these signals will be delivered to an nfsd thread
  34. * when handling a request
  35. */
  36. #define ALLOWED_SIGS (sigmask(SIGKILL))
  37. /* these signals will be delivered to an nfsd thread
  38. * when not handling a request. i.e. when waiting
  39. */
  40. #define SHUTDOWN_SIGS (sigmask(SIGKILL) | sigmask(SIGHUP) | sigmask(SIGINT) | sigmask(SIGQUIT))
  41. /* if the last thread dies with SIGHUP, then the exports table is
  42. * left unchanged ( like 2.4-{0-9} ). Any other signal will clear
  43. * the exports table (like 2.2).
  44. */
  45. #define SIG_NOCLEAN SIGHUP
  46. extern struct svc_program nfsd_program;
  47. static void nfsd(struct svc_rqst *rqstp);
  48. struct timeval nfssvc_boot;
  49. struct svc_serv *nfsd_serv;
  50. static atomic_t nfsd_busy;
  51. static unsigned long nfsd_last_call;
  52. static DEFINE_SPINLOCK(nfsd_call_lock);
  53. #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
  54. static struct svc_stat nfsd_acl_svcstats;
  55. static struct svc_version * nfsd_acl_version[] = {
  56. [2] = &nfsd_acl_version2,
  57. [3] = &nfsd_acl_version3,
  58. };
  59. #define NFSD_ACL_MINVERS 2
  60. #define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)
  61. static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
  62. static struct svc_program nfsd_acl_program = {
  63. .pg_prog = NFS_ACL_PROGRAM,
  64. .pg_nvers = NFSD_ACL_NRVERS,
  65. .pg_vers = nfsd_acl_versions,
  66. .pg_name = "nfsacl",
  67. .pg_class = "nfsd",
  68. .pg_stats = &nfsd_acl_svcstats,
  69. .pg_authenticate = &svc_set_client,
  70. };
  71. static struct svc_stat nfsd_acl_svcstats = {
  72. .program = &nfsd_acl_program,
  73. };
  74. #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
  75. static struct svc_version * nfsd_version[] = {
  76. [2] = &nfsd_version2,
  77. #if defined(CONFIG_NFSD_V3)
  78. [3] = &nfsd_version3,
  79. #endif
  80. #if defined(CONFIG_NFSD_V4)
  81. [4] = &nfsd_version4,
  82. #endif
  83. };
  84. #define NFSD_MINVERS 2
  85. #define NFSD_NRVERS ARRAY_SIZE(nfsd_version)
  86. static struct svc_version *nfsd_versions[NFSD_NRVERS];
  87. struct svc_program nfsd_program = {
  88. #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
  89. .pg_next = &nfsd_acl_program,
  90. #endif
  91. .pg_prog = NFS_PROGRAM, /* program number */
  92. .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
  93. .pg_vers = nfsd_versions, /* version table */
  94. .pg_name = "nfsd", /* program name */
  95. .pg_class = "nfsd", /* authentication class */
  96. .pg_stats = &nfsd_svcstats, /* version table */
  97. .pg_authenticate = &svc_set_client, /* export authentication */
  98. };
  99. int nfsd_vers(int vers, enum vers_op change)
  100. {
  101. if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
  102. return -1;
  103. switch(change) {
  104. case NFSD_SET:
  105. nfsd_versions[vers] = nfsd_version[vers];
  106. #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
  107. if (vers < NFSD_ACL_NRVERS)
  108. nfsd_acl_versions[vers] = nfsd_acl_version[vers];
  109. #endif
  110. break;
  111. case NFSD_CLEAR:
  112. nfsd_versions[vers] = NULL;
  113. #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
  114. if (vers < NFSD_ACL_NRVERS)
  115. nfsd_acl_versions[vers] = NULL;
  116. #endif
  117. break;
  118. case NFSD_TEST:
  119. return nfsd_versions[vers] != NULL;
  120. case NFSD_AVAIL:
  121. return nfsd_version[vers] != NULL;
  122. }
  123. return 0;
  124. }
  125. /*
  126. * Maximum number of nfsd processes
  127. */
  128. #define NFSD_MAXSERVS 8192
  129. int nfsd_nrthreads(void)
  130. {
  131. if (nfsd_serv == NULL)
  132. return 0;
  133. else
  134. return nfsd_serv->sv_nrthreads;
  135. }
  136. static int killsig; /* signal that was used to kill last nfsd */
  137. static void nfsd_last_thread(struct svc_serv *serv)
  138. {
  139. /* When last nfsd thread exits we need to do some clean-up */
  140. struct svc_sock *svsk;
  141. list_for_each_entry(svsk, &serv->sv_permsocks, sk_list)
  142. lockd_down();
  143. nfsd_serv = NULL;
  144. nfsd_racache_shutdown();
  145. nfs4_state_shutdown();
  146. printk(KERN_WARNING "nfsd: last server has exited\n");
  147. if (killsig != SIG_NOCLEAN) {
  148. printk(KERN_WARNING "nfsd: unexporting all filesystems\n");
  149. nfsd_export_flush();
  150. }
  151. }
  152. void nfsd_reset_versions(void)
  153. {
  154. int found_one = 0;
  155. int i;
  156. for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
  157. if (nfsd_program.pg_vers[i])
  158. found_one = 1;
  159. }
  160. if (!found_one) {
  161. for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
  162. nfsd_program.pg_vers[i] = nfsd_version[i];
  163. #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
  164. for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
  165. nfsd_acl_program.pg_vers[i] =
  166. nfsd_acl_version[i];
  167. #endif
  168. }
  169. }
  170. int nfsd_create_serv(void)
  171. {
  172. int err = 0;
  173. lock_kernel();
  174. if (nfsd_serv) {
  175. svc_get(nfsd_serv);
  176. unlock_kernel();
  177. return 0;
  178. }
  179. if (nfsd_max_blksize == 0) {
  180. /* choose a suitable default */
  181. struct sysinfo i;
  182. si_meminfo(&i);
  183. /* Aim for 1/4096 of memory per thread
  184. * This gives 1MB on 4Gig machines
  185. * But only uses 32K on 128M machines.
  186. * Bottom out at 8K on 32M and smaller.
  187. * Of course, this is only a default.
  188. */
  189. nfsd_max_blksize = NFSSVC_MAXBLKSIZE;
  190. i.totalram <<= PAGE_SHIFT - 12;
  191. while (nfsd_max_blksize > i.totalram &&
  192. nfsd_max_blksize >= 8*1024*2)
  193. nfsd_max_blksize /= 2;
  194. }
  195. atomic_set(&nfsd_busy, 0);
  196. nfsd_serv = svc_create_pooled(&nfsd_program,
  197. nfsd_max_blksize,
  198. nfsd_last_thread,
  199. nfsd, SIG_NOCLEAN, THIS_MODULE);
  200. if (nfsd_serv == NULL)
  201. err = -ENOMEM;
  202. unlock_kernel();
  203. do_gettimeofday(&nfssvc_boot); /* record boot time */
  204. return err;
  205. }
  206. static int nfsd_init_socks(int port)
  207. {
  208. int error;
  209. if (!list_empty(&nfsd_serv->sv_permsocks))
  210. return 0;
  211. error = lockd_up(IPPROTO_UDP);
  212. if (error >= 0) {
  213. error = svc_makesock(nfsd_serv, IPPROTO_UDP, port,
  214. SVC_SOCK_DEFAULTS);
  215. if (error < 0)
  216. lockd_down();
  217. }
  218. if (error < 0)
  219. return error;
  220. #ifdef CONFIG_NFSD_TCP
  221. error = lockd_up(IPPROTO_TCP);
  222. if (error >= 0) {
  223. error = svc_makesock(nfsd_serv, IPPROTO_TCP, port,
  224. SVC_SOCK_DEFAULTS);
  225. if (error < 0)
  226. lockd_down();
  227. }
  228. if (error < 0)
  229. return error;
  230. #endif
  231. return 0;
  232. }
  233. int nfsd_nrpools(void)
  234. {
  235. if (nfsd_serv == NULL)
  236. return 0;
  237. else
  238. return nfsd_serv->sv_nrpools;
  239. }
  240. int nfsd_get_nrthreads(int n, int *nthreads)
  241. {
  242. int i = 0;
  243. if (nfsd_serv != NULL) {
  244. for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
  245. nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
  246. }
  247. return 0;
  248. }
  249. int nfsd_set_nrthreads(int n, int *nthreads)
  250. {
  251. int i = 0;
  252. int tot = 0;
  253. int err = 0;
  254. if (nfsd_serv == NULL || n <= 0)
  255. return 0;
  256. if (n > nfsd_serv->sv_nrpools)
  257. n = nfsd_serv->sv_nrpools;
  258. /* enforce a global maximum number of threads */
  259. tot = 0;
  260. for (i = 0; i < n; i++) {
  261. if (nthreads[i] > NFSD_MAXSERVS)
  262. nthreads[i] = NFSD_MAXSERVS;
  263. tot += nthreads[i];
  264. }
  265. if (tot > NFSD_MAXSERVS) {
  266. /* total too large: scale down requested numbers */
  267. for (i = 0; i < n && tot > 0; i++) {
  268. int new = nthreads[i] * NFSD_MAXSERVS / tot;
  269. tot -= (nthreads[i] - new);
  270. nthreads[i] = new;
  271. }
  272. for (i = 0; i < n && tot > 0; i++) {
  273. nthreads[i]--;
  274. tot--;
  275. }
  276. }
  277. /*
  278. * There must always be a thread in pool 0; the admin
  279. * can't shut down NFS completely using pool_threads.
  280. */
  281. if (nthreads[0] == 0)
  282. nthreads[0] = 1;
  283. /* apply the new numbers */
  284. lock_kernel();
  285. svc_get(nfsd_serv);
  286. for (i = 0; i < n; i++) {
  287. err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
  288. nthreads[i]);
  289. if (err)
  290. break;
  291. }
  292. svc_destroy(nfsd_serv);
  293. unlock_kernel();
  294. return err;
  295. }
  296. int
  297. nfsd_svc(unsigned short port, int nrservs)
  298. {
  299. int error;
  300. lock_kernel();
  301. dprintk("nfsd: creating service\n");
  302. error = -EINVAL;
  303. if (nrservs <= 0)
  304. nrservs = 0;
  305. if (nrservs > NFSD_MAXSERVS)
  306. nrservs = NFSD_MAXSERVS;
  307. /* Readahead param cache - will no-op if it already exists */
  308. error = nfsd_racache_init(2*nrservs);
  309. if (error<0)
  310. goto out;
  311. error = nfs4_state_start();
  312. if (error<0)
  313. goto out;
  314. nfsd_reset_versions();
  315. error = nfsd_create_serv();
  316. if (error)
  317. goto out;
  318. error = nfsd_init_socks(port);
  319. if (error)
  320. goto failure;
  321. error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
  322. failure:
  323. svc_destroy(nfsd_serv); /* Release server */
  324. out:
  325. unlock_kernel();
  326. return error;
  327. }
  328. static inline void
  329. update_thread_usage(int busy_threads)
  330. {
  331. unsigned long prev_call;
  332. unsigned long diff;
  333. int decile;
  334. spin_lock(&nfsd_call_lock);
  335. prev_call = nfsd_last_call;
  336. nfsd_last_call = jiffies;
  337. decile = busy_threads*10/nfsdstats.th_cnt;
  338. if (decile>0 && decile <= 10) {
  339. diff = nfsd_last_call - prev_call;
  340. if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP)
  341. nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP;
  342. if (decile == 10)
  343. nfsdstats.th_fullcnt++;
  344. }
  345. spin_unlock(&nfsd_call_lock);
  346. }
  347. /*
  348. * This is the NFS server kernel thread
  349. */
  350. static void
  351. nfsd(struct svc_rqst *rqstp)
  352. {
  353. struct fs_struct *fsp;
  354. int err;
  355. sigset_t shutdown_mask, allowed_mask;
  356. /* Lock module and set up kernel thread */
  357. lock_kernel();
  358. daemonize("nfsd");
  359. /* After daemonize() this kernel thread shares current->fs
  360. * with the init process. We need to create files with a
  361. * umask of 0 instead of init's umask. */
  362. fsp = copy_fs_struct(current->fs);
  363. if (!fsp) {
  364. printk("Unable to start nfsd thread: out of memory\n");
  365. goto out;
  366. }
  367. exit_fs(current);
  368. current->fs = fsp;
  369. current->fs->umask = 0;
  370. siginitsetinv(&shutdown_mask, SHUTDOWN_SIGS);
  371. siginitsetinv(&allowed_mask, ALLOWED_SIGS);
  372. nfsdstats.th_cnt++;
  373. rqstp->rq_task = current;
  374. unlock_kernel();
  375. /*
  376. * We want less throttling in balance_dirty_pages() so that nfs to
  377. * localhost doesn't cause nfsd to lock up due to all the client's
  378. * dirty pages.
  379. */
  380. current->flags |= PF_LESS_THROTTLE;
  381. /*
  382. * The main request loop
  383. */
  384. for (;;) {
  385. /* Block all but the shutdown signals */
  386. sigprocmask(SIG_SETMASK, &shutdown_mask, NULL);
  387. /*
  388. * Find a socket with data available and call its
  389. * recvfrom routine.
  390. */
  391. while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
  392. ;
  393. if (err < 0)
  394. break;
  395. update_thread_usage(atomic_read(&nfsd_busy));
  396. atomic_inc(&nfsd_busy);
  397. /* Lock the export hash tables for reading. */
  398. exp_readlock();
  399. /* Process request with signals blocked. */
  400. sigprocmask(SIG_SETMASK, &allowed_mask, NULL);
  401. svc_process(rqstp);
  402. /* Unlock export hash tables */
  403. exp_readunlock();
  404. update_thread_usage(atomic_read(&nfsd_busy));
  405. atomic_dec(&nfsd_busy);
  406. }
  407. if (err != -EINTR) {
  408. printk(KERN_WARNING "nfsd: terminating on error %d\n", -err);
  409. } else {
  410. unsigned int signo;
  411. for (signo = 1; signo <= _NSIG; signo++)
  412. if (sigismember(&current->pending.signal, signo) &&
  413. !sigismember(&current->blocked, signo))
  414. break;
  415. killsig = signo;
  416. }
  417. /* Clear signals before calling svc_exit_thread() */
  418. flush_signals(current);
  419. lock_kernel();
  420. nfsdstats.th_cnt --;
  421. out:
  422. /* Release the thread */
  423. svc_exit_thread(rqstp);
  424. /* Release module */
  425. unlock_kernel();
  426. module_put_and_exit(0);
  427. }
  428. int
  429. nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
  430. {
  431. struct svc_procedure *proc;
  432. kxdrproc_t xdr;
  433. __be32 nfserr;
  434. __be32 *nfserrp;
  435. dprintk("nfsd_dispatch: vers %d proc %d\n",
  436. rqstp->rq_vers, rqstp->rq_proc);
  437. proc = rqstp->rq_procinfo;
  438. /* Check whether we have this call in the cache. */
  439. switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) {
  440. case RC_INTR:
  441. case RC_DROPIT:
  442. return 0;
  443. case RC_REPLY:
  444. return 1;
  445. case RC_DOIT:;
  446. /* do it */
  447. }
  448. /* Decode arguments */
  449. xdr = proc->pc_decode;
  450. if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
  451. rqstp->rq_argp)) {
  452. dprintk("nfsd: failed to decode arguments!\n");
  453. nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
  454. *statp = rpc_garbage_args;
  455. return 1;
  456. }
  457. /* need to grab the location to store the status, as
  458. * nfsv4 does some encoding while processing
  459. */
  460. nfserrp = rqstp->rq_res.head[0].iov_base
  461. + rqstp->rq_res.head[0].iov_len;
  462. rqstp->rq_res.head[0].iov_len += sizeof(__be32);
  463. /* Now call the procedure handler, and encode NFS status. */
  464. nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
  465. if (nfserr == nfserr_jukebox && rqstp->rq_vers == 2)
  466. nfserr = nfserr_dropit;
  467. if (nfserr == nfserr_dropit) {
  468. dprintk("nfsd: Dropping request due to malloc failure!\n");
  469. nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
  470. return 0;
  471. }
  472. if (rqstp->rq_proc != 0)
  473. *nfserrp++ = nfserr;
  474. /* Encode result.
  475. * For NFSv2, additional info is never returned in case of an error.
  476. */
  477. if (!(nfserr && rqstp->rq_vers == 2)) {
  478. xdr = proc->pc_encode;
  479. if (xdr && !xdr(rqstp, nfserrp,
  480. rqstp->rq_resp)) {
  481. /* Failed to encode result. Release cache entry */
  482. dprintk("nfsd: failed to encode result!\n");
  483. nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
  484. *statp = rpc_system_err;
  485. return 1;
  486. }
  487. }
  488. /* Store reply in cache. */
  489. nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
  490. return 1;
  491. }