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 * @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 rpc_authflavor_t
nfs_find_best_sec(struct nfs4_secinfo_flavors
*flavors
)
150 rpc_authflavor_t pseudoflavor
;
151 struct nfs4_secinfo4
*secinfo
;
154 for (i
= 0; i
< flavors
->num_flavors
; i
++) {
155 secinfo
= &flavors
->flavors
[i
];
157 switch (secinfo
->flavor
) {
161 pseudoflavor
= rpcauth_get_pseudoflavor(secinfo
->flavor
,
162 &secinfo
->flavor_info
);
163 if (pseudoflavor
!= RPC_AUTH_MAXFLAVOR
)
169 return RPC_AUTH_UNIX
;
172 static rpc_authflavor_t
nfs4_negotiate_security(struct inode
*inode
, struct qstr
*name
)
175 struct nfs4_secinfo_flavors
*flavors
;
176 rpc_authflavor_t flavor
;
179 page
= alloc_page(GFP_KERNEL
);
182 flavors
= page_address(page
);
184 err
= nfs4_proc_secinfo(inode
, name
, flavors
);
190 flavor
= nfs_find_best_sec(flavors
);
198 * Please call rpc_shutdown_client() when you are done with this client.
200 struct rpc_clnt
*nfs4_create_sec_client(struct rpc_clnt
*clnt
, struct inode
*inode
,
203 rpc_authflavor_t flavor
;
205 flavor
= nfs4_negotiate_security(inode
, name
);
207 return ERR_PTR((int)flavor
);
209 return rpc_clone_client_set_auth(clnt
, flavor
);
212 static struct vfsmount
*try_location(struct nfs_clone_mount
*mountdata
,
213 char *page
, char *page2
,
214 const struct nfs4_fs_location
*location
)
216 const size_t addr_bufsize
= sizeof(struct sockaddr_storage
);
217 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
219 unsigned int maxbuflen
;
222 mnt_path
= nfs4_pathname_string(&location
->rootpath
, page2
, PAGE_SIZE
);
223 if (IS_ERR(mnt_path
))
224 return ERR_CAST(mnt_path
);
225 mountdata
->mnt_path
= mnt_path
;
226 maxbuflen
= mnt_path
- 1 - page2
;
228 mountdata
->addr
= kmalloc(addr_bufsize
, GFP_KERNEL
);
229 if (mountdata
->addr
== NULL
)
230 return ERR_PTR(-ENOMEM
);
232 for (s
= 0; s
< location
->nservers
; s
++) {
233 const struct nfs4_string
*buf
= &location
->servers
[s
];
235 if (buf
->len
<= 0 || buf
->len
>= maxbuflen
)
238 if (memchr(buf
->data
, IPV6_SCOPE_DELIMITER
, buf
->len
))
241 mountdata
->addrlen
= nfs_parse_server_name(buf
->data
, buf
->len
,
242 mountdata
->addr
, addr_bufsize
,
243 NFS_SB(mountdata
->sb
));
244 if (mountdata
->addrlen
== 0)
247 rpc_set_port(mountdata
->addr
, NFS_PORT
);
249 memcpy(page2
, buf
->data
, buf
->len
);
250 page2
[buf
->len
] = '\0';
251 mountdata
->hostname
= page2
;
253 snprintf(page
, PAGE_SIZE
, "%s:%s",
255 mountdata
->mnt_path
);
257 mnt
= vfs_kern_mount(&nfs4_referral_fs_type
, 0, page
, mountdata
);
261 kfree(mountdata
->addr
);
266 * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
267 * @dentry - parent directory
268 * @locations - array of NFSv4 server location information
271 static struct vfsmount
*nfs_follow_referral(struct dentry
*dentry
,
272 const struct nfs4_fs_locations
*locations
)
274 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
275 struct nfs_clone_mount mountdata
= {
278 .authflavor
= NFS_SB(dentry
->d_sb
)->client
->cl_auth
->au_flavor
,
280 char *page
= NULL
, *page2
= NULL
;
283 if (locations
== NULL
|| locations
->nlocations
<= 0)
286 dprintk("%s: referral at %s/%s\n", __func__
,
287 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
289 page
= (char *) __get_free_page(GFP_USER
);
293 page2
= (char *) __get_free_page(GFP_USER
);
297 /* Ensure fs path is a prefix of current dentry path */
298 error
= nfs4_validate_fspath(dentry
, locations
, page
, page2
);
300 mnt
= ERR_PTR(error
);
304 for (loc
= 0; loc
< locations
->nlocations
; loc
++) {
305 const struct nfs4_fs_location
*location
= &locations
->locations
[loc
];
307 if (location
== NULL
|| location
->nservers
<= 0 ||
308 location
->rootpath
.ncomponents
== 0)
311 mnt
= try_location(&mountdata
, page
, page2
, location
);
317 free_page((unsigned long) page
);
318 free_page((unsigned long) page2
);
319 dprintk("%s: done\n", __func__
);
324 * nfs_do_refmount - handle crossing a referral on server
325 * @dentry - dentry of referral
328 static struct vfsmount
*nfs_do_refmount(struct rpc_clnt
*client
, struct dentry
*dentry
)
330 struct vfsmount
*mnt
= ERR_PTR(-ENOMEM
);
331 struct dentry
*parent
;
332 struct nfs4_fs_locations
*fs_locations
= NULL
;
336 /* BUG_ON(IS_ROOT(dentry)); */
337 dprintk("%s: enter\n", __func__
);
339 page
= alloc_page(GFP_KERNEL
);
343 fs_locations
= kmalloc(sizeof(struct nfs4_fs_locations
), GFP_KERNEL
);
344 if (fs_locations
== NULL
)
348 mnt
= ERR_PTR(-ENOENT
);
350 parent
= dget_parent(dentry
);
351 dprintk("%s: getting locations for %s/%s\n",
352 __func__
, parent
->d_name
.name
, dentry
->d_name
.name
);
354 err
= nfs4_proc_fs_locations(client
, parent
->d_inode
, &dentry
->d_name
, fs_locations
, page
);
357 fs_locations
->nlocations
<= 0 ||
358 fs_locations
->fs_path
.ncomponents
<= 0)
361 mnt
= nfs_follow_referral(dentry
, fs_locations
);
366 dprintk("%s: done\n", __func__
);
370 struct vfsmount
*nfs4_submount(struct nfs_server
*server
, struct dentry
*dentry
,
371 struct nfs_fh
*fh
, struct nfs_fattr
*fattr
)
373 rpc_authflavor_t flavor
= server
->client
->cl_auth
->au_flavor
;
374 struct dentry
*parent
= dget_parent(dentry
);
375 struct inode
*dir
= parent
->d_inode
;
376 struct qstr
*name
= &dentry
->d_name
;
377 struct rpc_clnt
*client
;
378 struct vfsmount
*mnt
;
380 /* Look it up again to get its attributes and sec flavor */
381 client
= nfs4_proc_lookup_mountpoint(dir
, name
, fh
, fattr
);
384 return ERR_CAST(client
);
386 if (fattr
->valid
& NFS_ATTR_FATTR_V4_REFERRAL
) {
387 mnt
= nfs_do_refmount(client
, dentry
);
391 if (client
->cl_auth
->au_flavor
!= flavor
)
392 flavor
= client
->cl_auth
->au_flavor
;
393 else if (!(server
->flags
& NFS_MOUNT_SECFLAVOUR
)) {
394 rpc_authflavor_t
new = nfs4_negotiate_security(dir
, name
);
398 mnt
= nfs_do_submount(dentry
, fh
, fattr
, flavor
);
400 rpc_shutdown_client(client
);