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
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>
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>
33#include <linux/security.h>
34
35#include <asm/system.h>
36#include <asm/uaccess.h>
37
38#include "nfs4_fs.h"
39#include "delegation.h"
40#include "internal.h"
41
42#define NFSDBG_FACILITY		NFSDBG_CLIENT
43
44/*
45 * Set the superblock root dentry.
46 * Note that this function frees the inode in case of error.
47 */
48static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *inode)
49{
50	/* The mntroot acts as the dummy root dentry for this superblock */
51	if (sb->s_root == NULL) {
52		sb->s_root = d_alloc_root(inode);
53		if (sb->s_root == NULL) {
54			iput(inode);
55			return -ENOMEM;
56		}
57		/* Circumvent igrab(): we know the inode is not being freed */
58		atomic_inc(&inode->i_count);
59		/*
60		 * Ensure that this dentry is invisible to d_find_alias().
61		 * Otherwise, it may be spliced into the tree by
62		 * d_materialise_unique if a parent directory from the same
63		 * filesystem gets mounted at a later time.
64		 * This again causes shrink_dcache_for_umount_subtree() to
65		 * Oops, since the test for IS_ROOT() will fail.
66		 */
67		spin_lock(&dcache_lock);
68		list_del_init(&sb->s_root->d_alias);
69		spin_unlock(&dcache_lock);
70	}
71	return 0;
72}
73
74/*
75 * get an NFS2/NFS3 root dentry from the root filehandle
76 */
77struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh)
78{
79	struct nfs_server *server = NFS_SB(sb);
80	struct nfs_fsinfo fsinfo;
81	struct dentry *ret;
82	struct inode *inode;
83	int error;
84
85	/* get the actual root for this mount */
86	fsinfo.fattr = nfs_alloc_fattr();
87	if (fsinfo.fattr == NULL)
88		return ERR_PTR(-ENOMEM);
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		ret = ERR_PTR(error);
94		goto out;
95	}
96
97	inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
98	if (IS_ERR(inode)) {
99		dprintk("nfs_get_root: get root inode failed\n");
100		ret = ERR_CAST(inode);
101		goto out;
102	}
103
104	error = nfs_superblock_set_dummy_root(sb, inode);
105	if (error != 0) {
106		ret = ERR_PTR(error);
107		goto out;
108	}
109
110	/* root dentries normally start off anonymous and get spliced in later
111	 * if the dentry tree reaches them; however if the dentry already
112	 * exists, we'll pick it up at this point and use it as the root
113	 */
114	ret = d_obtain_alias(inode);
115	if (IS_ERR(ret)) {
116		dprintk("nfs_get_root: get root dentry failed\n");
117		goto out;
118	}
119
120	security_d_instantiate(ret, inode);
121
122	if (ret->d_op == NULL)
123		ret->d_op = server->nfs_client->rpc_ops->dentry_ops;
124out:
125	nfs_free_fattr(fsinfo.fattr);
126	return ret;
127}
128
129#ifdef CONFIG_NFS_V4
130
131int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh)
132{
133	struct nfs_fsinfo fsinfo;
134	int ret = -ENOMEM;
135
136	dprintk("--> nfs4_get_rootfh()\n");
137
138	fsinfo.fattr = nfs_alloc_fattr();
139	if (fsinfo.fattr == NULL)
140		goto out;
141
142	/* Start by getting the root filehandle from the server */
143	ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
144	if (ret < 0) {
145		dprintk("nfs4_get_rootfh: getroot error = %d\n", -ret);
146		goto out;
147	}
148
149	if (!(fsinfo.fattr->valid & NFS_ATTR_FATTR_TYPE)
150			|| !S_ISDIR(fsinfo.fattr->mode)) {
151		printk(KERN_ERR "nfs4_get_rootfh:"
152		       " getroot encountered non-directory\n");
153		ret = -ENOTDIR;
154		goto out;
155	}
156
157	if (fsinfo.fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
158		printk(KERN_ERR "nfs4_get_rootfh:"
159		       " getroot obtained referral\n");
160		ret = -EREMOTE;
161		goto out;
162	}
163
164	memcpy(&server->fsid, &fsinfo.fattr->fsid, sizeof(server->fsid));
165out:
166	nfs_free_fattr(fsinfo.fattr);
167	dprintk("<-- nfs4_get_rootfh() = %d\n", ret);
168	return ret;
169}
170
171/*
172 * get an NFS4 root dentry from the root filehandle
173 */
174struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh)
175{
176	struct nfs_server *server = NFS_SB(sb);
177	struct nfs_fattr *fattr = NULL;
178	struct dentry *ret;
179	struct inode *inode;
180	int error;
181
182	dprintk("--> nfs4_get_root()\n");
183
184	/* get the info about the server and filesystem */
185	error = nfs4_server_capabilities(server, mntfh);
186	if (error < 0) {
187		dprintk("nfs_get_root: getcaps error = %d\n",
188			-error);
189		return ERR_PTR(error);
190	}
191
192	fattr = nfs_alloc_fattr();
193	if (fattr == NULL)
194		return ERR_PTR(-ENOMEM);;
195
196	/* get the actual root for this mount */
197	error = server->nfs_client->rpc_ops->getattr(server, mntfh, fattr);
198	if (error < 0) {
199		dprintk("nfs_get_root: getattr error = %d\n", -error);
200		ret = ERR_PTR(error);
201		goto out;
202	}
203
204	inode = nfs_fhget(sb, mntfh, fattr);
205	if (IS_ERR(inode)) {
206		dprintk("nfs_get_root: get root inode failed\n");
207		ret = ERR_CAST(inode);
208		goto out;
209	}
210
211	error = nfs_superblock_set_dummy_root(sb, inode);
212	if (error != 0) {
213		ret = ERR_PTR(error);
214		goto out;
215	}
216
217	/* root dentries normally start off anonymous and get spliced in later
218	 * if the dentry tree reaches them; however if the dentry already
219	 * exists, we'll pick it up at this point and use it as the root
220	 */
221	ret = d_obtain_alias(inode);
222	if (IS_ERR(ret)) {
223		dprintk("nfs_get_root: get root dentry failed\n");
224		goto out;
225	}
226
227	security_d_instantiate(ret, inode);
228
229	if (ret->d_op == NULL)
230		ret->d_op = server->nfs_client->rpc_ops->dentry_ops;
231
232out:
233	nfs_free_fattr(fattr);
234	dprintk("<-- nfs4_get_root()\n");
235	return ret;
236}
237
238#endif /* CONFIG_NFS_V4 */
239