fs/nfs/nfs4namespace.c

   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/nfs_mount.h>
  15 #include <linux/slab.h>
  16 #include <linux/string.h>
  17 #include <linux/sunrpc/clnt.h>
  18 #include <linux/sunrpc/addr.h>
  19 #include <linux/vfs.h>
  20 #include <linux/inet.h>
  21 #include "internal.h"
  22 #include "nfs4_fs.h"
  23 #include "dns_resolve.h"
  24
  25 #define NFSDBG_FACILITY         NFSDBG_VFS
  26
  27 /*
  28  * Convert the NFSv4 pathname components into a standard posix path.
  29  *
  30  * Note that the resulting string will be placed at the end of the buffer
  31  */
  32 static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
  33                                          char *buffer, ssize_t buflen)
  34 {
  35         char *end = buffer + buflen;
  36         int n;
  37
  38         *--end = '\0';
  39         buflen--;
  40
  41         n = pathname->ncomponents;
  42         while (--n >= 0) {
  43                 const struct nfs4_string *component = &pathname->components[n];
  44                 buflen -= component->len + 1;
  45                 if (buflen < 0)
  46                         goto Elong;
  47                 end -= component->len;
  48                 memcpy(end, component->data, component->len);
  49                 *--end = '/';
  50         }
  51         return end;
  52 Elong:
  53         return ERR_PTR(-ENAMETOOLONG);
  54 }
  55
  56 /*
  57  * return the path component of "<server>:<path>"
  58  *  nfspath - the "<server>:<path>" string
  59  *  end - one past the last char that could contain "<server>:"
  60  * returns NULL on failure
  61  */
  62 static char *nfs_path_component(const char *nfspath, const char *end)
  63 {
  64         char *p;
  65
  66         if (*nfspath == '[') {
  67                 /* parse [] escaped IPv6 addrs */
  68                 p = strchr(nfspath, ']');
  69                 if (p != NULL && ++p < end && *p == ':')
  70                         return p + 1;
  71         } else {
  72                 /* otherwise split on first colon */
  73                 p = strchr(nfspath, ':');
  74                 if (p != NULL && p < end)
  75                         return p + 1;
  76         }
  77         return NULL;
  78 }
  79
  80 /*
  81  * Determine the mount path as a string
  82  */
  83 static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
  84 {
  85         char *limit;
  86         char *path = nfs_path(&limit, dentry, buffer, buflen,
  87                               NFS_PATH_CANONICAL);
  88         if (!IS_ERR(path)) {
  89                 char *path_component = nfs_path_component(path, limit);
  90                 if (path_component)
  91                         return path_component;
  92         }
  93         return path;
  94 }
  95
  96 /*
  97  * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
  98  * believe to be the server path to this dentry
  99  */
 100 static int nfs4_validate_fspath(struct dentry *dentry,
 101                                 const struct nfs4_fs_locations *locations,
 102                                 char *page, char *page2)
 103 {
 104         const char *path, *fs_path;
 105
 106         path = nfs4_path(dentry, page, PAGE_SIZE);
 107         if (IS_ERR(path))
 108                 return PTR_ERR(path);
 109
 110         fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
 111         if (IS_ERR(fs_path))
 112                 return PTR_ERR(fs_path);
 113
 114         if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
 115                 dprintk("%s: path %s does not begin with fsroot %s\n",
 116                         __func__, path, fs_path);
 117                 return -ENOENT;
 118         }
 119
 120         return 0;
 121 }
 122
 123 static size_t nfs_parse_server_name(char *string, size_t len,
 124                 struct sockaddr *sa, size_t salen, struct net *net)
 125 {
 126         ssize_t ret;
 127
 128         ret = rpc_pton(net, string, len, sa, salen);
 129         if (ret == 0) {
 130                 ret = nfs_dns_resolve_name(net, string, len, sa, salen);
 131                 if (ret < 0)
 132                         ret = 0;
 133         }
 134         return ret;
 135 }
 136
 137 /**
 138  * nfs_find_best_sec - Find a security mechanism supported locally
 139  * @server: NFS server struct
 140  * @flavors: List of security tuples returned by SECINFO procedure
 141  *
 142  * Return the pseudoflavor of the first security mechanism in
 143  * "flavors" that is locally supported.  Return RPC_AUTH_UNIX if
 144  * no matching flavor is found in the array.  The "flavors" array
 145  * is searched in the order returned from the server, per RFC 3530
 146  * recommendation.
 147  */
 148 static rpc_authflavor_t nfs_find_best_sec(struct nfs_server *server,
 149                                           struct nfs4_secinfo_flavors *flavors)
 150 {
 151         rpc_authflavor_t pseudoflavor;
 152         struct nfs4_secinfo4 *secinfo;
 153         unsigned int i;
 154
 155         for (i = 0; i < flavors->num_flavors; i++) {
 156                 secinfo = &flavors->flavors[i];
 157
 158                 switch (secinfo->flavor) {
 159                 case RPC_AUTH_NULL:
 160                 case RPC_AUTH_UNIX:
 161                 case RPC_AUTH_GSS:
 162                         pseudoflavor = rpcauth_get_pseudoflavor(secinfo->flavor,
 163                                                         &secinfo->flavor_info);
 164                         /* make sure pseudoflavor matches sec= mount opt */
 165                         if (pseudoflavor != RPC_AUTH_MAXFLAVOR &&
 166                             nfs_auth_info_match(&server->auth_info,
 167                                                 pseudoflavor))
 168                                 return pseudoflavor;
 169                         break;
 170                 }
 171         }
 172
 173         /* if there were any sec= options then nothing matched */
 174         if (server->auth_info.flavor_len > 0)
 175                 return -EPERM;
 176
 177         return RPC_AUTH_UNIX;
 178 }
 179
 180 static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name)
 181 {
 182         struct page *page;
 183         struct nfs4_secinfo_flavors *flavors;
 184         rpc_authflavor_t flavor;
 185         int err;
 186
 187         page = alloc_page(GFP_KERNEL);
 188         if (!page)
 189                 return -ENOMEM;
 190         flavors = page_address(page);
 191
 192         err = nfs4_proc_secinfo(inode, name, flavors);
 193         if (err < 0) {
 194                 flavor = err;
 195                 goto out;
 196         }
 197
 198         flavor = nfs_find_best_sec(NFS_SERVER(inode), flavors);
 199
 200 out:
 201         put_page(page);
 202         return flavor;
 203 }
 204
 205 /*
 206  * Please call rpc_shutdown_client() when you are done with this client.
 207  */
 208 struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode,
 209                                         struct qstr *name)
 210 {
 211         rpc_authflavor_t flavor;
 212
 213         flavor = nfs4_negotiate_security(inode, name);
 214         if ((int)flavor < 0)
 215                 return ERR_PTR((int)flavor);
 216
 217         return rpc_clone_client_set_auth(clnt, flavor);
 218 }
 219
 220 static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
 221                                      char *page, char *page2,
 222                                      const struct nfs4_fs_location *location)
 223 {
 224         const size_t addr_bufsize = sizeof(struct sockaddr_storage);
 225         struct net *net = rpc_net_ns(NFS_SB(mountdata->sb)->client);
 226         struct vfsmount *mnt = ERR_PTR(-ENOENT);
 227         char *mnt_path;
 228         unsigned int maxbuflen;
 229         unsigned int s;
 230
 231         mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
 232         if (IS_ERR(mnt_path))
 233                 return ERR_CAST(mnt_path);
 234         mountdata->mnt_path = mnt_path;
 235         maxbuflen = mnt_path - 1 - page2;
 236
 237         mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
 238         if (mountdata->addr == NULL)
 239                 return ERR_PTR(-ENOMEM);
 240
 241         for (s = 0; s < location->nservers; s++) {
 242                 const struct nfs4_string *buf = &location->servers[s];
 243
 244                 if (buf->len <= 0 || buf->len >= maxbuflen)
 245                         continue;
 246
 247                 if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
 248                         continue;
 249
 250                 mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
 251                                 mountdata->addr, addr_bufsize, net);
 252                 if (mountdata->addrlen == 0)
 253                         continue;
 254
 255                 rpc_set_port(mountdata->addr, NFS_PORT);
 256
 257                 memcpy(page2, buf->data, buf->len);
 258                 page2[buf->len] = '\0';
 259                 mountdata->hostname = page2;
 260
 261                 snprintf(page, PAGE_SIZE, "%s:%s",
 262                                 mountdata->hostname,
 263                                 mountdata->mnt_path);
 264
 265                 mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
 266                 if (!IS_ERR(mnt))
 267                         break;
 268         }
 269         kfree(mountdata->addr);
 270         return mnt;
 271 }
 272
 273 /**
 274  * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
 275  * @dentry - parent directory
 276  * @locations - array of NFSv4 server location information
 277  *
 278  */
 279 static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
 280                                             const struct nfs4_fs_locations *locations)
 281 {
 282         struct vfsmount *mnt = ERR_PTR(-ENOENT);
 283         struct nfs_clone_mount mountdata = {
 284                 .sb = dentry->d_sb,
 285                 .dentry = dentry,
 286                 .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
 287         };
 288         char *page = NULL, *page2 = NULL;
 289         int loc, error;
 290
 291         if (locations == NULL || locations->nlocations <= 0)
 292                 goto out;
 293
 294         dprintk("%s: referral at %pd2\n", __func__, dentry);
 295
 296         page = (char *) __get_free_page(GFP_USER);
 297         if (!page)
 298                 goto out;
 299
 300         page2 = (char *) __get_free_page(GFP_USER);
 301         if (!page2)
 302                 goto out;
 303
 304         /* Ensure fs path is a prefix of current dentry path */
 305         error = nfs4_validate_fspath(dentry, locations, page, page2);
 306         if (error < 0) {
 307                 mnt = ERR_PTR(error);
 308                 goto out;
 309         }
 310
 311         for (loc = 0; loc < locations->nlocations; loc++) {
 312                 const struct nfs4_fs_location *location = &locations->locations[loc];
 313
 314                 if (location == NULL || location->nservers <= 0 ||
 315                     location->rootpath.ncomponents == 0)
 316                         continue;
 317
 318                 mnt = try_location(&mountdata, page, page2, location);
 319                 if (!IS_ERR(mnt))
 320                         break;
 321         }
 322
 323 out:
 324         free_page((unsigned long) page);
 325         free_page((unsigned long) page2);
 326         dprintk("%s: done\n", __func__);
 327         return mnt;
 328 }
 329
 330 /*
 331  * nfs_do_refmount - handle crossing a referral on server
 332  * @dentry - dentry of referral
 333  *
 334  */
 335 static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry)
 336 {
 337         struct vfsmount *mnt = ERR_PTR(-ENOMEM);
 338         struct dentry *parent;
 339         struct nfs4_fs_locations *fs_locations = NULL;
 340         struct page *page;
 341         int err;
 342
 343         /* BUG_ON(IS_ROOT(dentry)); */
 344         dprintk("%s: enter\n", __func__);
 345
 346         page = alloc_page(GFP_KERNEL);
 347         if (page == NULL)
 348                 goto out;
 349
 350         fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
 351         if (fs_locations == NULL)
 352                 goto out_free;
 353
 354         /* Get locations */
 355         mnt = ERR_PTR(-ENOENT);
 356
 357         parent = dget_parent(dentry);
 358         dprintk("%s: getting locations for %pd2\n",
 359                 __func__, dentry);
 360
 361         err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
 362         dput(parent);
 363         if (err != 0 ||
 364             fs_locations->nlocations <= 0 ||
 365             fs_locations->fs_path.ncomponents <= 0)
 366                 goto out_free;
 367
 368         mnt = nfs_follow_referral(dentry, fs_locations);
 369 out_free:
 370         __free_page(page);
 371         kfree(fs_locations);
 372 out:
 373         dprintk("%s: done\n", __func__);
 374         return mnt;
 375 }
 376
 377 struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
 378                                struct nfs_fh *fh, struct nfs_fattr *fattr)
 379 {
 380         rpc_authflavor_t flavor = server->client->cl_auth->au_flavor;
 381         struct dentry *parent = dget_parent(dentry);
 382         struct inode *dir = parent->d_inode;
 383         struct qstr *name = &dentry->d_name;
 384         struct rpc_clnt *client;
 385         struct vfsmount *mnt;
 386
 387         /* Look it up again to get its attributes and sec flavor */
 388         client = nfs4_proc_lookup_mountpoint(dir, name, fh, fattr);
 389         dput(parent);
 390         if (IS_ERR(client))
 391                 return ERR_CAST(client);
 392
 393         if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
 394                 mnt = nfs_do_refmount(client, dentry);
 395                 goto out;
 396         }
 397
 398         if (client->cl_auth->au_flavor != flavor)
 399                 flavor = client->cl_auth->au_flavor;
 400         else {
 401                 rpc_authflavor_t new = nfs4_negotiate_security(dir, name);
 402                 if ((int)new >= 0)
 403                         flavor = new;
 404         }
 405         mnt = nfs_do_submount(dentry, fh, fattr, flavor);
 406 out:
 407         rpc_shutdown_client(client);
 408         return mnt;
 409 }
 410
 411 /*
 412  * Try one location from the fs_locations array.
 413  *
 414  * Returns zero on success, or a negative errno value.
 415  */
 416 static int nfs4_try_replacing_one_location(struct nfs_server *server,
 417                 char *page, char *page2,
 418                 const struct nfs4_fs_location *location)
 419 {
 420         const size_t addr_bufsize = sizeof(struct sockaddr_storage);
 421         struct net *net = rpc_net_ns(server->client);
 422         struct sockaddr *sap;
 423         unsigned int s;
 424         size_t salen;
 425         int error;
 426
 427         sap = kmalloc(addr_bufsize, GFP_KERNEL);
 428         if (sap == NULL)
 429                 return -ENOMEM;
 430
 431         error = -ENOENT;
 432         for (s = 0; s < location->nservers; s++) {
 433                 const struct nfs4_string *buf = &location->servers[s];
 434                 char *hostname;
 435
 436                 if (buf->len <= 0 || buf->len > PAGE_SIZE)
 437                         continue;
 438
 439                 if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len) != NULL)
 440                         continue;
 441
 442                 salen = nfs_parse_server_name(buf->data, buf->len,
 443                                                 sap, addr_bufsize, net);
 444                 if (salen == 0)
 445                         continue;
 446                 rpc_set_port(sap, NFS_PORT);
 447
 448                 error = -ENOMEM;
 449                 hostname = kstrndup(buf->data, buf->len, GFP_KERNEL);
 450                 if (hostname == NULL)
 451                         break;
 452
 453                 error = nfs4_update_server(server, hostname, sap, salen, net);
 454                 kfree(hostname);
 455                 if (error == 0)
 456                         break;
 457         }
 458
 459         kfree(sap);
 460         return error;
 461 }
 462
 463 /**
 464  * nfs4_replace_transport - set up transport to destination server
 465  *
 466  * @server: export being migrated
 467  * @locations: fs_locations array
 468  *
 469  * Returns zero on success, or a negative errno value.
 470  *
 471  * The client tries all the entries in the "locations" array, in the
 472  * order returned by the server, until one works or the end of the
 473  * array is reached.
 474  */
 475 int nfs4_replace_transport(struct nfs_server *server,
 476                            const struct nfs4_fs_locations *locations)
 477 {
 478         char *page = NULL, *page2 = NULL;
 479         int loc, error;
 480
 481         error = -ENOENT;
 482         if (locations == NULL || locations->nlocations <= 0)
 483                 goto out;
 484
 485         error = -ENOMEM;
 486         page = (char *) __get_free_page(GFP_USER);
 487         if (!page)
 488                 goto out;
 489         page2 = (char *) __get_free_page(GFP_USER);
 490         if (!page2)
 491                 goto out;
 492
 493         for (loc = 0; loc < locations->nlocations; loc++) {
 494                 const struct nfs4_fs_location *location =
 495                                                 &locations->locations[loc];
 496
 497                 if (location == NULL || location->nservers <= 0 ||
 498                     location->rootpath.ncomponents == 0)
 499                         continue;
 500
 501                 error = nfs4_try_replacing_one_location(server, page,
 502                                                         page2, location);
 503                 if (error == 0)
 504                         break;
 505         }
 506
 507 out:
 508         free_page((unsigned long)page);
 509         free_page((unsigned long)page2);
 510         return error;
 511 }