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/slab.h>
15 #include <linux/string.h>
16 #include <linux/sunrpc/clnt.h>
17 #include <linux/vfs.h>
18 #include <linux/inet.h>
21 #include "dns_resolve.h"
23 #define NFSDBG_FACILITY NFSDBG_VFS
26 * Convert the NFSv4 pathname components into a standard posix path.
28 * Note that the resulting string will be placed at the end of the buffer
30 static inline char *nfs4_pathname_string(const struct nfs4_pathname
*pathname
,
31 char *buffer
, ssize_t buflen
)
33 char *end
= buffer
+ buflen
;
39 n
= pathname
->ncomponents
;
41 const struct nfs4_string
*component
= &pathname
->components
[n
];
42 buflen
-= component
->len
+ 1;
45 end
-= component
->len
;
46 memcpy(end
, component
->data
, component
->len
);
51 return ERR_PTR(-ENAMETOOLONG
);
55 * return the path component of "<server>:<path>"
56 * nfspath - the "<server>:<path>" string
57 * end - one past the last char that could contain "<server>:"
58 * returns NULL on failure
60 static char *nfs_path_component(const char *nfspath
, const char *end
)
64 if (*nfspath
== '[') {
65 /* parse [] escaped IPv6 addrs */
66 p
= strchr(nfspath
, ']');
67 if (p
!= NULL
&& ++p
< end
&& *p
== ':')
70 /* otherwise split on first colon */
71 p
= strchr(nfspath
, ':');
72 if (p
!= NULL
&& p
< end
)
79 * Determine the mount path as a string
81 static char *nfs4_path(struct dentry
*dentry
, char *buffer
, ssize_t buflen
)
84 char *path
= nfs_path(&limit
, dentry
, buffer
, buflen
);
86 char *path_component
= nfs_path_component(path
, limit
);
88 return path_component
;
94 * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
95 * believe to be the server path to this dentry
97 static int nfs4_validate_fspath(struct dentry
*dentry
,
98 const struct nfs4_fs_locations
*locations
,
99 char *page
, char *page2
)
101 const char *path
, *fs_path
;
103 path
= nfs4_path(dentry
, page
, PAGE_SIZE
);
105 return PTR_ERR(path
);
107 fs_path
= nfs4_pathname_string(&locations
->fs_path
, page2
, PAGE_SIZE
);
109 return PTR_ERR(fs_path
);
111 if (strncmp(path
, fs_path
, strlen(fs_path
)) != 0) {
112 dprintk("%s: path %s does not begin with fsroot %s\n",
113 __func__
, path
, fs_path
);
120 static size_t nfs_parse_server_name(char *string
, size_t len
,
121 struct sockaddr
*sa
, size_t salen
, struct nfs_server
*server
)
123 struct net
*net
= rpc_net_ns(server
->client
);
126 ret
= rpc_pton(net
, string
, len
, sa
, salen
);
128 ret
= nfs_dns_resolve_name(net
, string
, len
, sa
, salen
);
135 rpc_authflavor_t
nfs_find_best_sec(struct nfs4_secinfo_flavors
*flavors
)
137 struct gss_api_mech
*mech
;
138 struct xdr_netobj oid
;
140 rpc_authflavor_t pseudoflavor
= RPC_AUTH_UNIX
;
142 for (i
= 0; i
< flavors
->num_flavors
; i
++) {
143 struct nfs4_secinfo_flavor
*flavor
;
144 flavor
= &flavors
->flavors
[i
];
146 if (flavor
->flavor
== RPC_AUTH_NULL
|| flavor
->flavor
== RPC_AUTH_UNIX
) {
147 pseudoflavor
= flavor
->flavor
;
149 } else if (flavor
->flavor
== RPC_AUTH_GSS
) {
150 oid
.len
= flavor
->gss
.sec_oid4
.len
;
151 oid
.data
= flavor
->gss
.sec_oid4
.data
;
152 mech
= gss_mech_get_by_OID(&oid
);
155 pseudoflavor
= gss_svc_to_pseudoflavor(mech
, flavor
->gss
.service
);
164 static rpc_authflavor_t
nfs4_negotiate_security(struct inode
*inode
, struct qstr
*name
)
167 struct nfs4_secinfo_flavors
*flavors
;
168 rpc_authflavor_t flavor
;
171 page
= alloc_page(GFP_KERNEL
);
174 flavors
= page_address(page
);
176 err
= nfs4_proc_secinfo(inode
, name
, flavors
);
182 flavor
= nfs_find_best_sec(flavors
);
190 * Please call rpc_shutdown_client() when you are done with this client.
192 struct rpc_clnt
*nfs4_create_sec_client(struct rpc_clnt
*clnt
, struct inode
*inode
,
195 rpc_authflavor_t flavor
;
197 flavor
= nfs4_negotiate_security(inode
, name
);
199 return ERR_PTR((int)flavor
);
201 return rpc_clone_client_set_auth(clnt
, flavor
);
204 static struct vfsmount
*try_location(struct nfs_clone_mount
*mountdata
,
205 char *page
, char *page2
,
206 const struct nfs4_fs_location
*location
)
208 const size_t addr_bufsize
= sizeof(struct sockaddr_storage
);
209 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
211 unsigned int maxbuflen
;
214 mnt_path
= nfs4_pathname_string(&location
->rootpath
, page2
, PAGE_SIZE
);
215 if (IS_ERR(mnt_path
))
216 return ERR_CAST(mnt_path
);
217 mountdata
->mnt_path
= mnt_path
;
218 maxbuflen
= mnt_path
- 1 - page2
;
220 mountdata
->addr
= kmalloc(addr_bufsize
, GFP_KERNEL
);
221 if (mountdata
->addr
== NULL
)
222 return ERR_PTR(-ENOMEM
);
224 for (s
= 0; s
< location
->nservers
; s
++) {
225 const struct nfs4_string
*buf
= &location
->servers
[s
];
227 if (buf
->len
<= 0 || buf
->len
>= maxbuflen
)
230 if (memchr(buf
->data
, IPV6_SCOPE_DELIMITER
, buf
->len
))
233 mountdata
->addrlen
= nfs_parse_server_name(buf
->data
, buf
->len
,
234 mountdata
->addr
, addr_bufsize
,
235 NFS_SB(mountdata
->sb
));
236 if (mountdata
->addrlen
== 0)
239 rpc_set_port(mountdata
->addr
, NFS_PORT
);
241 memcpy(page2
, buf
->data
, buf
->len
);
242 page2
[buf
->len
] = '\0';
243 mountdata
->hostname
= page2
;
245 snprintf(page
, PAGE_SIZE
, "%s:%s",
247 mountdata
->mnt_path
);
249 mnt
= vfs_kern_mount(&nfs4_referral_fs_type
, 0, page
, mountdata
);
253 kfree(mountdata
->addr
);
258 * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
259 * @dentry - parent directory
260 * @locations - array of NFSv4 server location information
263 static struct vfsmount
*nfs_follow_referral(struct dentry
*dentry
,
264 const struct nfs4_fs_locations
*locations
)
266 struct vfsmount
*mnt
= ERR_PTR(-ENOENT
);
267 struct nfs_clone_mount mountdata
= {
270 .authflavor
= NFS_SB(dentry
->d_sb
)->client
->cl_auth
->au_flavor
,
272 char *page
= NULL
, *page2
= NULL
;
275 if (locations
== NULL
|| locations
->nlocations
<= 0)
278 dprintk("%s: referral at %s/%s\n", __func__
,
279 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
281 page
= (char *) __get_free_page(GFP_USER
);
285 page2
= (char *) __get_free_page(GFP_USER
);
289 /* Ensure fs path is a prefix of current dentry path */
290 error
= nfs4_validate_fspath(dentry
, locations
, page
, page2
);
292 mnt
= ERR_PTR(error
);
296 for (loc
= 0; loc
< locations
->nlocations
; loc
++) {
297 const struct nfs4_fs_location
*location
= &locations
->locations
[loc
];
299 if (location
== NULL
|| location
->nservers
<= 0 ||
300 location
->rootpath
.ncomponents
== 0)
303 mnt
= try_location(&mountdata
, page
, page2
, location
);
309 free_page((unsigned long) page
);
310 free_page((unsigned long) page2
);
311 dprintk("%s: done\n", __func__
);
316 * nfs_do_refmount - handle crossing a referral on server
317 * @dentry - dentry of referral
320 static struct vfsmount
*nfs_do_refmount(struct rpc_clnt
*client
, struct dentry
*dentry
)
322 struct vfsmount
*mnt
= ERR_PTR(-ENOMEM
);
323 struct dentry
*parent
;
324 struct nfs4_fs_locations
*fs_locations
= NULL
;
328 /* BUG_ON(IS_ROOT(dentry)); */
329 dprintk("%s: enter\n", __func__
);
331 page
= alloc_page(GFP_KERNEL
);
335 fs_locations
= kmalloc(sizeof(struct nfs4_fs_locations
), GFP_KERNEL
);
336 if (fs_locations
== NULL
)
340 mnt
= ERR_PTR(-ENOENT
);
342 parent
= dget_parent(dentry
);
343 dprintk("%s: getting locations for %s/%s\n",
344 __func__
, parent
->d_name
.name
, dentry
->d_name
.name
);
346 err
= nfs4_proc_fs_locations(client
, parent
->d_inode
, &dentry
->d_name
, fs_locations
, page
);
349 fs_locations
->nlocations
<= 0 ||
350 fs_locations
->fs_path
.ncomponents
<= 0)
353 mnt
= nfs_follow_referral(dentry
, fs_locations
);
358 dprintk("%s: done\n", __func__
);
362 struct vfsmount
*nfs4_submount(struct nfs_server
*server
, struct dentry
*dentry
,
363 struct nfs_fh
*fh
, struct nfs_fattr
*fattr
)
365 struct dentry
*parent
= dget_parent(dentry
);
366 struct rpc_clnt
*client
;
367 struct vfsmount
*mnt
;
369 /* Look it up again to get its attributes and sec flavor */
370 client
= nfs4_proc_lookup_mountpoint(parent
->d_inode
, &dentry
->d_name
, fh
, fattr
);
373 return ERR_CAST(client
);
375 if (fattr
->valid
& NFS_ATTR_FATTR_V4_REFERRAL
)
376 mnt
= nfs_do_refmount(client
, dentry
);
378 mnt
= nfs_do_submount(dentry
, fh
, fattr
, client
->cl_auth
->au_flavor
);
380 rpc_shutdown_client(client
);