blob: 1d163b6169151ce870c911dc1c7eb0eb40c80a74 [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
11#include <linux/config.h>
12#include <linux/module.h>
13
14#include <linux/time.h>
15#include <linux/errno.h>
16#include <linux/nfs.h>
17#include <linux/in.h>
18#include <linux/uio.h>
19#include <linux/unistd.h>
20#include <linux/slab.h>
21#include <linux/smp.h>
22#include <linux/smp_lock.h>
23#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
61struct nfsd_list {
62 struct list_head list;
63 struct task_struct *task;
64};
65static struct list_head nfsd_list = LIST_HEAD_INIT(nfsd_list);
66
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -080067#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
68static struct svc_stat nfsd_acl_svcstats;
69static struct svc_version * nfsd_acl_version[] = {
70 [2] = &nfsd_acl_version2,
71 [3] = &nfsd_acl_version3,
72};
73
74#define NFSD_ACL_MINVERS 2
75#define NFSD_ACL_NRVERS (sizeof(nfsd_acl_version)/sizeof(nfsd_acl_version[0]))
76static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
77
78static struct svc_program nfsd_acl_program = {
79 .pg_prog = NFS_ACL_PROGRAM,
80 .pg_nvers = NFSD_ACL_NRVERS,
81 .pg_vers = nfsd_acl_versions,
82 .pg_name = "nfsd",
83 .pg_class = "nfsd",
84 .pg_stats = &nfsd_acl_svcstats,
85 .pg_authenticate = &svc_set_client,
86};
87
88static struct svc_stat nfsd_acl_svcstats = {
89 .program = &nfsd_acl_program,
90};
91#endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */
92
NeilBrown70c3b762005-11-07 01:00:25 -080093static struct svc_version * nfsd_version[] = {
94 [2] = &nfsd_version2,
95#if defined(CONFIG_NFSD_V3)
96 [3] = &nfsd_version3,
97#endif
98#if defined(CONFIG_NFSD_V4)
99 [4] = &nfsd_version4,
100#endif
101};
102
103#define NFSD_MINVERS 2
104#define NFSD_NRVERS (sizeof(nfsd_version)/sizeof(nfsd_version[0]))
105static struct svc_version *nfsd_versions[NFSD_NRVERS];
106
107struct svc_program nfsd_program = {
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800108#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
109 .pg_next = &nfsd_acl_program,
110#endif
NeilBrown70c3b762005-11-07 01:00:25 -0800111 .pg_prog = NFS_PROGRAM, /* program number */
112 .pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
113 .pg_vers = nfsd_versions, /* version table */
114 .pg_name = "nfsd", /* program name */
115 .pg_class = "nfsd", /* authentication class */
116 .pg_stats = &nfsd_svcstats, /* version table */
117 .pg_authenticate = &svc_set_client, /* export authentication */
118
119};
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121/*
122 * Maximum number of nfsd processes
123 */
124#define NFSD_MAXSERVS 8192
125
126int nfsd_nrthreads(void)
127{
128 if (nfsd_serv == NULL)
129 return 0;
130 else
131 return nfsd_serv->sv_nrthreads;
132}
133
134int
135nfsd_svc(unsigned short port, int nrservs)
136{
137 int error;
NeilBrown70c3b762005-11-07 01:00:25 -0800138 int none_left, found_one, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 struct list_head *victim;
140
141 lock_kernel();
NeilBrown70c3b762005-11-07 01:00:25 -0800142 dprintk("nfsd: creating service: vers 0x%x\n",
143 nfsd_versbits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 error = -EINVAL;
145 if (nrservs <= 0)
146 nrservs = 0;
147 if (nrservs > NFSD_MAXSERVS)
148 nrservs = NFSD_MAXSERVS;
149
150 /* Readahead param cache - will no-op if it already exists */
151 error = nfsd_racache_init(2*nrservs);
152 if (error<0)
153 goto out;
NeilBrown76a35502005-06-23 22:03:26 -0700154 error = nfs4_state_start();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (error<0)
156 goto out;
157 if (!nfsd_serv) {
NeilBrown70c3b762005-11-07 01:00:25 -0800158 /*
159 * Use the nfsd_ctlbits to define which
160 * versions that will be advertised.
161 * If nfsd_ctlbits doesn't list any version,
162 * export them all.
163 */
164 found_one = 0;
165
166 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
167 if (NFSCTL_VERISSET(nfsd_versbits, i)) {
168 nfsd_program.pg_vers[i] = nfsd_version[i];
169 found_one = 1;
170 } else
171 nfsd_program.pg_vers[i] = NULL;
172 }
173
174 if (!found_one) {
175 for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
176 nfsd_program.pg_vers[i] = nfsd_version[i];
177 }
178
Andreas Gruenbacher3fb803a2006-02-01 03:04:34 -0800179
180#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
181 found_one = 0;
182
183 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++) {
184 if (NFSCTL_VERISSET(nfsd_versbits, i)) {
185 nfsd_acl_program.pg_vers[i] =
186 nfsd_acl_version[i];
187 found_one = 1;
188 } else
189 nfsd_acl_program.pg_vers[i] = NULL;
190 }
191
192 if (!found_one) {
193 for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
194 nfsd_acl_program.pg_vers[i] =
195 nfsd_acl_version[i];
196 }
197#endif
198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 atomic_set(&nfsd_busy, 0);
200 error = -ENOMEM;
201 nfsd_serv = svc_create(&nfsd_program, NFSD_BUFSIZE);
202 if (nfsd_serv == NULL)
203 goto out;
204 error = svc_makesock(nfsd_serv, IPPROTO_UDP, port);
205 if (error < 0)
206 goto failure;
207
208#ifdef CONFIG_NFSD_TCP
209 error = svc_makesock(nfsd_serv, IPPROTO_TCP, port);
210 if (error < 0)
211 goto failure;
212#endif
213 do_gettimeofday(&nfssvc_boot); /* record boot time */
214 } else
215 nfsd_serv->sv_nrthreads++;
216 nrservs -= (nfsd_serv->sv_nrthreads-1);
217 while (nrservs > 0) {
218 nrservs--;
219 __module_get(THIS_MODULE);
220 error = svc_create_thread(nfsd, nfsd_serv);
221 if (error < 0) {
222 module_put(THIS_MODULE);
223 break;
224 }
225 }
226 victim = nfsd_list.next;
227 while (nrservs < 0 && victim != &nfsd_list) {
228 struct nfsd_list *nl =
229 list_entry(victim,struct nfsd_list, list);
230 victim = victim->next;
231 send_sig(SIG_NOCLEAN, nl->task, 1);
232 nrservs++;
233 }
234 failure:
235 none_left = (nfsd_serv->sv_nrthreads == 1);
236 svc_destroy(nfsd_serv); /* Release server */
237 if (none_left) {
238 nfsd_serv = NULL;
239 nfsd_racache_shutdown();
240 nfs4_state_shutdown();
241 }
242 out:
243 unlock_kernel();
244 return error;
245}
246
247static inline void
248update_thread_usage(int busy_threads)
249{
250 unsigned long prev_call;
251 unsigned long diff;
252 int decile;
253
254 spin_lock(&nfsd_call_lock);
255 prev_call = nfsd_last_call;
256 nfsd_last_call = jiffies;
257 decile = busy_threads*10/nfsdstats.th_cnt;
258 if (decile>0 && decile <= 10) {
259 diff = nfsd_last_call - prev_call;
260 if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP)
261 nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP;
262 if (decile == 10)
263 nfsdstats.th_fullcnt++;
264 }
265 spin_unlock(&nfsd_call_lock);
266}
267
268/*
269 * This is the NFS server kernel thread
270 */
271static void
272nfsd(struct svc_rqst *rqstp)
273{
274 struct svc_serv *serv = rqstp->rq_server;
275 struct fs_struct *fsp;
276 int err;
277 struct nfsd_list me;
278 sigset_t shutdown_mask, allowed_mask;
279
280 /* Lock module and set up kernel thread */
281 lock_kernel();
282 daemonize("nfsd");
283
284 /* After daemonize() this kernel thread shares current->fs
285 * with the init process. We need to create files with a
286 * umask of 0 instead of init's umask. */
287 fsp = copy_fs_struct(current->fs);
288 if (!fsp) {
289 printk("Unable to start nfsd thread: out of memory\n");
290 goto out;
291 }
292 exit_fs(current);
293 current->fs = fsp;
294 current->fs->umask = 0;
295
296 siginitsetinv(&shutdown_mask, SHUTDOWN_SIGS);
297 siginitsetinv(&allowed_mask, ALLOWED_SIGS);
298
299 nfsdstats.th_cnt++;
300
301 lockd_up(); /* start lockd */
302
303 me.task = current;
304 list_add(&me.list, &nfsd_list);
305
306 unlock_kernel();
307
308 /*
309 * We want less throttling in balance_dirty_pages() so that nfs to
310 * localhost doesn't cause nfsd to lock up due to all the client's
311 * dirty pages.
312 */
313 current->flags |= PF_LESS_THROTTLE;
314
315 /*
316 * The main request loop
317 */
318 for (;;) {
319 /* Block all but the shutdown signals */
320 sigprocmask(SIG_SETMASK, &shutdown_mask, NULL);
321
322 /*
323 * Find a socket with data available and call its
324 * recvfrom routine.
325 */
326 while ((err = svc_recv(serv, rqstp,
327 60*60*HZ)) == -EAGAIN)
328 ;
329 if (err < 0)
330 break;
331 update_thread_usage(atomic_read(&nfsd_busy));
332 atomic_inc(&nfsd_busy);
333
334 /* Lock the export hash tables for reading. */
335 exp_readlock();
336
337 /* Process request with signals blocked. */
338 sigprocmask(SIG_SETMASK, &allowed_mask, NULL);
339
340 svc_process(serv, rqstp);
341
342 /* Unlock export hash tables */
343 exp_readunlock();
344 update_thread_usage(atomic_read(&nfsd_busy));
345 atomic_dec(&nfsd_busy);
346 }
347
348 if (err != -EINTR) {
349 printk(KERN_WARNING "nfsd: terminating on error %d\n", -err);
350 } else {
351 unsigned int signo;
352
353 for (signo = 1; signo <= _NSIG; signo++)
354 if (sigismember(&current->pending.signal, signo) &&
355 !sigismember(&current->blocked, signo))
356 break;
357 err = signo;
358 }
NeilBrown9e4160522005-04-16 15:26:37 -0700359 /* Clear signals before calling lockd_down() and svc_exit_thread() */
360 flush_signals(current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 lock_kernel();
363
364 /* Release lockd */
365 lockd_down();
366
367 /* Check if this is last thread */
368 if (serv->sv_nrthreads==1) {
369
370 printk(KERN_WARNING "nfsd: last server has exited\n");
371 if (err != SIG_NOCLEAN) {
372 printk(KERN_WARNING "nfsd: unexporting all filesystems\n");
373 nfsd_export_flush();
374 }
375 nfsd_serv = NULL;
376 nfsd_racache_shutdown(); /* release read-ahead cache */
377 nfs4_state_shutdown();
378 }
379 list_del(&me.list);
380 nfsdstats.th_cnt --;
381
382out:
383 /* Release the thread */
384 svc_exit_thread(rqstp);
385
386 /* Release module */
Steven Rostedtc4f92db2005-08-17 14:25:23 -0400387 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 module_put_and_exit(0);
389}
390
391int
392nfsd_dispatch(struct svc_rqst *rqstp, u32 *statp)
393{
394 struct svc_procedure *proc;
395 kxdrproc_t xdr;
396 u32 nfserr;
397 u32 *nfserrp;
398
399 dprintk("nfsd_dispatch: vers %d proc %d\n",
400 rqstp->rq_vers, rqstp->rq_proc);
401 proc = rqstp->rq_procinfo;
402
403 /* Check whether we have this call in the cache. */
404 switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) {
405 case RC_INTR:
406 case RC_DROPIT:
407 return 0;
408 case RC_REPLY:
409 return 1;
410 case RC_DOIT:;
411 /* do it */
412 }
413
414 /* Decode arguments */
415 xdr = proc->pc_decode;
416 if (xdr && !xdr(rqstp, (u32*)rqstp->rq_arg.head[0].iov_base,
417 rqstp->rq_argp)) {
418 dprintk("nfsd: failed to decode arguments!\n");
419 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
420 *statp = rpc_garbage_args;
421 return 1;
422 }
423
424 /* need to grab the location to store the status, as
425 * nfsv4 does some encoding while processing
426 */
427 nfserrp = rqstp->rq_res.head[0].iov_base
428 + rqstp->rq_res.head[0].iov_len;
429 rqstp->rq_res.head[0].iov_len += sizeof(u32);
430
431 /* Now call the procedure handler, and encode NFS status. */
432 nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
433 if (nfserr == nfserr_jukebox && rqstp->rq_vers == 2)
434 nfserr = nfserr_dropit;
435 if (nfserr == nfserr_dropit) {
436 dprintk("nfsd: Dropping request due to malloc failure!\n");
437 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
438 return 0;
439 }
440
441 if (rqstp->rq_proc != 0)
442 *nfserrp++ = nfserr;
443
444 /* Encode result.
445 * For NFSv2, additional info is never returned in case of an error.
446 */
447 if (!(nfserr && rqstp->rq_vers == 2)) {
448 xdr = proc->pc_encode;
449 if (xdr && !xdr(rqstp, nfserrp,
450 rqstp->rq_resp)) {
451 /* Failed to encode result. Release cache entry */
452 dprintk("nfsd: failed to encode result!\n");
453 nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
454 *statp = rpc_system_err;
455 return 1;
456 }
457 }
458
459 /* Store reply in cache. */
460 nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
461 return 1;
462}