Commit | Line | Data |
---|---|---|
f7b422b1 DH |
1 | /* |
2 | * linux/fs/nfs/nfs4namespace.c | |
3 | * | |
4 | * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com> | |
54ceac45 | 5 | * - Modified by David Howells <dhowells@redhat.com> |
f7b422b1 DH |
6 | * |
7 | * NFSv4 namespace | |
8 | */ | |
9 | ||
f7b422b1 DH |
10 | #include <linux/dcache.h> |
11 | #include <linux/mount.h> | |
12 | #include <linux/namei.h> | |
13 | #include <linux/nfs_fs.h> | |
14 | #include <linux/string.h> | |
15 | #include <linux/sunrpc/clnt.h> | |
16 | #include <linux/vfs.h> | |
17 | #include <linux/inet.h> | |
18 | #include "internal.h" | |
c228fd3a | 19 | #include "nfs4_fs.h" |
7d7ea882 | 20 | #include "dns_resolve.h" |
f7b422b1 DH |
21 | |
22 | #define NFSDBG_FACILITY NFSDBG_VFS | |
23 | ||
24 | /* | |
ef95d31e TM |
25 | * Convert the NFSv4 pathname components into a standard posix path. |
26 | * | |
27 | * Note that the resulting string will be placed at the end of the buffer | |
f7b422b1 | 28 | */ |
509de811 | 29 | static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname, |
f7b422b1 DH |
30 | char *buffer, ssize_t buflen) |
31 | { | |
32 | char *end = buffer + buflen; | |
33 | int n; | |
34 | ||
35 | *--end = '\0'; | |
36 | buflen--; | |
37 | ||
38 | n = pathname->ncomponents; | |
39 | while (--n >= 0) { | |
509de811 | 40 | const struct nfs4_string *component = &pathname->components[n]; |
f7b422b1 DH |
41 | buflen -= component->len + 1; |
42 | if (buflen < 0) | |
43 | goto Elong; | |
44 | end -= component->len; | |
45 | memcpy(end, component->data, component->len); | |
46 | *--end = '/'; | |
47 | } | |
48 | return end; | |
49 | Elong: | |
50 | return ERR_PTR(-ENAMETOOLONG); | |
51 | } | |
52 | ||
54ceac45 DH |
53 | /* |
54 | * Determine the mount path as a string | |
55 | */ | |
56 | static char *nfs4_path(const struct vfsmount *mnt_parent, | |
57 | const struct dentry *dentry, | |
58 | char *buffer, ssize_t buflen) | |
59 | { | |
60 | const char *srvpath; | |
61 | ||
62 | srvpath = strchr(mnt_parent->mnt_devname, ':'); | |
63 | if (srvpath) | |
64 | srvpath++; | |
65 | else | |
66 | srvpath = mnt_parent->mnt_devname; | |
67 | ||
68 | return nfs_path(srvpath, mnt_parent->mnt_root, dentry, buffer, buflen); | |
69 | } | |
70 | ||
71 | /* | |
72 | * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we | |
73 | * believe to be the server path to this dentry | |
74 | */ | |
75 | static int nfs4_validate_fspath(const struct vfsmount *mnt_parent, | |
76 | const struct dentry *dentry, | |
77 | const struct nfs4_fs_locations *locations, | |
78 | char *page, char *page2) | |
79 | { | |
80 | const char *path, *fs_path; | |
81 | ||
82 | path = nfs4_path(mnt_parent, dentry, page, PAGE_SIZE); | |
83 | if (IS_ERR(path)) | |
84 | return PTR_ERR(path); | |
85 | ||
86 | fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE); | |
87 | if (IS_ERR(fs_path)) | |
88 | return PTR_ERR(fs_path); | |
89 | ||
90 | if (strncmp(path, fs_path, strlen(fs_path)) != 0) { | |
91 | dprintk("%s: path %s does not begin with fsroot %s\n", | |
3110ff80 | 92 | __func__, path, fs_path); |
54ceac45 DH |
93 | return -ENOENT; |
94 | } | |
95 | ||
96 | return 0; | |
97 | } | |
98 | ||
7d7ea882 TM |
99 | static size_t nfs_parse_server_name(char *string, size_t len, |
100 | struct sockaddr *sa, size_t salen) | |
101 | { | |
102 | ssize_t ret; | |
103 | ||
104 | ret = rpc_pton(string, len, sa, salen); | |
105 | if (ret == 0) { | |
106 | ret = nfs_dns_resolve_name(string, len, sa, salen); | |
107 | if (ret < 0) | |
108 | ret = 0; | |
109 | } | |
110 | return ret; | |
111 | } | |
112 | ||
4ada29d5 BF |
113 | static struct vfsmount *try_location(struct nfs_clone_mount *mountdata, |
114 | char *page, char *page2, | |
115 | const struct nfs4_fs_location *location) | |
116 | { | |
117 | struct vfsmount *mnt = ERR_PTR(-ENOENT); | |
118 | char *mnt_path; | |
ef95d31e | 119 | unsigned int maxbuflen; |
460cdbc8 | 120 | unsigned int s; |
4ada29d5 BF |
121 | |
122 | mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE); | |
123 | if (IS_ERR(mnt_path)) | |
517be09d | 124 | return ERR_CAST(mnt_path); |
4ada29d5 | 125 | mountdata->mnt_path = mnt_path; |
ef95d31e | 126 | maxbuflen = mnt_path - 1 - page2; |
4ada29d5 | 127 | |
460cdbc8 | 128 | for (s = 0; s < location->nservers; s++) { |
ea31a443 BF |
129 | const struct nfs4_string *buf = &location->servers[s]; |
130 | struct sockaddr_storage addr; | |
4ada29d5 | 131 | |
ef95d31e | 132 | if (buf->len <= 0 || buf->len >= maxbuflen) |
4ada29d5 | 133 | continue; |
4ada29d5 | 134 | |
ea31a443 BF |
135 | if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len)) |
136 | continue; | |
517be09d TM |
137 | |
138 | mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len, | |
139 | (struct sockaddr *)&addr, sizeof(addr)); | |
53a0b9c4 | 140 | if (mountdata->addrlen == 0) |
ea31a443 | 141 | continue; |
517be09d TM |
142 | |
143 | mountdata->addr = (struct sockaddr *)&addr; | |
ec6ee612 | 144 | rpc_set_port(mountdata->addr, NFS_PORT); |
ea31a443 | 145 | |
ef95d31e TM |
146 | memcpy(page2, buf->data, buf->len); |
147 | page2[buf->len] = '\0'; | |
ea31a443 | 148 | mountdata->hostname = page2; |
4ada29d5 BF |
149 | |
150 | snprintf(page, PAGE_SIZE, "%s:%s", | |
151 | mountdata->hostname, | |
152 | mountdata->mnt_path); | |
153 | ||
154 | mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata); | |
155 | if (!IS_ERR(mnt)) | |
156 | break; | |
4ada29d5 BF |
157 | } |
158 | return mnt; | |
159 | } | |
160 | ||
f7b422b1 DH |
161 | /** |
162 | * nfs_follow_referral - set up mountpoint when hitting a referral on moved error | |
163 | * @mnt_parent - mountpoint of parent directory | |
164 | * @dentry - parent directory | |
3f43c666 | 165 | * @locations - array of NFSv4 server location information |
f7b422b1 DH |
166 | * |
167 | */ | |
168 | static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent, | |
169 | const struct dentry *dentry, | |
509de811 | 170 | const struct nfs4_fs_locations *locations) |
f7b422b1 DH |
171 | { |
172 | struct vfsmount *mnt = ERR_PTR(-ENOENT); | |
173 | struct nfs_clone_mount mountdata = { | |
174 | .sb = mnt_parent->mnt_sb, | |
175 | .dentry = dentry, | |
176 | .authflavor = NFS_SB(mnt_parent->mnt_sb)->client->cl_auth->au_flavor, | |
177 | }; | |
54ceac45 | 178 | char *page = NULL, *page2 = NULL; |
3f43c666 | 179 | int loc, error; |
f7b422b1 DH |
180 | |
181 | if (locations == NULL || locations->nlocations <= 0) | |
182 | goto out; | |
183 | ||
3110ff80 | 184 | dprintk("%s: referral at %s/%s\n", __func__, |
f7b422b1 DH |
185 | dentry->d_parent->d_name.name, dentry->d_name.name); |
186 | ||
f7b422b1 | 187 | page = (char *) __get_free_page(GFP_USER); |
54ceac45 | 188 | if (!page) |
f7b422b1 | 189 | goto out; |
54ceac45 | 190 | |
f7b422b1 | 191 | page2 = (char *) __get_free_page(GFP_USER); |
54ceac45 | 192 | if (!page2) |
f7b422b1 DH |
193 | goto out; |
194 | ||
54ceac45 DH |
195 | /* Ensure fs path is a prefix of current dentry path */ |
196 | error = nfs4_validate_fspath(mnt_parent, dentry, locations, page, page2); | |
197 | if (error < 0) { | |
198 | mnt = ERR_PTR(error); | |
199 | goto out; | |
f7b422b1 DH |
200 | } |
201 | ||
460cdbc8 | 202 | for (loc = 0; loc < locations->nlocations; loc++) { |
509de811 | 203 | const struct nfs4_fs_location *location = &locations->locations[loc]; |
f7b422b1 DH |
204 | |
205 | if (location == NULL || location->nservers <= 0 || | |
460cdbc8 | 206 | location->rootpath.ncomponents == 0) |
f7b422b1 | 207 | continue; |
f7b422b1 | 208 | |
4ada29d5 BF |
209 | mnt = try_location(&mountdata, page, page2, location); |
210 | if (!IS_ERR(mnt)) | |
211 | break; | |
f7b422b1 DH |
212 | } |
213 | ||
f7b422b1 | 214 | out: |
54ceac45 DH |
215 | free_page((unsigned long) page); |
216 | free_page((unsigned long) page2); | |
3110ff80 | 217 | dprintk("%s: done\n", __func__); |
f7b422b1 DH |
218 | return mnt; |
219 | } | |
220 | ||
221 | /* | |
222 | * nfs_do_refmount - handle crossing a referral on server | |
223 | * @dentry - dentry of referral | |
224 | * @nd - nameidata info | |
225 | * | |
226 | */ | |
227 | struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry) | |
228 | { | |
54ceac45 | 229 | struct vfsmount *mnt = ERR_PTR(-ENOMEM); |
f7b422b1 DH |
230 | struct dentry *parent; |
231 | struct nfs4_fs_locations *fs_locations = NULL; | |
232 | struct page *page; | |
233 | int err; | |
234 | ||
235 | /* BUG_ON(IS_ROOT(dentry)); */ | |
3110ff80 | 236 | dprintk("%s: enter\n", __func__); |
f7b422b1 DH |
237 | |
238 | page = alloc_page(GFP_KERNEL); | |
239 | if (page == NULL) | |
240 | goto out; | |
241 | ||
242 | fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); | |
243 | if (fs_locations == NULL) | |
244 | goto out_free; | |
245 | ||
246 | /* Get locations */ | |
54ceac45 DH |
247 | mnt = ERR_PTR(-ENOENT); |
248 | ||
f7b422b1 | 249 | parent = dget_parent(dentry); |
54ceac45 | 250 | dprintk("%s: getting locations for %s/%s\n", |
3110ff80 | 251 | __func__, parent->d_name.name, dentry->d_name.name); |
54ceac45 | 252 | |
c228fd3a | 253 | err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page); |
f7b422b1 | 254 | dput(parent); |
54ceac45 DH |
255 | if (err != 0 || |
256 | fs_locations->nlocations <= 0 || | |
f7b422b1 DH |
257 | fs_locations->fs_path.ncomponents <= 0) |
258 | goto out_free; | |
259 | ||
260 | mnt = nfs_follow_referral(mnt_parent, dentry, fs_locations); | |
261 | out_free: | |
262 | __free_page(page); | |
263 | kfree(fs_locations); | |
264 | out: | |
3110ff80 | 265 | dprintk("%s: done\n", __func__); |
f7b422b1 DH |
266 | return mnt; |
267 | } |