Viewing file:  nfssvc.c (8.18 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* linux/fs/nfsd/nfssvc.c
*
* Central processing for nfsd.
*
* Authors: Olaf Kirch (okir@monad.swb.de)
*
* Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
*/
#define __NO_VERSION__
#include <linux/config.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/nfs.h>
#include <linux/in.h>
#include <linux/uio.h>
#include <linux/version.h>
#include <linux/unistd.h>
#include <linux/slab.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
#include <linux/sunrpc/types.h>
#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/svcsock.h>
#include <linux/nfsd/nfsd.h>
#include <linux/nfsd/stats.h>
#include <linux/nfsd/cache.h>
#include <linux/nfsd/xdr.h>
#include <linux/lockd/bind.h>
#define NFSDDBG_FACILITY NFSDDBG_SVC
#define NFSD_BUFSIZE (1024 + NFSSVC_MAXBLKSIZE)
/* these signals will be delivered to an nfsd thread
* when handling a request
*/
#define ALLOWED_SIGS (sigmask(SIGKILL))
/* these signals will be delivered to an nfsd thread
* when not handling a request. i.e. when waiting
*/
#define SHUTDOWN_SIGS (sigmask(SIGKILL) | sigmask(SIGHUP) | sigmask(SIGINT) | sigmask(SIGQUIT))
/* if the last thread dies with SIGHUP, then the exports table is
* left unchanged ( like 2.4-{0-9} ). Any other signal will clear
* the exports table (like 2.2).
*/
#define SIG_NOCLEAN SIGHUP
extern struct svc_program nfsd_program;
static void nfsd(struct svc_rqst *rqstp);
struct timeval nfssvc_boot;
static struct svc_serv *nfsd_serv;
static int nfsd_busy;
static unsigned long nfsd_last_call;
struct nfsd_list {
struct list_head list;
struct task_struct *task;
};
struct list_head nfsd_list = LIST_HEAD_INIT(nfsd_list);
/*
* Maximum number of nfsd processes
*/
#define NFSD_MAXSERVS 128
int
nfsd_svc(unsigned short port, int nrservs)
{
int error;
int none_left;
struct list_head *victim;
dprintk("nfsd: creating service\n");
error = -EINVAL;
if (nrservs <= 0)
nrservs = 0;
if (nrservs > NFSD_MAXSERVS)
nrservs = NFSD_MAXSERVS;
/* Readahead param cache - will no-op if it already exists */
error = nfsd_racache_init(2*nrservs);
if (error<0)
goto out;
if (!nfsd_serv) {
nfsd_serv = svc_create(&nfsd_program, NFSD_BUFSIZE, NFSSVC_XDRSIZE);
if (nfsd_serv == NULL)
goto out;
error = svc_makesock(nfsd_serv, IPPROTO_UDP, port);
if (error < 0)
goto failure;
#if 0 /* Don't even pretend that TCP works. It doesn't. */
error = svc_makesock(nfsd_serv, IPPROTO_TCP, port);
if (error < 0)
goto failure;
#endif
do_gettimeofday(&nfssvc_boot); /* record boot time */
} else
nfsd_serv->sv_nrthreads++;
nrservs -= (nfsd_serv->sv_nrthreads-1);
while (nrservs > 0) {
nrservs--;
error = svc_create_thread(nfsd, nfsd_serv);
if (error < 0)
break;
}
victim = nfsd_list.next;
while (nrservs < 0 && victim != &nfsd_list) {
struct nfsd_list *nl =
list_entry(victim,struct nfsd_list, list);
victim = victim->next;
send_sig(SIG_NOCLEAN, nl->task, 1);
nrservs++;
}
failure:
none_left = (nfsd_serv->sv_nrthreads == 1);
svc_destroy(nfsd_serv); /* Release server */
if (none_left) {
nfsd_serv = NULL;
nfsd_racache_shutdown();
}
out:
return error;
}
static inline void
update_thread_usage(int busy_threads)
{
unsigned long prev_call;
unsigned long diff;
int decile;
prev_call = nfsd_last_call;
nfsd_last_call = jiffies;
decile = busy_threads*10/nfsdstats.th_cnt;
if (decile>0 && decile <= 10) {
diff = nfsd_last_call - prev_call;
if ( (nfsdstats.th_usage[decile-1] += diff) >= NFSD_USAGE_WRAP)
nfsdstats.th_usage[decile-1] -= NFSD_USAGE_WRAP;
if (decile == 10)
nfsdstats.th_fullcnt++;
}
}
/*
* This is the NFS server kernel thread
*/
static void
nfsd(struct svc_rqst *rqstp)
{
struct svc_serv *serv = rqstp->rq_server;
int err;
struct nfsd_list me;
/* Lock module and set up kernel thread */
MOD_INC_USE_COUNT;
lock_kernel();
daemonize();
sprintf(current->comm, "nfsd");
current->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
nfsdstats.th_cnt++;
/* Let svc_process check client's authentication. */
rqstp->rq_auth = 1;
lockd_up(); /* start lockd */
me.task = current;
list_add(&me.list, &nfsd_list);
/*
* The main request loop
*/
for (;;) {
/* Block all but the shutdown signals */
spin_lock_irq(¤t->sigmask_lock);
siginitsetinv(¤t->blocked, SHUTDOWN_SIGS);
recalc_sigpending(current);
spin_unlock_irq(¤t->sigmask_lock);
/*
* Find a socket with data available and call its
* recvfrom routine.
*/
while ((err = svc_recv(serv, rqstp,
MAX_SCHEDULE_TIMEOUT)) == -EAGAIN)
;
if (err < 0)
break;
update_thread_usage(nfsd_busy);
nfsd_busy++;
/* Lock the export hash tables for reading. */
exp_readlock();
/* Validate the client's address. This will also defeat
* port probes on port 2049 by unauthorized clients.
*/
rqstp->rq_client = exp_getclient(&rqstp->rq_addr);
/* Process request with signals blocked. */
spin_lock_irq(¤t->sigmask_lock);
siginitsetinv(¤t->blocked, ALLOWED_SIGS);
recalc_sigpending(current);
spin_unlock_irq(¤t->sigmask_lock);
svc_process(serv, rqstp);
/* Unlock export hash tables */
exp_unlock();
update_thread_usage(nfsd_busy);
nfsd_busy--;
}
if (err != -EINTR) {
printk(KERN_WARNING "nfsd: terminating on error %d\n", -err);
} else {
unsigned int signo;
for (signo = 1; signo <= _NSIG; signo++)
if (sigismember(¤t->pending.signal, signo) &&
!sigismember(¤t->blocked, signo))
break;
err = signo;
}
/* Release lockd */
lockd_down();
/* Check if this is last thread */
if (serv->sv_nrthreads==1) {
printk(KERN_WARNING "nfsd: last server has exited\n");
if (err != SIG_NOCLEAN) {
printk(KERN_WARNING "nfsd: unexporting all filesystems\n");
nfsd_export_shutdown();
}
nfsd_serv = NULL;
nfsd_racache_shutdown(); /* release read-ahead cache */
}
list_del(&me.list);
nfsdstats.th_cnt --;
/* Release the thread */
svc_exit_thread(rqstp);
/* Release module */
MOD_DEC_USE_COUNT;
}
static int
nfsd_dispatch(struct svc_rqst *rqstp, u32 *statp)
{
struct svc_procedure *proc;
kxdrproc_t xdr;
u32 nfserr;
dprintk("nfsd_dispatch: vers %d proc %d\n",
rqstp->rq_vers, rqstp->rq_proc);
proc = rqstp->rq_procinfo;
/* Check whether we have this call in the cache. */
switch (nfsd_cache_lookup(rqstp, proc->pc_cachetype)) {
case RC_INTR:
case RC_DROPIT:
return 0;
case RC_REPLY:
return 1;
case RC_DOIT:;
/* do it */
}
/* Decode arguments */
xdr = proc->pc_decode;
if (xdr && !xdr(rqstp, rqstp->rq_argbuf.buf, rqstp->rq_argp)) {
dprintk("nfsd: failed to decode arguments!\n");
nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
*statp = rpc_garbage_args;
return 1;
}
/* Now call the procedure handler, and encode NFS status. */
nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
if (nfserr == nfserr_dropit) {
dprintk("nfsd: Dropping request due to malloc failure!\n");
nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
return 0;
}
if (rqstp->rq_proc != 0)
svc_putlong(&rqstp->rq_resbuf, nfserr);
/* Encode result.
* For NFSv2, additional info is never returned in case of an error.
*/
if (!(nfserr && rqstp->rq_vers == 2)) {
xdr = proc->pc_encode;
if (xdr && !xdr(rqstp, rqstp->rq_resbuf.buf, rqstp->rq_resp)) {
/* Failed to encode result. Release cache entry */
dprintk("nfsd: failed to encode result!\n");
nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
*statp = rpc_system_err;
return 1;
}
}
/* Store reply in cache. */
nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
return 1;
}
static struct svc_version nfsd_version2 = {
2, 18, nfsd_procedures2, nfsd_dispatch
};
#ifdef CONFIG_NFSD_V3
static struct svc_version nfsd_version3 = {
3, 22, nfsd_procedures3, nfsd_dispatch
};
#endif
static struct svc_version * nfsd_version[] = {
NULL,
NULL,
&nfsd_version2,
#ifdef CONFIG_NFSD_V3
&nfsd_version3,
#endif
};
#define NFSD_NRVERS (sizeof(nfsd_version)/sizeof(nfsd_version[0]))
struct svc_program nfsd_program = {
NFS_PROGRAM, /* program number */
2, NFSD_NRVERS-1, /* version range */
NFSD_NRVERS, /* nr of entries in nfsd_version */
nfsd_version, /* version table */
"nfsd", /* program name */
&nfsd_svcstats, /* version table */
};
|