SUNRPC: Ensure that rpc_mkpipe returns a refcounted dentry

[linux-2.6-omap-h63xx.git] / net / sunrpc / rpc_pipe.c

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 24cc23af9b95d7d0ca1950ce7bcaf5ac098bdc6f..72b22172f0aff0f66e9c635a2b7600eddb47b104 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -38,44 +38,42 @@ static kmem_cache_t *rpc_inode_cachep __read_mostly;
 
 #define RPC_UPCALL_TIMEOUT (30*HZ)
 
-static void
-__rpc_purge_list(struct rpc_inode *rpci, struct list_head *head, int err)
+static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
+               void (*destroy_msg)(struct rpc_pipe_msg *), int err)
 {
        struct rpc_pipe_msg *msg;
-       void (*destroy_msg)(struct rpc_pipe_msg *);
 
-       destroy_msg = rpci->ops->destroy_msg;
-       while (!list_empty(head)) {
+       if (list_empty(head))
+               return;
+       do {
                msg = list_entry(head->next, struct rpc_pipe_msg, list);
-               list_del_init(&msg->list);
+               list_del(&msg->list);
                msg->errno = err;
                destroy_msg(msg);
-       }
-}
-
-static void
-__rpc_purge_upcall(struct inode *inode, int err)
-{
-       struct rpc_inode *rpci = RPC_I(inode);
-
-       __rpc_purge_list(rpci, &rpci->pipe, err);
-       rpci->pipelen = 0;
+       } while (!list_empty(head));
        wake_up(&rpci->waitq);
 }
 
 static void
 rpc_timeout_upcall_queue(void *data)
 {
+       LIST_HEAD(free_list);
        struct rpc_inode *rpci = (struct rpc_inode *)data;
        struct inode *inode = &rpci->vfs_inode;
+       void (*destroy_msg)(struct rpc_pipe_msg *);
 
-       down(&inode->i_sem);
-       if (rpci->ops == NULL)
-               goto out;
-       if (rpci->nreaders == 0 && !list_empty(&rpci->pipe))
-               __rpc_purge_upcall(inode, -ETIMEDOUT);
-out:
-       up(&inode->i_sem);
+       spin_lock(&inode->i_lock);
+       if (rpci->ops == NULL) {
+               spin_unlock(&inode->i_lock);
+               return;
+       }
+       destroy_msg = rpci->ops->destroy_msg;
+       if (rpci->nreaders == 0) {
+               list_splice_init(&rpci->pipe, &free_list);
+               rpci->pipelen = 0;
+       }
+       spin_unlock(&inode->i_lock);
+       rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
 }
 
 int
@@ -84,7 +82,7 @@ rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
        struct rpc_inode *rpci = RPC_I(inode);
        int res = -EPIPE;
 
-       down(&inode->i_sem);
+       spin_lock(&inode->i_lock);
        if (rpci->ops == NULL)
                goto out;
        if (rpci->nreaders) {
@@ -93,14 +91,15 @@ rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
                res = 0;
        } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
                if (list_empty(&rpci->pipe))
-                       schedule_delayed_work(&rpci->queue_timeout,
+                       queue_delayed_work(rpciod_workqueue,
+                                       &rpci->queue_timeout,
                                        RPC_UPCALL_TIMEOUT);
                list_add_tail(&msg->list, &rpci->pipe);
                rpci->pipelen += msg->len;
                res = 0;
        }
 out:
-       up(&inode->i_sem);
+       spin_unlock(&inode->i_lock);
        wake_up(&rpci->waitq);
        return res;
 }
@@ -115,21 +114,29 @@ static void
 rpc_close_pipes(struct inode *inode)
 {
        struct rpc_inode *rpci = RPC_I(inode);
+       struct rpc_pipe_ops *ops;
 
-       down(&inode->i_sem);
-       if (rpci->ops != NULL) {
+       mutex_lock(&inode->i_mutex);
+       ops = rpci->ops;
+       if (ops != NULL) {
+               LIST_HEAD(free_list);
+
+               spin_lock(&inode->i_lock);
                rpci->nreaders = 0;
-               __rpc_purge_list(rpci, &rpci->in_upcall, -EPIPE);
-               __rpc_purge_upcall(inode, -EPIPE);
-               rpci->nwriters = 0;
-               if (rpci->ops->release_pipe)
-                       rpci->ops->release_pipe(inode);
+               list_splice_init(&rpci->in_upcall, &free_list);
+               list_splice_init(&rpci->pipe, &free_list);
+               rpci->pipelen = 0;
                rpci->ops = NULL;
+               spin_unlock(&inode->i_lock);
+               rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
+               rpci->nwriters = 0;
+               if (ops->release_pipe)
+                       ops->release_pipe(inode);
+               cancel_delayed_work(&rpci->queue_timeout);
+               flush_workqueue(rpciod_workqueue);
        }
        rpc_inode_setowner(inode, NULL);
-       up(&inode->i_sem);
-       cancel_delayed_work(&rpci->queue_timeout);
-       flush_scheduled_work();
+       mutex_unlock(&inode->i_mutex);
 }
 
 static struct inode *
@@ -154,7 +161,7 @@ rpc_pipe_open(struct inode *inode, struct file *filp)
        struct rpc_inode *rpci = RPC_I(inode);
        int res = -ENXIO;
 
-       down(&inode->i_sem);
+       mutex_lock(&inode->i_mutex);
        if (rpci->ops != NULL) {
                if (filp->f_mode & FMODE_READ)
                        rpci->nreaders ++;
@@ -162,7 +169,7 @@ rpc_pipe_open(struct inode *inode, struct file *filp)
                        rpci->nwriters ++;
                res = 0;
        }
-       up(&inode->i_sem);
+       mutex_unlock(&inode->i_mutex);
        return res;
 }
 
@@ -172,25 +179,35 @@ rpc_pipe_release(struct inode *inode, struct file *filp)
        struct rpc_inode *rpci = RPC_I(inode);
        struct rpc_pipe_msg *msg;
 
-       down(&inode->i_sem);
+       mutex_lock(&inode->i_mutex);
        if (rpci->ops == NULL)
                goto out;
        msg = (struct rpc_pipe_msg *)filp->private_data;
        if (msg != NULL) {
+               spin_lock(&inode->i_lock);
                msg->errno = -EAGAIN;
-               list_del_init(&msg->list);
+               list_del(&msg->list);
+               spin_unlock(&inode->i_lock);
                rpci->ops->destroy_msg(msg);
        }
        if (filp->f_mode & FMODE_WRITE)
                rpci->nwriters --;
-       if (filp->f_mode & FMODE_READ)
+       if (filp->f_mode & FMODE_READ) {
                rpci->nreaders --;
-       if (!rpci->nreaders)
-               __rpc_purge_upcall(inode, -EAGAIN);
+               if (rpci->nreaders == 0) {
+                       LIST_HEAD(free_list);
+                       spin_lock(&inode->i_lock);
+                       list_splice_init(&rpci->pipe, &free_list);
+                       rpci->pipelen = 0;
+                       spin_unlock(&inode->i_lock);
+                       rpc_purge_list(rpci, &free_list,
+                                       rpci->ops->destroy_msg, -EAGAIN);
+               }
+       }
        if (rpci->ops->release_pipe)
                rpci->ops->release_pipe(inode);
 out:
-       up(&inode->i_sem);
+       mutex_unlock(&inode->i_mutex);
        return 0;
 }
 
@@ -202,13 +219,14 @@ rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
        struct rpc_pipe_msg *msg;
        int res = 0;
 
-       down(&inode->i_sem);
+       mutex_lock(&inode->i_mutex);
        if (rpci->ops == NULL) {
                res = -EPIPE;
                goto out_unlock;
        }
        msg = filp->private_data;
        if (msg == NULL) {
+               spin_lock(&inode->i_lock);
                if (!list_empty(&rpci->pipe)) {
                        msg = list_entry(rpci->pipe.next,
                                        struct rpc_pipe_msg,
@@ -218,6 +236,7 @@ rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
                        filp->private_data = msg;
                        msg->copied = 0;
                }
+               spin_unlock(&inode->i_lock);
                if (msg == NULL)
                        goto out_unlock;
        }
@@ -225,11 +244,13 @@ rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
        res = rpci->ops->upcall(filp, msg, buf, len);
        if (res < 0 || msg->len == msg->copied) {
                filp->private_data = NULL;
-               list_del_init(&msg->list);
+               spin_lock(&inode->i_lock);
+               list_del(&msg->list);
+               spin_unlock(&inode->i_lock);
                rpci->ops->destroy_msg(msg);
        }
 out_unlock:
-       up(&inode->i_sem);
+       mutex_unlock(&inode->i_mutex);
        return res;
 }
 
@@ -240,11 +261,11 @@ rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *of
        struct rpc_inode *rpci = RPC_I(inode);
        int res;
 
-       down(&inode->i_sem);
+       mutex_lock(&inode->i_mutex);
        res = -EPIPE;
        if (rpci->ops != NULL)
                res = rpci->ops->downcall(filp, buf, len);
-       up(&inode->i_sem);
+       mutex_unlock(&inode->i_mutex);
        return res;
 }
 
@@ -322,7 +343,7 @@ rpc_info_open(struct inode *inode, struct file *file)
 
        if (!ret) {
                struct seq_file *m = file->private_data;
-               down(&inode->i_sem);
+               mutex_lock(&inode->i_mutex);
                clnt = RPC_I(inode)->private;
                if (clnt) {
                        atomic_inc(&clnt->cl_users);
@@ -331,7 +352,7 @@ rpc_info_open(struct inode *inode, struct file *file)
                        single_release(inode, file);
                        ret = -EINVAL;
                }
-               up(&inode->i_sem);
+               mutex_unlock(&inode->i_mutex);
        }
        return ret;
 }
@@ -491,11 +512,11 @@ rpc_depopulate(struct dentry *parent)
        struct dentry *dentry, *dvec[10];
        int n = 0;
 
-       down(&dir->i_sem);
+       mutex_lock(&dir->i_mutex);
 repeat:
        spin_lock(&dcache_lock);
        list_for_each_safe(pos, next, &parent->d_subdirs) {
-               dentry = list_entry(pos, struct dentry, d_child);
+               dentry = list_entry(pos, struct dentry, d_u.d_child);
                spin_lock(&dentry->d_lock);
                if (!d_unhashed(dentry)) {
                        dget_locked(dentry);
@@ -519,7 +540,7 @@ repeat:
                } while (n);
                goto repeat;
        }
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
 }
 
 static int
@@ -532,7 +553,7 @@ rpc_populate(struct dentry *parent,
        struct dentry *dentry;
        int mode, i;
 
-       down(&dir->i_sem);
+       mutex_lock(&dir->i_mutex);
        for (i = start; i < eof; i++) {
                dentry = d_alloc_name(parent, files[i].name);
                if (!dentry)
@@ -552,10 +573,10 @@ rpc_populate(struct dentry *parent,
                        dir->i_nlink++;
                d_add(dentry, inode);
        }
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        return 0;
 out_bad:
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
                        __FILE__, __FUNCTION__, parent->d_name.name);
        return -ENOMEM;
@@ -609,8 +630,8 @@ rpc_lookup_negative(char *path, struct nameidata *nd)
        if ((error = rpc_lookup_parent(path, nd)) != 0)
                return ERR_PTR(error);
        dir = nd->dentry->d_inode;
-       down(&dir->i_sem);
-       dentry = lookup_hash(nd);
+       mutex_lock(&dir->i_mutex);
+       dentry = lookup_one_len(nd->last.name, nd->dentry, nd->last.len);
        if (IS_ERR(dentry))
                goto out_err;
        if (dentry->d_inode) {
@@ -620,7 +641,7 @@ rpc_lookup_negative(char *path, struct nameidata *nd)
        }
        return dentry;
 out_err:
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        rpc_release_path(nd);
        return dentry;
 }
@@ -646,9 +667,9 @@ rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
        if (error)
                goto err_depopulate;
 out:
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        rpc_release_path(&nd);
-       return dentry;
+       return dget(dentry);
 err_depopulate:
        rpc_depopulate(dentry);
        __rpc_rmdir(dir, dentry);
@@ -671,8 +692,8 @@ rpc_rmdir(char *path)
        if ((error = rpc_lookup_parent(path, &nd)) != 0)
                return error;
        dir = nd.dentry->d_inode;
-       down(&dir->i_sem);
-       dentry = lookup_hash(&nd);
+       mutex_lock(&dir->i_mutex);
+       dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
        if (IS_ERR(dentry)) {
                error = PTR_ERR(dentry);
                goto out_release;
@@ -681,7 +702,7 @@ rpc_rmdir(char *path)
        error = __rpc_rmdir(dir, dentry);
        dput(dentry);
 out_release:
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        rpc_release_path(&nd);
        return error;
 }
@@ -710,9 +731,9 @@ rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
        rpci->ops = ops;
        inode_dir_notify(dir, DN_CREATE);
 out:
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        rpc_release_path(&nd);
-       return dentry;
+       return dget(dentry);
 err_dput:
        dput(dentry);
        dentry = ERR_PTR(-ENOMEM);
@@ -732,8 +753,8 @@ rpc_unlink(char *path)
        if ((error = rpc_lookup_parent(path, &nd)) != 0)
                return error;
        dir = nd.dentry->d_inode;
-       down(&dir->i_sem);
-       dentry = lookup_hash(&nd);
+       mutex_lock(&dir->i_mutex);
+       dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
        if (IS_ERR(dentry)) {
                error = PTR_ERR(dentry);
                goto out_release;
@@ -746,7 +767,7 @@ rpc_unlink(char *path)
        dput(dentry);
        inode_dir_notify(dir, DN_DELETE);
 out_release:
-       up(&dir->i_sem);
+       mutex_unlock(&dir->i_mutex);
        rpc_release_path(&nd);
        return error;
 }