Branch data Line data Source code
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/nfs_mount.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/string.h>
17 : : #include <linux/sunrpc/clnt.h>
18 : : #include <linux/sunrpc/addr.h>
19 : : #include <linux/vfs.h>
20 : : #include <linux/inet.h>
21 : : #include "internal.h"
22 : : #include "nfs4_fs.h"
23 : : #include "dns_resolve.h"
24 : :
25 : : #define NFSDBG_FACILITY NFSDBG_VFS
26 : :
27 : : /*
28 : : * Convert the NFSv4 pathname components into a standard posix path.
29 : : *
30 : : * Note that the resulting string will be placed at the end of the buffer
31 : : */
32 : : static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
33 : : char *buffer, ssize_t buflen)
34 : : {
35 : : char *end = buffer + buflen;
36 : : int n;
37 : :
38 : 0 : *--end = '\0';
39 : : buflen--;
40 : :
41 : 0 : n = pathname->ncomponents;
42 [ # # ][ # # ]: 0 : while (--n >= 0) {
43 : 0 : const struct nfs4_string *component = &pathname->components[n];
44 : 0 : buflen -= component->len + 1;
45 [ # # ][ # # ]: 0 : if (buflen < 0)
46 : : goto Elong;
47 : 0 : end -= component->len;
48 : 0 : memcpy(end, component->data, component->len);
49 : 0 : *--end = '/';
50 : : }
51 : : return end;
52 : : Elong:
53 : : return ERR_PTR(-ENAMETOOLONG);
54 : : }
55 : :
56 : : /*
57 : : * return the path component of "<server>:<path>"
58 : : * nfspath - the "<server>:<path>" string
59 : : * end - one past the last char that could contain "<server>:"
60 : : * returns NULL on failure
61 : : */
62 : 0 : static char *nfs_path_component(const char *nfspath, const char *end)
63 : : {
64 : : char *p;
65 : :
66 [ # # ]: 0 : if (*nfspath == '[') {
67 : : /* parse [] escaped IPv6 addrs */
68 : 0 : p = strchr(nfspath, ']');
69 [ # # ][ # # ]: 0 : if (p != NULL && ++p < end && *p == ':')
[ # # ]
70 : 0 : return p + 1;
71 : : } else {
72 : : /* otherwise split on first colon */
73 : 0 : p = strchr(nfspath, ':');
74 [ # # ]: 0 : if (p != NULL && p < end)
75 : 0 : return p + 1;
76 : : }
77 : : return NULL;
78 : : }
79 : :
80 : : /*
81 : : * Determine the mount path as a string
82 : : */
83 : 0 : static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
84 : : {
85 : : char *limit;
86 : 0 : char *path = nfs_path(&limit, dentry, buffer, buflen,
87 : : NFS_PATH_CANONICAL);
88 [ # # ]: 0 : if (!IS_ERR(path)) {
89 : 0 : char *path_component = nfs_path_component(path, limit);
90 [ # # ]: 0 : if (path_component)
91 : : return path_component;
92 : : }
93 : 0 : return path;
94 : : }
95 : :
96 : : /*
97 : : * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
98 : : * believe to be the server path to this dentry
99 : : */
100 : 0 : static int nfs4_validate_fspath(struct dentry *dentry,
101 : : const struct nfs4_fs_locations *locations,
102 : : char *page, char *page2)
103 : : {
104 : : const char *path, *fs_path;
105 : :
106 : 0 : path = nfs4_path(dentry, page, PAGE_SIZE);
107 [ # # ]: 0 : if (IS_ERR(path))
108 : 0 : return PTR_ERR(path);
109 : :
110 : : fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
111 [ # # ]: 0 : if (IS_ERR(fs_path))
112 : 0 : return PTR_ERR(fs_path);
113 : :
114 [ # # ]: 0 : if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
115 : : dprintk("%s: path %s does not begin with fsroot %s\n",
116 : : __func__, path, fs_path);
117 : : return -ENOENT;
118 : : }
119 : :
120 : 0 : return 0;
121 : : }
122 : :
123 : 0 : static size_t nfs_parse_server_name(char *string, size_t len,
124 : : struct sockaddr *sa, size_t salen, struct net *net)
125 : : {
126 : : ssize_t ret;
127 : :
128 : 0 : ret = rpc_pton(net, string, len, sa, salen);
129 [ # # ]: 0 : if (ret == 0) {
130 : 0 : ret = nfs_dns_resolve_name(net, string, len, sa, salen);
131 [ # # ]: 0 : if (ret < 0)
132 : : ret = 0;
133 : : }
134 : 0 : return ret;
135 : : }
136 : :
137 : : /**
138 : : * nfs_find_best_sec - Find a security mechanism supported locally
139 : : * @server: NFS server struct
140 : : * @flavors: List of security tuples returned by SECINFO procedure
141 : : *
142 : : * Return the pseudoflavor of the first security mechanism in
143 : : * "flavors" that is locally supported. Return RPC_AUTH_UNIX if
144 : : * no matching flavor is found in the array. The "flavors" array
145 : : * is searched in the order returned from the server, per RFC 3530
146 : : * recommendation.
147 : : */
148 : 0 : static rpc_authflavor_t nfs_find_best_sec(struct nfs_server *server,
149 : : struct nfs4_secinfo_flavors *flavors)
150 : : {
151 : : rpc_authflavor_t pseudoflavor;
152 : : struct nfs4_secinfo4 *secinfo;
153 : : unsigned int i;
154 : :
155 [ # # ]: 0 : for (i = 0; i < flavors->num_flavors; i++) {
156 : 0 : secinfo = &flavors->flavors[i];
157 : :
158 [ # # ][ # # ]: 0 : switch (secinfo->flavor) {
159 : : case RPC_AUTH_NULL:
160 : : case RPC_AUTH_UNIX:
161 : : case RPC_AUTH_GSS:
162 : 0 : pseudoflavor = rpcauth_get_pseudoflavor(secinfo->flavor,
163 : : &secinfo->flavor_info);
164 : : /* make sure pseudoflavor matches sec= mount opt */
165 [ # # # # ]: 0 : if (pseudoflavor != RPC_AUTH_MAXFLAVOR &&
166 : 0 : nfs_auth_info_match(&server->auth_info,
167 : : pseudoflavor))
168 : : return pseudoflavor;
169 : : break;
170 : : }
171 : : }
172 : :
173 : : /* if there were any sec= options then nothing matched */
174 [ # # ]: 0 : if (server->auth_info.flavor_len > 0)
175 : : return -EPERM;
176 : :
177 : 0 : return RPC_AUTH_UNIX;
178 : : }
179 : :
180 : 0 : static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name)
181 : : {
182 : : struct page *page;
183 : : struct nfs4_secinfo_flavors *flavors;
184 : : rpc_authflavor_t flavor;
185 : : int err;
186 : :
187 : : page = alloc_page(GFP_KERNEL);
188 [ # # ]: 0 : if (!page)
189 : : return -ENOMEM;
190 : 0 : flavors = page_address(page);
191 : :
192 : 0 : err = nfs4_proc_secinfo(inode, name, flavors);
193 [ # # ]: 0 : if (err < 0) {
194 : 0 : flavor = err;
195 : 0 : goto out;
196 : : }
197 : :
198 : 0 : flavor = nfs_find_best_sec(NFS_SERVER(inode), flavors);
199 : :
200 : : out:
201 : 0 : put_page(page);
202 : 0 : return flavor;
203 : : }
204 : :
205 : : /*
206 : : * Please call rpc_shutdown_client() when you are done with this client.
207 : : */
208 : 0 : struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode,
209 : : struct qstr *name)
210 : : {
211 : : rpc_authflavor_t flavor;
212 : :
213 : 0 : flavor = nfs4_negotiate_security(inode, name);
214 [ # # ]: 0 : if ((int)flavor < 0)
215 : 0 : return ERR_PTR((int)flavor);
216 : :
217 : 0 : return rpc_clone_client_set_auth(clnt, flavor);
218 : : }
219 : :
220 : 0 : static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
221 : : char *page, char *page2,
222 : : const struct nfs4_fs_location *location)
223 : : {
224 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
225 : 0 : struct net *net = rpc_net_ns(NFS_SB(mountdata->sb)->client);
226 : : struct vfsmount *mnt = ERR_PTR(-ENOENT);
227 : : char *mnt_path;
228 : : unsigned int maxbuflen;
229 : : unsigned int s;
230 : :
231 : : mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
232 [ # # ]: 0 : if (IS_ERR(mnt_path))
233 : : return ERR_CAST(mnt_path);
234 : 0 : mountdata->mnt_path = mnt_path;
235 : 0 : maxbuflen = mnt_path - 1 - page2;
236 : :
237 : 0 : mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
238 [ # # ]: 0 : if (mountdata->addr == NULL)
239 : : return ERR_PTR(-ENOMEM);
240 : :
241 [ # # ]: 0 : for (s = 0; s < location->nservers; s++) {
242 : 0 : const struct nfs4_string *buf = &location->servers[s];
243 : :
244 [ # # ][ # # ]: 0 : if (buf->len <= 0 || buf->len >= maxbuflen)
245 : 0 : continue;
246 : :
247 [ # # ]: 0 : if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
248 : 0 : continue;
249 : :
250 : 0 : mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
251 : : mountdata->addr, addr_bufsize, net);
252 [ # # ]: 0 : if (mountdata->addrlen == 0)
253 : 0 : continue;
254 : :
255 : 0 : rpc_set_port(mountdata->addr, NFS_PORT);
256 : :
257 : 0 : memcpy(page2, buf->data, buf->len);
258 : 0 : page2[buf->len] = '\0';
259 : 0 : mountdata->hostname = page2;
260 : :
261 : 0 : snprintf(page, PAGE_SIZE, "%s:%s",
262 : : mountdata->hostname,
263 : : mountdata->mnt_path);
264 : :
265 : 0 : mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
266 [ # # ]: 0 : if (!IS_ERR(mnt))
267 : : break;
268 : : }
269 : 0 : kfree(mountdata->addr);
270 : 0 : return mnt;
271 : : }
272 : :
273 : : /**
274 : : * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
275 : : * @dentry - parent directory
276 : : * @locations - array of NFSv4 server location information
277 : : *
278 : : */
279 : 0 : static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
280 : : const struct nfs4_fs_locations *locations)
281 : : {
282 : : struct vfsmount *mnt = ERR_PTR(-ENOENT);
283 : 0 : struct nfs_clone_mount mountdata = {
284 : 0 : .sb = dentry->d_sb,
285 : : .dentry = dentry,
286 : 0 : .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
287 : : };
288 : : char *page = NULL, *page2 = NULL;
289 : : int loc, error;
290 : :
291 [ # # ][ # # ]: 0 : if (locations == NULL || locations->nlocations <= 0)
292 : : goto out;
293 : :
294 : : dprintk("%s: referral at %pd2\n", __func__, dentry);
295 : :
296 : 0 : page = (char *) __get_free_page(GFP_USER);
297 [ # # ]: 0 : if (!page)
298 : : goto out;
299 : :
300 : 0 : page2 = (char *) __get_free_page(GFP_USER);
301 [ # # ]: 0 : if (!page2)
302 : : goto out;
303 : :
304 : : /* Ensure fs path is a prefix of current dentry path */
305 : 0 : error = nfs4_validate_fspath(dentry, locations, page, page2);
306 [ # # ]: 0 : if (error < 0) {
307 : : mnt = ERR_PTR(error);
308 : 0 : goto out;
309 : : }
310 : :
311 [ # # ]: 0 : for (loc = 0; loc < locations->nlocations; loc++) {
312 : 0 : const struct nfs4_fs_location *location = &locations->locations[loc];
313 : :
314 [ # # ][ # # ]: 0 : if (location == NULL || location->nservers <= 0 ||
[ # # ]
315 : 0 : location->rootpath.ncomponents == 0)
316 : 0 : continue;
317 : :
318 : 0 : mnt = try_location(&mountdata, page, page2, location);
319 [ # # ]: 0 : if (!IS_ERR(mnt))
320 : : break;
321 : : }
322 : :
323 : : out:
324 : 0 : free_page((unsigned long) page);
325 : 0 : free_page((unsigned long) page2);
326 : : dprintk("%s: done\n", __func__);
327 : 0 : return mnt;
328 : : }
329 : :
330 : : /*
331 : : * nfs_do_refmount - handle crossing a referral on server
332 : : * @dentry - dentry of referral
333 : : *
334 : : */
335 : 0 : static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry)
336 : : {
337 : : struct vfsmount *mnt = ERR_PTR(-ENOMEM);
338 : : struct dentry *parent;
339 : : struct nfs4_fs_locations *fs_locations = NULL;
340 : : struct page *page;
341 : : int err;
342 : :
343 : : /* BUG_ON(IS_ROOT(dentry)); */
344 : : dprintk("%s: enter\n", __func__);
345 : :
346 : : page = alloc_page(GFP_KERNEL);
347 [ # # ]: 0 : if (page == NULL)
348 : : goto out;
349 : :
350 : : fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
351 [ # # ]: 0 : if (fs_locations == NULL)
352 : : goto out_free;
353 : :
354 : : /* Get locations */
355 : : mnt = ERR_PTR(-ENOENT);
356 : :
357 : 0 : parent = dget_parent(dentry);
358 : : dprintk("%s: getting locations for %pd2\n",
359 : : __func__, dentry);
360 : :
361 : 0 : err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
362 : 0 : dput(parent);
363 [ # # ][ # # ]: 0 : if (err != 0 ||
364 [ # # ]: 0 : fs_locations->nlocations <= 0 ||
365 : 0 : fs_locations->fs_path.ncomponents <= 0)
366 : : goto out_free;
367 : :
368 : 0 : mnt = nfs_follow_referral(dentry, fs_locations);
369 : : out_free:
370 : 0 : __free_page(page);
371 : 0 : kfree(fs_locations);
372 : : out:
373 : : dprintk("%s: done\n", __func__);
374 : 0 : return mnt;
375 : : }
376 : :
377 : 0 : struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
378 : : struct nfs_fh *fh, struct nfs_fattr *fattr)
379 : : {
380 : 0 : rpc_authflavor_t flavor = server->client->cl_auth->au_flavor;
381 : 0 : struct dentry *parent = dget_parent(dentry);
382 : 0 : struct inode *dir = parent->d_inode;
383 : 0 : struct qstr *name = &dentry->d_name;
384 : : struct rpc_clnt *client;
385 : : struct vfsmount *mnt;
386 : :
387 : : /* Look it up again to get its attributes and sec flavor */
388 : 0 : client = nfs4_proc_lookup_mountpoint(dir, name, fh, fattr);
389 : 0 : dput(parent);
390 [ # # ]: 0 : if (IS_ERR(client))
391 : : return ERR_CAST(client);
392 : :
393 [ # # ]: 0 : if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
394 : 0 : mnt = nfs_do_refmount(client, dentry);
395 : 0 : goto out;
396 : : }
397 : :
398 [ # # ]: 0 : if (client->cl_auth->au_flavor != flavor)
399 : : flavor = client->cl_auth->au_flavor;
400 : : else {
401 : 0 : rpc_authflavor_t new = nfs4_negotiate_security(dir, name);
402 [ # # ]: 0 : if ((int)new >= 0)
403 : : flavor = new;
404 : : }
405 : 0 : mnt = nfs_do_submount(dentry, fh, fattr, flavor);
406 : : out:
407 : 0 : rpc_shutdown_client(client);
408 : 0 : return mnt;
409 : : }
410 : :
411 : : /*
412 : : * Try one location from the fs_locations array.
413 : : *
414 : : * Returns zero on success, or a negative errno value.
415 : : */
416 : 0 : static int nfs4_try_replacing_one_location(struct nfs_server *server,
417 : : char *page, char *page2,
418 : : const struct nfs4_fs_location *location)
419 : : {
420 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
421 : 0 : struct net *net = rpc_net_ns(server->client);
422 : : struct sockaddr *sap;
423 : : unsigned int s;
424 : : size_t salen;
425 : : int error;
426 : :
427 : : sap = kmalloc(addr_bufsize, GFP_KERNEL);
428 [ # # ]: 0 : if (sap == NULL)
429 : : return -ENOMEM;
430 : :
431 : : error = -ENOENT;
432 [ # # ]: 0 : for (s = 0; s < location->nservers; s++) {
433 : 0 : const struct nfs4_string *buf = &location->servers[s];
434 : : char *hostname;
435 : :
436 [ # # ]: 0 : if (buf->len <= 0 || buf->len > PAGE_SIZE)
437 : 0 : continue;
438 : :
439 [ # # ]: 0 : if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len) != NULL)
440 : 0 : continue;
441 : :
442 : 0 : salen = nfs_parse_server_name(buf->data, buf->len,
443 : : sap, addr_bufsize, net);
444 [ # # ]: 0 : if (salen == 0)
445 : 0 : continue;
446 : : rpc_set_port(sap, NFS_PORT);
447 : :
448 : : error = -ENOMEM;
449 : 0 : hostname = kstrndup(buf->data, buf->len, GFP_KERNEL);
450 [ # # ]: 0 : if (hostname == NULL)
451 : : break;
452 : :
453 : 0 : error = nfs4_update_server(server, hostname, sap, salen, net);
454 : 0 : kfree(hostname);
455 [ # # ]: 0 : if (error == 0)
456 : : break;
457 : : }
458 : :
459 : 0 : kfree(sap);
460 : : return error;
461 : : }
462 : :
463 : : /**
464 : : * nfs4_replace_transport - set up transport to destination server
465 : : *
466 : : * @server: export being migrated
467 : : * @locations: fs_locations array
468 : : *
469 : : * Returns zero on success, or a negative errno value.
470 : : *
471 : : * The client tries all the entries in the "locations" array, in the
472 : : * order returned by the server, until one works or the end of the
473 : : * array is reached.
474 : : */
475 : 0 : int nfs4_replace_transport(struct nfs_server *server,
476 : : const struct nfs4_fs_locations *locations)
477 : : {
478 : : char *page = NULL, *page2 = NULL;
479 : : int loc, error;
480 : :
481 : : error = -ENOENT;
482 [ # # ][ # # ]: 0 : if (locations == NULL || locations->nlocations <= 0)
483 : : goto out;
484 : :
485 : : error = -ENOMEM;
486 : 0 : page = (char *) __get_free_page(GFP_USER);
487 [ # # ]: 0 : if (!page)
488 : : goto out;
489 : 0 : page2 = (char *) __get_free_page(GFP_USER);
490 [ # # ]: 0 : if (!page2)
491 : : goto out;
492 : :
493 [ # # ]: 0 : for (loc = 0; loc < locations->nlocations; loc++) {
494 : 0 : const struct nfs4_fs_location *location =
495 : : &locations->locations[loc];
496 : :
497 [ # # ][ # # ]: 0 : if (location == NULL || location->nservers <= 0 ||
[ # # ]
498 : 0 : location->rootpath.ncomponents == 0)
499 : 0 : continue;
500 : :
501 : 0 : error = nfs4_try_replacing_one_location(server, page,
502 : : page2, location);
503 [ # # ]: 0 : if (error == 0)
504 : : break;
505 : : }
506 : :
507 : : out:
508 : 0 : free_page((unsigned long)page);
509 : 0 : free_page((unsigned long)page2);
510 : 0 : return error;
511 : : }
|
