xref: /openbmc/linux/fs/nfs/getroot.c (revision a17627ef) 
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/mnt_namespace.h>
34 #include <linux/security.h>
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
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 
110 	security_d_instantiate(mntroot, inode);
111 
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;
136 
137 	dprintk("--> nfs4_path_walk(,,%s)\n", path);
138 
139 	fsinfo.fattr = &fattr;
140 	nfs_fattr_init(&fattr);
141 
142 	/* Eat leading slashes */
143 	while (*path == '/')
144 		path++;
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 
159 	/* FIXME: It is quite valid for the server to return a referral here */
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 
178 eat_dot_dir:
179 	while (*path == '/')
180 		path++;
181 
182 	if (path[0] == '.' && (path[1] == '/' || !path[1])) {
183 		path += 2;
184 		goto eat_dot_dir;
185 	}
186 
187 	/* FIXME: Why shouldn't the user be able to use ".." in the path? */
188 	if (path[0] == '.' && path[1] == '.' && (path[2] == '/' || !path[2])
189 	    ) {
190 		printk(KERN_ERR "nfs4_get_root:"
191 		       " Mount path contains reference to \"..\"\n");
192 		return -EINVAL;
193 	}
194 
195 	/* lookup the next FH in the sequence */
196 	memcpy(&lastfh, mntfh, sizeof(lastfh));
197 
198 	dprintk("LookupFH: %*.*s [%s]\n", name.len, name.len, name.name, path);
199 
200 	ret = server->nfs_client->rpc_ops->lookupfh(server, &lastfh, &name,
201 						    mntfh, &fattr);
202 	if (ret < 0) {
203 		dprintk("nfs4_get_root: getroot error = %d\n", -ret);
204 		return ret;
205 	}
206 
207 	if (fattr.type != NFDIR) {
208 		printk(KERN_ERR "nfs4_get_root:"
209 		       " lookupfh encountered non-directory\n");
210 		return -ENOTDIR;
211 	}
212 
213 	/* FIXME: Referrals are quite valid here too */
214 	if (fattr.valid & NFS_ATTR_FATTR_V4_REFERRAL) {
215 		printk(KERN_ERR "nfs4_get_root:"
216 		       " lookupfh obtained referral\n");
217 		return -EREMOTE;
218 	}
219 
220 	goto next_component;
221 
222 path_walk_complete:
223 	memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
224 	dprintk("<-- nfs4_path_walk() = 0\n");
225 	return 0;
226 }
227 
228 /*
229  * get an NFS4 root dentry from the root filehandle
230  */
231 struct dentry *nfs4_get_root(struct super_block *sb, struct nfs_fh *mntfh)
232 {
233 	struct nfs_server *server = NFS_SB(sb);
234 	struct nfs_fattr fattr;
235 	struct dentry *mntroot;
236 	struct inode *inode;
237 	int error;
238 
239 	dprintk("--> nfs4_get_root()\n");
240 
241 	/* create a dummy root dentry with dummy inode for this superblock */
242 	if (!sb->s_root) {
243 		struct nfs_fh dummyfh;
244 		struct dentry *root;
245 		struct inode *iroot;
246 
247 		memset(&dummyfh, 0, sizeof(dummyfh));
248 		memset(&fattr, 0, sizeof(fattr));
249 		nfs_fattr_init(&fattr);
250 		fattr.valid = NFS_ATTR_FATTR;
251 		fattr.type = NFDIR;
252 		fattr.mode = S_IFDIR | S_IRUSR | S_IWUSR;
253 		fattr.nlink = 2;
254 
255 		iroot = nfs_fhget(sb, &dummyfh, &fattr);
256 		if (IS_ERR(iroot))
257 			return ERR_PTR(PTR_ERR(iroot));
258 
259 		root = d_alloc_root(iroot);
260 		if (!root) {
261 			iput(iroot);
262 			return ERR_PTR(-ENOMEM);
263 		}
264 
265 		sb->s_root = root;
266 	}
267 
268 	/* get the info about the server and filesystem */
269 	error = nfs4_server_capabilities(server, mntfh);
270 	if (error < 0) {
271 		dprintk("nfs_get_root: getcaps error = %d\n",
272 			-error);
273 		return ERR_PTR(error);
274 	}
275 
276 	/* get the actual root for this mount */
277 	error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
278 	if (error < 0) {
279 		dprintk("nfs_get_root: getattr error = %d\n", -error);
280 		return ERR_PTR(error);
281 	}
282 
283 	inode = nfs_fhget(sb, mntfh, &fattr);
284 	if (IS_ERR(inode)) {
285 		dprintk("nfs_get_root: get root inode failed\n");
286 		return ERR_PTR(PTR_ERR(inode));
287 	}
288 
289 	/* root dentries normally start off anonymous and get spliced in later
290 	 * if the dentry tree reaches them; however if the dentry already
291 	 * exists, we'll pick it up at this point and use it as the root
292 	 */
293 	mntroot = d_alloc_anon(inode);
294 	if (!mntroot) {
295 		iput(inode);
296 		dprintk("nfs_get_root: get root dentry failed\n");
297 		return ERR_PTR(-ENOMEM);
298 	}
299 
300 	security_d_instantiate(mntroot, inode);
301 
302 	if (!mntroot->d_op)
303 		mntroot->d_op = server->nfs_client->rpc_ops->dentry_ops;
304 
305 	dprintk("<-- nfs4_get_root()\n");
306 	return mntroot;
307 }
308 
309 #endif /* CONFIG_NFS_V4 */
310