blob: 492c79b7800b5b7fcb4f8a8813b2d369a5039d7a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfsd/nfssvc.c
3 *
4 * Central processing for nfsd.
5 *
6 * Authors: Olaf Kirch (okir@monad.swb.de)
7 *
8 * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
9 */
10
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/module.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040012#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/time.h>
14#include <linux/errno.h>
15#include <linux/nfs.h>
16#include <linux/in.h>
17#include <linux/uio.h>
18#include <linux/unistd.h>
19#include <linux/slab.h>
20#include <linux/smp.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070021#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/fs_struct.h>
Jeff Layton9867d762008-06-10 08:40:38 -040023#include <linux/kthread.h>
Andy Adamsonc3d06f92009-04-03 08:28:18 +030024#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include <linux/sunrpc/types.h>
27#include <linux/sunrpc/stats.h>
28#include <linux/sunrpc/svc.h>
29#include <linux/sunrpc/svcsock.h>
30#include <linux/sunrpc/cache.h>
31#include <linux/nfsd/nfsd.h>
32#include <linux/nfsd/stats.h>
33#include <linux/nfsd/cache.h>
NeilBrown70c3b762005-11-07 01:00:25 -080034#include <linux/nfsd/syscall.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/lockd/bind.h>
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +000036#include <linux/nfsacl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#define NFSDDBG_FACILITY NFSDDBG_SVC
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040extern struct svc_program nfsd_program;
Jeff Layton9867d762008-06-10 08:40:38 -040041static int nfsd(void *vrqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042struct timeval nfssvc_boot;
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Neil Brownbedbdd82008-06-10 08:40:35 -040044/*
45 * nfsd_mutex protects nfsd_serv -- both the pointer itself and the members
46 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some
47 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
48 *
49 * If (out side the lock) nfsd_serv is non-NULL, then it must point to a
50 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
51 * of nfsd threads must exist and each must listed in ->sp_all_threads in each
52 * entry of ->sv_pools[].
53 *
54 * Transitions of the thread count between zero and non-zero are of particular
55 * interest since the svc_serv needs to be created and initialized at that
56 * point, or freed.
Jeff Layton3dd98a32008-06-10 08:40:36 -040057 *
58 * Finally, the nfsd_mutex also protects some of the global variables that are
59 * accessed when nfsd starts and that are settable via the write_* routines in
60 * nfsctl.c. In particular:
61 *
62 * user_recovery_dirname
63 * user_lease_time
64 * nfsd_versions
Neil Brownbedbdd82008-06-10 08:40:35 -040065 */
66DEFINE_MUTEX(nfsd_mutex);
67struct svc_serv *nfsd_serv;
68
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
Benny Halevy8daf2202009-04-03 08:28:59 +0300123u32 nfsd_supported_minorversion;
124
NeilBrown6658d3a2006-10-02 02:17:46 -0700125int nfsd_vers(int vers, enum vers_op change)
126{
127 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
128 return -1;
129 switch(change) {
130 case NFSD_SET:
131 nfsd_versions[vers] = nfsd_version[vers];
NeilBrown6658d3a2006-10-02 02:17:46 -0700132#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
133 if (vers < NFSD_ACL_NRVERS)
NeilBrown1a8eff62007-01-26 00:56:58 -0800134 nfsd_acl_versions[vers] = nfsd_acl_version[vers];
NeilBrown6658d3a2006-10-02 02:17:46 -0700135#endif
NeilBrown1a8eff62007-01-26 00:56:58 -0800136 break;
NeilBrown6658d3a2006-10-02 02:17:46 -0700137 case NFSD_CLEAR:
138 nfsd_versions[vers] = NULL;
139#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
140 if (vers < NFSD_ACL_NRVERS)
NeilBrown1a8eff62007-01-26 00:56:58 -0800141 nfsd_acl_versions[vers] = NULL;
NeilBrown6658d3a2006-10-02 02:17:46 -0700142#endif
143 break;
144 case NFSD_TEST:
145 return nfsd_versions[vers] != NULL;
146 case NFSD_AVAIL:
147 return nfsd_version[vers] != NULL;
148 }
149 return 0;
150}
Benny Halevy8daf2202009-04-03 08:28:59 +0300151
152int nfsd_minorversion(u32 minorversion, enum vers_op change)
153{
154 if (minorversion > NFSD_SUPPORTED_MINOR_VERSION)
155 return -1;
156 switch(change) {
157 case NFSD_SET:
158 nfsd_supported_minorversion = minorversion;
159 break;
160 case NFSD_CLEAR:
161 if (minorversion == 0)
162 return -1;
163 nfsd_supported_minorversion = minorversion - 1;
164 break;
165 case NFSD_TEST:
166 return minorversion <= nfsd_supported_minorversion;
167 case NFSD_AVAIL:
168 return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
169 }
170 return 0;
171}
172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/*
174 * Maximum number of nfsd processes
175 */
176#define NFSD_MAXSERVS 8192
177
178int nfsd_nrthreads(void)
179{
Neil Brownc7d106c2008-06-12 13:38:42 +1000180 int rv = 0;
181 mutex_lock(&nfsd_mutex);
182 if (nfsd_serv)
183 rv = nfsd_serv->sv_nrthreads;
184 mutex_unlock(&nfsd_mutex);
185 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186}
187
NeilBrownbc591cc2006-10-02 02:17:44 -0700188static void nfsd_last_thread(struct svc_serv *serv)
189{
190 /* When last nfsd thread exits we need to do some clean-up */
Tom Tucker7a182082007-12-30 21:07:53 -0600191 struct svc_xprt *xprt;
192 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list)
NeilBrown24e36662006-10-02 02:17:45 -0700193 lockd_down();
NeilBrownbc591cc2006-10-02 02:17:44 -0700194 nfsd_serv = NULL;
195 nfsd_racache_shutdown();
196 nfs4_state_shutdown();
197
Jeff Laytone096bbc2008-06-10 08:40:37 -0400198 printk(KERN_WARNING "nfsd: last server has exited, flushing export "
199 "cache\n");
200 nfsd_export_flush();
NeilBrownbc591cc2006-10-02 02:17:44 -0700201}
NeilBrown6658d3a2006-10-02 02:17:46 -0700202
203void nfsd_reset_versions(void)
204{
205 int found_one = 0;
206 int i;
207
208 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
209 if (nfsd_program.pg_vers[i])
210 found_one = 1;
211 }
212
213 if (!found_one) {
214 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
215 nfsd_program.pg_vers[i] = nfsd_version[i];
216#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
217 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
218 nfsd_acl_program.pg_vers[i] =
219 nfsd_acl_version[i];
220#endif
221 }
222}
223
Andy Adamsonc3d06f92009-04-03 08:28:18 +0300224/*
225 * Each session guarantees a negotiated per slot memory cache for replies
226 * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated
227 * NFSv4.1 server might want to use more memory for a DRC than a machine
228 * with mutiple services.
229 *
230 * Impose a hard limit on the number of pages for the DRC which varies
231 * according to the machines free pages. This is of course only a default.
232 *
233 * For now this is a #defined shift which could be under admin control
234 * in the future.
235 */
236static void set_max_drc(void)
237{
Benny Halevyf0ad6702009-04-06 12:00:36 +0300238 /* The percent of nr_free_buffer_pages used by the V4.1 server DRC */
239 #define NFSD_DRC_SIZE_SHIFT 7
Andy Adamsonc3d06f92009-04-03 08:28:18 +0300240 nfsd_serv->sv_drc_max_pages = nr_free_buffer_pages()
241 >> NFSD_DRC_SIZE_SHIFT;
242 nfsd_serv->sv_drc_pages_used = 0;
243 dprintk("%s svc_drc_max_pages %u\n", __func__,
244 nfsd_serv->sv_drc_max_pages);
245}
Neil Brownbedbdd82008-06-10 08:40:35 -0400246
NeilBrownb41b66d2006-10-02 02:17:48 -0700247int nfsd_create_serv(void)
NeilBrown02a375f2006-10-02 02:17:46 -0700248{
249 int err = 0;
Neil Brownbedbdd82008-06-10 08:40:35 -0400250
251 WARN_ON(!mutex_is_locked(&nfsd_mutex));
NeilBrown02a375f2006-10-02 02:17:46 -0700252 if (nfsd_serv) {
Greg Banks9a24ab52006-10-02 02:17:58 -0700253 svc_get(nfsd_serv);
NeilBrown02a375f2006-10-02 02:17:46 -0700254 return 0;
255 }
NeilBrown596bbe52006-10-04 02:15:48 -0700256 if (nfsd_max_blksize == 0) {
257 /* choose a suitable default */
258 struct sysinfo i;
259 si_meminfo(&i);
260 /* Aim for 1/4096 of memory per thread
261 * This gives 1MB on 4Gig machines
262 * But only uses 32K on 128M machines.
263 * Bottom out at 8K on 32M and smaller.
264 * Of course, this is only a default.
265 */
266 nfsd_max_blksize = NFSSVC_MAXBLKSIZE;
NeilBrown44c55602006-10-04 02:16:15 -0700267 i.totalram <<= PAGE_SHIFT - 12;
NeilBrown596bbe52006-10-04 02:15:48 -0700268 while (nfsd_max_blksize > i.totalram &&
269 nfsd_max_blksize >= 8*1024*2)
270 nfsd_max_blksize /= 2;
271 }
NeilBrown02a375f2006-10-02 02:17:46 -0700272
Jeff Laytone096bbc2008-06-10 08:40:37 -0400273 nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
Jeff Laytona75c5d02008-06-10 08:40:39 -0400274 nfsd_last_thread, nfsd, THIS_MODULE);
NeilBrown02a375f2006-10-02 02:17:46 -0700275 if (nfsd_serv == NULL)
276 err = -ENOMEM;
Andy Adamsonc3d06f92009-04-03 08:28:18 +0300277 else
278 set_max_drc();
Neil Brownbedbdd82008-06-10 08:40:35 -0400279
NeilBrown02a375f2006-10-02 02:17:46 -0700280 do_gettimeofday(&nfssvc_boot); /* record boot time */
281 return err;
282}
283
284static int nfsd_init_socks(int port)
285{
286 int error;
287 if (!list_empty(&nfsd_serv->sv_permsocks))
288 return 0;
289
Chuck Lever9652ada2009-03-18 20:46:21 -0400290 error = svc_create_xprt(nfsd_serv, "udp", PF_INET, port,
Chuck Lever482fb942007-02-12 00:53:29 -0800291 SVC_SOCK_DEFAULTS);
NeilBrown02a375f2006-10-02 02:17:46 -0700292 if (error < 0)
293 return error;
294
Chuck Lever1cd9cd12008-10-22 13:12:36 -0400295 error = lockd_up();
296 if (error < 0)
297 return error;
298
Chuck Lever9652ada2009-03-18 20:46:21 -0400299 error = svc_create_xprt(nfsd_serv, "tcp", PF_INET, port,
Chuck Lever482fb942007-02-12 00:53:29 -0800300 SVC_SOCK_DEFAULTS);
NeilBrown02a375f2006-10-02 02:17:46 -0700301 if (error < 0)
302 return error;
Chuck Lever26a41402008-10-03 17:15:30 -0400303
304 error = lockd_up();
305 if (error < 0)
306 return error;
307
NeilBrown02a375f2006-10-02 02:17:46 -0700308 return 0;
309}
310
Greg Bankseed29652006-10-02 02:18:02 -0700311int nfsd_nrpools(void)
312{
313 if (nfsd_serv == NULL)
314 return 0;
315 else
316 return nfsd_serv->sv_nrpools;
317}
318
319int nfsd_get_nrthreads(int n, int *nthreads)
320{
321 int i = 0;
322
323 if (nfsd_serv != NULL) {
324 for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
325 nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
326 }
327
328 return 0;
329}
330
331int nfsd_set_nrthreads(int n, int *nthreads)
332{
333 int i = 0;
334 int tot = 0;
335 int err = 0;
336
Neil Brownbedbdd82008-06-10 08:40:35 -0400337 WARN_ON(!mutex_is_locked(&nfsd_mutex));
338
Greg Bankseed29652006-10-02 02:18:02 -0700339 if (nfsd_serv == NULL || n <= 0)
340 return 0;
341
342 if (n > nfsd_serv->sv_nrpools)
343 n = nfsd_serv->sv_nrpools;
344
345 /* enforce a global maximum number of threads */
346 tot = 0;
347 for (i = 0; i < n; i++) {
348 if (nthreads[i] > NFSD_MAXSERVS)
349 nthreads[i] = NFSD_MAXSERVS;
350 tot += nthreads[i];
351 }
352 if (tot > NFSD_MAXSERVS) {
353 /* total too large: scale down requested numbers */
354 for (i = 0; i < n && tot > 0; i++) {
355 int new = nthreads[i] * NFSD_MAXSERVS / tot;
356 tot -= (nthreads[i] - new);
357 nthreads[i] = new;
358 }
359 for (i = 0; i < n && tot > 0; i++) {
360 nthreads[i]--;
361 tot--;
362 }
363 }
364
365 /*
366 * There must always be a thread in pool 0; the admin
367 * can't shut down NFS completely using pool_threads.
368 */
369 if (nthreads[0] == 0)
370 nthreads[0] = 1;
371
372 /* apply the new numbers */
Greg Bankseed29652006-10-02 02:18:02 -0700373 svc_get(nfsd_serv);
374 for (i = 0; i < n; i++) {
375 err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
376 nthreads[i]);
377 if (err)
378 break;
379 }
380 svc_destroy(nfsd_serv);
Greg Bankseed29652006-10-02 02:18:02 -0700381
382 return err;
383}
384
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385int
386nfsd_svc(unsigned short port, int nrservs)
387{
388 int error;
Neil Brownbedbdd82008-06-10 08:40:35 -0400389
390 mutex_lock(&nfsd_mutex);
NeilBrown6658d3a2006-10-02 02:17:46 -0700391 dprintk("nfsd: creating service\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if (nrservs <= 0)
393 nrservs = 0;
394 if (nrservs > NFSD_MAXSERVS)
395 nrservs = NFSD_MAXSERVS;
NeilBrown671e1fc2009-06-16 11:03:20 +1000396 error = 0;
397 if (nrservs == 0 && nfsd_serv == NULL)
398 goto out;
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 /* Readahead param cache - will no-op if it already exists */
401 error = nfsd_racache_init(2*nrservs);
402 if (error<0)
403 goto out;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -0400404 nfs4_state_start();
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800405
NeilBrown02a375f2006-10-02 02:17:46 -0700406 nfsd_reset_versions();
407
408 error = nfsd_create_serv();
409
410 if (error)
411 goto out;
412 error = nfsd_init_socks(port);
413 if (error)
414 goto failure;
415
Greg Bankseec09662006-10-02 02:18:00 -0700416 error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
NeilBrown82e12fe2009-06-16 11:03:07 +1000417 if (error == 0)
418 /* We are holding a reference to nfsd_serv which
419 * we don't want to count in the return value,
420 * so subtract 1
421 */
422 error = nfsd_serv->sv_nrthreads - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 failure:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 svc_destroy(nfsd_serv); /* Release server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 out:
Neil Brownbedbdd82008-06-10 08:40:35 -0400426 mutex_unlock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return error;
428}
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431/*
432 * This is the NFS server kernel thread
433 */
Jeff Layton9867d762008-06-10 08:40:38 -0400434static int
435nfsd(void *vrqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
Jeff Layton9867d762008-06-10 08:40:38 -0400437 struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
Jeff Layton9867d762008-06-10 08:40:38 -0400438 int err, preverr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 /* Lock module and set up kernel thread */
Neil Brownbedbdd82008-06-10 08:40:35 -0400441 mutex_lock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Jeff Layton9867d762008-06-10 08:40:38 -0400443 /* At this point, the thread shares current->fs
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 * with the init process. We need to create files with a
445 * umask of 0 instead of init's umask. */
Al Viro3e93cd62009-03-29 19:00:13 -0400446 if (unshare_fs_struct() < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 printk("Unable to start nfsd thread: out of memory\n");
448 goto out;
449 }
Al Viro3e93cd62009-03-29 19:00:13 -0400450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 current->fs->umask = 0;
452
Jeff Layton9867d762008-06-10 08:40:38 -0400453 /*
454 * thread is spawned with all signals set to SIG_IGN, re-enable
Jeff Layton100766f2008-06-30 14:09:46 -0400455 * the ones that will bring down the thread
Jeff Layton9867d762008-06-10 08:40:38 -0400456 */
Jeff Layton100766f2008-06-30 14:09:46 -0400457 allow_signal(SIGKILL);
458 allow_signal(SIGHUP);
459 allow_signal(SIGINT);
460 allow_signal(SIGQUIT);
Neil Brownbedbdd82008-06-10 08:40:35 -0400461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 nfsdstats.th_cnt++;
Neil Brownbedbdd82008-06-10 08:40:35 -0400463 mutex_unlock(&nfsd_mutex);
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 /*
466 * We want less throttling in balance_dirty_pages() so that nfs to
467 * localhost doesn't cause nfsd to lock up due to all the client's
468 * dirty pages.
469 */
470 current->flags |= PF_LESS_THROTTLE;
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700471 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 /*
474 * The main request loop
475 */
476 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /*
478 * Find a socket with data available and call its
479 * recvfrom routine.
480 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700481 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 ;
Jeff Layton9867d762008-06-10 08:40:38 -0400483 if (err == -EINTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 break;
Jeff Layton9867d762008-06-10 08:40:38 -0400485 else if (err < 0) {
486 if (err != preverr) {
487 printk(KERN_WARNING "%s: unexpected error "
488 "from svc_recv (%d)\n", __func__, -err);
489 preverr = err;
490 }
491 schedule_timeout_uninterruptible(HZ);
492 continue;
493 }
494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
496 /* Lock the export hash tables for reading. */
497 exp_readlock();
498
NeilBrown6fb2b472006-10-02 02:17:50 -0700499 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 /* Unlock export hash tables */
502 exp_readunlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 }
504
NeilBrown24e36662006-10-02 02:17:45 -0700505 /* Clear signals before calling svc_exit_thread() */
NeilBrown9e4160522005-04-16 15:26:37 -0700506 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Neil Brownbedbdd82008-06-10 08:40:35 -0400508 mutex_lock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 nfsdstats.th_cnt --;
510
511out:
512 /* Release the thread */
513 svc_exit_thread(rqstp);
514
515 /* Release module */
Neil Brownbedbdd82008-06-10 08:40:35 -0400516 mutex_unlock(&nfsd_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 module_put_and_exit(0);
Jeff Layton9867d762008-06-10 08:40:38 -0400518 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519}
520
Andy Adamson32c1eb02007-07-17 04:04:48 -0700521static __be32 map_new_errors(u32 vers, __be32 nfserr)
522{
523 if (nfserr == nfserr_jukebox && vers == 2)
524 return nfserr_dropit;
525 if (nfserr == nfserr_wrongsec && vers < 4)
526 return nfserr_acces;
527 return nfserr;
528}
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530int
Al Viroc7afef12006-10-19 23:29:02 -0700531nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532{
533 struct svc_procedure *proc;
534 kxdrproc_t xdr;
Al Viroad451d32006-10-19 23:28:55 -0700535 __be32 nfserr;
536 __be32 *nfserrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
538 dprintk("nfsd_dispatch: vers %d proc %d\n",
539 rqstp->rq_vers, rqstp->rq_proc);
540 proc = rqstp->rq_procinfo;
541
542 /* Check whether we have this call in the cache. */
543 switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) {
544 case RC_INTR:
545 case RC_DROPIT:
546 return 0;
547 case RC_REPLY:
548 return 1;
549 case RC_DOIT:;
550 /* do it */
551 }
552
553 /* Decode arguments */
554 xdr = proc->pc_decode;
Al Viroad451d32006-10-19 23:28:55 -0700555 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 rqstp->rq_argp)) {
557 dprintk("nfsd: failed to decode arguments!\n");
558 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
559 *statp = rpc_garbage_args;
560 return 1;
561 }
562
563 /* need to grab the location to store the status, as
564 * nfsv4 does some encoding while processing
565 */
566 nfserrp = rqstp->rq_res.head[0].iov_base
567 + rqstp->rq_res.head[0].iov_len;
Al Viroad451d32006-10-19 23:28:55 -0700568 rqstp->rq_res.head[0].iov_len += sizeof(__be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Andy Adamson074fe892009-04-03 08:28:15 +0300570 /* NFSv4.1 DRC requires statp */
571 if (rqstp->rq_vers == 4)
572 nfsd4_set_statp(rqstp, statp);
573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 /* Now call the procedure handler, and encode NFS status. */
575 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
Andy Adamson32c1eb02007-07-17 04:04:48 -0700576 nfserr = map_new_errors(rqstp->rq_vers, nfserr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 if (nfserr == nfserr_dropit) {
J. Bruce Fields45457e02007-06-22 17:26:32 -0400578 dprintk("nfsd: Dropping request; may be revisited later\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
580 return 0;
581 }
582
583 if (rqstp->rq_proc != 0)
584 *nfserrp++ = nfserr;
585
586 /* Encode result.
587 * For NFSv2, additional info is never returned in case of an error.
588 */
589 if (!(nfserr && rqstp->rq_vers == 2)) {
590 xdr = proc->pc_encode;
591 if (xdr && !xdr(rqstp, nfserrp,
592 rqstp->rq_resp)) {
593 /* Failed to encode result. Release cache entry */
594 dprintk("nfsd: failed to encode result!\n");
595 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
596 *statp = rpc_system_err;
597 return 1;
598 }
599 }
600
601 /* Store reply in cache. */
602 nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
603 return 1;
604}
Greg Banks03cf6c92009-01-13 21:26:36 +1100605
606int nfsd_pool_stats_open(struct inode *inode, struct file *file)
607{
608 if (nfsd_serv == NULL)
609 return -ENODEV;
610 return svc_pool_stats_open(nfsd_serv, file);
611}