2 * linux/fs/nfs/nfs4namespace.c
4 * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
5 * - Modified by David Howells <dhowells@redhat.com>
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>
23 #include "dns_resolve.h"
25 #define NFSDBG_FACILITY NFSDBG_VFS
28 * Convert the NFSv4 pathname components into a standard posix path.
30 * Note that the resulting string will be placed at the end of the buffer
32 static inline char *nfs4_pathname_string(const struct nfs4_pathname
*pathname
,
33 char *buffer
, ssize_t buflen
)
35 char *end
= buffer
+ buflen
;
41 n
= pathname
->ncomponents
;
43 const struct nfs4_string
*component
= &pathname
->components
[n
];
44 buflen
-= component
->len
+ 1;
47 end
-= component
->len
;
48 memcpy(end
, component
->data
, component
->len
);
53 return ERR_PTR(-ENAMETOOLONG
);
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
62 static char *nfs_path_component(const char *nfspath
, const char *end
)
66 if (*nfspath
== '[') {
67 /* parse [] escaped IPv6 addrs */
68 p
= strchr(nfspath
, ']');
69 if (p
!= NULL
&& ++p
< end
&& *p
== ':')
72 /* otherwise split on first colon */
73 p
= strchr(nfspath
, ':');
74 if (p
!= NULL
&& p
< end
)
81 * Determine the mount path as a string
83 static char *nfs4_path(struct dentry
*dentry
, char *buffer
, ssize_t buflen
)
86 char *path
= nfs_path(&limit
, dentry
, buffer
, buflen
,
89 char *path_component
= nfs_path_component(path
, limit
);
91 return path_component
;
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
100 static int nfs4_validate_fspath(struct dentry
*dentry
,
101 const struct nfs4_fs_locations
*locations
,
102 char *page
, char *page2
)
104 const char *path
, *fs_path
;
106 path
= nfs4_path(dentry
, page
, PAGE_SIZE
);
108 return PTR_ERR(path
);
110 fs_path
= nfs4_pathname_string(&locations
->fs_path
, page2
, PAGE_SIZE
);
112 return PTR_ERR(fs_path
);
114 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
);
123 static size_t nfs_parse_server_name(char *string
, size_t len
,
124 struct sockaddr
*sa
, size_t salen
, struct net
*net
)
128 ret
= rpc_pton(net
, string
, len
, sa
, salen
);
130 ret
= nfs_dns_resolve_name(net
, string
, len
, sa
, salen
);
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
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
148 static rpc_authflavor_t
nfs_find_best_sec(struct nfs_server
*server
,
149 struct nfs4_secinfo_flavors
*flavors
)
151 rpc_authflavor_t pseudoflavor
;
152 struct nfs4_secinfo4
*secinfo
;
155 for (i
= 0; i
< flavors
->num_flavors
; i
++) {
156 secinfo
= &flavors
->flavors
[i
];
158 switch (secinfo
->flavor
) {
162 pseudoflavor
= rpcauth_get_pseudoflavor(secinfo
->flavor
,
163 &secinfo
->flavor_info
);
164 /* make sure pseudoflavor matches sec= mount opt */
165 if (pseudoflavor
!= RPC_AUTH_MAXFLAVOR
&&
166 nfs_auth_info_match(&server
->auth_info
,
173 /* if there were any sec= options then nothing matched */
174 if (server
->auth_info
.flavor_len
> 0)
177 return RPC_AUTH_UNIX
;
180 static rpc_authflavor_t
nfs4_negotiate_security(struct inode
*inode
, struct qstr
*name
)
183 struct nfs4_secinfo_flavors
*flavors
;
184 rpc_authflavor_t flavor
;
187 page
= alloc_page(GFP_KERNEL
);
190 flavors
= page_address(page
);
192 err
= nfs4_proc_secinfo(inode
, name
, flavors
);
198 flavor
= nfs_find_best_sec(NFS_SERVER(inode
), flavors
);
206 * Please call rpc_shutdown_client() when you are done with this client.
208 struct rpc_clnt
*nfs4_create_sec_client(struct rpc_clnt
*clnt
, struct inode
*inode
,
211 rpc_authflavor_t flavor
;
213 flavor
= nfs4_negotiate_security(inode
, name
);
215 return ERR_PTR((int)flavor
);
217 return rpc_clone_client_set_auth(clnt
, flavor
);
220 static struct vfsmount
*try_location(struct nfs_clone_mount
*mountdata
,
221 char *page
, char *page2
,
222 const struct nfs4_fs_location
*location
)
224 const size_t addr_bufsize
= sizeof(struct sockaddr_storage
);
225 struct net
*net
= rpc_net_ns(NFS_SB(mountdata
->sb
)->client
);
226 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
228 unsigned int maxbuflen
;
231 mnt_path
= nfs4_pathname_string(&location
->rootpath
, page2
, PAGE_SIZE
);
232 if (IS_ERR(mnt_path
))
233 return ERR_CAST(mnt_path
);
234 mountdata
->mnt_path
= mnt_path
;
235 maxbuflen
= mnt_path
- 1 - page2
;
237 mountdata
->addr
= kmalloc(addr_bufsize
, GFP_KERNEL
);
238 if (mountdata
->addr
== NULL
)
239 return ERR_PTR(-ENOMEM
);
241 for (s
= 0; s
< location
->nservers
; s
++) {
242 const struct nfs4_string
*buf
= &location
->servers
[s
];
244 if (buf
->len
<= 0 || buf
->len
>= maxbuflen
)
247 if (memchr(buf
->data
, IPV6_SCOPE_DELIMITER
, buf
->len
))
250 mountdata
->addrlen
= nfs_parse_server_name(buf
->data
, buf
->len
,
251 mountdata
->addr
, addr_bufsize
, net
);
252 if (mountdata
->addrlen
== 0)
255 rpc_set_port(mountdata
->addr
, NFS_PORT
);
257 memcpy(page2
, buf
->data
, buf
->len
);
258 page2
[buf
->len
] = '\0';
259 mountdata
->hostname
= page2
;
261 snprintf(page
, PAGE_SIZE
, "%s:%s",
263 mountdata
->mnt_path
);
265 mnt
= vfs_kern_mount(&nfs4_referral_fs_type
, 0, page
, mountdata
);
269 kfree(mountdata
->addr
);
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
279 static struct vfsmount
*nfs_follow_referral(struct dentry
*dentry
,
280 const struct nfs4_fs_locations
*locations
)
282 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
283 struct nfs_clone_mount mountdata
= {
286 .authflavor
= NFS_SB(dentry
->d_sb
)->client
->cl_auth
->au_flavor
,
288 char *page
= NULL
, *page2
= NULL
;
291 if (locations
== NULL
|| locations
->nlocations
<= 0)
294 dprintk("%s: referral at %pd2\n", __func__
, dentry
);
296 page
= (char *) __get_free_page(GFP_USER
);
300 page2
= (char *) __get_free_page(GFP_USER
);
304 /* Ensure fs path is a prefix of current dentry path */
305 error
= nfs4_validate_fspath(dentry
, locations
, page
, page2
);
307 mnt
= ERR_PTR(error
);
311 for (loc
= 0; loc
< locations
->nlocations
; loc
++) {
312 const struct nfs4_fs_location
*location
= &locations
->locations
[loc
];
314 if (location
== NULL
|| location
->nservers
<= 0 ||
315 location
->rootpath
.ncomponents
== 0)
318 mnt
= try_location(&mountdata
, page
, page2
, location
);
324 free_page((unsigned long) page
);
325 free_page((unsigned long) page2
);
326 dprintk("%s: done\n", __func__
);
331 * nfs_do_refmount - handle crossing a referral on server
332 * @dentry - dentry of referral
335 static struct vfsmount
*nfs_do_refmount(struct rpc_clnt
*client
, struct dentry
*dentry
)
337 struct vfsmount
*mnt
= ERR_PTR(-ENOMEM
);
338 struct dentry
*parent
;
339 struct nfs4_fs_locations
*fs_locations
= NULL
;
343 /* BUG_ON(IS_ROOT(dentry)); */
344 dprintk("%s: enter\n", __func__
);
346 page
= alloc_page(GFP_KERNEL
);
350 fs_locations
= kmalloc(sizeof(struct nfs4_fs_locations
), GFP_KERNEL
);
351 if (fs_locations
== NULL
)
355 mnt
= ERR_PTR(-ENOENT
);
357 parent
= dget_parent(dentry
);
358 dprintk("%s: getting locations for %pd2\n",
361 err
= nfs4_proc_fs_locations(client
, parent
->d_inode
, &dentry
->d_name
, fs_locations
, page
);
364 fs_locations
->nlocations
<= 0 ||
365 fs_locations
->fs_path
.ncomponents
<= 0)
368 mnt
= nfs_follow_referral(dentry
, fs_locations
);
373 dprintk("%s: done\n", __func__
);
377 struct vfsmount
*nfs4_submount(struct nfs_server
*server
, struct dentry
*dentry
,
378 struct nfs_fh
*fh
, struct nfs_fattr
*fattr
)
380 rpc_authflavor_t flavor
= server
->client
->cl_auth
->au_flavor
;
381 struct dentry
*parent
= dget_parent(dentry
);
382 struct inode
*dir
= parent
->d_inode
;
383 struct qstr
*name
= &dentry
->d_name
;
384 struct rpc_clnt
*client
;
385 struct vfsmount
*mnt
;
387 /* Look it up again to get its attributes and sec flavor */
388 client
= nfs4_proc_lookup_mountpoint(dir
, name
, fh
, fattr
);
391 return ERR_CAST(client
);
393 if (fattr
->valid
& NFS_ATTR_FATTR_V4_REFERRAL
) {
394 mnt
= nfs_do_refmount(client
, dentry
);
398 if (client
->cl_auth
->au_flavor
!= flavor
)
399 flavor
= client
->cl_auth
->au_flavor
;
401 rpc_authflavor_t
new = nfs4_negotiate_security(dir
, name
);
405 mnt
= nfs_do_submount(dentry
, fh
, fattr
, flavor
);
407 rpc_shutdown_client(client
);
412 * Try one location from the fs_locations array.
414 * Returns zero on success, or a negative errno value.
416 static int nfs4_try_replacing_one_location(struct nfs_server
*server
,
417 char *page
, char *page2
,
418 const struct nfs4_fs_location
*location
)
420 const size_t addr_bufsize
= sizeof(struct sockaddr_storage
);
421 struct net
*net
= rpc_net_ns(server
->client
);
422 struct sockaddr
*sap
;
427 sap
= kmalloc(addr_bufsize
, GFP_KERNEL
);
432 for (s
= 0; s
< location
->nservers
; s
++) {
433 const struct nfs4_string
*buf
= &location
->servers
[s
];
436 if (buf
->len
<= 0 || buf
->len
> PAGE_SIZE
)
439 if (memchr(buf
->data
, IPV6_SCOPE_DELIMITER
, buf
->len
) != NULL
)
442 salen
= nfs_parse_server_name(buf
->data
, buf
->len
,
443 sap
, addr_bufsize
, net
);
446 rpc_set_port(sap
, NFS_PORT
);
449 hostname
= kstrndup(buf
->data
, buf
->len
, GFP_KERNEL
);
450 if (hostname
== NULL
)
453 error
= nfs4_update_server(server
, hostname
, sap
, salen
, net
);
464 * nfs4_replace_transport - set up transport to destination server
466 * @server: export being migrated
467 * @locations: fs_locations array
469 * Returns zero on success, or a negative errno value.
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
475 int nfs4_replace_transport(struct nfs_server
*server
,
476 const struct nfs4_fs_locations
*locations
)
478 char *page
= NULL
, *page2
= NULL
;
482 if (locations
== NULL
|| locations
->nlocations
<= 0)
486 page
= (char *) __get_free_page(GFP_USER
);
489 page2
= (char *) __get_free_page(GFP_USER
);
493 for (loc
= 0; loc
< locations
->nlocations
; loc
++) {
494 const struct nfs4_fs_location
*location
=
495 &locations
->locations
[loc
];
497 if (location
== NULL
|| location
->nservers
<= 0 ||
498 location
->rootpath
.ncomponents
== 0)
501 error
= nfs4_try_replacing_one_location(server
, page
,
508 free_page((unsigned long)page
);
509 free_page((unsigned long)page2
);