[PATCH] introduce a "kernel-internal pipe object" abstraction
authorIngo Molnar <mingo@elte.hu>
Mon, 10 Apr 2006 13:18:35 +0000 (15:18 +0200)
committerJens Axboe <axboe@suse.de>
Mon, 10 Apr 2006 13:18:35 +0000 (15:18 +0200)
separate out the 'internal pipe object' abstraction, and make it
usable to splice. This cleans up and fixes several aspects of the
internal splice APIs and the pipe code:

 - pipes: the allocation and freeing of pipe_inode_info is now more symmetric
   and more streamlined with existing kernel practices.

 - splice: small micro-optimization: less pointer dereferencing in splice
   methods

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Update XFS for the ->splice_read/->splice_write changes.

Signed-off-by: Jens Axboe <axboe@suse.de>
fs/fifo.c
fs/pipe.c
fs/splice.c
fs/xfs/linux-2.6/xfs_file.c
fs/xfs/linux-2.6/xfs_lrw.c
fs/xfs/linux-2.6/xfs_lrw.h
fs/xfs/linux-2.6/xfs_vnode.h
include/linux/fs.h
include/linux/pipe_fs_i.h

index 889f722ee36d638c5379634ebe2eb54c1055e58e..b16e2f597d6145bcf512fe7ba0a34638e97c4040 100644 (file)
--- a/fs/fifo.c
+++ b/fs/fifo.c
 #include <linux/fs.h>
 #include <linux/pipe_fs_i.h>
 
-static void wait_for_partner(struct inode* inode, unsigned intcnt)
+static void wait_for_partner(struct inode* inode, unsigned int *cnt)
 {
        int cur = *cnt; 
-       while(cur == *cnt) {
-               pipe_wait(inode);
-               if(signal_pending(current))
+
+       while (cur == *cnt) {
+               pipe_wait(inode->i_pipe);
+               if (signal_pending(current))
                        break;
        }
 }
@@ -37,7 +38,8 @@ static int fifo_open(struct inode *inode, struct file *filp)
        mutex_lock(PIPE_MUTEX(*inode));
        if (!inode->i_pipe) {
                ret = -ENOMEM;
-               if(!pipe_new(inode))
+               inode->i_pipe = alloc_pipe_info(inode);
+               if (!inode->i_pipe)
                        goto err_nocleanup;
        }
        filp->f_version = 0;
index 795df987cd38bbbe773fcc029084c019c75e5d02..705b4869262765c17124b2c361359686dce6e202 100644 (file)
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -36,7 +36,7 @@
  */
 
 /* Drop the inode semaphore and wait for a pipe event, atomically */
-void pipe_wait(struct inode * inode)
+void pipe_wait(struct pipe_inode_info *pipe)
 {
        DEFINE_WAIT(wait);
 
@@ -44,11 +44,13 @@ void pipe_wait(struct inode * inode)
         * Pipes are system-local resources, so sleeping on them
         * is considered a noninteractive wait:
         */
-       prepare_to_wait(PIPE_WAIT(*inode), &wait, TASK_INTERRUPTIBLE|TASK_NONINTERACTIVE);
-       mutex_unlock(PIPE_MUTEX(*inode));
+       prepare_to_wait(&pipe->wait, &wait, TASK_INTERRUPTIBLE|TASK_NONINTERACTIVE);
+       if (pipe->inode)
+               mutex_unlock(&pipe->inode->i_mutex);
        schedule();
-       finish_wait(PIPE_WAIT(*inode), &wait);
-       mutex_lock(PIPE_MUTEX(*inode));
+       finish_wait(&pipe->wait, &wait);
+       if (pipe->inode)
+               mutex_lock(&pipe->inode->i_mutex);
 }
 
 static int
@@ -223,7 +225,7 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
                        wake_up_interruptible_sync(PIPE_WAIT(*inode));
                        kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
                }
-               pipe_wait(inode);
+               pipe_wait(inode->i_pipe);
        }
        mutex_unlock(PIPE_MUTEX(*inode));
        /* Signal writers asynchronously that there is more room.  */
@@ -370,7 +372,7 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
                        do_wakeup = 0;
                }
                PIPE_WAITING_WRITERS(*inode)++;
-               pipe_wait(inode);
+               pipe_wait(inode->i_pipe);
                PIPE_WAITING_WRITERS(*inode)--;
        }
 out:
@@ -675,6 +677,20 @@ static struct file_operations rdwr_pipe_fops = {
        .fasync         = pipe_rdwr_fasync,
 };
 
+struct pipe_inode_info * alloc_pipe_info(struct inode *inode)
+{
+       struct pipe_inode_info *info;
+
+       info = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
+       if (info) {
+               init_waitqueue_head(&info->wait);
+               info->r_counter = info->w_counter = 1;
+               info->inode = inode;
+       }
+
+       return info;
+}
+
 void free_pipe_info(struct inode *inode)
 {
        int i;
@@ -691,23 +707,6 @@ void free_pipe_info(struct inode *inode)
        kfree(info);
 }
 
-struct inode* pipe_new(struct inode* inode)
-{
-       struct pipe_inode_info *info;
-
-       info = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
-       if (!info)
-               goto fail_page;
-       inode->i_pipe = info;
-
-       init_waitqueue_head(PIPE_WAIT(*inode));
-       PIPE_RCOUNTER(*inode) = PIPE_WCOUNTER(*inode) = 1;
-
-       return inode;
-fail_page:
-       return NULL;
-}
-
 static struct vfsmount *pipe_mnt __read_mostly;
 static int pipefs_delete_dentry(struct dentry *dentry)
 {
@@ -724,8 +723,10 @@ static struct inode * get_pipe_inode(void)
        if (!inode)
                goto fail_inode;
 
-       if(!pipe_new(inode))
+       inode->i_pipe = alloc_pipe_info(inode);
+       if (!inode->i_pipe)
                goto fail_iput;
+
        PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
        inode->i_fop = &rdwr_pipe_fops;
 
index 9bfd6af0cf452a4a558ea4b88c9044777d924502..ed91a62402e028e81e4ebedb895fae6556b17a38 100644 (file)
@@ -136,34 +136,33 @@ static struct pipe_buf_operations page_cache_pipe_buf_ops = {
  * Pipe output worker. This sets up our pipe format with the page cache
  * pipe buffer operations. Otherwise very similar to the regular pipe_writev().
  */
-static ssize_t move_to_pipe(struct inode *inode, struct page **pages,
+static ssize_t move_to_pipe(struct pipe_inode_info *pipe, struct page **pages,
                            int nr_pages, unsigned long offset,
                            unsigned long len, unsigned int flags)
 {
-       struct pipe_inode_info *info;
        int ret, do_wakeup, i;
 
        ret = 0;
        do_wakeup = 0;
        i = 0;
 
-       mutex_lock(PIPE_MUTEX(*inode));
+       if (pipe->inode)
+               mutex_lock(&pipe->inode->i_mutex);
 
-       info = inode->i_pipe;
        for (;;) {
                int bufs;
 
-               if (!PIPE_READERS(*inode)) {
+               if (!pipe->readers) {
                        send_sig(SIGPIPE, current, 0);
                        if (!ret)
                                ret = -EPIPE;
                        break;
                }
 
-               bufs = info->nrbufs;
+               bufs = pipe->nrbufs;
                if (bufs < PIPE_BUFFERS) {
-                       int newbuf = (info->curbuf + bufs) & (PIPE_BUFFERS - 1);
-                       struct pipe_buffer *buf = info->bufs + newbuf;
+                       int newbuf = (pipe->curbuf + bufs) & (PIPE_BUFFERS - 1);
+                       struct pipe_buffer *buf = pipe->bufs + newbuf;
                        struct page *page = pages[i++];
                        unsigned long this_len;
 
@@ -175,7 +174,7 @@ static ssize_t move_to_pipe(struct inode *inode, struct page **pages,
                        buf->offset = offset;
                        buf->len = this_len;
                        buf->ops = &page_cache_pipe_buf_ops;
-                       info->nrbufs = ++bufs;
+                       pipe->nrbufs = ++bufs;
                        do_wakeup = 1;
 
                        ret += this_len;
@@ -205,25 +204,25 @@ static ssize_t move_to_pipe(struct inode *inode, struct page **pages,
 
                if (do_wakeup) {
                        smp_mb();
-                       if (waitqueue_active(PIPE_WAIT(*inode)))
-                               wake_up_interruptible_sync(PIPE_WAIT(*inode));
-                       kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO,
-                                   POLL_IN);
+                       if (waitqueue_active(&pipe->wait))
+                               wake_up_interruptible_sync(&pipe->wait);
+                       kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
                        do_wakeup = 0;
                }
 
-               PIPE_WAITING_WRITERS(*inode)++;
-               pipe_wait(inode);
-               PIPE_WAITING_WRITERS(*inode)--;
+               pipe->waiting_writers++;
+               pipe_wait(pipe);
+               pipe->waiting_writers--;
        }
 
-       mutex_unlock(PIPE_MUTEX(*inode));
+       if (pipe->inode)
+               mutex_unlock(&pipe->inode->i_mutex);
 
        if (do_wakeup) {
                smp_mb();
-               if (waitqueue_active(PIPE_WAIT(*inode)))
-                       wake_up_interruptible(PIPE_WAIT(*inode));
-               kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
+               if (waitqueue_active(&pipe->wait))
+                       wake_up_interruptible(&pipe->wait);
+               kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
        }
 
        while (i < nr_pages)
@@ -232,8 +231,9 @@ static ssize_t move_to_pipe(struct inode *inode, struct page **pages,
        return ret;
 }
 
-static int __generic_file_splice_read(struct file *in, struct inode *pipe,
-                                     size_t len, unsigned int flags)
+static int
+__generic_file_splice_read(struct file *in, struct pipe_inode_info *pipe,
+                          size_t len, unsigned int flags)
 {
        struct address_space *mapping = in->f_mapping;
        unsigned int offset, nr_pages;
@@ -298,7 +298,7 @@ static int __generic_file_splice_read(struct file *in, struct inode *pipe,
  * Will read pages from given file and fill them into a pipe.
  *
  */
-ssize_t generic_file_splice_read(struct file *in, struct inode *pipe,
+ssize_t generic_file_splice_read(struct file *in, struct pipe_inode_info *pipe,
                                 size_t len, unsigned int flags)
 {
        ssize_t spliced;
@@ -306,6 +306,7 @@ ssize_t generic_file_splice_read(struct file *in, struct inode *pipe,
 
        ret = 0;
        spliced = 0;
+
        while (len) {
                ret = __generic_file_splice_read(in, pipe, len, flags);
 
@@ -509,11 +510,10 @@ typedef int (splice_actor)(struct pipe_inode_info *, struct pipe_buffer *,
  * key here is the 'actor' worker passed in that actually moves the data
  * to the wanted destination. See pipe_to_file/pipe_to_sendpage above.
  */
-static ssize_t move_from_pipe(struct inode *inode, struct file *out,
+static ssize_t move_from_pipe(struct pipe_inode_info *pipe, struct file *out,
                              size_t len, unsigned int flags,
                              splice_actor *actor)
 {
-       struct pipe_inode_info *info;
        int ret, do_wakeup, err;
        struct splice_desc sd;
 
@@ -525,22 +525,22 @@ static ssize_t move_from_pipe(struct inode *inode, struct file *out,
        sd.file = out;
        sd.pos = out->f_pos;
 
-       mutex_lock(PIPE_MUTEX(*inode));
+       if (pipe->inode)
+               mutex_lock(&pipe->inode->i_mutex);
 
-       info = inode->i_pipe;
        for (;;) {
-               int bufs = info->nrbufs;
+               int bufs = pipe->nrbufs;
 
                if (bufs) {
-                       int curbuf = info->curbuf;
-                       struct pipe_buffer *buf = info->bufs + curbuf;
+                       int curbuf = pipe->curbuf;
+                       struct pipe_buffer *buf = pipe->bufs + curbuf;
                        struct pipe_buf_operations *ops = buf->ops;
 
                        sd.len = buf->len;
                        if (sd.len > sd.total_len)
                                sd.len = sd.total_len;
 
-                       err = actor(info, buf, &sd);
+                       err = actor(pipe, buf, &sd);
                        if (err) {
                                if (!ret && err != -ENODATA)
                                        ret = err;
@@ -553,10 +553,10 @@ static ssize_t move_from_pipe(struct inode *inode, struct file *out,
                        buf->len -= sd.len;
                        if (!buf->len) {
                                buf->ops = NULL;
-                               ops->release(info, buf);
+                               ops->release(pipe, buf);
                                curbuf = (curbuf + 1) & (PIPE_BUFFERS - 1);
-                               info->curbuf = curbuf;
-                               info->nrbufs = --bufs;
+                               pipe->curbuf = curbuf;
+                               pipe->nrbufs = --bufs;
                                do_wakeup = 1;
                        }
 
@@ -568,9 +568,9 @@ static ssize_t move_from_pipe(struct inode *inode, struct file *out,
 
                if (bufs)
                        continue;
-               if (!PIPE_WRITERS(*inode))
+               if (!pipe->writers)
                        break;
-               if (!PIPE_WAITING_WRITERS(*inode)) {
+               if (!pipe->waiting_writers) {
                        if (ret)
                                break;
                }
@@ -589,22 +589,23 @@ static ssize_t move_from_pipe(struct inode *inode, struct file *out,
 
                if (do_wakeup) {
                        smp_mb();
-                       if (waitqueue_active(PIPE_WAIT(*inode)))
-                               wake_up_interruptible_sync(PIPE_WAIT(*inode));
-                       kill_fasync(PIPE_FASYNC_WRITERS(*inode),SIGIO,POLL_OUT);
+                       if (waitqueue_active(&pipe->wait))
+                               wake_up_interruptible_sync(&pipe->wait);
+                       kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
                        do_wakeup = 0;
                }
 
-               pipe_wait(inode);
+               pipe_wait(pipe);
        }
 
-       mutex_unlock(PIPE_MUTEX(*inode));
+       if (pipe->inode)
+               mutex_unlock(&pipe->inode->i_mutex);
 
        if (do_wakeup) {
                smp_mb();
-               if (waitqueue_active(PIPE_WAIT(*inode)))
-                       wake_up_interruptible(PIPE_WAIT(*inode));
-               kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
+               if (waitqueue_active(&pipe->wait))
+                       wake_up_interruptible(&pipe->wait);
+               kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
        }
 
        mutex_lock(&out->f_mapping->host->i_mutex);
@@ -616,7 +617,7 @@ static ssize_t move_from_pipe(struct inode *inode, struct file *out,
 
 /**
  * generic_file_splice_write - splice data from a pipe to a file
- * @inode:     pipe inode
+ * @pipe:      pipe info
  * @out:       file to write to
  * @len:       number of bytes to splice
  * @flags:     splice modifier flags
@@ -625,11 +626,14 @@ static ssize_t move_from_pipe(struct inode *inode, struct file *out,
  * the given pipe inode to the given file.
  *
  */
-ssize_t generic_file_splice_write(struct inode *inode, struct file *out,
-                                 size_t len, unsigned int flags)
+ssize_t
+generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
+                         size_t len, unsigned int flags)
 {
        struct address_space *mapping = out->f_mapping;
-       ssize_t ret = move_from_pipe(inode, out, len, flags, pipe_to_file);
+       ssize_t ret;
+
+       ret = move_from_pipe(pipe, out, len, flags, pipe_to_file);
 
        /*
         * if file or inode is SYNC and we actually wrote some data, sync it
@@ -664,10 +668,10 @@ EXPORT_SYMBOL(generic_file_splice_write);
  * is involved.
  *
  */
-ssize_t generic_splice_sendpage(struct inode *inode, struct file *out,
+ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe, struct file *out,
                                size_t len, unsigned int flags)
 {
-       return move_from_pipe(inode, out, len, flags, pipe_to_sendpage);
+       return move_from_pipe(pipe, out, len, flags, pipe_to_sendpage);
 }
 
 EXPORT_SYMBOL(generic_splice_sendpage);
@@ -675,8 +679,8 @@ EXPORT_SYMBOL(generic_splice_sendpage);
 /*
  * Attempt to initiate a splice from pipe to file.
  */
-static long do_splice_from(struct inode *pipe, struct file *out, size_t len,
-                          unsigned int flags)
+static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
+                          size_t len, unsigned int flags)
 {
        loff_t pos;
        int ret;
@@ -698,8 +702,8 @@ static long do_splice_from(struct inode *pipe, struct file *out, size_t len,
 /*
  * Attempt to initiate a splice from a file to a pipe.
  */
-static long do_splice_to(struct file *in, struct inode *pipe, size_t len,
-                        unsigned int flags)
+static long do_splice_to(struct file *in, struct pipe_inode_info *pipe,
+                        size_t len, unsigned int flags)
 {
        loff_t pos, isize, left;
        int ret;
@@ -732,14 +736,14 @@ static long do_splice_to(struct file *in, struct inode *pipe, size_t len,
 static long do_splice(struct file *in, struct file *out, size_t len,
                      unsigned int flags)
 {
-       struct inode *pipe;
+       struct pipe_inode_info *pipe;
 
-       pipe = in->f_dentry->d_inode;
-       if (pipe->i_pipe)
+       pipe = in->f_dentry->d_inode->i_pipe;
+       if (pipe)
                return do_splice_from(pipe, out, len, flags);
 
-       pipe = out->f_dentry->d_inode;
-       if (pipe->i_pipe)
+       pipe = out->f_dentry->d_inode->i_pipe;
+       if (pipe)
                return do_splice_to(in, pipe, len, flags);
 
        return -EINVAL;
index ae4c4754ed3185446023f8f25c0efd068104b19d..269721af02f3bf4390ac325b54f64f05435ee960 100644 (file)
@@ -252,7 +252,7 @@ xfs_file_sendfile_invis(
 STATIC ssize_t
 xfs_file_splice_read(
        struct file             *infilp,
-       struct inode            *pipe,
+       struct pipe_inode_info  *pipe,
        size_t                  len,
        unsigned int            flags)
 {
@@ -266,7 +266,7 @@ xfs_file_splice_read(
 STATIC ssize_t
 xfs_file_splice_read_invis(
        struct file             *infilp,
-       struct inode            *pipe,
+       struct pipe_inode_info  *pipe,
        size_t                  len,
        unsigned int            flags)
 {
@@ -279,7 +279,7 @@ xfs_file_splice_read_invis(
 
 STATIC ssize_t
 xfs_file_splice_write(
-       struct inode            *pipe,
+       struct pipe_inode_info  *pipe,
        struct file             *outfilp,
        size_t                  len,
        unsigned int            flags)
@@ -293,7 +293,7 @@ xfs_file_splice_write(
 
 STATIC ssize_t
 xfs_file_splice_write_invis(
-       struct inode            *pipe,
+       struct pipe_inode_info  *pipe,
        struct file             *outfilp,
        size_t                  len,
        unsigned int            flags)
index 90cd314acbaa7bc742af0509f263dd18053b5d74..74a52937f20848159949ccb64ad63f030fc2be7e 100644 (file)
@@ -338,7 +338,7 @@ ssize_t
 xfs_splice_read(
        bhv_desc_t              *bdp,
        struct file             *infilp,
-       struct inode            *pipe,
+       struct pipe_inode_info  *pipe,
        size_t                  count,
        int                     flags,
        int                     ioflags,
@@ -380,7 +380,7 @@ xfs_splice_read(
 ssize_t
 xfs_splice_write(
        bhv_desc_t              *bdp,
-       struct inode            *pipe,
+       struct pipe_inode_info  *pipe,
        struct file             *outfilp,
        size_t                  count,
        int                     flags,
index eaa5659713fb8d9535eb2c08bed9a7e621839d35..55c689a86ad2e9b40f1dece835952d73e412cd2c 100644 (file)
@@ -94,9 +94,9 @@ extern ssize_t xfs_sendfile(struct bhv_desc *, struct file *,
                                loff_t *, int, size_t, read_actor_t,
                                void *, struct cred *);
 extern ssize_t xfs_splice_read(struct bhv_desc *, struct file *,
-                               struct inode *, size_t, int, int,
+                               struct pipe_inode_info *, size_t, int, int,
                                struct cred *);
-extern ssize_t xfs_splice_write(struct bhv_desc *, struct inode *,
+extern ssize_t xfs_splice_write(struct bhv_desc *, struct pipe_inode_info *,
                                struct file *, size_t, int, int,
                                struct cred *);
 
index 6f1c79a28f8bee1e1faac2a2ced7b5acce9bacca..88b09f18628995ccb3c8d61dc6923260f3438b24 100644 (file)
@@ -174,9 +174,9 @@ typedef ssize_t (*vop_sendfile_t)(bhv_desc_t *, struct file *,
                                loff_t *, int, size_t, read_actor_t,
                                void *, struct cred *);
 typedef ssize_t (*vop_splice_read_t)(bhv_desc_t *, struct file *,
-                               struct inode *, size_t, int, int,
+                               struct pipe_inode_info *, size_t, int, int,
                                struct cred *);
-typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct inode *,
+typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct pipe_inode_info *,
                                struct file *, size_t, int, int,
                                struct cred *);
 typedef int    (*vop_ioctl_t)(bhv_desc_t *, struct inode *, struct file *,
index 1e9ebaba07b7a2d1c8436ef95cdb5b5799dc1fce..7e6454454fbd5395080e846c30ce3e7ebb3e6d79 100644 (file)
@@ -1039,8 +1039,8 @@ struct file_operations {
        int (*check_flags)(int);
        int (*dir_notify)(struct file *filp, unsigned long arg);
        int (*flock) (struct file *, int, struct file_lock *);
-       ssize_t (*splice_write)(struct inode *, struct file *, size_t, unsigned int);
-       ssize_t (*splice_read)(struct file *, struct inode *, size_t, unsigned int);
+       ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, size_t, unsigned int);
+       ssize_t (*splice_read)(struct file *, struct pipe_inode_info *, size_t, unsigned int);
 };
 
 struct inode_operations {
@@ -1611,8 +1611,8 @@ extern ssize_t generic_file_sendfile(struct file *, loff_t *, size_t, read_actor
 extern void do_generic_mapping_read(struct address_space *mapping,
                                    struct file_ra_state *, struct file *,
                                    loff_t *, read_descriptor_t *, read_actor_t);
-extern ssize_t generic_file_splice_read(struct file *, struct inode *, size_t, unsigned int);
-extern ssize_t generic_file_splice_write(struct inode *, struct file *, size_t, unsigned int);
+extern ssize_t generic_file_splice_read(struct file *, struct pipe_inode_info *, size_t, unsigned int);
+extern ssize_t generic_file_splice_write(struct pipe_inode_info *, struct file *, size_t, unsigned int);
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
 extern ssize_t generic_file_readv(struct file *filp, const struct iovec *iov, 
index ec384958d509690090aa1936b4624cb3da05b2d8..9cf99cb34c1537aeb881155aef14e895240610af 100644 (file)
@@ -36,6 +36,7 @@ struct pipe_inode_info {
        unsigned int w_counter;
        struct fasync_struct *fasync_readers;
        struct fasync_struct *fasync_writers;
+       struct inode *inode;
 };
 
 /* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
@@ -53,10 +54,10 @@ struct pipe_inode_info {
 #define PIPE_FASYNC_WRITERS(inode)     (&((inode).i_pipe->fasync_writers))
 
 /* Drop the inode semaphore and wait for a pipe event, atomically */
-void pipe_wait(struct inode * inode);
+void pipe_wait(struct pipe_inode_info *pipe);
 
-struct inode* pipe_new(struct inode* inode);
-void free_pipe_info(struct inode* inode);
+struct pipe_inode_info * alloc_pipe_info(struct inode * inode);
+void free_pipe_info(struct inode * inode);
 
 /*
  * splice is tied to pipes as a transport (at least for now), so we'll just