[deliverable/linux.git] / 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>
 */

#include <linux/sched.h>
#include <linux/freezer.h>
#include <linux/module.h>
#include <linux/fs_struct.h>
#include <linux/swap.h>

#include <linux/sunrpc/stats.h>
#include <linux/sunrpc/svcsock.h>
#include <linux/lockd/bind.h>
#include <linux/nfsacl.h>
#include <linux/seq_file.h>
#include <net/net_namespace.h>
#include "nfsd.h"
#include "cache.h"
#include "vfs.h"

#define NFSDDBG_FACILITY	NFSDDBG_SVC

extern struct svc_program	nfsd_program;
static int			nfsd(void *vrqstp);
struct timeval			nfssvc_boot;

/*
 * nfsd_mutex protects nfsd_serv -- both the pointer itself and the members
 * of the svc_serv struct. In particular, ->sv_nrthreads but also to some
 * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
 *
 * If (out side the lock) nfsd_serv is non-NULL, then it must point to a
 * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
 * of nfsd threads must exist and each must listed in ->sp_all_threads in each
 * entry of ->sv_pools[].
 *
 * Transitions of the thread count between zero and non-zero are of particular
 * interest since the svc_serv needs to be created and initialized at that
 * point, or freed.
 *
 * Finally, the nfsd_mutex also protects some of the global variables that are
 * accessed when nfsd starts and that are settable via the write_* routines in
 * nfsctl.c. In particular:
 *
 *	user_recovery_dirname
 *	user_lease_time
 *	nfsd_versions
 */
DEFINE_MUTEX(nfsd_mutex);
struct svc_serv 		*nfsd_serv;

/*
 * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used.
 * nfsd_drc_max_pages limits the total amount of memory available for
 * version 4.1 DRC caches.
 * nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage.
 */
spinlock_t	nfsd_drc_lock;
unsigned int	nfsd_drc_max_mem;
unsigned int	nfsd_drc_mem_used;

#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
static struct svc_stat	nfsd_acl_svcstats;
static struct svc_version *	nfsd_acl_version[] = {
	[2] = &nfsd_acl_version2,
	[3] = &nfsd_acl_version3,
};

#define NFSD_ACL_MINVERS            2
#define NFSD_ACL_NRVERS		ARRAY_SIZE(nfsd_acl_version)
static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];

static struct svc_program	nfsd_acl_program = {
	.pg_prog		= NFS_ACL_PROGRAM,
	.pg_nvers		= NFSD_ACL_NRVERS,
	.pg_vers		= nfsd_acl_versions,
	.pg_name		= "nfsacl",
	.pg_class		= "nfsd",
	.pg_stats		= &nfsd_acl_svcstats,
	.pg_authenticate	= &svc_set_client,
};

static struct svc_stat	nfsd_acl_svcstats = {
	.program	= &nfsd_acl_program,
};
#endif /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */

static struct svc_version *	nfsd_version[] = {
	[2] = &nfsd_version2,
#if defined(CONFIG_NFSD_V3)
	[3] = &nfsd_version3,
#endif
#if defined(CONFIG_NFSD_V4)
	[4] = &nfsd_version4,
#endif
};

#define NFSD_MINVERS    	2
#define NFSD_NRVERS		ARRAY_SIZE(nfsd_version)
static struct svc_version *nfsd_versions[NFSD_NRVERS];

struct svc_program		nfsd_program = {
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
	.pg_next		= &nfsd_acl_program,
#endif
	.pg_prog		= NFS_PROGRAM,		/* program number */
	.pg_nvers		= NFSD_NRVERS,		/* nr of entries in nfsd_version */
	.pg_vers		= nfsd_versions,	/* version table */
	.pg_name		= "nfsd",		/* program name */
	.pg_class		= "nfsd",		/* authentication class */
	.pg_stats		= &nfsd_svcstats,	/* version table */
	.pg_authenticate	= &svc_set_client,	/* export authentication */

};

u32 nfsd_supported_minorversion;

int nfsd_vers(int vers, enum vers_op change)
{
	if (vers < NFSD_MINVERS || vers >= NFSD_NRVERS)
		return 0;
	switch(change) {
	case NFSD_SET:
		nfsd_versions[vers] = nfsd_version[vers];
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
		if (vers < NFSD_ACL_NRVERS)
			nfsd_acl_versions[vers] = nfsd_acl_version[vers];
#endif
		break;
	case NFSD_CLEAR:
		nfsd_versions[vers] = NULL;
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
		if (vers < NFSD_ACL_NRVERS)
			nfsd_acl_versions[vers] = NULL;
#endif
		break;
	case NFSD_TEST:
		return nfsd_versions[vers] != NULL;
	case NFSD_AVAIL:
		return nfsd_version[vers] != NULL;
	}
	return 0;
}

int nfsd_minorversion(u32 minorversion, enum vers_op change)
{
	if (minorversion > NFSD_SUPPORTED_MINOR_VERSION)
		return -1;
	switch(change) {
	case NFSD_SET:
		nfsd_supported_minorversion = minorversion;
		break;
	case NFSD_CLEAR:
		if (minorversion == 0)
			return -1;
		nfsd_supported_minorversion = minorversion - 1;
		break;
	case NFSD_TEST:
		return minorversion <= nfsd_supported_minorversion;
	case NFSD_AVAIL:
		return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
	}
	return 0;
}

/*
 * Maximum number of nfsd processes
 */
#define	NFSD_MAXSERVS		8192

int nfsd_nrthreads(void)
{
	int rv = 0;
	mutex_lock(&nfsd_mutex);
	if (nfsd_serv)
		rv = nfsd_serv->sv_nrthreads;
	mutex_unlock(&nfsd_mutex);
	return rv;
}

static int nfsd_init_socks(struct net *net)
{
	int error;
	if (!list_empty(&nfsd_serv->sv_permsocks))
		return 0;

	error = svc_create_xprt(nfsd_serv, "udp", net, PF_INET, NFS_PORT,
					SVC_SOCK_DEFAULTS);
	if (error < 0)
		return error;

	error = svc_create_xprt(nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
					SVC_SOCK_DEFAULTS);
	if (error < 0)
		return error;

	return 0;
}

static bool nfsd_up = false;

static int nfsd_startup(int nrservs, struct net *net)
{
	int ret;

	if (nfsd_up)
		return 0;
	/*
	 * Readahead param cache - will no-op if it already exists.
	 * (Note therefore results will be suboptimal if number of
	 * threads is modified after nfsd start.)
	 */
	ret = nfsd_racache_init(2*nrservs);
	if (ret)
		return ret;
	ret = nfsd_init_socks(net);
	if (ret)
		goto out_racache;
	ret = lockd_up(net);
	if (ret)
		goto out_racache;
	ret = nfs4_state_start();
	if (ret)
		goto out_lockd;

	ret = nfs4_state_start_net(net);
	if (ret)
		goto out_net_state;

	nfsd_up = true;
	return 0;
out_net_state:
	nfs4_state_shutdown();
out_lockd:
	lockd_down(net);
out_racache:
	nfsd_racache_shutdown();
	return ret;
}

static void nfsd_shutdown(struct net *net)
{
	/*
	 * write_ports can create the server without actually starting
	 * any threads--if we get shut down before any threads are
	 * started, then nfsd_last_thread will be run before any of this
	 * other initialization has been done.
	 */
	if (!nfsd_up)
		return;
	nfs4_state_shutdown_net(net);
	nfs4_state_shutdown();
	lockd_down(net);
	nfsd_racache_shutdown();
	nfsd_up = false;
}

static void nfsd_last_thread(struct svc_serv *serv, struct net *net)
{
	nfsd_shutdown(net);

	svc_rpcb_cleanup(serv, net);

	printk(KERN_WARNING "nfsd: last server has exited, flushing export "
			    "cache\n");
	nfsd_export_flush(net);
}

void nfsd_reset_versions(void)
{
	int found_one = 0;
	int i;

	for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
		if (nfsd_program.pg_vers[i])
			found_one = 1;
	}

	if (!found_one) {
		for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
			nfsd_program.pg_vers[i] = nfsd_version[i];
#if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
		for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
			nfsd_acl_program.pg_vers[i] =
				nfsd_acl_version[i];
#endif
	}
}

/*
 * Each session guarantees a negotiated per slot memory cache for replies
 * which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated
 * NFSv4.1 server might want to use more memory for a DRC than a machine
 * with mutiple services.
 *
 * Impose a hard limit on the number of pages for the DRC which varies
 * according to the machines free pages. This is of course only a default.
 *
 * For now this is a #defined shift which could be under admin control
 * in the future.
 */
static void set_max_drc(void)
{
	#define NFSD_DRC_SIZE_SHIFT	10
	nfsd_drc_max_mem = (nr_free_buffer_pages()
					>> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE;
	nfsd_drc_mem_used = 0;
	spin_lock_init(&nfsd_drc_lock);
	dprintk("%s nfsd_drc_max_mem %u \n", __func__, nfsd_drc_max_mem);
}

static int nfsd_get_default_max_blksize(void)
{
	struct sysinfo i;
	unsigned long long target;
	unsigned long ret;

	si_meminfo(&i);
	target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
	/*
	 * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
	 * machines, but only uses 32K on 128M machines.  Bottom out at
	 * 8K on 32M and smaller.  Of course, this is only a default.
	 */
	target >>= 12;

	ret = NFSSVC_MAXBLKSIZE;
	while (ret > target && ret >= 8*1024*2)
		ret /= 2;
	return ret;
}

int nfsd_create_serv(struct net *net)
{
	int error;

	WARN_ON(!mutex_is_locked(&nfsd_mutex));
	if (nfsd_serv) {
		svc_get(nfsd_serv);
		return 0;
	}
	if (nfsd_max_blksize == 0)
		nfsd_max_blksize = nfsd_get_default_max_blksize();
	nfsd_reset_versions();
	nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
				      nfsd_last_thread, nfsd, THIS_MODULE);
	if (nfsd_serv == NULL)
		return -ENOMEM;

	error = svc_bind(nfsd_serv, net);
	if (error < 0) {
		svc_destroy(nfsd_serv);
		return error;
	}

	set_max_drc();
	do_gettimeofday(&nfssvc_boot);		/* record boot time */
	return 0;
}

int nfsd_nrpools(void)
{
	if (nfsd_serv == NULL)
		return 0;
	else
		return nfsd_serv->sv_nrpools;
}

int nfsd_get_nrthreads(int n, int *nthreads)
{
	int i = 0;

	if (nfsd_serv != NULL) {
		for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
			nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
	}

	return 0;
}

int nfsd_set_nrthreads(int n, int *nthreads)
{
	int i = 0;
	int tot = 0;
	int err = 0;
	struct net *net = &init_net;

	WARN_ON(!mutex_is_locked(&nfsd_mutex));

	if (nfsd_serv == NULL || n <= 0)
		return 0;

	if (n > nfsd_serv->sv_nrpools)
		n = nfsd_serv->sv_nrpools;

	/* enforce a global maximum number of threads */
	tot = 0;
	for (i = 0; i < n; i++) {
		if (nthreads[i] > NFSD_MAXSERVS)
			nthreads[i] = NFSD_MAXSERVS;
		tot += nthreads[i];
	}
	if (tot > NFSD_MAXSERVS) {
		/* total too large: scale down requested numbers */
		for (i = 0; i < n && tot > 0; i++) {
		    	int new = nthreads[i] * NFSD_MAXSERVS / tot;
			tot -= (nthreads[i] - new);
			nthreads[i] = new;
		}
		for (i = 0; i < n && tot > 0; i++) {
			nthreads[i]--;
			tot--;
		}
	}

	/*
	 * There must always be a thread in pool 0; the admin
	 * can't shut down NFS completely using pool_threads.
	 */
	if (nthreads[0] == 0)
		nthreads[0] = 1;

	/* apply the new numbers */
	svc_get(nfsd_serv);
	for (i = 0; i < n; i++) {
		err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
				    	  nthreads[i]);
		if (err)
			break;
	}
	nfsd_destroy(net);
	return err;
}

/*
 * Adjust the number of threads and return the new number of threads.
 * This is also the function that starts the server if necessary, if
 * this is the first time nrservs is nonzero.
 */
int
nfsd_svc(int nrservs, struct net *net)
{
	int	error;
	bool	nfsd_up_before;

	mutex_lock(&nfsd_mutex);
	dprintk("nfsd: creating service\n");
	if (nrservs <= 0)
		nrservs = 0;
	if (nrservs > NFSD_MAXSERVS)
		nrservs = NFSD_MAXSERVS;
	error = 0;
	if (nrservs == 0 && nfsd_serv == NULL)
		goto out;

	error = nfsd_create_serv(net);
	if (error)
		goto out;

	nfsd_up_before = nfsd_up;

	error = nfsd_startup(nrservs, net);
	if (error)
		goto out_destroy;
	error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
	if (error)
		goto out_shutdown;
	/* We are holding a reference to nfsd_serv which
	 * we don't want to count in the return value,
	 * so subtract 1
	 */
	error = nfsd_serv->sv_nrthreads - 1;
out_shutdown:
	if (error < 0 && !nfsd_up_before)
		nfsd_shutdown(net);
out_destroy:
	nfsd_destroy(net);		/* Release server */
out:
	mutex_unlock(&nfsd_mutex);
	return error;
}


/*
 * This is the NFS server kernel thread
 */
static int
nfsd(void *vrqstp)
{
	struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
	int err;

	/* Lock module and set up kernel thread */
	mutex_lock(&nfsd_mutex);

	/* At this point, the thread shares current->fs
	 * with the init process. We need to create files with a
	 * umask of 0 instead of init's umask. */
	if (unshare_fs_struct() < 0) {
		printk("Unable to start nfsd thread: out of memory\n");
		goto out;
	}

	current->fs->umask = 0;

	/*
	 * thread is spawned with all signals set to SIG_IGN, re-enable
	 * the ones that will bring down the thread
	 */
	allow_signal(SIGKILL);
	allow_signal(SIGHUP);
	allow_signal(SIGINT);
	allow_signal(SIGQUIT);

	nfsdstats.th_cnt++;
	mutex_unlock(&nfsd_mutex);

	/*
	 * We want less throttling in balance_dirty_pages() so that nfs to
	 * localhost doesn't cause nfsd to lock up due to all the client's
	 * dirty pages.
	 */
	current->flags |= PF_LESS_THROTTLE;
	set_freezable();

	/*
	 * The main request loop
	 */
	for (;;) {
		/*
		 * Find a socket with data available and call its
		 * recvfrom routine.
		 */
		while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
			;
		if (err == -EINTR)
			break;
		validate_process_creds();
		svc_process(rqstp);
		validate_process_creds();
	}

	/* Clear signals before calling svc_exit_thread() */
	flush_signals(current);

	mutex_lock(&nfsd_mutex);
	nfsdstats.th_cnt --;

out:
	rqstp->rq_server = NULL;

	/* Release the thread */
	svc_exit_thread(rqstp);

	nfsd_destroy(&init_net);

	/* Release module */
	mutex_unlock(&nfsd_mutex);
	module_put_and_exit(0);
	return 0;
}

static __be32 map_new_errors(u32 vers, __be32 nfserr)
{
	if (nfserr == nfserr_jukebox && vers == 2)
		return nfserr_dropit;
	if (nfserr == nfserr_wrongsec && vers < 4)
		return nfserr_acces;
	return nfserr;
}

int
nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
{
	struct svc_procedure	*proc;
	kxdrproc_t		xdr;
	__be32			nfserr;
	__be32			*nfserrp;

	dprintk("nfsd_dispatch: vers %d proc %d\n",
				rqstp->rq_vers, rqstp->rq_proc);
	proc = rqstp->rq_procinfo;

	/*
	 * Give the xdr decoder a chance to change this if it wants
	 * (necessary in the NFSv4.0 compound case)
	 */
	rqstp->rq_cachetype = proc->pc_cachetype;
	/* Decode arguments */
	xdr = proc->pc_decode;
	if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
			rqstp->rq_argp)) {
		dprintk("nfsd: failed to decode arguments!\n");
		*statp = rpc_garbage_args;
		return 1;
	}

	/* Check whether we have this call in the cache. */
	switch (nfsd_cache_lookup(rqstp)) {
	case RC_INTR:
	case RC_DROPIT:
		return 0;
	case RC_REPLY:
		return 1;
	case RC_DOIT:;
		/* do it */
	}

	/* need to grab the location to store the status, as
	 * nfsv4 does some encoding while processing 
	 */
	nfserrp = rqstp->rq_res.head[0].iov_base
		+ rqstp->rq_res.head[0].iov_len;
	rqstp->rq_res.head[0].iov_len += sizeof(__be32);

	/* Now call the procedure handler, and encode NFS status. */
	nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
	nfserr = map_new_errors(rqstp->rq_vers, nfserr);
	if (nfserr == nfserr_dropit || rqstp->rq_dropme) {
		dprintk("nfsd: Dropping request; may be revisited later\n");
		nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
		return 0;
	}

	if (rqstp->rq_proc != 0)
		*nfserrp++ = 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, nfserrp,
				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, rqstp->rq_cachetype, statp + 1);
	return 1;
}

int nfsd_pool_stats_open(struct inode *inode, struct file *file)
{
	int ret;
	mutex_lock(&nfsd_mutex);
	if (nfsd_serv == NULL) {
		mutex_unlock(&nfsd_mutex);
		return -ENODEV;
	}
	/* bump up the psudo refcount while traversing */
	svc_get(nfsd_serv);
	ret = svc_pool_stats_open(nfsd_serv, file);
	mutex_unlock(&nfsd_mutex);
	return ret;
}

int nfsd_pool_stats_release(struct inode *inode, struct file *file)
{
	int ret = seq_release(inode, file);
	struct net *net = &init_net;

	mutex_lock(&nfsd_mutex);
	/* this function really, really should have been called svc_put() */
	nfsd_destroy(net);
	mutex_unlock(&nfsd_mutex);
	return ret;
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Central processing for nfsd.
	3	*
	4	* Authors: Olaf Kirch (okir@monad.swb.de)
	5	*
	6	* Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
	7	*/
	8
e8edc6e0	9	#include <linux/sched.h>
83144186	10	#include <linux/freezer.h>
143cb494	11	#include <linux/module.h>
1da177e4	12	#include <linux/fs_struct.h>
c3d06f9c	13	#include <linux/swap.h>
1da177e4	14
1da177e4	15	#include <linux/sunrpc/stats.h>
1da177e4	16	#include <linux/sunrpc/svcsock.h>
1da177e4	17	#include <linux/lockd/bind.h>
a257cdd0	18	#include <linux/nfsacl.h>
ed2d8aed	19	#include <linux/seq_file.h>
fc5d00b0	20	#include <net/net_namespace.h>
9a74af21 BH	21	#include "nfsd.h"
9a74af21 BH	22	#include "cache.h"
0a3adade	23	#include "vfs.h"
1da177e4 LT	24
	25	#define NFSDDBG_FACILITY NFSDDBG_SVC
	26
1da177e4	27	extern struct svc_program nfsd_program;
9867d76c	28	static int nfsd(void *vrqstp);
1da177e4	29	struct timeval nfssvc_boot;
1da177e4	30
bedbdd8b NB	31	/*
	32	* nfsd_mutex protects nfsd_serv -- both the pointer itself and the members
	33	* of the svc_serv struct. In particular, ->sv_nrthreads but also to some
	34	* extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
	35	*
	36	* If (out side the lock) nfsd_serv is non-NULL, then it must point to a
	37	* properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
	38	* of nfsd threads must exist and each must listed in ->sp_all_threads in each
	39	* entry of ->sv_pools[].
	40	*
	41	* Transitions of the thread count between zero and non-zero are of particular
	42	* interest since the svc_serv needs to be created and initialized at that
	43	* point, or freed.
3dd98a3b JL	44	*
	45	* Finally, the nfsd_mutex also protects some of the global variables that are
	46	* accessed when nfsd starts and that are settable via the write_* routines in
	47	* nfsctl.c. In particular:
	48	*
	49	* user_recovery_dirname
	50	* user_lease_time
	51	* nfsd_versions
bedbdd8b NB	52	*/
	53	DEFINE_MUTEX(nfsd_mutex);
	54	struct svc_serv *nfsd_serv;
	55
4bd9b0f4 AA	56	/*
	57	* nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used.
	58	* nfsd_drc_max_pages limits the total amount of memory available for
	59	* version 4.1 DRC caches.
	60	* nfsd_drc_pages_used tracks the current version 4.1 DRC memory usage.
	61	*/
	62	spinlock_t nfsd_drc_lock;
0c193054 AA	63	unsigned int nfsd_drc_max_mem;
0c193054 AA	64	unsigned int nfsd_drc_mem_used;
4bd9b0f4	65
3fb803a9 AG	66	#if defined(CONFIG_NFSD_V2_ACL) \|\| defined(CONFIG_NFSD_V3_ACL)
	67	static struct svc_stat nfsd_acl_svcstats;
	68	static struct svc_version * nfsd_acl_version[] = {
	69	[2] = &nfsd_acl_version2,
	70	[3] = &nfsd_acl_version3,
	71	};
	72
	73	#define NFSD_ACL_MINVERS 2
e8c96f8c	74	#define NFSD_ACL_NRVERS ARRAY_SIZE(nfsd_acl_version)
3fb803a9 AG	75	static struct svc_version *nfsd_acl_versions[NFSD_ACL_NRVERS];
	76
	77	static struct svc_program nfsd_acl_program = {
	78	.pg_prog = NFS_ACL_PROGRAM,
	79	.pg_nvers = NFSD_ACL_NRVERS,
	80	.pg_vers = nfsd_acl_versions,
1a8eff6d	81	.pg_name = "nfsacl",
3fb803a9 AG	82	.pg_class = "nfsd",
	83	.pg_stats = &nfsd_acl_svcstats,
	84	.pg_authenticate = &svc_set_client,
	85	};
	86
	87	static struct svc_stat nfsd_acl_svcstats = {
	88	.program = &nfsd_acl_program,
	89	};
	90	#endif /* defined(CONFIG_NFSD_V2_ACL) \|\| defined(CONFIG_NFSD_V3_ACL) */
	91
70c3b76c N	92	static struct svc_version * nfsd_version[] = {
	93	[2] = &nfsd_version2,
	94	#if defined(CONFIG_NFSD_V3)
	95	[3] = &nfsd_version3,
	96	#endif
	97	#if defined(CONFIG_NFSD_V4)
	98	[4] = &nfsd_version4,
	99	#endif
	100	};
	101
	102	#define NFSD_MINVERS 2
e8c96f8c	103	#define NFSD_NRVERS ARRAY_SIZE(nfsd_version)
70c3b76c N	104	static struct svc_version *nfsd_versions[NFSD_NRVERS];
	105
	106	struct svc_program nfsd_program = {
3fb803a9 AG	107	#if defined(CONFIG_NFSD_V2_ACL) \|\| defined(CONFIG_NFSD_V3_ACL)
	108	.pg_next = &nfsd_acl_program,
	109	#endif
70c3b76c N	110	.pg_prog = NFS_PROGRAM, /* program number */
	111	.pg_nvers = NFSD_NRVERS, /* nr of entries in nfsd_version */
	112	.pg_vers = nfsd_versions, /* version table */
	113	.pg_name = "nfsd", /* program name */
	114	.pg_class = "nfsd", /* authentication class */
	115	.pg_stats = &nfsd_svcstats, /* version table */
	116	.pg_authenticate = &svc_set_client, /* export authentication */
	117
	118	};
	119
8daf220a BH	120	u32 nfsd_supported_minorversion;
8daf220a BH	121
6658d3a7 N	122	int nfsd_vers(int vers, enum vers_op change)
	123	{
	124	if (vers < NFSD_MINVERS \|\| vers >= NFSD_NRVERS)
15ddb4ae	125	return 0;
6658d3a7 N	126	switch(change) {
	127	case NFSD_SET:
	128	nfsd_versions[vers] = nfsd_version[vers];
6658d3a7 N	129	#if defined(CONFIG_NFSD_V2_ACL) \|\| defined(CONFIG_NFSD_V3_ACL)
6658d3a7 N	130	if (vers < NFSD_ACL_NRVERS)
1a8eff6d	131	nfsd_acl_versions[vers] = nfsd_acl_version[vers];
6658d3a7	132	#endif
1a8eff6d	133	break;
6658d3a7 N	134	case NFSD_CLEAR:
	135	nfsd_versions[vers] = NULL;
	136	#if defined(CONFIG_NFSD_V2_ACL) \|\| defined(CONFIG_NFSD_V3_ACL)
	137	if (vers < NFSD_ACL_NRVERS)
1a8eff6d	138	nfsd_acl_versions[vers] = NULL;
6658d3a7 N	139	#endif
	140	break;
	141	case NFSD_TEST:
	142	return nfsd_versions[vers] != NULL;
	143	case NFSD_AVAIL:
	144	return nfsd_version[vers] != NULL;
	145	}
	146	return 0;
	147	}
8daf220a BH	148
	149	int nfsd_minorversion(u32 minorversion, enum vers_op change)
	150	{
	151	if (minorversion > NFSD_SUPPORTED_MINOR_VERSION)
	152	return -1;
	153	switch(change) {
	154	case NFSD_SET:
	155	nfsd_supported_minorversion = minorversion;
	156	break;
	157	case NFSD_CLEAR:
	158	if (minorversion == 0)
	159	return -1;
	160	nfsd_supported_minorversion = minorversion - 1;
	161	break;
	162	case NFSD_TEST:
	163	return minorversion <= nfsd_supported_minorversion;
	164	case NFSD_AVAIL:
	165	return minorversion <= NFSD_SUPPORTED_MINOR_VERSION;
	166	}
	167	return 0;
	168	}
	169
1da177e4 LT	170	/*
	171	* Maximum number of nfsd processes
	172	*/
	173	#define NFSD_MAXSERVS 8192
	174
	175	int nfsd_nrthreads(void)
	176	{
c7d106c9 NB	177	int rv = 0;
	178	mutex_lock(&nfsd_mutex);
	179	if (nfsd_serv)
	180	rv = nfsd_serv->sv_nrthreads;
	181	mutex_unlock(&nfsd_mutex);
	182	return rv;
1da177e4 LT	183	}
1da177e4 LT	184
db6e182c	185	static int nfsd_init_socks(struct net *net)
59db4a0c BF	186	{
	187	int error;
	188	if (!list_empty(&nfsd_serv->sv_permsocks))
	189	return 0;
	190
db6e182c	191	error = svc_create_xprt(nfsd_serv, "udp", net, PF_INET, NFS_PORT,
59db4a0c BF	192	SVC_SOCK_DEFAULTS);
	193	if (error < 0)
	194	return error;
	195
db6e182c	196	error = svc_create_xprt(nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
59db4a0c BF	197	SVC_SOCK_DEFAULTS);
	198	if (error < 0)
	199	return error;
	200
	201	return 0;
	202	}
	203
4ad9a344 JL	204	static bool nfsd_up = false;
4ad9a344 JL	205
db42d1a7	206	static int nfsd_startup(int nrservs, struct net *net)
4ad9a344 JL	207	{
4ad9a344 JL	208	int ret;
774f8bbd BF	209
	210	if (nfsd_up)
	211	return 0;
59db4a0c BF	212	/*
	213	* Readahead param cache - will no-op if it already exists.
	214	* (Note therefore results will be suboptimal if number of
	215	* threads is modified after nfsd start.)
	216	*/
	217	ret = nfsd_racache_init(2*nrservs);
	218	if (ret)
	219	return ret;
db6e182c	220	ret = nfsd_init_socks(net);
59db4a0c BF	221	if (ret)
59db4a0c BF	222	goto out_racache;
f252bc68	223	ret = lockd_up(net);
ac77efbe	224	if (ret)
774f8bbd	225	goto out_racache;
4ad9a344	226	ret = nfs4_state_start();
ac77efbe JL	227	if (ret)
ac77efbe JL	228	goto out_lockd;
f252bc68 SK	229
	230	ret = nfs4_state_start_net(net);
	231	if (ret)
	232	goto out_net_state;
	233
4ad9a344	234	nfsd_up = true;
ac77efbe	235	return 0;
f252bc68 SK	236	out_net_state:
f252bc68 SK	237	nfs4_state_shutdown();
ac77efbe	238	out_lockd:
db42d1a7	239	lockd_down(net);
59db4a0c BF	240	out_racache:
59db4a0c BF	241	nfsd_racache_shutdown();
4ad9a344 JL	242	return ret;
	243	}
	244
db42d1a7	245	static void nfsd_shutdown(struct net *net)
4ad9a344 JL	246	{
	247	/*
	248	* write_ports can create the server without actually starting
	249	* any threads--if we get shut down before any threads are
	250	* started, then nfsd_last_thread will be run before any of this
	251	* other initialization has been done.
	252	*/
	253	if (!nfsd_up)
	254	return;
f252bc68	255	nfs4_state_shutdown_net(net);
4ad9a344	256	nfs4_state_shutdown();
f252bc68	257	lockd_down(net);
59db4a0c	258	nfsd_racache_shutdown();
4ad9a344 JL	259	nfsd_up = false;
	260	}
	261
5ecebb7c	262	static void nfsd_last_thread(struct svc_serv serv, struct net net)
bc591ccf	263	{
db42d1a7	264	nfsd_shutdown(net);
bc591ccf	265
5ecebb7c	266	svc_rpcb_cleanup(serv, net);
16d05870	267
e096bbc6 JL	268	printk(KERN_WARNING "nfsd: last server has exited, flushing export "
e096bbc6 JL	269	"cache\n");
b3853e0e	270	nfsd_export_flush(net);
bc591ccf	271	}
6658d3a7 N	272
	273	void nfsd_reset_versions(void)
	274	{
	275	int found_one = 0;
	276	int i;
	277
	278	for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++) {
	279	if (nfsd_program.pg_vers[i])
	280	found_one = 1;
	281	}
	282
	283	if (!found_one) {
	284	for (i = NFSD_MINVERS; i < NFSD_NRVERS; i++)
	285	nfsd_program.pg_vers[i] = nfsd_version[i];
	286	#if defined(CONFIG_NFSD_V2_ACL) \|\| defined(CONFIG_NFSD_V3_ACL)
	287	for (i = NFSD_ACL_MINVERS; i < NFSD_ACL_NRVERS; i++)
	288	nfsd_acl_program.pg_vers[i] =
	289	nfsd_acl_version[i];
	290	#endif
	291	}
	292	}
	293
c3d06f9c AA	294	/*
	295	* Each session guarantees a negotiated per slot memory cache for replies
	296	* which in turn consumes memory beyond the v2/v3/v4.0 server. A dedicated
	297	* NFSv4.1 server might want to use more memory for a DRC than a machine
	298	* with mutiple services.
	299	*
	300	* Impose a hard limit on the number of pages for the DRC which varies
	301	* according to the machines free pages. This is of course only a default.
	302	*
	303	* For now this is a #defined shift which could be under admin control
	304	* in the future.
	305	*/
	306	static void set_max_drc(void)
	307	{
6a14dd1a	308	#define NFSD_DRC_SIZE_SHIFT 10
0c193054 AA	309	nfsd_drc_max_mem = (nr_free_buffer_pages()
	310	>> NFSD_DRC_SIZE_SHIFT) * PAGE_SIZE;
	311	nfsd_drc_mem_used = 0;
4bd9b0f4	312	spin_lock_init(&nfsd_drc_lock);
0c193054	313	dprintk("%s nfsd_drc_max_mem %u \n", __func__, nfsd_drc_max_mem);
c3d06f9c	314	}
bedbdd8b	315
87b0fc7d	316	static int nfsd_get_default_max_blksize(void)
02a375f0	317	{
87b0fc7d BF	318	struct sysinfo i;
	319	unsigned long long target;
	320	unsigned long ret;
bedbdd8b	321
87b0fc7d	322	si_meminfo(&i);
508f9227	323	target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
87b0fc7d BF	324	/*
	325	* Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
	326	* machines, but only uses 32K on 128M machines. Bottom out at
	327	* 8K on 32M and smaller. Of course, this is only a default.
	328	*/
	329	target >>= 12;
	330
	331	ret = NFSSVC_MAXBLKSIZE;
	332	while (ret > target && ret >= 810242)
	333	ret /= 2;
	334	return ret;
	335	}
	336
6777436b	337	int nfsd_create_serv(struct net *net)
87b0fc7d	338	{
9793f7c8 SK	339	int error;
9793f7c8 SK	340
bedbdd8b	341	WARN_ON(!mutex_is_locked(&nfsd_mutex));
02a375f0	342	if (nfsd_serv) {
9a24ab57	343	svc_get(nfsd_serv);
02a375f0 N	344	return 0;
02a375f0 N	345	}
87b0fc7d BF	346	if (nfsd_max_blksize == 0)
87b0fc7d BF	347	nfsd_max_blksize = nfsd_get_default_max_blksize();
e844a7b9	348	nfsd_reset_versions();
e096bbc6	349	nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
a75c5d01	350	nfsd_last_thread, nfsd, THIS_MODULE);
02a375f0	351	if (nfsd_serv == NULL)
628b3687	352	return -ENOMEM;
bedbdd8b	353
57c8b13e	354	error = svc_bind(nfsd_serv, net);
9793f7c8 SK	355	if (error < 0) {
	356	svc_destroy(nfsd_serv);
	357	return error;
	358	}
	359
628b3687	360	set_max_drc();
02a375f0	361	do_gettimeofday(&nfssvc_boot); /* record boot time */
87b0fc7d	362	return 0;
02a375f0 N	363	}
02a375f0 N	364
eed2965a GB	365	int nfsd_nrpools(void)
	366	{
	367	if (nfsd_serv == NULL)
	368	return 0;
	369	else
	370	return nfsd_serv->sv_nrpools;
	371	}
	372
	373	int nfsd_get_nrthreads(int n, int *nthreads)
	374	{
	375	int i = 0;
	376
	377	if (nfsd_serv != NULL) {
	378	for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
	379	nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
	380	}
	381
	382	return 0;
	383	}
	384
	385	int nfsd_set_nrthreads(int n, int *nthreads)
	386	{
	387	int i = 0;
	388	int tot = 0;
	389	int err = 0;
786185b5	390	struct net *net = &init_net;
eed2965a	391
bedbdd8b NB	392	WARN_ON(!mutex_is_locked(&nfsd_mutex));
bedbdd8b NB	393
eed2965a GB	394	if (nfsd_serv == NULL \|\| n <= 0)
	395	return 0;
	396
	397	if (n > nfsd_serv->sv_nrpools)
	398	n = nfsd_serv->sv_nrpools;
	399
	400	/* enforce a global maximum number of threads */
	401	tot = 0;
	402	for (i = 0; i < n; i++) {
	403	if (nthreads[i] > NFSD_MAXSERVS)
	404	nthreads[i] = NFSD_MAXSERVS;
	405	tot += nthreads[i];
	406	}
	407	if (tot > NFSD_MAXSERVS) {
	408	/* total too large: scale down requested numbers */
	409	for (i = 0; i < n && tot > 0; i++) {
	410	int new = nthreads[i] * NFSD_MAXSERVS / tot;
	411	tot -= (nthreads[i] - new);
	412	nthreads[i] = new;
	413	}
	414	for (i = 0; i < n && tot > 0; i++) {
	415	nthreads[i]--;
	416	tot--;
	417	}
	418	}
	419
	420	/*
	421	* There must always be a thread in pool 0; the admin
	422	* can't shut down NFS completely using pool_threads.
	423	*/
	424	if (nthreads[0] == 0)
	425	nthreads[0] = 1;
	426
	427	/* apply the new numbers */
eed2965a GB	428	svc_get(nfsd_serv);
	429	for (i = 0; i < n; i++) {
	430	err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
	431	nthreads[i]);
	432	if (err)
	433	break;
	434	}
19f7e2ca	435	nfsd_destroy(net);
eed2965a GB	436	return err;
	437	}
	438
ac77efbe JL	439	/*
	440	* Adjust the number of threads and return the new number of threads.
	441	* This is also the function that starts the server if necessary, if
	442	* this is the first time nrservs is nonzero.
	443	*/
1da177e4	444	int
d41a9417	445	nfsd_svc(int nrservs, struct net *net)
1da177e4 LT	446	{
1da177e4 LT	447	int error;
774f8bbd	448	bool nfsd_up_before;
bedbdd8b NB	449
bedbdd8b NB	450	mutex_lock(&nfsd_mutex);
6658d3a7	451	dprintk("nfsd: creating service\n");
1da177e4 LT	452	if (nrservs <= 0)
	453	nrservs = 0;
	454	if (nrservs > NFSD_MAXSERVS)
	455	nrservs = NFSD_MAXSERVS;
671e1fcf N	456	error = 0;
	457	if (nrservs == 0 && nfsd_serv == NULL)
	458	goto out;
	459
6777436b	460	error = nfsd_create_serv(net);
02a375f0	461	if (error)
774f8bbd BF	462	goto out;
	463
	464	nfsd_up_before = nfsd_up;
	465
db42d1a7	466	error = nfsd_startup(nrservs, net);
af4718f3 BF	467	if (error)
af4718f3 BF	468	goto out_destroy;
774f8bbd BF	469	error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
	470	if (error)
	471	goto out_shutdown;
af4718f3 BF	472	/* We are holding a reference to nfsd_serv which
	473	* we don't want to count in the return value,
	474	* so subtract 1
	475	*/
	476	error = nfsd_serv->sv_nrthreads - 1;
4ad9a344	477	out_shutdown:
774f8bbd	478	if (error < 0 && !nfsd_up_before)
db42d1a7	479	nfsd_shutdown(net);
774f8bbd	480	out_destroy:
19f7e2ca	481	nfsd_destroy(net); /* Release server */
4ad9a344	482	out:
bedbdd8b	483	mutex_unlock(&nfsd_mutex);
1da177e4 LT	484	return error;
	485	}
	486
1da177e4 LT	487
	488	/*
	489	* This is the NFS server kernel thread
	490	*/
9867d76c JL	491	static int
9867d76c JL	492	nfsd(void *vrqstp)
1da177e4	493	{
9867d76c	494	struct svc_rqst rqstp = (struct svc_rqst ) vrqstp;
5b444cc9	495	int err;
1da177e4 LT	496
1da177e4 LT	497	/* Lock module and set up kernel thread */
bedbdd8b	498	mutex_lock(&nfsd_mutex);
1da177e4	499
9867d76c	500	/* At this point, the thread shares current->fs
1da177e4 LT	501	* with the init process. We need to create files with a
1da177e4 LT	502	* umask of 0 instead of init's umask. */
3e93cd67	503	if (unshare_fs_struct() < 0) {
1da177e4 LT	504	printk("Unable to start nfsd thread: out of memory\n");
	505	goto out;
	506	}
3e93cd67	507
1da177e4 LT	508	current->fs->umask = 0;
1da177e4 LT	509
9867d76c JL	510	/*
9867d76c JL	511	* thread is spawned with all signals set to SIG_IGN, re-enable
100766f8	512	* the ones that will bring down the thread
9867d76c	513	*/
100766f8 JL	514	allow_signal(SIGKILL);
	515	allow_signal(SIGHUP);
	516	allow_signal(SIGINT);
	517	allow_signal(SIGQUIT);
bedbdd8b	518
1da177e4	519	nfsdstats.th_cnt++;
bedbdd8b NB	520	mutex_unlock(&nfsd_mutex);
bedbdd8b NB	521
1da177e4 LT	522	/*
	523	* We want less throttling in balance_dirty_pages() so that nfs to
	524	* localhost doesn't cause nfsd to lock up due to all the client's
	525	* dirty pages.
	526	*/
	527	current->flags \|= PF_LESS_THROTTLE;
83144186	528	set_freezable();
1da177e4 LT	529
	530	/*
	531	* The main request loop
	532	*/
	533	for (;;) {
1da177e4 LT	534	/*
	535	* Find a socket with data available and call its
	536	* recvfrom routine.
	537	*/
6fb2b47f	538	while ((err = svc_recv(rqstp, 6060HZ)) == -EAGAIN)
1da177e4	539	;
9867d76c	540	if (err == -EINTR)
1da177e4	541	break;
e0e81739	542	validate_process_creds();
6fb2b47f	543	svc_process(rqstp);
e0e81739	544	validate_process_creds();
1da177e4 LT	545	}
1da177e4 LT	546
24e36663	547	/* Clear signals before calling svc_exit_thread() */
9e416052	548	flush_signals(current);
1da177e4	549
bedbdd8b	550	mutex_lock(&nfsd_mutex);
1da177e4 LT	551	nfsdstats.th_cnt --;
	552
	553	out:
57c8b13e	554	rqstp->rq_server = NULL;
786185b5	555
1da177e4 LT	556	/* Release the thread */
	557	svc_exit_thread(rqstp);
	558
57c8b13e SK	559	nfsd_destroy(&init_net);
57c8b13e SK	560
1da177e4	561	/* Release module */
bedbdd8b	562	mutex_unlock(&nfsd_mutex);
1da177e4	563	module_put_and_exit(0);
9867d76c	564	return 0;
1da177e4 LT	565	}
1da177e4 LT	566
32c1eb0c AA	567	static __be32 map_new_errors(u32 vers, __be32 nfserr)
	568	{
	569	if (nfserr == nfserr_jukebox && vers == 2)
	570	return nfserr_dropit;
	571	if (nfserr == nfserr_wrongsec && vers < 4)
	572	return nfserr_acces;
	573	return nfserr;
	574	}
	575
1da177e4	576	int
c7afef1f	577	nfsd_dispatch(struct svc_rqst rqstp, __be32 statp)
1da177e4 LT	578	{
	579	struct svc_procedure *proc;
	580	kxdrproc_t xdr;
ad451d38 AV	581	__be32 nfserr;
ad451d38 AV	582	__be32 *nfserrp;
1da177e4 LT	583
	584	dprintk("nfsd_dispatch: vers %d proc %d\n",
	585	rqstp->rq_vers, rqstp->rq_proc);
	586	proc = rqstp->rq_procinfo;
	587
1091006c BF	588	/*
	589	* Give the xdr decoder a chance to change this if it wants
	590	* (necessary in the NFSv4.0 compound case)
	591	*/
	592	rqstp->rq_cachetype = proc->pc_cachetype;
	593	/* Decode arguments */
	594	xdr = proc->pc_decode;
	595	if (xdr && !xdr(rqstp, (__be32*)rqstp->rq_arg.head[0].iov_base,
	596	rqstp->rq_argp)) {
	597	dprintk("nfsd: failed to decode arguments!\n");
	598	*statp = rpc_garbage_args;
	599	return 1;
	600	}
	601
1da177e4	602	/* Check whether we have this call in the cache. */
1091006c	603	switch (nfsd_cache_lookup(rqstp)) {
1da177e4 LT	604	case RC_INTR:
	605	case RC_DROPIT:
	606	return 0;
	607	case RC_REPLY:
	608	return 1;
	609	case RC_DOIT:;
	610	/* do it */
	611	}
	612
1da177e4 LT	613	/* need to grab the location to store the status, as
	614	* nfsv4 does some encoding while processing
	615	*/
	616	nfserrp = rqstp->rq_res.head[0].iov_base
	617	+ rqstp->rq_res.head[0].iov_len;
ad451d38	618	rqstp->rq_res.head[0].iov_len += sizeof(__be32);
1da177e4 LT	619
	620	/* Now call the procedure handler, and encode NFS status. */
	621	nfserr = proc->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
32c1eb0c	622	nfserr = map_new_errors(rqstp->rq_vers, nfserr);
9e701c61	623	if (nfserr == nfserr_dropit \|\| rqstp->rq_dropme) {
45457e09	624	dprintk("nfsd: Dropping request; may be revisited later\n");
1da177e4 LT	625	nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
	626	return 0;
	627	}
	628
	629	if (rqstp->rq_proc != 0)
	630	*nfserrp++ = nfserr;
	631
	632	/* Encode result.
	633	* For NFSv2, additional info is never returned in case of an error.
	634	*/
	635	if (!(nfserr && rqstp->rq_vers == 2)) {
	636	xdr = proc->pc_encode;
	637	if (xdr && !xdr(rqstp, nfserrp,
	638	rqstp->rq_resp)) {
	639	/* Failed to encode result. Release cache entry */
	640	dprintk("nfsd: failed to encode result!\n");
	641	nfsd_cache_update(rqstp, RC_NOCACHE, NULL);
	642	*statp = rpc_system_err;
	643	return 1;
	644	}
	645	}
	646
	647	/* Store reply in cache. */
57d276d7	648	nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
1da177e4 LT	649	return 1;
1da177e4 LT	650	}
03cf6c9f GB	651
	652	int nfsd_pool_stats_open(struct inode inode, struct file file)
	653	{
ed2d8aed RY	654	int ret;
	655	mutex_lock(&nfsd_mutex);
	656	if (nfsd_serv == NULL) {
	657	mutex_unlock(&nfsd_mutex);
03cf6c9f	658	return -ENODEV;
ed2d8aed RY	659	}
	660	/* bump up the psudo refcount while traversing */
	661	svc_get(nfsd_serv);
	662	ret = svc_pool_stats_open(nfsd_serv, file);
	663	mutex_unlock(&nfsd_mutex);
	664	return ret;
	665	}
	666
	667	int nfsd_pool_stats_release(struct inode inode, struct file file)
	668	{
	669	int ret = seq_release(inode, file);
786185b5 SK	670	struct net *net = &init_net;
786185b5 SK	671
ed2d8aed RY	672	mutex_lock(&nfsd_mutex);
ed2d8aed RY	673	/* this function really, really should have been called svc_put() */
19f7e2ca	674	nfsd_destroy(net);
ed2d8aed RY	675	mutex_unlock(&nfsd_mutex);
ed2d8aed RY	676	return ret;
03cf6c9f	677	}