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 nfs_server *server)
125 : : {
126 : 0 : struct net *net = rpc_net_ns(server->client);
127 : : ssize_t ret;
128 : :
129 : 0 : ret = rpc_pton(net, string, len, sa, salen);
130 [ # # ]: 0 : if (ret == 0) {
131 : 0 : ret = nfs_dns_resolve_name(net, string, len, sa, salen);
132 [ # # ]: 0 : if (ret < 0)
133 : : ret = 0;
134 : : }
135 : 0 : return ret;
136 : : }
137 : :
138 : : /**
139 : : * nfs_find_best_sec - Find a security mechanism supported locally
140 : : * @server: NFS server struct
141 : : * @flavors: List of security tuples returned by SECINFO procedure
142 : : *
143 : : * Return the pseudoflavor of the first security mechanism in
144 : : * "flavors" that is locally supported. Return RPC_AUTH_UNIX if
145 : : * no matching flavor is found in the array. The "flavors" array
146 : : * is searched in the order returned from the server, per RFC 3530
147 : : * recommendation.
148 : : */
149 : 0 : static rpc_authflavor_t nfs_find_best_sec(struct nfs_server *server,
150 : : struct nfs4_secinfo_flavors *flavors)
151 : : {
152 : : rpc_authflavor_t pseudoflavor;
153 : : struct nfs4_secinfo4 *secinfo;
154 : : unsigned int i;
155 : :
156 [ # # ]: 0 : for (i = 0; i < flavors->num_flavors; i++) {
157 : 0 : secinfo = &flavors->flavors[i];
158 : :
159 [ # # ][ # # ]: 0 : switch (secinfo->flavor) {
160 : : case RPC_AUTH_NULL:
161 : : case RPC_AUTH_UNIX:
162 : : case RPC_AUTH_GSS:
163 : 0 : pseudoflavor = rpcauth_get_pseudoflavor(secinfo->flavor,
164 : : &secinfo->flavor_info);
165 : : /* make sure pseudoflavor matches sec= mount opt */
166 [ # # # # ]: 0 : if (pseudoflavor != RPC_AUTH_MAXFLAVOR &&
167 : 0 : nfs_auth_info_match(&server->auth_info,
168 : : pseudoflavor))
169 : : return pseudoflavor;
170 : : break;
171 : : }
172 : : }
173 : :
174 : : /* if there were any sec= options then nothing matched */
175 [ # # ]: 0 : if (server->auth_info.flavor_len > 0)
176 : : return -EPERM;
177 : :
178 : 0 : return RPC_AUTH_UNIX;
179 : : }
180 : :
181 : 0 : static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name)
182 : : {
183 : : struct page *page;
184 : : struct nfs4_secinfo_flavors *flavors;
185 : : rpc_authflavor_t flavor;
186 : : int err;
187 : :
188 : : page = alloc_page(GFP_KERNEL);
189 [ # # ]: 0 : if (!page)
190 : : return -ENOMEM;
191 : 0 : flavors = page_address(page);
192 : :
193 : 0 : err = nfs4_proc_secinfo(inode, name, flavors);
194 [ # # ]: 0 : if (err < 0) {
195 : 0 : flavor = err;
196 : 0 : goto out;
197 : : }
198 : :
199 : 0 : flavor = nfs_find_best_sec(NFS_SERVER(inode), flavors);
200 : :
201 : : out:
202 : 0 : put_page(page);
203 : 0 : return flavor;
204 : : }
205 : :
206 : : /*
207 : : * Please call rpc_shutdown_client() when you are done with this client.
208 : : */
209 : 0 : struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode,
210 : : struct qstr *name)
211 : : {
212 : : rpc_authflavor_t flavor;
213 : :
214 : 0 : flavor = nfs4_negotiate_security(inode, name);
215 [ # # ]: 0 : if ((int)flavor < 0)
216 : 0 : return ERR_PTR((int)flavor);
217 : :
218 : 0 : return rpc_clone_client_set_auth(clnt, flavor);
219 : : }
220 : :
221 : 0 : static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
222 : : char *page, char *page2,
223 : : const struct nfs4_fs_location *location)
224 : : {
225 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
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,
252 : : NFS_SB(mountdata->sb));
253 [ # # ]: 0 : if (mountdata->addrlen == 0)
254 : 0 : continue;
255 : :
256 : 0 : rpc_set_port(mountdata->addr, NFS_PORT);
257 : :
258 : 0 : memcpy(page2, buf->data, buf->len);
259 : 0 : page2[buf->len] = '\0';
260 : 0 : mountdata->hostname = page2;
261 : :
262 : 0 : snprintf(page, PAGE_SIZE, "%s:%s",
263 : : mountdata->hostname,
264 : : mountdata->mnt_path);
265 : :
266 : 0 : mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
267 [ # # ]: 0 : if (!IS_ERR(mnt))
268 : : break;
269 : : }
270 : 0 : kfree(mountdata->addr);
271 : 0 : return mnt;
272 : : }
273 : :
274 : : /**
275 : : * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
276 : : * @dentry - parent directory
277 : : * @locations - array of NFSv4 server location information
278 : : *
279 : : */
280 : 0 : static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
281 : : const struct nfs4_fs_locations *locations)
282 : : {
283 : : struct vfsmount *mnt = ERR_PTR(-ENOENT);
284 : 0 : struct nfs_clone_mount mountdata = {
285 : 0 : .sb = dentry->d_sb,
286 : : .dentry = dentry,
287 : 0 : .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
288 : : };
289 : : char *page = NULL, *page2 = NULL;
290 : : int loc, error;
291 : :
292 [ # # ][ # # ]: 0 : if (locations == NULL || locations->nlocations <= 0)
293 : : goto out;
294 : :
295 : : dprintk("%s: referral at %pd2\n", __func__, dentry);
296 : :
297 : 0 : page = (char *) __get_free_page(GFP_USER);
298 [ # # ]: 0 : if (!page)
299 : : goto out;
300 : :
301 : 0 : page2 = (char *) __get_free_page(GFP_USER);
302 [ # # ]: 0 : if (!page2)
303 : : goto out;
304 : :
305 : : /* Ensure fs path is a prefix of current dentry path */
306 : 0 : error = nfs4_validate_fspath(dentry, locations, page, page2);
307 [ # # ]: 0 : if (error < 0) {
308 : : mnt = ERR_PTR(error);
309 : 0 : goto out;
310 : : }
311 : :
312 [ # # ]: 0 : for (loc = 0; loc < locations->nlocations; loc++) {
313 : 0 : const struct nfs4_fs_location *location = &locations->locations[loc];
314 : :
315 [ # # ][ # # ]: 0 : if (location == NULL || location->nservers <= 0 ||
[ # # ]
316 : 0 : location->rootpath.ncomponents == 0)
317 : 0 : continue;
318 : :
319 : 0 : mnt = try_location(&mountdata, page, page2, location);
320 [ # # ]: 0 : if (!IS_ERR(mnt))
321 : : break;
322 : : }
323 : :
324 : : out:
325 : 0 : free_page((unsigned long) page);
326 : 0 : free_page((unsigned long) page2);
327 : : dprintk("%s: done\n", __func__);
328 : 0 : return mnt;
329 : : }
330 : :
331 : : /*
332 : : * nfs_do_refmount - handle crossing a referral on server
333 : : * @dentry - dentry of referral
334 : : *
335 : : */
336 : 0 : static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry)
337 : : {
338 : : struct vfsmount *mnt = ERR_PTR(-ENOMEM);
339 : : struct dentry *parent;
340 : : struct nfs4_fs_locations *fs_locations = NULL;
341 : : struct page *page;
342 : : int err;
343 : :
344 : : /* BUG_ON(IS_ROOT(dentry)); */
345 : : dprintk("%s: enter\n", __func__);
346 : :
347 : : page = alloc_page(GFP_KERNEL);
348 [ # # ]: 0 : if (page == NULL)
349 : : goto out;
350 : :
351 : : fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
352 [ # # ]: 0 : if (fs_locations == NULL)
353 : : goto out_free;
354 : :
355 : : /* Get locations */
356 : : mnt = ERR_PTR(-ENOENT);
357 : :
358 : 0 : parent = dget_parent(dentry);
359 : : dprintk("%s: getting locations for %pd2\n",
360 : : __func__, dentry);
361 : :
362 : 0 : err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
363 : 0 : dput(parent);
364 [ # # ][ # # ]: 0 : if (err != 0 ||
365 [ # # ]: 0 : fs_locations->nlocations <= 0 ||
366 : 0 : fs_locations->fs_path.ncomponents <= 0)
367 : : goto out_free;
368 : :
369 : 0 : mnt = nfs_follow_referral(dentry, fs_locations);
370 : : out_free:
371 : 0 : __free_page(page);
372 : 0 : kfree(fs_locations);
373 : : out:
374 : : dprintk("%s: done\n", __func__);
375 : 0 : return mnt;
376 : : }
377 : :
378 : 0 : struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
379 : : struct nfs_fh *fh, struct nfs_fattr *fattr)
380 : : {
381 : 0 : rpc_authflavor_t flavor = server->client->cl_auth->au_flavor;
382 : 0 : struct dentry *parent = dget_parent(dentry);
383 : 0 : struct inode *dir = parent->d_inode;
384 : 0 : struct qstr *name = &dentry->d_name;
385 : : struct rpc_clnt *client;
386 : : struct vfsmount *mnt;
387 : :
388 : : /* Look it up again to get its attributes and sec flavor */
389 : 0 : client = nfs4_proc_lookup_mountpoint(dir, name, fh, fattr);
390 : 0 : dput(parent);
391 [ # # ]: 0 : if (IS_ERR(client))
392 : : return ERR_CAST(client);
393 : :
394 [ # # ]: 0 : if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
395 : 0 : mnt = nfs_do_refmount(client, dentry);
396 : 0 : goto out;
397 : : }
398 : :
399 [ # # ]: 0 : if (client->cl_auth->au_flavor != flavor)
400 : : flavor = client->cl_auth->au_flavor;
401 : : else {
402 : 0 : rpc_authflavor_t new = nfs4_negotiate_security(dir, name);
403 [ # # ]: 0 : if ((int)new >= 0)
404 : : flavor = new;
405 : : }
406 : 0 : mnt = nfs_do_submount(dentry, fh, fattr, flavor);
407 : : out:
408 : 0 : rpc_shutdown_client(client);
409 : 0 : return mnt;
410 : : }
411 : :
412 : : /*
413 : : * Try one location from the fs_locations array.
414 : : *
415 : : * Returns zero on success, or a negative errno value.
416 : : */
417 : 0 : static int nfs4_try_replacing_one_location(struct nfs_server *server,
418 : : char *page, char *page2,
419 : : const struct nfs4_fs_location *location)
420 : : {
421 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
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, server);
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);
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 : : }
|
