[linux-block.git] / fs / nfs / getroot.c

/* getroot.c: get the root dentry for an NFS mount
 *
 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@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.
 */

#include <linux/module.h>
#include <linux/init.h>

#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/stats.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs4_mount.h>
#include <linux/lockd/bind.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
#include <linux/nfs_idmap.h>
#include <linux/vfs.h>
#include <linux/namei.h>
#include <linux/mnt_namespace.h>
#include <linux/security.h>

#include <asm/system.h>
#include <asm/uaccess.h>

#include "nfs4_fs.h"
#include "delegation.h"
#include "internal.h"

#define NFSDBG_FACILITY		NFSDBG_CLIENT

/*
 * Set the superblock root dentry.
 * Note that this function frees the inode in case of error.
 */
static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *inode)
{
	/* The mntroot acts as the dummy root dentry for this superblock */
	if (sb->s_root == NULL) {
		sb->s_root = d_alloc_root(inode);
		if (sb->s_root == NULL) {
			iput(inode);
			return -ENOMEM;
		}
		/* Circumvent igrab(): we know the inode is not being freed */
		atomic_inc(&inode->i_count);
		/*
		 * Ensure that this dentry is invisible to d_find_alias().
		 * Otherwise, it may be spliced into the tree by
		 * d_materialise_unique if a parent directory from the same
		 * filesystem gets mounted at a later time.
		 * This again causes shrink_dcache_for_umount_subtree() to
		 * Oops, since the test for IS_ROOT() will fail.
		 */
		spin_lock(&dcache_lock);
		list_del_init(&sb->s_root->d_alias);
		spin_unlock(&dcache_lock);
	}
	return 0;
}

/*
 * get an NFS2/NFS3 root dentry from the root filehandle
 */
struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh)
{
	struct nfs_server *server = NFS_SB(sb);
	struct nfs_fsinfo fsinfo;
	struct nfs_fattr fattr;
	struct dentry *mntroot;
	struct inode *inode;
	int error;

	/* get the actual root for this mount */
	fsinfo.fattr = &fattr;

	error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	if (error < 0) {
		dprintk("nfs_get_root: getattr error = %d\n", -error);
		return ERR_PTR(error);
	}

	inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
	if (IS_ERR(inode)) {
		dprintk("nfs_get_root: get root inode failed\n");
		return ERR_CAST(inode);
	}

	error = nfs_superblock_set_dummy_root(sb, inode);
	if (error != 0)
		return ERR_PTR(error);

	/* root dentries normally start off anonymous and get spliced in later
	 * if the dentry tree reaches them; however if the dentry already
	 * exists, we'll pick it up at this point and use it as the root
	 */
	mntroot = d_obtain_alias(inode);
	if (IS_ERR(mntroot)) {
		dprintk("nfs_get_root: get root dentry failed\n");
		return mntroot;
	}

	security_d_instantiate(mntroot, inode);

	if (!mntroot->d_op)
		mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;

	return mntroot;
}

#ifdef CONFIG_NFS_V4

/*
 * Do a simple pathwalk from the root FH of the server to the nominated target
 * of the mountpoint
 * - give error on symlinks
 * - give error on ".." occurring in the path
 * - follow traversals
 */
int nfs4_path_walk(struct nfs_server *server,
		   struct nfs_fh *mntfh,
		   const char *path)
{
	struct nfs_fsinfo fsinfo;
	struct nfs_fattr fattr;
	struct nfs_fh lastfh;
	struct qstr name;
	int ret;

	dprintk("--> nfs4_path_walk(,,%s)\n", path);

	fsinfo.fattr = &fattr;
	nfs_fattr_init(&fattr);

	/* Eat leading slashes */
	while (*path == '/')
		path++;

	/* Start by getting the root filehandle from the server */
	ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	if (ret < 0) {
		dprintk("nfs4_get_root: getroot error = %d\n", -ret);
		return ret;
	}

	if (!S_ISDIR(fattr.mode)) {
		printk(KERN_ERR "nfs4_get_root:"
		       " getroot encountered non-directory\n");
		return -ENOTDIR;
	}

	/* FIXME: It is quite valid for the server to return a referral here */
	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
		printk(KERN_ERR "nfs4_get_root:"
		       " getroot obtained referral\n");
		return -EREMOTE;
	}

next_component:
	dprintk("Next: %s\n", path);

	/* extract the next bit of the path */
	if (!*path)
		goto path_walk_complete;

	name.name = path;
	while (*path && *path != '/')
		path++;
	name.len = path - (const char *) name.name;

	if (name.len > NFS4_MAXNAMLEN)
		return -ENAMETOOLONG;

eat_dot_dir:
	while (*path == '/')
		path++;

	if (path[0] == '.' && (path[1] == '/' || !path[1])) {
		path += 2;
		goto eat_dot_dir;
	}

	/* FIXME: Why shouldn't the user be able to use ".." in the path? */
	if (path[0] == '.' && path[1] == '.' && (path[2] == '/' || !path[2])
	    ) {
		printk(KERN_ERR "nfs4_get_root:"
		       " Mount path contains reference to \"..\"\n");
		return -EINVAL;
	}

	/* lookup the next FH in the sequence */
	memcpy(&lastfh, mntfh, sizeof(lastfh));

	dprintk("LookupFH: %*.*s [%s]\n", name.len, name.len, name.name, path);

	ret = server->nfs_client->rpc_ops->lookupfh(server, &lastfh, &name,
						    mntfh, &fattr);
	if (ret < 0) {
		dprintk("nfs4_get_root: getroot error = %d\n", -ret);
		return ret;
	}

	if (!S_ISDIR(fattr.mode)) {
		printk(KERN_ERR "nfs4_get_root:"
		       " lookupfh encountered non-directory\n");
		return -ENOTDIR;
	}

	/* FIXME: Referrals are quite valid here too */
	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
		printk(KERN_ERR "nfs4_get_root:"
		       " lookupfh obtained referral\n");
		return -EREMOTE;
	}

	goto next_component;

path_walk_complete:
	memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
	dprintk("<-- nfs4_path_walk() = 0\n");
	return 0;
}

/*
 * get an NFS4 root dentry from the root filehandle
 */
struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh)
{
	struct nfs_server *server = NFS_SB(sb);
	struct nfs_fattr fattr;
	struct dentry *mntroot;
	struct inode *inode;
	int error;

	dprintk("--> nfs4_get_root()\n");

	/* get the info about the server and filesystem */
	error = nfs4_server_capabilities(server, mntfh);
	if (error < 0) {
		dprintk("nfs_get_root: getcaps error = %d\n",
			-error);
		return ERR_PTR(error);
	}

	/* get the actual root for this mount */
	error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
	if (error < 0) {
		dprintk("nfs_get_root: getattr error = %d\n", -error);
		return ERR_PTR(error);
	}

	inode = nfs_fhget(sb, mntfh, &fattr);
	if (IS_ERR(inode)) {
		dprintk("nfs_get_root: get root inode failed\n");
		return ERR_CAST(inode);
	}

	error = nfs_superblock_set_dummy_root(sb, inode);
	if (error != 0)
		return ERR_PTR(error);

	/* root dentries normally start off anonymous and get spliced in later
	 * if the dentry tree reaches them; however if the dentry already
	 * exists, we'll pick it up at this point and use it as the root
	 */
	mntroot = d_obtain_alias(inode);
	if (IS_ERR(mntroot)) {
		dprintk("nfs_get_root: get root dentry failed\n");
		return mntroot;
	}

	security_d_instantiate(mntroot, inode);

	if (!mntroot->d_op)
		mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;

	dprintk("<-- nfs4_get_root()\n");
	return mntroot;
}

#endif /* CONFIG_NFS_V4 */
Commit	Line	Data
54ceac45 DH	1	/* getroot.c: get the root dentry for an NFS mount
	2	*
	3	* Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
54ceac45 DH	12	#include <linux/module.h>
	13	#include <linux/init.h>
	14
	15	#include <linux/time.h>
	16	#include <linux/kernel.h>
	17	#include <linux/mm.h>
	18	#include <linux/string.h>
	19	#include <linux/stat.h>
	20	#include <linux/errno.h>
	21	#include <linux/unistd.h>
	22	#include <linux/sunrpc/clnt.h>
	23	#include <linux/sunrpc/stats.h>
	24	#include <linux/nfs_fs.h>
	25	#include <linux/nfs_mount.h>
	26	#include <linux/nfs4_mount.h>
	27	#include <linux/lockd/bind.h>
54ceac45 DH	28	#include <linux/seq_file.h>
	29	#include <linux/mount.h>
	30	#include <linux/nfs_idmap.h>
	31	#include <linux/vfs.h>
	32	#include <linux/namei.h>
6b3286ed	33	#include <linux/mnt_namespace.h>
738a3519	34	#include <linux/security.h>
54ceac45 DH	35
	36	#include <asm/system.h>
	37	#include <asm/uaccess.h>
	38
	39	#include "nfs4_fs.h"
	40	#include "delegation.h"
	41	#include "internal.h"
	42
	43	#define NFSDBG_FACILITY NFSDBG_CLIENT
54ceac45	44
b09b9417 TM	45	/*
	46	* Set the superblock root dentry.
	47	* Note that this function frees the inode in case of error.
	48	*/
	49	static int nfs_superblock_set_dummy_root(struct super_block sb, struct inode inode)
	50	{
	51	/* The mntroot acts as the dummy root dentry for this superblock */
	52	if (sb->s_root == NULL) {
	53	sb->s_root = d_alloc_root(inode);
	54	if (sb->s_root == NULL) {
	55	iput(inode);
	56	return -ENOMEM;
	57	}
	58	/* Circumvent igrab(): we know the inode is not being freed */
	59	atomic_inc(&inode->i_count);
a10db50a TM	60	/*
	61	* Ensure that this dentry is invisible to d_find_alias().
	62	* Otherwise, it may be spliced into the tree by
	63	* d_materialise_unique if a parent directory from the same
	64	* filesystem gets mounted at a later time.
	65	* This again causes shrink_dcache_for_umount_subtree() to
	66	* Oops, since the test for IS_ROOT() will fail.
	67	*/
	68	spin_lock(&dcache_lock);
	69	list_del_init(&sb->s_root->d_alias);
	70	spin_unlock(&dcache_lock);
b09b9417 TM	71	}
	72	return 0;
	73	}
	74
54ceac45 DH	75	/*
	76	* get an NFS2/NFS3 root dentry from the root filehandle
	77	*/
	78	struct dentry nfs_get_root(struct super_block sb, struct nfs_fh *mntfh)
	79	{
	80	struct nfs_server *server = NFS_SB(sb);
	81	struct nfs_fsinfo fsinfo;
	82	struct nfs_fattr fattr;
	83	struct dentry *mntroot;
	84	struct inode *inode;
	85	int error;
	86
54ceac45 DH	87	/* get the actual root for this mount */
	88	fsinfo.fattr = &fattr;
	89
	90	error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	91	if (error < 0) {
	92	dprintk("nfs_get_root: getattr error = %d\n", -error);
	93	return ERR_PTR(error);
	94	}
	95
	96	inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
	97	if (IS_ERR(inode)) {
	98	dprintk("nfs_get_root: get root inode failed\n");
e231c2ee	99	return ERR_CAST(inode);
54ceac45 DH	100	}
54ceac45 DH	101
b09b9417 TM	102	error = nfs_superblock_set_dummy_root(sb, inode);
	103	if (error != 0)
	104	return ERR_PTR(error);
	105
54ceac45 DH	106	/* root dentries normally start off anonymous and get spliced in later
	107	* if the dentry tree reaches them; however if the dentry already
	108	* exists, we'll pick it up at this point and use it as the root
	109	*/
44003728 CH	110	mntroot = d_obtain_alias(inode);
44003728 CH	111	if (IS_ERR(mntroot)) {
54ceac45	112	dprintk("nfs_get_root: get root dentry failed\n");
44003728	113	return mntroot;
54ceac45 DH	114	}
54ceac45 DH	115
738a3519 DH	116	security_d_instantiate(mntroot, inode);
738a3519 DH	117
54ceac45 DH	118	if (!mntroot->d_op)
	119	mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
	120
	121	return mntroot;
	122	}
	123
	124	#ifdef CONFIG_NFS_V4
	125
	126	/*
	127	* Do a simple pathwalk from the root FH of the server to the nominated target
	128	* of the mountpoint
	129	* - give error on symlinks
	130	* - give error on ".." occurring in the path
	131	* - follow traversals
	132	*/
	133	int nfs4_path_walk(struct nfs_server *server,
	134	struct nfs_fh *mntfh,
	135	const char *path)
	136	{
	137	struct nfs_fsinfo fsinfo;
	138	struct nfs_fattr fattr;
	139	struct nfs_fh lastfh;
	140	struct qstr name;
	141	int ret;
54ceac45 DH	142
	143	dprintk("--> nfs4_path_walk(,,%s)\n", path);
	144
	145	fsinfo.fattr = &fattr;
	146	nfs_fattr_init(&fattr);
	147
faebf4e2 TM	148	/* Eat leading slashes */
	149	while (*path == '/')
	150	path++;
54ceac45 DH	151
	152	/* Start by getting the root filehandle from the server */
	153	ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	154	if (ret < 0) {
	155	dprintk("nfs4_get_root: getroot error = %d\n", -ret);
	156	return ret;
	157	}
	158
bca79478	159	if (!S_ISDIR(fattr.mode)) {
54ceac45 DH	160	printk(KERN_ERR "nfs4_get_root:"
	161	" getroot encountered non-directory\n");
	162	return -ENOTDIR;
	163	}
	164
faebf4e2	165	/* FIXME: It is quite valid for the server to return a referral here */
54ceac45 DH	166	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
	167	printk(KERN_ERR "nfs4_get_root:"
	168	" getroot obtained referral\n");
	169	return -EREMOTE;
	170	}
	171
	172	next_component:
	173	dprintk("Next: %s\n", path);
	174
	175	/* extract the next bit of the path */
	176	if (!*path)
	177	goto path_walk_complete;
	178
	179	name.name = path;
	180	while (path && path != '/')
	181	path++;
	182	name.len = path - (const char *) name.name;
	183
54af3bb5 TM	184	if (name.len > NFS4_MAXNAMLEN)
	185	return -ENAMETOOLONG;
	186
54ceac45 DH	187	eat_dot_dir:
	188	while (*path == '/')
	189	path++;
	190
	191	if (path[0] == '.' && (path[1] == '/' \|\| !path[1])) {
	192	path += 2;
	193	goto eat_dot_dir;
	194	}
	195
faebf4e2	196	/* FIXME: Why shouldn't the user be able to use ".." in the path? */
54ceac45 DH	197	if (path[0] == '.' && path[1] == '.' && (path[2] == '/' \|\| !path[2])
	198	) {
	199	printk(KERN_ERR "nfs4_get_root:"
	200	" Mount path contains reference to \"..\"\n");
	201	return -EINVAL;
	202	}
	203
	204	/* lookup the next FH in the sequence */
	205	memcpy(&lastfh, mntfh, sizeof(lastfh));
	206
	207	dprintk("LookupFH: %.s [%s]\n", name.len, name.len, name.name, path);
	208
	209	ret = server->nfs_client->rpc_ops->lookupfh(server, &lastfh, &name,
	210	mntfh, &fattr);
	211	if (ret < 0) {
	212	dprintk("nfs4_get_root: getroot error = %d\n", -ret);
	213	return ret;
	214	}
	215
bca79478	216	if (!S_ISDIR(fattr.mode)) {
54ceac45 DH	217	printk(KERN_ERR "nfs4_get_root:"
	218	" lookupfh encountered non-directory\n");
	219	return -ENOTDIR;
	220	}
	221
faebf4e2	222	/* FIXME: Referrals are quite valid here too */
54ceac45 DH	223	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
	224	printk(KERN_ERR "nfs4_get_root:"
	225	" lookupfh obtained referral\n");
	226	return -EREMOTE;
	227	}
	228
	229	goto next_component;
	230
	231	path_walk_complete:
	232	memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
	233	dprintk("<-- nfs4_path_walk() = 0\n");
	234	return 0;
	235	}
	236
	237	/*
	238	* get an NFS4 root dentry from the root filehandle
	239	*/
	240	struct dentry nfs4_get_root(struct super_block sb, struct nfs_fh *mntfh)
	241	{
	242	struct nfs_server *server = NFS_SB(sb);
	243	struct nfs_fattr fattr;
	244	struct dentry *mntroot;
	245	struct inode *inode;
	246	int error;
	247
	248	dprintk("--> nfs4_get_root()\n");
	249
54ceac45 DH	250	/* get the info about the server and filesystem */
	251	error = nfs4_server_capabilities(server, mntfh);
	252	if (error < 0) {
	253	dprintk("nfs_get_root: getcaps error = %d\n",
	254	-error);
	255	return ERR_PTR(error);
	256	}
	257
	258	/* get the actual root for this mount */
	259	error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
	260	if (error < 0) {
	261	dprintk("nfs_get_root: getattr error = %d\n", -error);
	262	return ERR_PTR(error);
	263	}
	264
	265	inode = nfs_fhget(sb, mntfh, &fattr);
	266	if (IS_ERR(inode)) {
	267	dprintk("nfs_get_root: get root inode failed\n");
e231c2ee	268	return ERR_CAST(inode);
54ceac45 DH	269	}
54ceac45 DH	270
b09b9417 TM	271	error = nfs_superblock_set_dummy_root(sb, inode);
	272	if (error != 0)
	273	return ERR_PTR(error);
	274
54ceac45 DH	275	/* root dentries normally start off anonymous and get spliced in later
	276	* if the dentry tree reaches them; however if the dentry already
	277	* exists, we'll pick it up at this point and use it as the root
	278	*/
44003728 CH	279	mntroot = d_obtain_alias(inode);
44003728 CH	280	if (IS_ERR(mntroot)) {
54ceac45	281	dprintk("nfs_get_root: get root dentry failed\n");
44003728	282	return mntroot;
54ceac45 DH	283	}
54ceac45 DH	284
738a3519 DH	285	security_d_instantiate(mntroot, inode);
738a3519 DH	286
54ceac45 DH	287	if (!mntroot->d_op)
	288	mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
	289
	290	dprintk("<-- nfs4_get_root()\n");
	291	return mntroot;
	292	}
	293
	294	#endif /* CONFIG_NFS_V4 */