#include <linux/pipe_fs_i.h>
#include <linux/uio.h>
#include <linux/highmem.h>
-#include <linux/pagemap.h>
#include <asm/uaccess.h>
#include <asm/ioctls.h>
*/
/* Drop the inode semaphore and wait for a pipe event, atomically */
-void pipe_wait(struct pipe_inode_info *pipe)
+void pipe_wait(struct inode * inode)
{
DEFINE_WAIT(wait);
* Pipes are system-local resources, so sleeping on them
* is considered a noninteractive wait:
*/
- prepare_to_wait(&pipe->wait, &wait,
- TASK_INTERRUPTIBLE | TASK_NONINTERACTIVE);
- if (pipe->inode)
- mutex_unlock(&pipe->inode->i_mutex);
+ prepare_to_wait(PIPE_WAIT(*inode), &wait, TASK_INTERRUPTIBLE|TASK_NONINTERACTIVE);
+ mutex_unlock(PIPE_MUTEX(*inode));
schedule();
- finish_wait(&pipe->wait, &wait);
- if (pipe->inode)
- mutex_lock(&pipe->inode->i_mutex);
+ finish_wait(PIPE_WAIT(*inode), &wait);
+ mutex_lock(PIPE_MUTEX(*inode));
}
static int
-pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len,
- int atomic)
+pipe_iov_copy_from_user(void *to, struct iovec *iov, unsigned long len)
{
unsigned long copy;
iov++;
copy = min_t(unsigned long, len, iov->iov_len);
- 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;
- }
+ if (copy_from_user(to, iov->iov_base, copy))
+ return -EFAULT;
to += copy;
len -= copy;
iov->iov_base += copy;
}
static int
-pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len,
- int atomic)
+pipe_iov_copy_to_user(struct iovec *iov, const void *from, unsigned long len)
{
unsigned long copy;
iov++;
copy = min_t(unsigned long, len, iov->iov_len);
- 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;
- }
+ if (copy_to_user(iov->iov_base, from, copy))
+ return -EFAULT;
from += copy;
len -= copy;
iov->iov_base += copy;
return 0;
}
-/*
- * 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)
-{
- while (!iov->iov_len)
- iov++;
-
- 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++;
- }
-
- 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)
+static void anon_pipe_buf_release(struct pipe_inode_info *info, 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);
-}
-
-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);
+ if (info->tmp_page) {
+ __free_page(page);
+ return;
}
-
- return kmap(buf->page);
-}
-
-void generic_pipe_buf_unmap(struct pipe_inode_info *pipe,
- struct pipe_buffer *buf, void *map_data)
-{
- if (buf->flags & PIPE_BUF_FLAG_ATOMIC) {
- buf->flags &= ~PIPE_BUF_FLAG_ATOMIC;
- kunmap_atomic(map_data, KM_USER0);
- } else
- kunmap(buf->page);
+ info->tmp_page = page;
}
-int generic_pipe_buf_steal(struct pipe_inode_info *pipe,
- struct pipe_buffer *buf)
+static void *anon_pipe_buf_map(struct file *file, struct pipe_inode_info *info, struct pipe_buffer *buf)
{
- struct page *page = buf->page;
-
- if (page_count(page) == 1) {
- lock_page(page);
- return 0;
- }
-
- return 1;
-}
-
-void generic_pipe_buf_get(struct pipe_inode_info *info, struct pipe_buffer *buf)
-{
- page_cache_get(buf->page);
+ return kmap(buf->page);
}
-int generic_pipe_buf_pin(struct pipe_inode_info *info, struct pipe_buffer *buf)
+static void anon_pipe_buf_unmap(struct pipe_inode_info *info, struct pipe_buffer *buf)
{
- return 0;
+ kunmap(buf->page);
}
static struct pipe_buf_operations anon_pipe_buf_ops = {
.can_merge = 1,
- .map = generic_pipe_buf_map,
- .unmap = generic_pipe_buf_unmap,
- .pin = generic_pipe_buf_pin,
+ .map = anon_pipe_buf_map,
+ .unmap = anon_pipe_buf_unmap,
.release = anon_pipe_buf_release,
- .steal = generic_pipe_buf_steal,
- .get = generic_pipe_buf_get,
};
static ssize_t
unsigned long nr_segs, loff_t *ppos)
{
struct inode *inode = filp->f_dentry->d_inode;
- struct pipe_inode_info *pipe;
+ struct pipe_inode_info *info;
int do_wakeup;
ssize_t ret;
struct iovec *iov = (struct iovec *)_iov;
do_wakeup = 0;
ret = 0;
- mutex_lock(&inode->i_mutex);
- pipe = inode->i_pipe;
+ mutex_lock(PIPE_MUTEX(*inode));
+ info = inode->i_pipe;
for (;;) {
- int bufs = pipe->nrbufs;
+ int bufs = info->nrbufs;
if (bufs) {
- int curbuf = pipe->curbuf;
- struct pipe_buffer *buf = pipe->bufs + curbuf;
+ int curbuf = info->curbuf;
+ struct pipe_buffer *buf = info->bufs + curbuf;
struct pipe_buf_operations *ops = buf->ops;
void *addr;
size_t chars = buf->len;
- int error, atomic;
+ int error;
if (chars > total_len)
chars = total_len;
- error = ops->pin(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);
+ addr = ops->map(filp, info, buf);
+ error = pipe_iov_copy_to_user(iov, addr + buf->offset, chars);
+ ops->unmap(info, buf);
if (unlikely(error)) {
- /*
- * Just retry with the slow path if we failed.
- */
- if (atomic) {
- atomic = 0;
- goto redo;
- }
- if (!ret)
- ret = error;
+ if (!ret) ret = -EFAULT;
break;
}
ret += chars;
buf->len -= chars;
if (!buf->len) {
buf->ops = NULL;
- ops->release(pipe, buf);
+ ops->release(info, buf);
curbuf = (curbuf + 1) & (PIPE_BUFFERS-1);
- pipe->curbuf = curbuf;
- pipe->nrbufs = --bufs;
+ info->curbuf = curbuf;
+ info->nrbufs = --bufs;
do_wakeup = 1;
}
total_len -= chars;
}
if (bufs) /* More to do? */
continue;
- if (!pipe->writers)
+ if (!PIPE_WRITERS(*inode))
break;
- if (!pipe->waiting_writers) {
+ if (!PIPE_WAITING_WRITERS(*inode)) {
/* 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
}
}
if (signal_pending(current)) {
- if (!ret)
- ret = -ERESTARTSYS;
+ if (!ret) ret = -ERESTARTSYS;
break;
}
if (do_wakeup) {
- wake_up_interruptible_sync(&pipe->wait);
- kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
+ wake_up_interruptible_sync(PIPE_WAIT(*inode));
+ kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
}
- pipe_wait(pipe);
+ pipe_wait(inode);
}
- mutex_unlock(&inode->i_mutex);
-
- /* Signal writers asynchronously that there is more room. */
+ mutex_unlock(PIPE_MUTEX(*inode));
+ /* Signal writers asynchronously that there is more room. */
if (do_wakeup) {
- wake_up_interruptible(&pipe->wait);
- kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
+ wake_up_interruptible(PIPE_WAIT(*inode));
+ kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
}
if (ret > 0)
file_accessed(filp);
pipe_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
struct iovec iov = { .iov_base = buf, .iov_len = count };
-
return pipe_readv(filp, &iov, 1, ppos);
}
unsigned long nr_segs, loff_t *ppos)
{
struct inode *inode = filp->f_dentry->d_inode;
- struct pipe_inode_info *pipe;
+ struct pipe_inode_info *info;
ssize_t ret;
int do_wakeup;
struct iovec *iov = (struct iovec *)_iov;
do_wakeup = 0;
ret = 0;
- mutex_lock(&inode->i_mutex);
- pipe = inode->i_pipe;
+ mutex_lock(PIPE_MUTEX(*inode));
+ info = inode->i_pipe;
- if (!pipe->readers) {
+ if (!PIPE_READERS(*inode)) {
send_sig(SIGPIPE, current, 0);
ret = -EPIPE;
goto out;
/* We try to merge small writes */
chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
- if (pipe->nrbufs && chars != 0) {
- int lastbuf = (pipe->curbuf + pipe->nrbufs - 1) &
- (PIPE_BUFFERS-1);
- struct pipe_buffer *buf = pipe->bufs + lastbuf;
+ 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;
int offset = buf->offset + buf->len;
-
if (ops->can_merge && offset + chars <= PAGE_SIZE) {
- int error, atomic = 1;
- void *addr;
-
- error = ops->pin(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);
+ void *addr = ops->map(filp, info, buf);
+ int error = pipe_iov_copy_from_user(offset + addr, iov, chars);
+ ops->unmap(info, buf);
ret = error;
do_wakeup = 1;
- if (error) {
- if (atomic) {
- atomic = 0;
- goto redo1;
- }
+ if (error)
goto out;
- }
buf->len += chars;
total_len -= chars;
ret = chars;
for (;;) {
int bufs;
-
- if (!pipe->readers) {
+ if (!PIPE_READERS(*inode)) {
send_sig(SIGPIPE, current, 0);
- if (!ret)
- ret = -EPIPE;
+ if (!ret) ret = -EPIPE;
break;
}
- bufs = pipe->nrbufs;
+ bufs = info->nrbufs;
if (bufs < PIPE_BUFFERS) {
- 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;
+ int newbuf = (info->curbuf + bufs) & (PIPE_BUFFERS-1);
+ struct pipe_buffer *buf = info->bufs + newbuf;
+ struct page *page = info->tmp_page;
+ int error;
if (!page) {
page = alloc_page(GFP_HIGHUSER);
ret = ret ? : -ENOMEM;
break;
}
- pipe->tmp_page = page;
+ info->tmp_page = page;
}
- /* Always wake up, even if the copy fails. Otherwise
+ /* Always wakeup, even if the copy fails. Otherwise
* we lock up (O_NONBLOCK-)readers that sleep due to
* syscall merging.
* FIXME! Is this really true?
if (chars > total_len)
chars = total_len;
- 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);
-
+ error = pipe_iov_copy_from_user(kmap(page), iov, chars);
+ kunmap(page);
if (unlikely(error)) {
- if (atomic) {
- atomic = 0;
- goto redo2;
- }
- if (!ret)
- ret = error;
+ if (!ret) ret = -EFAULT;
break;
}
ret += chars;
buf->ops = &anon_pipe_buf_ops;
buf->offset = 0;
buf->len = chars;
- pipe->nrbufs = ++bufs;
- pipe->tmp_page = NULL;
+ info->nrbufs = ++bufs;
+ info->tmp_page = NULL;
total_len -= chars;
if (!total_len)
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);
- kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
+ wake_up_interruptible_sync(PIPE_WAIT(*inode));
+ kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
do_wakeup = 0;
}
- pipe->waiting_writers++;
- pipe_wait(pipe);
- pipe->waiting_writers--;
+ PIPE_WAITING_WRITERS(*inode)++;
+ pipe_wait(inode);
+ PIPE_WAITING_WRITERS(*inode)--;
}
out:
- mutex_unlock(&inode->i_mutex);
+ mutex_unlock(PIPE_MUTEX(*inode));
if (do_wakeup) {
- wake_up_interruptible(&pipe->wait);
- kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
+ wake_up_interruptible(PIPE_WAIT(*inode));
+ kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
}
if (ret > 0)
file_update_time(filp);
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_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;
}
unsigned int cmd, unsigned long arg)
{
struct inode *inode = filp->f_dentry->d_inode;
- struct pipe_inode_info *pipe;
+ struct pipe_inode_info *info;
int count, buf, nrbufs;
switch (cmd) {
case FIONREAD:
- mutex_lock(&inode->i_mutex);
- pipe = inode->i_pipe;
+ mutex_lock(PIPE_MUTEX(*inode));
+ info = inode->i_pipe;
count = 0;
- buf = pipe->curbuf;
- nrbufs = pipe->nrbufs;
+ buf = info->curbuf;
+ nrbufs = info->nrbufs;
while (--nrbufs >= 0) {
- count += pipe->bufs[buf].len;
+ count += info->bufs[buf].len;
buf = (buf+1) & (PIPE_BUFFERS-1);
}
- mutex_unlock(&inode->i_mutex);
-
+ mutex_unlock(PIPE_MUTEX(*inode));
return put_user(count, (int __user *)arg);
default:
return -EINVAL;
{
unsigned int mask;
struct inode *inode = filp->f_dentry->d_inode;
- struct pipe_inode_info *pipe = inode->i_pipe;
+ struct pipe_inode_info *info = inode->i_pipe;
int nrbufs;
- poll_wait(filp, &pipe->wait, wait);
+ poll_wait(filp, PIPE_WAIT(*inode), wait);
/* Reading only -- no need for acquiring the semaphore. */
- nrbufs = pipe->nrbufs;
+ nrbufs = info->nrbufs;
mask = 0;
if (filp->f_mode & FMODE_READ) {
mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
- if (!pipe->writers && filp->f_version != pipe->w_counter)
+ if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))
mask |= POLLHUP;
}
* Most Unices do not set POLLERR for FIFOs but on Linux they
* behave exactly like pipes for poll().
*/
- if (!pipe->readers)
+ if (!PIPE_READERS(*inode))
mask |= POLLERR;
}
static int
pipe_release(struct inode *inode, int decr, int decw)
{
- 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) {
+ mutex_lock(PIPE_MUTEX(*inode));
+ PIPE_READERS(*inode) -= decr;
+ PIPE_WRITERS(*inode) -= decw;
+ if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
free_pipe_info(inode);
} else {
- wake_up_interruptible(&pipe->wait);
- kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
- kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT);
+ wake_up_interruptible(PIPE_WAIT(*inode));
+ kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);
+ kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);
}
- mutex_unlock(&inode->i_mutex);
+ mutex_unlock(PIPE_MUTEX(*inode));
return 0;
}
struct inode *inode = filp->f_dentry->d_inode;
int retval;
- mutex_lock(&inode->i_mutex);
- retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
- mutex_unlock(&inode->i_mutex);
+ mutex_lock(PIPE_MUTEX(*inode));
+ retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
+ mutex_unlock(PIPE_MUTEX(*inode));
if (retval < 0)
return retval;
struct inode *inode = filp->f_dentry->d_inode;
int retval;
- mutex_lock(&inode->i_mutex);
- retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
- mutex_unlock(&inode->i_mutex);
+ mutex_lock(PIPE_MUTEX(*inode));
+ retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
+ mutex_unlock(PIPE_MUTEX(*inode));
if (retval < 0)
return retval;
pipe_rdwr_fasync(int fd, struct file *filp, int on)
{
struct inode *inode = filp->f_dentry->d_inode;
- struct pipe_inode_info *pipe = inode->i_pipe;
int retval;
- mutex_lock(&inode->i_mutex);
+ mutex_lock(PIPE_MUTEX(*inode));
- retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
+ retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));
if (retval >= 0)
- retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
+ retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));
- mutex_unlock(&inode->i_mutex);
+ mutex_unlock(PIPE_MUTEX(*inode));
if (retval < 0)
return retval;
{
/* We could have perhaps used atomic_t, but this and friends
below are the only places. So it doesn't seem worthwhile. */
- mutex_lock(&inode->i_mutex);
- inode->i_pipe->readers++;
- mutex_unlock(&inode->i_mutex);
+ mutex_lock(PIPE_MUTEX(*inode));
+ PIPE_READERS(*inode)++;
+ mutex_unlock(PIPE_MUTEX(*inode));
return 0;
}
static int
pipe_write_open(struct inode *inode, struct file *filp)
{
- mutex_lock(&inode->i_mutex);
- inode->i_pipe->writers++;
- mutex_unlock(&inode->i_mutex);
+ mutex_lock(PIPE_MUTEX(*inode));
+ PIPE_WRITERS(*inode)++;
+ mutex_unlock(PIPE_MUTEX(*inode));
return 0;
}
static int
pipe_rdwr_open(struct inode *inode, struct file *filp)
{
- mutex_lock(&inode->i_mutex);
+ mutex_lock(PIPE_MUTEX(*inode));
if (filp->f_mode & FMODE_READ)
- inode->i_pipe->readers++;
+ PIPE_READERS(*inode)++;
if (filp->f_mode & FMODE_WRITE)
- inode->i_pipe->writers++;
- mutex_unlock(&inode->i_mutex);
+ PIPE_WRITERS(*inode)++;
+ mutex_unlock(PIPE_MUTEX(*inode));
return 0;
}
* The file_operations structs are not static because they
* are also used in linux/fs/fifo.c to do operations on FIFOs.
*/
-const struct file_operations read_fifo_fops = {
+struct file_operations read_fifo_fops = {
.llseek = no_llseek,
.read = pipe_read,
.readv = pipe_readv,
.fasync = pipe_read_fasync,
};
-const struct file_operations write_fifo_fops = {
+struct file_operations write_fifo_fops = {
.llseek = no_llseek,
.read = bad_pipe_r,
.write = pipe_write,
.fasync = pipe_write_fasync,
};
-const struct file_operations rdwr_fifo_fops = {
+struct file_operations rdwr_fifo_fops = {
.llseek = no_llseek,
.read = pipe_read,
.readv = pipe_readv,
.fasync = pipe_rdwr_fasync,
};
-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)
+void free_pipe_info(struct inode *inode)
{
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 = pipe->bufs + i;
+ struct pipe_buffer *buf = info->bufs + i;
if (buf->ops)
- buf->ops->release(pipe, buf);
+ buf->ops->release(info, buf);
}
- if (pipe->tmp_page)
- __free_page(pipe->tmp_page);
- kfree(pipe);
+ if (info->tmp_page)
+ __free_page(info->tmp_page);
+ kfree(info);
}
-void free_pipe_info(struct inode *inode)
+struct inode* pipe_new(struct inode* inode)
{
- __free_pipe_info(inode->i_pipe);
- inode->i_pipe = NULL;
+ struct pipe_inode_info *info;
+
+ info = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
+ if (!info)
+ goto fail_page;
+ memset(info, 0, sizeof(*info));
+ 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 struct vfsmount *pipe_mnt;
static int pipefs_delete_dentry(struct dentry *dentry)
{
return 1;
}
-
static struct dentry_operations pipefs_dentry_operations = {
.d_delete = pipefs_delete_dentry,
};
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;
- pipe = alloc_pipe_info(inode);
- if (!pipe)
+ if(!pipe_new(inode))
goto fail_iput;
- inode->i_pipe = pipe;
-
- pipe->readers = pipe->writers = 1;
+ PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
inode->i_fop = &rdwr_pipe_fops;
/*
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;
}
struct inode * inode;
struct file *f1, *f2;
int error;
- int i, j;
+ int i,j;
error = -ENFILE;
f1 = get_empty_filp();
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));
fd_install(j, f2);
fd[0] = i;
fd[1] = j;
-
return 0;
close_f12_inode_i_j:
return error;
}
-EXPORT_SYMBOL_GPL(do_pipe);
-
/*
* pipefs should _never_ be mounted by userland - too much of security hassle,
* no real gain from having the whole whorehouse mounted. So we don't need
* 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 int pipefs_get_sb(struct file_system_type *fs_type,
- int flags, const char *dev_name, void *data,
- struct vfsmount *mnt)
+
+static struct super_block *pipefs_get_sb(struct file_system_type *fs_type,
+ int flags, const char *dev_name, void *data)
{
- return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC, mnt);
+ return get_sb_pseudo(fs_type, "pipe:", NULL, PIPEFS_MAGIC);
}
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)) {
git://git.onelab.eu / linux-2.6.git / blobdiff