Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 797a9d797f8483bb67f265c761b76dcd5a077a23

Authored by Jeff Layton 2012-03-29 19:52:49 +0800

Committed by J. Bruce Fields 2012-03-29 20:01:07 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

nfsd: only register cld pipe notifier when CONFIG_NFSD_V4 is enabled

Otherwise, we get a warning or error similar to this when building with
CONFIG_NFSD_V4 disabled:

    ERROR: "nfsd4_cld_block" [fs/nfsd/nfsd.ko] undefined!

Fix this by wrapping the calls to rpc_pipefs_notifier_register and
..._unregister in another function and providing no-op replacements
when CONFIG_NFSD_V4 is disabled.

Reported-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>

Showing 4 changed files with 21 additions and 5 deletions Inline Diff

fs/nfsd/netns.h
fs/nfsd/nfs4recover.c
fs/nfsd/nfsctl.c
fs/nfsd/nfsd.h

fs/nfsd/netns.h

Diff comments View file @ 797a9d7

 /*
  * per net namespace data structures for nfsd
  *
  * Copyright (C) 2012, Jeff Layton <jlayton@redhat.com>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program; if not, write to the Free Software Foundation, Inc., 51
  * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef __NFSD_NETNS_H__
 #define __NFSD_NETNS_H__
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
 struct cld_net;
 struct nfsd_net {
 	struct cld_net *cld_net;
 };
 extern int nfsd_net_id;
-extern struct notifier_block nfsd4_cld_block;
 #endif /* __NFSD_NETNS_H__ */

fs/nfsd/nfs4recover.c

Diff comments View file @ 797a9d7

 /*
 *  Copyright (c) 2004 The Regents of the University of Michigan.
 *  Copyright (c) 2012 Jeff Layton <jlayton@redhat.com>
 *  All rights reserved.
 *
 *  Andy Adamson <andros@citi.umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 #include <linux/file.h>
 #include <linux/slab.h>
 #include <linux/namei.h>
 #include <linux/crypto.h>
 #include <linux/sched.h>
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <net/net_namespace.h>
 #include <linux/sunrpc/rpc_pipe_fs.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/nfsd/cld.h>
 #include "nfsd.h"
 #include "state.h"
 #include "vfs.h"
 #include "netns.h"
 #define NFSDDBG_FACILITY                NFSDDBG_PROC
 /* Declarations */
 struct nfsd4_client_tracking_ops {
 	int (*init)(struct net *);
 	void (*exit)(struct net *);
 	void (*create)(struct nfs4_client *);
 	void (*remove)(struct nfs4_client *);
 	int (*check)(struct nfs4_client *);
 	void (*grace_done)(struct net *, time_t);
 };
 /* Globals */
 static struct file *rec_file;
 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
 static struct nfsd4_client_tracking_ops *client_tracking_ops;
 static int
 nfs4_save_creds(const struct cred **original_creds)
 {
 	struct cred *new;
 	new = prepare_creds();
 	if (!new)
 		return -ENOMEM;
 	new->fsuid = 0;
 	new->fsgid = 0;
 	*original_creds = override_creds(new);
 	put_cred(new);
 	return 0;
 }
 static void
 nfs4_reset_creds(const struct cred *original)
 {
 	revert_creds(original);
 }
 static void
 md5_to_hex(char *out, char *md5)
 {
 	int i;
 	for (i=0; i<16; i++) {
 		unsigned char c = md5[i];
 		*out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
 		*out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
 	}
 	*out = '\0';
 }
 __be32
 nfs4_make_rec_clidname(char *dname, struct xdr_netobj *clname)
 {
 	struct xdr_netobj cksum;
 	struct hash_desc desc;
 	struct scatterlist sg;
 	__be32 status = nfserr_jukebox;
 	dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
 			clname->len, clname->data);
 	desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 	desc.tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
 	if (IS_ERR(desc.tfm))
 		goto out_no_tfm;
 	cksum.len = crypto_hash_digestsize(desc.tfm);
 	cksum.data = kmalloc(cksum.len, GFP_KERNEL);
 	if (cksum.data == NULL)
  		goto out;
 	sg_init_one(&sg, clname->data, clname->len);
 	if (crypto_hash_digest(&desc, &sg, sg.length, cksum.data))
 		goto out;
 	md5_to_hex(dname, cksum.data);
 	status = nfs_ok;
 out:
 	kfree(cksum.data);
 	crypto_free_hash(desc.tfm);
 out_no_tfm:
 	return status;
 }
 static void
 nfsd4_create_clid_dir(struct nfs4_client *clp)
 {
 	const struct cred *original_cred;
 	char *dname = clp->cl_recdir;
 	struct dentry *dir, *dentry;
 	int status;
 	dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname);
 	if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
 		return;
 	if (!rec_file)
 		return;
 	status = nfs4_save_creds(&original_cred);
 	if (status < 0)
 		return;
 	dir = rec_file->f_path.dentry;
 	/* lock the parent */
 	mutex_lock(&dir->d_inode->i_mutex);
 	dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
 	if (IS_ERR(dentry)) {
 		status = PTR_ERR(dentry);
 		goto out_unlock;
 	}
 	if (dentry->d_inode)
 		/*
 		 * In the 4.1 case, where we're called from
 		 * reclaim_complete(), records from the previous reboot
 		 * may still be left, so this is OK.
 		 *
 		 * In the 4.0 case, we should never get here; but we may
 		 * as well be forgiving and just succeed silently.
 		 */
 		goto out_put;
 	status = mnt_want_write_file(rec_file);
 	if (status)
 		goto out_put;
 	status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
 	mnt_drop_write_file(rec_file);
 out_put:
 	dput(dentry);
 out_unlock:
 	mutex_unlock(&dir->d_inode->i_mutex);
 	if (status == 0)
 		vfs_fsync(rec_file, 0);
 	else
 		printk(KERN_ERR "NFSD: failed to write recovery record"
 				" (err %d); please check that %s exists"
 				" and is writeable", status,
 				user_recovery_dirname);
 	nfs4_reset_creds(original_cred);
 }
 typedef int (recdir_func)(struct dentry *, struct dentry *);
 struct name_list {
 	char name[HEXDIR_LEN];
 	struct list_head list;
 };
 static int
 nfsd4_build_namelist(void *arg, const char *name, int namlen,
 		loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct list_head *names = arg;
 	struct name_list *entry;
 	if (namlen != HEXDIR_LEN - 1)
 		return 0;
 	entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
 	if (entry == NULL)
 		return -ENOMEM;
 	memcpy(entry->name, name, HEXDIR_LEN - 1);
 	entry->name[HEXDIR_LEN - 1] = '\0';
 	list_add(&entry->list, names);
 	return 0;
 }
 static int
 nfsd4_list_rec_dir(recdir_func *f)
 {
 	const struct cred *original_cred;
 	struct dentry *dir = rec_file->f_path.dentry;
 	LIST_HEAD(names);
 	int status;
 	status = nfs4_save_creds(&original_cred);
 	if (status < 0)
 		return status;
 	status = vfs_llseek(rec_file, 0, SEEK_SET);
 	if (status < 0) {
 		nfs4_reset_creds(original_cred);
 		return status;
 	}
 	status = vfs_readdir(rec_file, nfsd4_build_namelist, &names);
 	mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
 	while (!list_empty(&names)) {
 		struct name_list *entry;
 		entry = list_entry(names.next, struct name_list, list);
 		if (!status) {
 			struct dentry *dentry;
 			dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);
 			if (IS_ERR(dentry)) {
 				status = PTR_ERR(dentry);
 				break;
 			}
 			status = f(dir, dentry);
 			dput(dentry);
 		}
 		list_del(&entry->list);
 		kfree(entry);
 	}
 	mutex_unlock(&dir->d_inode->i_mutex);
 	nfs4_reset_creds(original_cred);
 	return status;
 }
 static int
 nfsd4_unlink_clid_dir(char *name, int namlen)
 {
 	struct dentry *dir, *dentry;
 	int status;
 	dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
 	dir = rec_file->f_path.dentry;
 	mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
 	dentry = lookup_one_len(name, dir, namlen);
 	if (IS_ERR(dentry)) {
 		status = PTR_ERR(dentry);
 		goto out_unlock;
 	}
 	status = -ENOENT;
 	if (!dentry->d_inode)
 		goto out;
 	status = vfs_rmdir(dir->d_inode, dentry);
 out:
 	dput(dentry);
 out_unlock:
 	mutex_unlock(&dir->d_inode->i_mutex);
 	return status;
 }
 static void
 nfsd4_remove_clid_dir(struct nfs4_client *clp)
 {
 	const struct cred *original_cred;
 	int status;
 	if (!rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
 		return;
 	status = mnt_want_write_file(rec_file);
 	if (status)
 		goto out;
 	clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
 	status = nfs4_save_creds(&original_cred);
 	if (status < 0)
 		goto out;
 	status = nfsd4_unlink_clid_dir(clp->cl_recdir, HEXDIR_LEN-1);
 	nfs4_reset_creds(original_cred);
 	if (status == 0)
 		vfs_fsync(rec_file, 0);
 	mnt_drop_write_file(rec_file);
 out:
 	if (status)
 		printk("NFSD: Failed to remove expired client state directory"
 				" %.*s\n", HEXDIR_LEN, clp->cl_recdir);
 }
 static int
 purge_old(struct dentry *parent, struct dentry *child)
 {
 	int status;
 	if (nfs4_has_reclaimed_state(child->d_name.name, false))
 		return 0;
 	status = vfs_rmdir(parent->d_inode, child);
 	if (status)
 		printk("failed to remove client recovery directory %s\n",
 				child->d_name.name);
 	/* Keep trying, success or failure: */
 	return 0;
 }
 static void
 nfsd4_recdir_purge_old(struct net *net, time_t boot_time)
 {
 	int status;
 	if (!rec_file)
 		return;
 	status = mnt_want_write_file(rec_file);
 	if (status)
 		goto out;
 	status = nfsd4_list_rec_dir(purge_old);
 	if (status == 0)
 		vfs_fsync(rec_file, 0);
 	mnt_drop_write_file(rec_file);
 out:
 	if (status)
 		printk("nfsd4: failed to purge old clients from recovery"
 			" directory %s\n", rec_file->f_path.dentry->d_name.name);
 }
 static int
 load_recdir(struct dentry *parent, struct dentry *child)
 {
 	if (child->d_name.len != HEXDIR_LEN - 1) {
 		printk("nfsd4: illegal name %s in recovery directory\n",
 				child->d_name.name);
 		/* Keep trying; maybe the others are OK: */
 		return 0;
 	}
 	nfs4_client_to_reclaim(child->d_name.name);
 	return 0;
 }
 static int
 nfsd4_recdir_load(void) {
 	int status;
 	if (!rec_file)
 		return 0;
 	status = nfsd4_list_rec_dir(load_recdir);
 	if (status)
 		printk("nfsd4: failed loading clients from recovery"
 			" directory %s\n", rec_file->f_path.dentry->d_name.name);
 	return status;
 }
 /*
  * Hold reference to the recovery directory.
  */
 static int
 nfsd4_init_recdir(void)
 {
 	const struct cred *original_cred;
 	int status;
 	printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
 			user_recovery_dirname);
 	BUG_ON(rec_file);
 	status = nfs4_save_creds(&original_cred);
 	if (status < 0) {
 		printk("NFSD: Unable to change credentials to find recovery"
 		       " directory: error %d\n",
 		       status);
 		return status;
 	}
 	rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0);
 	if (IS_ERR(rec_file)) {
 		printk("NFSD: unable to find recovery directory %s\n",
 				user_recovery_dirname);
 		status = PTR_ERR(rec_file);
 		rec_file = NULL;
 	}
 	nfs4_reset_creds(original_cred);
 	return status;
 }
 static int
 nfsd4_load_reboot_recovery_data(struct net *net)
 {
 	int status;
 	/* XXX: The legacy code won't work in a container */
 	if (net != &init_net) {
 		WARN(1, KERN_ERR "NFSD: attempt to initialize legacy client "
 			"tracking in a container!\n");
 		return -EINVAL;
 	}
 	nfs4_lock_state();
 	status = nfsd4_init_recdir();
 	if (!status)
 		status = nfsd4_recdir_load();
 	nfs4_unlock_state();
 	if (status)
 		printk(KERN_ERR "NFSD: Failure reading reboot recovery data\n");
 	return status;
 }
 static void
 nfsd4_shutdown_recdir(void)
 {
 	if (!rec_file)
 		return;
 	fput(rec_file);
 	rec_file = NULL;
 }
 static void
 nfsd4_legacy_tracking_exit(struct net *net)
 {
 	nfs4_release_reclaim();
 	nfsd4_shutdown_recdir();
 }
 /*
  * Change the NFSv4 recovery directory to recdir.
  */
 int
 nfs4_reset_recoverydir(char *recdir)
 {
 	int status;
 	struct path path;
 	status = kern_path(recdir, LOOKUP_FOLLOW, &path);
 	if (status)
 		return status;
 	status = -ENOTDIR;
 	if (S_ISDIR(path.dentry->d_inode->i_mode)) {
 		strcpy(user_recovery_dirname, recdir);
 		status = 0;
 	}
 	path_put(&path);
 	return status;
 }
 char *
 nfs4_recoverydir(void)
 {
 	return user_recovery_dirname;
 }
 static int
 nfsd4_check_legacy_client(struct nfs4_client *clp)
 {
 	/* did we already find that this client is stable? */
 	if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
 		return 0;
 	/* look for it in the reclaim hashtable otherwise */
 	if (nfsd4_find_reclaim_client(clp)) {
 		set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
 		return 0;
 	}
 	return -ENOENT;
 }
 static struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = {
 	.init		= nfsd4_load_reboot_recovery_data,
 	.exit		= nfsd4_legacy_tracking_exit,
 	.create		= nfsd4_create_clid_dir,
 	.remove		= nfsd4_remove_clid_dir,
 	.check		= nfsd4_check_legacy_client,
 	.grace_done	= nfsd4_recdir_purge_old,
 };
 /* Globals */
 #define NFSD_PIPE_DIR		"nfsd"
 #define NFSD_CLD_PIPE		"cld"
 /* per-net-ns structure for holding cld upcall info */
 struct cld_net {
 	struct rpc_pipe		*cn_pipe;
 	spinlock_t		 cn_lock;
 	struct list_head	 cn_list;
 	unsigned int		 cn_xid;
 };
 struct cld_upcall {
 	struct list_head	 cu_list;
 	struct cld_net		*cu_net;
 	struct task_struct	*cu_task;
 	struct cld_msg		 cu_msg;
 };
 static int
 __cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
 {
 	int ret;
 	struct rpc_pipe_msg msg;
 	memset(&msg, 0, sizeof(msg));
 	msg.data = cmsg;
 	msg.len = sizeof(*cmsg);
 	/*
 	 * Set task state before we queue the upcall. That prevents
 	 * wake_up_process in the downcall from racing with schedule.
 	 */
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	ret = rpc_queue_upcall(pipe, &msg);
 	if (ret < 0) {
 		set_current_state(TASK_RUNNING);
 		goto out;
 	}
 	schedule();
 	set_current_state(TASK_RUNNING);
 	if (msg.errno < 0)
 		ret = msg.errno;
 out:
 	return ret;
 }
 static int
 cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
 {
 	int ret;
 	/*
 	 * -EAGAIN occurs when pipe is closed and reopened while there are
 	 *  upcalls queued.
 	 */
 	do {
 		ret = __cld_pipe_upcall(pipe, cmsg);
 	} while (ret == -EAGAIN);
 	return ret;
 }
 static ssize_t
 cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 {
 	struct cld_upcall *tmp, *cup;
 	struct cld_msg *cmsg = (struct cld_msg *)src;
 	uint32_t xid;
 	struct nfsd_net *nn = net_generic(filp->f_dentry->d_sb->s_fs_info,
 						nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	if (mlen != sizeof(*cmsg)) {
 		dprintk("%s: got %lu bytes, expected %lu\n", __func__, mlen,
 			sizeof(*cmsg));
 		return -EINVAL;
 	}
 	/* copy just the xid so we can try to find that */
 	if (copy_from_user(&xid, &cmsg->cm_xid, sizeof(xid)) != 0) {
 		dprintk("%s: error when copying xid from userspace", __func__);
 		return -EFAULT;
 	}
 	/* walk the list and find corresponding xid */
 	cup = NULL;
 	spin_lock(&cn->cn_lock);
 	list_for_each_entry(tmp, &cn->cn_list, cu_list) {
 		if (get_unaligned(&tmp->cu_msg.cm_xid) == xid) {
 			cup = tmp;
 			list_del_init(&cup->cu_list);
 			break;
 		}
 	}
 	spin_unlock(&cn->cn_lock);
 	/* couldn't find upcall? */
 	if (!cup) {
 		dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid);
 		return -EINVAL;
 	}
 	if (copy_from_user(&cup->cu_msg, src, mlen) != 0)
 		return -EFAULT;
 	wake_up_process(cup->cu_task);
 	return mlen;
 }
 static void
 cld_pipe_destroy_msg(struct rpc_pipe_msg *msg)
 {
 	struct cld_msg *cmsg = msg->data;
 	struct cld_upcall *cup = container_of(cmsg, struct cld_upcall,
 						 cu_msg);
 	/* errno >= 0 means we got a downcall */
 	if (msg->errno >= 0)
 		return;
 	wake_up_process(cup->cu_task);
 }
 static const struct rpc_pipe_ops cld_upcall_ops = {
 	.upcall		= rpc_pipe_generic_upcall,
 	.downcall	= cld_pipe_downcall,
 	.destroy_msg	= cld_pipe_destroy_msg,
 };
 static struct dentry *
 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe)
 {
 	struct dentry *dir, *dentry;
 	dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR);
 	if (dir == NULL)
 		return ERR_PTR(-ENOENT);
 	dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe);
 	dput(dir);
 	return dentry;
 }
 static void
 nfsd4_cld_unregister_sb(struct rpc_pipe *pipe)
 {
 	if (pipe->dentry)
 		rpc_unlink(pipe->dentry);
 }
 static struct dentry *
 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe)
 {
 	struct super_block *sb;
 	struct dentry *dentry;
 	sb = rpc_get_sb_net(net);
 	if (!sb)
 		return NULL;
 	dentry = nfsd4_cld_register_sb(sb, pipe);
 	rpc_put_sb_net(net);
 	return dentry;
 }
 static void
 nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe)
 {
 	struct super_block *sb;
 	sb = rpc_get_sb_net(net);
 	if (sb) {
 		nfsd4_cld_unregister_sb(pipe);
 		rpc_put_sb_net(net);
 	}
 }
 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */
 static int
 nfsd4_init_cld_pipe(struct net *net)
 {
 	int ret;
 	struct dentry *dentry;
 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 	struct cld_net *cn;
 	if (nn->cld_net)
 		return 0;
 	cn = kzalloc(sizeof(*cn), GFP_KERNEL);
 	if (!cn) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
 	if (IS_ERR(cn->cn_pipe)) {
 		ret = PTR_ERR(cn->cn_pipe);
 		goto err;
 	}
 	spin_lock_init(&cn->cn_lock);
 	INIT_LIST_HEAD(&cn->cn_list);
 	dentry = nfsd4_cld_register_net(net, cn->cn_pipe);
 	if (IS_ERR(dentry)) {
 		ret = PTR_ERR(dentry);
 		goto err_destroy_data;
 	}
 	cn->cn_pipe->dentry = dentry;
 	nn->cld_net = cn;
 	return 0;
 err_destroy_data:
 	rpc_destroy_pipe_data(cn->cn_pipe);
 err:
 	kfree(cn);
 	printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n",
 			ret);
 	return ret;
 }
 static void
 nfsd4_remove_cld_pipe(struct net *net)
 {
 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	nfsd4_cld_unregister_net(net, cn->cn_pipe);
 	rpc_destroy_pipe_data(cn->cn_pipe);
 	kfree(nn->cld_net);
 	nn->cld_net = NULL;
 }
 static struct cld_upcall *
 alloc_cld_upcall(struct cld_net *cn)
 {
 	struct cld_upcall *new, *tmp;
 	new = kzalloc(sizeof(*new), GFP_KERNEL);
 	if (!new)
 		return new;
 	/* FIXME: hard cap on number in flight? */
 restart_search:
 	spin_lock(&cn->cn_lock);
 	list_for_each_entry(tmp, &cn->cn_list, cu_list) {
 		if (tmp->cu_msg.cm_xid == cn->cn_xid) {
 			cn->cn_xid++;
 			spin_unlock(&cn->cn_lock);
 			goto restart_search;
 		}
 	}
 	new->cu_task = current;
 	new->cu_msg.cm_vers = CLD_UPCALL_VERSION;
 	put_unaligned(cn->cn_xid++, &new->cu_msg.cm_xid);
 	new->cu_net = cn;
 	list_add(&new->cu_list, &cn->cn_list);
 	spin_unlock(&cn->cn_lock);
 	dprintk("%s: allocated xid %u\n", __func__, new->cu_msg.cm_xid);
 	return new;
 }
 static void
 free_cld_upcall(struct cld_upcall *victim)
 {
 	struct cld_net *cn = victim->cu_net;
 	spin_lock(&cn->cn_lock);
 	list_del(&victim->cu_list);
 	spin_unlock(&cn->cn_lock);
 	kfree(victim);
 }
 /* Ask daemon to create a new record */
 static void
 nfsd4_cld_create(struct nfs4_client *clp)
 {
 	int ret;
 	struct cld_upcall *cup;
 	/* FIXME: determine net from clp */
 	struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	/* Don't upcall if it's already stored */
 	if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
 		return;
 	cup = alloc_cld_upcall(cn);
 	if (!cup) {
 		ret = -ENOMEM;
 		goto out_err;
 	}
 	cup->cu_msg.cm_cmd = Cld_Create;
 	cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
 	memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
 			clp->cl_name.len);
 	ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
 	if (!ret) {
 		ret = cup->cu_msg.cm_status;
 		set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
 	}
 	free_cld_upcall(cup);
 out_err:
 	if (ret)
 		printk(KERN_ERR "NFSD: Unable to create client "
 				"record on stable storage: %d\n", ret);
 }
 /* Ask daemon to create a new record */
 static void
 nfsd4_cld_remove(struct nfs4_client *clp)
 {
 	int ret;
 	struct cld_upcall *cup;
 	/* FIXME: determine net from clp */
 	struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	/* Don't upcall if it's already removed */
 	if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
 		return;
 	cup = alloc_cld_upcall(cn);
 	if (!cup) {
 		ret = -ENOMEM;
 		goto out_err;
 	}
 	cup->cu_msg.cm_cmd = Cld_Remove;
 	cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
 	memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
 			clp->cl_name.len);
 	ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
 	if (!ret) {
 		ret = cup->cu_msg.cm_status;
 		clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
 	}
 	free_cld_upcall(cup);
 out_err:
 	if (ret)
 		printk(KERN_ERR "NFSD: Unable to remove client "
 				"record from stable storage: %d\n", ret);
 }
 /* Check for presence of a record, and update its timestamp */
 static int
 nfsd4_cld_check(struct nfs4_client *clp)
 {
 	int ret;
 	struct cld_upcall *cup;
 	/* FIXME: determine net from clp */
 	struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	/* Don't upcall if one was already stored during this grace pd */
 	if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
 		return 0;
 	cup = alloc_cld_upcall(cn);
 	if (!cup) {
 		printk(KERN_ERR "NFSD: Unable to check client record on "
 				"stable storage: %d\n", -ENOMEM);
 		return -ENOMEM;
 	}
 	cup->cu_msg.cm_cmd = Cld_Check;
 	cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
 	memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
 			clp->cl_name.len);
 	ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
 	if (!ret) {
 		ret = cup->cu_msg.cm_status;
 		set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
 	}
 	free_cld_upcall(cup);
 	return ret;
 }
 static void
 nfsd4_cld_grace_done(struct net *net, time_t boot_time)
 {
 	int ret;
 	struct cld_upcall *cup;
 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	cup = alloc_cld_upcall(cn);
 	if (!cup) {
 		ret = -ENOMEM;
 		goto out_err;
 	}
 	cup->cu_msg.cm_cmd = Cld_GraceDone;
 	cup->cu_msg.cm_u.cm_gracetime = (int64_t)boot_time;
 	ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
 	if (!ret)
 		ret = cup->cu_msg.cm_status;
 	free_cld_upcall(cup);
 out_err:
 	if (ret)
 		printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);
 }
 static struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = {
 	.init		= nfsd4_init_cld_pipe,
 	.exit		= nfsd4_remove_cld_pipe,
 	.create		= nfsd4_cld_create,
 	.remove		= nfsd4_cld_remove,
 	.check		= nfsd4_cld_check,
 	.grace_done	= nfsd4_cld_grace_done,
 };
 int
 nfsd4_client_tracking_init(struct net *net)
 {
 	int status;
 	struct path path;
 	if (!client_tracking_ops) {
 		client_tracking_ops = &nfsd4_cld_tracking_ops;
 		status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path);
 		if (!status) {
 			if (S_ISDIR(path.dentry->d_inode->i_mode))
 				client_tracking_ops =
 						&nfsd4_legacy_tracking_ops;
 			path_put(&path);
 		}
 	}
 	status = client_tracking_ops->init(net);
 	if (status) {
 		printk(KERN_WARNING "NFSD: Unable to initialize client "
 				    "recovery tracking! (%d)\n", status);
 		client_tracking_ops = NULL;
 	}
 	return status;
 }
 void
 nfsd4_client_tracking_exit(struct net *net)
 {
 	if (client_tracking_ops) {
 		client_tracking_ops->exit(net);
 		client_tracking_ops = NULL;
 	}
 }
 void
 nfsd4_client_record_create(struct nfs4_client *clp)
 {
 	if (client_tracking_ops)
 		client_tracking_ops->create(clp);
 }
 void
 nfsd4_client_record_remove(struct nfs4_client *clp)
 {
 	if (client_tracking_ops)
 		client_tracking_ops->remove(clp);
 }
 int
 nfsd4_client_record_check(struct nfs4_client *clp)
 {
 	if (client_tracking_ops)
 		return client_tracking_ops->check(clp);
 	return -EOPNOTSUPP;
 }
 void
 nfsd4_record_grace_done(struct net *net, time_t boot_time)
 {
 	if (client_tracking_ops)
 		client_tracking_ops->grace_done(net, boot_time);
 }
 static int
 rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr)
 {
 	struct super_block *sb = ptr;
 	struct net *net = sb->s_fs_info;
 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 	struct cld_net *cn = nn->cld_net;
 	struct dentry *dentry;
 	int ret = 0;
 	if (!try_module_get(THIS_MODULE))
 		return 0;
 	if (!cn) {
 		module_put(THIS_MODULE);
 		return 0;
 	}
 	switch (event) {
 	case RPC_PIPEFS_MOUNT:
 		dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe);
 		if (IS_ERR(dentry)) {
 			ret = PTR_ERR(dentry);
 			break;
 		}
 		cn->cn_pipe->dentry = dentry;
 		break;
 	case RPC_PIPEFS_UMOUNT:
 		if (cn->cn_pipe->dentry)
 			nfsd4_cld_unregister_sb(cn->cn_pipe);
 		break;
 	default:
 		ret = -ENOTSUPP;
 		break;
 	}
 	module_put(THIS_MODULE);
 	return ret;
 }
 struct notifier_block nfsd4_cld_block = {
 	.notifier_call = rpc_pipefs_event,
 };
+int
+register_cld_notifier(void)
+{
+	return rpc_pipefs_notifier_register(&nfsd4_cld_block);
+}
+void
+unregister_cld_notifier(void)
+{
+	rpc_pipefs_notifier_unregister(&nfsd4_cld_block);
+}

fs/nfsd/nfsctl.c

Diff comments View file @ 797a9d7

1	/*	1	/*
2	* Syscall interface to knfsd.	2	* Syscall interface to knfsd.
3	*	3	*
4	* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>	4	* Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
5	*/	5	*/
6		6
7	#include <linux/slab.h>	7	#include <linux/slab.h>
8	#include <linux/namei.h>	8	#include <linux/namei.h>
9	#include <linux/ctype.h>	9	#include <linux/ctype.h>
10		10
11	#include <linux/sunrpc/svcsock.h>	11	#include <linux/sunrpc/svcsock.h>
12	#include <linux/lockd/lockd.h>	12	#include <linux/lockd/lockd.h>
13	#include <linux/sunrpc/clnt.h>	13	#include <linux/sunrpc/clnt.h>
14	#include <linux/sunrpc/gss_api.h>	14	#include <linux/sunrpc/gss_api.h>
15	#include <linux/sunrpc/gss_krb5_enctypes.h>	15	#include <linux/sunrpc/gss_krb5_enctypes.h>
16	#include <linux/sunrpc/rpc_pipe_fs.h>	16	#include <linux/sunrpc/rpc_pipe_fs.h>
17	#include <linux/module.h>	17	#include <linux/module.h>
18		18
19	#include "idmap.h"	19	#include "idmap.h"
20	#include "nfsd.h"	20	#include "nfsd.h"
21	#include "cache.h"	21	#include "cache.h"
22	#include "fault_inject.h"	22	#include "fault_inject.h"
23	#include "netns.h"	23	#include "netns.h"
24		24
25	/*	25	/*
26	* We have a single directory with several nodes in it.	26	* We have a single directory with several nodes in it.
27	*/	27	*/
28	enum {	28	enum {
29	NFSD_Root = 1,	29	NFSD_Root = 1,
30	NFSD_List,	30	NFSD_List,
31	NFSD_Export_features,	31	NFSD_Export_features,
32	NFSD_Fh,	32	NFSD_Fh,
33	NFSD_FO_UnlockIP,	33	NFSD_FO_UnlockIP,
34	NFSD_FO_UnlockFS,	34	NFSD_FO_UnlockFS,
35	NFSD_Threads,	35	NFSD_Threads,
36	NFSD_Pool_Threads,	36	NFSD_Pool_Threads,
37	NFSD_Pool_Stats,	37	NFSD_Pool_Stats,
38	NFSD_Versions,	38	NFSD_Versions,
39	NFSD_Ports,	39	NFSD_Ports,
40	NFSD_MaxBlkSize,	40	NFSD_MaxBlkSize,
41	NFSD_SupportedEnctypes,	41	NFSD_SupportedEnctypes,
42	/*	42	/*
43	* The below MUST come last. Otherwise we leave a hole in nfsd_files[]	43	* The below MUST come last. Otherwise we leave a hole in nfsd_files[]
44	* with !CONFIG_NFSD_V4 and simple_fill_super() goes oops	44	* with !CONFIG_NFSD_V4 and simple_fill_super() goes oops
45	*/	45	*/
46	#ifdef CONFIG_NFSD_V4	46	#ifdef CONFIG_NFSD_V4
47	NFSD_Leasetime,	47	NFSD_Leasetime,
48	NFSD_Gracetime,	48	NFSD_Gracetime,
49	NFSD_RecoveryDir,	49	NFSD_RecoveryDir,
50	#endif	50	#endif
51	};	51	};
52		52
53	/*	53	/*
54	* write() for these nodes.	54	* write() for these nodes.
55	*/	55	*/
56	static ssize_t write_filehandle(struct file file, char buf, size_t size);	56	static ssize_t write_filehandle(struct file file, char buf, size_t size);
57	static ssize_t write_unlock_ip(struct file file, char buf, size_t size);	57	static ssize_t write_unlock_ip(struct file file, char buf, size_t size);
58	static ssize_t write_unlock_fs(struct file file, char buf, size_t size);	58	static ssize_t write_unlock_fs(struct file file, char buf, size_t size);
59	static ssize_t write_threads(struct file file, char buf, size_t size);	59	static ssize_t write_threads(struct file file, char buf, size_t size);
60	static ssize_t write_pool_threads(struct file file, char buf, size_t size);	60	static ssize_t write_pool_threads(struct file file, char buf, size_t size);
61	static ssize_t write_versions(struct file file, char buf, size_t size);	61	static ssize_t write_versions(struct file file, char buf, size_t size);
62	static ssize_t write_ports(struct file file, char buf, size_t size);	62	static ssize_t write_ports(struct file file, char buf, size_t size);
63	static ssize_t write_maxblksize(struct file file, char buf, size_t size);	63	static ssize_t write_maxblksize(struct file file, char buf, size_t size);
64	#ifdef CONFIG_NFSD_V4	64	#ifdef CONFIG_NFSD_V4
65	static ssize_t write_leasetime(struct file file, char buf, size_t size);	65	static ssize_t write_leasetime(struct file file, char buf, size_t size);
66	static ssize_t write_gracetime(struct file file, char buf, size_t size);	66	static ssize_t write_gracetime(struct file file, char buf, size_t size);
67	static ssize_t write_recoverydir(struct file file, char buf, size_t size);	67	static ssize_t write_recoverydir(struct file file, char buf, size_t size);
68	#endif	68	#endif
69		69
70	static ssize_t (write_op[])(struct file , char *, size_t) = {	70	static ssize_t (write_op[])(struct file , char *, size_t) = {
71	[NFSD_Fh] = write_filehandle,	71	[NFSD_Fh] = write_filehandle,
72	[NFSD_FO_UnlockIP] = write_unlock_ip,	72	[NFSD_FO_UnlockIP] = write_unlock_ip,
73	[NFSD_FO_UnlockFS] = write_unlock_fs,	73	[NFSD_FO_UnlockFS] = write_unlock_fs,
74	[NFSD_Threads] = write_threads,	74	[NFSD_Threads] = write_threads,
75	[NFSD_Pool_Threads] = write_pool_threads,	75	[NFSD_Pool_Threads] = write_pool_threads,
76	[NFSD_Versions] = write_versions,	76	[NFSD_Versions] = write_versions,
77	[NFSD_Ports] = write_ports,	77	[NFSD_Ports] = write_ports,
78	[NFSD_MaxBlkSize] = write_maxblksize,	78	[NFSD_MaxBlkSize] = write_maxblksize,
79	#ifdef CONFIG_NFSD_V4	79	#ifdef CONFIG_NFSD_V4
80	[NFSD_Leasetime] = write_leasetime,	80	[NFSD_Leasetime] = write_leasetime,
81	[NFSD_Gracetime] = write_gracetime,	81	[NFSD_Gracetime] = write_gracetime,
82	[NFSD_RecoveryDir] = write_recoverydir,	82	[NFSD_RecoveryDir] = write_recoverydir,
83	#endif	83	#endif
84	};	84	};
85		85
86	static ssize_t nfsctl_transaction_write(struct file file, const char __user buf, size_t size, loff_t *pos)	86	static ssize_t nfsctl_transaction_write(struct file file, const char __user buf, size_t size, loff_t *pos)
87	{	87	{
88	ino_t ino = file->f_path.dentry->d_inode->i_ino;	88	ino_t ino = file->f_path.dentry->d_inode->i_ino;
89	char *data;	89	char *data;
90	ssize_t rv;	90	ssize_t rv;
91		91
92	if (ino >= ARRAY_SIZE(write_op) \|\| !write_op[ino])	92	if (ino >= ARRAY_SIZE(write_op) \|\| !write_op[ino])
93	return -EINVAL;	93	return -EINVAL;
94		94
95	data = simple_transaction_get(file, buf, size);	95	data = simple_transaction_get(file, buf, size);
96	if (IS_ERR(data))	96	if (IS_ERR(data))
97	return PTR_ERR(data);	97	return PTR_ERR(data);
98		98
99	rv = write_op[ino](file, data, size);	99	rv = write_op[ino](file, data, size);
100	if (rv >= 0) {	100	if (rv >= 0) {
101	simple_transaction_set(file, rv);	101	simple_transaction_set(file, rv);
102	rv = size;	102	rv = size;
103	}	103	}
104	return rv;	104	return rv;
105	}	105	}
106		106
107	static ssize_t nfsctl_transaction_read(struct file file, char __user buf, size_t size, loff_t *pos)	107	static ssize_t nfsctl_transaction_read(struct file file, char __user buf, size_t size, loff_t *pos)
108	{	108	{
109	if (! file->private_data) {	109	if (! file->private_data) {
110	/* An attempt to read a transaction file without writing	110	/* An attempt to read a transaction file without writing
111	* causes a 0-byte write so that the file can return	111	* causes a 0-byte write so that the file can return
112	* state information	112	* state information
113	*/	113	*/
114	ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);	114	ssize_t rv = nfsctl_transaction_write(file, buf, 0, pos);
115	if (rv < 0)	115	if (rv < 0)
116	return rv;	116	return rv;
117	}	117	}
118	return simple_transaction_read(file, buf, size, pos);	118	return simple_transaction_read(file, buf, size, pos);
119	}	119	}
120		120
121	static const struct file_operations transaction_ops = {	121	static const struct file_operations transaction_ops = {
122	.write = nfsctl_transaction_write,	122	.write = nfsctl_transaction_write,
123	.read = nfsctl_transaction_read,	123	.read = nfsctl_transaction_read,
124	.release = simple_transaction_release,	124	.release = simple_transaction_release,
125	.llseek = default_llseek,	125	.llseek = default_llseek,
126	};	126	};
127		127
128	static int exports_open(struct inode inode, struct file file)	128	static int exports_open(struct inode inode, struct file file)
129	{	129	{
130	return seq_open(file, &nfs_exports_op);	130	return seq_open(file, &nfs_exports_op);
131	}	131	}
132		132
133	static const struct file_operations exports_operations = {	133	static const struct file_operations exports_operations = {
134	.open = exports_open,	134	.open = exports_open,
135	.read = seq_read,	135	.read = seq_read,
136	.llseek = seq_lseek,	136	.llseek = seq_lseek,
137	.release = seq_release,	137	.release = seq_release,
138	.owner = THIS_MODULE,	138	.owner = THIS_MODULE,
139	};	139	};
140		140
141	static int export_features_show(struct seq_file m, void v)	141	static int export_features_show(struct seq_file m, void v)
142	{	142	{
143	seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);	143	seq_printf(m, "0x%x 0x%x\n", NFSEXP_ALLFLAGS, NFSEXP_SECINFO_FLAGS);
144	return 0;	144	return 0;
145	}	145	}
146		146
147	static int export_features_open(struct inode inode, struct file file)	147	static int export_features_open(struct inode inode, struct file file)
148	{	148	{
149	return single_open(file, export_features_show, NULL);	149	return single_open(file, export_features_show, NULL);
150	}	150	}
151		151
152	static struct file_operations export_features_operations = {	152	static struct file_operations export_features_operations = {
153	.open = export_features_open,	153	.open = export_features_open,
154	.read = seq_read,	154	.read = seq_read,
155	.llseek = seq_lseek,	155	.llseek = seq_lseek,
156	.release = single_release,	156	.release = single_release,
157	};	157	};
158		158
159	#if defined(CONFIG_SUNRPC_GSS) \|\| defined(CONFIG_SUNRPC_GSS_MODULE)	159	#if defined(CONFIG_SUNRPC_GSS) \|\| defined(CONFIG_SUNRPC_GSS_MODULE)
160	static int supported_enctypes_show(struct seq_file m, void v)	160	static int supported_enctypes_show(struct seq_file m, void v)
161	{	161	{
162	seq_printf(m, KRB5_SUPPORTED_ENCTYPES);	162	seq_printf(m, KRB5_SUPPORTED_ENCTYPES);
163	return 0;	163	return 0;
164	}	164	}
165		165
166	static int supported_enctypes_open(struct inode inode, struct file file)	166	static int supported_enctypes_open(struct inode inode, struct file file)
167	{	167	{
168	return single_open(file, supported_enctypes_show, NULL);	168	return single_open(file, supported_enctypes_show, NULL);
169	}	169	}
170		170
171	static struct file_operations supported_enctypes_ops = {	171	static struct file_operations supported_enctypes_ops = {
172	.open = supported_enctypes_open,	172	.open = supported_enctypes_open,
173	.read = seq_read,	173	.read = seq_read,
174	.llseek = seq_lseek,	174	.llseek = seq_lseek,
175	.release = single_release,	175	.release = single_release,
176	};	176	};
177	#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */	177	#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
178		178
179	extern int nfsd_pool_stats_open(struct inode inode, struct file file);	179	extern int nfsd_pool_stats_open(struct inode inode, struct file file);
180	extern int nfsd_pool_stats_release(struct inode inode, struct file file);	180	extern int nfsd_pool_stats_release(struct inode inode, struct file file);
181		181
182	static const struct file_operations pool_stats_operations = {	182	static const struct file_operations pool_stats_operations = {
183	.open = nfsd_pool_stats_open,	183	.open = nfsd_pool_stats_open,
184	.read = seq_read,	184	.read = seq_read,
185	.llseek = seq_lseek,	185	.llseek = seq_lseek,
186	.release = nfsd_pool_stats_release,	186	.release = nfsd_pool_stats_release,
187	.owner = THIS_MODULE,	187	.owner = THIS_MODULE,
188	};	188	};
189		189
190	/----------------------------------------------------------------------------/	190	/----------------------------------------------------------------------------/
191	/*	191	/*
192	* payload - write methods	192	* payload - write methods
193	*/	193	*/
194		194
195		195
196	/**	196	/**
197	* write_unlock_ip - Release all locks used by a client	197	* write_unlock_ip - Release all locks used by a client
198	*	198	*
199	* Experimental.	199	* Experimental.
200	*	200	*
201	* Input:	201	* Input:
202	* buf: '\n'-terminated C string containing a	202	* buf: '\n'-terminated C string containing a
203	* presentation format IP address	203	* presentation format IP address
204	* size: length of C string in @buf	204	* size: length of C string in @buf
205	* Output:	205	* Output:
206	* On success: returns zero if all specified locks were released;	206	* On success: returns zero if all specified locks were released;
207	* returns one if one or more locks were not released	207	* returns one if one or more locks were not released
208	* On error: return code is negative errno value	208	* On error: return code is negative errno value
209	*/	209	*/
210	static ssize_t write_unlock_ip(struct file file, char buf, size_t size)	210	static ssize_t write_unlock_ip(struct file file, char buf, size_t size)
211	{	211	{
212	struct sockaddr_storage address;	212	struct sockaddr_storage address;
213	struct sockaddr sap = (struct sockaddr )&address;	213	struct sockaddr sap = (struct sockaddr )&address;
214	size_t salen = sizeof(address);	214	size_t salen = sizeof(address);
215	char *fo_path;	215	char *fo_path;
216		216
217	/* sanity check */	217	/* sanity check */
218	if (size == 0)	218	if (size == 0)
219	return -EINVAL;	219	return -EINVAL;
220		220
221	if (buf[size-1] != '\n')	221	if (buf[size-1] != '\n')
222	return -EINVAL;	222	return -EINVAL;
223		223
224	fo_path = buf;	224	fo_path = buf;
225	if (qword_get(&buf, fo_path, size) < 0)	225	if (qword_get(&buf, fo_path, size) < 0)
226	return -EINVAL;	226	return -EINVAL;
227		227
228	if (rpc_pton(&init_net, fo_path, size, sap, salen) == 0)	228	if (rpc_pton(&init_net, fo_path, size, sap, salen) == 0)
229	return -EINVAL;	229	return -EINVAL;
230		230
231	return nlmsvc_unlock_all_by_ip(sap);	231	return nlmsvc_unlock_all_by_ip(sap);
232	}	232	}
233		233
234	/**	234	/**
235	* write_unlock_fs - Release all locks on a local file system	235	* write_unlock_fs - Release all locks on a local file system
236	*	236	*
237	* Experimental.	237	* Experimental.
238	*	238	*
239	* Input:	239	* Input:
240	* buf: '\n'-terminated C string containing the	240	* buf: '\n'-terminated C string containing the
241	* absolute pathname of a local file system	241	* absolute pathname of a local file system
242	* size: length of C string in @buf	242	* size: length of C string in @buf
243	* Output:	243	* Output:
244	* On success: returns zero if all specified locks were released;	244	* On success: returns zero if all specified locks were released;
245	* returns one if one or more locks were not released	245	* returns one if one or more locks were not released
246	* On error: return code is negative errno value	246	* On error: return code is negative errno value
247	*/	247	*/
248	static ssize_t write_unlock_fs(struct file file, char buf, size_t size)	248	static ssize_t write_unlock_fs(struct file file, char buf, size_t size)
249	{	249	{
250	struct path path;	250	struct path path;
251	char *fo_path;	251	char *fo_path;
252	int error;	252	int error;
253		253
254	/* sanity check */	254	/* sanity check */
255	if (size == 0)	255	if (size == 0)
256	return -EINVAL;	256	return -EINVAL;
257		257
258	if (buf[size-1] != '\n')	258	if (buf[size-1] != '\n')
259	return -EINVAL;	259	return -EINVAL;
260		260
261	fo_path = buf;	261	fo_path = buf;
262	if (qword_get(&buf, fo_path, size) < 0)	262	if (qword_get(&buf, fo_path, size) < 0)
263	return -EINVAL;	263	return -EINVAL;
264		264
265	error = kern_path(fo_path, 0, &path);	265	error = kern_path(fo_path, 0, &path);
266	if (error)	266	if (error)
267	return error;	267	return error;
268		268
269	/*	269	/*
270	* XXX: Needs better sanity checking. Otherwise we could end up	270	* XXX: Needs better sanity checking. Otherwise we could end up
271	* releasing locks on the wrong file system.	271	* releasing locks on the wrong file system.
272	*	272	*
273	* For example:	273	* For example:
274	* 1. Does the path refer to a directory?	274	* 1. Does the path refer to a directory?
275	* 2. Is that directory a mount point, or	275	* 2. Is that directory a mount point, or
276	* 3. Is that directory the root of an exported file system?	276	* 3. Is that directory the root of an exported file system?
277	*/	277	*/
278	error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);	278	error = nlmsvc_unlock_all_by_sb(path.dentry->d_sb);
279		279
280	path_put(&path);	280	path_put(&path);
281	return error;	281	return error;
282	}	282	}
283		283
284	/**	284	/**
285	* write_filehandle - Get a variable-length NFS file handle by path	285	* write_filehandle - Get a variable-length NFS file handle by path
286	*	286	*
287	* On input, the buffer contains a '\n'-terminated C string comprised of	287	* On input, the buffer contains a '\n'-terminated C string comprised of
288	* three alphanumeric words separated by whitespace. The string may	288	* three alphanumeric words separated by whitespace. The string may
289	* contain escape sequences.	289	* contain escape sequences.
290	*	290	*
291	* Input:	291	* Input:
292	* buf:	292	* buf:
293	* domain: client domain name	293	* domain: client domain name
294	* path: export pathname	294	* path: export pathname
295	* maxsize: numeric maximum size of	295	* maxsize: numeric maximum size of
296	* @buf	296	* @buf
297	* size: length of C string in @buf	297	* size: length of C string in @buf
298	* Output:	298	* Output:
299	* On success: passed-in buffer filled with '\n'-terminated C	299	* On success: passed-in buffer filled with '\n'-terminated C
300	* string containing a ASCII hex text version	300	* string containing a ASCII hex text version
301	* of the NFS file handle;	301	* of the NFS file handle;
302	* return code is the size in bytes of the string	302	* return code is the size in bytes of the string
303	* On error: return code is negative errno value	303	* On error: return code is negative errno value
304	*/	304	*/
305	static ssize_t write_filehandle(struct file file, char buf, size_t size)	305	static ssize_t write_filehandle(struct file file, char buf, size_t size)
306	{	306	{
307	char dname, path;	307	char dname, path;
308	int uninitialized_var(maxsize);	308	int uninitialized_var(maxsize);
309	char *mesg = buf;	309	char *mesg = buf;
310	int len;	310	int len;
311	struct auth_domain *dom;	311	struct auth_domain *dom;
312	struct knfsd_fh fh;	312	struct knfsd_fh fh;
313		313
314	if (size == 0)	314	if (size == 0)
315	return -EINVAL;	315	return -EINVAL;
316		316
317	if (buf[size-1] != '\n')	317	if (buf[size-1] != '\n')
318	return -EINVAL;	318	return -EINVAL;
319	buf[size-1] = 0;	319	buf[size-1] = 0;
320		320
321	dname = mesg;	321	dname = mesg;
322	len = qword_get(&mesg, dname, size);	322	len = qword_get(&mesg, dname, size);
323	if (len <= 0)	323	if (len <= 0)
324	return -EINVAL;	324	return -EINVAL;
325		325
326	path = dname+len+1;	326	path = dname+len+1;
327	len = qword_get(&mesg, path, size);	327	len = qword_get(&mesg, path, size);
328	if (len <= 0)	328	if (len <= 0)
329	return -EINVAL;	329	return -EINVAL;
330		330
331	len = get_int(&mesg, &maxsize);	331	len = get_int(&mesg, &maxsize);
332	if (len)	332	if (len)
333	return len;	333	return len;
334		334
335	if (maxsize < NFS_FHSIZE)	335	if (maxsize < NFS_FHSIZE)
336	return -EINVAL;	336	return -EINVAL;
337	if (maxsize > NFS3_FHSIZE)	337	if (maxsize > NFS3_FHSIZE)
338	maxsize = NFS3_FHSIZE;	338	maxsize = NFS3_FHSIZE;
339		339
340	if (qword_get(&mesg, mesg, size)>0)	340	if (qword_get(&mesg, mesg, size)>0)
341	return -EINVAL;	341	return -EINVAL;
342		342
343	/* we have all the words, they are in buf.. */	343	/* we have all the words, they are in buf.. */
344	dom = unix_domain_find(dname);	344	dom = unix_domain_find(dname);
345	if (!dom)	345	if (!dom)
346	return -ENOMEM;	346	return -ENOMEM;
347		347
348	len = exp_rootfh(dom, path, &fh, maxsize);	348	len = exp_rootfh(dom, path, &fh, maxsize);
349	auth_domain_put(dom);	349	auth_domain_put(dom);
350	if (len)	350	if (len)
351	return len;	351	return len;
352		352
353	mesg = buf;	353	mesg = buf;
354	len = SIMPLE_TRANSACTION_LIMIT;	354	len = SIMPLE_TRANSACTION_LIMIT;
355	qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);	355	qword_addhex(&mesg, &len, (char*)&fh.fh_base, fh.fh_size);
356	mesg[-1] = '\n';	356	mesg[-1] = '\n';
357	return mesg - buf;	357	return mesg - buf;
358	}	358	}
359		359
360	/**	360	/**
361	* write_threads - Start NFSD, or report the current number of running threads	361	* write_threads - Start NFSD, or report the current number of running threads
362	*	362	*
363	* Input:	363	* Input:
364	* buf: ignored	364	* buf: ignored
365	* size: zero	365	* size: zero
366	* Output:	366	* Output:
367	* On success: passed-in buffer filled with '\n'-terminated C	367	* On success: passed-in buffer filled with '\n'-terminated C
368	* string numeric value representing the number of	368	* string numeric value representing the number of
369	* running NFSD threads;	369	* running NFSD threads;
370	* return code is the size in bytes of the string	370	* return code is the size in bytes of the string
371	* On error: return code is zero	371	* On error: return code is zero
372	*	372	*
373	* OR	373	* OR
374	*	374	*
375	* Input:	375	* Input:
376	* buf: C string containing an unsigned	376	* buf: C string containing an unsigned
377	* integer value representing the	377	* integer value representing the
378	* number of NFSD threads to start	378	* number of NFSD threads to start
379	* size: non-zero length of C string in @buf	379	* size: non-zero length of C string in @buf
380	* Output:	380	* Output:
381	* On success: NFS service is started;	381	* On success: NFS service is started;
382	* passed-in buffer filled with '\n'-terminated C	382	* passed-in buffer filled with '\n'-terminated C
383	* string numeric value representing the number of	383	* string numeric value representing the number of
384	* running NFSD threads;	384	* running NFSD threads;
385	* return code is the size in bytes of the string	385	* return code is the size in bytes of the string
386	* On error: return code is zero or a negative errno value	386	* On error: return code is zero or a negative errno value
387	*/	387	*/
388	static ssize_t write_threads(struct file file, char buf, size_t size)	388	static ssize_t write_threads(struct file file, char buf, size_t size)
389	{	389	{
390	char *mesg = buf;	390	char *mesg = buf;
391	int rv;	391	int rv;
392	if (size > 0) {	392	if (size > 0) {
393	int newthreads;	393	int newthreads;
394	rv = get_int(&mesg, &newthreads);	394	rv = get_int(&mesg, &newthreads);
395	if (rv)	395	if (rv)
396	return rv;	396	return rv;
397	if (newthreads < 0)	397	if (newthreads < 0)
398	return -EINVAL;	398	return -EINVAL;
399	rv = nfsd_svc(NFS_PORT, newthreads);	399	rv = nfsd_svc(NFS_PORT, newthreads);
400	if (rv < 0)	400	if (rv < 0)
401	return rv;	401	return rv;
402	} else	402	} else
403	rv = nfsd_nrthreads();	403	rv = nfsd_nrthreads();
404		404
405	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);	405	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
406	}	406	}
407		407
408	/**	408	/**
409	* write_pool_threads - Set or report the current number of threads per pool	409	* write_pool_threads - Set or report the current number of threads per pool
410	*	410	*
411	* Input:	411	* Input:
412	* buf: ignored	412	* buf: ignored
413	* size: zero	413	* size: zero
414	*	414	*
415	* OR	415	* OR
416	*	416	*
417	* Input:	417	* Input:
418	* buf: C string containing whitespace-	418	* buf: C string containing whitespace-
419	* separated unsigned integer values	419	* separated unsigned integer values
420	* representing the number of NFSD	420	* representing the number of NFSD
421	* threads to start in each pool	421	* threads to start in each pool
422	* size: non-zero length of C string in @buf	422	* size: non-zero length of C string in @buf
423	* Output:	423	* Output:
424	* On success: passed-in buffer filled with '\n'-terminated C	424	* On success: passed-in buffer filled with '\n'-terminated C
425	* string containing integer values representing the	425	* string containing integer values representing the
426	* number of NFSD threads in each pool;	426	* number of NFSD threads in each pool;
427	* return code is the size in bytes of the string	427	* return code is the size in bytes of the string
428	* On error: return code is zero or a negative errno value	428	* On error: return code is zero or a negative errno value
429	*/	429	*/
430	static ssize_t write_pool_threads(struct file file, char buf, size_t size)	430	static ssize_t write_pool_threads(struct file file, char buf, size_t size)
431	{	431	{
432	/* if size > 0, look for an array of number of threads per node	432	/* if size > 0, look for an array of number of threads per node
433	* and apply them then write out number of threads per node as reply	433	* and apply them then write out number of threads per node as reply
434	*/	434	*/
435	char *mesg = buf;	435	char *mesg = buf;
436	int i;	436	int i;
437	int rv;	437	int rv;
438	int len;	438	int len;
439	int npools;	439	int npools;
440	int *nthreads;	440	int *nthreads;
441		441
442	mutex_lock(&nfsd_mutex);	442	mutex_lock(&nfsd_mutex);
443	npools = nfsd_nrpools();	443	npools = nfsd_nrpools();
444	if (npools == 0) {	444	if (npools == 0) {
445	/*	445	/*
446	* NFS is shut down. The admin can start it by	446	* NFS is shut down. The admin can start it by
447	* writing to the threads file but NOT the pool_threads	447	* writing to the threads file but NOT the pool_threads
448	* file, sorry. Report zero threads.	448	* file, sorry. Report zero threads.
449	*/	449	*/
450	mutex_unlock(&nfsd_mutex);	450	mutex_unlock(&nfsd_mutex);
451	strcpy(buf, "0\n");	451	strcpy(buf, "0\n");
452	return strlen(buf);	452	return strlen(buf);
453	}	453	}
454		454
455	nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);	455	nthreads = kcalloc(npools, sizeof(int), GFP_KERNEL);
456	rv = -ENOMEM;	456	rv = -ENOMEM;
457	if (nthreads == NULL)	457	if (nthreads == NULL)
458	goto out_free;	458	goto out_free;
459		459
460	if (size > 0) {	460	if (size > 0) {
461	for (i = 0; i < npools; i++) {	461	for (i = 0; i < npools; i++) {
462	rv = get_int(&mesg, &nthreads[i]);	462	rv = get_int(&mesg, &nthreads[i]);
463	if (rv == -ENOENT)	463	if (rv == -ENOENT)
464	break; /* fewer numbers than pools */	464	break; /* fewer numbers than pools */
465	if (rv)	465	if (rv)
466	goto out_free; /* syntax error */	466	goto out_free; /* syntax error */
467	rv = -EINVAL;	467	rv = -EINVAL;
468	if (nthreads[i] < 0)	468	if (nthreads[i] < 0)
469	goto out_free;	469	goto out_free;
470	}	470	}
471	rv = nfsd_set_nrthreads(i, nthreads);	471	rv = nfsd_set_nrthreads(i, nthreads);
472	if (rv)	472	if (rv)
473	goto out_free;	473	goto out_free;
474	}	474	}
475		475
476	rv = nfsd_get_nrthreads(npools, nthreads);	476	rv = nfsd_get_nrthreads(npools, nthreads);
477	if (rv)	477	if (rv)
478	goto out_free;	478	goto out_free;
479		479
480	mesg = buf;	480	mesg = buf;
481	size = SIMPLE_TRANSACTION_LIMIT;	481	size = SIMPLE_TRANSACTION_LIMIT;
482	for (i = 0; i < npools && size > 0; i++) {	482	for (i = 0; i < npools && size > 0; i++) {
483	snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));	483	snprintf(mesg, size, "%d%c", nthreads[i], (i == npools-1 ? '\n' : ' '));
484	len = strlen(mesg);	484	len = strlen(mesg);
485	size -= len;	485	size -= len;
486	mesg += len;	486	mesg += len;
487	}	487	}
488	rv = mesg - buf;	488	rv = mesg - buf;
489	out_free:	489	out_free:
490	kfree(nthreads);	490	kfree(nthreads);
491	mutex_unlock(&nfsd_mutex);	491	mutex_unlock(&nfsd_mutex);
492	return rv;	492	return rv;
493	}	493	}
494		494
495	static ssize_t __write_versions(struct file file, char buf, size_t size)	495	static ssize_t __write_versions(struct file file, char buf, size_t size)
496	{	496	{
497	char *mesg = buf;	497	char *mesg = buf;
498	char vers, minorp, sign;	498	char vers, minorp, sign;
499	int len, num, remaining;	499	int len, num, remaining;
500	unsigned minor;	500	unsigned minor;
501	ssize_t tlen = 0;	501	ssize_t tlen = 0;
502	char *sep;	502	char *sep;
503		503
504	if (size>0) {	504	if (size>0) {
505	if (nfsd_serv)	505	if (nfsd_serv)
506	/* Cannot change versions without updating	506	/* Cannot change versions without updating
507	* nfsd_serv->sv_xdrsize, and reallocing	507	* nfsd_serv->sv_xdrsize, and reallocing
508	* rq_argp and rq_resp	508	* rq_argp and rq_resp
509	*/	509	*/
510	return -EBUSY;	510	return -EBUSY;
511	if (buf[size-1] != '\n')	511	if (buf[size-1] != '\n')
512	return -EINVAL;	512	return -EINVAL;
513	buf[size-1] = 0;	513	buf[size-1] = 0;
514		514
515	vers = mesg;	515	vers = mesg;
516	len = qword_get(&mesg, vers, size);	516	len = qword_get(&mesg, vers, size);
517	if (len <= 0) return -EINVAL;	517	if (len <= 0) return -EINVAL;
518	do {	518	do {
519	sign = *vers;	519	sign = *vers;
520	if (sign == '+' \|\| sign == '-')	520	if (sign == '+' \|\| sign == '-')
521	num = simple_strtol((vers+1), &minorp, 0);	521	num = simple_strtol((vers+1), &minorp, 0);
522	else	522	else
523	num = simple_strtol(vers, &minorp, 0);	523	num = simple_strtol(vers, &minorp, 0);
524	if (*minorp == '.') {	524	if (*minorp == '.') {
525	if (num < 4)	525	if (num < 4)
526	return -EINVAL;	526	return -EINVAL;
527	minor = simple_strtoul(minorp+1, NULL, 0);	527	minor = simple_strtoul(minorp+1, NULL, 0);
528	if (minor == 0)	528	if (minor == 0)
529	return -EINVAL;	529	return -EINVAL;
530	if (nfsd_minorversion(minor, sign == '-' ?	530	if (nfsd_minorversion(minor, sign == '-' ?
531	NFSD_CLEAR : NFSD_SET) < 0)	531	NFSD_CLEAR : NFSD_SET) < 0)
532	return -EINVAL;	532	return -EINVAL;
533	goto next;	533	goto next;
534	}	534	}
535	switch(num) {	535	switch(num) {
536	case 2:	536	case 2:
537	case 3:	537	case 3:
538	case 4:	538	case 4:
539	nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);	539	nfsd_vers(num, sign == '-' ? NFSD_CLEAR : NFSD_SET);
540	break;	540	break;
541	default:	541	default:
542	return -EINVAL;	542	return -EINVAL;
543	}	543	}
544	next:	544	next:
545	vers += len + 1;	545	vers += len + 1;
546	} while ((len = qword_get(&mesg, vers, size)) > 0);	546	} while ((len = qword_get(&mesg, vers, size)) > 0);
547	/* If all get turned off, turn them back on, as	547	/* If all get turned off, turn them back on, as
548	* having no versions is BAD	548	* having no versions is BAD
549	*/	549	*/
550	nfsd_reset_versions();	550	nfsd_reset_versions();
551	}	551	}
552		552
553	/* Now write current state into reply buffer */	553	/* Now write current state into reply buffer */
554	len = 0;	554	len = 0;
555	sep = "";	555	sep = "";
556	remaining = SIMPLE_TRANSACTION_LIMIT;	556	remaining = SIMPLE_TRANSACTION_LIMIT;
557	for (num=2 ; num <= 4 ; num++)	557	for (num=2 ; num <= 4 ; num++)
558	if (nfsd_vers(num, NFSD_AVAIL)) {	558	if (nfsd_vers(num, NFSD_AVAIL)) {
559	len = snprintf(buf, remaining, "%s%c%d", sep,	559	len = snprintf(buf, remaining, "%s%c%d", sep,
560	nfsd_vers(num, NFSD_TEST)?'+':'-',	560	nfsd_vers(num, NFSD_TEST)?'+':'-',
561	num);	561	num);
562	sep = " ";	562	sep = " ";
563		563
564	if (len > remaining)	564	if (len > remaining)
565	break;	565	break;
566	remaining -= len;	566	remaining -= len;
567	buf += len;	567	buf += len;
568	tlen += len;	568	tlen += len;
569	}	569	}
570	if (nfsd_vers(4, NFSD_AVAIL))	570	if (nfsd_vers(4, NFSD_AVAIL))
571	for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;	571	for (minor = 1; minor <= NFSD_SUPPORTED_MINOR_VERSION;
572	minor++) {	572	minor++) {
573	len = snprintf(buf, remaining, " %c4.%u",	573	len = snprintf(buf, remaining, " %c4.%u",
574	(nfsd_vers(4, NFSD_TEST) &&	574	(nfsd_vers(4, NFSD_TEST) &&
575	nfsd_minorversion(minor, NFSD_TEST)) ?	575	nfsd_minorversion(minor, NFSD_TEST)) ?
576	'+' : '-',	576	'+' : '-',
577	minor);	577	minor);
578		578
579	if (len > remaining)	579	if (len > remaining)
580	break;	580	break;
581	remaining -= len;	581	remaining -= len;
582	buf += len;	582	buf += len;
583	tlen += len;	583	tlen += len;
584	}	584	}
585		585
586	len = snprintf(buf, remaining, "\n");	586	len = snprintf(buf, remaining, "\n");
587	if (len > remaining)	587	if (len > remaining)
588	return -EINVAL;	588	return -EINVAL;
589	return tlen + len;	589	return tlen + len;
590	}	590	}
591		591
592	/**	592	/**
593	* write_versions - Set or report the available NFS protocol versions	593	* write_versions - Set or report the available NFS protocol versions
594	*	594	*
595	* Input:	595	* Input:
596	* buf: ignored	596	* buf: ignored
597	* size: zero	597	* size: zero
598	* Output:	598	* Output:
599	* On success: passed-in buffer filled with '\n'-terminated C	599	* On success: passed-in buffer filled with '\n'-terminated C
600	* string containing positive or negative integer	600	* string containing positive or negative integer
601	* values representing the current status of each	601	* values representing the current status of each
602	* protocol version;	602	* protocol version;
603	* return code is the size in bytes of the string	603	* return code is the size in bytes of the string
604	* On error: return code is zero or a negative errno value	604	* On error: return code is zero or a negative errno value
605	*	605	*
606	* OR	606	* OR
607	*	607	*
608	* Input:	608	* Input:
609	* buf: C string containing whitespace-	609	* buf: C string containing whitespace-
610	* separated positive or negative	610	* separated positive or negative
611	* integer values representing NFS	611	* integer values representing NFS
612	* protocol versions to enable ("+n")	612	* protocol versions to enable ("+n")
613	* or disable ("-n")	613	* or disable ("-n")
614	* size: non-zero length of C string in @buf	614	* size: non-zero length of C string in @buf
615	* Output:	615	* Output:
616	* On success: status of zero or more protocol versions has	616	* On success: status of zero or more protocol versions has
617	* been updated; passed-in buffer filled with	617	* been updated; passed-in buffer filled with
618	* '\n'-terminated C string containing positive	618	* '\n'-terminated C string containing positive
619	* or negative integer values representing the	619	* or negative integer values representing the
620	* current status of each protocol version;	620	* current status of each protocol version;
621	* return code is the size in bytes of the string	621	* return code is the size in bytes of the string
622	* On error: return code is zero or a negative errno value	622	* On error: return code is zero or a negative errno value
623	*/	623	*/
624	static ssize_t write_versions(struct file file, char buf, size_t size)	624	static ssize_t write_versions(struct file file, char buf, size_t size)
625	{	625	{
626	ssize_t rv;	626	ssize_t rv;
627		627
628	mutex_lock(&nfsd_mutex);	628	mutex_lock(&nfsd_mutex);
629	rv = __write_versions(file, buf, size);	629	rv = __write_versions(file, buf, size);
630	mutex_unlock(&nfsd_mutex);	630	mutex_unlock(&nfsd_mutex);
631	return rv;	631	return rv;
632	}	632	}
633		633
634	/*	634	/*
635	* Zero-length write. Return a list of NFSD's current listener	635	* Zero-length write. Return a list of NFSD's current listener
636	* transports.	636	* transports.
637	*/	637	*/
638	static ssize_t __write_ports_names(char *buf)	638	static ssize_t __write_ports_names(char *buf)
639	{	639	{
640	if (nfsd_serv == NULL)	640	if (nfsd_serv == NULL)
641	return 0;	641	return 0;
642	return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);	642	return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
643	}	643	}
644		644
645	/*	645	/*
646	* A single 'fd' number was written, in which case it must be for	646	* A single 'fd' number was written, in which case it must be for
647	* a socket of a supported family/protocol, and we use it as an	647	* a socket of a supported family/protocol, and we use it as an
648	* nfsd listener.	648	* nfsd listener.
649	*/	649	*/
650	static ssize_t __write_ports_addfd(char *buf)	650	static ssize_t __write_ports_addfd(char *buf)
651	{	651	{
652	char *mesg = buf;	652	char *mesg = buf;
653	int fd, err;	653	int fd, err;
654		654
655	err = get_int(&mesg, &fd);	655	err = get_int(&mesg, &fd);
656	if (err != 0 \|\| fd < 0)	656	if (err != 0 \|\| fd < 0)
657	return -EINVAL;	657	return -EINVAL;
658		658
659	err = nfsd_create_serv();	659	err = nfsd_create_serv();
660	if (err != 0)	660	if (err != 0)
661	return err;	661	return err;
662		662
663	err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);	663	err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
664	if (err < 0) {	664	if (err < 0) {
665	svc_destroy(nfsd_serv);	665	svc_destroy(nfsd_serv);
666	return err;	666	return err;
667	}	667	}
668		668
669	/* Decrease the count, but don't shut down the service */	669	/* Decrease the count, but don't shut down the service */
670	nfsd_serv->sv_nrthreads--;	670	nfsd_serv->sv_nrthreads--;
671	return err;	671	return err;
672	}	672	}
673		673
674	/*	674	/*
675	* A '-' followed by the 'name' of a socket means we close the socket.	675	* A '-' followed by the 'name' of a socket means we close the socket.
676	*/	676	*/
677	static ssize_t __write_ports_delfd(char *buf)	677	static ssize_t __write_ports_delfd(char *buf)
678	{	678	{
679	char *toclose;	679	char *toclose;
680	int len = 0;	680	int len = 0;
681		681
682	toclose = kstrdup(buf + 1, GFP_KERNEL);	682	toclose = kstrdup(buf + 1, GFP_KERNEL);
683	if (toclose == NULL)	683	if (toclose == NULL)
684	return -ENOMEM;	684	return -ENOMEM;
685		685
686	if (nfsd_serv != NULL)	686	if (nfsd_serv != NULL)
687	len = svc_sock_names(nfsd_serv, buf,	687	len = svc_sock_names(nfsd_serv, buf,
688	SIMPLE_TRANSACTION_LIMIT, toclose);	688	SIMPLE_TRANSACTION_LIMIT, toclose);
689	kfree(toclose);	689	kfree(toclose);
690	return len;	690	return len;
691	}	691	}
692		692
693	/*	693	/*
694	* A transport listener is added by writing it's transport name and	694	* A transport listener is added by writing it's transport name and
695	* a port number.	695	* a port number.
696	*/	696	*/
697	static ssize_t __write_ports_addxprt(char *buf)	697	static ssize_t __write_ports_addxprt(char *buf)
698	{	698	{
699	char transport[16];	699	char transport[16];
700	struct svc_xprt *xprt;	700	struct svc_xprt *xprt;
701	int port, err;	701	int port, err;
702		702
703	if (sscanf(buf, "%15s %4u", transport, &port) != 2)	703	if (sscanf(buf, "%15s %4u", transport, &port) != 2)
704	return -EINVAL;	704	return -EINVAL;
705		705
706	if (port < 1 \|\| port > USHRT_MAX)	706	if (port < 1 \|\| port > USHRT_MAX)
707	return -EINVAL;	707	return -EINVAL;
708		708
709	err = nfsd_create_serv();	709	err = nfsd_create_serv();
710	if (err != 0)	710	if (err != 0)
711	return err;	711	return err;
712		712
713	err = svc_create_xprt(nfsd_serv, transport, &init_net,	713	err = svc_create_xprt(nfsd_serv, transport, &init_net,
714	PF_INET, port, SVC_SOCK_ANONYMOUS);	714	PF_INET, port, SVC_SOCK_ANONYMOUS);
715	if (err < 0)	715	if (err < 0)
716	goto out_err;	716	goto out_err;
717		717
718	err = svc_create_xprt(nfsd_serv, transport, &init_net,	718	err = svc_create_xprt(nfsd_serv, transport, &init_net,
719	PF_INET6, port, SVC_SOCK_ANONYMOUS);	719	PF_INET6, port, SVC_SOCK_ANONYMOUS);
720	if (err < 0 && err != -EAFNOSUPPORT)	720	if (err < 0 && err != -EAFNOSUPPORT)
721	goto out_close;	721	goto out_close;
722		722
723	/* Decrease the count, but don't shut down the service */	723	/* Decrease the count, but don't shut down the service */
724	nfsd_serv->sv_nrthreads--;	724	nfsd_serv->sv_nrthreads--;
725	return 0;	725	return 0;
726	out_close:	726	out_close:
727	xprt = svc_find_xprt(nfsd_serv, transport, &init_net, PF_INET, port);	727	xprt = svc_find_xprt(nfsd_serv, transport, &init_net, PF_INET, port);
728	if (xprt != NULL) {	728	if (xprt != NULL) {
729	svc_close_xprt(xprt);	729	svc_close_xprt(xprt);
730	svc_xprt_put(xprt);	730	svc_xprt_put(xprt);
731	}	731	}
732	out_err:	732	out_err:
733	svc_destroy(nfsd_serv);	733	svc_destroy(nfsd_serv);
734	return err;	734	return err;
735	}	735	}
736		736
737	/*	737	/*
738	* A transport listener is removed by writing a "-", it's transport	738	* A transport listener is removed by writing a "-", it's transport
739	* name, and it's port number.	739	* name, and it's port number.
740	*/	740	*/
741	static ssize_t __write_ports_delxprt(char *buf)	741	static ssize_t __write_ports_delxprt(char *buf)
742	{	742	{
743	struct svc_xprt *xprt;	743	struct svc_xprt *xprt;
744	char transport[16];	744	char transport[16];
745	int port;	745	int port;
746		746
747	if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)	747	if (sscanf(&buf[1], "%15s %4u", transport, &port) != 2)
748	return -EINVAL;	748	return -EINVAL;
749		749
750	if (port < 1 \|\| port > USHRT_MAX \|\| nfsd_serv == NULL)	750	if (port < 1 \|\| port > USHRT_MAX \|\| nfsd_serv == NULL)
751	return -EINVAL;	751	return -EINVAL;
752		752
753	xprt = svc_find_xprt(nfsd_serv, transport, &init_net, AF_UNSPEC, port);	753	xprt = svc_find_xprt(nfsd_serv, transport, &init_net, AF_UNSPEC, port);
754	if (xprt == NULL)	754	if (xprt == NULL)
755	return -ENOTCONN;	755	return -ENOTCONN;
756		756
757	svc_close_xprt(xprt);	757	svc_close_xprt(xprt);
758	svc_xprt_put(xprt);	758	svc_xprt_put(xprt);
759	return 0;	759	return 0;
760	}	760	}
761		761
762	static ssize_t __write_ports(struct file file, char buf, size_t size)	762	static ssize_t __write_ports(struct file file, char buf, size_t size)
763	{	763	{
764	if (size == 0)	764	if (size == 0)
765	return __write_ports_names(buf);	765	return __write_ports_names(buf);
766		766
767	if (isdigit(buf[0]))	767	if (isdigit(buf[0]))
768	return __write_ports_addfd(buf);	768	return __write_ports_addfd(buf);
769		769
770	if (buf[0] == '-' && isdigit(buf[1]))	770	if (buf[0] == '-' && isdigit(buf[1]))
771	return __write_ports_delfd(buf);	771	return __write_ports_delfd(buf);
772		772
773	if (isalpha(buf[0]))	773	if (isalpha(buf[0]))
774	return __write_ports_addxprt(buf);	774	return __write_ports_addxprt(buf);
775		775
776	if (buf[0] == '-' && isalpha(buf[1]))	776	if (buf[0] == '-' && isalpha(buf[1]))
777	return __write_ports_delxprt(buf);	777	return __write_ports_delxprt(buf);
778		778
779	return -EINVAL;	779	return -EINVAL;
780	}	780	}
781		781
782	/**	782	/**
783	* write_ports - Pass a socket file descriptor or transport name to listen on	783	* write_ports - Pass a socket file descriptor or transport name to listen on
784	*	784	*
785	* Input:	785	* Input:
786	* buf: ignored	786	* buf: ignored
787	* size: zero	787	* size: zero
788	* Output:	788	* Output:
789	* On success: passed-in buffer filled with a '\n'-terminated C	789	* On success: passed-in buffer filled with a '\n'-terminated C
790	* string containing a whitespace-separated list of	790	* string containing a whitespace-separated list of
791	* named NFSD listeners;	791	* named NFSD listeners;
792	* return code is the size in bytes of the string	792	* return code is the size in bytes of the string
793	* On error: return code is zero or a negative errno value	793	* On error: return code is zero or a negative errno value
794	*	794	*
795	* OR	795	* OR
796	*	796	*
797	* Input:	797	* Input:
798	* buf: C string containing an unsigned	798	* buf: C string containing an unsigned
799	* integer value representing a bound	799	* integer value representing a bound
800	* but unconnected socket that is to be	800	* but unconnected socket that is to be
801	* used as an NFSD listener; listen(3)	801	* used as an NFSD listener; listen(3)
802	* must be called for a SOCK_STREAM	802	* must be called for a SOCK_STREAM
803	* socket, otherwise it is ignored	803	* socket, otherwise it is ignored
804	* size: non-zero length of C string in @buf	804	* size: non-zero length of C string in @buf
805	* Output:	805	* Output:
806	* On success: NFS service is started;	806	* On success: NFS service is started;
807	* passed-in buffer filled with a '\n'-terminated C	807	* passed-in buffer filled with a '\n'-terminated C
808	* string containing a unique alphanumeric name of	808	* string containing a unique alphanumeric name of
809	* the listener;	809	* the listener;
810	* return code is the size in bytes of the string	810	* return code is the size in bytes of the string
811	* On error: return code is a negative errno value	811	* On error: return code is a negative errno value
812	*	812	*
813	* OR	813	* OR
814	*	814	*
815	* Input:	815	* Input:
816	* buf: C string containing a "-" followed	816	* buf: C string containing a "-" followed
817	* by an integer value representing a	817	* by an integer value representing a
818	* previously passed in socket file	818	* previously passed in socket file
819	* descriptor	819	* descriptor
820	* size: non-zero length of C string in @buf	820	* size: non-zero length of C string in @buf
821	* Output:	821	* Output:
822	* On success: NFS service no longer listens on that socket;	822	* On success: NFS service no longer listens on that socket;
823	* passed-in buffer filled with a '\n'-terminated C	823	* passed-in buffer filled with a '\n'-terminated C
824	* string containing a unique name of the listener;	824	* string containing a unique name of the listener;
825	* return code is the size in bytes of the string	825	* return code is the size in bytes of the string
826	* On error: return code is a negative errno value	826	* On error: return code is a negative errno value
827	*	827	*
828	* OR	828	* OR
829	*	829	*
830	* Input:	830	* Input:
831	* buf: C string containing a transport	831	* buf: C string containing a transport
832	* name and an unsigned integer value	832	* name and an unsigned integer value
833	* representing the port to listen on,	833	* representing the port to listen on,
834	* separated by whitespace	834	* separated by whitespace
835	* size: non-zero length of C string in @buf	835	* size: non-zero length of C string in @buf
836	* Output:	836	* Output:
837	* On success: returns zero; NFS service is started	837	* On success: returns zero; NFS service is started
838	* On error: return code is a negative errno value	838	* On error: return code is a negative errno value
839	*	839	*
840	* OR	840	* OR
841	*	841	*
842	* Input:	842	* Input:
843	* buf: C string containing a "-" followed	843	* buf: C string containing a "-" followed
844	* by a transport name and an unsigned	844	* by a transport name and an unsigned
845	* integer value representing the port	845	* integer value representing the port
846	* to listen on, separated by whitespace	846	* to listen on, separated by whitespace
847	* size: non-zero length of C string in @buf	847	* size: non-zero length of C string in @buf
848	* Output:	848	* Output:
849	* On success: returns zero; NFS service no longer listens	849	* On success: returns zero; NFS service no longer listens
850	* on that transport	850	* on that transport
851	* On error: return code is a negative errno value	851	* On error: return code is a negative errno value
852	*/	852	*/
853	static ssize_t write_ports(struct file file, char buf, size_t size)	853	static ssize_t write_ports(struct file file, char buf, size_t size)
854	{	854	{
855	ssize_t rv;	855	ssize_t rv;
856		856
857	mutex_lock(&nfsd_mutex);	857	mutex_lock(&nfsd_mutex);
858	rv = __write_ports(file, buf, size);	858	rv = __write_ports(file, buf, size);
859	mutex_unlock(&nfsd_mutex);	859	mutex_unlock(&nfsd_mutex);
860	return rv;	860	return rv;
861	}	861	}
862		862
863		863
864	int nfsd_max_blksize;	864	int nfsd_max_blksize;
865		865
866	/**	866	/**
867	* write_maxblksize - Set or report the current NFS blksize	867	* write_maxblksize - Set or report the current NFS blksize
868	*	868	*
869	* Input:	869	* Input:
870	* buf: ignored	870	* buf: ignored
871	* size: zero	871	* size: zero
872	*	872	*
873	* OR	873	* OR
874	*	874	*
875	* Input:	875	* Input:
876	* buf: C string containing an unsigned	876	* buf: C string containing an unsigned
877	* integer value representing the new	877	* integer value representing the new
878	* NFS blksize	878	* NFS blksize
879	* size: non-zero length of C string in @buf	879	* size: non-zero length of C string in @buf
880	* Output:	880	* Output:
881	* On success: passed-in buffer filled with '\n'-terminated C string	881	* On success: passed-in buffer filled with '\n'-terminated C string
882	* containing numeric value of the current NFS blksize	882	* containing numeric value of the current NFS blksize
883	* setting;	883	* setting;
884	* return code is the size in bytes of the string	884	* return code is the size in bytes of the string
885	* On error: return code is zero or a negative errno value	885	* On error: return code is zero or a negative errno value
886	*/	886	*/
887	static ssize_t write_maxblksize(struct file file, char buf, size_t size)	887	static ssize_t write_maxblksize(struct file file, char buf, size_t size)
888	{	888	{
889	char *mesg = buf;	889	char *mesg = buf;
890	if (size > 0) {	890	if (size > 0) {
891	int bsize;	891	int bsize;
892	int rv = get_int(&mesg, &bsize);	892	int rv = get_int(&mesg, &bsize);
893	if (rv)	893	if (rv)
894	return rv;	894	return rv;
895	/* force bsize into allowed range and	895	/* force bsize into allowed range and
896	* required alignment.	896	* required alignment.
897	*/	897	*/
898	if (bsize < 1024)	898	if (bsize < 1024)
899	bsize = 1024;	899	bsize = 1024;
900	if (bsize > NFSSVC_MAXBLKSIZE)	900	if (bsize > NFSSVC_MAXBLKSIZE)
901	bsize = NFSSVC_MAXBLKSIZE;	901	bsize = NFSSVC_MAXBLKSIZE;
902	bsize &= ~(1024-1);	902	bsize &= ~(1024-1);
903	mutex_lock(&nfsd_mutex);	903	mutex_lock(&nfsd_mutex);
904	if (nfsd_serv) {	904	if (nfsd_serv) {
905	mutex_unlock(&nfsd_mutex);	905	mutex_unlock(&nfsd_mutex);
906	return -EBUSY;	906	return -EBUSY;
907	}	907	}
908	nfsd_max_blksize = bsize;	908	nfsd_max_blksize = bsize;
909	mutex_unlock(&nfsd_mutex);	909	mutex_unlock(&nfsd_mutex);
910	}	910	}
911		911
912	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",	912	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n",
913	nfsd_max_blksize);	913	nfsd_max_blksize);
914	}	914	}
915		915
916	#ifdef CONFIG_NFSD_V4	916	#ifdef CONFIG_NFSD_V4
917	static ssize_t __nfsd4_write_time(struct file file, char buf, size_t size, time_t *time)	917	static ssize_t __nfsd4_write_time(struct file file, char buf, size_t size, time_t *time)
918	{	918	{
919	char *mesg = buf;	919	char *mesg = buf;
920	int rv, i;	920	int rv, i;
921		921
922	if (size > 0) {	922	if (size > 0) {
923	if (nfsd_serv)	923	if (nfsd_serv)
924	return -EBUSY;	924	return -EBUSY;
925	rv = get_int(&mesg, &i);	925	rv = get_int(&mesg, &i);
926	if (rv)	926	if (rv)
927	return rv;	927	return rv;
928	/*	928	/*
929	* Some sanity checking. We don't have a reason for	929	* Some sanity checking. We don't have a reason for
930	* these particular numbers, but problems with the	930	* these particular numbers, but problems with the
931	* extremes are:	931	* extremes are:
932	* - Too short: the briefest network outage may	932	* - Too short: the briefest network outage may
933	* cause clients to lose all their locks. Also,	933	* cause clients to lose all their locks. Also,
934	* the frequent polling may be wasteful.	934	* the frequent polling may be wasteful.
935	* - Too long: do you really want reboot recovery	935	* - Too long: do you really want reboot recovery
936	* to take more than an hour? Or to make other	936	* to take more than an hour? Or to make other
937	* clients wait an hour before being able to	937	* clients wait an hour before being able to
938	* revoke a dead client's locks?	938	* revoke a dead client's locks?
939	*/	939	*/
940	if (i < 10 \|\| i > 3600)	940	if (i < 10 \|\| i > 3600)
941	return -EINVAL;	941	return -EINVAL;
942	*time = i;	942	*time = i;
943	}	943	}
944		944
945	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);	945	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);
946	}	946	}
947		947
948	static ssize_t nfsd4_write_time(struct file file, char buf, size_t size, time_t *time)	948	static ssize_t nfsd4_write_time(struct file file, char buf, size_t size, time_t *time)
949	{	949	{
950	ssize_t rv;	950	ssize_t rv;
951		951
952	mutex_lock(&nfsd_mutex);	952	mutex_lock(&nfsd_mutex);
953	rv = __nfsd4_write_time(file, buf, size, time);	953	rv = __nfsd4_write_time(file, buf, size, time);
954	mutex_unlock(&nfsd_mutex);	954	mutex_unlock(&nfsd_mutex);
955	return rv;	955	return rv;
956	}	956	}
957		957
958	/**	958	/**
959	* write_leasetime - Set or report the current NFSv4 lease time	959	* write_leasetime - Set or report the current NFSv4 lease time
960	*	960	*
961	* Input:	961	* Input:
962	* buf: ignored	962	* buf: ignored
963	* size: zero	963	* size: zero
964	*	964	*
965	* OR	965	* OR
966	*	966	*
967	* Input:	967	* Input:
968	* buf: C string containing an unsigned	968	* buf: C string containing an unsigned
969	* integer value representing the new	969	* integer value representing the new
970	* NFSv4 lease expiry time	970	* NFSv4 lease expiry time
971	* size: non-zero length of C string in @buf	971	* size: non-zero length of C string in @buf
972	* Output:	972	* Output:
973	* On success: passed-in buffer filled with '\n'-terminated C	973	* On success: passed-in buffer filled with '\n'-terminated C
974	* string containing unsigned integer value of the	974	* string containing unsigned integer value of the
975	* current lease expiry time;	975	* current lease expiry time;
976	* return code is the size in bytes of the string	976	* return code is the size in bytes of the string
977	* On error: return code is zero or a negative errno value	977	* On error: return code is zero or a negative errno value
978	*/	978	*/
979	static ssize_t write_leasetime(struct file file, char buf, size_t size)	979	static ssize_t write_leasetime(struct file file, char buf, size_t size)
980	{	980	{
981	return nfsd4_write_time(file, buf, size, &nfsd4_lease);	981	return nfsd4_write_time(file, buf, size, &nfsd4_lease);
982	}	982	}
983		983
984	/**	984	/**
985	* write_gracetime - Set or report current NFSv4 grace period time	985	* write_gracetime - Set or report current NFSv4 grace period time
986	*	986	*
987	* As above, but sets the time of the NFSv4 grace period.	987	* As above, but sets the time of the NFSv4 grace period.
988	*	988	*
989	* Note this should never be set to less than the previous	989	* Note this should never be set to less than the previous
990	* lease-period time, but we don't try to enforce this. (In the common	990	* lease-period time, but we don't try to enforce this. (In the common
991	* case (a new boot), we don't know what the previous lease time was	991	* case (a new boot), we don't know what the previous lease time was
992	* anyway.)	992	* anyway.)
993	*/	993	*/
994	static ssize_t write_gracetime(struct file file, char buf, size_t size)	994	static ssize_t write_gracetime(struct file file, char buf, size_t size)
995	{	995	{
996	return nfsd4_write_time(file, buf, size, &nfsd4_grace);	996	return nfsd4_write_time(file, buf, size, &nfsd4_grace);
997	}	997	}
998		998
999	extern char *nfs4_recoverydir(void);	999	extern char *nfs4_recoverydir(void);
1000		1000
1001	static ssize_t __write_recoverydir(struct file file, char buf, size_t size)	1001	static ssize_t __write_recoverydir(struct file file, char buf, size_t size)
1002	{	1002	{
1003	char *mesg = buf;	1003	char *mesg = buf;
1004	char *recdir;	1004	char *recdir;
1005	int len, status;	1005	int len, status;
1006		1006
1007	if (size > 0) {	1007	if (size > 0) {
1008	if (nfsd_serv)	1008	if (nfsd_serv)
1009	return -EBUSY;	1009	return -EBUSY;
1010	if (size > PATH_MAX \|\| buf[size-1] != '\n')	1010	if (size > PATH_MAX \|\| buf[size-1] != '\n')
1011	return -EINVAL;	1011	return -EINVAL;
1012	buf[size-1] = 0;	1012	buf[size-1] = 0;
1013		1013
1014	recdir = mesg;	1014	recdir = mesg;
1015	len = qword_get(&mesg, recdir, size);	1015	len = qword_get(&mesg, recdir, size);
1016	if (len <= 0)	1016	if (len <= 0)
1017	return -EINVAL;	1017	return -EINVAL;
1018		1018
1019	status = nfs4_reset_recoverydir(recdir);	1019	status = nfs4_reset_recoverydir(recdir);
1020	if (status)	1020	if (status)
1021	return status;	1021	return status;
1022	}	1022	}
1023		1023
1024	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",	1024	return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%s\n",
1025	nfs4_recoverydir());	1025	nfs4_recoverydir());
1026	}	1026	}
1027		1027
1028	/**	1028	/**
1029	* write_recoverydir - Set or report the pathname of the recovery directory	1029	* write_recoverydir - Set or report the pathname of the recovery directory
1030	*	1030	*
1031	* Input:	1031	* Input:
1032	* buf: ignored	1032	* buf: ignored
1033	* size: zero	1033	* size: zero
1034	*	1034	*
1035	* OR	1035	* OR
1036	*	1036	*
1037	* Input:	1037	* Input:
1038	* buf: C string containing the pathname	1038	* buf: C string containing the pathname
1039	* of the directory on a local file	1039	* of the directory on a local file
1040	* system containing permanent NFSv4	1040	* system containing permanent NFSv4
1041	* recovery data	1041	* recovery data
1042	* size: non-zero length of C string in @buf	1042	* size: non-zero length of C string in @buf
1043	* Output:	1043	* Output:
1044	* On success: passed-in buffer filled with '\n'-terminated C string	1044	* On success: passed-in buffer filled with '\n'-terminated C string
1045	* containing the current recovery pathname setting;	1045	* containing the current recovery pathname setting;
1046	* return code is the size in bytes of the string	1046	* return code is the size in bytes of the string
1047	* On error: return code is zero or a negative errno value	1047	* On error: return code is zero or a negative errno value
1048	*/	1048	*/
1049	static ssize_t write_recoverydir(struct file file, char buf, size_t size)	1049	static ssize_t write_recoverydir(struct file file, char buf, size_t size)
1050	{	1050	{
1051	ssize_t rv;	1051	ssize_t rv;
1052		1052
1053	mutex_lock(&nfsd_mutex);	1053	mutex_lock(&nfsd_mutex);
1054	rv = __write_recoverydir(file, buf, size);	1054	rv = __write_recoverydir(file, buf, size);
1055	mutex_unlock(&nfsd_mutex);	1055	mutex_unlock(&nfsd_mutex);
1056	return rv;	1056	return rv;
1057	}	1057	}
1058		1058
1059	#endif	1059	#endif
1060		1060
1061	/----------------------------------------------------------------------------/	1061	/----------------------------------------------------------------------------/
1062	/*	1062	/*
1063	* populating the filesystem.	1063	* populating the filesystem.
1064	*/	1064	*/
1065		1065
1066	static int nfsd_fill_super(struct super_block * sb, void * data, int silent)	1066	static int nfsd_fill_super(struct super_block * sb, void * data, int silent)
1067	{	1067	{
1068	static struct tree_descr nfsd_files[] = {	1068	static struct tree_descr nfsd_files[] = {
1069	[NFSD_List] = {"exports", &exports_operations, S_IRUGO},	1069	[NFSD_List] = {"exports", &exports_operations, S_IRUGO},
1070	[NFSD_Export_features] = {"export_features",	1070	[NFSD_Export_features] = {"export_features",
1071	&export_features_operations, S_IRUGO},	1071	&export_features_operations, S_IRUGO},
1072	[NFSD_FO_UnlockIP] = {"unlock_ip",	1072	[NFSD_FO_UnlockIP] = {"unlock_ip",
1073	&transaction_ops, S_IWUSR\|S_IRUSR},	1073	&transaction_ops, S_IWUSR\|S_IRUSR},
1074	[NFSD_FO_UnlockFS] = {"unlock_filesystem",	1074	[NFSD_FO_UnlockFS] = {"unlock_filesystem",
1075	&transaction_ops, S_IWUSR\|S_IRUSR},	1075	&transaction_ops, S_IWUSR\|S_IRUSR},
1076	[NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR\|S_IRUSR},	1076	[NFSD_Fh] = {"filehandle", &transaction_ops, S_IWUSR\|S_IRUSR},
1077	[NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR\|S_IRUSR},	1077	[NFSD_Threads] = {"threads", &transaction_ops, S_IWUSR\|S_IRUSR},
1078	[NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR\|S_IRUSR},	1078	[NFSD_Pool_Threads] = {"pool_threads", &transaction_ops, S_IWUSR\|S_IRUSR},
1079	[NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},	1079	[NFSD_Pool_Stats] = {"pool_stats", &pool_stats_operations, S_IRUGO},
1080	[NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR\|S_IRUSR},	1080	[NFSD_Versions] = {"versions", &transaction_ops, S_IWUSR\|S_IRUSR},
1081	[NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR\|S_IRUGO},	1081	[NFSD_Ports] = {"portlist", &transaction_ops, S_IWUSR\|S_IRUGO},
1082	[NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR\|S_IRUGO},	1082	[NFSD_MaxBlkSize] = {"max_block_size", &transaction_ops, S_IWUSR\|S_IRUGO},
1083	#if defined(CONFIG_SUNRPC_GSS) \|\| defined(CONFIG_SUNRPC_GSS_MODULE)	1083	#if defined(CONFIG_SUNRPC_GSS) \|\| defined(CONFIG_SUNRPC_GSS_MODULE)
1084	[NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO},	1084	[NFSD_SupportedEnctypes] = {"supported_krb5_enctypes", &supported_enctypes_ops, S_IRUGO},
1085	#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */	1085	#endif /* CONFIG_SUNRPC_GSS or CONFIG_SUNRPC_GSS_MODULE */
1086	#ifdef CONFIG_NFSD_V4	1086	#ifdef CONFIG_NFSD_V4
1087	[NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR\|S_IRUSR},	1087	[NFSD_Leasetime] = {"nfsv4leasetime", &transaction_ops, S_IWUSR\|S_IRUSR},
1088	[NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR\|S_IRUSR},	1088	[NFSD_Gracetime] = {"nfsv4gracetime", &transaction_ops, S_IWUSR\|S_IRUSR},
1089	[NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR\|S_IRUSR},	1089	[NFSD_RecoveryDir] = {"nfsv4recoverydir", &transaction_ops, S_IWUSR\|S_IRUSR},
1090	#endif	1090	#endif
1091	/* last one */ {""}	1091	/* last one */ {""}
1092	};	1092	};
1093	return simple_fill_super(sb, 0x6e667364, nfsd_files);	1093	return simple_fill_super(sb, 0x6e667364, nfsd_files);
1094	}	1094	}
1095		1095
1096	static struct dentry nfsd_mount(struct file_system_type fs_type,	1096	static struct dentry nfsd_mount(struct file_system_type fs_type,
1097	int flags, const char dev_name, void data)	1097	int flags, const char dev_name, void data)
1098	{	1098	{
1099	return mount_single(fs_type, flags, data, nfsd_fill_super);	1099	return mount_single(fs_type, flags, data, nfsd_fill_super);
1100	}	1100	}
1101		1101
1102	static struct file_system_type nfsd_fs_type = {	1102	static struct file_system_type nfsd_fs_type = {
1103	.owner = THIS_MODULE,	1103	.owner = THIS_MODULE,
1104	.name = "nfsd",	1104	.name = "nfsd",
1105	.mount = nfsd_mount,	1105	.mount = nfsd_mount,
1106	.kill_sb = kill_litter_super,	1106	.kill_sb = kill_litter_super,
1107	};	1107	};
1108		1108
1109	#ifdef CONFIG_PROC_FS	1109	#ifdef CONFIG_PROC_FS
1110	static int create_proc_exports_entry(void)	1110	static int create_proc_exports_entry(void)
1111	{	1111	{
1112	struct proc_dir_entry *entry;	1112	struct proc_dir_entry *entry;
1113		1113
1114	entry = proc_mkdir("fs/nfs", NULL);	1114	entry = proc_mkdir("fs/nfs", NULL);
1115	if (!entry)	1115	if (!entry)
1116	return -ENOMEM;	1116	return -ENOMEM;
1117	entry = proc_create("exports", 0, entry, &exports_operations);	1117	entry = proc_create("exports", 0, entry, &exports_operations);
1118	if (!entry)	1118	if (!entry)
1119	return -ENOMEM;	1119	return -ENOMEM;
1120	return 0;	1120	return 0;
1121	}	1121	}
1122	#else /* CONFIG_PROC_FS */	1122	#else /* CONFIG_PROC_FS */
1123	static int create_proc_exports_entry(void)	1123	static int create_proc_exports_entry(void)
1124	{	1124	{
1125	return 0;	1125	return 0;
1126	}	1126	}
1127	#endif	1127	#endif
1128		1128
1129	int nfsd_net_id;	1129	int nfsd_net_id;
1130	static struct pernet_operations nfsd_net_ops = {	1130	static struct pernet_operations nfsd_net_ops = {
1131	.id = &nfsd_net_id,	1131	.id = &nfsd_net_id,
1132	.size = sizeof(struct nfsd_net),	1132	.size = sizeof(struct nfsd_net),
1133	};	1133	};
1134		1134
1135	static int __init init_nfsd(void)	1135	static int __init init_nfsd(void)
1136	{	1136	{
1137	int retval;	1137	int retval;
1138	printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");	1138	printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
1139		1139
1140	retval = rpc_pipefs_notifier_register(&nfsd4_cld_block);	1140	retval = register_cld_notifier();
1141	if (retval)	1141	if (retval)
1142	return retval;	1142	return retval;
1143	retval = register_pernet_subsys(&nfsd_net_ops);	1143	retval = register_pernet_subsys(&nfsd_net_ops);
1144	if (retval < 0)	1144	if (retval < 0)
1145	goto out_unregister_notifier;	1145	goto out_unregister_notifier;
1146	retval = nfsd4_init_slabs();	1146	retval = nfsd4_init_slabs();
1147	if (retval)	1147	if (retval)
1148	goto out_unregister_pernet;	1148	goto out_unregister_pernet;
1149	nfs4_state_init();	1149	nfs4_state_init();
1150	retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */	1150	retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */
1151	if (retval)	1151	if (retval)
1152	goto out_free_slabs;	1152	goto out_free_slabs;
1153	nfsd_stat_init(); /* Statistics */	1153	nfsd_stat_init(); /* Statistics */
1154	retval = nfsd_reply_cache_init();	1154	retval = nfsd_reply_cache_init();
1155	if (retval)	1155	if (retval)
1156	goto out_free_stat;	1156	goto out_free_stat;
1157	retval = nfsd_export_init();	1157	retval = nfsd_export_init();
1158	if (retval)	1158	if (retval)
1159	goto out_free_cache;	1159	goto out_free_cache;
1160	nfsd_lockd_init(); /* lockd->nfsd callbacks */	1160	nfsd_lockd_init(); /* lockd->nfsd callbacks */
1161	retval = nfsd_idmap_init();	1161	retval = nfsd_idmap_init();
1162	if (retval)	1162	if (retval)
1163	goto out_free_lockd;	1163	goto out_free_lockd;
1164	retval = create_proc_exports_entry();	1164	retval = create_proc_exports_entry();
1165	if (retval)	1165	if (retval)
1166	goto out_free_idmap;	1166	goto out_free_idmap;
1167	retval = register_filesystem(&nfsd_fs_type);	1167	retval = register_filesystem(&nfsd_fs_type);
1168	if (retval)	1168	if (retval)
1169	goto out_free_all;	1169	goto out_free_all;
1170	return 0;	1170	return 0;
1171	out_free_all:	1171	out_free_all:
1172	remove_proc_entry("fs/nfs/exports", NULL);	1172	remove_proc_entry("fs/nfs/exports", NULL);
1173	remove_proc_entry("fs/nfs", NULL);	1173	remove_proc_entry("fs/nfs", NULL);
1174	out_free_idmap:	1174	out_free_idmap:
1175	nfsd_idmap_shutdown();	1175	nfsd_idmap_shutdown();
1176	out_free_lockd:	1176	out_free_lockd:
1177	nfsd_lockd_shutdown();	1177	nfsd_lockd_shutdown();
1178	nfsd_export_shutdown();	1178	nfsd_export_shutdown();
1179	out_free_cache:	1179	out_free_cache:
1180	nfsd_reply_cache_shutdown();	1180	nfsd_reply_cache_shutdown();
1181	out_free_stat:	1181	out_free_stat:
1182	nfsd_stat_shutdown();	1182	nfsd_stat_shutdown();
1183	nfsd_fault_inject_cleanup();	1183	nfsd_fault_inject_cleanup();
1184	out_free_slabs:	1184	out_free_slabs:
1185	nfsd4_free_slabs();	1185	nfsd4_free_slabs();
1186	out_unregister_pernet:	1186	out_unregister_pernet:
1187	unregister_pernet_subsys(&nfsd_net_ops);	1187	unregister_pernet_subsys(&nfsd_net_ops);
1188	out_unregister_notifier:	1188	out_unregister_notifier:
1189	rpc_pipefs_notifier_unregister(&nfsd4_cld_block);	1189	unregister_cld_notifier();
1190	return retval;	1190	return retval;
1191	}	1191	}
1192		1192
1193	static void __exit exit_nfsd(void)	1193	static void __exit exit_nfsd(void)
1194	{	1194	{
1195	nfsd_export_shutdown();	1195	nfsd_export_shutdown();
1196	nfsd_reply_cache_shutdown();	1196	nfsd_reply_cache_shutdown();
1197	remove_proc_entry("fs/nfs/exports", NULL);	1197	remove_proc_entry("fs/nfs/exports", NULL);
1198	remove_proc_entry("fs/nfs", NULL);	1198	remove_proc_entry("fs/nfs", NULL);
1199	nfsd_stat_shutdown();	1199	nfsd_stat_shutdown();
1200	nfsd_lockd_shutdown();	1200	nfsd_lockd_shutdown();
1201	nfsd_idmap_shutdown();	1201	nfsd_idmap_shutdown();
1202	nfsd4_free_slabs();	1202	nfsd4_free_slabs();
1203	nfsd_fault_inject_cleanup();	1203	nfsd_fault_inject_cleanup();
1204	unregister_filesystem(&nfsd_fs_type);	1204	unregister_filesystem(&nfsd_fs_type);
1205	unregister_pernet_subsys(&nfsd_net_ops);	1205	unregister_pernet_subsys(&nfsd_net_ops);
1206	rpc_pipefs_notifier_unregister(&nfsd4_cld_block);	1206	unregister_cld_notifier();
1207	}	1207	}
1208		1208
1209	MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");	1209	MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
1210	MODULE_LICENSE("GPL");	1210	MODULE_LICENSE("GPL");
1211	module_init(init_nfsd)	1211	module_init(init_nfsd)
1212	module_exit(exit_nfsd)	1212	module_exit(exit_nfsd)
1213		1213

fs/nfsd/nfsd.h

Diff comments View file @ 797a9d7

 /*
  * Hodge-podge collection of knfsd-related stuff.
  * I will sort this out later.
  *
  * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
  */
 #ifndef LINUX_NFSD_NFSD_H
 #define LINUX_NFSD_NFSD_H
 #include <linux/types.h>
 #include <linux/mount.h>
 #include <linux/nfs.h>
 #include <linux/nfs2.h>
 #include <linux/nfs3.h>
 #include <linux/nfs4.h>
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/nfsd/debug.h>
 #include <linux/nfsd/export.h>
 #include <linux/nfsd/stats.h>
 /*
  * nfsd version
  */
 #define NFSD_SUPPORTED_MINOR_VERSION	1
 /*
  * Maximum blocksizes supported by daemon under various circumstances.
  */
 #define NFSSVC_MAXBLKSIZE       RPCSVC_MAXPAYLOAD
 /* NFSv2 is limited by the protocol specification, see RFC 1094 */
 #define NFSSVC_MAXBLKSIZE_V2    (8*1024)
 /*
  * Largest number of bytes we need to allocate for an NFS
  * call or reply.  Used to control buffer sizes.  We use
  * the length of v3 WRITE, READDIR and READDIR replies
  * which are an RPC header, up to 26 XDR units of reply
  * data, and some page data.
  *
  * Note that accuracy here doesn't matter too much as the
  * size is rounded up to a page size when allocating space.
  */
 #define NFSD_BUFSIZE            ((RPC_MAX_HEADER_WITH_AUTH+26)*XDR_UNIT + NFSSVC_MAXBLKSIZE)
 struct readdir_cd {
 	__be32			err;	/* 0, nfserr, or nfserr_eof */
 };
 extern struct svc_program	nfsd_program;
 extern struct svc_version	nfsd_version2, nfsd_version3,
 				nfsd_version4;
 extern u32			nfsd_supported_minorversion;
 extern struct mutex		nfsd_mutex;
 extern struct svc_serv		*nfsd_serv;
 extern spinlock_t		nfsd_drc_lock;
 extern unsigned int		nfsd_drc_max_mem;
 extern unsigned int		nfsd_drc_mem_used;
 extern const struct seq_operations nfs_exports_op;
 /*
  * Function prototypes.
  */
 int		nfsd_svc(unsigned short port, int nrservs);
 int		nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp);
 int		nfsd_nrthreads(void);
 int		nfsd_nrpools(void);
 int		nfsd_get_nrthreads(int n, int *);
 int		nfsd_set_nrthreads(int n, int *);
 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
 #ifdef CONFIG_NFSD_V2_ACL
 extern struct svc_version nfsd_acl_version2;
 #else
 #define nfsd_acl_version2 NULL
 #endif
 #ifdef CONFIG_NFSD_V3_ACL
 extern struct svc_version nfsd_acl_version3;
 #else
 #define nfsd_acl_version3 NULL
 #endif
 #endif
 enum vers_op {NFSD_SET, NFSD_CLEAR, NFSD_TEST, NFSD_AVAIL };
 int nfsd_vers(int vers, enum vers_op change);
 int nfsd_minorversion(u32 minorversion, enum vers_op change);
 void nfsd_reset_versions(void);
 int nfsd_create_serv(void);
 extern int nfsd_max_blksize;
 static inline int nfsd_v4client(struct svc_rqst *rq)
 {
 	return rq->rq_prog == NFS_PROGRAM && rq->rq_vers == 4;
 }
 /*
  * NFSv4 State
  */
 #ifdef CONFIG_NFSD_V4
 extern unsigned int max_delegations;
 void nfs4_state_init(void);
 int nfsd4_init_slabs(void);
 void nfsd4_free_slabs(void);
 int nfs4_state_start(void);
 void nfs4_state_shutdown(void);
 void nfs4_reset_lease(time_t leasetime);
 int nfs4_reset_recoverydir(char *recdir);
 #else
 static inline void nfs4_state_init(void) { }
 static inline int nfsd4_init_slabs(void) { return 0; }
 static inline void nfsd4_free_slabs(void) { }
 static inline int nfs4_state_start(void) { return 0; }
 static inline void nfs4_state_shutdown(void) { }
 static inline void nfs4_reset_lease(time_t leasetime) { }
 static inline int nfs4_reset_recoverydir(char *recdir) { return 0; }
 #endif
 /*
  * lockd binding
  */
 void		nfsd_lockd_init(void);
 void		nfsd_lockd_shutdown(void);
 /*
  * These macros provide pre-xdr'ed values for faster operation.
  */
 #define	nfs_ok			cpu_to_be32(NFS_OK)
 #define	nfserr_perm		cpu_to_be32(NFSERR_PERM)
 #define	nfserr_noent		cpu_to_be32(NFSERR_NOENT)
 #define	nfserr_io		cpu_to_be32(NFSERR_IO)
 #define	nfserr_nxio		cpu_to_be32(NFSERR_NXIO)
 #define	nfserr_eagain		cpu_to_be32(NFSERR_EAGAIN)
 #define	nfserr_acces		cpu_to_be32(NFSERR_ACCES)
 #define	nfserr_exist		cpu_to_be32(NFSERR_EXIST)
 #define	nfserr_xdev		cpu_to_be32(NFSERR_XDEV)
 #define	nfserr_nodev		cpu_to_be32(NFSERR_NODEV)
 #define	nfserr_notdir		cpu_to_be32(NFSERR_NOTDIR)
 #define	nfserr_isdir		cpu_to_be32(NFSERR_ISDIR)
 #define	nfserr_inval		cpu_to_be32(NFSERR_INVAL)
 #define	nfserr_fbig		cpu_to_be32(NFSERR_FBIG)
 #define	nfserr_nospc		cpu_to_be32(NFSERR_NOSPC)
 #define	nfserr_rofs		cpu_to_be32(NFSERR_ROFS)
 #define	nfserr_mlink		cpu_to_be32(NFSERR_MLINK)
 #define	nfserr_opnotsupp	cpu_to_be32(NFSERR_OPNOTSUPP)
 #define	nfserr_nametoolong	cpu_to_be32(NFSERR_NAMETOOLONG)
 #define	nfserr_notempty		cpu_to_be32(NFSERR_NOTEMPTY)
 #define	nfserr_dquot		cpu_to_be32(NFSERR_DQUOT)
 #define	nfserr_stale		cpu_to_be32(NFSERR_STALE)
 #define	nfserr_remote		cpu_to_be32(NFSERR_REMOTE)
 #define	nfserr_wflush		cpu_to_be32(NFSERR_WFLUSH)
 #define	nfserr_badhandle	cpu_to_be32(NFSERR_BADHANDLE)
 #define	nfserr_notsync		cpu_to_be32(NFSERR_NOT_SYNC)
 #define	nfserr_badcookie	cpu_to_be32(NFSERR_BAD_COOKIE)
 #define	nfserr_notsupp		cpu_to_be32(NFSERR_NOTSUPP)
 #define	nfserr_toosmall		cpu_to_be32(NFSERR_TOOSMALL)
 #define	nfserr_serverfault	cpu_to_be32(NFSERR_SERVERFAULT)
 #define	nfserr_badtype		cpu_to_be32(NFSERR_BADTYPE)
 #define	nfserr_jukebox		cpu_to_be32(NFSERR_JUKEBOX)
 #define	nfserr_denied		cpu_to_be32(NFSERR_DENIED)
 #define	nfserr_deadlock		cpu_to_be32(NFSERR_DEADLOCK)
 #define nfserr_expired          cpu_to_be32(NFSERR_EXPIRED)
 #define	nfserr_bad_cookie	cpu_to_be32(NFSERR_BAD_COOKIE)
 #define	nfserr_same		cpu_to_be32(NFSERR_SAME)
 #define	nfserr_clid_inuse	cpu_to_be32(NFSERR_CLID_INUSE)
 #define	nfserr_stale_clientid	cpu_to_be32(NFSERR_STALE_CLIENTID)
 #define	nfserr_resource		cpu_to_be32(NFSERR_RESOURCE)
 #define	nfserr_moved		cpu_to_be32(NFSERR_MOVED)
 #define	nfserr_nofilehandle	cpu_to_be32(NFSERR_NOFILEHANDLE)
 #define	nfserr_minor_vers_mismatch	cpu_to_be32(NFSERR_MINOR_VERS_MISMATCH)
 #define nfserr_share_denied	cpu_to_be32(NFSERR_SHARE_DENIED)
 #define nfserr_stale_stateid	cpu_to_be32(NFSERR_STALE_STATEID)
 #define nfserr_old_stateid	cpu_to_be32(NFSERR_OLD_STATEID)
 #define nfserr_bad_stateid	cpu_to_be32(NFSERR_BAD_STATEID)
 #define nfserr_bad_seqid	cpu_to_be32(NFSERR_BAD_SEQID)
 #define	nfserr_symlink		cpu_to_be32(NFSERR_SYMLINK)
 #define	nfserr_not_same		cpu_to_be32(NFSERR_NOT_SAME)
 #define nfserr_lock_range	cpu_to_be32(NFSERR_LOCK_RANGE)
 #define	nfserr_restorefh	cpu_to_be32(NFSERR_RESTOREFH)
 #define	nfserr_attrnotsupp	cpu_to_be32(NFSERR_ATTRNOTSUPP)
 #define	nfserr_bad_xdr		cpu_to_be32(NFSERR_BAD_XDR)
 #define	nfserr_openmode		cpu_to_be32(NFSERR_OPENMODE)
 #define	nfserr_badowner		cpu_to_be32(NFSERR_BADOWNER)
 #define	nfserr_locks_held	cpu_to_be32(NFSERR_LOCKS_HELD)
 #define	nfserr_op_illegal	cpu_to_be32(NFSERR_OP_ILLEGAL)
 #define	nfserr_grace		cpu_to_be32(NFSERR_GRACE)
 #define	nfserr_no_grace		cpu_to_be32(NFSERR_NO_GRACE)
 #define	nfserr_reclaim_bad	cpu_to_be32(NFSERR_RECLAIM_BAD)
 #define	nfserr_badname		cpu_to_be32(NFSERR_BADNAME)
 #define	nfserr_cb_path_down	cpu_to_be32(NFSERR_CB_PATH_DOWN)
 #define	nfserr_locked		cpu_to_be32(NFSERR_LOCKED)
 #define	nfserr_wrongsec		cpu_to_be32(NFSERR_WRONGSEC)
 #define nfserr_badiomode		cpu_to_be32(NFS4ERR_BADIOMODE)
 #define nfserr_badlayout		cpu_to_be32(NFS4ERR_BADLAYOUT)
 #define nfserr_bad_session_digest	cpu_to_be32(NFS4ERR_BAD_SESSION_DIGEST)
 #define nfserr_badsession		cpu_to_be32(NFS4ERR_BADSESSION)
 #define nfserr_badslot			cpu_to_be32(NFS4ERR_BADSLOT)
 #define nfserr_complete_already		cpu_to_be32(NFS4ERR_COMPLETE_ALREADY)
 #define nfserr_conn_not_bound_to_session cpu_to_be32(NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
 #define nfserr_deleg_already_wanted	cpu_to_be32(NFS4ERR_DELEG_ALREADY_WANTED)
 #define nfserr_back_chan_busy		cpu_to_be32(NFS4ERR_BACK_CHAN_BUSY)
 #define nfserr_layouttrylater		cpu_to_be32(NFS4ERR_LAYOUTTRYLATER)
 #define nfserr_layoutunavailable	cpu_to_be32(NFS4ERR_LAYOUTUNAVAILABLE)
 #define nfserr_nomatching_layout	cpu_to_be32(NFS4ERR_NOMATCHING_LAYOUT)
 #define nfserr_recallconflict		cpu_to_be32(NFS4ERR_RECALLCONFLICT)
 #define nfserr_unknown_layouttype	cpu_to_be32(NFS4ERR_UNKNOWN_LAYOUTTYPE)
 #define nfserr_seq_misordered		cpu_to_be32(NFS4ERR_SEQ_MISORDERED)
 #define nfserr_sequence_pos		cpu_to_be32(NFS4ERR_SEQUENCE_POS)
 #define nfserr_req_too_big		cpu_to_be32(NFS4ERR_REQ_TOO_BIG)
 #define nfserr_rep_too_big		cpu_to_be32(NFS4ERR_REP_TOO_BIG)
 #define nfserr_rep_too_big_to_cache	cpu_to_be32(NFS4ERR_REP_TOO_BIG_TO_CACHE)
 #define nfserr_retry_uncached_rep	cpu_to_be32(NFS4ERR_RETRY_UNCACHED_REP)
 #define nfserr_unsafe_compound		cpu_to_be32(NFS4ERR_UNSAFE_COMPOUND)
 #define nfserr_too_many_ops		cpu_to_be32(NFS4ERR_TOO_MANY_OPS)
 #define nfserr_op_not_in_session	cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION)
 #define nfserr_hash_alg_unsupp		cpu_to_be32(NFS4ERR_HASH_ALG_UNSUPP)
 #define nfserr_clientid_busy		cpu_to_be32(NFS4ERR_CLIENTID_BUSY)
 #define nfserr_pnfs_io_hole		cpu_to_be32(NFS4ERR_PNFS_IO_HOLE)
 #define nfserr_seq_false_retry		cpu_to_be32(NFS4ERR_SEQ_FALSE_RETRY)
 #define nfserr_bad_high_slot		cpu_to_be32(NFS4ERR_BAD_HIGH_SLOT)
 #define nfserr_deadsession		cpu_to_be32(NFS4ERR_DEADSESSION)
 #define nfserr_encr_alg_unsupp		cpu_to_be32(NFS4ERR_ENCR_ALG_UNSUPP)
 #define nfserr_pnfs_no_layout		cpu_to_be32(NFS4ERR_PNFS_NO_LAYOUT)
 #define nfserr_not_only_op		cpu_to_be32(NFS4ERR_NOT_ONLY_OP)
 #define nfserr_wrong_cred		cpu_to_be32(NFS4ERR_WRONG_CRED)
 #define nfserr_wrong_type		cpu_to_be32(NFS4ERR_WRONG_TYPE)
 #define nfserr_dirdeleg_unavail		cpu_to_be32(NFS4ERR_DIRDELEG_UNAVAIL)
 #define nfserr_reject_deleg		cpu_to_be32(NFS4ERR_REJECT_DELEG)
 #define nfserr_returnconflict		cpu_to_be32(NFS4ERR_RETURNCONFLICT)
 #define nfserr_deleg_revoked		cpu_to_be32(NFS4ERR_DELEG_REVOKED)
 /* error codes for internal use */
 /* if a request fails due to kmalloc failure, it gets dropped.
  *  Client should resend eventually
  */
 #define	nfserr_dropit		cpu_to_be32(30000)
 /* end-of-file indicator in readdir */
 #define	nfserr_eof		cpu_to_be32(30001)
 /* replay detected */
 #define	nfserr_replay_me	cpu_to_be32(11001)
 /* nfs41 replay detected */
 #define	nfserr_replay_cache	cpu_to_be32(11002)
 /* Check for dir entries '.' and '..' */
 #define isdotent(n, l)	(l < 3 && n[0] == '.' && (l == 1 || n[1] == '.'))
 /*
  * Time of server startup
  */
 extern struct timeval	nfssvc_boot;
 #ifdef CONFIG_NFSD_V4
 extern time_t nfsd4_lease;
 extern time_t nfsd4_grace;
 /* before processing a COMPOUND operation, we have to check that there
  * is enough space in the buffer for XDR encode to succeed.  otherwise,
  * we might process an operation with side effects, and be unable to
  * tell the client that the operation succeeded.
  *
  * COMPOUND_SLACK_SPACE - this is the minimum bytes of buffer space
  * needed to encode an "ordinary" _successful_ operation.  (GETATTR,
  * READ, READDIR, and READLINK have their own buffer checks.)  if we
  * fall below this level, we fail the next operation with NFS4ERR_RESOURCE.
  *
  * COMPOUND_ERR_SLACK_SPACE - this is the minimum bytes of buffer space
  * needed to encode an operation which has failed with NFS4ERR_RESOURCE.
  * care is taken to ensure that we never fall below this level for any
  * reason.
  */
 #define	COMPOUND_SLACK_SPACE		140    /* OP_GETFH */
 #define COMPOUND_ERR_SLACK_SPACE	12     /* OP_SETATTR */
 #define NFSD_LAUNDROMAT_MINTIMEOUT      1   /* seconds */
 /*
  * The following attributes are currently not supported by the NFSv4 server:
  *    ARCHIVE       (deprecated anyway)
  *    HIDDEN        (unlikely to be supported any time soon)
  *    MIMETYPE      (unlikely to be supported any time soon)
  *    QUOTA_*       (will be supported in a forthcoming patch)
  *    SYSTEM        (unlikely to be supported any time soon)
  *    TIME_BACKUP   (unlikely to be supported any time soon)
  *    TIME_CREATE   (unlikely to be supported any time soon)
  */
 #define NFSD4_SUPPORTED_ATTRS_WORD0                                                         \
 (FATTR4_WORD0_SUPPORTED_ATTRS   | FATTR4_WORD0_TYPE         | FATTR4_WORD0_FH_EXPIRE_TYPE   \
  | FATTR4_WORD0_CHANGE          | FATTR4_WORD0_SIZE         | FATTR4_WORD0_LINK_SUPPORT     \
  | FATTR4_WORD0_SYMLINK_SUPPORT | FATTR4_WORD0_NAMED_ATTR   | FATTR4_WORD0_FSID             \
  | FATTR4_WORD0_UNIQUE_HANDLES  | FATTR4_WORD0_LEASE_TIME   | FATTR4_WORD0_RDATTR_ERROR     \
  | FATTR4_WORD0_ACLSUPPORT      | FATTR4_WORD0_CANSETTIME   | FATTR4_WORD0_CASE_INSENSITIVE \
  | FATTR4_WORD0_CASE_PRESERVING | FATTR4_WORD0_CHOWN_RESTRICTED                             \
  | FATTR4_WORD0_FILEHANDLE      | FATTR4_WORD0_FILEID       | FATTR4_WORD0_FILES_AVAIL      \
  | FATTR4_WORD0_FILES_FREE      | FATTR4_WORD0_FILES_TOTAL  | FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_HOMOGENEOUS      \
  | FATTR4_WORD0_MAXFILESIZE     | FATTR4_WORD0_MAXLINK      | FATTR4_WORD0_MAXNAME          \
  | FATTR4_WORD0_MAXREAD         | FATTR4_WORD0_MAXWRITE     | FATTR4_WORD0_ACL)
 #define NFSD4_SUPPORTED_ATTRS_WORD1                                                         \
 (FATTR4_WORD1_MODE              | FATTR4_WORD1_NO_TRUNC     | FATTR4_WORD1_NUMLINKS         \
  | FATTR4_WORD1_OWNER	        | FATTR4_WORD1_OWNER_GROUP  | FATTR4_WORD1_RAWDEV           \
  | FATTR4_WORD1_SPACE_AVAIL     | FATTR4_WORD1_SPACE_FREE   | FATTR4_WORD1_SPACE_TOTAL      \
  | FATTR4_WORD1_SPACE_USED      | FATTR4_WORD1_TIME_ACCESS  | FATTR4_WORD1_TIME_ACCESS_SET  \
  | FATTR4_WORD1_TIME_DELTA   | FATTR4_WORD1_TIME_METADATA    \
  | FATTR4_WORD1_TIME_MODIFY     | FATTR4_WORD1_TIME_MODIFY_SET | FATTR4_WORD1_MOUNTED_ON_FILEID)
 #define NFSD4_SUPPORTED_ATTRS_WORD2 0
 #define NFSD4_1_SUPPORTED_ATTRS_WORD0 \
 	NFSD4_SUPPORTED_ATTRS_WORD0
 #define NFSD4_1_SUPPORTED_ATTRS_WORD1 \
 	NFSD4_SUPPORTED_ATTRS_WORD1
 #define NFSD4_1_SUPPORTED_ATTRS_WORD2 \
 	(NFSD4_SUPPORTED_ATTRS_WORD2 | FATTR4_WORD2_SUPPATTR_EXCLCREAT)
 static inline u32 nfsd_suppattrs0(u32 minorversion)
 {
 	return minorversion ? NFSD4_1_SUPPORTED_ATTRS_WORD0
 			    : NFSD4_SUPPORTED_ATTRS_WORD0;
 }
 static inline u32 nfsd_suppattrs1(u32 minorversion)
 {
 	return minorversion ? NFSD4_1_SUPPORTED_ATTRS_WORD1
 			    : NFSD4_SUPPORTED_ATTRS_WORD1;
 }
 static inline u32 nfsd_suppattrs2(u32 minorversion)
 {
 	return minorversion ? NFSD4_1_SUPPORTED_ATTRS_WORD2
 			    : NFSD4_SUPPORTED_ATTRS_WORD2;
 }
 /* These will return ERR_INVAL if specified in GETATTR or READDIR. */
 #define NFSD_WRITEONLY_ATTRS_WORD1 \
 	(FATTR4_WORD1_TIME_ACCESS_SET   | FATTR4_WORD1_TIME_MODIFY_SET)
 /* These are the only attrs allowed in CREATE/OPEN/SETATTR. */
 #define NFSD_WRITEABLE_ATTRS_WORD0 \
 	(FATTR4_WORD0_SIZE | FATTR4_WORD0_ACL)
 #define NFSD_WRITEABLE_ATTRS_WORD1 \
 	(FATTR4_WORD1_MODE | FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP \
 	| FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET)
 #define NFSD_WRITEABLE_ATTRS_WORD2 0
 #define NFSD_SUPPATTR_EXCLCREAT_WORD0 \
 	NFSD_WRITEABLE_ATTRS_WORD0
 /*
  * we currently store the exclusive create verifier in the v_{a,m}time
  * attributes so the client can't set these at create time using EXCLUSIVE4_1
  */
 #define NFSD_SUPPATTR_EXCLCREAT_WORD1 \
 	(NFSD_WRITEABLE_ATTRS_WORD1 & \
 	 ~(FATTR4_WORD1_TIME_ACCESS_SET | FATTR4_WORD1_TIME_MODIFY_SET))
 #define NFSD_SUPPATTR_EXCLCREAT_WORD2 \
 	NFSD_WRITEABLE_ATTRS_WORD2
 extern int nfsd4_is_junction(struct dentry *dentry);
-#else
+extern int register_cld_notifier(void);
+extern void unregister_cld_notifier(void);
+#else /* CONFIG_NFSD_V4 */
 static inline int nfsd4_is_junction(struct dentry *dentry)
 {
 	return 0;
 }
+#define register_cld_notifier() 0
+#define unregister_cld_notifier() do { } while(0)
 #endif /* CONFIG_NFSD_V4 */
 #endif /* LINUX_NFSD_NFSD_H */