URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [pipe.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *  linux/fs/pipe.c
 *
 *  Copyright (C) 1991, 1992, 1999  Linus Torvalds
 */
 
#include <linux/mm.h>
#include <linux/file.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
 
#include <asm/uaccess.h>
#include <asm/ioctls.h>
 
/*
 * We use a start+len construction, which provides full use of the
 * allocated memory.
 * -- Florian Coosmann (FGC)
 *
 * Reads with count = 0 should always return 0.
 * -- Julian Bradfield 1999-06-07.
 */
 
/* Drop the inode semaphore and wait for a pipe event, atomically */
void pipe_wait(struct inode * inode)
{
        DECLARE_WAITQUEUE(wait, current);
        current->state = TASK_INTERRUPTIBLE;
        add_wait_queue(PIPE_WAIT(*inode), &wait);
        up(PIPE_SEM(*inode));
        schedule();
        remove_wait_queue(PIPE_WAIT(*inode), &wait);
        current->state = TASK_RUNNING;
        down(PIPE_SEM(*inode));
}
 
static ssize_t
pipe_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
        struct inode *inode = filp->f_dentry->d_inode;
        ssize_t size, read, ret;
 
        /* Seeks are not allowed on pipes.  */
        ret = -ESPIPE;
        read = 0;
        if (ppos != &filp->f_pos)
                goto out_nolock;
 
        /* Always return 0 on null read.  */
        ret = 0;
        if (count == 0)
                goto out_nolock;
 
        /* Get the pipe semaphore */
        ret = -ERESTARTSYS;
        if (down_interruptible(PIPE_SEM(*inode)))
                goto out_nolock;
 
        if (PIPE_EMPTY(*inode)) {
do_more_read:
                ret = 0;
                if (!PIPE_WRITERS(*inode))
                        goto out;
 
                ret = -EAGAIN;
                if (filp->f_flags & O_NONBLOCK)
                        goto out;
 
                for (;;) {
                        PIPE_WAITING_READERS(*inode)++;
                        pipe_wait(inode);
                        PIPE_WAITING_READERS(*inode)--;
                        ret = -ERESTARTSYS;
                        if (signal_pending(current))
                                goto out;
                        ret = 0;
                        if (!PIPE_EMPTY(*inode))
                                break;
                        if (!PIPE_WRITERS(*inode))
                                goto out;
                }
        }
 
        /* Read what data is available.  */
        ret = -EFAULT;
        while (count > 0 && (size = PIPE_LEN(*inode))) {
                char *pipebuf = PIPE_BASE(*inode) + PIPE_START(*inode);
                ssize_t chars = PIPE_MAX_RCHUNK(*inode);
 
                if (chars > count)
                        chars = count;
                if (chars > size)
                        chars = size;
 
                if (copy_to_user(buf, pipebuf, chars))
                        goto out;
 
                read += chars;
                PIPE_START(*inode) += chars;
                PIPE_START(*inode) &= (PIPE_SIZE - 1);
                PIPE_LEN(*inode) -= chars;
                count -= chars;
                buf += chars;
        }
 
        /* Cache behaviour optimization */
        if (!PIPE_LEN(*inode))
                PIPE_START(*inode) = 0;
 
        if (count && PIPE_WAITING_WRITERS(*inode) && !(filp->f_flags & O_NONBLOCK)) {
                /*
                 * We know that we are going to sleep: signal
                 * writers synchronously that there is more
                 * room.
                 */
                wake_up_interruptible_sync(PIPE_WAIT(*inode));
                if (!PIPE_EMPTY(*inode))
                        BUG();
                goto do_more_read;
        }
        /* Signal writers asynchronously that there is more room.  */
        wake_up_interruptible(PIPE_WAIT(*inode));
 
        ret = read;
out:
        up(PIPE_SEM(*inode));
out_nolock:
        if (read)
                ret = read;
 
        UPDATE_ATIME(inode);
        return ret;
}
 
static ssize_t
pipe_write(struct file *filp, const char *buf, size_t count, loff_t *ppos)
{
        struct inode *inode = filp->f_dentry->d_inode;
        ssize_t free, written, ret;
 
        /* Seeks are not allowed on pipes.  */
        ret = -ESPIPE;
        written = 0;
        if (ppos != &filp->f_pos)
                goto out_nolock;
 
        /* Null write succeeds.  */
        ret = 0;
        if (count == 0)
                goto out_nolock;
 
        ret = -ERESTARTSYS;
        if (down_interruptible(PIPE_SEM(*inode)))
                goto out_nolock;
 
        /* No readers yields SIGPIPE.  */
        if (!PIPE_READERS(*inode))
                goto sigpipe;
 
        /* If count <= PIPE_BUF, we have to make it atomic.  */
        free = (count <= PIPE_BUF ? count : 1);
 
        /* Wait, or check for, available space.  */
        if (filp->f_flags & O_NONBLOCK) {
                ret = -EAGAIN;
                if (PIPE_FREE(*inode) < free)
                        goto out;
        } else {
                while (PIPE_FREE(*inode) < free) {
                        PIPE_WAITING_WRITERS(*inode)++;
                        pipe_wait(inode);
                        PIPE_WAITING_WRITERS(*inode)--;
                        ret = -ERESTARTSYS;
                        if (signal_pending(current))
                                goto out;
 
                        if (!PIPE_READERS(*inode))
                                goto sigpipe;
                }
        }
 
        /* Copy into available space.  */
        ret = -EFAULT;
        while (count > 0) {
                int space;
                char *pipebuf = PIPE_BASE(*inode) + PIPE_END(*inode);
                ssize_t chars = PIPE_MAX_WCHUNK(*inode);
 
                if ((space = PIPE_FREE(*inode)) != 0) {
                        if (chars > count)
                                chars = count;
                        if (chars > space)
                                chars = space;
 
                        if (copy_from_user(pipebuf, buf, chars))
                                goto out;
 
                        written += chars;
                        PIPE_LEN(*inode) += chars;
                        count -= chars;
                        buf += chars;
                        space = PIPE_FREE(*inode);
                        continue;
                }
 
                ret = written;
                if (filp->f_flags & O_NONBLOCK)
                        break;
 
                do {
                        /*
                         * Synchronous wake-up: it knows that this process
                         * is going to give up this CPU, so it doesn't have
                         * to do idle reschedules.
                         */
                        wake_up_interruptible_sync(PIPE_WAIT(*inode));
                        PIPE_WAITING_WRITERS(*inode)++;
                        pipe_wait(inode);
                        PIPE_WAITING_WRITERS(*inode)--;
                        if (signal_pending(current))
                                goto out;
                        if (!PIPE_READERS(*inode))
                                goto sigpipe;
                } while (!PIPE_FREE(*inode));
                ret = -EFAULT;
        }
 
        /* Signal readers asynchronously that there is more data.  */
        wake_up_interruptible(PIPE_WAIT(*inode));
 
        update_mctime(inode);
 
out:
        up(PIPE_SEM(*inode));
out_nolock:
        if (written)
                ret = written;
        return ret;
 
sigpipe:
        if (written)
                goto out;
        up(PIPE_SEM(*inode));
        send_sig(SIGPIPE, current, 0);
        return -EPIPE;
}
 
static ssize_t
bad_pipe_r(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
        return -EBADF;
}
 
static ssize_t
bad_pipe_w(struct file *filp, const char *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)
{
        switch (cmd) {
                case FIONREAD:
                        return put_user(PIPE_LEN(*pino), (int *)arg);
                default:
                        return -EINVAL;
        }
}
 
/* No kernel lock held - fine */
static unsigned int
pipe_poll(struct file *filp, poll_table *wait)
{
        unsigned int mask;
        struct inode *inode = filp->f_dentry->d_inode;
 
        poll_wait(filp, PIPE_WAIT(*inode), wait);
 
        /* Reading only -- no need for acquiring the semaphore.  */
        mask = POLLIN | POLLRDNORM;
        if (PIPE_EMPTY(*inode))
                mask = POLLOUT | POLLWRNORM;
        if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))
                mask |= POLLHUP;
        if (!PIPE_READERS(*inode))
                mask |= POLLERR;
 
        return mask;
}
 
/* FIXME: most Unices do not set POLLERR for fifos */
#define fifo_poll pipe_poll
 
static int
pipe_release(struct inode *inode, int decr, int decw)
{
        down(PIPE_SEM(*inode));
        PIPE_READERS(*inode) -= decr;
        PIPE_WRITERS(*inode) -= decw;
        if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
                struct pipe_inode_info *info = inode->i_pipe;
                inode->i_pipe = NULL;
                free_page((unsigned long) info->base);
                kfree(info);
        } else {
                wake_up_interruptible(PIPE_WAIT(*inode));
        }
        up(PIPE_SEM(*inode));
 
        return 0;
}
 
static int
pipe_read_release(struct inode *inode, struct file *filp)
{
        return pipe_release(inode, 1, 0);
}
 
static int
pipe_write_release(struct inode *inode, struct file *filp)
{
        return pipe_release(inode, 0, 1);
}
 
static int
pipe_rdwr_release(struct inode *inode, struct file *filp)
{
        int decr, decw;
 
        decr = (filp->f_mode & FMODE_READ) != 0;
        decw = (filp->f_mode & FMODE_WRITE) != 0;
        return pipe_release(inode, decr, decw);
}
 
static int
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.  */
        down(PIPE_SEM(*inode));
        PIPE_READERS(*inode)++;
        up(PIPE_SEM(*inode));
 
        return 0;
}
 
static int
pipe_write_open(struct inode *inode, struct file *filp)
{
        down(PIPE_SEM(*inode));
        PIPE_WRITERS(*inode)++;
        up(PIPE_SEM(*inode));
 
        return 0;
}
 
static int
pipe_rdwr_open(struct inode *inode, struct file *filp)
{
        down(PIPE_SEM(*inode));
        if (filp->f_mode & FMODE_READ)
                PIPE_READERS(*inode)++;
        if (filp->f_mode & FMODE_WRITE)
                PIPE_WRITERS(*inode)++;
        up(PIPE_SEM(*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.
 */
struct file_operations read_fifo_fops = {
        llseek:         no_llseek,
        read:           pipe_read,
        write:          bad_pipe_w,
        poll:           fifo_poll,
        ioctl:          pipe_ioctl,
        open:           pipe_read_open,
        release:        pipe_read_release,
};
 
struct file_operations write_fifo_fops = {
        llseek:         no_llseek,
        read:           bad_pipe_r,
        write:          pipe_write,
        poll:           fifo_poll,
        ioctl:          pipe_ioctl,
        open:           pipe_write_open,
        release:        pipe_write_release,
};
 
struct file_operations rdwr_fifo_fops = {
        llseek:         no_llseek,
        read:           pipe_read,
        write:          pipe_write,
        poll:           fifo_poll,
        ioctl:          pipe_ioctl,
        open:           pipe_rdwr_open,
        release:        pipe_rdwr_release,
};
 
struct file_operations read_pipe_fops = {
        llseek:         no_llseek,
        read:           pipe_read,
        write:          bad_pipe_w,
        poll:           pipe_poll,
        ioctl:          pipe_ioctl,
        open:           pipe_read_open,
        release:        pipe_read_release,
};
 
struct file_operations write_pipe_fops = {
        llseek:         no_llseek,
        read:           bad_pipe_r,
        write:          pipe_write,
        poll:           pipe_poll,
        ioctl:          pipe_ioctl,
        open:           pipe_write_open,
        release:        pipe_write_release,
};
 
struct file_operations rdwr_pipe_fops = {
        llseek:         no_llseek,
        read:           pipe_read,
        write:          pipe_write,
        poll:           pipe_poll,
        ioctl:          pipe_ioctl,
        open:           pipe_rdwr_open,
        release:        pipe_rdwr_release,
};
 
struct inode* pipe_new(struct inode* inode)
{
        unsigned long page;
 
        page = __get_free_page(GFP_USER);
        if (!page)
                return NULL;
 
        inode->i_pipe = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);
        if (!inode->i_pipe)
                goto fail_page;
 
        init_waitqueue_head(PIPE_WAIT(*inode));
        PIPE_BASE(*inode) = (char*) page;
        PIPE_START(*inode) = PIPE_LEN(*inode) = 0;
        PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
        PIPE_WAITING_READERS(*inode) = PIPE_WAITING_WRITERS(*inode) = 0;
        PIPE_RCOUNTER(*inode) = PIPE_WCOUNTER(*inode) = 1;
 
        return inode;
fail_page:
        free_page(page);
        return NULL;
}
 
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);
 
        if (!inode)
                goto fail_inode;
 
        if(!pipe_new(inode))
                goto fail_iput;
        PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
        inode->i_fop = &rdwr_pipe_fops;
 
        /*
         * Mark the inode dirty from the very beginning,
         * that way it will never be moved to the dirty
         * list because "mark_inode_dirty()" will think
         * that it already _is_ on the dirty list.
         */
        inode->i_state = I_DIRTY;
        inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
        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 qstr this;
        char name[32];
        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;
 
        inode = get_pipe_inode();
        if (!inode)
                goto close_f12;
 
        error = get_unused_fd();
        if (error < 0)
                goto close_f12_inode;
        i = 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);
 
        /* read file */
        f1->f_pos = f2->f_pos = 0;
        f1->f_flags = O_RDONLY;
        f1->f_op = &read_pipe_fops;
        f1->f_mode = 1;
        f1->f_version = 0;
 
        /* write file */
        f2->f_flags = O_WRONLY;
        f2->f_op = &write_pipe_fops;
        f2->f_mode = 2;
        f2->f_version = 0;
 
        fd_install(i, f1);
        fd_install(j, f2);
        fd[0] = i;
        fd[1] = j;
        return 0;
 
close_f12_inode_i_j:
        put_unused_fd(j);
close_f12_inode_i:
        put_unused_fd(i);
close_f12_inode:
        free_page((unsigned long) PIPE_BASE(*inode));
        kfree(inode->i_pipe);
        inode->i_pipe = NULL;
        iput(inode);
close_f12:
        put_filp(f2);
close_f1:
        put_filp(f1);
no_files:
        return error;
}
 
/*
 * 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_statfs(struct super_block *sb, struct statfs *buf)
{
        buf->f_type = PIPEFS_MAGIC;
        buf->f_bsize = 1024;
        buf->f_namelen = 255;
        return 0;
}
 
static struct super_operations pipefs_ops = {
        statfs:         pipefs_statfs,
};
 
static struct super_block * pipefs_read_super(struct super_block *sb, void *data, int silent)
{
        struct inode *root = new_inode(sb);
        if (!root)
                return NULL;
        root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
        root->i_uid = root->i_gid = 0;
        root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
        sb->s_blocksize = 1024;
        sb->s_blocksize_bits = 10;
        sb->s_magic = PIPEFS_MAGIC;
        sb->s_op        = &pipefs_ops;
        sb->s_root = d_alloc(NULL, &(const struct qstr) { "pipe:", 5, 0 });
        if (!sb->s_root) {
                iput(root);
                return NULL;
        }
        sb->s_root->d_sb = sb;
        sb->s_root->d_parent = sb->s_root;
        d_instantiate(sb->s_root, root);
        return sb;
}
 
static DECLARE_FSTYPE(pipe_fs_type, "pipefs", pipefs_read_super, FS_NOMOUNT);
 
static int __init init_pipe_fs(void)
{
        int err = register_filesystem(&pipe_fs_type);
        if (!err) {
                pipe_mnt = kern_mount(&pipe_fs_type);
                err = PTR_ERR(pipe_mnt);
                if (IS_ERR(pipe_mnt))
                        unregister_filesystem(&pipe_fs_type);
                else
                        err = 0;
        }
        return err;
}
 
static void __exit exit_pipe_fs(void)
{
        unregister_filesystem(&pipe_fs_type);
        mntput(pipe_mnt);
}
 
module_init(init_pipe_fs)
module_exit(exit_pipe_fs)

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [pipe.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* linux/fs/pipe.c`
3			`*`
4			`* Copyright (C) 1991, 1992, 1999 Linus Torvalds`
5			`*/`
6
7			`#include <linux/mm.h>`
8			`#include <linux/file.h>`
9			`#include <linux/poll.h>`
10			`#include <linux/slab.h>`
11			`#include <linux/module.h>`
12			`#include <linux/init.h>`
13
14			`#include <asm/uaccess.h>`
15			`#include <asm/ioctls.h>`
16
17			`/*`
18			`* We use a start+len construction, which provides full use of the`
19			`* allocated memory.`
20			`* -- Florian Coosmann (FGC)`
21			`*`
22			`* Reads with count = 0 should always return 0.`
23			`* -- Julian Bradfield 1999-06-07.`
24			`*/`
25
26			`/* Drop the inode semaphore and wait for a pipe event, atomically */`
27			`void pipe_wait(struct inode * inode)`
28			`{`
29			`DECLARE_WAITQUEUE(wait, current);`
30			`current->state = TASK_INTERRUPTIBLE;`
31			`add_wait_queue(PIPE_WAIT(*inode), &wait);`
32			`up(PIPE_SEM(*inode));`
33			`schedule();`
34			`remove_wait_queue(PIPE_WAIT(*inode), &wait);`
35			`current->state = TASK_RUNNING;`
36			`down(PIPE_SEM(*inode));`
37			`}`
38
39			`static ssize_t`
40			`pipe_read(struct file filp, char buf, size_t count, loff_t *ppos)`
41			`{`
42			`struct inode *inode = filp->f_dentry->d_inode;`
43			`ssize_t size, read, ret;`
44
45			`/* Seeks are not allowed on pipes. */`
46			`ret = -ESPIPE;`
47			`read = 0;`
48			`if (ppos != &filp->f_pos)`
49			`goto out_nolock;`
50
51			`/* Always return 0 on null read. */`
52			`ret = 0;`
53			`if (count == 0)`
54			`goto out_nolock;`
55
56			`/* Get the pipe semaphore */`
57			`ret = -ERESTARTSYS;`
58			`if (down_interruptible(PIPE_SEM(*inode)))`
59			`goto out_nolock;`
60
61			`if (PIPE_EMPTY(*inode)) {`
62			`do_more_read:`
63			`ret = 0;`
64			`if (!PIPE_WRITERS(*inode))`
65			`goto out;`
66
67			`ret = -EAGAIN;`
68			`if (filp->f_flags & O_NONBLOCK)`
69			`goto out;`
70
71			`for (;;) {`
72			`PIPE_WAITING_READERS(*inode)++;`
73			`pipe_wait(inode);`
74			`PIPE_WAITING_READERS(*inode)--;`
75			`ret = -ERESTARTSYS;`
76			`if (signal_pending(current))`
77			`goto out;`
78			`ret = 0;`
79			`if (!PIPE_EMPTY(*inode))`
80			`break;`
81			`if (!PIPE_WRITERS(*inode))`
82			`goto out;`
83			`}`
84			`}`
85
86			`/* Read what data is available. */`
87			`ret = -EFAULT;`
88			`while (count > 0 && (size = PIPE_LEN(*inode))) {`
89			`char pipebuf = PIPE_BASE(inode) + PIPE_START(*inode);`
90			`ssize_t chars = PIPE_MAX_RCHUNK(*inode);`
91
92			`if (chars > count)`
93			`chars = count;`
94			`if (chars > size)`
95			`chars = size;`
96
97			`if (copy_to_user(buf, pipebuf, chars))`
98			`goto out;`
99
100			`read += chars;`
101			`PIPE_START(*inode) += chars;`
102			`PIPE_START(*inode) &= (PIPE_SIZE - 1);`
103			`PIPE_LEN(*inode) -= chars;`
104			`count -= chars;`
105			`buf += chars;`
106			`}`
107
108			`/* Cache behaviour optimization */`
109			`if (!PIPE_LEN(*inode))`
110			`PIPE_START(*inode) = 0;`
111
112			`if (count && PIPE_WAITING_WRITERS(*inode) && !(filp->f_flags & O_NONBLOCK)) {`
113			`/*`
114			`* We know that we are going to sleep: signal`
115			`* writers synchronously that there is more`
116			`* room.`
117			`*/`
118			`wake_up_interruptible_sync(PIPE_WAIT(*inode));`
119			`if (!PIPE_EMPTY(*inode))`
120			`BUG();`
121			`goto do_more_read;`
122			`}`
123			`/* Signal writers asynchronously that there is more room. */`
124			`wake_up_interruptible(PIPE_WAIT(*inode));`
125
126			`ret = read;`
127			`out:`
128			`up(PIPE_SEM(*inode));`
129			`out_nolock:`
130			`if (read)`
131			`ret = read;`
132
133			`UPDATE_ATIME(inode);`
134			`return ret;`
135			`}`
136
137			`static ssize_t`
138			`pipe_write(struct file filp, const char buf, size_t count, loff_t *ppos)`
139			`{`
140			`struct inode *inode = filp->f_dentry->d_inode;`
141			`ssize_t free, written, ret;`
142
143			`/* Seeks are not allowed on pipes. */`
144			`ret = -ESPIPE;`
145			`written = 0;`
146			`if (ppos != &filp->f_pos)`
147			`goto out_nolock;`
148
149			`/* Null write succeeds. */`
150			`ret = 0;`
151			`if (count == 0)`
152			`goto out_nolock;`
153
154			`ret = -ERESTARTSYS;`
155			`if (down_interruptible(PIPE_SEM(*inode)))`
156			`goto out_nolock;`
157
158			`/* No readers yields SIGPIPE. */`
159			`if (!PIPE_READERS(*inode))`
160			`goto sigpipe;`
161
162			`/* If count <= PIPE_BUF, we have to make it atomic. */`
163			`free = (count <= PIPE_BUF ? count : 1);`
164
165			`/* Wait, or check for, available space. */`
166			`if (filp->f_flags & O_NONBLOCK) {`
167			`ret = -EAGAIN;`
168			`if (PIPE_FREE(*inode) < free)`
169			`goto out;`
170			`} else {`
171			`while (PIPE_FREE(*inode) < free) {`
172			`PIPE_WAITING_WRITERS(*inode)++;`
173			`pipe_wait(inode);`
174			`PIPE_WAITING_WRITERS(*inode)--;`
175			`ret = -ERESTARTSYS;`
176			`if (signal_pending(current))`
177			`goto out;`
178
179			`if (!PIPE_READERS(*inode))`
180			`goto sigpipe;`
181			`}`
182			`}`
183
184			`/* Copy into available space. */`
185			`ret = -EFAULT;`
186			`while (count > 0) {`
187			`int space;`
188			`char pipebuf = PIPE_BASE(inode) + PIPE_END(*inode);`
189			`ssize_t chars = PIPE_MAX_WCHUNK(*inode);`
190
191			`if ((space = PIPE_FREE(*inode)) != 0) {`
192			`if (chars > count)`
193			`chars = count;`
194			`if (chars > space)`
195			`chars = space;`
196
197			`if (copy_from_user(pipebuf, buf, chars))`
198			`goto out;`
199
200			`written += chars;`
201			`PIPE_LEN(*inode) += chars;`
202			`count -= chars;`
203			`buf += chars;`
204			`space = PIPE_FREE(*inode);`
205			`continue;`
206			`}`
207
208			`ret = written;`
209			`if (filp->f_flags & O_NONBLOCK)`
210			`break;`
211
212			`do {`
213			`/*`
214			`* Synchronous wake-up: it knows that this process`
215			`* is going to give up this CPU, so it doesn't have`
216			`* to do idle reschedules.`
217			`*/`
218			`wake_up_interruptible_sync(PIPE_WAIT(*inode));`
219			`PIPE_WAITING_WRITERS(*inode)++;`
220			`pipe_wait(inode);`
221			`PIPE_WAITING_WRITERS(*inode)--;`
222			`if (signal_pending(current))`
223			`goto out;`
224			`if (!PIPE_READERS(*inode))`
225			`goto sigpipe;`
226			`} while (!PIPE_FREE(*inode));`
227			`ret = -EFAULT;`
228			`}`
229
230			`/* Signal readers asynchronously that there is more data. */`
231			`wake_up_interruptible(PIPE_WAIT(*inode));`
232
233			`update_mctime(inode);`
234
235			`out:`
236			`up(PIPE_SEM(*inode));`
237			`out_nolock:`
238			`if (written)`
239			`ret = written;`
240			`return ret;`
241
242			`sigpipe:`
243			`if (written)`
244			`goto out;`
245			`up(PIPE_SEM(*inode));`
246			`send_sig(SIGPIPE, current, 0);`
247			`return -EPIPE;`
248			`}`
249
250			`static ssize_t`
251			`bad_pipe_r(struct file filp, char buf, size_t count, loff_t *ppos)`
252			`{`
253			`return -EBADF;`
254			`}`
255
256			`static ssize_t`
257			`bad_pipe_w(struct file filp, const char buf, size_t count, loff_t *ppos)`
258			`{`
259			`return -EBADF;`
260			`}`
261
262			`static int`
263			`pipe_ioctl(struct inode pino, struct file filp,`
264			`unsigned int cmd, unsigned long arg)`
265			`{`
266			`switch (cmd) {`
267			`case FIONREAD:`
268			`return put_user(PIPE_LEN(pino), (int )arg);`
269			`default:`
270			`return -EINVAL;`
271			`}`
272			`}`
273
274			`/* No kernel lock held - fine */`
275			`static unsigned int`
276			`pipe_poll(struct file filp, poll_table wait)`
277			`{`
278			`unsigned int mask;`
279			`struct inode *inode = filp->f_dentry->d_inode;`
280
281			`poll_wait(filp, PIPE_WAIT(*inode), wait);`
282
283			`/* Reading only -- no need for acquiring the semaphore. */`
284			`mask = POLLIN \| POLLRDNORM;`
285			`if (PIPE_EMPTY(*inode))`
286			`mask = POLLOUT \| POLLWRNORM;`
287			`if (!PIPE_WRITERS(inode) && filp->f_version != PIPE_WCOUNTER(inode))`
288			`mask \|= POLLHUP;`
289			`if (!PIPE_READERS(*inode))`
290			`mask \|= POLLERR;`
291
292			`return mask;`
293			`}`
294
295			`/* FIXME: most Unices do not set POLLERR for fifos */`
296			`#define fifo_poll pipe_poll`
297
298			`static int`
299			`pipe_release(struct inode *inode, int decr, int decw)`
300			`{`
301			`down(PIPE_SEM(*inode));`
302			`PIPE_READERS(*inode) -= decr;`
303			`PIPE_WRITERS(*inode) -= decw;`
304			`if (!PIPE_READERS(inode) && !PIPE_WRITERS(inode)) {`
305			`struct pipe_inode_info *info = inode->i_pipe;`
306			`inode->i_pipe = NULL;`
307			`free_page((unsigned long) info->base);`
308			`kfree(info);`
309			`} else {`
310			`wake_up_interruptible(PIPE_WAIT(*inode));`
311			`}`
312			`up(PIPE_SEM(*inode));`
313
314			`return 0;`
315			`}`
316
317			`static int`
318			`pipe_read_release(struct inode inode, struct file filp)`
319			`{`
320			`return pipe_release(inode, 1, 0);`
321			`}`
322
323			`static int`
324			`pipe_write_release(struct inode inode, struct file filp)`
325			`{`
326			`return pipe_release(inode, 0, 1);`
327			`}`
328
329			`static int`
330			`pipe_rdwr_release(struct inode inode, struct file filp)`
331			`{`
332			`int decr, decw;`
333
334			`decr = (filp->f_mode & FMODE_READ) != 0;`
335			`decw = (filp->f_mode & FMODE_WRITE) != 0;`
336			`return pipe_release(inode, decr, decw);`
337			`}`
338
339			`static int`
340			`pipe_read_open(struct inode inode, struct file filp)`
341			`{`
342			`/* We could have perhaps used atomic_t, but this and friends`
343			`below are the only places. So it doesn't seem worthwhile. */`
344			`down(PIPE_SEM(*inode));`
345			`PIPE_READERS(*inode)++;`
346			`up(PIPE_SEM(*inode));`
347
348			`return 0;`
349			`}`
350
351			`static int`
352			`pipe_write_open(struct inode inode, struct file filp)`
353			`{`
354			`down(PIPE_SEM(*inode));`
355			`PIPE_WRITERS(*inode)++;`
356			`up(PIPE_SEM(*inode));`
357
358			`return 0;`
359			`}`
360
361			`static int`
362			`pipe_rdwr_open(struct inode inode, struct file filp)`
363			`{`
364			`down(PIPE_SEM(*inode));`
365			`if (filp->f_mode & FMODE_READ)`
366			`PIPE_READERS(*inode)++;`
367			`if (filp->f_mode & FMODE_WRITE)`
368			`PIPE_WRITERS(*inode)++;`
369			`up(PIPE_SEM(*inode));`
370
371			`return 0;`
372			`}`
373
374			`/*`
375			`* The file_operations structs are not static because they`
376			`* are also used in linux/fs/fifo.c to do operations on FIFOs.`
377			`*/`
378			`struct file_operations read_fifo_fops = {`
379			`llseek: no_llseek,`
380			`read: pipe_read,`
381			`write: bad_pipe_w,`
382			`poll: fifo_poll,`
383			`ioctl: pipe_ioctl,`
384			`open: pipe_read_open,`
385			`release: pipe_read_release,`
386			`};`
387
388			`struct file_operations write_fifo_fops = {`
389			`llseek: no_llseek,`
390			`read: bad_pipe_r,`
391			`write: pipe_write,`
392			`poll: fifo_poll,`
393			`ioctl: pipe_ioctl,`
394			`open: pipe_write_open,`
395			`release: pipe_write_release,`
396			`};`
397
398			`struct file_operations rdwr_fifo_fops = {`
399			`llseek: no_llseek,`
400			`read: pipe_read,`
401			`write: pipe_write,`
402			`poll: fifo_poll,`
403			`ioctl: pipe_ioctl,`
404			`open: pipe_rdwr_open,`
405			`release: pipe_rdwr_release,`
406			`};`
407
408			`struct file_operations read_pipe_fops = {`
409			`llseek: no_llseek,`
410			`read: pipe_read,`
411			`write: bad_pipe_w,`
412			`poll: pipe_poll,`
413			`ioctl: pipe_ioctl,`
414			`open: pipe_read_open,`
415			`release: pipe_read_release,`
416			`};`
417
418			`struct file_operations write_pipe_fops = {`
419			`llseek: no_llseek,`
420			`read: bad_pipe_r,`
421			`write: pipe_write,`
422			`poll: pipe_poll,`
423			`ioctl: pipe_ioctl,`
424			`open: pipe_write_open,`
425			`release: pipe_write_release,`
426			`};`
427
428			`struct file_operations rdwr_pipe_fops = {`
429			`llseek: no_llseek,`
430			`read: pipe_read,`
431			`write: pipe_write,`
432			`poll: pipe_poll,`
433			`ioctl: pipe_ioctl,`
434			`open: pipe_rdwr_open,`
435			`release: pipe_rdwr_release,`
436			`};`
437
438			`struct inode* pipe_new(struct inode* inode)`
439			`{`
440			`unsigned long page;`
441
442			`page = __get_free_page(GFP_USER);`
443			`if (!page)`
444			`return NULL;`
445
446			`inode->i_pipe = kmalloc(sizeof(struct pipe_inode_info), GFP_KERNEL);`
447			`if (!inode->i_pipe)`
448			`goto fail_page;`
449
450			`init_waitqueue_head(PIPE_WAIT(*inode));`
451			`PIPE_BASE(inode) = (char) page;`
452			`PIPE_START(inode) = PIPE_LEN(inode) = 0;`
453			`PIPE_READERS(inode) = PIPE_WRITERS(inode) = 0;`
454			`PIPE_WAITING_READERS(inode) = PIPE_WAITING_WRITERS(inode) = 0;`
455			`PIPE_RCOUNTER(inode) = PIPE_WCOUNTER(inode) = 1;`
456
457			`return inode;`
458			`fail_page:`
459			`free_page(page);`
460			`return NULL;`
461			`}`
462
463			`static struct vfsmount *pipe_mnt;`
464			`static int pipefs_delete_dentry(struct dentry *dentry)`
465			`{`
466			`return 1;`
467			`}`
468			`static struct dentry_operations pipefs_dentry_operations = {`
469			`d_delete: pipefs_delete_dentry,`
470			`};`
471
472			`static struct inode * get_pipe_inode(void)`
473			`{`
474			`struct inode *inode = new_inode(pipe_mnt->mnt_sb);`
475
476			`if (!inode)`
477			`goto fail_inode;`
478
479			`if(!pipe_new(inode))`
480			`goto fail_iput;`
481			`PIPE_READERS(inode) = PIPE_WRITERS(inode) = 1;`
482			`inode->i_fop = &rdwr_pipe_fops;`
483
484			`/*`
485			`* Mark the inode dirty from the very beginning,`
486			`* that way it will never be moved to the dirty`
487			`* list because "mark_inode_dirty()" will think`
488			`* that it already _is_ on the dirty list.`
489			`*/`
490			`inode->i_state = I_DIRTY;`
491			`inode->i_mode = S_IFIFO \| S_IRUSR \| S_IWUSR;`
492			`inode->i_uid = current->fsuid;`
493			`inode->i_gid = current->fsgid;`
494			`inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;`
495			`inode->i_blksize = PAGE_SIZE;`
496			`return inode;`
497
498			`fail_iput:`
499			`iput(inode);`
500			`fail_inode:`
501			`return NULL;`
502			`}`
503
504			`int do_pipe(int *fd)`
505			`{`
506			`struct qstr this;`
507			`char name[32];`
508			`struct dentry *dentry;`
509			`struct inode * inode;`
510			`struct file f1, f2;`
511			`int error;`
512			`int i,j;`
513
514			`error = -ENFILE;`
515			`f1 = get_empty_filp();`
516			`if (!f1)`
517			`goto no_files;`
518
519			`f2 = get_empty_filp();`
520			`if (!f2)`
521			`goto close_f1;`
522
523			`inode = get_pipe_inode();`
524			`if (!inode)`
525			`goto close_f12;`
526
527			`error = get_unused_fd();`
528			`if (error < 0)`
529			`goto close_f12_inode;`
530			`i = error;`
531
532			`error = get_unused_fd();`
533			`if (error < 0)`
534			`goto close_f12_inode_i;`
535			`j = error;`
536
537			`error = -ENOMEM;`
538			`sprintf(name, "[%lu]", inode->i_ino);`
539			`this.name = name;`
540			`this.len = strlen(name);`
541			`this.hash = inode->i_ino; /* will go */`
542			`dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);`
543			`if (!dentry)`
544			`goto close_f12_inode_i_j;`
545			`dentry->d_op = &pipefs_dentry_operations;`
546			`d_add(dentry, inode);`
547			`f1->f_vfsmnt = f2->f_vfsmnt = mntget(mntget(pipe_mnt));`
548			`f1->f_dentry = f2->f_dentry = dget(dentry);`
549
550			`/* read file */`
551			`f1->f_pos = f2->f_pos = 0;`
552			`f1->f_flags = O_RDONLY;`
553			`f1->f_op = &read_pipe_fops;`
554			`f1->f_mode = 1;`
555			`f1->f_version = 0;`
556
557			`/* write file */`
558			`f2->f_flags = O_WRONLY;`
559			`f2->f_op = &write_pipe_fops;`
560			`f2->f_mode = 2;`
561			`f2->f_version = 0;`
562
563			`fd_install(i, f1);`
564			`fd_install(j, f2);`
565			`fd[0] = i;`
566			`fd[1] = j;`
567			`return 0;`
568
569			`close_f12_inode_i_j:`
570			`put_unused_fd(j);`
571			`close_f12_inode_i:`
572			`put_unused_fd(i);`
573			`close_f12_inode:`
574			`free_page((unsigned long) PIPE_BASE(*inode));`
575			`kfree(inode->i_pipe);`
576			`inode->i_pipe = NULL;`
577			`iput(inode);`
578			`close_f12:`
579			`put_filp(f2);`
580			`close_f1:`
581			`put_filp(f1);`
582			`no_files:`
583			`return error;`
584			`}`
585
586			`/*`
587			`* pipefs should _never_ be mounted by userland - too much of security hassle,`
588			`* no real gain from having the whole whorehouse mounted. So we don't need`
589			`* any operations on the root directory. However, we need a non-trivial`
590			`* d_name - pipe: will go nicely and kill the special-casing in procfs.`
591			`*/`
592			`static int pipefs_statfs(struct super_block sb, struct statfs buf)`
593			`{`
594			`buf->f_type = PIPEFS_MAGIC;`
595			`buf->f_bsize = 1024;`
596			`buf->f_namelen = 255;`
597			`return 0;`
598			`}`
599
600			`static struct super_operations pipefs_ops = {`
601			`statfs: pipefs_statfs,`
602			`};`
603
604			`static struct super_block * pipefs_read_super(struct super_block sb, void data, int silent)`
605			`{`
606			`struct inode *root = new_inode(sb);`
607			`if (!root)`
608			`return NULL;`
609			`root->i_mode = S_IFDIR \| S_IRUSR \| S_IWUSR;`
610			`root->i_uid = root->i_gid = 0;`
611			`root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;`
612			`sb->s_blocksize = 1024;`
613			`sb->s_blocksize_bits = 10;`
614			`sb->s_magic = PIPEFS_MAGIC;`
615			`sb->s_op = &pipefs_ops;`
616			`sb->s_root = d_alloc(NULL, &(const struct qstr) { "pipe:", 5, 0 });`
617			`if (!sb->s_root) {`
618			`iput(root);`
619			`return NULL;`
620			`}`
621			`sb->s_root->d_sb = sb;`
622			`sb->s_root->d_parent = sb->s_root;`
623			`d_instantiate(sb->s_root, root);`
624			`return sb;`
625			`}`
626
627			`static DECLARE_FSTYPE(pipe_fs_type, "pipefs", pipefs_read_super, FS_NOMOUNT);`
628
629			`static int __init init_pipe_fs(void)`
630			`{`
631			`int err = register_filesystem(&pipe_fs_type);`
632			`if (!err) {`
633			`pipe_mnt = kern_mount(&pipe_fs_type);`
634			`err = PTR_ERR(pipe_mnt);`
635			`if (IS_ERR(pipe_mnt))`
636			`unregister_filesystem(&pipe_fs_type);`
637			`else`
638			`err = 0;`
639			`}`
640			`return err;`
641			`}`
642
643			`static void __exit exit_pipe_fs(void)`
644			`{`
645			`unregister_filesystem(&pipe_fs_type);`
646			`mntput(pipe_mnt);`
647			`}`
648
649			`module_init(init_pipe_fs)`
650			`module_exit(exit_pipe_fs)`