1
2
3
4
5
6
7
8
9
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>
19#include "internal.h"
20#include "nfs4_fs.h"
21#include "dns_resolve.h"
22
23#define NFSDBG_FACILITY NFSDBG_VFS
24
25
26
27
28
29
30static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
31 char *buffer, ssize_t buflen)
32{
33 char *end = buffer + buflen;
34 int n;
35
36 *--end = '\0';
37 buflen--;
38
39 n = pathname->ncomponents;
40 while (--n >= 0) {
41 const struct nfs4_string *component = &pathname->components[n];
42 buflen -= component->len + 1;
43 if (buflen < 0)
44 goto Elong;
45 end -= component->len;
46 memcpy(end, component->data, component->len);
47 *--end = '/';
48 }
49 return end;
50Elong:
51 return ERR_PTR(-ENAMETOOLONG);
52}
53
54
55
56
57static char *nfs4_path(const struct vfsmount *mnt_parent,
58 const struct dentry *dentry,
59 char *buffer, ssize_t buflen)
60{
61 const char *srvpath;
62
63 srvpath = strchr(mnt_parent->mnt_devname, ':');
64 if (srvpath)
65 srvpath++;
66 else
67 srvpath = mnt_parent->mnt_devname;
68
69 return nfs_path(srvpath, mnt_parent->mnt_root, dentry, buffer, buflen);
70}
71
72
73
74
75
76static int nfs4_validate_fspath(const struct vfsmount *mnt_parent,
77 const struct dentry *dentry,
78 const struct nfs4_fs_locations *locations,
79 char *page, char *page2)
80{
81 const char *path, *fs_path;
82
83 path = nfs4_path(mnt_parent, dentry, page, PAGE_SIZE);
84 if (IS_ERR(path))
85 return PTR_ERR(path);
86
87 fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
88 if (IS_ERR(fs_path))
89 return PTR_ERR(fs_path);
90
91 if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
92 dprintk("%s: path %s does not begin with fsroot %s\n",
93 __func__, path, fs_path);
94 return -ENOENT;
95 }
96
97 return 0;
98}
99
100static size_t nfs_parse_server_name(char *string, size_t len,
101 struct sockaddr *sa, size_t salen)
102{
103 ssize_t ret;
104
105 ret = rpc_pton(string, len, sa, salen);
106 if (ret == 0) {
107 ret = nfs_dns_resolve_name(string, len, sa, salen);
108 if (ret < 0)
109 ret = 0;
110 }
111 return ret;
112}
113
114static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
115 char *page, char *page2,
116 const struct nfs4_fs_location *location)
117{
118 const size_t addr_bufsize = sizeof(struct sockaddr_storage);
119 struct vfsmount *mnt = ERR_PTR(-ENOENT);
120 char *mnt_path;
121 unsigned int maxbuflen;
122 unsigned int s;
123
124 mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
125 if (IS_ERR(mnt_path))
126 return ERR_CAST(mnt_path);
127 mountdata->mnt_path = mnt_path;
128 maxbuflen = mnt_path - 1 - page2;
129
130 mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
131 if (mountdata->addr == NULL)
132 return ERR_PTR(-ENOMEM);
133
134 for (s = 0; s < location->nservers; s++) {
135 const struct nfs4_string *buf = &location->servers[s];
136
137 if (buf->len <= 0 || buf->len >= maxbuflen)
138 continue;
139
140 if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
141 continue;
142
143 mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
144 mountdata->addr, addr_bufsize);
145 if (mountdata->addrlen == 0)
146 continue;
147
148 rpc_set_port(mountdata->addr, NFS_PORT);
149
150 memcpy(page2, buf->data, buf->len);
151 page2[buf->len] = '\0';
152 mountdata->hostname = page2;
153
154 snprintf(page, PAGE_SIZE, "%s:%s",
155 mountdata->hostname,
156 mountdata->mnt_path);
157
158 mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
159 if (!IS_ERR(mnt))
160 break;
161 }
162 kfree(mountdata->addr);
163 return mnt;
164}
165
166
167
168
169
170
171
172
173static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
174 const struct dentry *dentry,
175 const struct nfs4_fs_locations *locations)
176{
177 struct vfsmount *mnt = ERR_PTR(-ENOENT);
178 struct nfs_clone_mount mountdata = {
179 .sb = mnt_parent->mnt_sb,
180 .dentry = dentry,
181 .authflavor = NFS_SB(mnt_parent->mnt_sb)->client->cl_auth->au_flavor,
182 };
183 char *page = NULL, *page2 = NULL;
184 int loc, error;
185
186 if (locations == NULL || locations->nlocations <= 0)
187 goto out;
188
189 dprintk("%s: referral at %s/%s\n", __func__,
190 dentry->d_parent->d_name.name, dentry->d_name.name);
191
192 page = (char *) __get_free_page(GFP_USER);
193 if (!page)
194 goto out;
195
196 page2 = (char *) __get_free_page(GFP_USER);
197 if (!page2)
198 goto out;
199
200
201 error = nfs4_validate_fspath(mnt_parent, dentry, locations, page, page2);
202 if (error < 0) {
203 mnt = ERR_PTR(error);
204 goto out;
205 }
206
207 for (loc = 0; loc < locations->nlocations; loc++) {
208 const struct nfs4_fs_location *location = &locations->locations[loc];
209
210 if (location == NULL || location->nservers <= 0 ||
211 location->rootpath.ncomponents == 0)
212 continue;
213
214 mnt = try_location(&mountdata, page, page2, location);
215 if (!IS_ERR(mnt))
216 break;
217 }
218
219out:
220 free_page((unsigned long) page);
221 free_page((unsigned long) page2);
222 dprintk("%s: done\n", __func__);
223 return mnt;
224}
225
226
227
228
229
230
231
232struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
233{
234 struct vfsmount *mnt = ERR_PTR(-ENOMEM);
235 struct dentry *parent;
236 struct nfs4_fs_locations *fs_locations = NULL;
237 struct page *page;
238 int err;
239
240
241 dprintk("%s: enter\n", __func__);
242
243 page = alloc_page(GFP_KERNEL);
244 if (page == NULL)
245 goto out;
246
247 fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
248 if (fs_locations == NULL)
249 goto out_free;
250
251
252 mnt = ERR_PTR(-ENOENT);
253
254 parent = dget_parent(dentry);
255 dprintk("%s: getting locations for %s/%s\n",
256 __func__, parent->d_name.name, dentry->d_name.name);
257
258 err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page);
259 dput(parent);
260 if (err != 0 ||
261 fs_locations->nlocations <= 0 ||
262 fs_locations->fs_path.ncomponents <= 0)
263 goto out_free;
264
265 mnt = nfs_follow_referral(mnt_parent, dentry, fs_locations);
266out_free:
267 __free_page(page);
268 kfree(fs_locations);
269out:
270 dprintk("%s: done\n", __func__);
271 return mnt;
272}
273
