Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * linux/fs/nfs/nfs4namespace.c
4 : : *
5 : : * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
6 : : * - Modified by David Howells <dhowells@redhat.com>
7 : : *
8 : : * NFSv4 namespace
9 : : */
10 : :
11 : : #include <linux/module.h>
12 : : #include <linux/dcache.h>
13 : : #include <linux/mount.h>
14 : : #include <linux/namei.h>
15 : : #include <linux/nfs_fs.h>
16 : : #include <linux/nfs_mount.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/string.h>
19 : : #include <linux/sunrpc/clnt.h>
20 : : #include <linux/sunrpc/addr.h>
21 : : #include <linux/vfs.h>
22 : : #include <linux/inet.h>
23 : : #include "internal.h"
24 : : #include "nfs4_fs.h"
25 : : #include "nfs.h"
26 : : #include "dns_resolve.h"
27 : :
28 : : #define NFSDBG_FACILITY NFSDBG_VFS
29 : :
30 : : /*
31 : : * Work out the length that an NFSv4 path would render to as a standard posix
32 : : * path, with a leading slash but no terminating slash.
33 : : */
34 : 0 : static ssize_t nfs4_pathname_len(const struct nfs4_pathname *pathname)
35 : : {
36 : 0 : ssize_t len = 0;
37 : 0 : int i;
38 : :
39 [ # # ]: 0 : for (i = 0; i < pathname->ncomponents; i++) {
40 : 0 : const struct nfs4_string *component = &pathname->components[i];
41 : :
42 [ # # ]: 0 : if (component->len > NAME_MAX)
43 : 0 : goto too_long;
44 : 0 : len += 1 + component->len; /* Adding "/foo" */
45 [ # # ]: 0 : if (len > PATH_MAX)
46 : 0 : goto too_long;
47 : : }
48 : : return len;
49 : :
50 : 0 : too_long:
51 : : return -ENAMETOOLONG;
52 : : }
53 : :
54 : : /*
55 : : * Convert the NFSv4 pathname components into a standard posix path.
56 : : */
57 : 0 : static char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
58 : : unsigned short *_len)
59 : : {
60 : 0 : ssize_t len;
61 : 0 : char *buf, *p;
62 : 0 : int i;
63 : :
64 : 0 : len = nfs4_pathname_len(pathname);
65 [ # # ]: 0 : if (len < 0)
66 : 0 : return ERR_PTR(len);
67 : 0 : *_len = len;
68 : :
69 [ # # ]: 0 : p = buf = kmalloc(len + 1, GFP_KERNEL);
70 [ # # ]: 0 : if (!buf)
71 : : return ERR_PTR(-ENOMEM);
72 : :
73 [ # # ]: 0 : for (i = 0; i < pathname->ncomponents; i++) {
74 : 0 : const struct nfs4_string *component = &pathname->components[i];
75 : :
76 : 0 : *p++ = '/';
77 : 0 : memcpy(p, component->data, component->len);
78 : 0 : p += component->len;
79 : : }
80 : :
81 : 0 : *p = 0;
82 : 0 : return buf;
83 : : }
84 : :
85 : : /*
86 : : * return the path component of "<server>:<path>"
87 : : * nfspath - the "<server>:<path>" string
88 : : * end - one past the last char that could contain "<server>:"
89 : : * returns NULL on failure
90 : : */
91 : 0 : static char *nfs_path_component(const char *nfspath, const char *end)
92 : : {
93 : 0 : char *p;
94 : :
95 [ # # ]: 0 : if (*nfspath == '[') {
96 : : /* parse [] escaped IPv6 addrs */
97 : 0 : p = strchr(nfspath, ']');
98 [ # # # # : 0 : if (p != NULL && ++p < end && *p == ':')
# # ]
99 : 0 : return p + 1;
100 : : } else {
101 : : /* otherwise split on first colon */
102 : 0 : p = strchr(nfspath, ':');
103 [ # # ]: 0 : if (p != NULL && p < end)
104 : 0 : return p + 1;
105 : : }
106 : : return NULL;
107 : : }
108 : :
109 : : /*
110 : : * Determine the mount path as a string
111 : : */
112 : 0 : static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
113 : : {
114 : 0 : char *limit;
115 : 0 : char *path = nfs_path(&limit, dentry, buffer, buflen,
116 : : NFS_PATH_CANONICAL);
117 [ # # ]: 0 : if (!IS_ERR(path)) {
118 : 0 : char *path_component = nfs_path_component(path, limit);
119 [ # # ]: 0 : if (path_component)
120 : 0 : return path_component;
121 : : }
122 : : return path;
123 : : }
124 : :
125 : : /*
126 : : * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
127 : : * believe to be the server path to this dentry
128 : : */
129 : : static int nfs4_validate_fspath(struct dentry *dentry,
130 : : const struct nfs4_fs_locations *locations,
131 : : struct nfs_fs_context *ctx)
132 : : {
133 : : const char *path;
134 : : char *fs_path;
135 : : unsigned short len;
136 : : char *buf;
137 : : int n;
138 : :
139 : : buf = kmalloc(4096, GFP_KERNEL);
140 : : if (!buf)
141 : : return -ENOMEM;
142 : :
143 : : path = nfs4_path(dentry, buf, 4096);
144 : : if (IS_ERR(path)) {
145 : : kfree(buf);
146 : : return PTR_ERR(path);
147 : : }
148 : :
149 : : fs_path = nfs4_pathname_string(&locations->fs_path, &len);
150 : : if (IS_ERR(fs_path)) {
151 : : kfree(buf);
152 : : return PTR_ERR(fs_path);
153 : : }
154 : :
155 : : n = strncmp(path, fs_path, len);
156 : : kfree(buf);
157 : : kfree(fs_path);
158 : : if (n != 0) {
159 : : dprintk("%s: path %s does not begin with fsroot %s\n",
160 : : __func__, path, ctx->nfs_server.export_path);
161 : : return -ENOENT;
162 : : }
163 : :
164 : : return 0;
165 : : }
166 : :
167 : 0 : static size_t nfs_parse_server_name(char *string, size_t len,
168 : : struct sockaddr *sa, size_t salen, struct net *net)
169 : : {
170 : 0 : ssize_t ret;
171 : :
172 : 0 : ret = rpc_pton(net, string, len, sa, salen);
173 [ # # ]: 0 : if (ret == 0) {
174 : 0 : ret = nfs_dns_resolve_name(net, string, len, sa, salen);
175 : 0 : if (ret < 0)
176 : : ret = 0;
177 : : }
178 : 0 : return ret;
179 : : }
180 : :
181 : : /**
182 : : * nfs_find_best_sec - Find a security mechanism supported locally
183 : : * @clnt: pointer to rpc_clnt
184 : : * @server: NFS server struct
185 : : * @flavors: List of security tuples returned by SECINFO procedure
186 : : *
187 : : * Return an rpc client that uses the first security mechanism in
188 : : * "flavors" that is locally supported. The "flavors" array
189 : : * is searched in the order returned from the server, per RFC 3530
190 : : * recommendation and each flavor is checked for membership in the
191 : : * sec= mount option list if it exists.
192 : : *
193 : : * Return -EPERM if no matching flavor is found in the array.
194 : : *
195 : : * Please call rpc_shutdown_client() when you are done with this rpc client.
196 : : *
197 : : */
198 : 0 : static struct rpc_clnt *nfs_find_best_sec(struct rpc_clnt *clnt,
199 : : struct nfs_server *server,
200 : : struct nfs4_secinfo_flavors *flavors)
201 : : {
202 : 0 : rpc_authflavor_t pflavor;
203 : 0 : struct nfs4_secinfo4 *secinfo;
204 : 0 : unsigned int i;
205 : :
206 [ # # ]: 0 : for (i = 0; i < flavors->num_flavors; i++) {
207 : 0 : secinfo = &flavors->flavors[i];
208 : :
209 [ # # ]: 0 : switch (secinfo->flavor) {
210 : 0 : case RPC_AUTH_NULL:
211 : : case RPC_AUTH_UNIX:
212 : : case RPC_AUTH_GSS:
213 : 0 : pflavor = rpcauth_get_pseudoflavor(secinfo->flavor,
214 : : &secinfo->flavor_info);
215 : : /* does the pseudoflavor match a sec= mount opt? */
216 [ # # # # ]: 0 : if (pflavor != RPC_AUTH_MAXFLAVOR &&
217 : 0 : nfs_auth_info_match(&server->auth_info, pflavor)) {
218 : 0 : struct rpc_clnt *new;
219 : 0 : struct rpc_cred *cred;
220 : :
221 : : /* Cloning creates an rpc_auth for the flavor */
222 : 0 : new = rpc_clone_client_set_auth(clnt, pflavor);
223 [ # # ]: 0 : if (IS_ERR(new))
224 : 0 : continue;
225 : : /**
226 : : * Check that the user actually can use the
227 : : * flavor. This is mostly for RPC_AUTH_GSS
228 : : * where cr_init obtains a gss context
229 : : */
230 : 0 : cred = rpcauth_lookupcred(new->cl_auth, 0);
231 [ # # ]: 0 : if (IS_ERR(cred)) {
232 : 0 : rpc_shutdown_client(new);
233 : 0 : continue;
234 : : }
235 : 0 : put_rpccred(cred);
236 : 0 : return new;
237 : : }
238 : : }
239 : : }
240 : : return ERR_PTR(-EPERM);
241 : : }
242 : :
243 : : /**
244 : : * nfs4_negotiate_security - in response to an NFS4ERR_WRONGSEC on lookup,
245 : : * return an rpc_clnt that uses the best available security flavor with
246 : : * respect to the secinfo flavor list and the sec= mount options.
247 : : *
248 : : * @clnt: RPC client to clone
249 : : * @inode: directory inode
250 : : * @name: lookup name
251 : : *
252 : : * Please call rpc_shutdown_client() when you are done with this rpc client.
253 : : */
254 : : struct rpc_clnt *
255 : 0 : nfs4_negotiate_security(struct rpc_clnt *clnt, struct inode *inode,
256 : : const struct qstr *name)
257 : : {
258 : 0 : struct page *page;
259 : 0 : struct nfs4_secinfo_flavors *flavors;
260 : 0 : struct rpc_clnt *new;
261 : 0 : int err;
262 : :
263 : 0 : page = alloc_page(GFP_KERNEL);
264 [ # # ]: 0 : if (!page)
265 : : return ERR_PTR(-ENOMEM);
266 : :
267 : 0 : flavors = page_address(page);
268 : :
269 : 0 : err = nfs4_proc_secinfo(inode, name, flavors);
270 [ # # ]: 0 : if (err < 0) {
271 : 0 : new = ERR_PTR(err);
272 : 0 : goto out;
273 : : }
274 : :
275 : 0 : new = nfs_find_best_sec(clnt, NFS_SERVER(inode), flavors);
276 : :
277 : 0 : out:
278 : 0 : put_page(page);
279 : 0 : return new;
280 : : }
281 : :
282 : 0 : static int try_location(struct fs_context *fc,
283 : : const struct nfs4_fs_location *location)
284 : : {
285 : 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
286 : 0 : unsigned int len, s;
287 : 0 : char *export_path, *source, *p;
288 : 0 : int ret = -ENOENT;
289 : :
290 : : /* Allocate a buffer big enough to hold any of the hostnames plus a
291 : : * terminating char and also a buffer big enough to hold the hostname
292 : : * plus a colon plus the path.
293 : : */
294 : 0 : len = 0;
295 [ # # ]: 0 : for (s = 0; s < location->nservers; s++) {
296 : 0 : const struct nfs4_string *buf = &location->servers[s];
297 : 0 : if (buf->len > len)
298 : : len = buf->len;
299 : : }
300 : :
301 : 0 : kfree(ctx->nfs_server.hostname);
302 [ # # ]: 0 : ctx->nfs_server.hostname = kmalloc(len + 1, GFP_KERNEL);
303 [ # # ]: 0 : if (!ctx->nfs_server.hostname)
304 : : return -ENOMEM;
305 : :
306 : 0 : export_path = nfs4_pathname_string(&location->rootpath,
307 : : &ctx->nfs_server.export_path_len);
308 [ # # ]: 0 : if (IS_ERR(export_path))
309 : 0 : return PTR_ERR(export_path);
310 : :
311 : 0 : ctx->nfs_server.export_path = export_path;
312 : :
313 [ # # ]: 0 : source = kmalloc(len + 1 + ctx->nfs_server.export_path_len + 1,
314 : : GFP_KERNEL);
315 [ # # ]: 0 : if (!source)
316 : : return -ENOMEM;
317 : :
318 : 0 : kfree(fc->source);
319 : 0 : fc->source = source;
320 [ # # ]: 0 : for (s = 0; s < location->nservers; s++) {
321 : 0 : const struct nfs4_string *buf = &location->servers[s];
322 : :
323 [ # # ]: 0 : if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
324 : 0 : continue;
325 : :
326 : 0 : ctx->nfs_server.addrlen =
327 : 0 : nfs_parse_server_name(buf->data, buf->len,
328 : : &ctx->nfs_server.address,
329 : : sizeof(ctx->nfs_server._address),
330 : : fc->net_ns);
331 [ # # ]: 0 : if (ctx->nfs_server.addrlen == 0)
332 : 0 : continue;
333 : :
334 [ # # # ]: 0 : rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
335 : :
336 : 0 : memcpy(ctx->nfs_server.hostname, buf->data, buf->len);
337 : 0 : ctx->nfs_server.hostname[buf->len] = '\0';
338 : :
339 : 0 : p = source;
340 : 0 : memcpy(p, buf->data, buf->len);
341 : 0 : p += buf->len;
342 : 0 : *p++ = ':';
343 : 0 : memcpy(p, ctx->nfs_server.export_path, ctx->nfs_server.export_path_len);
344 : 0 : p += ctx->nfs_server.export_path_len;
345 : 0 : *p = 0;
346 : :
347 : 0 : ret = nfs4_get_referral_tree(fc);
348 [ # # ]: 0 : if (ret == 0)
349 : : return 0;
350 : : }
351 : :
352 : : return ret;
353 : : }
354 : :
355 : : /**
356 : : * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
357 : : * @dentry: parent directory
358 : : * @locations: array of NFSv4 server location information
359 : : *
360 : : */
361 : 0 : static int nfs_follow_referral(struct fs_context *fc,
362 : : const struct nfs4_fs_locations *locations)
363 : : {
364 [ # # ]: 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
365 : 0 : int loc, error;
366 : :
367 [ # # # # ]: 0 : if (locations == NULL || locations->nlocations <= 0)
368 : : return -ENOENT;
369 : :
370 : 0 : dprintk("%s: referral at %pd2\n", __func__, ctx->clone_data.dentry);
371 : :
372 : : /* Ensure fs path is a prefix of current dentry path */
373 : 0 : error = nfs4_validate_fspath(ctx->clone_data.dentry, locations, ctx);
374 [ # # ]: 0 : if (error < 0)
375 : : return error;
376 : :
377 : : error = -ENOENT;
378 [ # # ]: 0 : for (loc = 0; loc < locations->nlocations; loc++) {
379 : 0 : const struct nfs4_fs_location *location = &locations->locations[loc];
380 : :
381 [ # # # # ]: 0 : if (location == NULL || location->nservers <= 0 ||
382 [ # # ]: 0 : location->rootpath.ncomponents == 0)
383 : 0 : continue;
384 : :
385 : 0 : error = try_location(fc, location);
386 [ # # ]: 0 : if (error == 0)
387 : : return 0;
388 : : }
389 : :
390 : : return error;
391 : : }
392 : :
393 : : /*
394 : : * nfs_do_refmount - handle crossing a referral on server
395 : : * @dentry - dentry of referral
396 : : *
397 : : */
398 : 0 : static int nfs_do_refmount(struct fs_context *fc, struct rpc_clnt *client)
399 : : {
400 : 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
401 : 0 : struct dentry *dentry, *parent;
402 : 0 : struct nfs4_fs_locations *fs_locations = NULL;
403 : 0 : struct page *page;
404 : 0 : int err = -ENOMEM;
405 : :
406 : : /* BUG_ON(IS_ROOT(dentry)); */
407 : 0 : page = alloc_page(GFP_KERNEL);
408 [ # # ]: 0 : if (!page)
409 : : return -ENOMEM;
410 : :
411 : 0 : fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
412 [ # # ]: 0 : if (!fs_locations)
413 : 0 : goto out_free;
414 : :
415 : : /* Get locations */
416 : 0 : dentry = ctx->clone_data.dentry;
417 : 0 : parent = dget_parent(dentry);
418 : 0 : dprintk("%s: getting locations for %pd2\n",
419 : : __func__, dentry);
420 : :
421 : 0 : err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page);
422 : 0 : dput(parent);
423 [ # # ]: 0 : if (err != 0)
424 : 0 : goto out_free_2;
425 : :
426 : 0 : err = -ENOENT;
427 [ # # ]: 0 : if (fs_locations->nlocations <= 0 ||
428 [ # # ]: 0 : fs_locations->fs_path.ncomponents <= 0)
429 : 0 : goto out_free_2;
430 : :
431 : 0 : err = nfs_follow_referral(fc, fs_locations);
432 : 0 : out_free_2:
433 : 0 : kfree(fs_locations);
434 : 0 : out_free:
435 : 0 : __free_page(page);
436 : 0 : return err;
437 : : }
438 : :
439 : 0 : int nfs4_submount(struct fs_context *fc, struct nfs_server *server)
440 : : {
441 : 0 : struct nfs_fs_context *ctx = nfs_fc2context(fc);
442 : 0 : struct dentry *dentry = ctx->clone_data.dentry;
443 : 0 : struct dentry *parent = dget_parent(dentry);
444 : 0 : struct inode *dir = d_inode(parent);
445 : 0 : struct rpc_clnt *client;
446 : 0 : int ret;
447 : :
448 : : /* Look it up again to get its attributes and sec flavor */
449 : 0 : client = nfs4_proc_lookup_mountpoint(dir, dentry, ctx->mntfh,
450 : : ctx->clone_data.fattr);
451 : 0 : dput(parent);
452 [ # # ]: 0 : if (IS_ERR(client))
453 : 0 : return PTR_ERR(client);
454 : :
455 : 0 : ctx->selected_flavor = client->cl_auth->au_flavor;
456 [ # # ]: 0 : if (ctx->clone_data.fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
457 : 0 : ret = nfs_do_refmount(fc, client);
458 : : } else {
459 : 0 : ret = nfs_do_submount(fc);
460 : : }
461 : :
462 : 0 : rpc_shutdown_client(client);
463 : 0 : return ret;
464 : : }
465 : :
466 : : /*
467 : : * Try one location from the fs_locations array.
468 : : *
469 : : * Returns zero on success, or a negative errno value.
470 : : */
471 : : static int nfs4_try_replacing_one_location(struct nfs_server *server,
472 : : char *page, char *page2,
473 : : const struct nfs4_fs_location *location)
474 : : {
475 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
476 : : struct net *net = rpc_net_ns(server->client);
477 : : struct sockaddr *sap;
478 : : unsigned int s;
479 : : size_t salen;
480 : : int error;
481 : :
482 : : sap = kmalloc(addr_bufsize, GFP_KERNEL);
483 : : if (sap == NULL)
484 : : return -ENOMEM;
485 : :
486 : : error = -ENOENT;
487 : : for (s = 0; s < location->nservers; s++) {
488 : : const struct nfs4_string *buf = &location->servers[s];
489 : : char *hostname;
490 : :
491 : : if (buf->len <= 0 || buf->len > PAGE_SIZE)
492 : : continue;
493 : :
494 : : if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len) != NULL)
495 : : continue;
496 : :
497 : : salen = nfs_parse_server_name(buf->data, buf->len,
498 : : sap, addr_bufsize, net);
499 : : if (salen == 0)
500 : : continue;
501 : : rpc_set_port(sap, NFS_PORT);
502 : :
503 : : error = -ENOMEM;
504 : : hostname = kmemdup_nul(buf->data, buf->len, GFP_KERNEL);
505 : : if (hostname == NULL)
506 : : break;
507 : :
508 : : error = nfs4_update_server(server, hostname, sap, salen, net);
509 : : kfree(hostname);
510 : : if (error == 0)
511 : : break;
512 : : }
513 : :
514 : : kfree(sap);
515 : : return error;
516 : : }
517 : :
518 : : /**
519 : : * nfs4_replace_transport - set up transport to destination server
520 : : *
521 : : * @server: export being migrated
522 : : * @locations: fs_locations array
523 : : *
524 : : * Returns zero on success, or a negative errno value.
525 : : *
526 : : * The client tries all the entries in the "locations" array, in the
527 : : * order returned by the server, until one works or the end of the
528 : : * array is reached.
529 : : */
530 : 0 : int nfs4_replace_transport(struct nfs_server *server,
531 : : const struct nfs4_fs_locations *locations)
532 : : {
533 : 0 : char *page = NULL, *page2 = NULL;
534 : 0 : int loc, error;
535 : :
536 : 0 : error = -ENOENT;
537 [ # # # # ]: 0 : if (locations == NULL || locations->nlocations <= 0)
538 : 0 : goto out;
539 : :
540 : 0 : error = -ENOMEM;
541 : 0 : page = (char *) __get_free_page(GFP_USER);
542 [ # # ]: 0 : if (!page)
543 : 0 : goto out;
544 : 0 : page2 = (char *) __get_free_page(GFP_USER);
545 [ # # ]: 0 : if (!page2)
546 : 0 : goto out;
547 : :
548 [ # # ]: 0 : for (loc = 0; loc < locations->nlocations; loc++) {
549 : 0 : const struct nfs4_fs_location *location =
550 : : &locations->locations[loc];
551 : :
552 [ # # # # ]: 0 : if (location == NULL || location->nservers <= 0 ||
553 [ # # ]: 0 : location->rootpath.ncomponents == 0)
554 : 0 : continue;
555 : :
556 : 0 : error = nfs4_try_replacing_one_location(server, page,
557 : : page2, location);
558 [ # # ]: 0 : if (error == 0)
559 : : break;
560 : : }
561 : :
562 : 0 : out:
563 : 0 : free_page((unsigned long)page);
564 : 0 : free_page((unsigned long)page2);
565 : 0 : return error;
566 : : }
|
