ARM: s3c64xx: bring back notes from removed debug-macro.S
[linux-2.6-microblaze.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 #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 bool i_am_nfsd(void)
605 {
606         return kthread_func(current) == nfsd;
607 }
608
609 int nfsd_create_serv(struct net *net)
610 {
611         int error;
612         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
613
614         WARN_ON(!mutex_is_locked(&nfsd_mutex));
615         if (nn->nfsd_serv) {
616                 svc_get(nn->nfsd_serv);
617                 return 0;
618         }
619         if (nfsd_max_blksize == 0)
620                 nfsd_max_blksize = nfsd_get_default_max_blksize();
621         nfsd_reset_versions(nn);
622         nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
623                                                 &nfsd_thread_sv_ops);
624         if (nn->nfsd_serv == NULL)
625                 return -ENOMEM;
626
627         nn->nfsd_serv->sv_maxconn = nn->max_connections;
628         error = svc_bind(nn->nfsd_serv, net);
629         if (error < 0) {
630                 svc_destroy(nn->nfsd_serv);
631                 return error;
632         }
633
634         set_max_drc();
635         /* check if the notifier is already set */
636         if (atomic_inc_return(&nfsd_notifier_refcount) == 1) {
637                 register_inetaddr_notifier(&nfsd_inetaddr_notifier);
638 #if IS_ENABLED(CONFIG_IPV6)
639                 register_inet6addr_notifier(&nfsd_inet6addr_notifier);
640 #endif
641         }
642         atomic_inc(&nn->ntf_refcnt);
643         nfsd_reset_boot_verifier(nn);
644         return 0;
645 }
646
647 int nfsd_nrpools(struct net *net)
648 {
649         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
650
651         if (nn->nfsd_serv == NULL)
652                 return 0;
653         else
654                 return nn->nfsd_serv->sv_nrpools;
655 }
656
657 int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
658 {
659         int i = 0;
660         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
661
662         if (nn->nfsd_serv != NULL) {
663                 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++)
664                         nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads;
665         }
666
667         return 0;
668 }
669
670 void nfsd_destroy(struct net *net)
671 {
672         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
673         int destroy = (nn->nfsd_serv->sv_nrthreads == 1);
674
675         if (destroy)
676                 svc_shutdown_net(nn->nfsd_serv, net);
677         svc_destroy(nn->nfsd_serv);
678         if (destroy)
679                 nn->nfsd_serv = NULL;
680 }
681
682 int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
683 {
684         int i = 0;
685         int tot = 0;
686         int err = 0;
687         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
688
689         WARN_ON(!mutex_is_locked(&nfsd_mutex));
690
691         if (nn->nfsd_serv == NULL || n <= 0)
692                 return 0;
693
694         if (n > nn->nfsd_serv->sv_nrpools)
695                 n = nn->nfsd_serv->sv_nrpools;
696
697         /* enforce a global maximum number of threads */
698         tot = 0;
699         for (i = 0; i < n; i++) {
700                 nthreads[i] = min(nthreads[i], NFSD_MAXSERVS);
701                 tot += nthreads[i];
702         }
703         if (tot > NFSD_MAXSERVS) {
704                 /* total too large: scale down requested numbers */
705                 for (i = 0; i < n && tot > 0; i++) {
706                         int new = nthreads[i] * NFSD_MAXSERVS / tot;
707                         tot -= (nthreads[i] - new);
708                         nthreads[i] = new;
709                 }
710                 for (i = 0; i < n && tot > 0; i++) {
711                         nthreads[i]--;
712                         tot--;
713                 }
714         }
715
716         /*
717          * There must always be a thread in pool 0; the admin
718          * can't shut down NFS completely using pool_threads.
719          */
720         if (nthreads[0] == 0)
721                 nthreads[0] = 1;
722
723         /* apply the new numbers */
724         svc_get(nn->nfsd_serv);
725         for (i = 0; i < n; i++) {
726                 err = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
727                                 &nn->nfsd_serv->sv_pools[i], nthreads[i]);
728                 if (err)
729                         break;
730         }
731         nfsd_destroy(net);
732         return err;
733 }
734
735 /*
736  * Adjust the number of threads and return the new number of threads.
737  * This is also the function that starts the server if necessary, if
738  * this is the first time nrservs is nonzero.
739  */
740 int
741 nfsd_svc(int nrservs, struct net *net, const struct cred *cred)
742 {
743         int     error;
744         bool    nfsd_up_before;
745         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
746
747         mutex_lock(&nfsd_mutex);
748         dprintk("nfsd: creating service\n");
749
750         nrservs = max(nrservs, 0);
751         nrservs = min(nrservs, NFSD_MAXSERVS);
752         error = 0;
753
754         if (nrservs == 0 && nn->nfsd_serv == NULL)
755                 goto out;
756
757         strlcpy(nn->nfsd_name, utsname()->nodename,
758                 sizeof(nn->nfsd_name));
759
760         error = nfsd_create_serv(net);
761         if (error)
762                 goto out;
763
764         nfsd_up_before = nn->nfsd_net_up;
765
766         error = nfsd_startup_net(nrservs, net, cred);
767         if (error)
768                 goto out_destroy;
769         error = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
770                         NULL, nrservs);
771         if (error)
772                 goto out_shutdown;
773         /* We are holding a reference to nn->nfsd_serv which
774          * we don't want to count in the return value,
775          * so subtract 1
776          */
777         error = nn->nfsd_serv->sv_nrthreads - 1;
778 out_shutdown:
779         if (error < 0 && !nfsd_up_before)
780                 nfsd_shutdown_net(net);
781 out_destroy:
782         nfsd_destroy(net);              /* Release server */
783 out:
784         mutex_unlock(&nfsd_mutex);
785         return error;
786 }
787
788 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
789 static bool
790 nfsd_support_acl_version(int vers)
791 {
792         if (vers >= NFSD_ACL_MINVERS && vers < NFSD_ACL_NRVERS)
793                 return nfsd_acl_version[vers] != NULL;
794         return false;
795 }
796
797 static int
798 nfsd_acl_rpcbind_set(struct net *net, const struct svc_program *progp,
799                      u32 version, int family, unsigned short proto,
800                      unsigned short port)
801 {
802         if (!nfsd_support_acl_version(version) ||
803             !nfsd_vers(net_generic(net, nfsd_net_id), version, NFSD_TEST))
804                 return 0;
805         return svc_generic_rpcbind_set(net, progp, version, family,
806                         proto, port);
807 }
808
809 static __be32
810 nfsd_acl_init_request(struct svc_rqst *rqstp,
811                       const struct svc_program *progp,
812                       struct svc_process_info *ret)
813 {
814         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
815         int i;
816
817         if (likely(nfsd_support_acl_version(rqstp->rq_vers) &&
818             nfsd_vers(nn, rqstp->rq_vers, NFSD_TEST)))
819                 return svc_generic_init_request(rqstp, progp, ret);
820
821         ret->mismatch.lovers = NFSD_ACL_NRVERS;
822         for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++) {
823                 if (nfsd_support_acl_version(rqstp->rq_vers) &&
824                     nfsd_vers(nn, i, NFSD_TEST)) {
825                         ret->mismatch.lovers = i;
826                         break;
827                 }
828         }
829         if (ret->mismatch.lovers == NFSD_ACL_NRVERS)
830                 return rpc_prog_unavail;
831         ret->mismatch.hivers = NFSD_ACL_MINVERS;
832         for (i = NFSD_ACL_NRVERS - 1; i >= NFSD_ACL_MINVERS; i--) {
833                 if (nfsd_support_acl_version(rqstp->rq_vers) &&
834                     nfsd_vers(nn, i, NFSD_TEST)) {
835                         ret->mismatch.hivers = i;
836                         break;
837                 }
838         }
839         return rpc_prog_mismatch;
840 }
841 #endif
842
843 static int
844 nfsd_rpcbind_set(struct net *net, const struct svc_program *progp,
845                  u32 version, int family, unsigned short proto,
846                  unsigned short port)
847 {
848         if (!nfsd_vers(net_generic(net, nfsd_net_id), version, NFSD_TEST))
849                 return 0;
850         return svc_generic_rpcbind_set(net, progp, version, family,
851                         proto, port);
852 }
853
854 static __be32
855 nfsd_init_request(struct svc_rqst *rqstp,
856                   const struct svc_program *progp,
857                   struct svc_process_info *ret)
858 {
859         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
860         int i;
861
862         if (likely(nfsd_vers(nn, rqstp->rq_vers, NFSD_TEST)))
863                 return svc_generic_init_request(rqstp, progp, ret);
864
865         ret->mismatch.lovers = NFSD_NRVERS;
866         for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
867                 if (nfsd_vers(nn, i, NFSD_TEST)) {
868                         ret->mismatch.lovers = i;
869                         break;
870                 }
871         }
872         if (ret->mismatch.lovers == NFSD_NRVERS)
873                 return rpc_prog_unavail;
874         ret->mismatch.hivers = NFSD_MINVERS;
875         for (i = NFSD_NRVERS - 1; i >= NFSD_MINVERS; i--) {
876                 if (nfsd_vers(nn, i, NFSD_TEST)) {
877                         ret->mismatch.hivers = i;
878                         break;
879                 }
880         }
881         return rpc_prog_mismatch;
882 }
883
884 /*
885  * This is the NFS server kernel thread
886  */
887 static int
888 nfsd(void *vrqstp)
889 {
890         struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
891         struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
892         struct net *net = perm_sock->xpt_net;
893         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
894         int err;
895
896         /* Lock module and set up kernel thread */
897         mutex_lock(&nfsd_mutex);
898
899         /* At this point, the thread shares current->fs
900          * with the init process. We need to create files with the
901          * umask as defined by the client instead of init's umask. */
902         if (unshare_fs_struct() < 0) {
903                 printk("Unable to start nfsd thread: out of memory\n");
904                 goto out;
905         }
906
907         current->fs->umask = 0;
908
909         /*
910          * thread is spawned with all signals set to SIG_IGN, re-enable
911          * the ones that will bring down the thread
912          */
913         allow_signal(SIGKILL);
914         allow_signal(SIGHUP);
915         allow_signal(SIGINT);
916         allow_signal(SIGQUIT);
917
918         nfsdstats.th_cnt++;
919         mutex_unlock(&nfsd_mutex);
920
921         set_freezable();
922
923         /*
924          * The main request loop
925          */
926         for (;;) {
927                 /* Update sv_maxconn if it has changed */
928                 rqstp->rq_server->sv_maxconn = nn->max_connections;
929
930                 /*
931                  * Find a socket with data available and call its
932                  * recvfrom routine.
933                  */
934                 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
935                         ;
936                 if (err == -EINTR)
937                         break;
938                 validate_process_creds();
939                 svc_process(rqstp);
940                 validate_process_creds();
941         }
942
943         /* Clear signals before calling svc_exit_thread() */
944         flush_signals(current);
945
946         mutex_lock(&nfsd_mutex);
947         nfsdstats.th_cnt --;
948
949 out:
950         rqstp->rq_server = NULL;
951
952         /* Release the thread */
953         svc_exit_thread(rqstp);
954
955         nfsd_destroy(net);
956
957         /* Release module */
958         mutex_unlock(&nfsd_mutex);
959         module_put_and_exit(0);
960         return 0;
961 }
962
963 static __be32 map_new_errors(u32 vers, __be32 nfserr)
964 {
965         if (nfserr == nfserr_jukebox && vers == 2)
966                 return nfserr_dropit;
967         if (nfserr == nfserr_wrongsec && vers < 4)
968                 return nfserr_acces;
969         return nfserr;
970 }
971
972 /*
973  * A write procedure can have a large argument, and a read procedure can
974  * have a large reply, but no NFSv2 or NFSv3 procedure has argument and
975  * reply that can both be larger than a page.  The xdr code has taken
976  * advantage of this assumption to be a sloppy about bounds checking in
977  * some cases.  Pending a rewrite of the NFSv2/v3 xdr code to fix that
978  * problem, we enforce these assumptions here:
979  */
980 static bool nfs_request_too_big(struct svc_rqst *rqstp,
981                                 const struct svc_procedure *proc)
982 {
983         /*
984          * The ACL code has more careful bounds-checking and is not
985          * susceptible to this problem:
986          */
987         if (rqstp->rq_prog != NFS_PROGRAM)
988                 return false;
989         /*
990          * Ditto NFSv4 (which can in theory have argument and reply both
991          * more than a page):
992          */
993         if (rqstp->rq_vers >= 4)
994                 return false;
995         /* The reply will be small, we're OK: */
996         if (proc->pc_xdrressize > 0 &&
997             proc->pc_xdrressize < XDR_QUADLEN(PAGE_SIZE))
998                 return false;
999
1000         return rqstp->rq_arg.len > PAGE_SIZE;
1001 }
1002
1003 int
1004 nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
1005 {
1006         const struct svc_procedure *proc;
1007         __be32                  nfserr;
1008         __be32                  *nfserrp;
1009
1010         dprintk("nfsd_dispatch: vers %d proc %d\n",
1011                                 rqstp->rq_vers, rqstp->rq_proc);
1012         proc = rqstp->rq_procinfo;
1013
1014         if (nfs_request_too_big(rqstp, proc)) {
1015                 dprintk("nfsd: NFSv%d argument too large\n", rqstp->rq_vers);
1016                 *statp = rpc_garbage_args;
1017                 return 1;
1018         }
1019         rqstp->rq_lease_breaker = NULL;
1020         /*
1021          * Give the xdr decoder a chance to change this if it wants
1022          * (necessary in the NFSv4.0 compound case)
1023          */
1024         rqstp->rq_cachetype = proc->pc_cachetype;
1025         /* Decode arguments */
1026         if (proc->pc_decode &&
1027             !proc->pc_decode(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base)) {
1028                 dprintk("nfsd: failed to decode arguments!\n");
1029                 *statp = rpc_garbage_args;
1030                 return 1;
1031         }
1032
1033         /* Check whether we have this call in the cache. */
1034         switch (nfsd_cache_lookup(rqstp)) {
1035         case RC_DROPIT:
1036                 return 0;
1037         case RC_REPLY:
1038                 return 1;
1039         case RC_DOIT:;
1040                 /* do it */
1041         }
1042
1043         /* need to grab the location to store the status, as
1044          * nfsv4 does some encoding while processing 
1045          */
1046         nfserrp = rqstp->rq_res.head[0].iov_base
1047                 + rqstp->rq_res.head[0].iov_len;
1048         rqstp->rq_res.head[0].iov_len += sizeof(__be32);
1049
1050         /* Now call the procedure handler, and encode NFS status. */
1051         nfserr = proc->pc_func(rqstp);
1052         nfserr = map_new_errors(rqstp->rq_vers, nfserr);
1053         if (nfserr == nfserr_dropit || test_bit(RQ_DROPME, &rqstp->rq_flags)) {
1054                 dprintk("nfsd: Dropping request; may be revisited later\n");
1055                 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
1056                 return 0;
1057         }
1058
1059         if (rqstp->rq_proc != 0)
1060                 *nfserrp++ = nfserr;
1061
1062         /* Encode result.
1063          * For NFSv2, additional info is never returned in case of an error.
1064          */
1065         if (!(nfserr && rqstp->rq_vers == 2)) {
1066                 if (proc->pc_encode && !proc->pc_encode(rqstp, nfserrp)) {
1067                         /* Failed to encode result. Release cache entry */
1068                         dprintk("nfsd: failed to encode result!\n");
1069                         nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
1070                         *statp = rpc_system_err;
1071                         return 1;
1072                 }
1073         }
1074
1075         /* Store reply in cache. */
1076         nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
1077         return 1;
1078 }
1079
1080 int nfsd_pool_stats_open(struct inode *inode, struct file *file)
1081 {
1082         int ret;
1083         struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id);
1084
1085         mutex_lock(&nfsd_mutex);
1086         if (nn->nfsd_serv == NULL) {
1087                 mutex_unlock(&nfsd_mutex);
1088                 return -ENODEV;
1089         }
1090         /* bump up the psudo refcount while traversing */
1091         svc_get(nn->nfsd_serv);
1092         ret = svc_pool_stats_open(nn->nfsd_serv, file);
1093         mutex_unlock(&nfsd_mutex);
1094         return ret;
1095 }
1096
1097 int nfsd_pool_stats_release(struct inode *inode, struct file *file)
1098 {
1099         int ret = seq_release(inode, file);
1100         struct net *net = inode->i_sb->s_fs_info;
1101
1102         mutex_lock(&nfsd_mutex);
1103         /* this function really, really should have been called svc_put() */
1104         nfsd_destroy(net);
1105         mutex_unlock(&nfsd_mutex);
1106         return ret;
1107 }