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