1
2
3
4
5
6
7
8
9#include <linux/sched.h>
10#include <linux/freezer.h>
11#include <linux/module.h>
12#include <linux/fs_struct.h>
13#include <linux/swap.h>
14
15#include <linux/sunrpc/stats.h>
16#include <linux/sunrpc/svcsock.h>
17#include <linux/lockd/bind.h>
18#include <linux/nfsacl.h>
19#include <linux/seq_file.h>
20#include <net/net_namespace.h>
21#include "nfsd.h"
22#include "cache.h"
23#include "vfs.h"
24#include "netns.h"
25
26#define NFSDDBG_FACILITY NFSDDBG_SVC
27
28extern struct svc_program nfsd_program;
29static int nfsd(void *vrqstp);
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53DEFINE_MUTEX(nfsd_mutex);
54
55
56
57
58
59
60
61spinlock_t nfsd_drc_lock;
62unsigned long nfsd_drc_max_mem;
63unsigned long nfsd_drc_mem_used;
64
65#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
66static struct svc_stat nfsd_acl_svcstats;
67static struct svc_version * nfsd_acl_version[] = {
68 [2] = &nfsd_acl_version2,
69 [3] = &nfsd_acl_version3,
70};
71
72#define NFSD_ACL_MINVERS 2
73#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)
74static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
75
76static struct svc_program nfsd_acl_program = {
77 .pg_prog = NFS_ACL_PROGRAM,
78 .pg_nvers = NFSD_ACL_NRVERS,
79 .pg_vers = nfsd_acl_versions,
80 .pg_name = "nfsacl",
81 .pg_class = "nfsd",
82 .pg_stats = &nfsd_acl_svcstats,
83 .pg_authenticate = &svc_set_client,
84};
85
86static struct svc_stat nfsd_acl_svcstats = {
87 .program = &nfsd_acl_program,
88};
89#endif
90
91static struct svc_version * nfsd_version[] = {
92 [2] = &nfsd_version2,
93#if defined(CONFIG_NFSD_V3)
94 [3] = &nfsd_version3,
95#endif
96#if defined(CONFIG_NFSD_V4)
97 [4] = &nfsd_version4,
98#endif
99};
100
101#define NFSD_MINVERS 2
102#define NFSD_NRVERS ARRAY_SIZE(nfsd_version)
103static struct svc_version *nfsd_versions[NFSD_NRVERS];
104
105struct svc_program nfsd_program = {
106#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
107 .pg_next = &nfsd_acl_program,
108#endif
109 .pg_prog = NFS_PROGRAM,
110 .pg_nvers = NFSD_NRVERS,
111 .pg_vers = nfsd_versions,
112 .pg_name = "nfsd",
113 .pg_class = "nfsd",
114 .pg_stats = &nfsd_svcstats,
115 .pg_authenticate = &svc_set_client,
116
117};
118
119static bool nfsd_supported_minorversions[NFSD_SUPPORTED_MINOR_VERSION + 1] = {
120 [0] = 1,
121 [1] = 1,
122};
123
124int nfsd_vers(int vers, enum vers_op change)
125{
126 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
127 return 0;
128 switch(change) {
129 case NFSD_SET:
130 nfsd_versions[vers] = nfsd_version[vers];
131#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
132 if (vers < NFSD_ACL_NRVERS)
133 nfsd_acl_versions[vers] = nfsd_acl_version[vers];
134#endif
135 break;
136 case NFSD_CLEAR:
137 nfsd_versions[vers] = NULL;
138#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
139 if (vers < NFSD_ACL_NRVERS)
140 nfsd_acl_versions[vers] = NULL;
141#endif
142 break;
143 case NFSD_TEST:
144 return nfsd_versions[vers] != NULL;
145 case NFSD_AVAIL:
146 return nfsd_version[vers] != NULL;
147 }
148 return 0;
149}
150
151int nfsd_minorversion(u32 minorversion, enum vers_op change)
152{
153 if (minorversion > NFSD_SUPPORTED_MINOR_VERSION)
154 return -1;
155 switch(change) {
156 case NFSD_SET:
157 nfsd_supported_minorversions[minorversion] = true;
158 break;
159 case NFSD_CLEAR:
160 nfsd_supported_minorversions[minorversion] = false;
161 break;
162 case NFSD_TEST:
163 return nfsd_supported_minorversions[minorversion];
164 case NFSD_AVAIL:
165 return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
166 }
167 return 0;
168}
169
170
171
172
173#define NFSD_MAXSERVS 8192
174
175int nfsd_nrthreads(struct net *net)
176{
177 int rv = 0;
178 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
179
180 mutex_lock(&nfsd_mutex);
181 if (nn->nfsd_serv)
182 rv = nn->nfsd_serv->sv_nrthreads;
183 mutex_unlock(&nfsd_mutex);
184 return rv;
185}
186
187static int nfsd_init_socks(struct net *net)
188{
189 int error;
190 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
191
192 if (!list_empty(&nn->nfsd_serv->sv_permsocks))
193 return 0;
194
195 error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT,
196 SVC_SOCK_DEFAULTS);
197 if (error < 0)
198 return error;
199
200 error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
201 SVC_SOCK_DEFAULTS);
202 if (error < 0)
203 return error;
204
205 return 0;
206}
207
208static int nfsd_users = 0;
209
210static int nfsd_startup_generic(int nrservs)
211{
212 int ret;
213
214 if (nfsd_users++)
215 return 0;
216
217
218
219
220
221
222 ret = nfsd_racache_init(2*nrservs);
223 if (ret)
224 return ret;
225 ret = nfs4_state_start();
226 if (ret)
227 goto out_racache;
228 return 0;
229
230out_racache:
231 nfsd_racache_shutdown();
232 return ret;
233}
234
235static void nfsd_shutdown_generic(void)
236{
237 if (--nfsd_users)
238 return;
239
240 nfs4_state_shutdown();
241 nfsd_racache_shutdown();
242}
243
244static int nfsd_startup_net(int nrservs, struct net *net)
245{
246 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
247 int ret;
248
249 if (nn->nfsd_net_up)
250 return 0;
251
252 ret = nfsd_startup_generic(nrservs);
253 if (ret)
254 return ret;
255 ret = nfsd_init_socks(net);
256 if (ret)
257 goto out_socks;
258 ret = lockd_up(net);
259 if (ret)
260 goto out_socks;
261 ret = nfs4_state_start_net(net);
262 if (ret)
263 goto out_lockd;
264
265 nn->nfsd_net_up = true;
266 return 0;
267
268out_lockd:
269 lockd_down(net);
270out_socks:
271 nfsd_shutdown_generic();
272 return ret;
273}
274
275static void nfsd_shutdown_net(struct net *net)
276{
277 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
278
279 nfs4_state_shutdown_net(net);
280 lockd_down(net);
281 nn->nfsd_net_up = false;
282 nfsd_shutdown_generic();
283}
284
285static void nfsd_last_thread(struct svc_serv *serv, struct net *net)
286{
287 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
288
289
290
291
292
293
294
295 if (!nn->nfsd_net_up)
296 return;
297 nfsd_shutdown_net(net);
298
299 svc_rpcb_cleanup(serv, net);
300
301 printk(KERN_WARNING "nfsd: last server has exited, flushing export "
302 "cache\n");
303 nfsd_export_flush(net);
304}
305
306void nfsd_reset_versions(void)
307{
308 int found_one = 0;
309 int i;
310
311 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
312 if (nfsd_program.pg_vers[i])
313 found_one = 1;
314 }
315
316 if (!found_one) {
317 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
318 nfsd_program.pg_vers[i] = nfsd_version[i];
319#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
320 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
321 nfsd_acl_program.pg_vers[i] =
322 nfsd_acl_version[i];
323#endif
324 }
325}
326
327
328
329
330
331
332
333
334
335
336
337
338
339static void set_max_drc(void)
340{
341 #define NFSD_DRC_SIZE_SHIFT 10
342 nfsd_drc_max_mem = (nr_free_buffer_pages()
343 >> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE;
344 nfsd_drc_mem_used = 0;
345 spin_lock_init(&nfsd_drc_lock);
346 dprintk("%s nfsd_drc_max_mem %lu \n", __func__, nfsd_drc_max_mem);
347}
348
349static int nfsd_get_default_max_blksize(void)
350{
351 struct sysinfo i;
352 unsigned long long target;
353 unsigned long ret;
354
355 si_meminfo(&i);
356 target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
357
358
359
360
361
362 target >>= 12;
363
364 ret = NFSSVC_MAXBLKSIZE;
365 while (ret > target && ret >= 8*1024*2)
366 ret /= 2;
367 return ret;
368}
369
370int nfsd_create_serv(struct net *net)
371{
372 int error;
373 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
374
375 WARN_ON(!mutex_is_locked(&nfsd_mutex));
376 if (nn->nfsd_serv) {
377 svc_get(nn->nfsd_serv);
378 return 0;
379 }
380 if (nfsd_max_blksize == 0)
381 nfsd_max_blksize = nfsd_get_default_max_blksize();
382 nfsd_reset_versions();
383 nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
384 nfsd_last_thread, nfsd, THIS_MODULE);
385 if (nn->nfsd_serv == NULL)
386 return -ENOMEM;
387
388 error = svc_bind(nn->nfsd_serv, net);
389 if (error < 0) {
390 svc_destroy(nn->nfsd_serv);
391 return error;
392 }
393
394 set_max_drc();
395 do_gettimeofday(&nn->nfssvc_boot);
396 return 0;
397}
398
399int nfsd_nrpools(struct net *net)
400{
401 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
402
403 if (nn->nfsd_serv == NULL)
404 return 0;
405 else
406 return nn->nfsd_serv->sv_nrpools;
407}
408
409int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
410{
411 int i = 0;
412 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
413
414 if (nn->nfsd_serv != NULL) {
415 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++)
416 nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads;
417 }
418
419 return 0;
420}
421
422void nfsd_destroy(struct net *net)
423{
424 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
425 int destroy = (nn->nfsd_serv->sv_nrthreads == 1);
426
427 if (destroy)
428 svc_shutdown_net(nn->nfsd_serv, net);
429 svc_destroy(nn->nfsd_serv);
430 if (destroy)
431 nn->nfsd_serv = NULL;
432}
433
434int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
435{
436 int i = 0;
437 int tot = 0;
438 int err = 0;
439 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
440
441 WARN_ON(!mutex_is_locked(&nfsd_mutex));
442
443 if (nn->nfsd_serv == NULL || n <= 0)
444 return 0;
445
446 if (n > nn->nfsd_serv->sv_nrpools)
447 n = nn->nfsd_serv->sv_nrpools;
448
449
450 tot = 0;
451 for (i = 0; i < n; i++) {
452 if (nthreads[i] > NFSD_MAXSERVS)
453 nthreads[i] = NFSD_MAXSERVS;
454 tot += nthreads[i];
455 }
456 if (tot > NFSD_MAXSERVS) {
457
458 for (i = 0; i < n && tot > 0; i++) {
459 int new = nthreads[i] * NFSD_MAXSERVS / tot;
460 tot -= (nthreads[i] - new);
461 nthreads[i] = new;
462 }
463 for (i = 0; i < n && tot > 0; i++) {
464 nthreads[i]--;
465 tot--;
466 }
467 }
468
469
470
471
472
473 if (nthreads[0] == 0)
474 nthreads[0] = 1;
475
476
477 svc_get(nn->nfsd_serv);
478 for (i = 0; i < n; i++) {
479 err = svc_set_num_threads(nn->nfsd_serv, &nn->nfsd_serv->sv_pools[i],
480 nthreads[i]);
481 if (err)
482 break;
483 }
484 nfsd_destroy(net);
485 return err;
486}
487
488
489
490
491
492
493int
494nfsd_svc(int nrservs, struct net *net)
495{
496 int error;
497 bool nfsd_up_before;
498 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
499
500 mutex_lock(&nfsd_mutex);
501 dprintk("nfsd: creating service\n");
502 if (nrservs <= 0)
503 nrservs = 0;
504 if (nrservs > NFSD_MAXSERVS)
505 nrservs = NFSD_MAXSERVS;
506 error = 0;
507 if (nrservs == 0 && nn->nfsd_serv == NULL)
508 goto out;
509
510 error = nfsd_create_serv(net);
511 if (error)
512 goto out;
513
514 nfsd_up_before = nn->nfsd_net_up;
515
516 error = nfsd_startup_net(nrservs, net);
517 if (error)
518 goto out_destroy;
519 error = svc_set_num_threads(nn->nfsd_serv, NULL, nrservs);
520 if (error)
521 goto out_shutdown;
522
523
524
525
526 error = nn->nfsd_serv->sv_nrthreads - 1;
527out_shutdown:
528 if (error < 0 && !nfsd_up_before)
529 nfsd_shutdown_net(net);
530out_destroy:
531 nfsd_destroy(net);
532out:
533 mutex_unlock(&nfsd_mutex);
534 return error;
535}
536
537
538
539
540
541static int
542nfsd(void *vrqstp)
543{
544 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
545 struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
546 struct net *net = perm_sock->xpt_net;
547 int err;
548
549
550 mutex_lock(&nfsd_mutex);
551
552
553
554
555 if (unshare_fs_struct() < 0) {
556 printk("Unable to start nfsd thread: out of memory\n");
557 goto out;
558 }
559
560 current->fs->umask = 0;
561
562
563
564
565
566 allow_signal(SIGKILL);
567 allow_signal(SIGHUP);
568 allow_signal(SIGINT);
569 allow_signal(SIGQUIT);
570
571 nfsdstats.th_cnt++;
572 mutex_unlock(&nfsd_mutex);
573
574
575
576
577
578
579 current->flags |= PF_LESS_THROTTLE;
580 set_freezable();
581
582
583
584
585 for (;;) {
586
587
588
589
590 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
591 ;
592 if (err == -EINTR)
593 break;
594 validate_process_creds();
595 svc_process(rqstp);
596 validate_process_creds();
597 }
598
599
600 flush_signals(current);
601
602 mutex_lock(&nfsd_mutex);
603 nfsdstats.th_cnt --;
604
605out:
606 rqstp->rq_server = NULL;
607
608
609 svc_exit_thread(rqstp);
610
611 nfsd_destroy(net);
612
613
614 mutex_unlock(&nfsd_mutex);
615 module_put_and_exit(0);
616 return 0;
617}
618
619static __be32 map_new_errors(u32 vers, __be32 nfserr)
620{
621 if (nfserr == nfserr_jukebox && vers == 2)
622 return nfserr_dropit;
623 if (nfserr == nfserr_wrongsec && vers < 4)
624 return nfserr_acces;
625 return nfserr;
626}
627
628int
629nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
630{
631 struct svc_procedure *proc;
632 kxdrproc_t xdr;
633 __be32 nfserr;
634 __be32 *nfserrp;
635
636 dprintk("nfsd_dispatch: vers %d proc %d\n",
637 rqstp->rq_vers, rqstp->rq_proc);
638 proc = rqstp->rq_procinfo;
639
640
641
642
643
644 rqstp->rq_cachetype = proc->pc_cachetype;
645
646 xdr = proc->pc_decode;
647 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
648 rqstp->rq_argp)) {
649 dprintk("nfsd: failed to decode arguments!\n");
650 *statp = rpc_garbage_args;
651 return 1;
652 }
653
654
655 switch (nfsd_cache_lookup(rqstp)) {
656 case RC_DROPIT:
657 return 0;
658 case RC_REPLY:
659 return 1;
660 case RC_DOIT:;
661
662 }
663
664
665
666
667 nfserrp = rqstp->rq_res.head[0].iov_base
668 + rqstp->rq_res.head[0].iov_len;
669 rqstp->rq_res.head[0].iov_len += sizeof(__be32);
670
671
672 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
673 nfserr = map_new_errors(rqstp->rq_vers, nfserr);
674 if (nfserr == nfserr_dropit || rqstp->rq_dropme) {
675 dprintk("nfsd: Dropping request; may be revisited later\n");
676 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
677 return 0;
678 }
679
680 if (rqstp->rq_proc != 0)
681 *nfserrp++ = nfserr;
682
683
684
685
686 if (!(nfserr && rqstp->rq_vers == 2)) {
687 xdr = proc->pc_encode;
688 if (xdr && !xdr(rqstp, nfserrp,
689 rqstp->rq_resp)) {
690
691 dprintk("nfsd: failed to encode result!\n");
692 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
693 *statp = rpc_system_err;
694 return 1;
695 }
696 }
697
698
699 nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
700 return 1;
701}
702
703int nfsd_pool_stats_open(struct inode *inode, struct file *file)
704{
705 int ret;
706 struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id);
707
708 mutex_lock(&nfsd_mutex);
709 if (nn->nfsd_serv == NULL) {
710 mutex_unlock(&nfsd_mutex);
711 return -ENODEV;
712 }
713
714 svc_get(nn->nfsd_serv);
715 ret = svc_pool_stats_open(nn->nfsd_serv, file);
716 mutex_unlock(&nfsd_mutex);
717 return ret;
718}
719
720int nfsd_pool_stats_release(struct inode *inode, struct file *file)
721{
722 int ret = seq_release(inode, file);
723 struct net *net = inode->i_sb->s_fs_info;
724
725 mutex_lock(&nfsd_mutex);
726
727 nfsd_destroy(net);
728 mutex_unlock(&nfsd_mutex);
729 return ret;
730}
731