David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 1 | /* |
| 2 | * linux/fs/nfs/nfs4namespace.c |
| 3 | * |
| 4 | * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com> |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 5 | * - Modified by David Howells <dhowells@redhat.com> |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 6 | * |
| 7 | * NFSv4 namespace |
| 8 | */ |
| 9 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 10 | #include <linux/dcache.h> |
| 11 | #include <linux/mount.h> |
| 12 | #include <linux/namei.h> |
| 13 | #include <linux/nfs_fs.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 14 | #include <linux/slab.h> |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 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" |
Trond Myklebust | c228fd3 | 2007-01-13 02:28:11 -0500 | [diff] [blame] | 20 | #include "nfs4_fs.h" |
Trond Myklebust | 7d7ea88 | 2009-08-19 18:12:34 -0400 | [diff] [blame] | 21 | #include "dns_resolve.h" |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 22 | |
| 23 | #define NFSDBG_FACILITY NFSDBG_VFS |
| 24 | |
| 25 | /* |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 26 | * Convert the NFSv4 pathname components into a standard posix path. |
| 27 | * |
| 28 | * Note that the resulting string will be placed at the end of the buffer |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 29 | */ |
David Howells | 509de81 | 2006-08-22 20:06:11 -0400 | [diff] [blame] | 30 | static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 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) { |
David Howells | 509de81 | 2006-08-22 20:06:11 -0400 | [diff] [blame] | 41 | const struct nfs4_string *component = &pathname->components[n]; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 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; |
| 50 | Elong: |
| 51 | return ERR_PTR(-ENAMETOOLONG); |
| 52 | } |
| 53 | |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 54 | /* |
Weston Andros Adamson | 1aba156 | 2012-04-24 16:50:37 -0400 | [diff] [blame] | 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 |
| 59 | */ |
| 60 | static char *nfs_path_component(const char *nfspath, const char *end) |
| 61 | { |
| 62 | char *p; |
| 63 | |
| 64 | if (*nfspath == '[') { |
| 65 | /* parse [] escaped IPv6 addrs */ |
| 66 | p = strchr(nfspath, ']'); |
| 67 | if (p != NULL && ++p < end && *p == ':') |
| 68 | return p + 1; |
| 69 | } else { |
| 70 | /* otherwise split on first colon */ |
| 71 | p = strchr(nfspath, ':'); |
| 72 | if (p != NULL && p < end) |
| 73 | return p + 1; |
| 74 | } |
| 75 | return NULL; |
| 76 | } |
| 77 | |
| 78 | /* |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 79 | * Determine the mount path as a string |
| 80 | */ |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 81 | static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen) |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 82 | { |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 83 | char *limit; |
| 84 | char *path = nfs_path(&limit, dentry, buffer, buflen); |
| 85 | if (!IS_ERR(path)) { |
Weston Andros Adamson | 1aba156 | 2012-04-24 16:50:37 -0400 | [diff] [blame] | 86 | char *path_component = nfs_path_component(path, limit); |
| 87 | if (path_component) |
| 88 | return path_component; |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 89 | } |
| 90 | return path; |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 91 | } |
| 92 | |
| 93 | /* |
| 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 |
| 96 | */ |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 97 | static int nfs4_validate_fspath(struct dentry *dentry, |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 98 | const struct nfs4_fs_locations *locations, |
| 99 | char *page, char *page2) |
| 100 | { |
| 101 | const char *path, *fs_path; |
| 102 | |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 103 | path = nfs4_path(dentry, page, PAGE_SIZE); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 104 | if (IS_ERR(path)) |
| 105 | return PTR_ERR(path); |
| 106 | |
| 107 | fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE); |
| 108 | if (IS_ERR(fs_path)) |
| 109 | return PTR_ERR(fs_path); |
| 110 | |
| 111 | if (strncmp(path, fs_path, strlen(fs_path)) != 0) { |
| 112 | dprintk("%s: path %s does not begin with fsroot %s\n", |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 113 | __func__, path, fs_path); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 114 | return -ENOENT; |
| 115 | } |
| 116 | |
| 117 | return 0; |
| 118 | } |
| 119 | |
Trond Myklebust | 7d7ea88 | 2009-08-19 18:12:34 -0400 | [diff] [blame] | 120 | static size_t nfs_parse_server_name(char *string, size_t len, |
Stanislav Kinsbursky | 1b340d0 | 2011-11-25 17:13:04 +0300 | [diff] [blame] | 121 | struct sockaddr *sa, size_t salen, struct nfs_server *server) |
Trond Myklebust | 7d7ea88 | 2009-08-19 18:12:34 -0400 | [diff] [blame] | 122 | { |
Trond Myklebust | 2446ab6 | 2012-03-01 17:00:56 -0500 | [diff] [blame] | 123 | struct net *net = rpc_net_ns(server->client); |
Trond Myklebust | 7d7ea88 | 2009-08-19 18:12:34 -0400 | [diff] [blame] | 124 | ssize_t ret; |
| 125 | |
Stanislav Kinsbursky | 33faaa3 | 2012-01-26 15:12:05 +0400 | [diff] [blame] | 126 | ret = rpc_pton(net, string, len, sa, salen); |
Trond Myklebust | 7d7ea88 | 2009-08-19 18:12:34 -0400 | [diff] [blame] | 127 | if (ret == 0) { |
Stanislav Kinsbursky | 33faaa3 | 2012-01-26 15:12:05 +0400 | [diff] [blame] | 128 | ret = nfs_dns_resolve_name(net, string, len, sa, salen); |
Trond Myklebust | 7d7ea88 | 2009-08-19 18:12:34 -0400 | [diff] [blame] | 129 | if (ret < 0) |
| 130 | ret = 0; |
| 131 | } |
| 132 | return ret; |
| 133 | } |
| 134 | |
Bryan Schumaker | 2671bfc | 2012-04-27 13:27:44 -0400 | [diff] [blame] | 135 | rpc_authflavor_t nfs_find_best_sec(struct nfs4_secinfo_flavors *flavors) |
| 136 | { |
| 137 | struct gss_api_mech *mech; |
| 138 | struct xdr_netobj oid; |
| 139 | int i; |
| 140 | rpc_authflavor_t pseudoflavor = RPC_AUTH_UNIX; |
| 141 | |
| 142 | for (i = 0; i < flavors->num_flavors; i++) { |
| 143 | struct nfs4_secinfo_flavor *flavor; |
| 144 | flavor = &flavors->flavors[i]; |
| 145 | |
| 146 | if (flavor->flavor == RPC_AUTH_NULL || flavor->flavor == RPC_AUTH_UNIX) { |
| 147 | pseudoflavor = flavor->flavor; |
| 148 | break; |
| 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); |
| 153 | if (!mech) |
| 154 | continue; |
| 155 | pseudoflavor = gss_svc_to_pseudoflavor(mech, flavor->gss.service); |
| 156 | gss_mech_put(mech); |
| 157 | break; |
| 158 | } |
| 159 | } |
| 160 | |
| 161 | return pseudoflavor; |
| 162 | } |
| 163 | |
Bryan Schumaker | 72de53e | 2012-04-27 13:27:40 -0400 | [diff] [blame] | 164 | static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name) |
| 165 | { |
| 166 | struct page *page; |
| 167 | struct nfs4_secinfo_flavors *flavors; |
| 168 | rpc_authflavor_t flavor; |
| 169 | int err; |
| 170 | |
| 171 | page = alloc_page(GFP_KERNEL); |
| 172 | if (!page) |
| 173 | return -ENOMEM; |
| 174 | flavors = page_address(page); |
| 175 | |
| 176 | err = nfs4_proc_secinfo(inode, name, flavors); |
| 177 | if (err < 0) { |
| 178 | flavor = err; |
| 179 | goto out; |
| 180 | } |
| 181 | |
| 182 | flavor = nfs_find_best_sec(flavors); |
| 183 | |
| 184 | out: |
| 185 | put_page(page); |
| 186 | return flavor; |
| 187 | } |
| 188 | |
| 189 | /* |
| 190 | * Please call rpc_shutdown_client() when you are done with this client. |
| 191 | */ |
| 192 | struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode, |
| 193 | struct qstr *name) |
| 194 | { |
Bryan Schumaker | 72de53e | 2012-04-27 13:27:40 -0400 | [diff] [blame] | 195 | rpc_authflavor_t flavor; |
| 196 | |
| 197 | flavor = nfs4_negotiate_security(inode, name); |
Benny Halevy | 5f23eff3 | 2012-05-16 11:35:36 +0300 | [diff] [blame] | 198 | if ((int)flavor < 0) |
NeilBrown | 62d98c9 | 2012-09-17 16:46:34 +1000 | [diff] [blame] | 199 | return ERR_PTR((int)flavor); |
Bryan Schumaker | 72de53e | 2012-04-27 13:27:40 -0400 | [diff] [blame] | 200 | |
Chuck Lever | ba9b584 | 2012-09-14 17:24:02 -0400 | [diff] [blame^] | 201 | return rpc_clone_client_set_auth(clnt, flavor); |
Bryan Schumaker | 72de53e | 2012-04-27 13:27:40 -0400 | [diff] [blame] | 202 | } |
| 203 | |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 204 | static struct vfsmount *try_location(struct nfs_clone_mount *mountdata, |
| 205 | char *page, char *page2, |
| 206 | const struct nfs4_fs_location *location) |
| 207 | { |
Trond Myklebust | 364d015e5 | 2010-04-16 16:22:46 -0400 | [diff] [blame] | 208 | const size_t addr_bufsize = sizeof(struct sockaddr_storage); |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 209 | struct vfsmount *mnt = ERR_PTR(-ENOENT); |
| 210 | char *mnt_path; |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 211 | unsigned int maxbuflen; |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 212 | unsigned int s; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 213 | |
| 214 | mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE); |
| 215 | if (IS_ERR(mnt_path)) |
Trond Myklebust | 517be09 | 2009-10-06 15:42:20 -0400 | [diff] [blame] | 216 | return ERR_CAST(mnt_path); |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 217 | mountdata->mnt_path = mnt_path; |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 218 | maxbuflen = mnt_path - 1 - page2; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 219 | |
Trond Myklebust | 364d015e5 | 2010-04-16 16:22:46 -0400 | [diff] [blame] | 220 | mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL); |
| 221 | if (mountdata->addr == NULL) |
| 222 | return ERR_PTR(-ENOMEM); |
| 223 | |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 224 | for (s = 0; s < location->nservers; s++) { |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 225 | const struct nfs4_string *buf = &location->servers[s]; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 226 | |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 227 | if (buf->len <= 0 || buf->len >= maxbuflen) |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 228 | continue; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 229 | |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 230 | if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len)) |
| 231 | continue; |
Trond Myklebust | 517be09 | 2009-10-06 15:42:20 -0400 | [diff] [blame] | 232 | |
| 233 | mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len, |
Stanislav Kinsbursky | 1b340d0 | 2011-11-25 17:13:04 +0300 | [diff] [blame] | 234 | mountdata->addr, addr_bufsize, |
| 235 | NFS_SB(mountdata->sb)); |
Chuck Lever | 53a0b9c | 2009-08-09 15:09:36 -0400 | [diff] [blame] | 236 | if (mountdata->addrlen == 0) |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 237 | continue; |
Trond Myklebust | 517be09 | 2009-10-06 15:42:20 -0400 | [diff] [blame] | 238 | |
Chuck Lever | ec6ee61 | 2009-08-09 15:09:37 -0400 | [diff] [blame] | 239 | rpc_set_port(mountdata->addr, NFS_PORT); |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 240 | |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 241 | memcpy(page2, buf->data, buf->len); |
| 242 | page2[buf->len] = '\0'; |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 243 | mountdata->hostname = page2; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 244 | |
| 245 | snprintf(page, PAGE_SIZE, "%s:%s", |
| 246 | mountdata->hostname, |
| 247 | mountdata->mnt_path); |
| 248 | |
| 249 | mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata); |
| 250 | if (!IS_ERR(mnt)) |
| 251 | break; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 252 | } |
Trond Myklebust | 364d015e5 | 2010-04-16 16:22:46 -0400 | [diff] [blame] | 253 | kfree(mountdata->addr); |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 254 | return mnt; |
| 255 | } |
| 256 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 257 | /** |
| 258 | * nfs_follow_referral - set up mountpoint when hitting a referral on moved error |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 259 | * @dentry - parent directory |
Chuck Lever | 3f43c66 | 2007-12-10 14:57:31 -0500 | [diff] [blame] | 260 | * @locations - array of NFSv4 server location information |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 261 | * |
| 262 | */ |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 263 | static struct vfsmount *nfs_follow_referral(struct dentry *dentry, |
David Howells | 509de81 | 2006-08-22 20:06:11 -0400 | [diff] [blame] | 264 | const struct nfs4_fs_locations *locations) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 265 | { |
| 266 | struct vfsmount *mnt = ERR_PTR(-ENOENT); |
| 267 | struct nfs_clone_mount mountdata = { |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 268 | .sb = dentry->d_sb, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 269 | .dentry = dentry, |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 270 | .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 271 | }; |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 272 | char *page = NULL, *page2 = NULL; |
Chuck Lever | 3f43c66 | 2007-12-10 14:57:31 -0500 | [diff] [blame] | 273 | int loc, error; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 274 | |
| 275 | if (locations == NULL || locations->nlocations <= 0) |
| 276 | goto out; |
| 277 | |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 278 | dprintk("%s: referral at %s/%s\n", __func__, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 279 | dentry->d_parent->d_name.name, dentry->d_name.name); |
| 280 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 281 | page = (char *) __get_free_page(GFP_USER); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 282 | if (!page) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 283 | goto out; |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 284 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 285 | page2 = (char *) __get_free_page(GFP_USER); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 286 | if (!page2) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 287 | goto out; |
| 288 | |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 289 | /* Ensure fs path is a prefix of current dentry path */ |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 290 | error = nfs4_validate_fspath(dentry, locations, page, page2); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 291 | if (error < 0) { |
| 292 | mnt = ERR_PTR(error); |
| 293 | goto out; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 294 | } |
| 295 | |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 296 | for (loc = 0; loc < locations->nlocations; loc++) { |
David Howells | 509de81 | 2006-08-22 20:06:11 -0400 | [diff] [blame] | 297 | const struct nfs4_fs_location *location = &locations->locations[loc]; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 298 | |
| 299 | if (location == NULL || location->nservers <= 0 || |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 300 | location->rootpath.ncomponents == 0) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 301 | continue; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 302 | |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 303 | mnt = try_location(&mountdata, page, page2, location); |
| 304 | if (!IS_ERR(mnt)) |
| 305 | break; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 306 | } |
| 307 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 308 | out: |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 309 | free_page((unsigned long) page); |
| 310 | free_page((unsigned long) page2); |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 311 | dprintk("%s: done\n", __func__); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 312 | return mnt; |
| 313 | } |
| 314 | |
| 315 | /* |
| 316 | * nfs_do_refmount - handle crossing a referral on server |
| 317 | * @dentry - dentry of referral |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 318 | * |
| 319 | */ |
Bryan Schumaker | 281cad4 | 2012-04-27 13:27:45 -0400 | [diff] [blame] | 320 | static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 321 | { |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 322 | struct vfsmount *mnt = ERR_PTR(-ENOMEM); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 323 | struct dentry *parent; |
| 324 | struct nfs4_fs_locations *fs_locations = NULL; |
| 325 | struct page *page; |
| 326 | int err; |
| 327 | |
| 328 | /* BUG_ON(IS_ROOT(dentry)); */ |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 329 | dprintk("%s: enter\n", __func__); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 330 | |
| 331 | page = alloc_page(GFP_KERNEL); |
| 332 | if (page == NULL) |
| 333 | goto out; |
| 334 | |
| 335 | fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); |
| 336 | if (fs_locations == NULL) |
| 337 | goto out_free; |
| 338 | |
| 339 | /* Get locations */ |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 340 | mnt = ERR_PTR(-ENOENT); |
| 341 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 342 | parent = dget_parent(dentry); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 343 | dprintk("%s: getting locations for %s/%s\n", |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 344 | __func__, parent->d_name.name, dentry->d_name.name); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 345 | |
Bryan Schumaker | f05d147 | 2012-04-27 13:27:41 -0400 | [diff] [blame] | 346 | err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 347 | dput(parent); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 348 | if (err != 0 || |
| 349 | fs_locations->nlocations <= 0 || |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 350 | fs_locations->fs_path.ncomponents <= 0) |
| 351 | goto out_free; |
| 352 | |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 353 | mnt = nfs_follow_referral(dentry, fs_locations); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 354 | out_free: |
| 355 | __free_page(page); |
| 356 | kfree(fs_locations); |
| 357 | out: |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 358 | dprintk("%s: done\n", __func__); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 359 | return mnt; |
| 360 | } |
Bryan Schumaker | 281cad4 | 2012-04-27 13:27:45 -0400 | [diff] [blame] | 361 | |
| 362 | struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry, |
| 363 | struct nfs_fh *fh, struct nfs_fattr *fattr) |
| 364 | { |
| 365 | struct dentry *parent = dget_parent(dentry); |
| 366 | struct rpc_clnt *client; |
| 367 | struct vfsmount *mnt; |
| 368 | |
| 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); |
| 371 | dput(parent); |
| 372 | if (IS_ERR(client)) |
| 373 | return ERR_CAST(client); |
| 374 | |
| 375 | if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) |
| 376 | mnt = nfs_do_refmount(client, dentry); |
| 377 | else |
| 378 | mnt = nfs_do_submount(dentry, fh, fattr, client->cl_auth->au_flavor); |
| 379 | |
| 380 | rpc_shutdown_client(client); |
| 381 | return mnt; |
| 382 | } |