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  */
nfs_superblock_set_dummy_root(struct super_block * sb,struct inode * inode)48 static 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 		ihold(inode);
58 		/*
59 		 * Ensure that this dentry is invisible to d_find_alias().
60 		 * Otherwise, it may be spliced into the tree by
61 		 * d_materialise_unique if a parent directory from the same
62 		 * filesystem gets mounted at a later time.
63 		 * This again causes shrink_dcache_for_umount_subtree() to
64 		 * Oops, since the test for IS_ROOT() will fail.
65 		 */
66 		spin_lock(&sb->s_root->d_inode->i_lock);
67 		spin_lock(&sb->s_root->d_lock);
68 		list_del_init(&sb->s_root->d_alias);
69 		spin_unlock(&sb->s_root->d_lock);
70 		spin_unlock(&sb->s_root->d_inode->i_lock);
71 	}
72 	return 0;
73 }
74 
75 /*
76  * get an NFS2/NFS3 root dentry from the root filehandle
77  */
nfs_get_root(struct super_block * sb,struct nfs_fh * mntfh,const char * devname)78 struct dentry *nfs_get_root(struct super_block *sb, struct nfs_fh *mntfh,
79 			    const char *devname)
80 {
81 	struct nfs_server *server = NFS_SB(sb);
82 	struct nfs_fsinfo fsinfo;
83 	struct dentry *ret;
84 	struct inode *inode;
85 	void *name = kstrdup(devname, GFP_KERNEL);
86 	int error;
87 
88 	if (!name)
89 		return ERR_PTR(-ENOMEM);
90 
91 	/* get the actual root for this mount */
92 	fsinfo.fattr = nfs_alloc_fattr();
93 	if (fsinfo.fattr == NULL) {
94 		kfree(name);
95 		return ERR_PTR(-ENOMEM);
96 	}
97 
98 	error = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
99 	if (error < 0) {
100 		dprintk("nfs_get_root: getattr error = %d\n", -error);
101 		ret = ERR_PTR(error);
102 		goto out;
103 	}
104 
105 	inode = nfs_fhget(sb, mntfh, fsinfo.fattr);
106 	if (IS_ERR(inode)) {
107 		dprintk("nfs_get_root: get root inode failed\n");
108 		ret = ERR_CAST(inode);
109 		goto out;
110 	}
111 
112 	error = nfs_superblock_set_dummy_root(sb, inode);
113 	if (error != 0) {
114 		ret = ERR_PTR(error);
115 		goto out;
116 	}
117 
118 	/* root dentries normally start off anonymous and get spliced in later
119 	 * if the dentry tree reaches them; however if the dentry already
120 	 * exists, we'll pick it up at this point and use it as the root
121 	 */
122 	ret = d_obtain_alias(inode);
123 	if (IS_ERR(ret)) {
124 		dprintk("nfs_get_root: get root dentry failed\n");
125 		goto out;
126 	}
127 
128 	security_d_instantiate(ret, inode);
129 	spin_lock(&ret->d_lock);
130 	if (IS_ROOT(ret) && !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
131 		ret->d_fsdata = name;
132 		name = NULL;
133 	}
134 	spin_unlock(&ret->d_lock);
135 out:
136 	if (name)
137 		kfree(name);
138 	nfs_free_fattr(fsinfo.fattr);
139 	return ret;
140 }
141 
142 #ifdef CONFIG_NFS_V4
143 
nfs4_get_rootfh(struct nfs_server * server,struct nfs_fh * mntfh)144 int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh)
145 {
146 	struct nfs_fsinfo fsinfo;
147 	int ret = -ENOMEM;
148 
149 	dprintk("--> nfs4_get_rootfh()\n");
150 
151 	fsinfo.fattr = nfs_alloc_fattr();
152 	if (fsinfo.fattr == NULL)
153 		goto out;
154 
155 	/* Start by getting the root filehandle from the server */
156 	ret = server->nfs_client->rpc_ops->getroot(server, mntfh, &fsinfo);
157 	if (ret < 0) {
158 		dprintk("nfs4_get_rootfh: getroot error = %d\n", -ret);
159 		goto out;
160 	}
161 
162 	if (!(fsinfo.fattr->valid & NFS_ATTR_FATTR_TYPE)
163 			|| !S_ISDIR(fsinfo.fattr->mode)) {
164 		printk(KERN_ERR "nfs4_get_rootfh:"
165 		       " getroot encountered non-directory\n");
166 		ret = -ENOTDIR;
167 		goto out;
168 	}
169 
170 	if (fsinfo.fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
171 		printk(KERN_ERR "nfs4_get_rootfh:"
172 		       " getroot obtained referral\n");
173 		ret = -EREMOTE;
174 		goto out;
175 	}
176 
177 	memcpy(&server->fsid, &fsinfo.fattr->fsid, sizeof(server->fsid));
178 out:
179 	nfs_free_fattr(fsinfo.fattr);
180 	dprintk("<-- nfs4_get_rootfh() = %d\n", ret);
181 	return ret;
182 }
183 
184 /*
185  * get an NFS4 root dentry from the root filehandle
186  */
nfs4_get_root(struct super_block * sb,struct nfs_fh * mntfh,const char * devname)187 struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh,
188 			     const char *devname)
189 {
190 	struct nfs_server *server = NFS_SB(sb);
191 	struct nfs_fattr *fattr = NULL;
192 	struct dentry *ret;
193 	struct inode *inode;
194 	void *name = kstrdup(devname, GFP_KERNEL);
195 	int error;
196 
197 	dprintk("--> nfs4_get_root()\n");
198 
199 	if (!name)
200 		return ERR_PTR(-ENOMEM);
201 
202 	/* get the info about the server and filesystem */
203 	error = nfs4_server_capabilities(server, mntfh);
204 	if (error < 0) {
205 		dprintk("nfs_get_root: getcaps error = %d\n",
206 			-error);
207 		kfree(name);
208 		return ERR_PTR(error);
209 	}
210 
211 	fattr = nfs_alloc_fattr();
212 	if (fattr == NULL) {
213 		kfree(name);
214 		return ERR_PTR(-ENOMEM);
215 	}
216 
217 	/* get the actual root for this mount */
218 	error = server->nfs_client->rpc_ops->getattr(server, mntfh, fattr);
219 	if (error < 0) {
220 		dprintk("nfs_get_root: getattr error = %d\n", -error);
221 		ret = ERR_PTR(error);
222 		goto out;
223 	}
224 
225 	if (fattr->valid & NFS_ATTR_FATTR_FSID &&
226 	    !nfs_fsid_equal(&server->fsid, &fattr->fsid))
227 		memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
228 
229 	inode = nfs_fhget(sb, mntfh, fattr);
230 	if (IS_ERR(inode)) {
231 		dprintk("nfs_get_root: get root inode failed\n");
232 		ret = ERR_CAST(inode);
233 		goto out;
234 	}
235 
236 	error = nfs_superblock_set_dummy_root(sb, inode);
237 	if (error != 0) {
238 		ret = ERR_PTR(error);
239 		goto out;
240 	}
241 
242 	/* root dentries normally start off anonymous and get spliced in later
243 	 * if the dentry tree reaches them; however if the dentry already
244 	 * exists, we'll pick it up at this point and use it as the root
245 	 */
246 	ret = d_obtain_alias(inode);
247 	if (IS_ERR(ret)) {
248 		dprintk("nfs_get_root: get root dentry failed\n");
249 		goto out;
250 	}
251 
252 	security_d_instantiate(ret, inode);
253 	spin_lock(&ret->d_lock);
254 	if (IS_ROOT(ret) && !(ret->d_flags & DCACHE_NFSFS_RENAMED)) {
255 		ret->d_fsdata = name;
256 		name = NULL;
257 	}
258 	spin_unlock(&ret->d_lock);
259 out:
260 	if (name)
261 		kfree(name);
262 	nfs_free_fattr(fattr);
263 	dprintk("<-- nfs4_get_root()\n");
264 	return ret;
265 }
266 
267 #endif /* CONFIG_NFS_V4 */
268