1 files changed, 183 insertions, 78 deletions

diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index db6aa3673cf3..1f063bacd285 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -15,6 +15,7 @@
 #include <linux/string.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/vfs.h>
+#include <linux/sunrpc/gss_api.h>
 #include "internal.h"
 
 #define NFSDBG_FACILITY         NFSDBG_VFS
@@ -25,37 +26,43 @@ static LIST_HEAD(nfs_automount_list);
 static DECLARE_DELAYED_WORK(nfs_automount_task, nfs_expire_automounts);
 int nfs_mountpoint_expiry_timeout = 500 * HZ;
 
-static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
-                                        const struct dentry *dentry,
+static struct vfsmount *nfs_do_submount(struct dentry *dentry,
                                         struct nfs_fh *fh,
-                                        struct nfs_fattr *fattr);
+                                        struct nfs_fattr *fattr,
+                                        rpc_authflavor_t authflavor);
 
 /*
  * nfs_path - reconstruct the path given an arbitrary dentry
- * @base - arbitrary string to prepend to the path
- * @droot - pointer to root dentry for mountpoint
+ * @base - used to return pointer to the end of devname part of path
  * @dentry - pointer to dentry
  * @buffer - result buffer
  * @buflen - length of buffer
  *
- * Helper function for constructing the path from the
- * root dentry to an arbitrary hashed dentry.
+ * Helper function for constructing the server pathname
+ * by arbitrary hashed dentry.
  *
  * This is mainly for use in figuring out the path on the
- * server side when automounting on top of an existing partition.
+ * server side when automounting on top of an existing partition
+ * and in generating /proc/mounts and friends.
  */
-char *nfs_path(const char *base,
-               const struct dentry *droot,
-               const struct dentry *dentry,
-               char *buffer, ssize_t buflen)
+char *nfs_path(char **p, struct dentry *dentry, char *buffer, ssize_t buflen)
 {
-        char *end = buffer+buflen;
+        char *end;
         int namelen;
+        unsigned seq;
+        const char *base;
 
+rename_retry:
+        end = buffer+buflen;
         *--end = '\0';
         buflen--;
-        spin_lock(&dcache_lock);
-        while (!IS_ROOT(dentry) && dentry != droot) {
+
+        seq = read_seqbegin(&rename_lock);
+        rcu_read_lock();
+        while (1) {
+                spin_lock(&dentry->d_lock);
+                if (IS_ROOT(dentry))
+                        break;
                 namelen = dentry->d_name.len;
                 buflen -= namelen + 1;
                 if (buflen < 0)
@@ -63,34 +70,150 @@ char *nfs_path(const char *base,
                 end -= namelen;
                 memcpy(end, dentry->d_name.name, namelen);
                 *--end = '/';
+                spin_unlock(&dentry->d_lock);
                 dentry = dentry->d_parent;
         }
-        spin_unlock(&dcache_lock);
+        if (read_seqretry(&rename_lock, seq)) {
+                spin_unlock(&dentry->d_lock);
+                rcu_read_unlock();
+                goto rename_retry;
+        }
         if (*end != '/') {
-                if (--buflen < 0)
+                if (--buflen < 0) {
+                        spin_unlock(&dentry->d_lock);
+                        rcu_read_unlock();
                         goto Elong;
+                }
                 *--end = '/';
         }
+        *p = end;
+        base = dentry->d_fsdata;
+        if (!base) {
+                spin_unlock(&dentry->d_lock);
+                rcu_read_unlock();
+                WARN_ON(1);
+                return end;
+        }
         namelen = strlen(base);
         /* Strip off excess slashes in base string */
         while (namelen > 0 && base[namelen - 1] == '/')
                 namelen--;
         buflen -= namelen;
-        if (buflen < 0)
+        if (buflen < 0) {
+                spin_unlock(&dentry->d_lock);
+                rcu_read_unlock();
                 goto Elong;
+        }
         end -= namelen;
         memcpy(end, base, namelen);
+        spin_unlock(&dentry->d_lock);
+        rcu_read_unlock();
         return end;
 Elong_unlock:
-        spin_unlock(&dcache_lock);
+        spin_unlock(&dentry->d_lock);
+        rcu_read_unlock();
+        if (read_seqretry(&rename_lock, seq))
+                goto rename_retry;
 Elong:
         return ERR_PTR(-ENAMETOOLONG);
 }
 
+#ifdef CONFIG_NFS_V4
+static rpc_authflavor_t nfs_find_best_sec(struct nfs4_secinfo_flavors *flavors)
+{
+        struct gss_api_mech *mech;
+        struct xdr_netobj oid;
+        int i;
+        rpc_authflavor_t pseudoflavor = RPC_AUTH_UNIX;
+
+        for (i = 0; i < flavors->num_flavors; i++) {
+                struct nfs4_secinfo_flavor *flavor;
+                flavor = &flavors->flavors[i];
+
+                if (flavor->flavor == RPC_AUTH_NULL || flavor->flavor == RPC_AUTH_UNIX) {
+                        pseudoflavor = flavor->flavor;
+                        break;
+                } else if (flavor->flavor == RPC_AUTH_GSS) {
+                        oid.len  = flavor->gss.sec_oid4.len;
+                        oid.data = flavor->gss.sec_oid4.data;
+                        mech = gss_mech_get_by_OID(&oid);
+                        if (!mech)
+                                continue;
+                        pseudoflavor = gss_svc_to_pseudoflavor(mech, flavor->gss.service);
+                        gss_mech_put(mech);
+                        break;
+                }
+        }
+
+        return pseudoflavor;
+}
+
+static int nfs_negotiate_security(const struct dentry *parent,
+                                  const struct dentry *dentry,
+                                  rpc_authflavor_t *flavor)
+{
+        struct page *page;
+        struct nfs4_secinfo_flavors *flavors;
+        int (*secinfo)(struct inode *, const struct qstr *, struct nfs4_secinfo_flavors *);
+        int ret = -EPERM;
+
+        secinfo = NFS_PROTO(parent->d_inode)->secinfo;
+        if (secinfo != NULL) {
+                page = alloc_page(GFP_KERNEL);
+                if (!page) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                flavors = page_address(page);
+                ret = secinfo(parent->d_inode, &dentry->d_name, flavors);
+                *flavor = nfs_find_best_sec(flavors);
+                put_page(page);
+        }
+
+out:
+        return ret;
+}
+
+static int nfs_lookup_with_sec(struct nfs_server *server, struct dentry *parent,
+                               struct dentry *dentry, struct path *path,
+                               struct nfs_fh *fh, struct nfs_fattr *fattr,
+                               rpc_authflavor_t *flavor)
+{
+        struct rpc_clnt *clone;
+        struct rpc_auth *auth;
+        int err;
+
+        err = nfs_negotiate_security(parent, path->dentry, flavor);
+        if (err < 0)
+                goto out;
+        clone  = rpc_clone_client(server->client);
+        auth   = rpcauth_create(*flavor, clone);
+        if (!auth) {
+                err = -EIO;
+                goto out_shutdown;
+        }
+        err = server->nfs_client->rpc_ops->lookup(clone, parent->d_inode,
+                                                  &path->dentry->d_name,
+                                                  fh, fattr);
+out_shutdown:
+        rpc_shutdown_client(clone);
+out:
+        return err;
+}
+#else /* CONFIG_NFS_V4 */
+static inline int nfs_lookup_with_sec(struct nfs_server *server,
+                                      struct dentry *parent, struct dentry *dentry,
+                                      struct path *path, struct nfs_fh *fh,
+                                      struct nfs_fattr *fattr,
+                                      rpc_authflavor_t *flavor)
+{
+        return -EPERM;
+}
+#endif /* CONFIG_NFS_V4 */
+
 /*
- * nfs_follow_mountpoint - handle crossing a mountpoint on the server
- * @dentry - dentry of mountpoint
- * @nd - nameidata info
+ * nfs_d_automount - Handle crossing a mountpoint on the server
+ * @path - The mountpoint
  *
  * When we encounter a mountpoint on the server, we want to set up
  * a mountpoint on the client too, to prevent inode numbers from
@@ -100,87 +223,68 @@ Elong:
  * situation, and that different filesystems may want to use
  * different security flavours.
  */
-static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
+struct vfsmount *nfs_d_automount(struct path *path)
 {
         struct vfsmount *mnt;
-        struct nfs_server *server = NFS_SERVER(dentry->d_inode);
+        struct nfs_server *server = NFS_SERVER(path->dentry->d_inode);
         struct dentry *parent;
         struct nfs_fh *fh = NULL;
         struct nfs_fattr *fattr = NULL;
         int err;
+        rpc_authflavor_t flavor = RPC_AUTH_UNIX;
 
-        dprintk("--> nfs_follow_mountpoint()\n");
+        dprintk("--> nfs_d_automount()\n");
 
-        err = -ESTALE;
-        if (IS_ROOT(dentry))
-                goto out_err;
+        mnt = ERR_PTR(-ESTALE);
+        if (IS_ROOT(path->dentry))
+                goto out_nofree;
 
-        err = -ENOMEM;
+        mnt = ERR_PTR(-ENOMEM);
         fh = nfs_alloc_fhandle();
         fattr = nfs_alloc_fattr();
         if (fh == NULL || fattr == NULL)
-                goto out_err;
+                goto out;
 
         dprintk("%s: enter\n", __func__);
-        dput(nd->path.dentry);
-        nd->path.dentry = dget(dentry);
 
-        /* Look it up again */
-        parent = dget_parent(nd->path.dentry);
-        err = server->nfs_client->rpc_ops->lookup(parent->d_inode,
-                                                  &nd->path.dentry->d_name,
+        /* Look it up again to get its attributes */
+        parent = dget_parent(path->dentry);
+        err = server->nfs_client->rpc_ops->lookup(server->client, parent->d_inode,
+                                                  &path->dentry->d_name,
                                                   fh, fattr);
+        if (err == -EPERM && NFS_PROTO(parent->d_inode)->secinfo != NULL)
+                err = nfs_lookup_with_sec(server, parent, path->dentry, path, fh, fattr, &flavor);
         dput(parent);
-        if (err != 0)
-                goto out_err;
+        if (err != 0) {
+                mnt = ERR_PTR(err);
+                goto out;
+        }
 
         if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
-                mnt = nfs_do_refmount(nd->path.mnt, nd->path.dentry);
+                mnt = nfs_do_refmount(path->dentry);
         else
-                mnt = nfs_do_submount(nd->path.mnt, nd->path.dentry, fh,
-                                      fattr);
-        err = PTR_ERR(mnt);
+                mnt = nfs_do_submount(path->dentry, fh, fattr, flavor);
         if (IS_ERR(mnt))
-                goto out_err;
-
-        mntget(mnt);
-        err = do_add_mount(mnt, &nd->path, nd->path.mnt->mnt_flags|MNT_SHRINKABLE,
-                           &nfs_automount_list);
-        if (err < 0) {
-                mntput(mnt);
-                if (err == -EBUSY)
-                        goto out_follow;
-                goto out_err;
-        }
-        path_put(&nd->path);
-        nd->path.mnt = mnt;
-        nd->path.dentry = dget(mnt->mnt_root);
+                goto out;
+
+        dprintk("%s: done, success\n", __func__);
+        mntget(mnt); /* prevent immediate expiration */
+        mnt_set_expiry(mnt, &nfs_automount_list);
         schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
+
 out:
         nfs_free_fattr(fattr);
         nfs_free_fhandle(fh);
-        dprintk("%s: done, returned %d\n", __func__, err);
-
-        dprintk("<-- nfs_follow_mountpoint() = %d\n", err);
-        return ERR_PTR(err);
-out_err:
-        path_put(&nd->path);
-        goto out;
-out_follow:
-        while (d_mountpoint(nd->path.dentry) &&
-               follow_down(&nd->path))
-                ;
-        err = 0;
-        goto out;
+out_nofree:
+        dprintk("<-- nfs_follow_mountpoint() = %p\n", mnt);
+        return mnt;
 }
 
 const struct inode_operations nfs_mountpoint_inode_operations = {
-        .follow_link    = nfs_follow_mountpoint,
         .getattr        = nfs_getattr,
 };
 
 const struct inode_operations nfs_referral_inode_operations = {
-        .follow_link    = nfs_follow_mountpoint,
 };
 
 static void nfs_expire_automounts(struct work_struct *work)
@@ -223,22 +327,23 @@ static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server,
 
 /**
  * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
- * @mnt_parent - mountpoint of parent directory
  * @dentry - parent directory
  * @fh - filehandle for new root dentry
  * @fattr - attributes for new root inode
+ * @authflavor - security flavor to use when performing the mount
  *
  */
-static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
-                                        const struct dentry *dentry,
+static struct vfsmount *nfs_do_submount(struct dentry *dentry,
                                         struct nfs_fh *fh,
-                                        struct nfs_fattr *fattr)
+                                        struct nfs_fattr *fattr,
+                                        rpc_authflavor_t authflavor)
 {
         struct nfs_clone_mount mountdata = {
-                .sb = mnt_parent->mnt_sb,
+                .sb = dentry->d_sb,
                 .dentry = dentry,
                 .fh = fh,
                 .fattr = fattr,
+                .authflavor = authflavor,
         };
         struct vfsmount *mnt = ERR_PTR(-ENOMEM);
         char *page = (char *) __get_free_page(GFP_USER);
@@ -251,11 +356,11 @@ static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
                         dentry->d_name.name);
         if (page == NULL)
                 goto out;
-        devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
+        devname = nfs_devname(dentry, page, PAGE_SIZE);
         mnt = (struct vfsmount *)devname;
         if (IS_ERR(devname))
                 goto free_page;
-        mnt = nfs_do_clone_mount(NFS_SB(mnt_parent->mnt_sb), devname, &mountdata);
+        mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), devname, &mountdata);
 free_page:
         free_page((unsigned long)page);
 out: