[GitHub/mt8127/android_kernel_alcatel_ttab.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_alloc_anon(inode);
	if (!mntroot) {
		iput(inode);
		dprintk("nfs_get_root: get root dentry failed\n");
		return ERR_PTR(-ENOMEM);
	}

	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 (fattr.type != NFDIR) {
		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 (fattr.type != NFDIR) {
		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_alloc_anon(inode);
	if (!mntroot) {
		iput(inode);
		dprintk("nfs_get_root: get root dentry failed\n");
		return ERR_PTR(-ENOMEM);
	}

	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	*/
	110	mntroot = d_alloc_anon(inode);
	111	if (!mntroot) {
	112	iput(inode);
	113	dprintk("nfs_get_root: get root dentry failed\n");
	114	return ERR_PTR(-ENOMEM);
	115	}
	116
738a3519 DH	117	security_d_instantiate(mntroot, inode);
738a3519 DH	118
54ceac45 DH	119	if (!mntroot->d_op)
	120	mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
	121
	122	return mntroot;
	123	}
	124
	125	#ifdef CONFIG_NFS_V4
	126
	127	/*
	128	* Do a simple pathwalk from the root FH of the server to the nominated target
	129	* of the mountpoint
	130	* - give error on symlinks
	131	* - give error on ".." occurring in the path
	132	* - follow traversals
	133	*/
	134	int nfs4_path_walk(struct nfs_server *server,
	135	struct nfs_fh *mntfh,
	136	const char *path)
	137	{
	138	struct nfs_fsinfo fsinfo;
	139	struct nfs_fattr fattr;
	140	struct nfs_fh lastfh;
	141	struct qstr name;
	142	int ret;
54ceac45 DH	143
	144	dprintk("--> nfs4_path_walk(,,%s)\n", path);
	145
	146	fsinfo.fattr = &fattr;
	147	nfs_fattr_init(&fattr);
	148
faebf4e2 TM	149	/* Eat leading slashes */
	150	while (*path == '/')
	151	path++;
54ceac45 DH	152
	153	/* Start by getting the root filehandle from the server */
	154	ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	155	if (ret < 0) {
	156	dprintk("nfs4_get_root: getroot error = %d\n", -ret);
	157	return ret;
	158	}
	159
	160	if (fattr.type != NFDIR) {
	161	printk(KERN_ERR "nfs4_get_root:"
	162	" getroot encountered non-directory\n");
	163	return -ENOTDIR;
	164	}
	165
faebf4e2	166	/* FIXME: It is quite valid for the server to return a referral here */
54ceac45 DH	167	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
	168	printk(KERN_ERR "nfs4_get_root:"
	169	" getroot obtained referral\n");
	170	return -EREMOTE;
	171	}
	172
	173	next_component:
	174	dprintk("Next: %s\n", path);
	175
	176	/* extract the next bit of the path */
	177	if (!*path)
	178	goto path_walk_complete;
	179
	180	name.name = path;
	181	while (path && path != '/')
	182	path++;
	183	name.len = path - (const char *) name.name;
	184
54af3bb5 TM	185	if (name.len > NFS4_MAXNAMLEN)
	186	return -ENAMETOOLONG;
	187
54ceac45 DH	188	eat_dot_dir:
	189	while (*path == '/')
	190	path++;
	191
	192	if (path[0] == '.' && (path[1] == '/' \|\| !path[1])) {
	193	path += 2;
	194	goto eat_dot_dir;
	195	}
	196
faebf4e2	197	/* FIXME: Why shouldn't the user be able to use ".." in the path? */
54ceac45 DH	198	if (path[0] == '.' && path[1] == '.' && (path[2] == '/' \|\| !path[2])
	199	) {
	200	printk(KERN_ERR "nfs4_get_root:"
	201	" Mount path contains reference to \"..\"\n");
	202	return -EINVAL;
	203	}
	204
	205	/* lookup the next FH in the sequence */
	206	memcpy(&lastfh, mntfh, sizeof(lastfh));
	207
	208	dprintk("LookupFH: %.s [%s]\n", name.len, name.len, name.name, path);
	209
	210	ret = server->nfs_client->rpc_ops->lookupfh(server, &lastfh, &name,
	211	mntfh, &fattr);
	212	if (ret < 0) {
	213	dprintk("nfs4_get_root: getroot error = %d\n", -ret);
	214	return ret;
	215	}
	216
	217	if (fattr.type != NFDIR) {
	218	printk(KERN_ERR "nfs4_get_root:"
	219	" lookupfh encountered non-directory\n");
	220	return -ENOTDIR;
	221	}
	222
faebf4e2	223	/* FIXME: Referrals are quite valid here too */
54ceac45 DH	224	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
	225	printk(KERN_ERR "nfs4_get_root:"
	226	" lookupfh obtained referral\n");
	227	return -EREMOTE;
	228	}
	229
	230	goto next_component;
	231
	232	path_walk_complete:
	233	memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
	234	dprintk("<-- nfs4_path_walk() = 0\n");
	235	return 0;
	236	}
	237
	238	/*
	239	* get an NFS4 root dentry from the root filehandle
	240	*/
	241	struct dentry nfs4_get_root(struct super_block sb, struct nfs_fh *mntfh)
	242	{
	243	struct nfs_server *server = NFS_SB(sb);
	244	struct nfs_fattr fattr;
	245	struct dentry *mntroot;
	246	struct inode *inode;
	247	int error;
	248
	249	dprintk("--> nfs4_get_root()\n");
	250
54ceac45 DH	251	/* get the info about the server and filesystem */
	252	error = nfs4_server_capabilities(server, mntfh);
	253	if (error < 0) {
	254	dprintk("nfs_get_root: getcaps error = %d\n",
	255	-error);
	256	return ERR_PTR(error);
	257	}
	258
	259	/* get the actual root for this mount */
	260	error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
	261	if (error < 0) {
	262	dprintk("nfs_get_root: getattr error = %d\n", -error);
	263	return ERR_PTR(error);
	264	}
	265
	266	inode = nfs_fhget(sb, mntfh, &fattr);
	267	if (IS_ERR(inode)) {
	268	dprintk("nfs_get_root: get root inode failed\n");
e231c2ee	269	return ERR_CAST(inode);
54ceac45 DH	270	}
54ceac45 DH	271
b09b9417 TM	272	error = nfs_superblock_set_dummy_root(sb, inode);
	273	if (error != 0)
	274	return ERR_PTR(error);
	275
54ceac45 DH	276	/* root dentries normally start off anonymous and get spliced in later
	277	* if the dentry tree reaches them; however if the dentry already
	278	* exists, we'll pick it up at this point and use it as the root
	279	*/
	280	mntroot = d_alloc_anon(inode);
	281	if (!mntroot) {
	282	iput(inode);
	283	dprintk("nfs_get_root: get root dentry failed\n");
	284	return ERR_PTR(-ENOMEM);
	285	}
	286
738a3519 DH	287	security_d_instantiate(mntroot, inode);
738a3519 DH	288
54ceac45 DH	289	if (!mntroot->d_op)
	290	mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
	291
	292	dprintk("<-- nfs4_get_root()\n");
	293	return mntroot;
	294	}
	295
	296	#endif /* CONFIG_NFS_V4 */