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 nfs_server
*server
)
126 struct net
*net
= rpc_net_ns(server
->client
);
129 ret
= rpc_pton(net
, string
, len
, sa
, salen
);
131 ret
= nfs_dns_resolve_name(net
, string
, len
, sa
, salen
);
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
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
149 static rpc_authflavor_t
nfs_find_best_sec(struct nfs_server
*server
,
150 struct nfs4_secinfo_flavors
*flavors
)
152 rpc_authflavor_t pseudoflavor
;
153 struct nfs4_secinfo4
*secinfo
;
156 for (i
= 0; i
< flavors
->num_flavors
; i
++) {
157 secinfo
= &flavors
->flavors
[i
];
159 switch (secinfo
->flavor
) {
163 pseudoflavor
= rpcauth_get_pseudoflavor(secinfo
->flavor
,
164 &secinfo
->flavor_info
);
165 /* make sure pseudoflavor matches sec= mount opt */
166 if (pseudoflavor
!= RPC_AUTH_MAXFLAVOR
&&
167 nfs_auth_info_match(&server
->auth_info
,
174 /* if there were any sec= options then nothing matched */
175 if (server
->auth_info
.flavor_len
> 0)
178 return RPC_AUTH_UNIX
;
181 static rpc_authflavor_t
nfs4_negotiate_security(struct inode
*inode
, struct qstr
*name
)
184 struct nfs4_secinfo_flavors
*flavors
;
185 rpc_authflavor_t flavor
;
188 page
= alloc_page(GFP_KERNEL
);
191 flavors
= page_address(page
);
193 err
= nfs4_proc_secinfo(inode
, name
, flavors
);
199 flavor
= nfs_find_best_sec(NFS_SERVER(inode
), flavors
);
207 * Please call rpc_shutdown_client() when you are done with this client.
209 struct rpc_clnt
*nfs4_create_sec_client(struct rpc_clnt
*clnt
, struct inode
*inode
,
212 rpc_authflavor_t flavor
;
214 flavor
= nfs4_negotiate_security(inode
, name
);
216 return ERR_PTR((int)flavor
);
218 return rpc_clone_client_set_auth(clnt
, flavor
);
221 static struct vfsmount
*try_location(struct nfs_clone_mount
*mountdata
,
222 char *page
, char *page2
,
223 const struct nfs4_fs_location
*location
)
225 const size_t addr_bufsize
= sizeof(struct sockaddr_storage
);
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
,
252 NFS_SB(mountdata
->sb
));
253 if (mountdata
->addrlen
== 0)
256 rpc_set_port(mountdata
->addr
, NFS_PORT
);
258 memcpy(page2
, buf
->data
, buf
->len
);
259 page2
[buf
->len
] = '\0';
260 mountdata
->hostname
= page2
;
262 snprintf(page
, PAGE_SIZE
, "%s:%s",
264 mountdata
->mnt_path
);
266 mnt
= vfs_kern_mount(&nfs4_referral_fs_type
, 0, page
, mountdata
);
270 kfree(mountdata
->addr
);
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
280 static struct vfsmount
*nfs_follow_referral(struct dentry
*dentry
,
281 const struct nfs4_fs_locations
*locations
)
283 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
284 struct nfs_clone_mount mountdata
= {
287 .authflavor
= NFS_SB(dentry
->d_sb
)->client
->cl_auth
->au_flavor
,
289 char *page
= NULL
, *page2
= NULL
;
292 if (locations
== NULL
|| locations
->nlocations
<= 0)
295 dprintk("%s: referral at %s/%s\n", __func__
,
296 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
298 page
= (char *) __get_free_page(GFP_USER
);
302 page2
= (char *) __get_free_page(GFP_USER
);
306 /* Ensure fs path is a prefix of current dentry path */
307 error
= nfs4_validate_fspath(dentry
, locations
, page
, page2
);
309 mnt
= ERR_PTR(error
);
313 for (loc
= 0; loc
< locations
->nlocations
; loc
++) {
314 const struct nfs4_fs_location
*location
= &locations
->locations
[loc
];
316 if (location
== NULL
|| location
->nservers
<= 0 ||
317 location
->rootpath
.ncomponents
== 0)
320 mnt
= try_location(&mountdata
, page
, page2
, location
);
326 free_page((unsigned long) page
);
327 free_page((unsigned long) page2
);
328 dprintk("%s: done\n", __func__
);
333 * nfs_do_refmount - handle crossing a referral on server
334 * @dentry - dentry of referral
337 static struct vfsmount
*nfs_do_refmount(struct rpc_clnt
*client
, struct dentry
*dentry
)
339 struct vfsmount
*mnt
= ERR_PTR(-ENOMEM
);
340 struct dentry
*parent
;
341 struct nfs4_fs_locations
*fs_locations
= NULL
;
345 /* BUG_ON(IS_ROOT(dentry)); */
346 dprintk("%s: enter\n", __func__
);
348 page
= alloc_page(GFP_KERNEL
);
352 fs_locations
= kmalloc(sizeof(struct nfs4_fs_locations
), GFP_KERNEL
);
353 if (fs_locations
== NULL
)
357 mnt
= ERR_PTR(-ENOENT
);
359 parent
= dget_parent(dentry
);
360 dprintk("%s: getting locations for %s/%s\n",
361 __func__
, parent
->d_name
.name
, dentry
->d_name
.name
);
363 err
= nfs4_proc_fs_locations(client
, parent
->d_inode
, &dentry
->d_name
, fs_locations
, page
);
366 fs_locations
->nlocations
<= 0 ||
367 fs_locations
->fs_path
.ncomponents
<= 0)
370 mnt
= nfs_follow_referral(dentry
, fs_locations
);
375 dprintk("%s: done\n", __func__
);
379 struct vfsmount
*nfs4_submount(struct nfs_server
*server
, struct dentry
*dentry
,
380 struct nfs_fh
*fh
, struct nfs_fattr
*fattr
)
382 rpc_authflavor_t flavor
= server
->client
->cl_auth
->au_flavor
;
383 struct dentry
*parent
= dget_parent(dentry
);
384 struct inode
*dir
= parent
->d_inode
;
385 struct qstr
*name
= &dentry
->d_name
;
386 struct rpc_clnt
*client
;
387 struct vfsmount
*mnt
;
389 /* Look it up again to get its attributes and sec flavor */
390 client
= nfs4_proc_lookup_mountpoint(dir
, name
, fh
, fattr
);
393 return ERR_CAST(client
);
395 if (fattr
->valid
& NFS_ATTR_FATTR_V4_REFERRAL
) {
396 mnt
= nfs_do_refmount(client
, dentry
);
400 if (client
->cl_auth
->au_flavor
!= flavor
)
401 flavor
= client
->cl_auth
->au_flavor
;
403 rpc_authflavor_t
new = nfs4_negotiate_security(dir
, name
);
407 mnt
= nfs_do_submount(dentry
, fh
, fattr
, flavor
);
409 rpc_shutdown_client(client
);
414 * Try one location from the fs_locations array.
416 * Returns zero on success, or a negative errno value.
418 static int nfs4_try_replacing_one_location(struct nfs_server
*server
,
419 char *page
, char *page2
,
420 const struct nfs4_fs_location
*location
)
422 const size_t addr_bufsize
= sizeof(struct sockaddr_storage
);
423 struct sockaddr
*sap
;
428 sap
= kmalloc(addr_bufsize
, GFP_KERNEL
);
433 for (s
= 0; s
< location
->nservers
; s
++) {
434 const struct nfs4_string
*buf
= &location
->servers
[s
];
437 if (buf
->len
<= 0 || buf
->len
> PAGE_SIZE
)
440 if (memchr(buf
->data
, IPV6_SCOPE_DELIMITER
, buf
->len
) != NULL
)
443 salen
= nfs_parse_server_name(buf
->data
, buf
->len
,
444 sap
, addr_bufsize
, server
);
447 rpc_set_port(sap
, NFS_PORT
);
450 hostname
= kstrndup(buf
->data
, buf
->len
, GFP_KERNEL
);
451 if (hostname
== NULL
)
454 error
= nfs4_update_server(server
, hostname
, sap
, salen
);
465 * nfs4_replace_transport - set up transport to destination server
467 * @server: export being migrated
468 * @locations: fs_locations array
470 * Returns zero on success, or a negative errno value.
472 * The client tries all the entries in the "locations" array, in the
473 * order returned by the server, until one works or the end of the
476 int nfs4_replace_transport(struct nfs_server
*server
,
477 const struct nfs4_fs_locations
*locations
)
479 char *page
= NULL
, *page2
= NULL
;
483 if (locations
== NULL
|| locations
->nlocations
<= 0)
487 page
= (char *) __get_free_page(GFP_USER
);
490 page2
= (char *) __get_free_page(GFP_USER
);
494 for (loc
= 0; loc
< locations
->nlocations
; loc
++) {
495 const struct nfs4_fs_location
*location
=
496 &locations
->locations
[loc
];
498 if (location
== NULL
|| location
->nservers
<= 0 ||
499 location
->rootpath
.ncomponents
== 0)
502 error
= nfs4_try_replacing_one_location(server
, page
,
509 free_page((unsigned long)page
);
510 free_page((unsigned long)page2
);