Merge tag 'nfsd-4.15' of git://linux-nfs.org/~bfields/linux
[sfrench/cifs-2.6.git] / fs / nfsd / nfssvc.c
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
31 #define NFSDDBG_FACILITY        NFSDDBG_SVC
32
33 extern struct svc_program       nfsd_program;
34 static int                      nfsd(void *vrqstp);
35
36 /*
37  * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members
38  * of the svc_serv struct. In particular, ->sv_nrthreads but also to some
39  * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
40  *
41  * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a
42  * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
43  * of nfsd threads must exist and each must listed in ->sp_all_threads in each
44  * entry of ->sv_pools[].
45  *
46  * Transitions of the thread count between zero and non-zero are of particular
47  * interest since the svc_serv needs to be created and initialized at that
48  * point, or freed.
49  *
50  * Finally, the nfsd_mutex also protects some of the global variables that are
51  * accessed when nfsd starts and that are settable via the write_* routines in
52  * nfsctl.c. In particular:
53  *
54  *      user_recovery_dirname
55  *      user_lease_time
56  *      nfsd_versions
57  */
58 DEFINE_MUTEX(nfsd_mutex);
59
60 /*
61  * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used.
62  * nfsd_drc_max_pages limits the total amount of memory available for
63  * version 4.1 DRC caches.
64  * nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage.
65  */
66 spinlock_t      nfsd_drc_lock;
67 unsigned long   nfsd_drc_max_mem;
68 unsigned long   nfsd_drc_mem_used;
69
70 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
71 static struct svc_stat  nfsd_acl_svcstats;
72 static const struct svc_version *nfsd_acl_version[] = {
73         [2] = &nfsd_acl_version2,
74         [3] = &nfsd_acl_version3,
75 };
76
77 #define NFSD_ACL_MINVERS            2
78 #define NFSD_ACL_NRVERS         ARRAY_SIZE(nfsd_acl_version)
79 static const struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
80
81 static struct svc_program       nfsd_acl_program = {
82         .pg_prog                = NFS_ACL_PROGRAM,
83         .pg_nvers               = NFSD_ACL_NRVERS,
84         .pg_vers                = nfsd_acl_versions,
85         .pg_name                = "nfsacl",
86         .pg_class               = "nfsd",
87         .pg_stats               = &nfsd_acl_svcstats,
88         .pg_authenticate        = &svc_set_client,
89 };
90
91 static struct svc_stat  nfsd_acl_svcstats = {
92         .program        = &nfsd_acl_program,
93 };
94 #endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
95
96 static const struct svc_version *nfsd_version[] = {
97         [2] = &nfsd_version2,
98 #if defined(CONFIG_NFSD_V3)
99         [3] = &nfsd_version3,
100 #endif
101 #if defined(CONFIG_NFSD_V4)
102         [4] = &nfsd_version4,
103 #endif
104 };
105
106 #define NFSD_MINVERS            2
107 #define NFSD_NRVERS             ARRAY_SIZE(nfsd_version)
108 static const struct svc_version *nfsd_versions[NFSD_NRVERS];
109
110 struct svc_program              nfsd_program = {
111 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
112         .pg_next                = &nfsd_acl_program,
113 #endif
114         .pg_prog                = NFS_PROGRAM,          /* program number */
115         .pg_nvers               = NFSD_NRVERS,          /* nr of entries in nfsd_version */
116         .pg_vers                = nfsd_versions,        /* version table */
117         .pg_name                = "nfsd",               /* program name */
118         .pg_class               = "nfsd",               /* authentication class */
119         .pg_stats               = &nfsd_svcstats,       /* version table */
120         .pg_authenticate        = &svc_set_client,      /* export authentication */
121
122 };
123
124 static bool nfsd_supported_minorversions[NFSD_SUPPORTED_MINOR_VERSION + 1] = {
125         [0] = 1,
126         [1] = 1,
127         [2] = 1,
128 };
129
130 int nfsd_vers(int vers, enum vers_op change)
131 {
132         if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
133                 return 0;
134         switch(change) {
135         case NFSD_SET:
136                 nfsd_versions[vers] = nfsd_version[vers];
137 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
138                 if (vers < NFSD_ACL_NRVERS)
139                         nfsd_acl_versions[vers] = nfsd_acl_version[vers];
140 #endif
141                 break;
142         case NFSD_CLEAR:
143                 nfsd_versions[vers] = NULL;
144 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
145                 if (vers < NFSD_ACL_NRVERS)
146                         nfsd_acl_versions[vers] = NULL;
147 #endif
148                 break;
149         case NFSD_TEST:
150                 return nfsd_versions[vers] != NULL;
151         case NFSD_AVAIL:
152                 return nfsd_version[vers] != NULL;
153         }
154         return 0;
155 }
156
157 static void
158 nfsd_adjust_nfsd_versions4(void)
159 {
160         unsigned i;
161
162         for (i = 0; i <= NFSD_SUPPORTED_MINOR_VERSION; i++) {
163                 if (nfsd_supported_minorversions[i])
164                         return;
165         }
166         nfsd_vers(4, NFSD_CLEAR);
167 }
168
169 int nfsd_minorversion(u32 minorversion, enum vers_op change)
170 {
171         if (minorversion > NFSD_SUPPORTED_MINOR_VERSION &&
172             change != NFSD_AVAIL)
173                 return -1;
174         switch(change) {
175         case NFSD_SET:
176                 nfsd_supported_minorversions[minorversion] = true;
177                 nfsd_vers(4, NFSD_SET);
178                 break;
179         case NFSD_CLEAR:
180                 nfsd_supported_minorversions[minorversion] = false;
181                 nfsd_adjust_nfsd_versions4();
182                 break;
183         case NFSD_TEST:
184                 return nfsd_supported_minorversions[minorversion];
185         case NFSD_AVAIL:
186                 return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
187         }
188         return 0;
189 }
190
191 /*
192  * Maximum number of nfsd processes
193  */
194 #define NFSD_MAXSERVS           8192
195
196 int nfsd_nrthreads(struct net *net)
197 {
198         int rv = 0;
199         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
200
201         mutex_lock(&nfsd_mutex);
202         if (nn->nfsd_serv)
203                 rv = nn->nfsd_serv->sv_nrthreads;
204         mutex_unlock(&nfsd_mutex);
205         return rv;
206 }
207
208 static int nfsd_init_socks(struct net *net)
209 {
210         int error;
211         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
212
213         if (!list_empty(&nn->nfsd_serv->sv_permsocks))
214                 return 0;
215
216         error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT,
217                                         SVC_SOCK_DEFAULTS);
218         if (error < 0)
219                 return error;
220
221         error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
222                                         SVC_SOCK_DEFAULTS);
223         if (error < 0)
224                 return error;
225
226         return 0;
227 }
228
229 static int nfsd_users = 0;
230
231 static int nfsd_startup_generic(int nrservs)
232 {
233         int ret;
234
235         if (nfsd_users++)
236                 return 0;
237
238         /*
239          * Readahead param cache - will no-op if it already exists.
240          * (Note therefore results will be suboptimal if number of
241          * threads is modified after nfsd start.)
242          */
243         ret = nfsd_racache_init(2*nrservs);
244         if (ret)
245                 goto dec_users;
246
247         ret = nfs4_state_start();
248         if (ret)
249                 goto out_racache;
250         return 0;
251
252 out_racache:
253         nfsd_racache_shutdown();
254 dec_users:
255         nfsd_users--;
256         return ret;
257 }
258
259 static void nfsd_shutdown_generic(void)
260 {
261         if (--nfsd_users)
262                 return;
263
264         nfs4_state_shutdown();
265         nfsd_racache_shutdown();
266 }
267
268 static bool nfsd_needs_lockd(void)
269 {
270 #if defined(CONFIG_NFSD_V3)
271         return (nfsd_versions[2] != NULL) || (nfsd_versions[3] != NULL);
272 #else
273         return (nfsd_versions[2] != NULL);
274 #endif
275 }
276
277 static int nfsd_startup_net(int nrservs, struct net *net)
278 {
279         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
280         int ret;
281
282         if (nn->nfsd_net_up)
283                 return 0;
284
285         ret = nfsd_startup_generic(nrservs);
286         if (ret)
287                 return ret;
288         ret = nfsd_init_socks(net);
289         if (ret)
290                 goto out_socks;
291
292         if (nfsd_needs_lockd() && !nn->lockd_up) {
293                 ret = lockd_up(net);
294                 if (ret)
295                         goto out_socks;
296                 nn->lockd_up = 1;
297         }
298
299         ret = nfs4_state_start_net(net);
300         if (ret)
301                 goto out_lockd;
302
303         nn->nfsd_net_up = true;
304         return 0;
305
306 out_lockd:
307         if (nn->lockd_up) {
308                 lockd_down(net);
309                 nn->lockd_up = 0;
310         }
311 out_socks:
312         nfsd_shutdown_generic();
313         return ret;
314 }
315
316 static void nfsd_shutdown_net(struct net *net)
317 {
318         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
319
320         nfs4_state_shutdown_net(net);
321         if (nn->lockd_up) {
322                 lockd_down(net);
323                 nn->lockd_up = 0;
324         }
325         nn->nfsd_net_up = false;
326         nfsd_shutdown_generic();
327 }
328
329 static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event,
330         void *ptr)
331 {
332         struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
333         struct net_device *dev = ifa->ifa_dev->dev;
334         struct net *net = dev_net(dev);
335         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
336         struct sockaddr_in sin;
337
338         if (event != NETDEV_DOWN)
339                 goto out;
340
341         if (nn->nfsd_serv) {
342                 dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local);
343                 sin.sin_family = AF_INET;
344                 sin.sin_addr.s_addr = ifa->ifa_local;
345                 svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin);
346         }
347
348 out:
349         return NOTIFY_DONE;
350 }
351
352 static struct notifier_block nfsd_inetaddr_notifier = {
353         .notifier_call = nfsd_inetaddr_event,
354 };
355
356 #if IS_ENABLED(CONFIG_IPV6)
357 static int nfsd_inet6addr_event(struct notifier_block *this,
358         unsigned long event, void *ptr)
359 {
360         struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
361         struct net_device *dev = ifa->idev->dev;
362         struct net *net = dev_net(dev);
363         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
364         struct sockaddr_in6 sin6;
365
366         if (event != NETDEV_DOWN)
367                 goto out;
368
369         if (nn->nfsd_serv) {
370                 dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr);
371                 sin6.sin6_family = AF_INET6;
372                 sin6.sin6_addr = ifa->addr;
373                 if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
374                         sin6.sin6_scope_id = ifa->idev->dev->ifindex;
375                 svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6);
376         }
377
378 out:
379         return NOTIFY_DONE;
380 }
381
382 static struct notifier_block nfsd_inet6addr_notifier = {
383         .notifier_call = nfsd_inet6addr_event,
384 };
385 #endif
386
387 /* Only used under nfsd_mutex, so this atomic may be overkill: */
388 static atomic_t nfsd_notifier_refcount = ATOMIC_INIT(0);
389
390 static void nfsd_last_thread(struct svc_serv *serv, struct net *net)
391 {
392         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
393
394         /* check if the notifier still has clients */
395         if (atomic_dec_return(&nfsd_notifier_refcount) == 0) {
396                 unregister_inetaddr_notifier(&nfsd_inetaddr_notifier);
397 #if IS_ENABLED(CONFIG_IPV6)
398                 unregister_inet6addr_notifier(&nfsd_inet6addr_notifier);
399 #endif
400         }
401
402         /*
403          * write_ports can create the server without actually starting
404          * any threads--if we get shut down before any threads are
405          * started, then nfsd_last_thread will be run before any of this
406          * other initialization has been done except the rpcb information.
407          */
408         svc_rpcb_cleanup(serv, net);
409         if (!nn->nfsd_net_up)
410                 return;
411
412         nfsd_shutdown_net(net);
413         printk(KERN_WARNING "nfsd: last server has exited, flushing export "
414                             "cache\n");
415         nfsd_export_flush(net);
416 }
417
418 void nfsd_reset_versions(void)
419 {
420         int i;
421
422         for (i = 0; i < NFSD_NRVERS; i++)
423                 if (nfsd_vers(i, NFSD_TEST))
424                         return;
425
426         for (i = 0; i < NFSD_NRVERS; i++)
427                 if (i != 4)
428                         nfsd_vers(i, NFSD_SET);
429                 else {
430                         int minor = 0;
431                         while (nfsd_minorversion(minor, NFSD_SET) >= 0)
432                                 minor++;
433                 }
434 }
435
436 /*
437  * Each session guarantees a negotiated per slot memory cache for replies
438  * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated
439  * NFSv4.1 server might want to use more memory for a DRC than a machine
440  * with mutiple services.
441  *
442  * Impose a hard limit on the number of pages for the DRC which varies
443  * according to the machines free pages. This is of course only a default.
444  *
445  * For now this is a #defined shift which could be under admin control
446  * in the future.
447  */
448 static void set_max_drc(void)
449 {
450         #define NFSD_DRC_SIZE_SHIFT     7
451         nfsd_drc_max_mem = (nr_free_buffer_pages()
452                                         >> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE;
453         nfsd_drc_mem_used = 0;
454         spin_lock_init(&nfsd_drc_lock);
455         dprintk("%s nfsd_drc_max_mem %lu \n", __func__, nfsd_drc_max_mem);
456 }
457
458 static int nfsd_get_default_max_blksize(void)
459 {
460         struct sysinfo i;
461         unsigned long long target;
462         unsigned long ret;
463
464         si_meminfo(&i);
465         target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
466         /*
467          * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
468          * machines, but only uses 32K on 128M machines.  Bottom out at
469          * 8K on 32M and smaller.  Of course, this is only a default.
470          */
471         target >>= 12;
472
473         ret = NFSSVC_MAXBLKSIZE;
474         while (ret > target && ret >= 8*1024*2)
475                 ret /= 2;
476         return ret;
477 }
478
479 static const struct svc_serv_ops nfsd_thread_sv_ops = {
480         .svo_shutdown           = nfsd_last_thread,
481         .svo_function           = nfsd,
482         .svo_enqueue_xprt       = svc_xprt_do_enqueue,
483         .svo_setup              = svc_set_num_threads,
484         .svo_module             = THIS_MODULE,
485 };
486
487 int nfsd_create_serv(struct net *net)
488 {
489         int error;
490         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
491
492         WARN_ON(!mutex_is_locked(&nfsd_mutex));
493         if (nn->nfsd_serv) {
494                 svc_get(nn->nfsd_serv);
495                 return 0;
496         }
497         if (nfsd_max_blksize == 0)
498                 nfsd_max_blksize = nfsd_get_default_max_blksize();
499         nfsd_reset_versions();
500         nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
501                                                 &nfsd_thread_sv_ops);
502         if (nn->nfsd_serv == NULL)
503                 return -ENOMEM;
504
505         nn->nfsd_serv->sv_maxconn = nn->max_connections;
506         error = svc_bind(nn->nfsd_serv, net);
507         if (error < 0) {
508                 svc_destroy(nn->nfsd_serv);
509                 return error;
510         }
511
512         set_max_drc();
513         /* check if the notifier is already set */
514         if (atomic_inc_return(&nfsd_notifier_refcount) == 1) {
515                 register_inetaddr_notifier(&nfsd_inetaddr_notifier);
516 #if IS_ENABLED(CONFIG_IPV6)
517                 register_inet6addr_notifier(&nfsd_inet6addr_notifier);
518 #endif
519         }
520         ktime_get_real_ts64(&nn->nfssvc_boot); /* record boot time */
521         return 0;
522 }
523
524 int nfsd_nrpools(struct net *net)
525 {
526         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
527
528         if (nn->nfsd_serv == NULL)
529                 return 0;
530         else
531                 return nn->nfsd_serv->sv_nrpools;
532 }
533
534 int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
535 {
536         int i = 0;
537         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
538
539         if (nn->nfsd_serv != NULL) {
540                 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++)
541                         nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads;
542         }
543
544         return 0;
545 }
546
547 void nfsd_destroy(struct net *net)
548 {
549         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
550         int destroy = (nn->nfsd_serv->sv_nrthreads == 1);
551
552         if (destroy)
553                 svc_shutdown_net(nn->nfsd_serv, net);
554         svc_destroy(nn->nfsd_serv);
555         if (destroy)
556                 nn->nfsd_serv = NULL;
557 }
558
559 int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
560 {
561         int i = 0;
562         int tot = 0;
563         int err = 0;
564         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
565
566         WARN_ON(!mutex_is_locked(&nfsd_mutex));
567
568         if (nn->nfsd_serv == NULL || n <= 0)
569                 return 0;
570
571         if (n > nn->nfsd_serv->sv_nrpools)
572                 n = nn->nfsd_serv->sv_nrpools;
573
574         /* enforce a global maximum number of threads */
575         tot = 0;
576         for (i = 0; i < n; i++) {
577                 nthreads[i] = min(nthreads[i], NFSD_MAXSERVS);
578                 tot += nthreads[i];
579         }
580         if (tot > NFSD_MAXSERVS) {
581                 /* total too large: scale down requested numbers */
582                 for (i = 0; i < n && tot > 0; i++) {
583                         int new = nthreads[i] * NFSD_MAXSERVS / tot;
584                         tot -= (nthreads[i] - new);
585                         nthreads[i] = new;
586                 }
587                 for (i = 0; i < n && tot > 0; i++) {
588                         nthreads[i]--;
589                         tot--;
590                 }
591         }
592
593         /*
594          * There must always be a thread in pool 0; the admin
595          * can't shut down NFS completely using pool_threads.
596          */
597         if (nthreads[0] == 0)
598                 nthreads[0] = 1;
599
600         /* apply the new numbers */
601         svc_get(nn->nfsd_serv);
602         for (i = 0; i < n; i++) {
603                 err = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
604                                 &nn->nfsd_serv->sv_pools[i], nthreads[i]);
605                 if (err)
606                         break;
607         }
608         nfsd_destroy(net);
609         return err;
610 }
611
612 /*
613  * Adjust the number of threads and return the new number of threads.
614  * This is also the function that starts the server if necessary, if
615  * this is the first time nrservs is nonzero.
616  */
617 int
618 nfsd_svc(int nrservs, struct net *net)
619 {
620         int     error;
621         bool    nfsd_up_before;
622         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
623
624         mutex_lock(&nfsd_mutex);
625         dprintk("nfsd: creating service\n");
626
627         nrservs = max(nrservs, 0);
628         nrservs = min(nrservs, NFSD_MAXSERVS);
629         error = 0;
630
631         if (nrservs == 0 && nn->nfsd_serv == NULL)
632                 goto out;
633
634         error = nfsd_create_serv(net);
635         if (error)
636                 goto out;
637
638         nfsd_up_before = nn->nfsd_net_up;
639
640         error = nfsd_startup_net(nrservs, net);
641         if (error)
642                 goto out_destroy;
643         error = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
644                         NULL, nrservs);
645         if (error)
646                 goto out_shutdown;
647         /* We are holding a reference to nn->nfsd_serv which
648          * we don't want to count in the return value,
649          * so subtract 1
650          */
651         error = nn->nfsd_serv->sv_nrthreads - 1;
652 out_shutdown:
653         if (error < 0 && !nfsd_up_before)
654                 nfsd_shutdown_net(net);
655 out_destroy:
656         nfsd_destroy(net);              /* Release server */
657 out:
658         mutex_unlock(&nfsd_mutex);
659         return error;
660 }
661
662
663 /*
664  * This is the NFS server kernel thread
665  */
666 static int
667 nfsd(void *vrqstp)
668 {
669         struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
670         struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
671         struct net *net = perm_sock->xpt_net;
672         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
673         int err;
674
675         /* Lock module and set up kernel thread */
676         mutex_lock(&nfsd_mutex);
677
678         /* At this point, the thread shares current->fs
679          * with the init process. We need to create files with the
680          * umask as defined by the client instead of init's umask. */
681         if (unshare_fs_struct() < 0) {
682                 printk("Unable to start nfsd thread: out of memory\n");
683                 goto out;
684         }
685
686         current->fs->umask = 0;
687
688         /*
689          * thread is spawned with all signals set to SIG_IGN, re-enable
690          * the ones that will bring down the thread
691          */
692         allow_signal(SIGKILL);
693         allow_signal(SIGHUP);
694         allow_signal(SIGINT);
695         allow_signal(SIGQUIT);
696
697         nfsdstats.th_cnt++;
698         mutex_unlock(&nfsd_mutex);
699
700         set_freezable();
701
702         /*
703          * The main request loop
704          */
705         for (;;) {
706                 /* Update sv_maxconn if it has changed */
707                 rqstp->rq_server->sv_maxconn = nn->max_connections;
708
709                 /*
710                  * Find a socket with data available and call its
711                  * recvfrom routine.
712                  */
713                 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
714                         ;
715                 if (err == -EINTR)
716                         break;
717                 validate_process_creds();
718                 svc_process(rqstp);
719                 validate_process_creds();
720         }
721
722         /* Clear signals before calling svc_exit_thread() */
723         flush_signals(current);
724
725         mutex_lock(&nfsd_mutex);
726         nfsdstats.th_cnt --;
727
728 out:
729         rqstp->rq_server = NULL;
730
731         /* Release the thread */
732         svc_exit_thread(rqstp);
733
734         nfsd_destroy(net);
735
736         /* Release module */
737         mutex_unlock(&nfsd_mutex);
738         module_put_and_exit(0);
739         return 0;
740 }
741
742 static __be32 map_new_errors(u32 vers, __be32 nfserr)
743 {
744         if (nfserr == nfserr_jukebox && vers == 2)
745                 return nfserr_dropit;
746         if (nfserr == nfserr_wrongsec && vers < 4)
747                 return nfserr_acces;
748         return nfserr;
749 }
750
751 /*
752  * A write procedure can have a large argument, and a read procedure can
753  * have a large reply, but no NFSv2 or NFSv3 procedure has argument and
754  * reply that can both be larger than a page.  The xdr code has taken
755  * advantage of this assumption to be a sloppy about bounds checking in
756  * some cases.  Pending a rewrite of the NFSv2/v3 xdr code to fix that
757  * problem, we enforce these assumptions here:
758  */
759 static bool nfs_request_too_big(struct svc_rqst *rqstp,
760                                 const struct svc_procedure *proc)
761 {
762         /*
763          * The ACL code has more careful bounds-checking and is not
764          * susceptible to this problem:
765          */
766         if (rqstp->rq_prog != NFS_PROGRAM)
767                 return false;
768         /*
769          * Ditto NFSv4 (which can in theory have argument and reply both
770          * more than a page):
771          */
772         if (rqstp->rq_vers >= 4)
773                 return false;
774         /* The reply will be small, we're OK: */
775         if (proc->pc_xdrressize > 0 &&
776             proc->pc_xdrressize < XDR_QUADLEN(PAGE_SIZE))
777                 return false;
778
779         return rqstp->rq_arg.len > PAGE_SIZE;
780 }
781
782 int
783 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
784 {
785         const struct svc_procedure *proc;
786         __be32                  nfserr;
787         __be32                  *nfserrp;
788
789         dprintk("nfsd_dispatch: vers %d proc %d\n",
790                                 rqstp->rq_vers, rqstp->rq_proc);
791         proc = rqstp->rq_procinfo;
792
793         if (nfs_request_too_big(rqstp, proc)) {
794                 dprintk("nfsd: NFSv%d argument too large\n", rqstp->rq_vers);
795                 *statp = rpc_garbage_args;
796                 return 1;
797         }
798         /*
799          * Give the xdr decoder a chance to change this if it wants
800          * (necessary in the NFSv4.0 compound case)
801          */
802         rqstp->rq_cachetype = proc->pc_cachetype;
803         /* Decode arguments */
804         if (proc->pc_decode &&
805             !proc->pc_decode(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base)) {
806                 dprintk("nfsd: failed to decode arguments!\n");
807                 *statp = rpc_garbage_args;
808                 return 1;
809         }
810
811         /* Check whether we have this call in the cache. */
812         switch (nfsd_cache_lookup(rqstp)) {
813         case RC_DROPIT:
814                 return 0;
815         case RC_REPLY:
816                 return 1;
817         case RC_DOIT:;
818                 /* do it */
819         }
820
821         /* need to grab the location to store the status, as
822          * nfsv4 does some encoding while processing 
823          */
824         nfserrp = rqstp->rq_res.head[0].iov_base
825                 + rqstp->rq_res.head[0].iov_len;
826         rqstp->rq_res.head[0].iov_len += sizeof(__be32);
827
828         /* Now call the procedure handler, and encode NFS status. */
829         nfserr = proc->pc_func(rqstp);
830         nfserr = map_new_errors(rqstp->rq_vers, nfserr);
831         if (nfserr == nfserr_dropit || test_bit(RQ_DROPME, &rqstp->rq_flags)) {
832                 dprintk("nfsd: Dropping request; may be revisited later\n");
833                 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
834                 return 0;
835         }
836
837         if (rqstp->rq_proc != 0)
838                 *nfserrp++ = nfserr;
839
840         /* Encode result.
841          * For NFSv2, additional info is never returned in case of an error.
842          */
843         if (!(nfserr && rqstp->rq_vers == 2)) {
844                 if (proc->pc_encode && !proc->pc_encode(rqstp, nfserrp)) {
845                         /* Failed to encode result. Release cache entry */
846                         dprintk("nfsd: failed to encode result!\n");
847                         nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
848                         *statp = rpc_system_err;
849                         return 1;
850                 }
851         }
852
853         /* Store reply in cache. */
854         nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
855         return 1;
856 }
857
858 int nfsd_pool_stats_open(struct inode *inode, struct file *file)
859 {
860         int ret;
861         struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id);
862
863         mutex_lock(&nfsd_mutex);
864         if (nn->nfsd_serv == NULL) {
865                 mutex_unlock(&nfsd_mutex);
866                 return -ENODEV;
867         }
868         /* bump up the psudo refcount while traversing */
869         svc_get(nn->nfsd_serv);
870         ret = svc_pool_stats_open(nn->nfsd_serv, file);
871         mutex_unlock(&nfsd_mutex);
872         return ret;
873 }
874
875 int nfsd_pool_stats_release(struct inode *inode, struct file *file)
876 {
877         int ret = seq_release(inode, file);
878         struct net *net = inode->i_sb->s_fs_info;
879
880         mutex_lock(&nfsd_mutex);
881         /* this function really, really should have been called svc_put() */
882         nfsd_destroy(net);
883         mutex_unlock(&nfsd_mutex);
884         return ret;
885 }