[PATCH] RPC,NFS: new rpc_pipefs patch

 Currently rpc_mkdir/rpc_rmdir and rpc_mkpipe/mk_unlink have an API that's
 a little unfortunate.  They take a path relative to the rpc_pipefs root and
 thus need to perform a full lookup.  If you look at debugfs or usbfs they
 always store the dentry for directories they created and thus can pass in
 a dentry + single pathname component pair into their equivalents of the
 above functions.

 And in fact rpc_pipefs actually stores a dentry for all but one component so
 this change not only simplifies the core rpc_pipe code but also the callers.

 Unfortuntately this code path is only used by the NFS4 idmapper and
 AUTH_GSSAPI for which I don't have a test enviroment.  Could someone give
 it a spin?  It's the last bit needed before we can rework the
 lookup_hash API

 Signed-off-by: Christoph Hellwig <hch@lst.de>
 Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>

diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index ffb8df9..1d0a5bf 100644 (file)
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -66,7 +66,6 @@ struct idmap_hashtable {
 };
 
 struct idmap {
-       char                  idmap_path[48];
        struct dentry        *idmap_dentry;
        wait_queue_head_t     idmap_wq;
        struct idmap_msg      idmap_im;
@@ -102,11 +101,8 @@ nfs_idmap_new(struct nfs4_client *clp)
 
        memset(idmap, 0, sizeof(*idmap));
 
-       snprintf(idmap->idmap_path, sizeof(idmap->idmap_path),
-           "%s/idmap", clp->cl_rpcclient->cl_pathname);
-
-        idmap->idmap_dentry = rpc_mkpipe(idmap->idmap_path,
-           idmap, &idmap_upcall_ops, 0);
+       idmap->idmap_dentry = rpc_mkpipe(clp->cl_rpcclient->cl_dentry,
+                       "idmap", idmap, &idmap_upcall_ops, 0);
         if (IS_ERR(idmap->idmap_dentry)) {
                kfree(idmap);
                return;
@@ -128,7 +124,7 @@ nfs_idmap_delete(struct nfs4_client *clp)
 
        if (!idmap)
                return;
-       rpc_unlink(idmap->idmap_path);
+       rpc_unlink(idmap->idmap_dentry);
        clp->cl_idmap = NULL;
        kfree(idmap);
 }

diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index ab151bb..b5b51c1 100644 (file)
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -59,7 +59,7 @@ struct rpc_clnt {
 
        int                     cl_nodelen;     /* nodename length */
        char                    cl_nodename[UNX_MAXNODENAME];
-       char                    cl_pathname[30];/* Path in rpc_pipe_fs */
+       struct dentry *         __cl_parent_dentry;
        struct dentry *         cl_dentry;      /* inode */
        struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
        struct rpc_rtt          cl_rtt_default;

diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index 6392934..63878d0 100644 (file)
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -41,10 +41,11 @@ RPC_I(struct inode *inode)
 
 extern int rpc_queue_upcall(struct inode *, struct rpc_pipe_msg *);
 
-extern struct dentry *rpc_mkdir(char *, struct rpc_clnt *);
-extern int rpc_rmdir(char *);
-extern struct dentry *rpc_mkpipe(char *, void *, struct rpc_pipe_ops *, int flags);
-extern int rpc_unlink(char *);
+extern struct dentry *rpc_mkdir(struct dentry *, char *, struct rpc_clnt *);
+extern void rpc_rmdir(struct dentry *);
+extern struct dentry *rpc_mkpipe(struct dentry *, char *, void *,
+               struct rpc_pipe_ops *, int flags);
+extern void rpc_unlink(struct dentry *);
 
 #endif
 #endif

diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index d2b08f1..bd25551 100644 (file)
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -87,7 +87,6 @@ struct gss_auth {
        struct list_head upcalls;
        struct rpc_clnt *client;
        struct dentry *dentry;
-       char path[48];
        spinlock_t lock;
 };
 
@@ -690,10 +689,8 @@ gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
        if (err)
                goto err_put_mech;
 
-       snprintf(gss_auth->path, sizeof(gss_auth->path), "%s/%s",
-                       clnt->cl_pathname,
-                       gss_auth->mech->gm_name);
-       gss_auth->dentry = rpc_mkpipe(gss_auth->path, clnt, &gss_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
+       gss_auth->dentry = rpc_mkpipe(clnt->cl_dentry, gss_auth->mech->gm_name,
+                       clnt, &gss_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
        if (IS_ERR(gss_auth->dentry)) {
                err = PTR_ERR(gss_auth->dentry);
                goto err_put_mech;
@@ -718,7 +715,7 @@ gss_destroy(struct rpc_auth *auth)
                auth, auth->au_flavor);
 
        gss_auth = container_of(auth, struct gss_auth, rpc_auth);
-       rpc_unlink(gss_auth->path);
+       rpc_unlink(gss_auth->dentry);
        gss_mech_put(gss_auth->mech);
 
        rpcauth_free_credcache(auth);

diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 5a8f01d..63bf591 100644 (file)
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -67,26 +67,42 @@ static u32 *        call_verify(struct rpc_task *task);
 static int
 rpc_setup_pipedir(struct rpc_clnt *clnt, char *dir_name)
 {
-       static uint32_t clntid;
+       static unsigned int clntid;
+       char name[128];
        int error;
 
        if (dir_name == NULL)
                return 0;
-       for (;;) {
-               snprintf(clnt->cl_pathname, sizeof(clnt->cl_pathname),
-                               "%s/clnt%x", dir_name,
-                               (unsigned int)clntid++);
-               clnt->cl_pathname[sizeof(clnt->cl_pathname) - 1] = '\0';
-               clnt->cl_dentry = rpc_mkdir(clnt->cl_pathname, clnt);
-               if (!IS_ERR(clnt->cl_dentry))
-                       return 0;
+
+ retry_parent:
+       clnt->__cl_parent_dentry = rpc_mkdir(NULL, dir_name, NULL);
+       if (IS_ERR(clnt->__cl_parent_dentry)) {
+               error = PTR_ERR(clnt->__cl_parent_dentry);
+               if (error == -EEXIST)
+                       goto retry_parent; /* XXX(hch): WTF? */
+       
+               printk(KERN_INFO "RPC: Couldn't create pipefs entry %s, error %d\n",
+                               dir_name, error);
+               return error;
+       }
+
+
+ retry_child:
+       snprintf(name, sizeof(name), "clnt%x", clntid++);
+       name[sizeof(name) - 1] = '\0';
+
+       clnt->cl_dentry = rpc_mkdir(clnt->__cl_parent_dentry, name, clnt);
+       if (IS_ERR(clnt->cl_dentry)) {
                error = PTR_ERR(clnt->cl_dentry);
-               if (error != -EEXIST) {
-                       printk(KERN_INFO "RPC: Couldn't create pipefs entry %s, error %d\n",
-                                       clnt->cl_pathname, error);
-                       return error;
-               }
+               if (error == -EEXIST)
+                       goto retry_child;
+               printk(KERN_INFO "RPC: Couldn't create pipefs entry %s, error %d\n",
+                               name, error);
+               rpc_rmdir(clnt->__cl_parent_dentry);
+               return error;
        }
+
+       return 0;
 }
 
 /*
@@ -174,7 +190,8 @@ rpc_new_client(struct rpc_xprt *xprt, char *servname,
        return clnt;
 
 out_no_auth:
-       rpc_rmdir(clnt->cl_pathname);
+       rpc_rmdir(clnt->cl_dentry);
+       rpc_rmdir(clnt->__cl_parent_dentry);
 out_no_path:
        if (clnt->cl_server != clnt->cl_inline_name)
                kfree(clnt->cl_server);
@@ -302,8 +319,10 @@ rpc_destroy_client(struct rpc_clnt *clnt)
                rpc_destroy_client(clnt->cl_parent);
                goto out_free;
        }
-       if (clnt->cl_pathname[0])
-               rpc_rmdir(clnt->cl_pathname);
+       if (clnt->cl_dentry)
+               rpc_rmdir(clnt->cl_dentry);
+       if (clnt->__cl_parent_dentry)
+               rpc_rmdir(clnt->__cl_parent_dentry);
        if (clnt->cl_xprt) {
                xprt_destroy(clnt->cl_xprt);
                clnt->cl_xprt = NULL;

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index ded6c63..b382809 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -414,38 +414,6 @@ rpc_put_mount(void)
        simple_release_fs(&rpc_mount, &rpc_mount_count);
 }
 
-static int
-rpc_lookup_parent(char *path, struct nameidata *nd)
-{
-       if (path[0] == '\0')
-               return -ENOENT;
-       if (rpc_get_mount()) {
-               printk(KERN_WARNING "%s: %s failed to mount "
-                              "pseudofilesystem \n", __FILE__, __FUNCTION__);
-               return -ENODEV;
-       }
-       nd->mnt = mntget(rpc_mount);
-       nd->dentry = dget(rpc_mount->mnt_root);
-       nd->last_type = LAST_ROOT;
-       nd->flags = LOOKUP_PARENT;
-       nd->depth = 0;
-
-       if (path_walk(path, nd)) {
-               printk(KERN_WARNING "%s: %s failed to find path %s\n",
-                               __FILE__, __FUNCTION__, path);
-               rpc_put_mount();
-               return -ENOENT;
-       }
-       return 0;
-}
-
-static void
-rpc_release_path(struct nameidata *nd)
-{
-       path_release(nd);
-       rpc_put_mount();
-}
-
 static struct inode *
 rpc_get_inode(struct super_block *sb, int mode)
 {
@@ -550,197 +518,149 @@ out_bad:
        return -ENOMEM;
 }
 
-static int
-__rpc_mkdir(struct inode *dir, struct dentry *dentry)
+struct dentry *
+rpc_mkdir(struct dentry *parent, char *name, struct rpc_clnt *rpc_client)
 {
+       struct inode *dir;
+       struct dentry *dentry;
        struct inode *inode;
-
-       inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
-       if (!inode)
-               goto out_err;
-       inode->i_ino = iunique(dir->i_sb, 100);
-       d_instantiate(dentry, inode);
-       dir->i_nlink++;
-       inode_dir_notify(dir, DN_CREATE);
-       rpc_get_mount();
-       return 0;
-out_err:
-       printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
-                       __FILE__, __FUNCTION__, dentry->d_name.name);
-       return -ENOMEM;
-}
-
-static int
-__rpc_rmdir(struct inode *dir, struct dentry *dentry)
-{
        int error;
 
-       shrink_dcache_parent(dentry);
-       if (dentry->d_inode) {
-               rpc_close_pipes(dentry->d_inode);
-               rpc_inode_setowner(dentry->d_inode, NULL);
-       }
-       if ((error = simple_rmdir(dir, dentry)) != 0)
-               return error;
-       if (!error) {
-               inode_dir_notify(dir, DN_DELETE);
-               d_drop(dentry);
-               rpc_put_mount();
-       }
-       return 0;
-}
+       if (!parent)
+               parent = rpc_mount->mnt_root;
 
-static struct dentry *
-rpc_lookup_negative(char *path, struct nameidata *nd)
-{
-       struct dentry *dentry;
-       struct inode *dir;
-       int error;
-
-       if ((error = rpc_lookup_parent(path, nd)) != 0)
+       dir = parent->d_inode;
+       
+       error = rpc_get_mount();
+       if (error)
                return ERR_PTR(error);
-       dir = nd->dentry->d_inode;
+
        down(&dir->i_sem);
-       dentry = lookup_hash(&nd->last, nd->dentry);
+       dentry = lookup_one_len(name, parent, strlen(name));
        if (IS_ERR(dentry))
-               goto out_err;
+               goto out_unlock;
        if (dentry->d_inode) {
-               dput(dentry);
                dentry = ERR_PTR(-EEXIST);
-               goto out_err;
+               goto out_dput;
        }
-       return dentry;
-out_err:
-       up(&dir->i_sem);
-       rpc_release_path(nd);
-       return dentry;
-}
 
+       inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
+       if (!inode)
+               goto out_dput;
+       inode->i_ino = iunique(dir->i_sb, 100);
+       dir->i_nlink++;
+       RPC_I(dentry->d_inode)->private = rpc_client;
 
-struct dentry *
-rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
-{
-       struct nameidata nd;
-       struct dentry *dentry;
-       struct inode *dir;
-       int error;
+       d_instantiate(dentry, inode);
+       dget(dentry);
+       up(&dir->i_sem);
+
+       inode_dir_notify(dir, DN_CREATE);
 
-       dentry = rpc_lookup_negative(path, &nd);
-       if (IS_ERR(dentry))
-               return dentry;
-       dir = nd.dentry->d_inode;
-       if ((error = __rpc_mkdir(dir, dentry)) != 0)
-               goto err_dput;
-       RPC_I(dentry->d_inode)->private = rpc_client;
        error = rpc_populate(dentry, authfiles,
                        RPCAUTH_info, RPCAUTH_EOF);
        if (error)
-               goto err_depopulate;
-out:
-       up(&dir->i_sem);
-       rpc_release_path(&nd);
+               goto out_depopulate;
+
        return dentry;
-err_depopulate:
-       rpc_depopulate(dentry);
-       __rpc_rmdir(dir, dentry);
-err_dput:
+
+ out_depopulate:
+       rpc_rmdir(dentry);
+ out_dput:
        dput(dentry);
-       printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
-                       __FILE__, __FUNCTION__, path, error);
-       dentry = ERR_PTR(error);
-       goto out;
+ out_unlock:
+       up(&dir->i_sem);
+       rpc_put_mount();
+       return dentry;
 }
 
-int
-rpc_rmdir(char *path)
+void
+rpc_rmdir(struct dentry *dentry)
 {
-       struct nameidata nd;
-       struct dentry *dentry;
-       struct inode *dir;
-       int error;
+       struct dentry *parent = dentry->d_parent;
 
-       if ((error = rpc_lookup_parent(path, &nd)) != 0)
-               return error;
-       dir = nd.dentry->d_inode;
-       down(&dir->i_sem);
-       dentry = lookup_hash(&nd.last, nd.dentry);
-       if (IS_ERR(dentry)) {
-               error = PTR_ERR(dentry);
-               goto out_release;
-       }
        rpc_depopulate(dentry);
-       error = __rpc_rmdir(dir, dentry);
-       dput(dentry);
-out_release:
-       up(&dir->i_sem);
-       rpc_release_path(&nd);
-       return error;
+
+       down(&parent->d_inode->i_sem);
+       if (dentry->d_inode) {
+               rpc_close_pipes(dentry->d_inode);
+               rpc_inode_setowner(dentry->d_inode, NULL);
+               simple_rmdir(parent->d_inode, dentry);
+       }
+       up(&parent->d_inode->i_sem);
+
+       inode_dir_notify(parent->d_inode, DN_DELETE);
+       rpc_put_mount();
 }
 
 struct dentry *
-rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
+rpc_mkpipe(struct dentry *parent, char *name, void *private,
+          struct rpc_pipe_ops *ops, int flags)
 {
-       struct nameidata nd;
+       struct inode *dir = parent->d_inode;
        struct dentry *dentry;
-       struct inode *dir, *inode;
+       struct inode *inode;
        struct rpc_inode *rpci;
+       int error;
+
+       error = rpc_get_mount();
+       if (error)
+               return ERR_PTR(error);
 
-       dentry = rpc_lookup_negative(path, &nd);
+       down(&parent->d_inode->i_sem);
+       dentry = lookup_one_len(name, parent, strlen(name));
        if (IS_ERR(dentry))
-               return dentry;
-       dir = nd.dentry->d_inode;
-       inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
-       if (!inode)
-               goto err_dput;
+               goto out_unlock;
+       if (dentry->d_inode) {
+               dentry = ERR_PTR(-EEXIST);
+               goto out_dput;
+       }
+
+       inode = rpc_get_inode(parent->d_inode->i_sb,
+                       S_IFSOCK | S_IRUSR | S_IWUSR);
+       if (!inode) {
+               dentry = ERR_PTR(-ENOMEM);
+               goto out_dput;
+       }
+
        inode->i_ino = iunique(dir->i_sb, 100);
        inode->i_fop = &rpc_pipe_fops;
-       d_instantiate(dentry, inode);
+
        rpci = RPC_I(inode);
        rpci->private = private;
        rpci->flags = flags;
        rpci->ops = ops;
+
+       d_instantiate(dentry, inode);
+       dget(dentry);
+       up(&parent->d_inode->i_sem);
+
        inode_dir_notify(dir, DN_CREATE);
-out:
-       up(&dir->i_sem);
-       rpc_release_path(&nd);
        return dentry;
-err_dput:
+
+ out_dput:
        dput(dentry);
-       dentry = ERR_PTR(-ENOMEM);
-       printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
-                       __FILE__, __FUNCTION__, path, -ENOMEM);
-       goto out;
+ out_unlock:
+       up(&parent->d_inode->i_sem);
+       rpc_put_mount();
+       return dentry;
 }
 
-int
-rpc_unlink(char *path)
+void
+rpc_unlink(struct dentry *dentry)
 {
-       struct nameidata nd;
-       struct dentry *dentry;
-       struct inode *dir;
-       int error;
+       struct dentry *parent = dentry->d_parent;
 
-       if ((error = rpc_lookup_parent(path, &nd)) != 0)
-               return error;
-       dir = nd.dentry->d_inode;
-       down(&dir->i_sem);
-       dentry = lookup_hash(&nd.last, nd.dentry);
-       if (IS_ERR(dentry)) {
-               error = PTR_ERR(dentry);
-               goto out_release;
-       }
-       d_drop(dentry);
+       down(&parent->d_inode->i_sem);
        if (dentry->d_inode) {
                rpc_close_pipes(dentry->d_inode);
                rpc_inode_setowner(dentry->d_inode, NULL);
-               error = simple_unlink(dir, dentry);
+               simple_unlink(parent->d_inode, dentry);
        }
-       dput(dentry);
-       inode_dir_notify(dir, DN_DELETE);
-out_release:
-       up(&dir->i_sem);
-       rpc_release_path(&nd);
-       return error;
+       up(&parent->d_inode->i_sem);
+
+       inode_dir_notify(parent->d_inode, DN_DELETE);
+       rpc_put_mount();
 }
 
 /*