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