blob: 5c4800626f130acc9574733547fc46c613768e02 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Central processing for nfsd.
3 *
4 * Authors: Olaf Kirch (okir@monad.swb.de)
5 *
6 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
7 */
8
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +04009#include <linux/sched.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070010#include <linux/freezer.h>
Paul Gortmaker143cb492011-07-01 14:23:34 -040011#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/fs_struct.h>
Andy Adamsonc3d06f92009-04-03 08:28:18 +030013#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/sunrpc/stats.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/sunrpc/svcsock.h>
Scott Mayhew36684992015-12-11 16:45:59 -050017#include <linux/sunrpc/svc_xprt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/lockd/bind.h>
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +000019#include <linux/nfsacl.h>
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +090020#include <linux/seq_file.h>
Scott Mayhew36684992015-12-11 16:45:59 -050021#include <linux/inetdevice.h>
22#include <net/addrconf.h>
23#include <net/ipv6.h>
Pavel Emelyanovfc5d00b2010-09-29 16:03:50 +040024#include <net/net_namespace.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020025#include "nfsd.h"
26#include "cache.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050027#include "vfs.h"
Stanislav Kinsbursky2c2fe292012-12-06 14:23:14 +030028#include "netns.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#define NFSDDBG_FACILITY NFSDDBG_SVC
31
Linus Torvalds1da177e2005-04-16 15:20:36 -070032extern struct svc_program nfsd_program;
Jeff Layton9867d762008-06-10 08:40:38 -040033static int nfsd(void *vrqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Neil Brownbedbdd82008-06-10 08:40:35 -040035/*
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +030036 * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members
Neil Brownbedbdd82008-06-10 08:40:35 -040037 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some
38 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
39 *
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +030040 * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a
Neil Brownbedbdd82008-06-10 08:40:35 -040041 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
42 * of nfsd threads must exist and each must listed in ->sp_all_threads in each
43 * entry of ->sv_pools[].
44 *
45 * Transitions of the thread count between zero and non-zero are of particular
46 * interest since the svc_serv needs to be created and initialized at that
47 * point, or freed.
Jeff Layton3dd98a32008-06-10 08:40:36 -040048 *
49 * Finally, the nfsd_mutex also protects some of the global variables that are
50 * accessed when nfsd starts and that are settable via the write_* routines in
51 * nfsctl.c. In particular:
52 *
53 * user_recovery_dirname
54 * user_lease_time
55 * nfsd_versions
Neil Brownbedbdd82008-06-10 08:40:35 -040056 */
57DEFINE_MUTEX(nfsd_mutex);
Neil Brownbedbdd82008-06-10 08:40:35 -040058
Andy Adamson4bd9b0f42009-06-24 15:37:45 -040059/*
60 * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used.
61 * nfsd_drc_max_pages limits the total amount of memory available for
62 * version 4.1 DRC caches.
63 * nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage.
64 */
65spinlock_t nfsd_drc_lock;
Zhang Yanfei697ce9b2013-02-22 16:35:47 -080066unsigned long nfsd_drc_max_mem;
67unsigned long nfsd_drc_mem_used;
Andy Adamson4bd9b0f42009-06-24 15:37:45 -040068
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080069#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
70static struct svc_stat nfsd_acl_svcstats;
71static struct svc_version * nfsd_acl_version[] = {
72 [2] = &nfsd_acl_version2,
73 [3] = &nfsd_acl_version3,
74};
75
76#define NFSD_ACL_MINVERS 2
Tobias Klausere8c96f82006-03-24 03:15:34 -080077#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080078static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
79
80static struct svc_program nfsd_acl_program = {
81 .pg_prog = NFS_ACL_PROGRAM,
82 .pg_nvers = NFSD_ACL_NRVERS,
83 .pg_vers = nfsd_acl_versions,
NeilBrown1a8eff62007-01-26 00:56:58 -080084 .pg_name = "nfsacl",
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080085 .pg_class = "nfsd",
86 .pg_stats = &nfsd_acl_svcstats,
87 .pg_authenticate = &svc_set_client,
88};
89
90static struct svc_stat nfsd_acl_svcstats = {
91 .program = &nfsd_acl_program,
92};
93#endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
94
NeilBrown70c3b762005-11-07 01:00:25 -080095static struct svc_version * nfsd_version[] = {
96 [2] = &nfsd_version2,
97#if defined(CONFIG_NFSD_V3)
98 [3] = &nfsd_version3,
99#endif
100#if defined(CONFIG_NFSD_V4)
101 [4] = &nfsd_version4,
102#endif
103};
104
105#define NFSD_MINVERS 2
Tobias Klausere8c96f82006-03-24 03:15:34 -0800106#define NFSD_NRVERS ARRAY_SIZE(nfsd_version)
NeilBrown70c3b762005-11-07 01:00:25 -0800107static struct svc_version *nfsd_versions[NFSD_NRVERS];
108
109struct svc_program nfsd_program = {
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800110#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
111 .pg_next = &nfsd_acl_program,
112#endif
NeilBrown70c3b762005-11-07 01:00:25 -0800113 .pg_prog = NFS_PROGRAM, /* program number */
114 .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
115 .pg_vers = nfsd_versions, /* version table */
116 .pg_name = "nfsd", /* program name */
117 .pg_class = "nfsd", /* authentication class */
118 .pg_stats = &nfsd_svcstats, /* version table */
119 .pg_authenticate = &svc_set_client, /* export authentication */
120
121};
122
J. Bruce Fields35f7a142013-07-08 19:51:44 -0400123static bool nfsd_supported_minorversions[NFSD_SUPPORTED_MINOR_VERSION + 1] = {
124 [0] = 1,
125 [1] = 1,
J. Bruce Fieldsc23ae602015-01-12 14:52:15 -0500126 [2] = 1,
J. Bruce Fields35f7a142013-07-08 19:51:44 -0400127};
Benny Halevy8daf2202009-04-03 08:28:59 +0300128
NeilBrown6658d3a2006-10-02 02:17:46 -0700129int nfsd_vers(int vers, enum vers_op change)
130{
131 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
Pavel Emelyanov15ddb4a2010-05-14 15:33:36 +0400132 return 0;
NeilBrown6658d3a2006-10-02 02:17:46 -0700133 switch(change) {
134 case NFSD_SET:
135 nfsd_versions[vers] = nfsd_version[vers];
NeilBrown6658d3a2006-10-02 02:17:46 -0700136#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
137 if (vers < NFSD_ACL_NRVERS)
NeilBrown1a8eff62007-01-26 00:56:58 -0800138 nfsd_acl_versions[vers] = nfsd_acl_version[vers];
NeilBrown6658d3a2006-10-02 02:17:46 -0700139#endif
NeilBrown1a8eff62007-01-26 00:56:58 -0800140 break;
NeilBrown6658d3a2006-10-02 02:17:46 -0700141 case NFSD_CLEAR:
142 nfsd_versions[vers] = NULL;
143#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
144 if (vers < NFSD_ACL_NRVERS)
NeilBrown1a8eff62007-01-26 00:56:58 -0800145 nfsd_acl_versions[vers] = NULL;
NeilBrown6658d3a2006-10-02 02:17:46 -0700146#endif
147 break;
148 case NFSD_TEST:
149 return nfsd_versions[vers] != NULL;
150 case NFSD_AVAIL:
151 return nfsd_version[vers] != NULL;
152 }
153 return 0;
154}
Benny Halevy8daf2202009-04-03 08:28:59 +0300155
156int nfsd_minorversion(u32 minorversion, enum vers_op change)
157{
NeilBrown01542692017-03-10 11:36:39 +1100158 if (minorversion > NFSD_SUPPORTED_MINOR_VERSION &&
159 change != NFSD_AVAIL)
Benny Halevy8daf2202009-04-03 08:28:59 +0300160 return -1;
161 switch(change) {
162 case NFSD_SET:
J. Bruce Fields35f7a142013-07-08 19:51:44 -0400163 nfsd_supported_minorversions[minorversion] = true;
Benny Halevy8daf2202009-04-03 08:28:59 +0300164 break;
165 case NFSD_CLEAR:
J. Bruce Fields35f7a142013-07-08 19:51:44 -0400166 nfsd_supported_minorversions[minorversion] = false;
Benny Halevy8daf2202009-04-03 08:28:59 +0300167 break;
168 case NFSD_TEST:
J. Bruce Fields35f7a142013-07-08 19:51:44 -0400169 return nfsd_supported_minorversions[minorversion];
Benny Halevy8daf2202009-04-03 08:28:59 +0300170 case NFSD_AVAIL:
171 return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
172 }
173 return 0;
174}
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176/*
177 * Maximum number of nfsd processes
178 */
179#define NFSD_MAXSERVS 8192
180
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300181int nfsd_nrthreads(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182{
Neil Brownc7d106c2008-06-12 13:38:42 +1000183 int rv = 0;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300184 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
185
Neil Brownc7d106c2008-06-12 13:38:42 +1000186 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300187 if (nn->nfsd_serv)
188 rv = nn->nfsd_serv->sv_nrthreads;
Neil Brownc7d106c2008-06-12 13:38:42 +1000189 mutex_unlock(&nfsd_mutex);
190 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191}
192
Stanislav Kinsburskydb6e1822012-12-10 12:19:09 +0300193static int nfsd_init_socks(struct net *net)
J. Bruce Fields59db4a02010-07-21 18:29:25 -0400194{
195 int error;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300196 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
197
198 if (!list_empty(&nn->nfsd_serv->sv_permsocks))
J. Bruce Fields59db4a02010-07-21 18:29:25 -0400199 return 0;
200
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300201 error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT,
J. Bruce Fields59db4a02010-07-21 18:29:25 -0400202 SVC_SOCK_DEFAULTS);
203 if (error < 0)
204 return error;
205
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300206 error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
J. Bruce Fields59db4a02010-07-21 18:29:25 -0400207 SVC_SOCK_DEFAULTS);
208 if (error < 0)
209 return error;
210
211 return 0;
212}
213
Stanislav Kinsbursky4539f142012-12-06 14:23:39 +0300214static int nfsd_users = 0;
Jeff Layton4ad9a342010-07-19 16:50:04 -0400215
Stanislav Kinsburskybda9cac2012-12-06 14:23:29 +0300216static int nfsd_startup_generic(int nrservs)
217{
218 int ret;
219
Stanislav Kinsbursky4539f142012-12-06 14:23:39 +0300220 if (nfsd_users++)
Stanislav Kinsburskybda9cac2012-12-06 14:23:29 +0300221 return 0;
222
223 /*
224 * Readahead param cache - will no-op if it already exists.
225 * (Note therefore results will be suboptimal if number of
226 * threads is modified after nfsd start.)
227 */
228 ret = nfsd_racache_init(2*nrservs);
229 if (ret)
Kinglong Meed9499a92014-07-30 21:26:05 +0800230 goto dec_users;
231
Stanislav Kinsburskybda9cac2012-12-06 14:23:29 +0300232 ret = nfs4_state_start();
233 if (ret)
234 goto out_racache;
235 return 0;
236
237out_racache:
238 nfsd_racache_shutdown();
Kinglong Meed9499a92014-07-30 21:26:05 +0800239dec_users:
240 nfsd_users--;
Stanislav Kinsburskybda9cac2012-12-06 14:23:29 +0300241 return ret;
242}
243
244static void nfsd_shutdown_generic(void)
245{
Stanislav Kinsbursky4539f142012-12-06 14:23:39 +0300246 if (--nfsd_users)
247 return;
248
Stanislav Kinsburskybda9cac2012-12-06 14:23:29 +0300249 nfs4_state_shutdown();
250 nfsd_racache_shutdown();
251}
252
Kinglong Mee8ef66712013-12-31 13:17:30 +0800253static bool nfsd_needs_lockd(void)
254{
Kinglong Meeff888252014-01-06 11:28:41 +0800255#if defined(CONFIG_NFSD_V3)
Kinglong Mee8ef66712013-12-31 13:17:30 +0800256 return (nfsd_versions[2] != NULL) || (nfsd_versions[3] != NULL);
Kinglong Meeff888252014-01-06 11:28:41 +0800257#else
258 return (nfsd_versions[2] != NULL);
259#endif
Kinglong Mee8ef66712013-12-31 13:17:30 +0800260}
261
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300262static int nfsd_startup_net(int nrservs, struct net *net)
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300263{
Stanislav Kinsbursky2c2fe292012-12-06 14:23:14 +0300264 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300265 int ret;
266
Stanislav Kinsbursky2c2fe292012-12-06 14:23:14 +0300267 if (nn->nfsd_net_up)
268 return 0;
269
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300270 ret = nfsd_startup_generic(nrservs);
271 if (ret)
272 return ret;
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300273 ret = nfsd_init_socks(net);
274 if (ret)
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300275 goto out_socks;
Kinglong Mee8ef66712013-12-31 13:17:30 +0800276
277 if (nfsd_needs_lockd() && !nn->lockd_up) {
278 ret = lockd_up(net);
279 if (ret)
280 goto out_socks;
281 nn->lockd_up = 1;
282 }
283
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300284 ret = nfs4_state_start_net(net);
285 if (ret)
286 goto out_lockd;
287
Stanislav Kinsbursky2c2fe292012-12-06 14:23:14 +0300288 nn->nfsd_net_up = true;
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300289 return 0;
290
291out_lockd:
Kinglong Mee8ef66712013-12-31 13:17:30 +0800292 if (nn->lockd_up) {
293 lockd_down(net);
294 nn->lockd_up = 0;
295 }
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300296out_socks:
Stanislav Kinsburskybda9cac2012-12-06 14:23:29 +0300297 nfsd_shutdown_generic();
Jeff Layton4ad9a342010-07-19 16:50:04 -0400298 return ret;
299}
300
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300301static void nfsd_shutdown_net(struct net *net)
302{
Stanislav Kinsbursky2c2fe292012-12-06 14:23:14 +0300303 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
304
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300305 nfs4_state_shutdown_net(net);
Kinglong Mee8ef66712013-12-31 13:17:30 +0800306 if (nn->lockd_up) {
307 lockd_down(net);
308 nn->lockd_up = 0;
309 }
Stanislav Kinsbursky2c2fe292012-12-06 14:23:14 +0300310 nn->nfsd_net_up = false;
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300311 nfsd_shutdown_generic();
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300312}
313
Scott Mayhew36684992015-12-11 16:45:59 -0500314static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event,
315 void *ptr)
316{
317 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
318 struct net_device *dev = ifa->ifa_dev->dev;
319 struct net *net = dev_net(dev);
320 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
321 struct sockaddr_in sin;
322
323 if (event != NETDEV_DOWN)
324 goto out;
325
326 if (nn->nfsd_serv) {
327 dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local);
328 sin.sin_family = AF_INET;
329 sin.sin_addr.s_addr = ifa->ifa_local;
330 svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin);
331 }
332
333out:
334 return NOTIFY_DONE;
335}
336
337static struct notifier_block nfsd_inetaddr_notifier = {
338 .notifier_call = nfsd_inetaddr_event,
339};
340
341#if IS_ENABLED(CONFIG_IPV6)
342static int nfsd_inet6addr_event(struct notifier_block *this,
343 unsigned long event, void *ptr)
344{
345 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
346 struct net_device *dev = ifa->idev->dev;
347 struct net *net = dev_net(dev);
348 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
349 struct sockaddr_in6 sin6;
350
351 if (event != NETDEV_DOWN)
352 goto out;
353
354 if (nn->nfsd_serv) {
355 dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr);
356 sin6.sin6_family = AF_INET6;
357 sin6.sin6_addr = ifa->addr;
358 svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6);
359 }
360
361out:
362 return NOTIFY_DONE;
363}
364
365static struct notifier_block nfsd_inet6addr_notifier = {
366 .notifier_call = nfsd_inet6addr_event,
367};
368#endif
369
Vasily Averin1eca45f2016-09-21 15:33:05 +0300370/* Only used under nfsd_mutex, so this atomic may be overkill: */
371static atomic_t nfsd_notifier_refcount = ATOMIC_INIT(0);
372
Stanislav Kinsbursky541e8642012-12-06 14:23:44 +0300373static void nfsd_last_thread(struct svc_serv *serv, struct net *net)
Jeff Layton4ad9a342010-07-19 16:50:04 -0400374{
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300375 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
376
Vasily Averin1eca45f2016-09-21 15:33:05 +0300377 /* check if the notifier still has clients */
378 if (atomic_dec_return(&nfsd_notifier_refcount) == 0) {
379 unregister_inetaddr_notifier(&nfsd_inetaddr_notifier);
Scott Mayhew36684992015-12-11 16:45:59 -0500380#if IS_ENABLED(CONFIG_IPV6)
Vasily Averin1eca45f2016-09-21 15:33:05 +0300381 unregister_inet6addr_notifier(&nfsd_inet6addr_notifier);
Scott Mayhew36684992015-12-11 16:45:59 -0500382#endif
Vasily Averin1eca45f2016-09-21 15:33:05 +0300383 }
384
Jeff Layton4ad9a342010-07-19 16:50:04 -0400385 /*
386 * write_ports can create the server without actually starting
387 * any threads--if we get shut down before any threads are
388 * started, then nfsd_last_thread will be run before any of this
Kinglong Mee691412b2016-01-04 11:15:21 +0800389 * other initialization has been done except the rpcb information.
Jeff Layton4ad9a342010-07-19 16:50:04 -0400390 */
Kinglong Mee691412b2016-01-04 11:15:21 +0800391 svc_rpcb_cleanup(serv, net);
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300392 if (!nn->nfsd_net_up)
Jeff Layton4ad9a342010-07-19 16:50:04 -0400393 return;
Kinglong Mee691412b2016-01-04 11:15:21 +0800394
Stanislav Kinsbursky6ff50b32012-12-06 14:23:09 +0300395 nfsd_shutdown_net(net);
Jeff Laytone096bbc2008-06-10 08:40:37 -0400396 printk(KERN_WARNING "nfsd: last server has exited, flushing export "
397 "cache\n");
Stanislav Kinsburskyb3853e02012-04-11 15:13:21 +0400398 nfsd_export_flush(net);
NeilBrownbc591cc2006-10-02 02:17:44 -0700399}
NeilBrown6658d3a2006-10-02 02:17:46 -0700400
401void nfsd_reset_versions(void)
402{
NeilBrown6658d3a2006-10-02 02:17:46 -0700403 int i;
404
NeilBrown817f60c2017-03-10 11:36:39 +1100405 for (i = 0; i < NFSD_NRVERS; i++)
406 if (nfsd_vers(i, NFSD_TEST))
407 return;
NeilBrown6658d3a2006-10-02 02:17:46 -0700408
NeilBrown817f60c2017-03-10 11:36:39 +1100409 for (i = 0; i < NFSD_NRVERS; i++)
410 if (i != 4)
411 nfsd_vers(i, NFSD_SET);
412 else {
413 int minor = 0;
414 while (nfsd_minorversion(minor, NFSD_SET) >= 0)
415 minor++;
416 }
NeilBrown6658d3a2006-10-02 02:17:46 -0700417}
418
Andy Adamsonc3d06f92009-04-03 08:28:18 +0300419/*
420 * Each session guarantees a negotiated per slot memory cache for replies
421 * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated
422 * NFSv4.1 server might want to use more memory for a DRC than a machine
423 * with mutiple services.
424 *
425 * Impose a hard limit on the number of pages for the DRC which varies
426 * according to the machines free pages. This is of course only a default.
427 *
428 * For now this is a #defined shift which could be under admin control
429 * in the future.
430 */
431static void set_max_drc(void)
432{
Andy Adamson6a14dd12009-07-27 19:06:45 -0400433 #define NFSD_DRC_SIZE_SHIFT 10
Andy Adamson0c193052009-07-27 19:09:19 -0400434 nfsd_drc_max_mem = (nr_free_buffer_pages()
435 >> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE;
436 nfsd_drc_mem_used = 0;
Andy Adamson4bd9b0f42009-06-24 15:37:45 -0400437 spin_lock_init(&nfsd_drc_lock);
Zhang Yanfei697ce9b2013-02-22 16:35:47 -0800438 dprintk("%s nfsd_drc_max_mem %lu \n", __func__, nfsd_drc_max_mem);
Andy Adamsonc3d06f92009-04-03 08:28:18 +0300439}
Neil Brownbedbdd82008-06-10 08:40:35 -0400440
J. Bruce Fields87b0fc72012-01-30 16:18:35 -0500441static int nfsd_get_default_max_blksize(void)
442{
443 struct sysinfo i;
444 unsigned long long target;
445 unsigned long ret;
446
447 si_meminfo(&i);
J. Bruce Fields508f9222012-01-30 16:21:11 -0500448 target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
J. Bruce Fields87b0fc72012-01-30 16:18:35 -0500449 /*
450 * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
451 * machines, but only uses 32K on 128M machines. Bottom out at
452 * 8K on 32M and smaller. Of course, this is only a default.
453 */
454 target >>= 12;
455
456 ret = NFSSVC_MAXBLKSIZE;
457 while (ret > target && ret >= 8*1024*2)
458 ret /= 2;
459 return ret;
460}
461
Jeff Laytonb9e13cd2015-06-08 12:06:51 -0700462static struct svc_serv_ops nfsd_thread_sv_ops = {
463 .svo_shutdown = nfsd_last_thread,
464 .svo_function = nfsd,
465 .svo_enqueue_xprt = svc_xprt_do_enqueue,
Jeff Layton598e2352015-06-08 12:08:33 -0700466 .svo_setup = svc_set_num_threads,
Jeff Laytonb9e13cd2015-06-08 12:06:51 -0700467 .svo_module = THIS_MODULE,
Jeff Laytonea126e72015-06-08 12:03:32 -0700468};
469
Stanislav Kinsbursky67774362012-12-10 12:19:20 +0300470int nfsd_create_serv(struct net *net)
NeilBrown02a375f2006-10-02 02:17:46 -0700471{
Stanislav Kinsbursky9793f7c2012-05-02 16:08:38 +0400472 int error;
Stanislav Kinsburskyb9c0ef82012-12-06 14:23:19 +0300473 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Stanislav Kinsbursky9793f7c2012-05-02 16:08:38 +0400474
Neil Brownbedbdd82008-06-10 08:40:35 -0400475 WARN_ON(!mutex_is_locked(&nfsd_mutex));
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300476 if (nn->nfsd_serv) {
477 svc_get(nn->nfsd_serv);
NeilBrown02a375f2006-10-02 02:17:46 -0700478 return 0;
479 }
J. Bruce Fields87b0fc72012-01-30 16:18:35 -0500480 if (nfsd_max_blksize == 0)
481 nfsd_max_blksize = nfsd_get_default_max_blksize();
J. Bruce Fieldse844a7b2010-08-06 15:48:03 -0400482 nfsd_reset_versions();
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300483 nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
Jeff Laytonb9e13cd2015-06-08 12:06:51 -0700484 &nfsd_thread_sv_ops);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300485 if (nn->nfsd_serv == NULL)
Jeff Layton628b3682010-07-21 16:40:08 -0400486 return -ENOMEM;
Neil Brownbedbdd82008-06-10 08:40:35 -0400487
Jeff Layton5b8db002014-07-02 16:11:22 -0400488 nn->nfsd_serv->sv_maxconn = nn->max_connections;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300489 error = svc_bind(nn->nfsd_serv, net);
Stanislav Kinsbursky9793f7c2012-05-02 16:08:38 +0400490 if (error < 0) {
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300491 svc_destroy(nn->nfsd_serv);
Stanislav Kinsbursky9793f7c2012-05-02 16:08:38 +0400492 return error;
493 }
494
Jeff Layton628b3682010-07-21 16:40:08 -0400495 set_max_drc();
Vasily Averin1eca45f2016-09-21 15:33:05 +0300496 /* check if the notifier is already set */
497 if (atomic_inc_return(&nfsd_notifier_refcount) == 1) {
498 register_inetaddr_notifier(&nfsd_inetaddr_notifier);
Scott Mayhew36684992015-12-11 16:45:59 -0500499#if IS_ENABLED(CONFIG_IPV6)
Vasily Averin1eca45f2016-09-21 15:33:05 +0300500 register_inet6addr_notifier(&nfsd_inet6addr_notifier);
Scott Mayhew36684992015-12-11 16:45:59 -0500501#endif
Vasily Averin1eca45f2016-09-21 15:33:05 +0300502 }
Stanislav Kinsburskyb9c0ef82012-12-06 14:23:19 +0300503 do_gettimeofday(&nn->nfssvc_boot); /* record boot time */
J. Bruce Fields87b0fc72012-01-30 16:18:35 -0500504 return 0;
NeilBrown02a375f2006-10-02 02:17:46 -0700505}
506
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300507int nfsd_nrpools(struct net *net)
Greg Bankseed29652006-10-02 02:18:02 -0700508{
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300509 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
510
511 if (nn->nfsd_serv == NULL)
Greg Bankseed29652006-10-02 02:18:02 -0700512 return 0;
513 else
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300514 return nn->nfsd_serv->sv_nrpools;
Greg Bankseed29652006-10-02 02:18:02 -0700515}
516
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300517int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
Greg Bankseed29652006-10-02 02:18:02 -0700518{
519 int i = 0;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300520 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Greg Bankseed29652006-10-02 02:18:02 -0700521
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300522 if (nn->nfsd_serv != NULL) {
523 for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++)
524 nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads;
Greg Bankseed29652006-10-02 02:18:02 -0700525 }
526
527 return 0;
528}
529
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300530void nfsd_destroy(struct net *net)
531{
532 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
533 int destroy = (nn->nfsd_serv->sv_nrthreads == 1);
534
535 if (destroy)
536 svc_shutdown_net(nn->nfsd_serv, net);
537 svc_destroy(nn->nfsd_serv);
538 if (destroy)
539 nn->nfsd_serv = NULL;
540}
541
Stanislav Kinsbursky3938a0d2012-12-10 12:19:30 +0300542int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
Greg Bankseed29652006-10-02 02:18:02 -0700543{
544 int i = 0;
545 int tot = 0;
546 int err = 0;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300547 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Greg Bankseed29652006-10-02 02:18:02 -0700548
Neil Brownbedbdd82008-06-10 08:40:35 -0400549 WARN_ON(!mutex_is_locked(&nfsd_mutex));
550
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300551 if (nn->nfsd_serv == NULL || n <= 0)
Greg Bankseed29652006-10-02 02:18:02 -0700552 return 0;
553
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300554 if (n > nn->nfsd_serv->sv_nrpools)
555 n = nn->nfsd_serv->sv_nrpools;
Greg Bankseed29652006-10-02 02:18:02 -0700556
557 /* enforce a global maximum number of threads */
558 tot = 0;
559 for (i = 0; i < n; i++) {
Kinglong Mee3c7aa152014-06-10 18:08:19 +0800560 nthreads[i] = min(nthreads[i], NFSD_MAXSERVS);
Greg Bankseed29652006-10-02 02:18:02 -0700561 tot += nthreads[i];
562 }
563 if (tot > NFSD_MAXSERVS) {
564 /* total too large: scale down requested numbers */
565 for (i = 0; i < n && tot > 0; i++) {
566 int new = nthreads[i] * NFSD_MAXSERVS / tot;
567 tot -= (nthreads[i] - new);
568 nthreads[i] = new;
569 }
570 for (i = 0; i < n && tot > 0; i++) {
571 nthreads[i]--;
572 tot--;
573 }
574 }
575
576 /*
577 * There must always be a thread in pool 0; the admin
578 * can't shut down NFS completely using pool_threads.
579 */
580 if (nthreads[0] == 0)
581 nthreads[0] = 1;
582
583 /* apply the new numbers */
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300584 svc_get(nn->nfsd_serv);
Greg Bankseed29652006-10-02 02:18:02 -0700585 for (i = 0; i < n; i++) {
Jeff Layton598e2352015-06-08 12:08:33 -0700586 err = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
587 &nn->nfsd_serv->sv_pools[i], nthreads[i]);
Greg Bankseed29652006-10-02 02:18:02 -0700588 if (err)
589 break;
590 }
Stanislav Kinsbursky19f7e2c2012-07-03 16:46:41 +0400591 nfsd_destroy(net);
Greg Bankseed29652006-10-02 02:18:02 -0700592 return err;
593}
594
Jeff Laytonac77efb2010-07-20 14:10:22 -0400595/*
596 * Adjust the number of threads and return the new number of threads.
597 * This is also the function that starts the server if necessary, if
598 * this is the first time nrservs is nonzero.
599 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600int
Stanislav Kinsburskyd41a9412012-12-10 12:19:25 +0300601nfsd_svc(int nrservs, struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 int error;
J. Bruce Fields774f8bb2010-08-02 14:12:44 -0400604 bool nfsd_up_before;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300605 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
Neil Brownbedbdd82008-06-10 08:40:35 -0400606
607 mutex_lock(&nfsd_mutex);
NeilBrown6658d3a2006-10-02 02:17:46 -0700608 dprintk("nfsd: creating service\n");
Kinglong Mee3c7aa152014-06-10 18:08:19 +0800609
610 nrservs = max(nrservs, 0);
611 nrservs = min(nrservs, NFSD_MAXSERVS);
NeilBrown671e1fc2009-06-16 11:03:20 +1000612 error = 0;
Kinglong Mee3c7aa152014-06-10 18:08:19 +0800613
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300614 if (nrservs == 0 && nn->nfsd_serv == NULL)
NeilBrown671e1fc2009-06-16 11:03:20 +1000615 goto out;
616
Stanislav Kinsbursky67774362012-12-10 12:19:20 +0300617 error = nfsd_create_serv(net);
NeilBrown02a375f2006-10-02 02:17:46 -0700618 if (error)
J. Bruce Fields774f8bb2010-08-02 14:12:44 -0400619 goto out;
620
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300621 nfsd_up_before = nn->nfsd_net_up;
J. Bruce Fields774f8bb2010-08-02 14:12:44 -0400622
Stanislav Kinsbursky903d9bf2012-12-06 14:23:34 +0300623 error = nfsd_startup_net(nrservs, net);
J. Bruce Fieldsaf4718f2010-07-21 18:31:42 -0400624 if (error)
625 goto out_destroy;
Jeff Layton598e2352015-06-08 12:08:33 -0700626 error = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,
627 NULL, nrservs);
J. Bruce Fields774f8bb2010-08-02 14:12:44 -0400628 if (error)
629 goto out_shutdown;
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300630 /* We are holding a reference to nn->nfsd_serv which
J. Bruce Fieldsaf4718f2010-07-21 18:31:42 -0400631 * we don't want to count in the return value,
632 * so subtract 1
633 */
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300634 error = nn->nfsd_serv->sv_nrthreads - 1;
J. Bruce Fields774f8bb2010-08-02 14:12:44 -0400635out_shutdown:
636 if (error < 0 && !nfsd_up_before)
Stanislav Kinsbursky541e8642012-12-06 14:23:44 +0300637 nfsd_shutdown_net(net);
Jeff Layton4ad9a342010-07-19 16:50:04 -0400638out_destroy:
Stanislav Kinsbursky19f7e2c2012-07-03 16:46:41 +0400639 nfsd_destroy(net); /* Release server */
Jeff Layton4ad9a342010-07-19 16:50:04 -0400640out:
Neil Brownbedbdd82008-06-10 08:40:35 -0400641 mutex_unlock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return error;
643}
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646/*
647 * This is the NFS server kernel thread
648 */
Jeff Layton9867d762008-06-10 08:40:38 -0400649static int
650nfsd(void *vrqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651{
Jeff Layton9867d762008-06-10 08:40:38 -0400652 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
Stanislav Kinsbursky88c47662012-12-06 18:34:42 +0300653 struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
654 struct net *net = perm_sock->xpt_net;
Jeff Layton5b8db002014-07-02 16:11:22 -0400655 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
J. Bruce Fields5b444cc2012-08-17 21:47:53 -0400656 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 /* Lock module and set up kernel thread */
Neil Brownbedbdd82008-06-10 08:40:35 -0400659 mutex_lock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Jeff Layton9867d762008-06-10 08:40:38 -0400661 /* At this point, the thread shares current->fs
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 * with the init process. We need to create files with a
663 * umask of 0 instead of init's umask. */
Al Viro3e93cd62009-03-29 19:00:13 -0400664 if (unshare_fs_struct() < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 printk("Unable to start nfsd thread: out of memory\n");
666 goto out;
667 }
Al Viro3e93cd62009-03-29 19:00:13 -0400668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 current->fs->umask = 0;
670
Jeff Layton9867d762008-06-10 08:40:38 -0400671 /*
672 * thread is spawned with all signals set to SIG_IGN, re-enable
Jeff Layton100766f2008-06-30 14:09:46 -0400673 * the ones that will bring down the thread
Jeff Layton9867d762008-06-10 08:40:38 -0400674 */
Jeff Layton100766f2008-06-30 14:09:46 -0400675 allow_signal(SIGKILL);
676 allow_signal(SIGHUP);
677 allow_signal(SIGINT);
678 allow_signal(SIGQUIT);
Neil Brownbedbdd82008-06-10 08:40:35 -0400679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 nfsdstats.th_cnt++;
Neil Brownbedbdd82008-06-10 08:40:35 -0400681 mutex_unlock(&nfsd_mutex);
682
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700683 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
685 /*
686 * The main request loop
687 */
688 for (;;) {
Jeff Layton5b8db002014-07-02 16:11:22 -0400689 /* Update sv_maxconn if it has changed */
690 rqstp->rq_server->sv_maxconn = nn->max_connections;
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 /*
693 * Find a socket with data available and call its
694 * recvfrom routine.
695 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700696 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 ;
Jeff Layton9867d762008-06-10 08:40:38 -0400698 if (err == -EINTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 break;
David Howellse0e81732009-09-02 09:13:40 +0100700 validate_process_creds();
NeilBrown6fb2b472006-10-02 02:17:50 -0700701 svc_process(rqstp);
David Howellse0e81732009-09-02 09:13:40 +0100702 validate_process_creds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 }
704
NeilBrown24e36662006-10-02 02:17:45 -0700705 /* Clear signals before calling svc_exit_thread() */
NeilBrown9e4160522005-04-16 15:26:37 -0700706 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Neil Brownbedbdd82008-06-10 08:40:35 -0400708 mutex_lock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 nfsdstats.th_cnt --;
710
711out:
Stanislav Kinsbursky57c8b13e2012-07-03 16:46:41 +0400712 rqstp->rq_server = NULL;
Stanislav Kinsbursky786185b2012-05-04 12:49:41 +0400713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 /* Release the thread */
715 svc_exit_thread(rqstp);
716
Stanislav Kinsbursky88c47662012-12-06 18:34:42 +0300717 nfsd_destroy(net);
Stanislav Kinsbursky57c8b13e2012-07-03 16:46:41 +0400718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 /* Release module */
Neil Brownbedbdd82008-06-10 08:40:35 -0400720 mutex_unlock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 module_put_and_exit(0);
Jeff Layton9867d762008-06-10 08:40:38 -0400722 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723}
724
Andy Adamson32c1eb02007-07-17 04:04:48 -0700725static __be32 map_new_errors(u32 vers, __be32 nfserr)
726{
727 if (nfserr == nfserr_jukebox && vers == 2)
728 return nfserr_dropit;
729 if (nfserr == nfserr_wrongsec && vers < 4)
730 return nfserr_acces;
731 return nfserr;
732}
733
J. Bruce Fieldsfc6445d2017-04-21 16:10:18 -0400734/*
735 * A write procedure can have a large argument, and a read procedure can
736 * have a large reply, but no NFSv2 or NFSv3 procedure has argument and
737 * reply that can both be larger than a page. The xdr code has taken
738 * advantage of this assumption to be a sloppy about bounds checking in
739 * some cases. Pending a rewrite of the NFSv2/v3 xdr code to fix that
740 * problem, we enforce these assumptions here:
741 */
742static bool nfs_request_too_big(struct svc_rqst *rqstp,
743 struct svc_procedure *proc)
744{
745 /*
746 * The ACL code has more careful bounds-checking and is not
747 * susceptible to this problem:
748 */
749 if (rqstp->rq_prog != NFS_PROGRAM)
750 return false;
751 /*
752 * Ditto NFSv4 (which can in theory have argument and reply both
753 * more than a page):
754 */
755 if (rqstp->rq_vers >= 4)
756 return false;
757 /* The reply will be small, we're OK: */
758 if (proc->pc_xdrressize > 0 &&
759 proc->pc_xdrressize < XDR_QUADLEN(PAGE_SIZE))
760 return false;
761
762 return rqstp->rq_arg.len > PAGE_SIZE;
763}
764
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765int
Al Viroc7afef12006-10-19 23:29:02 -0700766nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767{
768 struct svc_procedure *proc;
769 kxdrproc_t xdr;
Al Viroad451d32006-10-19 23:28:55 -0700770 __be32 nfserr;
771 __be32 *nfserrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
773 dprintk("nfsd_dispatch: vers %d proc %d\n",
774 rqstp->rq_vers, rqstp->rq_proc);
775 proc = rqstp->rq_procinfo;
776
J. Bruce Fieldsfc6445d2017-04-21 16:10:18 -0400777 if (nfs_request_too_big(rqstp, proc)) {
778 dprintk("nfsd: NFSv%d argument too large\n", rqstp->rq_vers);
779 *statp = rpc_garbage_args;
780 return 1;
781 }
J. Bruce Fields10910062011-01-24 12:11:02 -0500782 /*
783 * Give the xdr decoder a chance to change this if it wants
784 * (necessary in the NFSv4.0 compound case)
785 */
786 rqstp->rq_cachetype = proc->pc_cachetype;
787 /* Decode arguments */
788 xdr = proc->pc_decode;
789 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
790 rqstp->rq_argp)) {
791 dprintk("nfsd: failed to decode arguments!\n");
792 *statp = rpc_garbage_args;
793 return 1;
794 }
795
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 /* Check whether we have this call in the cache. */
J. Bruce Fields10910062011-01-24 12:11:02 -0500797 switch (nfsd_cache_lookup(rqstp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 case RC_DROPIT:
799 return 0;
800 case RC_REPLY:
801 return 1;
802 case RC_DOIT:;
803 /* do it */
804 }
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 /* need to grab the location to store the status, as
807 * nfsv4 does some encoding while processing
808 */
809 nfserrp = rqstp->rq_res.head[0].iov_base
810 + rqstp->rq_res.head[0].iov_len;
Al Viroad451d32006-10-19 23:28:55 -0700811 rqstp->rq_res.head[0].iov_len += sizeof(__be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812
813 /* Now call the procedure handler, and encode NFS status. */
814 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
Andy Adamson32c1eb02007-07-17 04:04:48 -0700815 nfserr = map_new_errors(rqstp->rq_vers, nfserr);
Jeff Layton78b65eb2014-11-19 07:51:17 -0500816 if (nfserr == nfserr_dropit || test_bit(RQ_DROPME, &rqstp->rq_flags)) {
J. Bruce Fields45457e02007-06-22 17:26:32 -0400817 dprintk("nfsd: Dropping request; may be revisited later\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
819 return 0;
820 }
821
822 if (rqstp->rq_proc != 0)
823 *nfserrp++ = nfserr;
824
825 /* Encode result.
826 * For NFSv2, additional info is never returned in case of an error.
827 */
828 if (!(nfserr && rqstp->rq_vers == 2)) {
829 xdr = proc->pc_encode;
830 if (xdr && !xdr(rqstp, nfserrp,
831 rqstp->rq_resp)) {
832 /* Failed to encode result. Release cache entry */
833 dprintk("nfsd: failed to encode result!\n");
834 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
835 *statp = rpc_system_err;
836 return 1;
837 }
838 }
839
840 /* Store reply in cache. */
J. Bruce Fields57d276d2012-11-16 15:22:43 -0500841 nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return 1;
843}
Greg Banks03cf6c92009-01-13 21:26:36 +1100844
845int nfsd_pool_stats_open(struct inode *inode, struct file *file)
846{
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900847 int ret;
Stanislav Kinsbursky11f77942013-02-01 15:56:12 +0300848 struct nfsd_net *nn = net_generic(inode->i_sb->s_fs_info, nfsd_net_id);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300849
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900850 mutex_lock(&nfsd_mutex);
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300851 if (nn->nfsd_serv == NULL) {
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900852 mutex_unlock(&nfsd_mutex);
Greg Banks03cf6c92009-01-13 21:26:36 +1100853 return -ENODEV;
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900854 }
855 /* bump up the psudo refcount while traversing */
Stanislav Kinsbursky9dd98452012-12-06 14:23:24 +0300856 svc_get(nn->nfsd_serv);
857 ret = svc_pool_stats_open(nn->nfsd_serv, file);
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900858 mutex_unlock(&nfsd_mutex);
859 return ret;
860}
861
862int nfsd_pool_stats_release(struct inode *inode, struct file *file)
863{
864 int ret = seq_release(inode, file);
Stanislav Kinsbursky11f77942013-02-01 15:56:12 +0300865 struct net *net = inode->i_sb->s_fs_info;
Stanislav Kinsbursky786185b2012-05-04 12:49:41 +0400866
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900867 mutex_lock(&nfsd_mutex);
868 /* this function really, really should have been called svc_put() */
Stanislav Kinsbursky19f7e2c2012-07-03 16:46:41 +0400869 nfsd_destroy(net);
Ryusei Yamaguchied2d8ae2009-08-16 00:54:41 +0900870 mutex_unlock(&nfsd_mutex);
871 return ret;
Greg Banks03cf6c92009-01-13 21:26:36 +1100872}