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

/*
 * 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;

	/* create a dummy root dentry with dummy inode for this superblock */
	if (!sb->s_root) {
		struct nfs_fh dummyfh;
		struct dentry *root;
		struct inode *iroot;

		memset(&dummyfh, 0, sizeof(dummyfh));
		memset(&fattr, 0, sizeof(fattr));
		nfs_fattr_init(&fattr);
		fattr.valid = NFS_ATTR_FATTR;
		fattr.type = NFDIR;
		fattr.mode = S_IFDIR | S_IRUSR | S_IWUSR;
		fattr.nlink = 2;

		iroot = nfs_fhget(sb, &dummyfh, &fattr);
		if (IS_ERR(iroot))
			return ERR_PTR(PTR_ERR(iroot));

		root = d_alloc_root(iroot);
		if (!root) {
			iput(iroot);
			return ERR_PTR(-ENOMEM);
		}

		sb->s_root = root;
	}

	/* 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_PTR(PTR_ERR(inode));
	}

	/* 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");

	/* create a dummy root dentry with dummy inode for this superblock */
	if (!sb->s_root) {
		struct nfs_fh dummyfh;
		struct dentry *root;
		struct inode *iroot;

		memset(&dummyfh, 0, sizeof(dummyfh));
		memset(&fattr, 0, sizeof(fattr));
		nfs_fattr_init(&fattr);
		fattr.valid = NFS_ATTR_FATTR;
		fattr.type = NFDIR;
		fattr.mode = S_IFDIR | S_IRUSR | S_IWUSR;
		fattr.nlink = 2;

		iroot = nfs_fhget(sb, &dummyfh, &fattr);
		if (IS_ERR(iroot))
			return ERR_PTR(PTR_ERR(iroot));

		root = d_alloc_root(iroot);
		if (!root) {
			iput(iroot);
			return ERR_PTR(-ENOMEM);
		}

		sb->s_root = root;
	}

	/* 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_PTR(PTR_ERR(inode));
	}

	/* 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 DH	44
	45	/*
	46	* get an NFS2/NFS3 root dentry from the root filehandle
	47	*/
	48	struct dentry nfs_get_root(struct super_block sb, struct nfs_fh *mntfh)
	49	{
	50	struct nfs_server *server = NFS_SB(sb);
	51	struct nfs_fsinfo fsinfo;
	52	struct nfs_fattr fattr;
	53	struct dentry *mntroot;
	54	struct inode *inode;
	55	int error;
	56
	57	/* create a dummy root dentry with dummy inode for this superblock */
	58	if (!sb->s_root) {
	59	struct nfs_fh dummyfh;
	60	struct dentry *root;
	61	struct inode *iroot;
	62
	63	memset(&dummyfh, 0, sizeof(dummyfh));
	64	memset(&fattr, 0, sizeof(fattr));
	65	nfs_fattr_init(&fattr);
	66	fattr.valid = NFS_ATTR_FATTR;
	67	fattr.type = NFDIR;
	68	fattr.mode = S_IFDIR \| S_IRUSR \| S_IWUSR;
	69	fattr.nlink = 2;
	70
	71	iroot = nfs_fhget(sb, &dummyfh, &fattr);
	72	if (IS_ERR(iroot))
	73	return ERR_PTR(PTR_ERR(iroot));
	74
	75	root = d_alloc_root(iroot);
	76	if (!root) {
	77	iput(iroot);
	78	return ERR_PTR(-ENOMEM);
	79	}
	80
	81	sb->s_root = root;
	82	}
	83
	84	/* get the actual root for this mount */
	85	fsinfo.fattr = &fattr;
	86
	87	error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	88	if (error < 0) {
	89	dprintk("nfs_get_root: getattr error = %d\n", -error);
	90	return ERR_PTR(error);
	91	}
	92
	93	inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
	94	if (IS_ERR(inode)) {
	95	dprintk("nfs_get_root: get root inode failed\n");
	96	return ERR_PTR(PTR_ERR(inode));
	97	}
	98
	99	/* root dentries normally start off anonymous and get spliced in later
	100	* if the dentry tree reaches them; however if the dentry already
	101	* exists, we'll pick it up at this point and use it as the root
	102	*/
	103	mntroot = d_alloc_anon(inode);
	104	if (!mntroot) {
	105	iput(inode);
	106	dprintk("nfs_get_root: get root dentry failed\n");
	107	return ERR_PTR(-ENOMEM);
108	}
109
738a3519 DH	110	security_d_instantiate(mntroot, inode);
738a3519 DH	111
54ceac45 DH	112	if (!mntroot->d_op)
	113	mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
	114
	115	return mntroot;
	116	}
	117
	118	#ifdef CONFIG_NFS_V4
	119
	120	/*
	121	* Do a simple pathwalk from the root FH of the server to the nominated target
	122	* of the mountpoint
	123	* - give error on symlinks
	124	* - give error on ".." occurring in the path
	125	* - follow traversals
	126	*/
	127	int nfs4_path_walk(struct nfs_server *server,
	128	struct nfs_fh *mntfh,
	129	const char *path)
	130	{
	131	struct nfs_fsinfo fsinfo;
	132	struct nfs_fattr fattr;
	133	struct nfs_fh lastfh;
	134	struct qstr name;
	135	int ret;
54ceac45 DH	136
	137	dprintk("--> nfs4_path_walk(,,%s)\n", path);
	138
	139	fsinfo.fattr = &fattr;
	140	nfs_fattr_init(&fattr);
	141
faebf4e2 TM	142	/* Eat leading slashes */
	143	while (*path == '/')
	144	path++;
54ceac45 DH	145
	146	/* Start by getting the root filehandle from the server */
	147	ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
	148	if (ret < 0) {
	149	dprintk("nfs4_get_root: getroot error = %d\n", -ret);
	150	return ret;
	151	}
	152
	153	if (fattr.type != NFDIR) {
	154	printk(KERN_ERR "nfs4_get_root:"
	155	" getroot encountered non-directory\n");
	156	return -ENOTDIR;
	157	}
	158
faebf4e2	159	/* FIXME: It is quite valid for the server to return a referral here */
54ceac45 DH	160	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
	161	printk(KERN_ERR "nfs4_get_root:"
	162	" getroot obtained referral\n");
	163	return -EREMOTE;
	164	}
	165
	166	next_component:
	167	dprintk("Next: %s\n", path);
	168
	169	/* extract the next bit of the path */
	170	if (!*path)
	171	goto path_walk_complete;
	172
	173	name.name = path;
	174	while (path && path != '/')
	175	path++;
	176	name.len = path - (const char *) name.name;
	177
54af3bb5 TM	178	if (name.len > NFS4_MAXNAMLEN)
	179	return -ENAMETOOLONG;
	180
54ceac45 DH	181	eat_dot_dir:
	182	while (*path == '/')
	183	path++;
	184
	185	if (path[0] == '.' && (path[1] == '/' \|\| !path[1])) {
	186	path += 2;
	187	goto eat_dot_dir;
	188	}
	189
faebf4e2	190	/* FIXME: Why shouldn't the user be able to use ".." in the path? */
54ceac45 DH	191	if (path[0] == '.' && path[1] == '.' && (path[2] == '/' \|\| !path[2])
	192	) {
	193	printk(KERN_ERR "nfs4_get_root:"
	194	" Mount path contains reference to \"..\"\n");
	195	return -EINVAL;
	196	}
	197
	198	/* lookup the next FH in the sequence */
	199	memcpy(&lastfh, mntfh, sizeof(lastfh));
	200
	201	dprintk("LookupFH: %.s [%s]\n", name.len, name.len, name.name, path);
	202
	203	ret = server->nfs_client->rpc_ops->lookupfh(server, &lastfh, &name,
	204	mntfh, &fattr);
	205	if (ret < 0) {
	206	dprintk("nfs4_get_root: getroot error = %d\n", -ret);
	207	return ret;
	208	}
	209
	210	if (fattr.type != NFDIR) {
	211	printk(KERN_ERR "nfs4_get_root:"
	212	" lookupfh encountered non-directory\n");
	213	return -ENOTDIR;
	214	}
	215
faebf4e2	216	/* FIXME: Referrals are quite valid here too */
54ceac45 DH	217	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
	218	printk(KERN_ERR "nfs4_get_root:"
	219	" lookupfh obtained referral\n");
	220	return -EREMOTE;
	221	}
	222
	223	goto next_component;
	224
	225	path_walk_complete:
	226	memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
	227	dprintk("<-- nfs4_path_walk() = 0\n");
	228	return 0;
	229	}
	230
	231	/*
	232	* get an NFS4 root dentry from the root filehandle
	233	*/
	234	struct dentry nfs4_get_root(struct super_block sb, struct nfs_fh *mntfh)
	235	{
	236	struct nfs_server *server = NFS_SB(sb);
	237	struct nfs_fattr fattr;
	238	struct dentry *mntroot;
	239	struct inode *inode;
	240	int error;
	241
	242	dprintk("--> nfs4_get_root()\n");
	243
	244	/* create a dummy root dentry with dummy inode for this superblock */
	245	if (!sb->s_root) {
	246	struct nfs_fh dummyfh;
	247	struct dentry *root;
	248	struct inode *iroot;
	249
	250	memset(&dummyfh, 0, sizeof(dummyfh));
	251	memset(&fattr, 0, sizeof(fattr));
	252	nfs_fattr_init(&fattr);
	253	fattr.valid = NFS_ATTR_FATTR;
	254	fattr.type = NFDIR;
	255	fattr.mode = S_IFDIR \| S_IRUSR \| S_IWUSR;
	256	fattr.nlink = 2;
	257
	258	iroot = nfs_fhget(sb, &dummyfh, &fattr);
	259	if (IS_ERR(iroot))
	260	return ERR_PTR(PTR_ERR(iroot));
	261
	262	root = d_alloc_root(iroot);
	263	if (!root) {
	264	iput(iroot);
	265	return ERR_PTR(-ENOMEM);
	266	}
	267
	268	sb->s_root = root;
	269	}
	270
	271	/* get the info about the server and filesystem */
	272	error = nfs4_server_capabilities(server, mntfh);
	273	if (error < 0) {
	274	dprintk("nfs_get_root: getcaps error = %d\n",
	275	-error);
	276	return ERR_PTR(error);
	277	}
	278
	279	/* get the actual root for this mount */
	280	error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
281	if (error < 0) {
282	dprintk("nfs_get_root: getattr error = %d\n", -error);
283	return ERR_PTR(error);
284	}
285
286	inode = nfs_fhget(sb, mntfh, &fattr);
287	if (IS_ERR(inode)) {
288	dprintk("nfs_get_root: get root inode failed\n");
289	return ERR_PTR(PTR_ERR(inode));
290	}
291
292	/* root dentries normally start off anonymous and get spliced in later
293	* if the dentry tree reaches them; however if the dentry already
294	* exists, we'll pick it up at this point and use it as the root
295	*/
296	mntroot = d_alloc_anon(inode);
297	if (!mntroot) {
298	iput(inode);
299	dprintk("nfs_get_root: get root dentry failed\n");
300	return ERR_PTR(-ENOMEM);
301	}
302
738a3519 DH	303	security_d_instantiate(mntroot, inode);
738a3519 DH	304
54ceac45 DH	305	if (!mntroot->d_op)
	306	mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
	307
	308	dprintk("<-- nfs4_get_root()\n");
	309	return mntroot;
	310	}
	311
	312	#endif /* CONFIG_NFS_V4 */