blob: 941041f4b1365fb72f77558aa93b376f9d5818fb [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>
21#include <linux/smp_lock.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070022#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/fs_struct.h>
24
25#include <linux/sunrpc/types.h>
26#include <linux/sunrpc/stats.h>
27#include <linux/sunrpc/svc.h>
28#include <linux/sunrpc/svcsock.h>
29#include <linux/sunrpc/cache.h>
30#include <linux/nfsd/nfsd.h>
31#include <linux/nfsd/stats.h>
32#include <linux/nfsd/cache.h>
NeilBrown70c3b762005-11-07 01:00:25 -080033#include <linux/nfsd/syscall.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/lockd/bind.h>
Andreas Gruenbachera257cdd2005-06-22 17:16:26 +000035#include <linux/nfsacl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37#define NFSDDBG_FACILITY NFSDDBG_SVC
38
39/* these signals will be delivered to an nfsd thread
40 * when handling a request
41 */
42#define ALLOWED_SIGS (sigmask(SIGKILL))
43/* these signals will be delivered to an nfsd thread
44 * when not handling a request. i.e. when waiting
45 */
46#define SHUTDOWN_SIGS (sigmask(SIGKILL) | sigmask(SIGHUP) | sigmask(SIGINT) | sigmask(SIGQUIT))
47/* if the last thread dies with SIGHUP, then the exports table is
48 * left unchanged ( like 2.4-{0-9} ). Any other signal will clear
49 * the exports table (like 2.2).
50 */
51#define SIG_NOCLEAN SIGHUP
52
53extern struct svc_program nfsd_program;
54static void nfsd(struct svc_rqst *rqstp);
55struct timeval nfssvc_boot;
NeilBrown70c3b762005-11-07 01:00:25 -080056 struct svc_serv *nfsd_serv;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static atomic_t nfsd_busy;
58static unsigned long nfsd_last_call;
59static DEFINE_SPINLOCK(nfsd_call_lock);
60
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080061#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
62static struct svc_stat nfsd_acl_svcstats;
63static struct svc_version * nfsd_acl_version[] = {
64 [2] = &nfsd_acl_version2,
65 [3] = &nfsd_acl_version3,
66};
67
68#define NFSD_ACL_MINVERS 2
Tobias Klausere8c96f82006-03-24 03:15:34 -080069#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080070static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
71
72static struct svc_program nfsd_acl_program = {
73 .pg_prog = NFS_ACL_PROGRAM,
74 .pg_nvers = NFSD_ACL_NRVERS,
75 .pg_vers = nfsd_acl_versions,
NeilBrown1a8eff62007-01-26 00:56:58 -080076 .pg_name = "nfsacl",
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080077 .pg_class = "nfsd",
78 .pg_stats = &nfsd_acl_svcstats,
79 .pg_authenticate = &svc_set_client,
80};
81
82static struct svc_stat nfsd_acl_svcstats = {
83 .program = &nfsd_acl_program,
84};
85#endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
86
NeilBrown70c3b762005-11-07 01:00:25 -080087static struct svc_version * nfsd_version[] = {
88 [2] = &nfsd_version2,
89#if defined(CONFIG_NFSD_V3)
90 [3] = &nfsd_version3,
91#endif
92#if defined(CONFIG_NFSD_V4)
93 [4] = &nfsd_version4,
94#endif
95};
96
97#define NFSD_MINVERS 2
Tobias Klausere8c96f82006-03-24 03:15:34 -080098#define NFSD_NRVERS ARRAY_SIZE(nfsd_version)
NeilBrown70c3b762005-11-07 01:00:25 -080099static struct svc_version *nfsd_versions[NFSD_NRVERS];
100
101struct svc_program nfsd_program = {
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800102#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
103 .pg_next = &nfsd_acl_program,
104#endif
NeilBrown70c3b762005-11-07 01:00:25 -0800105 .pg_prog = NFS_PROGRAM, /* program number */
106 .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
107 .pg_vers = nfsd_versions, /* version table */
108 .pg_name = "nfsd", /* program name */
109 .pg_class = "nfsd", /* authentication class */
110 .pg_stats = &nfsd_svcstats, /* version table */
111 .pg_authenticate = &svc_set_client, /* export authentication */
112
113};
114
NeilBrown6658d3a2006-10-02 02:17:46 -0700115int nfsd_vers(int vers, enum vers_op change)
116{
117 if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
118 return -1;
119 switch(change) {
120 case NFSD_SET:
121 nfsd_versions[vers] = nfsd_version[vers];
NeilBrown6658d3a2006-10-02 02:17:46 -0700122#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
123 if (vers < NFSD_ACL_NRVERS)
NeilBrown1a8eff62007-01-26 00:56:58 -0800124 nfsd_acl_versions[vers] = nfsd_acl_version[vers];
NeilBrown6658d3a2006-10-02 02:17:46 -0700125#endif
NeilBrown1a8eff62007-01-26 00:56:58 -0800126 break;
NeilBrown6658d3a2006-10-02 02:17:46 -0700127 case NFSD_CLEAR:
128 nfsd_versions[vers] = NULL;
129#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
130 if (vers < NFSD_ACL_NRVERS)
NeilBrown1a8eff62007-01-26 00:56:58 -0800131 nfsd_acl_versions[vers] = NULL;
NeilBrown6658d3a2006-10-02 02:17:46 -0700132#endif
133 break;
134 case NFSD_TEST:
135 return nfsd_versions[vers] != NULL;
136 case NFSD_AVAIL:
137 return nfsd_version[vers] != NULL;
138 }
139 return 0;
140}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141/*
142 * Maximum number of nfsd processes
143 */
144#define NFSD_MAXSERVS 8192
145
146int nfsd_nrthreads(void)
147{
148 if (nfsd_serv == NULL)
149 return 0;
150 else
151 return nfsd_serv->sv_nrthreads;
152}
153
NeilBrownbc591cc2006-10-02 02:17:44 -0700154static int killsig; /* signal that was used to kill last nfsd */
155static void nfsd_last_thread(struct svc_serv *serv)
156{
157 /* When last nfsd thread exits we need to do some clean-up */
Tom Tucker7a182082007-12-30 21:07:53 -0600158 struct svc_xprt *xprt;
159 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list)
NeilBrown24e36662006-10-02 02:17:45 -0700160 lockd_down();
NeilBrownbc591cc2006-10-02 02:17:44 -0700161 nfsd_serv = NULL;
162 nfsd_racache_shutdown();
163 nfs4_state_shutdown();
164
165 printk(KERN_WARNING "nfsd: last server has exited\n");
166 if (killsig != SIG_NOCLEAN) {
167 printk(KERN_WARNING "nfsd: unexporting all filesystems\n");
168 nfsd_export_flush();
169 }
170}
NeilBrown6658d3a2006-10-02 02:17:46 -0700171
172void nfsd_reset_versions(void)
173{
174 int found_one = 0;
175 int i;
176
177 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
178 if (nfsd_program.pg_vers[i])
179 found_one = 1;
180 }
181
182 if (!found_one) {
183 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
184 nfsd_program.pg_vers[i] = nfsd_version[i];
185#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
186 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
187 nfsd_acl_program.pg_vers[i] =
188 nfsd_acl_version[i];
189#endif
190 }
191}
192
NeilBrownb41b66d2006-10-02 02:17:48 -0700193int nfsd_create_serv(void)
NeilBrown02a375f2006-10-02 02:17:46 -0700194{
195 int err = 0;
196 lock_kernel();
197 if (nfsd_serv) {
Greg Banks9a24ab52006-10-02 02:17:58 -0700198 svc_get(nfsd_serv);
NeilBrown02a375f2006-10-02 02:17:46 -0700199 unlock_kernel();
200 return 0;
201 }
NeilBrown596bbe52006-10-04 02:15:48 -0700202 if (nfsd_max_blksize == 0) {
203 /* choose a suitable default */
204 struct sysinfo i;
205 si_meminfo(&i);
206 /* Aim for 1/4096 of memory per thread
207 * This gives 1MB on 4Gig machines
208 * But only uses 32K on 128M machines.
209 * Bottom out at 8K on 32M and smaller.
210 * Of course, this is only a default.
211 */
212 nfsd_max_blksize = NFSSVC_MAXBLKSIZE;
NeilBrown44c55602006-10-04 02:16:15 -0700213 i.totalram <<= PAGE_SHIFT - 12;
NeilBrown596bbe52006-10-04 02:15:48 -0700214 while (nfsd_max_blksize > i.totalram &&
215 nfsd_max_blksize >= 8*1024*2)
216 nfsd_max_blksize /= 2;
217 }
NeilBrown02a375f2006-10-02 02:17:46 -0700218
219 atomic_set(&nfsd_busy, 0);
NeilBrown596bbe52006-10-04 02:15:48 -0700220 nfsd_serv = svc_create_pooled(&nfsd_program,
NeilBrownc6b0a9f2006-10-06 00:44:05 -0700221 nfsd_max_blksize,
Greg Bankseec09662006-10-02 02:18:00 -0700222 nfsd_last_thread,
223 nfsd, SIG_NOCLEAN, THIS_MODULE);
NeilBrown02a375f2006-10-02 02:17:46 -0700224 if (nfsd_serv == NULL)
225 err = -ENOMEM;
NeilBrown02a375f2006-10-02 02:17:46 -0700226 unlock_kernel();
227 do_gettimeofday(&nfssvc_boot); /* record boot time */
228 return err;
229}
230
231static int nfsd_init_socks(int port)
232{
233 int error;
234 if (!list_empty(&nfsd_serv->sv_permsocks))
235 return 0;
236
NeilBrown02a375f2006-10-02 02:17:46 -0700237 error = lockd_up(IPPROTO_UDP);
NeilBrown4a3ae422006-10-02 02:17:53 -0700238 if (error >= 0) {
Tom Tuckerd7c9f1e2007-12-30 21:07:44 -0600239 error = svc_create_xprt(nfsd_serv, "udp", port,
Chuck Lever482fb942007-02-12 00:53:29 -0800240 SVC_SOCK_DEFAULTS);
NeilBrown4a3ae422006-10-02 02:17:53 -0700241 if (error < 0)
242 lockd_down();
243 }
NeilBrown02a375f2006-10-02 02:17:46 -0700244 if (error < 0)
245 return error;
246
NeilBrown02a375f2006-10-02 02:17:46 -0700247 error = lockd_up(IPPROTO_TCP);
NeilBrown4a3ae422006-10-02 02:17:53 -0700248 if (error >= 0) {
Tom Tuckerd7c9f1e2007-12-30 21:07:44 -0600249 error = svc_create_xprt(nfsd_serv, "tcp", port,
Chuck Lever482fb942007-02-12 00:53:29 -0800250 SVC_SOCK_DEFAULTS);
NeilBrown4a3ae422006-10-02 02:17:53 -0700251 if (error < 0)
252 lockd_down();
253 }
NeilBrown02a375f2006-10-02 02:17:46 -0700254 if (error < 0)
255 return error;
NeilBrown02a375f2006-10-02 02:17:46 -0700256 return 0;
257}
258
Greg Bankseed29652006-10-02 02:18:02 -0700259int nfsd_nrpools(void)
260{
261 if (nfsd_serv == NULL)
262 return 0;
263 else
264 return nfsd_serv->sv_nrpools;
265}
266
267int nfsd_get_nrthreads(int n, int *nthreads)
268{
269 int i = 0;
270
271 if (nfsd_serv != NULL) {
272 for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
273 nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
274 }
275
276 return 0;
277}
278
279int nfsd_set_nrthreads(int n, int *nthreads)
280{
281 int i = 0;
282 int tot = 0;
283 int err = 0;
284
285 if (nfsd_serv == NULL || n <= 0)
286 return 0;
287
288 if (n > nfsd_serv->sv_nrpools)
289 n = nfsd_serv->sv_nrpools;
290
291 /* enforce a global maximum number of threads */
292 tot = 0;
293 for (i = 0; i < n; i++) {
294 if (nthreads[i] > NFSD_MAXSERVS)
295 nthreads[i] = NFSD_MAXSERVS;
296 tot += nthreads[i];
297 }
298 if (tot > NFSD_MAXSERVS) {
299 /* total too large: scale down requested numbers */
300 for (i = 0; i < n && tot > 0; i++) {
301 int new = nthreads[i] * NFSD_MAXSERVS / tot;
302 tot -= (nthreads[i] - new);
303 nthreads[i] = new;
304 }
305 for (i = 0; i < n && tot > 0; i++) {
306 nthreads[i]--;
307 tot--;
308 }
309 }
310
311 /*
312 * There must always be a thread in pool 0; the admin
313 * can't shut down NFS completely using pool_threads.
314 */
315 if (nthreads[0] == 0)
316 nthreads[0] = 1;
317
318 /* apply the new numbers */
319 lock_kernel();
320 svc_get(nfsd_serv);
321 for (i = 0; i < n; i++) {
322 err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
323 nthreads[i]);
324 if (err)
325 break;
326 }
327 svc_destroy(nfsd_serv);
328 unlock_kernel();
329
330 return err;
331}
332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333int
334nfsd_svc(unsigned short port, int nrservs)
335{
336 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
338 lock_kernel();
NeilBrown6658d3a2006-10-02 02:17:46 -0700339 dprintk("nfsd: creating service\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 error = -EINVAL;
341 if (nrservs <= 0)
342 nrservs = 0;
343 if (nrservs > NFSD_MAXSERVS)
344 nrservs = NFSD_MAXSERVS;
345
346 /* Readahead param cache - will no-op if it already exists */
347 error = nfsd_racache_init(2*nrservs);
348 if (error<0)
349 goto out;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -0400350 nfs4_state_start();
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800351
NeilBrown02a375f2006-10-02 02:17:46 -0700352 nfsd_reset_versions();
353
354 error = nfsd_create_serv();
355
356 if (error)
357 goto out;
358 error = nfsd_init_socks(port);
359 if (error)
360 goto failure;
361
Greg Bankseec09662006-10-02 02:18:00 -0700362 error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 failure:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 svc_destroy(nfsd_serv); /* Release server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 out:
366 unlock_kernel();
367 return error;
368}
369
370static inline void
371update_thread_usage(int busy_threads)
372{
373 unsigned long prev_call;
374 unsigned long diff;
375 int decile;
376
377 spin_lock(&nfsd_call_lock);
378 prev_call = nfsd_last_call;
379 nfsd_last_call = jiffies;
380 decile = busy_threads*10/nfsdstats.th_cnt;
381 if (decile>0 && decile <= 10) {
382 diff = nfsd_last_call - prev_call;
383 if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP)
384 nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP;
385 if (decile == 10)
386 nfsdstats.th_fullcnt++;
387 }
388 spin_unlock(&nfsd_call_lock);
389}
390
391/*
392 * This is the NFS server kernel thread
393 */
394static void
395nfsd(struct svc_rqst *rqstp)
396{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 struct fs_struct *fsp;
398 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 sigset_t shutdown_mask, allowed_mask;
400
401 /* Lock module and set up kernel thread */
402 lock_kernel();
403 daemonize("nfsd");
404
405 /* After daemonize() this kernel thread shares current->fs
406 * with the init process. We need to create files with a
407 * umask of 0 instead of init's umask. */
408 fsp = copy_fs_struct(current->fs);
409 if (!fsp) {
410 printk("Unable to start nfsd thread: out of memory\n");
411 goto out;
412 }
413 exit_fs(current);
414 current->fs = fsp;
415 current->fs->umask = 0;
416
417 siginitsetinv(&shutdown_mask, SHUTDOWN_SIGS);
418 siginitsetinv(&allowed_mask, ALLOWED_SIGS);
419
420 nfsdstats.th_cnt++;
421
Greg Bankseec09662006-10-02 02:18:00 -0700422 rqstp->rq_task = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 unlock_kernel();
425
426 /*
427 * We want less throttling in balance_dirty_pages() so that nfs to
428 * localhost doesn't cause nfsd to lock up due to all the client's
429 * dirty pages.
430 */
431 current->flags |= PF_LESS_THROTTLE;
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700432 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 /*
435 * The main request loop
436 */
437 for (;;) {
438 /* Block all but the shutdown signals */
439 sigprocmask(SIG_SETMASK, &shutdown_mask, NULL);
440
441 /*
442 * Find a socket with data available and call its
443 * recvfrom routine.
444 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700445 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 ;
447 if (err < 0)
448 break;
449 update_thread_usage(atomic_read(&nfsd_busy));
450 atomic_inc(&nfsd_busy);
451
452 /* Lock the export hash tables for reading. */
453 exp_readlock();
454
455 /* Process request with signals blocked. */
456 sigprocmask(SIG_SETMASK, &allowed_mask, NULL);
457
NeilBrown6fb2b472006-10-02 02:17:50 -0700458 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 /* Unlock export hash tables */
461 exp_readunlock();
462 update_thread_usage(atomic_read(&nfsd_busy));
463 atomic_dec(&nfsd_busy);
464 }
465
466 if (err != -EINTR) {
467 printk(KERN_WARNING "nfsd: terminating on error %d\n", -err);
468 } else {
469 unsigned int signo;
470
471 for (signo = 1; signo <= _NSIG; signo++)
472 if (sigismember(&current->pending.signal, signo) &&
473 !sigismember(&current->blocked, signo))
474 break;
NeilBrownbc591cc2006-10-02 02:17:44 -0700475 killsig = signo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 }
NeilBrown24e36662006-10-02 02:17:45 -0700477 /* Clear signals before calling svc_exit_thread() */
NeilBrown9e4160522005-04-16 15:26:37 -0700478 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480 lock_kernel();
481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 nfsdstats.th_cnt --;
483
484out:
485 /* Release the thread */
486 svc_exit_thread(rqstp);
487
488 /* Release module */
Steven Rostedtc4f92db2005-08-17 14:25:23 -0400489 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 module_put_and_exit(0);
491}
492
Andy Adamson32c1eb02007-07-17 04:04:48 -0700493static __be32 map_new_errors(u32 vers, __be32 nfserr)
494{
495 if (nfserr == nfserr_jukebox && vers == 2)
496 return nfserr_dropit;
497 if (nfserr == nfserr_wrongsec && vers < 4)
498 return nfserr_acces;
499 return nfserr;
500}
501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502int
Al Viroc7afef12006-10-19 23:29:02 -0700503nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
505 struct svc_procedure *proc;
506 kxdrproc_t xdr;
Al Viroad451d32006-10-19 23:28:55 -0700507 __be32 nfserr;
508 __be32 *nfserrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 dprintk("nfsd_dispatch: vers %d proc %d\n",
511 rqstp->rq_vers, rqstp->rq_proc);
512 proc = rqstp->rq_procinfo;
513
514 /* Check whether we have this call in the cache. */
515 switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) {
516 case RC_INTR:
517 case RC_DROPIT:
518 return 0;
519 case RC_REPLY:
520 return 1;
521 case RC_DOIT:;
522 /* do it */
523 }
524
525 /* Decode arguments */
526 xdr = proc->pc_decode;
Al Viroad451d32006-10-19 23:28:55 -0700527 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 rqstp->rq_argp)) {
529 dprintk("nfsd: failed to decode arguments!\n");
530 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
531 *statp = rpc_garbage_args;
532 return 1;
533 }
534
535 /* need to grab the location to store the status, as
536 * nfsv4 does some encoding while processing
537 */
538 nfserrp = rqstp->rq_res.head[0].iov_base
539 + rqstp->rq_res.head[0].iov_len;
Al Viroad451d32006-10-19 23:28:55 -0700540 rqstp->rq_res.head[0].iov_len += sizeof(__be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
542 /* Now call the procedure handler, and encode NFS status. */
543 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
Andy Adamson32c1eb02007-07-17 04:04:48 -0700544 nfserr = map_new_errors(rqstp->rq_vers, nfserr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 if (nfserr == nfserr_dropit) {
J. Bruce Fields45457e02007-06-22 17:26:32 -0400546 dprintk("nfsd: Dropping request; may be revisited later\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
548 return 0;
549 }
550
551 if (rqstp->rq_proc != 0)
552 *nfserrp++ = nfserr;
553
554 /* Encode result.
555 * For NFSv2, additional info is never returned in case of an error.
556 */
557 if (!(nfserr && rqstp->rq_vers == 2)) {
558 xdr = proc->pc_encode;
559 if (xdr && !xdr(rqstp, nfserrp,
560 rqstp->rq_resp)) {
561 /* Failed to encode result. Release cache entry */
562 dprintk("nfsd: failed to encode result!\n");
563 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
564 *statp = rpc_system_err;
565 return 1;
566 }
567 }
568
569 /* Store reply in cache. */
570 nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
571 return 1;
572}