Fix compile issues in fs/compat_ioctl.c when CONFIG_BLOCK is disabled
[linux-2.6.git] / fs / pipe.c
index e2f4f1d..700f4e0 100644 (file)
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -15,6 +15,9 @@
 #include <linux/pipe_fs_i.h>
 #include <linux/uio.h>
 #include <linux/highmem.h>
+#include <linux/pagemap.h>
+#include <linux/audit.h>
+#include <linux/syscalls.h>
 
 #include <asm/uaccess.h>
 #include <asm/ioctls.h>
@@ -35,7 +38,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);
 
@@ -43,15 +46,18 @@ 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);
+       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
-pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len)
+pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len,
+                       int atomic)
 {
        unsigned long copy;
 
@@ -60,8 +66,13 @@ pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len)
                        iov++;
                copy = min_t(unsigned long, len, iov->iov_len);
 
-               if (copy_from_user(to, iov->iov_base, copy))
-                       return -EFAULT;
+               if (atomic) {
+                       if (__copy_from_user_inatomic(to, iov->iov_base, copy))
+                               return -EFAULT;
+               } else {
+                       if (copy_from_user(to, iov->iov_base, copy))
+                               return -EFAULT;
+               }
                to += copy;
                len -= copy;
                iov->iov_base += copy;
@@ -71,7 +82,8 @@ pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len)
 }
 
 static int
-pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len)
+pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len,
+                     int atomic)
 {
        unsigned long copy;
 
@@ -80,8 +92,13 @@ pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len)
                        iov++;
                copy = min_t(unsigned long, len, iov->iov_len);
 
-               if (copy_to_user(iov->iov_base, from, copy))
-                       return -EFAULT;
+               if (atomic) {
+                       if (__copy_to_user_inatomic(iov->iov_base, from, copy))
+                               return -EFAULT;
+               } else {
+                       if (copy_to_user(iov->iov_base, from, copy))
+                               return -EFAULT;
+               }
                from += copy;
                len -= copy;
                iov->iov_base += copy;
@@ -90,40 +107,184 @@ pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len)
        return 0;
 }
 
-static void anon_pipe_buf_release(struct pipe_inode_info *info, struct pipe_buffer *buf)
+/*
+ * Attempt to pre-fault in the user memory, so we can use atomic copies.
+ * Returns the number of bytes not faulted in.
+ */
+static int iov_fault_in_pages_write(struct iovec *iov, unsigned long len)
 {
-       struct page *page = buf->page;
+       while (!iov->iov_len)
+               iov++;
 
-       if (info->tmp_page) {
-               __free_page(page);
-               return;
+       while (len > 0) {
+               unsigned long this_len;
+
+               this_len = min_t(unsigned long, len, iov->iov_len);
+               if (fault_in_pages_writeable(iov->iov_base, this_len))
+                       break;
+
+               len -= this_len;
+               iov++;
        }
-       info->tmp_page = page;
+
+       return len;
+}
+
+/*
+ * Pre-fault in the user memory, so we can use atomic copies.
+ */
+static void iov_fault_in_pages_read(struct iovec *iov, unsigned long len)
+{
+       while (!iov->iov_len)
+               iov++;
+
+       while (len > 0) {
+               unsigned long this_len;
+
+               this_len = min_t(unsigned long, len, iov->iov_len);
+               fault_in_pages_readable(iov->iov_base, this_len);
+               len -= this_len;
+               iov++;
+       }
+}
+
+static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
+                                 struct pipe_buffer *buf)
+{
+       struct page *page = buf->page;
+
+       /*
+        * If nobody else uses this page, and we don't already have a
+        * temporary page, let's keep track of it as a one-deep
+        * allocation cache. (Otherwise just release our reference to it)
+        */
+       if (page_count(page) == 1 && !pipe->tmp_page)
+               pipe->tmp_page = page;
+       else
+               page_cache_release(page);
 }
 
-static void *anon_pipe_buf_map(struct file *file, struct pipe_inode_info *info, struct pipe_buffer *buf)
+/**
+ * generic_pipe_buf_map - virtually map a pipe buffer
+ * @pipe:      the pipe that the buffer belongs to
+ * @buf:       the buffer that should be mapped
+ * @atomic:    whether to use an atomic map
+ *
+ * Description:
+ *     This function returns a kernel virtual address mapping for the
+ *     pipe_buffer passed in @buf. If @atomic is set, an atomic map is provided
+ *     and the caller has to be careful not to fault before calling
+ *     the unmap function.
+ *
+ *     Note that this function occupies KM_USER0 if @atomic != 0.
+ */
+void *generic_pipe_buf_map(struct pipe_inode_info *pipe,
+                          struct pipe_buffer *buf, int atomic)
 {
+       if (atomic) {
+               buf->flags |= PIPE_BUF_FLAG_ATOMIC;
+               return kmap_atomic(buf->page, KM_USER0);
+       }
+
        return kmap(buf->page);
 }
 
-static void anon_pipe_buf_unmap(struct pipe_inode_info *info, struct pipe_buffer *buf)
+/**
+ * generic_pipe_buf_unmap - unmap a previously mapped pipe buffer
+ * @pipe:      the pipe that the buffer belongs to
+ * @buf:       the buffer that should be unmapped
+ * @map_data:  the data that the mapping function returned
+ *
+ * Description:
+ *     This function undoes the mapping that ->map() provided.
+ */
+void generic_pipe_buf_unmap(struct pipe_inode_info *pipe,
+                           struct pipe_buffer *buf, void *map_data)
 {
-       kunmap(buf->page);
+       if (buf->flags & PIPE_BUF_FLAG_ATOMIC) {
+               buf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
+               kunmap_atomic(map_data, KM_USER0);
+       } else
+               kunmap(buf->page);
 }
 
-static struct pipe_buf_operations anon_pipe_buf_ops = {
+/**
+ * generic_pipe_buf_steal - attempt to take ownership of a &pipe_buffer
+ * @pipe:      the pipe that the buffer belongs to
+ * @buf:       the buffer to attempt to steal
+ *
+ * Description:
+ *     This function attempts to steal the &struct page attached to
+ *     @buf. If successful, this function returns 0 and returns with
+ *     the page locked. The caller may then reuse the page for whatever
+ *     he wishes; the typical use is insertion into a different file
+ *     page cache.
+ */
+int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
+                          struct pipe_buffer *buf)
+{
+       struct page *page = buf->page;
+
+       /*
+        * A reference of one is golden, that means that the owner of this
+        * page is the only one holding a reference to it. lock the page
+        * and return OK.
+        */
+       if (page_count(page) == 1) {
+               lock_page(page);
+               return 0;
+       }
+
+       return 1;
+}
+
+/**
+ * generic_pipe_buf_get - get a reference to a &struct pipe_buffer
+ * @pipe:      the pipe that the buffer belongs to
+ * @buf:       the buffer to get a reference to
+ *
+ * Description:
+ *     This function grabs an extra reference to @buf. It's used in
+ *     in the tee() system call, when we duplicate the buffers in one
+ *     pipe into another.
+ */
+void generic_pipe_buf_get(struct pipe_inode_info *pipe, struct pipe_buffer *buf)
+{
+       page_cache_get(buf->page);
+}
+
+/**
+ * generic_pipe_buf_confirm - verify contents of the pipe buffer
+ * @info:      the pipe that the buffer belongs to
+ * @buf:       the buffer to confirm
+ *
+ * Description:
+ *     This function does nothing, because the generic pipe code uses
+ *     pages that are always good when inserted into the pipe.
+ */
+int generic_pipe_buf_confirm(struct pipe_inode_info *info,
+                            struct pipe_buffer *buf)
+{
+       return 0;
+}
+
+static const struct pipe_buf_operations anon_pipe_buf_ops = {
        .can_merge = 1,
-       .map = anon_pipe_buf_map,
-       .unmap = anon_pipe_buf_unmap,
+       .map = generic_pipe_buf_map,
+       .unmap = generic_pipe_buf_unmap,
+       .confirm = generic_pipe_buf_confirm,
        .release = anon_pipe_buf_release,
+       .steal = generic_pipe_buf_steal,
+       .get = generic_pipe_buf_get,
 };
 
 static ssize_t
-pipe_readv(struct file *filp, const struct iovec *_iov,
-          unsigned long nr_segs, loff_t *ppos)
+pipe_read(struct kiocb *iocb, const struct iovec *_iov,
+          unsigned long nr_segs, loff_t pos)
 {
-       struct inode *inode = filp->f_dentry->d_inode;
-       struct pipe_inode_info *info;
+       struct file *filp = iocb->ki_filp;
+       struct inode *inode = filp->f_path.dentry->d_inode;
+       struct pipe_inode_info *pipe;
        int do_wakeup;
        ssize_t ret;
        struct iovec *iov = (struct iovec *)_iov;
@@ -136,26 +297,43 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
 
        do_wakeup = 0;
        ret = 0;
-       mutex_lock(PIPE_MUTEX(*inode));
-       info = inode->i_pipe;
+       mutex_lock(&inode->i_mutex);
+       pipe = 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;
-                       struct pipe_buf_operations *ops = buf->ops;
+                       int curbuf = pipe->curbuf;
+                       struct pipe_buffer *buf = pipe->bufs + curbuf;
+                       const struct pipe_buf_operations *ops = buf->ops;
                        void *addr;
                        size_t chars = buf->len;
-                       int error;
+                       int error, atomic;
 
                        if (chars > total_len)
                                chars = total_len;
 
-                       addr = ops->map(filp, info, buf);
-                       error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars);
-                       ops->unmap(info, buf);
+                       error = ops->confirm(pipe, buf);
+                       if (error) {
+                               if (!ret)
+                                       error = ret;
+                               break;
+                       }
+
+                       atomic = !iov_fault_in_pages_write(iov, chars);
+redo:
+                       addr = ops->map(pipe, buf, atomic);
+                       error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars, atomic);
+                       ops->unmap(pipe, buf, addr);
                        if (unlikely(error)) {
-                               if (!ret) ret = -EFAULT;
+                               /*
+                                * Just retry with the slow path if we failed.
+                                */
+                               if (atomic) {
+                                       atomic = 0;
+                                       goto redo;
+                               }
+                               if (!ret)
+                                       ret = error;
                                break;
                        }
                        ret += chars;
@@ -163,10 +341,10 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
                        buf->len -= chars;
                        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;
                        }
                        total_len -= chars;
@@ -175,9 +353,9 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
                }
                if (bufs)       /* More to do? */
                        continue;
-               if (!PIPE_WRITERS(*inode))
+               if (!pipe->writers)
                        break;
-               if (!PIPE_WAITING_WRITERS(*inode)) {
+               if (!pipe->waiting_writers) {
                        /* syscall merging: Usually we must not sleep
                         * if O_NONBLOCK is set, or if we got some data.
                         * But if a writer sleeps in kernel space, then
@@ -191,20 +369,22 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
                        }
                }
                if (signal_pending(current)) {
-                       if (!ret) ret = -ERESTARTSYS;
+                       if (!ret)
+                               ret = -ERESTARTSYS;
                        break;
                }
                if (do_wakeup) {
-                       wake_up_interruptible_sync(PIPE_WAIT(*inode));
-                       kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
+                       wake_up_interruptible_sync(&pipe->wait);
+                       kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
                }
-               pipe_wait(inode);
+               pipe_wait(pipe);
        }
-       mutex_unlock(PIPE_MUTEX(*inode));
-       /* Signal writers asynchronously that there is more room.  */
+       mutex_unlock(&inode->i_mutex);
+
+       /* Signal writers asynchronously that there is more room. */
        if (do_wakeup) {
-               wake_up_interruptible(PIPE_WAIT(*inode));
-               kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
+               wake_up_interruptible_sync(&pipe->wait);
+               kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
        }
        if (ret > 0)
                file_accessed(filp);
@@ -212,18 +392,12 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
 }
 
 static ssize_t
-pipe_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
+pipe_write(struct kiocb *iocb, const struct iovec *_iov,
+           unsigned long nr_segs, loff_t ppos)
 {
-       struct iovec iov = { .iov_base = buf, .iov_len = count };
-       return pipe_readv(filp, &iov, 1, ppos);
-}
-
-static ssize_t
-pipe_writev(struct file *filp, const struct iovec *_iov,
-           unsigned long nr_segs, loff_t *ppos)
-{
-       struct inode *inode = filp->f_dentry->d_inode;
-       struct pipe_inode_info *info;
+       struct file *filp = iocb->ki_filp;
+       struct inode *inode = filp->f_path.dentry->d_inode;
+       struct pipe_inode_info *pipe;
        ssize_t ret;
        int do_wakeup;
        struct iovec *iov = (struct iovec *)_iov;
@@ -237,10 +411,10 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
 
        do_wakeup = 0;
        ret = 0;
-       mutex_lock(PIPE_MUTEX(*inode));
-       info = inode->i_pipe;
+       mutex_lock(&inode->i_mutex);
+       pipe = inode->i_pipe;
 
-       if (!PIPE_READERS(*inode)) {
+       if (!pipe->readers) {
                send_sig(SIGPIPE, current, 0);
                ret = -EPIPE;
                goto out;
@@ -248,19 +422,36 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
 
        /* We try to merge small writes */
        chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
-       if (info->nrbufs && chars != 0) {
-               int lastbuf = (info->curbuf + info->nrbufs - 1) & (PIPE_BUFFERS-1);
-               struct pipe_buffer *buf = info->bufs + lastbuf;
-               struct pipe_buf_operations *ops = buf->ops;
+       if (pipe->nrbufs && chars != 0) {
+               int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
+                                                       (PIPE_BUFFERS-1);
+               struct pipe_buffer *buf = pipe->bufs + lastbuf;
+               const struct pipe_buf_operations *ops = buf->ops;
                int offset = buf->offset + buf->len;
+
                if (ops->can_merge && offset + chars <= PAGE_SIZE) {
-                       void *addr = ops->map(filp, info, buf);
-                       int error = pipe_iov_copy_from_user(offset + addr, iov, chars);
-                       ops->unmap(info, buf);
+                       int error, atomic = 1;
+                       void *addr;
+
+                       error = ops->confirm(pipe, buf);
+                       if (error)
+                               goto out;
+
+                       iov_fault_in_pages_read(iov, chars);
+redo1:
+                       addr = ops->map(pipe, buf, atomic);
+                       error = pipe_iov_copy_from_user(offset + addr, iov,
+                                                       chars, atomic);
+                       ops->unmap(pipe, buf, addr);
                        ret = error;
                        do_wakeup = 1;
-                       if (error)
+                       if (error) {
+                               if (atomic) {
+                                       atomic = 0;
+                                       goto redo1;
+                               }
                                goto out;
+                       }
                        buf->len += chars;
                        total_len -= chars;
                        ret = chars;
@@ -271,17 +462,20 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
 
        for (;;) {
                int bufs;
-               if (!PIPE_READERS(*inode)) {
+
+               if (!pipe->readers) {
                        send_sig(SIGPIPE, current, 0);
-                       if (!ret) ret = -EPIPE;
+                       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;
-                       struct page *page = info->tmp_page;
-                       int error;
+                       int newbuf = (pipe->curbuf + bufs) & (PIPE_BUFFERS-1);
+                       struct pipe_buffer *buf = pipe->bufs + newbuf;
+                       struct page *page = pipe->tmp_page;
+                       char *src;
+                       int error, atomic = 1;
 
                        if (!page) {
                                page = alloc_page(GFP_HIGHUSER);
@@ -289,9 +483,9 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
                                        ret = ret ? : -ENOMEM;
                                        break;
                                }
-                               info->tmp_page = page;
+                               pipe->tmp_page = page;
                        }
-                       /* Always wakeup, even if the copy fails. Otherwise
+                       /* Always wake up, even if the copy fails. Otherwise
                         * we lock up (O_NONBLOCK-)readers that sleep due to
                         * syscall merging.
                         * FIXME! Is this really true?
@@ -301,10 +495,27 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
                        if (chars > total_len)
                                chars = total_len;
 
-                       error = pipe_iov_copy_from_user(kmap(page), iov, chars);
-                       kunmap(page);
+                       iov_fault_in_pages_read(iov, chars);
+redo2:
+                       if (atomic)
+                               src = kmap_atomic(page, KM_USER0);
+                       else
+                               src = kmap(page);
+
+                       error = pipe_iov_copy_from_user(src, iov, chars,
+                                                       atomic);
+                       if (atomic)
+                               kunmap_atomic(src, KM_USER0);
+                       else
+                               kunmap(page);
+
                        if (unlikely(error)) {
-                               if (!ret) ret = -EFAULT;
+                               if (atomic) {
+                                       atomic = 0;
+                                       goto redo2;
+                               }
+                               if (!ret)
+                                       ret = error;
                                break;
                        }
                        ret += chars;
@@ -314,8 +525,8 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
                        buf->ops = &anon_pipe_buf_ops;
                        buf->offset = 0;
                        buf->len = chars;
-                       info->nrbufs = ++bufs;
-                       info->tmp_page = NULL;
+                       pipe->nrbufs = ++bufs;
+                       pipe->tmp_page = NULL;
 
                        total_len -= chars;
                        if (!total_len)
@@ -324,27 +535,29 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
                if (bufs < PIPE_BUFFERS)
                        continue;
                if (filp->f_flags & O_NONBLOCK) {
-                       if (!ret) ret = -EAGAIN;
+                       if (!ret)
+                               ret = -EAGAIN;
                        break;
                }
                if (signal_pending(current)) {
-                       if (!ret) ret = -ERESTARTSYS;
+                       if (!ret)
+                               ret = -ERESTARTSYS;
                        break;
                }
                if (do_wakeup) {
-                       wake_up_interruptible_sync(PIPE_WAIT(*inode));
-                       kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
+                       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--;
        }
 out:
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_unlock(&inode->i_mutex);
        if (do_wakeup) {
-               wake_up_interruptible(PIPE_WAIT(*inode));
-               kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
+               wake_up_interruptible_sync(&pipe->wait);
+               kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
        }
        if (ret > 0)
                file_update_time(filp);
@@ -352,45 +565,37 @@ out:
 }
 
 static ssize_t
-pipe_write(struct file *filp, const char __user *buf,
-          size_t count, loff_t *ppos)
-{
-       struct iovec iov = { .iov_base = (void __user *)buf, .iov_len = count };
-       return pipe_writev(filp, &iov, 1, ppos);
-}
-
-static ssize_t
 bad_pipe_r(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
 {
        return -EBADF;
 }
 
 static ssize_t
-bad_pipe_w(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
+bad_pipe_w(struct file *filp, const char __user *buf, size_t count,
+          loff_t *ppos)
 {
        return -EBADF;
 }
 
-static int
-pipe_ioctl(struct inode *pino, struct file *filp,
-          unsigned int cmd, unsigned long arg)
+static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-       struct inode *inode = filp->f_dentry->d_inode;
-       struct pipe_inode_info *info;
+       struct inode *inode = filp->f_path.dentry->d_inode;
+       struct pipe_inode_info *pipe;
        int count, buf, nrbufs;
 
        switch (cmd) {
                case FIONREAD:
-                       mutex_lock(PIPE_MUTEX(*inode));
-                       info =  inode->i_pipe;
+                       mutex_lock(&inode->i_mutex);
+                       pipe = inode->i_pipe;
                        count = 0;
-                       buf = info->curbuf;
-                       nrbufs = info->nrbufs;
+                       buf = pipe->curbuf;
+                       nrbufs = pipe->nrbufs;
                        while (--nrbufs >= 0) {
-                               count += info->bufs[buf].len;
+                               count += pipe->bufs[buf].len;
                                buf = (buf+1) & (PIPE_BUFFERS-1);
                        }
-                       mutex_unlock(PIPE_MUTEX(*inode));
+                       mutex_unlock(&inode->i_mutex);
+
                        return put_user(count, (int __user *)arg);
                default:
                        return -EINVAL;
@@ -402,18 +607,18 @@ static unsigned int
 pipe_poll(struct file *filp, poll_table *wait)
 {
        unsigned int mask;
-       struct inode *inode = filp->f_dentry->d_inode;
-       struct pipe_inode_info *info = inode->i_pipe;
+       struct inode *inode = filp->f_path.dentry->d_inode;
+       struct pipe_inode_info *pipe = inode->i_pipe;
        int nrbufs;
 
-       poll_wait(filp, PIPE_WAIT(*inode), wait);
+       poll_wait(filp, &pipe->wait, wait);
 
        /* Reading only -- no need for acquiring the semaphore.  */
-       nrbufs = info->nrbufs;
+       nrbufs = pipe->nrbufs;
        mask = 0;
        if (filp->f_mode & FMODE_READ) {
                mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
-               if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))
+               if (!pipe->writers && filp->f_version != pipe->w_counter)
                        mask |= POLLHUP;
        }
 
@@ -423,7 +628,7 @@ pipe_poll(struct file *filp, poll_table *wait)
                 * Most Unices do not set POLLERR for FIFOs but on Linux they
                 * behave exactly like pipes for poll().
                 */
-               if (!PIPE_READERS(*inode))
+               if (!pipe->readers)
                        mask |= POLLERR;
        }
 
@@ -433,17 +638,21 @@ pipe_poll(struct file *filp, poll_table *wait)
 static int
 pipe_release(struct inode *inode, int decr, int decw)
 {
-       mutex_lock(PIPE_MUTEX(*inode));
-       PIPE_READERS(*inode) -= decr;
-       PIPE_WRITERS(*inode) -= decw;
-       if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
+       struct pipe_inode_info *pipe;
+
+       mutex_lock(&inode->i_mutex);
+       pipe = inode->i_pipe;
+       pipe->readers -= decr;
+       pipe->writers -= decw;
+
+       if (!pipe->readers && !pipe->writers) {
                free_pipe_info(inode);
        } else {
-               wake_up_interruptible(PIPE_WAIT(*inode));
-               kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
-               kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
+               wake_up_interruptible_sync(&pipe->wait);
+               kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
+               kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
        }
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_unlock(&inode->i_mutex);
 
        return 0;
 }
@@ -451,12 +660,12 @@ pipe_release(struct inode *inode, int decr, int decw)
 static int
 pipe_read_fasync(int fd, struct file *filp, int on)
 {
-       struct inode *inode = filp->f_dentry->d_inode;
+       struct inode *inode = filp->f_path.dentry->d_inode;
        int retval;
 
-       mutex_lock(PIPE_MUTEX(*inode));
-       retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_lock(&inode->i_mutex);
+       retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
+       mutex_unlock(&inode->i_mutex);
 
        if (retval < 0)
                return retval;
@@ -468,12 +677,12 @@ pipe_read_fasync(int fd, struct file *filp, int on)
 static int
 pipe_write_fasync(int fd, struct file *filp, int on)
 {
-       struct inode *inode = filp->f_dentry->d_inode;
+       struct inode *inode = filp->f_path.dentry->d_inode;
        int retval;
 
-       mutex_lock(PIPE_MUTEX(*inode));
-       retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_lock(&inode->i_mutex);
+       retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
+       mutex_unlock(&inode->i_mutex);
 
        if (retval < 0)
                return retval;
@@ -485,17 +694,18 @@ pipe_write_fasync(int fd, struct file *filp, int on)
 static int
 pipe_rdwr_fasync(int fd, struct file *filp, int on)
 {
-       struct inode *inode = filp->f_dentry->d_inode;
+       struct inode *inode = filp->f_path.dentry->d_inode;
+       struct pipe_inode_info *pipe = inode->i_pipe;
        int retval;
 
-       mutex_lock(PIPE_MUTEX(*inode));
+       mutex_lock(&inode->i_mutex);
 
-       retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
+       retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
 
        if (retval >= 0)
-               retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
+               retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
 
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_unlock(&inode->i_mutex);
 
        if (retval < 0)
                return retval;
@@ -534,9 +744,9 @@ pipe_read_open(struct inode *inode, struct file *filp)
 {
        /* We could have perhaps used atomic_t, but this and friends
           below are the only places.  So it doesn't seem worthwhile.  */
-       mutex_lock(PIPE_MUTEX(*inode));
-       PIPE_READERS(*inode)++;
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_lock(&inode->i_mutex);
+       inode->i_pipe->readers++;
+       mutex_unlock(&inode->i_mutex);
 
        return 0;
 }
@@ -544,9 +754,9 @@ pipe_read_open(struct inode *inode, struct file *filp)
 static int
 pipe_write_open(struct inode *inode, struct file *filp)
 {
-       mutex_lock(PIPE_MUTEX(*inode));
-       PIPE_WRITERS(*inode)++;
-       mutex_unlock(PIPE_MUTEX(*inode));
+       mutex_lock(&inode->i_mutex);
+       inode->i_pipe->writers++;
+       mutex_unlock(&inode->i_mutex);
 
        return 0;
 }
@@ -554,12 +764,12 @@ pipe_write_open(struct inode *inode, struct file *filp)
 static int
 pipe_rdwr_open(struct inode *inode, struct file *filp)
 {
-       mutex_lock(PIPE_MUTEX(*inode));
+       mutex_lock(&inode->i_mutex);
        if (filp->f_mode & FMODE_READ)
-               PIPE_READERS(*inode)++;
+               inode->i_pipe->readers++;
        if (filp->f_mode & FMODE_WRITE)
-               PIPE_WRITERS(*inode)++;
-       mutex_unlock(PIPE_MUTEX(*inode));
+               inode->i_pipe->writers++;
+       mutex_unlock(&inode->i_mutex);
 
        return 0;
 }
@@ -570,11 +780,11 @@ pipe_rdwr_open(struct inode *inode, struct file *filp)
  */
 const struct file_operations read_fifo_fops = {
        .llseek         = no_llseek,
-       .read           = pipe_read,
-       .readv          = pipe_readv,
+       .read           = do_sync_read,
+       .aio_read       = pipe_read,
        .write          = bad_pipe_w,
        .poll           = pipe_poll,
-       .ioctl          = pipe_ioctl,
+       .unlocked_ioctl = pipe_ioctl,
        .open           = pipe_read_open,
        .release        = pipe_read_release,
        .fasync         = pipe_read_fasync,
@@ -583,10 +793,10 @@ const struct file_operations read_fifo_fops = {
 const struct file_operations write_fifo_fops = {
        .llseek         = no_llseek,
        .read           = bad_pipe_r,
-       .write          = pipe_write,
-       .writev         = pipe_writev,
+       .write          = do_sync_write,
+       .aio_write      = pipe_write,
        .poll           = pipe_poll,
-       .ioctl          = pipe_ioctl,
+       .unlocked_ioctl = pipe_ioctl,
        .open           = pipe_write_open,
        .release        = pipe_write_release,
        .fasync         = pipe_write_fasync,
@@ -594,106 +804,129 @@ const struct file_operations write_fifo_fops = {
 
 const struct file_operations rdwr_fifo_fops = {
        .llseek         = no_llseek,
-       .read           = pipe_read,
-       .readv          = pipe_readv,
-       .write          = pipe_write,
-       .writev         = pipe_writev,
+       .read           = do_sync_read,
+       .aio_read       = pipe_read,
+       .write          = do_sync_write,
+       .aio_write      = pipe_write,
        .poll           = pipe_poll,
-       .ioctl          = pipe_ioctl,
+       .unlocked_ioctl = pipe_ioctl,
        .open           = pipe_rdwr_open,
        .release        = pipe_rdwr_release,
        .fasync         = pipe_rdwr_fasync,
 };
 
-static struct file_operations read_pipe_fops = {
+static const struct file_operations read_pipe_fops = {
        .llseek         = no_llseek,
-       .read           = pipe_read,
-       .readv          = pipe_readv,
+       .read           = do_sync_read,
+       .aio_read       = pipe_read,
        .write          = bad_pipe_w,
        .poll           = pipe_poll,
-       .ioctl          = pipe_ioctl,
+       .unlocked_ioctl = pipe_ioctl,
        .open           = pipe_read_open,
        .release        = pipe_read_release,
        .fasync         = pipe_read_fasync,
 };
 
-static struct file_operations write_pipe_fops = {
+static const struct file_operations write_pipe_fops = {
        .llseek         = no_llseek,
        .read           = bad_pipe_r,
-       .write          = pipe_write,
-       .writev         = pipe_writev,
+       .write          = do_sync_write,
+       .aio_write      = pipe_write,
        .poll           = pipe_poll,
-       .ioctl          = pipe_ioctl,
+       .unlocked_ioctl = pipe_ioctl,
        .open           = pipe_write_open,
        .release        = pipe_write_release,
        .fasync         = pipe_write_fasync,
 };
 
-static struct file_operations rdwr_pipe_fops = {
+static const struct file_operations rdwr_pipe_fops = {
        .llseek         = no_llseek,
-       .read           = pipe_read,
-       .readv          = pipe_readv,
-       .write          = pipe_write,
-       .writev         = pipe_writev,
+       .read           = do_sync_read,
+       .aio_read       = pipe_read,
+       .write          = do_sync_write,
+       .aio_write      = pipe_write,
        .poll           = pipe_poll,
-       .ioctl          = pipe_ioctl,
+       .unlocked_ioctl = pipe_ioctl,
        .open           = pipe_rdwr_open,
        .release        = pipe_rdwr_release,
        .fasync         = pipe_rdwr_fasync,
 };
 
-void free_pipe_info(struct inode *inode)
+struct pipe_inode_info * alloc_pipe_info(struct inode *inode)
+{
+       struct pipe_inode_info *pipe;
+
+       pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
+       if (pipe) {
+               init_waitqueue_head(&pipe->wait);
+               pipe->r_counter = pipe->w_counter = 1;
+               pipe->inode = inode;
+       }
+
+       return pipe;
+}
+
+void __free_pipe_info(struct pipe_inode_info *pipe)
 {
        int i;
-       struct pipe_inode_info *info = inode->i_pipe;
 
-       inode->i_pipe = NULL;
        for (i = 0; i < PIPE_BUFFERS; i++) {
-               struct pipe_buffer *buf = info->bufs + i;
+               struct pipe_buffer *buf = pipe->bufs + i;
                if (buf->ops)
-                       buf->ops->release(info, buf);
+                       buf->ops->release(pipe, buf);
        }
-       if (info->tmp_page)
-               __free_page(info->tmp_page);
-       kfree(info);
+       if (pipe->tmp_page)
+               __free_page(pipe->tmp_page);
+       kfree(pipe);
 }
 
-struct inode* pipe_new(struct inode* inode)
+void free_pipe_info(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;
+       __free_pipe_info(inode->i_pipe);
+       inode->i_pipe = NULL;
 }
 
 static struct vfsmount *pipe_mnt __read_mostly;
 static int pipefs_delete_dentry(struct dentry *dentry)
 {
-       return 1;
+       /*
+        * At creation time, we pretended this dentry was hashed
+        * (by clearing DCACHE_UNHASHED bit in d_flags)
+        * At delete time, we restore the truth : not hashed.
+        * (so that dput() can proceed correctly)
+        */
+       dentry->d_flags |= DCACHE_UNHASHED;
+       return 0;
+}
+
+/*
+ * pipefs_dname() is called from d_path().
+ */
+static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
+{
+       return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
+                               dentry->d_inode->i_ino);
 }
+
 static struct dentry_operations pipefs_dentry_operations = {
        .d_delete       = pipefs_delete_dentry,
+       .d_dname        = pipefs_dname,
 };
 
 static struct inode * get_pipe_inode(void)
 {
        struct inode *inode = new_inode(pipe_mnt->mnt_sb);
+       struct pipe_inode_info *pipe;
 
        if (!inode)
                goto fail_inode;
 
-       if(!pipe_new(inode))
+       pipe = alloc_pipe_info(inode);
+       if (!pipe)
                goto fail_iput;
-       PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
+       inode->i_pipe = pipe;
+
+       pipe->readers = pipe->writers = 1;
        inode->i_fop = &rdwr_pipe_fops;
 
        /*
@@ -707,94 +940,158 @@ static struct inode * get_pipe_inode(void)
        inode->i_uid = current->fsuid;
        inode->i_gid = current->fsgid;
        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
-       inode->i_blksize = PAGE_SIZE;
+
        return inode;
 
 fail_iput:
        iput(inode);
+
 fail_inode:
        return NULL;
 }
 
-int do_pipe(int *fd)
+struct file *create_write_pipe(void)
 {
-       struct qstr this;
-       char name[32];
+       int err;
+       struct inode *inode;
+       struct file *f;
        struct dentry *dentry;
-       struct inode * inode;
-       struct file *f1, *f2;
-       int error;
-       int i,j;
-
-       error = -ENFILE;
-       f1 = get_empty_filp();
-       if (!f1)
-               goto no_files;
-
-       f2 = get_empty_filp();
-       if (!f2)
-               goto close_f1;
+       struct qstr name = { .name = "" };
 
+       err = -ENFILE;
        inode = get_pipe_inode();
        if (!inode)
-               goto close_f12;
+               goto err;
+
+       err = -ENOMEM;
+       dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &name);
+       if (!dentry)
+               goto err_inode;
+
+       dentry->d_op = &pipefs_dentry_operations;
+       /*
+        * We dont want to publish this dentry into global dentry hash table.
+        * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
+        * This permits a working /proc/$pid/fd/XXX on pipes
+        */
+       dentry->d_flags &= ~DCACHE_UNHASHED;
+       d_instantiate(dentry, inode);
+
+       err = -ENFILE;
+       f = alloc_file(pipe_mnt, dentry, FMODE_WRITE, &write_pipe_fops);
+       if (!f)
+               goto err_dentry;
+       f->f_mapping = inode->i_mapping;
+
+       f->f_flags = O_WRONLY;
+       f->f_version = 0;
+
+       return f;
+
+ err_dentry:
+       free_pipe_info(inode);
+       dput(dentry);
+       return ERR_PTR(err);
+
+ err_inode:
+       free_pipe_info(inode);
+       iput(inode);
+ err:
+       return ERR_PTR(err);
+}
+
+void free_write_pipe(struct file *f)
+{
+       free_pipe_info(f->f_dentry->d_inode);
+       path_put(&f->f_path);
+       put_filp(f);
+}
+
+struct file *create_read_pipe(struct file *wrf)
+{
+       struct file *f = get_empty_filp();
+       if (!f)
+               return ERR_PTR(-ENFILE);
+
+       /* Grab pipe from the writer */
+       f->f_path = wrf->f_path;
+       path_get(&wrf->f_path);
+       f->f_mapping = wrf->f_path.dentry->d_inode->i_mapping;
+
+       f->f_pos = 0;
+       f->f_flags = O_RDONLY;
+       f->f_op = &read_pipe_fops;
+       f->f_mode = FMODE_READ;
+       f->f_version = 0;
+
+       return f;
+}
+
+int do_pipe(int *fd)
+{
+       struct file *fw, *fr;
+       int error;
+       int fdw, fdr;
+
+       fw = create_write_pipe();
+       if (IS_ERR(fw))
+               return PTR_ERR(fw);
+       fr = create_read_pipe(fw);
+       error = PTR_ERR(fr);
+       if (IS_ERR(fr))
+               goto err_write_pipe;
 
        error = get_unused_fd();
        if (error < 0)
-               goto close_f12_inode;
-       i = error;
+               goto err_read_pipe;
+       fdr = error;
 
        error = get_unused_fd();
        if (error < 0)
-               goto close_f12_inode_i;
-       j = error;
-
-       error = -ENOMEM;
-       sprintf(name, "[%lu]", inode->i_ino);
-       this.name = name;
-       this.len = strlen(name);
-       this.hash = inode->i_ino; /* will go */
-       dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
-       if (!dentry)
-               goto close_f12_inode_i_j;
-       dentry->d_op = &pipefs_dentry_operations;
-       d_add(dentry, inode);
-       f1->f_vfsmnt = f2->f_vfsmnt = mntget(mntget(pipe_mnt));
-       f1->f_dentry = f2->f_dentry = dget(dentry);
-       f1->f_mapping = f2->f_mapping = inode->i_mapping;
-
-       /* read file */
-       f1->f_pos = f2->f_pos = 0;
-       f1->f_flags = O_RDONLY;
-       f1->f_op = &read_pipe_fops;
-       f1->f_mode = FMODE_READ;
-       f1->f_version = 0;
-
-       /* write file */
-       f2->f_flags = O_WRONLY;
-       f2->f_op = &write_pipe_fops;
-       f2->f_mode = FMODE_WRITE;
-       f2->f_version = 0;
-
-       fd_install(i, f1);
-       fd_install(j, f2);
-       fd[0] = i;
-       fd[1] = j;
+               goto err_fdr;
+       fdw = error;
+
+       error = audit_fd_pair(fdr, fdw);
+       if (error < 0)
+               goto err_fdw;
+
+       fd_install(fdr, fr);
+       fd_install(fdw, fw);
+       fd[0] = fdr;
+       fd[1] = fdw;
+
        return 0;
 
-close_f12_inode_i_j:
-       put_unused_fd(j);
-close_f12_inode_i:
-       put_unused_fd(i);
-close_f12_inode:
-       free_pipe_info(inode);
-       iput(inode);
-close_f12:
-       put_filp(f2);
-close_f1:
-       put_filp(f1);
-no_files:
-       return error;   
+ err_fdw:
+       put_unused_fd(fdw);
+ err_fdr:
+       put_unused_fd(fdr);
+ err_read_pipe:
+       path_put(&fr->f_path);
+       put_filp(fr);
+ err_write_pipe:
+       free_write_pipe(fw);
+       return error;
+}
+
+/*
+ * sys_pipe() is the normal C calling standard for creating
+ * a pipe. It's not the way Unix traditionally does this, though.
+ */
+asmlinkage long __weak sys_pipe(int __user *fildes)
+{
+       int fd[2];
+       int error;
+
+       error = do_pipe(fd);
+       if (!error) {
+               if (copy_to_user(fildes, fd, sizeof(fd))) {
+                       sys_close(fd[0]);
+                       sys_close(fd[1]);
+                       error = -EFAULT;
+               }
+       }
+       return error;
 }
 
 /*
@@ -803,11 +1100,11 @@ no_files:
  * any operations on the root directory. However, we need a non-trivial
  * d_name - pipe: will go nicely and kill the special-casing in procfs.
  */
-
-static struct super_block *pipefs_get_sb(struct file_system_type *fs_type,
-       int flags, const char *dev_name, void *data)
+static int pipefs_get_sb(struct file_system_type *fs_type,
+                        int flags, const char *dev_name, void *data,
+                        struct vfsmount *mnt)
 {
-       return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC);
+       return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC, mnt);
 }
 
 static struct file_system_type pipe_fs_type = {
@@ -819,6 +1116,7 @@ static struct file_system_type pipe_fs_type = {
 static int __init init_pipe_fs(void)
 {
        int err = register_filesystem(&pipe_fs_type);
+
        if (!err) {
                pipe_mnt = kern_mount(&pipe_fs_type);
                if (IS_ERR(pipe_mnt)) {