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 | 72de53e | 2012-04-27 13:27:40 -0400 | [diff] [blame] | 135 | static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name) |
| 136 | { |
| 137 | struct page *page; |
| 138 | struct nfs4_secinfo_flavors *flavors; |
| 139 | rpc_authflavor_t flavor; |
| 140 | int err; |
| 141 | |
| 142 | page = alloc_page(GFP_KERNEL); |
| 143 | if (!page) |
| 144 | return -ENOMEM; |
| 145 | flavors = page_address(page); |
| 146 | |
| 147 | err = nfs4_proc_secinfo(inode, name, flavors); |
| 148 | if (err < 0) { |
| 149 | flavor = err; |
| 150 | goto out; |
| 151 | } |
| 152 | |
| 153 | flavor = nfs_find_best_sec(flavors); |
| 154 | |
| 155 | out: |
| 156 | put_page(page); |
| 157 | return flavor; |
| 158 | } |
| 159 | |
| 160 | /* |
| 161 | * Please call rpc_shutdown_client() when you are done with this client. |
| 162 | */ |
| 163 | struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode, |
| 164 | struct qstr *name) |
| 165 | { |
| 166 | struct rpc_clnt *clone; |
| 167 | struct rpc_auth *auth; |
| 168 | rpc_authflavor_t flavor; |
| 169 | |
| 170 | flavor = nfs4_negotiate_security(inode, name); |
| 171 | if (flavor < 0) |
| 172 | return ERR_PTR(flavor); |
| 173 | |
| 174 | clone = rpc_clone_client(clnt); |
| 175 | if (IS_ERR(clone)) |
| 176 | return clone; |
| 177 | |
| 178 | auth = rpcauth_create(flavor, clone); |
| 179 | if (!auth) { |
| 180 | rpc_shutdown_client(clone); |
| 181 | clone = ERR_PTR(-EIO); |
| 182 | } |
| 183 | |
| 184 | return clone; |
| 185 | } |
| 186 | |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 187 | static struct vfsmount *try_location(struct nfs_clone_mount *mountdata, |
| 188 | char *page, char *page2, |
| 189 | const struct nfs4_fs_location *location) |
| 190 | { |
Trond Myklebust | 364d015e5 | 2010-04-16 16:22:46 -0400 | [diff] [blame] | 191 | const size_t addr_bufsize = sizeof(struct sockaddr_storage); |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 192 | struct vfsmount *mnt = ERR_PTR(-ENOENT); |
| 193 | char *mnt_path; |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 194 | unsigned int maxbuflen; |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 195 | unsigned int s; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 196 | |
| 197 | mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE); |
| 198 | if (IS_ERR(mnt_path)) |
Trond Myklebust | 517be09 | 2009-10-06 15:42:20 -0400 | [diff] [blame] | 199 | return ERR_CAST(mnt_path); |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 200 | mountdata->mnt_path = mnt_path; |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 201 | maxbuflen = mnt_path - 1 - page2; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 202 | |
Trond Myklebust | 364d015e5 | 2010-04-16 16:22:46 -0400 | [diff] [blame] | 203 | mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL); |
| 204 | if (mountdata->addr == NULL) |
| 205 | return ERR_PTR(-ENOMEM); |
| 206 | |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 207 | for (s = 0; s < location->nservers; s++) { |
J. Bruce Fields | ea31a44 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 208 | const struct nfs4_string *buf = &location->servers[s]; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 209 | |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 210 | if (buf->len <= 0 || buf->len >= maxbuflen) |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 211 | continue; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 212 | |
J. Bruce Fields | ea31a44 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 213 | if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len)) |
| 214 | continue; |
Trond Myklebust | 517be09 | 2009-10-06 15:42:20 -0400 | [diff] [blame] | 215 | |
| 216 | mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len, |
Stanislav Kinsbursky | 1b340d0 | 2011-11-25 17:13:04 +0300 | [diff] [blame] | 217 | mountdata->addr, addr_bufsize, |
| 218 | NFS_SB(mountdata->sb)); |
Chuck Lever | 53a0b9c | 2009-08-09 15:09:36 -0400 | [diff] [blame] | 219 | if (mountdata->addrlen == 0) |
J. Bruce Fields | ea31a44 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 220 | continue; |
Trond Myklebust | 517be09 | 2009-10-06 15:42:20 -0400 | [diff] [blame] | 221 | |
Chuck Lever | ec6ee61 | 2009-08-09 15:09:37 -0400 | [diff] [blame] | 222 | rpc_set_port(mountdata->addr, NFS_PORT); |
J. Bruce Fields | ea31a44 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 223 | |
Trond Myklebust | ef95d31 | 2009-03-10 20:33:17 -0400 | [diff] [blame] | 224 | memcpy(page2, buf->data, buf->len); |
| 225 | page2[buf->len] = '\0'; |
J. Bruce Fields | ea31a44 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 226 | mountdata->hostname = page2; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 227 | |
| 228 | snprintf(page, PAGE_SIZE, "%s:%s", |
| 229 | mountdata->hostname, |
| 230 | mountdata->mnt_path); |
| 231 | |
| 232 | mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata); |
| 233 | if (!IS_ERR(mnt)) |
| 234 | break; |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 235 | } |
Trond Myklebust | 364d015e5 | 2010-04-16 16:22:46 -0400 | [diff] [blame] | 236 | kfree(mountdata->addr); |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 237 | return mnt; |
| 238 | } |
| 239 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 240 | /** |
| 241 | * 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] | 242 | * @dentry - parent directory |
Chuck Lever | 3f43c66 | 2007-12-10 14:57:31 -0500 | [diff] [blame] | 243 | * @locations - array of NFSv4 server location information |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 244 | * |
| 245 | */ |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 246 | static struct vfsmount *nfs_follow_referral(struct dentry *dentry, |
David Howells | 509de81 | 2006-08-22 20:06:11 -0400 | [diff] [blame] | 247 | const struct nfs4_fs_locations *locations) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 248 | { |
| 249 | struct vfsmount *mnt = ERR_PTR(-ENOENT); |
| 250 | struct nfs_clone_mount mountdata = { |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 251 | .sb = dentry->d_sb, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 252 | .dentry = dentry, |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 253 | .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 254 | }; |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 255 | char *page = NULL, *page2 = NULL; |
Chuck Lever | 3f43c66 | 2007-12-10 14:57:31 -0500 | [diff] [blame] | 256 | int loc, error; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 257 | |
| 258 | if (locations == NULL || locations->nlocations <= 0) |
| 259 | goto out; |
| 260 | |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 261 | dprintk("%s: referral at %s/%s\n", __func__, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 262 | dentry->d_parent->d_name.name, dentry->d_name.name); |
| 263 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 264 | page = (char *) __get_free_page(GFP_USER); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 265 | if (!page) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 266 | goto out; |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 267 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 268 | page2 = (char *) __get_free_page(GFP_USER); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 269 | if (!page2) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 270 | goto out; |
| 271 | |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 272 | /* Ensure fs path is a prefix of current dentry path */ |
Al Viro | b514f87 | 2011-03-16 06:26:11 -0400 | [diff] [blame] | 273 | error = nfs4_validate_fspath(dentry, locations, page, page2); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 274 | if (error < 0) { |
| 275 | mnt = ERR_PTR(error); |
| 276 | goto out; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 277 | } |
| 278 | |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 279 | for (loc = 0; loc < locations->nlocations; loc++) { |
David Howells | 509de81 | 2006-08-22 20:06:11 -0400 | [diff] [blame] | 280 | const struct nfs4_fs_location *location = &locations->locations[loc]; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 281 | |
| 282 | if (location == NULL || location->nservers <= 0 || |
J. Bruce Fields | 460cdbc | 2008-08-20 16:10:21 -0400 | [diff] [blame] | 283 | location->rootpath.ncomponents == 0) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 284 | continue; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 285 | |
J. Bruce Fields | 4ada29d | 2008-08-20 16:10:20 -0400 | [diff] [blame] | 286 | mnt = try_location(&mountdata, page, page2, location); |
| 287 | if (!IS_ERR(mnt)) |
| 288 | break; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 289 | } |
| 290 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 291 | out: |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 292 | free_page((unsigned long) page); |
| 293 | free_page((unsigned long) page2); |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 294 | dprintk("%s: done\n", __func__); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 295 | return mnt; |
| 296 | } |
| 297 | |
| 298 | /* |
| 299 | * nfs_do_refmount - handle crossing a referral on server |
| 300 | * @dentry - dentry of referral |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 301 | * |
| 302 | */ |
Bryan Schumaker | f05d147 | 2012-04-27 13:27:41 -0400 | [diff] [blame] | 303 | struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 304 | { |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 305 | struct vfsmount *mnt = ERR_PTR(-ENOMEM); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 306 | struct dentry *parent; |
| 307 | struct nfs4_fs_locations *fs_locations = NULL; |
| 308 | struct page *page; |
| 309 | int err; |
| 310 | |
| 311 | /* BUG_ON(IS_ROOT(dentry)); */ |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 312 | dprintk("%s: enter\n", __func__); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 313 | |
| 314 | page = alloc_page(GFP_KERNEL); |
| 315 | if (page == NULL) |
| 316 | goto out; |
| 317 | |
| 318 | fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL); |
| 319 | if (fs_locations == NULL) |
| 320 | goto out_free; |
| 321 | |
| 322 | /* Get locations */ |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 323 | mnt = ERR_PTR(-ENOENT); |
| 324 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 325 | parent = dget_parent(dentry); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 326 | dprintk("%s: getting locations for %s/%s\n", |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 327 | __func__, parent->d_name.name, dentry->d_name.name); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 328 | |
Bryan Schumaker | f05d147 | 2012-04-27 13:27:41 -0400 | [diff] [blame] | 329 | 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] | 330 | dput(parent); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 331 | if (err != 0 || |
| 332 | fs_locations->nlocations <= 0 || |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 333 | fs_locations->fs_path.ncomponents <= 0) |
| 334 | goto out_free; |
| 335 | |
Al Viro | f8ad9c4 | 2011-03-16 06:32:07 -0400 | [diff] [blame] | 336 | mnt = nfs_follow_referral(dentry, fs_locations); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 337 | out_free: |
| 338 | __free_page(page); |
| 339 | kfree(fs_locations); |
| 340 | out: |
Harvey Harrison | 3110ff8 | 2008-05-02 13:42:44 -0700 | [diff] [blame] | 341 | dprintk("%s: done\n", __func__); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 342 | return mnt; |
| 343 | } |