blob: 9647b0f7bc0c0d52610bf1419c9bafcd466b57dc [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
247#ifdef CONFIG_NFSD_TCP
NeilBrown02a375f2006-10-02 02:17:46 -0700248 error = lockd_up(IPPROTO_TCP);
NeilBrown4a3ae422006-10-02 02:17:53 -0700249 if (error >= 0) {
Tom Tuckerd7c9f1e2007-12-30 21:07:44 -0600250 error = svc_create_xprt(nfsd_serv, "tcp", port,
Chuck Lever482fb942007-02-12 00:53:29 -0800251 SVC_SOCK_DEFAULTS);
NeilBrown4a3ae422006-10-02 02:17:53 -0700252 if (error < 0)
253 lockd_down();
254 }
NeilBrown02a375f2006-10-02 02:17:46 -0700255 if (error < 0)
256 return error;
257#endif
258 return 0;
259}
260
Greg Bankseed29652006-10-02 02:18:02 -0700261int nfsd_nrpools(void)
262{
263 if (nfsd_serv == NULL)
264 return 0;
265 else
266 return nfsd_serv->sv_nrpools;
267}
268
269int nfsd_get_nrthreads(int n, int *nthreads)
270{
271 int i = 0;
272
273 if (nfsd_serv != NULL) {
274 for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
275 nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
276 }
277
278 return 0;
279}
280
281int nfsd_set_nrthreads(int n, int *nthreads)
282{
283 int i = 0;
284 int tot = 0;
285 int err = 0;
286
287 if (nfsd_serv == NULL || n <= 0)
288 return 0;
289
290 if (n > nfsd_serv->sv_nrpools)
291 n = nfsd_serv->sv_nrpools;
292
293 /* enforce a global maximum number of threads */
294 tot = 0;
295 for (i = 0; i < n; i++) {
296 if (nthreads[i] > NFSD_MAXSERVS)
297 nthreads[i] = NFSD_MAXSERVS;
298 tot += nthreads[i];
299 }
300 if (tot > NFSD_MAXSERVS) {
301 /* total too large: scale down requested numbers */
302 for (i = 0; i < n && tot > 0; i++) {
303 int new = nthreads[i] * NFSD_MAXSERVS / tot;
304 tot -= (nthreads[i] - new);
305 nthreads[i] = new;
306 }
307 for (i = 0; i < n && tot > 0; i++) {
308 nthreads[i]--;
309 tot--;
310 }
311 }
312
313 /*
314 * There must always be a thread in pool 0; the admin
315 * can't shut down NFS completely using pool_threads.
316 */
317 if (nthreads[0] == 0)
318 nthreads[0] = 1;
319
320 /* apply the new numbers */
321 lock_kernel();
322 svc_get(nfsd_serv);
323 for (i = 0; i < n; i++) {
324 err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
325 nthreads[i]);
326 if (err)
327 break;
328 }
329 svc_destroy(nfsd_serv);
330 unlock_kernel();
331
332 return err;
333}
334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335int
336nfsd_svc(unsigned short port, int nrservs)
337{
338 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340 lock_kernel();
NeilBrown6658d3a2006-10-02 02:17:46 -0700341 dprintk("nfsd: creating service\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 error = -EINVAL;
343 if (nrservs <= 0)
344 nrservs = 0;
345 if (nrservs > NFSD_MAXSERVS)
346 nrservs = NFSD_MAXSERVS;
347
348 /* Readahead param cache - will no-op if it already exists */
349 error = nfsd_racache_init(2*nrservs);
350 if (error<0)
351 goto out;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -0400352 nfs4_state_start();
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800353
NeilBrown02a375f2006-10-02 02:17:46 -0700354 nfsd_reset_versions();
355
356 error = nfsd_create_serv();
357
358 if (error)
359 goto out;
360 error = nfsd_init_socks(port);
361 if (error)
362 goto failure;
363
Greg Bankseec09662006-10-02 02:18:00 -0700364 error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 failure:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 svc_destroy(nfsd_serv); /* Release server */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 out:
368 unlock_kernel();
369 return error;
370}
371
372static inline void
373update_thread_usage(int busy_threads)
374{
375 unsigned long prev_call;
376 unsigned long diff;
377 int decile;
378
379 spin_lock(&nfsd_call_lock);
380 prev_call = nfsd_last_call;
381 nfsd_last_call = jiffies;
382 decile = busy_threads*10/nfsdstats.th_cnt;
383 if (decile>0 && decile <= 10) {
384 diff = nfsd_last_call - prev_call;
385 if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP)
386 nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP;
387 if (decile == 10)
388 nfsdstats.th_fullcnt++;
389 }
390 spin_unlock(&nfsd_call_lock);
391}
392
393/*
394 * This is the NFS server kernel thread
395 */
396static void
397nfsd(struct svc_rqst *rqstp)
398{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 struct fs_struct *fsp;
400 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 sigset_t shutdown_mask, allowed_mask;
402
403 /* Lock module and set up kernel thread */
404 lock_kernel();
405 daemonize("nfsd");
406
407 /* After daemonize() this kernel thread shares current->fs
408 * with the init process. We need to create files with a
409 * umask of 0 instead of init's umask. */
410 fsp = copy_fs_struct(current->fs);
411 if (!fsp) {
412 printk("Unable to start nfsd thread: out of memory\n");
413 goto out;
414 }
415 exit_fs(current);
416 current->fs = fsp;
417 current->fs->umask = 0;
418
419 siginitsetinv(&shutdown_mask, SHUTDOWN_SIGS);
420 siginitsetinv(&allowed_mask, ALLOWED_SIGS);
421
422 nfsdstats.th_cnt++;
423
Greg Bankseec09662006-10-02 02:18:00 -0700424 rqstp->rq_task = current;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 unlock_kernel();
427
428 /*
429 * We want less throttling in balance_dirty_pages() so that nfs to
430 * localhost doesn't cause nfsd to lock up due to all the client's
431 * dirty pages.
432 */
433 current->flags |= PF_LESS_THROTTLE;
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700434 set_freezable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436 /*
437 * The main request loop
438 */
439 for (;;) {
440 /* Block all but the shutdown signals */
441 sigprocmask(SIG_SETMASK, &shutdown_mask, NULL);
442
443 /*
444 * Find a socket with data available and call its
445 * recvfrom routine.
446 */
NeilBrown6fb2b472006-10-02 02:17:50 -0700447 while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 ;
449 if (err < 0)
450 break;
451 update_thread_usage(atomic_read(&nfsd_busy));
452 atomic_inc(&nfsd_busy);
453
454 /* Lock the export hash tables for reading. */
455 exp_readlock();
456
457 /* Process request with signals blocked. */
458 sigprocmask(SIG_SETMASK, &allowed_mask, NULL);
459
NeilBrown6fb2b472006-10-02 02:17:50 -0700460 svc_process(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462 /* Unlock export hash tables */
463 exp_readunlock();
464 update_thread_usage(atomic_read(&nfsd_busy));
465 atomic_dec(&nfsd_busy);
466 }
467
468 if (err != -EINTR) {
469 printk(KERN_WARNING "nfsd: terminating on error %d\n", -err);
470 } else {
471 unsigned int signo;
472
473 for (signo = 1; signo <= _NSIG; signo++)
474 if (sigismember(&current->pending.signal, signo) &&
475 !sigismember(&current->blocked, signo))
476 break;
NeilBrownbc591cc2006-10-02 02:17:44 -0700477 killsig = signo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 }
NeilBrown24e36662006-10-02 02:17:45 -0700479 /* Clear signals before calling svc_exit_thread() */
NeilBrown9e4160522005-04-16 15:26:37 -0700480 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 lock_kernel();
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 nfsdstats.th_cnt --;
485
486out:
487 /* Release the thread */
488 svc_exit_thread(rqstp);
489
490 /* Release module */
Steven Rostedtc4f92db2005-08-17 14:25:23 -0400491 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 module_put_and_exit(0);
493}
494
Andy Adamson32c1eb02007-07-17 04:04:48 -0700495static __be32 map_new_errors(u32 vers, __be32 nfserr)
496{
497 if (nfserr == nfserr_jukebox && vers == 2)
498 return nfserr_dropit;
499 if (nfserr == nfserr_wrongsec && vers < 4)
500 return nfserr_acces;
501 return nfserr;
502}
503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504int
Al Viroc7afef12006-10-19 23:29:02 -0700505nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506{
507 struct svc_procedure *proc;
508 kxdrproc_t xdr;
Al Viroad451d32006-10-19 23:28:55 -0700509 __be32 nfserr;
510 __be32 *nfserrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512 dprintk("nfsd_dispatch: vers %d proc %d\n",
513 rqstp->rq_vers, rqstp->rq_proc);
514 proc = rqstp->rq_procinfo;
515
516 /* Check whether we have this call in the cache. */
517 switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) {
518 case RC_INTR:
519 case RC_DROPIT:
520 return 0;
521 case RC_REPLY:
522 return 1;
523 case RC_DOIT:;
524 /* do it */
525 }
526
527 /* Decode arguments */
528 xdr = proc->pc_decode;
Al Viroad451d32006-10-19 23:28:55 -0700529 if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 rqstp->rq_argp)) {
531 dprintk("nfsd: failed to decode arguments!\n");
532 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
533 *statp = rpc_garbage_args;
534 return 1;
535 }
536
537 /* need to grab the location to store the status, as
538 * nfsv4 does some encoding while processing
539 */
540 nfserrp = rqstp->rq_res.head[0].iov_base
541 + rqstp->rq_res.head[0].iov_len;
Al Viroad451d32006-10-19 23:28:55 -0700542 rqstp->rq_res.head[0].iov_len += sizeof(__be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
544 /* Now call the procedure handler, and encode NFS status. */
545 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
Andy Adamson32c1eb02007-07-17 04:04:48 -0700546 nfserr = map_new_errors(rqstp->rq_vers, nfserr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 if (nfserr == nfserr_dropit) {
J. Bruce Fields45457e02007-06-22 17:26:32 -0400548 dprintk("nfsd: Dropping request; may be revisited later\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
550 return 0;
551 }
552
553 if (rqstp->rq_proc != 0)
554 *nfserrp++ = nfserr;
555
556 /* Encode result.
557 * For NFSv2, additional info is never returned in case of an error.
558 */
559 if (!(nfserr && rqstp->rq_vers == 2)) {
560 xdr = proc->pc_encode;
561 if (xdr && !xdr(rqstp, nfserrp,
562 rqstp->rq_resp)) {
563 /* Failed to encode result. Release cache entry */
564 dprintk("nfsd: failed to encode result!\n");
565 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
566 *statp = rpc_system_err;
567 return 1;
568 }
569 }
570
571 /* Store reply in cache. */
572 nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
573 return 1;
574}