NFSv4: Fix lock recovery when CREATE_SESSION/SETCLIENTID_CONFIRM fails
[linux-3.10.git] / fs / nfs / nfs4namespace.c
1 /*
2  * linux/fs/nfs/nfs4namespace.c
3  *
4  * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
5  * - Modified by David Howells <dhowells@redhat.com>
6  *
7  * NFSv4 namespace
8  */
9
10 #include <linux/dcache.h>
11 #include <linux/mount.h>
12 #include <linux/namei.h>
13 #include <linux/nfs_fs.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/sunrpc/clnt.h>
17 #include <linux/sunrpc/addr.h>
18 #include <linux/vfs.h>
19 #include <linux/inet.h>
20 #include "internal.h"
21 #include "nfs4_fs.h"
22 #include "dns_resolve.h"
23
24 #define NFSDBG_FACILITY         NFSDBG_VFS
25
26 /*
27  * Convert the NFSv4 pathname components into a standard posix path.
28  *
29  * Note that the resulting string will be placed at the end of the buffer
30  */
31 static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
32                                          char *buffer, ssize_t buflen)
33 {
34         char *end = buffer + buflen;
35         int n;
36
37         *--end = '\0';
38         buflen--;
39
40         n = pathname->ncomponents;
41         while (--n >= 0) {
42                 const struct nfs4_string *component = &pathname->components[n];
43                 buflen -= component->len + 1;
44                 if (buflen < 0)
45                         goto Elong;
46                 end -= component->len;
47                 memcpy(end, component->data, component->len);
48                 *--end = '/';
49         }
50         return end;
51 Elong:
52         return ERR_PTR(-ENAMETOOLONG);
53 }
54
55 /*
56  * return the path component of "<server>:<path>"
57  *  nfspath - the "<server>:<path>" string
58  *  end - one past the last char that could contain "<server>:"
59  * returns NULL on failure
60  */
61 static char *nfs_path_component(const char *nfspath, const char *end)
62 {
63         char *p;
64
65         if (*nfspath == '[') {
66                 /* parse [] escaped IPv6 addrs */
67                 p = strchr(nfspath, ']');
68                 if (p != NULL && ++p < end && *p == ':')
69                         return p + 1;
70         } else {
71                 /* otherwise split on first colon */
72                 p = strchr(nfspath, ':');
73                 if (p != NULL && p < end)
74                         return p + 1;
75         }
76         return NULL;
77 }
78
79 /*
80  * Determine the mount path as a string
81  */
82 static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
83 {
84         char *limit;
85         char *path = nfs_path(&limit, dentry, buffer, buflen,
86                               NFS_PATH_CANONICAL);
87         if (!IS_ERR(path)) {
88                 char *path_component = nfs_path_component(path, limit);
89                 if (path_component)
90                         return path_component;
91         }
92         return path;
93 }
94
95 /*
96  * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
97  * believe to be the server path to this dentry
98  */
99 static int nfs4_validate_fspath(struct dentry *dentry,
100                                 const struct nfs4_fs_locations *locations,
101                                 char *page, char *page2)
102 {
103         const char *path, *fs_path;
104
105         path = nfs4_path(dentry, page, PAGE_SIZE);
106         if (IS_ERR(path))
107                 return PTR_ERR(path);
108
109         fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
110         if (IS_ERR(fs_path))
111                 return PTR_ERR(fs_path);
112
113         if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
114                 dprintk("%s: path %s does not begin with fsroot %s\n",
115                         __func__, path, fs_path);
116                 return -ENOENT;
117         }
118
119         return 0;
120 }
121
122 static size_t nfs_parse_server_name(char *string, size_t len,
123                 struct sockaddr *sa, size_t salen, struct nfs_server *server)
124 {
125         struct net *net = rpc_net_ns(server->client);
126         ssize_t ret;
127
128         ret = rpc_pton(net, string, len, sa, salen);
129         if (ret == 0) {
130                 ret = nfs_dns_resolve_name(net, string, len, sa, salen);
131                 if (ret < 0)
132                         ret = 0;
133         }
134         return ret;
135 }
136
137 /**
138  * nfs_find_best_sec - Find a security mechanism supported locally
139  * @flavors: List of security tuples returned by SECINFO procedure
140  *
141  * Return the pseudoflavor of the first security mechanism in
142  * "flavors" that is locally supported.  Return RPC_AUTH_UNIX if
143  * no matching flavor is found in the array.  The "flavors" array
144  * is searched in the order returned from the server, per RFC 3530
145  * recommendation.
146  */
147 rpc_authflavor_t nfs_find_best_sec(struct nfs4_secinfo_flavors *flavors)
148 {
149         rpc_authflavor_t pseudoflavor;
150         struct nfs4_secinfo4 *secinfo;
151         unsigned int i;
152
153         for (i = 0; i < flavors->num_flavors; i++) {
154                 secinfo = &flavors->flavors[i];
155
156                 switch (secinfo->flavor) {
157                 case RPC_AUTH_NULL:
158                 case RPC_AUTH_UNIX:
159                 case RPC_AUTH_GSS:
160                         pseudoflavor = rpcauth_get_pseudoflavor(secinfo->flavor,
161                                                         &secinfo->flavor_info);
162                         if (pseudoflavor != RPC_AUTH_MAXFLAVOR)
163                                 return pseudoflavor;
164                         break;
165                 }
166         }
167
168         return RPC_AUTH_UNIX;
169 }
170
171 static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name)
172 {
173         struct page *page;
174         struct nfs4_secinfo_flavors *flavors;
175         rpc_authflavor_t flavor;
176         int err;
177
178         page = alloc_page(GFP_KERNEL);
179         if (!page)
180                 return -ENOMEM;
181         flavors = page_address(page);
182
183         err = nfs4_proc_secinfo(inode, name, flavors);
184         if (err < 0) {
185                 flavor = err;
186                 goto out;
187         }
188
189         flavor = nfs_find_best_sec(flavors);
190
191 out:
192         put_page(page);
193         return flavor;
194 }
195
196 /*
197  * Please call rpc_shutdown_client() when you are done with this client.
198  */
199 struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode,
200                                         struct qstr *name)
201 {
202         rpc_authflavor_t flavor;
203
204         flavor = nfs4_negotiate_security(inode, name);
205         if ((int)flavor < 0)
206                 return ERR_PTR((int)flavor);
207
208         return rpc_clone_client_set_auth(clnt, flavor);
209 }
210
211 static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
212                                      char *page, char *page2,
213                                      const struct nfs4_fs_location *location)
214 {
215         const size_t addr_bufsize = sizeof(struct sockaddr_storage);
216         struct vfsmount *mnt = ERR_PTR(-ENOENT);
217         char *mnt_path;
218         unsigned int maxbuflen;
219         unsigned int s;
220
221         mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
222         if (IS_ERR(mnt_path))
223                 return ERR_CAST(mnt_path);
224         mountdata->mnt_path = mnt_path;
225         maxbuflen = mnt_path - 1 - page2;
226
227         mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
228         if (mountdata->addr == NULL)
229                 return ERR_PTR(-ENOMEM);
230
231         for (s = 0; s < location->nservers; s++) {
232                 const struct nfs4_string *buf = &location->servers[s];
233
234                 if (buf->len <= 0 || buf->len >= maxbuflen)
235                         continue;
236
237                 if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
238                         continue;
239
240                 mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
241                                 mountdata->addr, addr_bufsize,
242                                 NFS_SB(mountdata->sb));
243                 if (mountdata->addrlen == 0)
244                         continue;
245
246                 rpc_set_port(mountdata->addr, NFS_PORT);
247
248                 memcpy(page2, buf->data, buf->len);
249                 page2[buf->len] = '\0';
250                 mountdata->hostname = page2;
251
252                 snprintf(page, PAGE_SIZE, "%s:%s",
253                                 mountdata->hostname,
254                                 mountdata->mnt_path);
255
256                 mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
257                 if (!IS_ERR(mnt))
258                         break;
259         }
260         kfree(mountdata->addr);
261         return mnt;
262 }
263
264 /**
265  * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
266  * @dentry - parent directory
267  * @locations - array of NFSv4 server location information
268  *
269  */
270 static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
271                                             const struct nfs4_fs_locations *locations)
272 {
273         struct vfsmount *mnt = ERR_PTR(-ENOENT);
274         struct nfs_clone_mount mountdata = {
275                 .sb = dentry->d_sb,
276                 .dentry = dentry,
277                 .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
278         };
279         char *page = NULL, *page2 = NULL;
280         int loc, error;
281
282         if (locations == NULL || locations->nlocations <= 0)
283                 goto out;
284
285         dprintk("%s: referral at %s/%s\n", __func__,
286                 dentry->d_parent->d_name.name, dentry->d_name.name);
287
288         page = (char *) __get_free_page(GFP_USER);
289         if (!page)
290                 goto out;
291
292         page2 = (char *) __get_free_page(GFP_USER);
293         if (!page2)
294                 goto out;
295
296         /* Ensure fs path is a prefix of current dentry path */
297         error = nfs4_validate_fspath(dentry, locations, page, page2);
298         if (error < 0) {
299                 mnt = ERR_PTR(error);
300                 goto out;
301         }
302
303         for (loc = 0; loc < locations->nlocations; loc++) {
304                 const struct nfs4_fs_location *location = &locations->locations[loc];
305
306                 if (location == NULL || location->nservers <= 0 ||
307                     location->rootpath.ncomponents == 0)
308                         continue;
309
310                 mnt = try_location(&mountdata, page, page2, location);
311                 if (!IS_ERR(mnt))
312                         break;
313         }
314
315 out:
316         free_page((unsigned long) page);
317         free_page((unsigned long) page2);
318         dprintk("%s: done\n", __func__);
319         return mnt;
320 }
321
322 /*
323  * nfs_do_refmount - handle crossing a referral on server
324  * @dentry - dentry of referral
325  *
326  */
327 static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry)
328 {
329         struct vfsmount *mnt = ERR_PTR(-ENOMEM);
330         struct dentry *parent;
331         struct nfs4_fs_locations *fs_locations = NULL;
332         struct page *page;
333         int err;
334
335         /* BUG_ON(IS_ROOT(dentry)); */
336         dprintk("%s: enter\n", __func__);
337
338         page = alloc_page(GFP_KERNEL);
339         if (page == NULL)
340                 goto out;
341
342         fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
343         if (fs_locations == NULL)
344                 goto out_free;
345
346         /* Get locations */
347         mnt = ERR_PTR(-ENOENT);
348
349         parent = dget_parent(dentry);
350         dprintk("%s: getting locations for %s/%s\n",
351                 __func__, parent->d_name.name, dentry->d_name.name);
352
353         err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
354         dput(parent);
355         if (err != 0 ||
356             fs_locations->nlocations <= 0 ||
357             fs_locations->fs_path.ncomponents <= 0)
358                 goto out_free;
359
360         mnt = nfs_follow_referral(dentry, fs_locations);
361 out_free:
362         __free_page(page);
363         kfree(fs_locations);
364 out:
365         dprintk("%s: done\n", __func__);
366         return mnt;
367 }
368
369 struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
370                                struct nfs_fh *fh, struct nfs_fattr *fattr)
371 {
372         struct dentry *parent = dget_parent(dentry);
373         struct rpc_clnt *client;
374         struct vfsmount *mnt;
375
376         /* Look it up again to get its attributes and sec flavor */
377         client = nfs4_proc_lookup_mountpoint(parent->d_inode, &dentry->d_name, fh, fattr);
378         dput(parent);
379         if (IS_ERR(client))
380                 return ERR_CAST(client);
381
382         if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
383                 mnt = nfs_do_refmount(client, dentry);
384         else
385                 mnt = nfs_do_submount(dentry, fh, fattr, client->cl_auth->au_flavor);
386
387         rpc_shutdown_client(client);
388         return mnt;
389 }