1/* 2 * linux/fs/nfs/nfs4namespace.c 3 * 4 * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com> 5 * - Modified by David Howells <dhowells@redhat.com> 6 * 7 * NFSv4 namespace 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 * 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 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 * Determine the mount path as a string 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 * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we 74 * believe to be the server path to this dentry 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 * nfs_follow_referral - set up mountpoint when hitting a referral on moved error 168 * @mnt_parent - mountpoint of parent directory 169 * @dentry - parent directory 170 * @locations - array of NFSv4 server location information 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 /* Ensure fs path is a prefix of current dentry path */ 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 * nfs_do_refmount - handle crossing a referral on server 228 * @mnt_parent - mountpoint of referral 229 * @dentry - dentry of referral 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 /* BUG_ON(IS_ROOT(dentry)); */ 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 /* Get locations */ 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