cregit-Linux how code gets into the kernel

Release 4.7 fs/pipe.c

Directory: fs
/*
 *  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 <linux/fs.h>
#include <linux/log2.h>
#include <linux/mount.h>
#include <linux/magic.h>
#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 <linux/fcntl.h>

#include <asm/uaccess.h>
#include <asm/ioctls.h>

#include "internal.h"

/*
 * The max size that a non-root user is allowed to grow the pipe. Can
 * be set by root in /proc/sys/fs/pipe-max-size
 */

unsigned int pipe_max_size = 1048576;

/*
 * Minimum pipe size, as required by POSIX
 */

unsigned int pipe_min_size = PAGE_SIZE;

/* Maximum allocatable pages per user. Hard limit is unset by default, soft
 * matches default values.
 */

unsigned long pipe_user_pages_hard;

unsigned long pipe_user_pages_soft = PIPE_DEF_BUFFERS * INR_OPEN_CUR;

/*
 * 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.
 *
 * FIFOs and Pipes now generate SIGIO for both readers and writers.
 * -- Jeremy Elson <jelson@circlemud.org> 2001-08-16
 *
 * pipe_read & write cleanup
 * -- Manfred Spraul <manfred@colorfullife.com> 2002-05-09
 */


static void pipe_lock_nested(struct pipe_inode_info *pipe, int subclass) { if (pipe->files) mutex_lock_nested(&pipe->mutex, subclass); }

Contributors

PersonTokensPropCommitsCommitProp
miklos szeredimiklos szeredi2893.33%133.33%
al viroal viro26.67%266.67%
Total30100.00%3100.00%


void pipe_lock(struct pipe_inode_info *pipe) { /* * pipe_lock() nests non-pipe inode locks (for writing to a file) */ pipe_lock_nested(pipe, I_MUTEX_PARENT); }

Contributors

PersonTokensPropCommitsCommitProp
miklos szeredimiklos szeredi18100.00%1100.00%
Total18100.00%1100.00%

EXPORT_SYMBOL(pipe_lock);
void pipe_unlock(struct pipe_inode_info *pipe) { if (pipe->files) mutex_unlock(&pipe->mutex); }

Contributors

PersonTokensPropCommitsCommitProp
miklos szeredimiklos szeredi2291.67%133.33%
al viroal viro28.33%266.67%
Total24100.00%3100.00%

EXPORT_SYMBOL(pipe_unlock);
static inline void __pipe_lock(struct pipe_inode_info *pipe) { mutex_lock_nested(&pipe->mutex, I_MUTEX_PARENT); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro22100.00%1100.00%
Total22100.00%1100.00%


static inline void __pipe_unlock(struct pipe_inode_info *pipe) { mutex_unlock(&pipe->mutex); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro20100.00%1100.00%
Total20100.00%1100.00%


void pipe_double_lock(struct pipe_inode_info *pipe1, struct pipe_inode_info *pipe2) { BUG_ON(pipe1 == pipe2); if (pipe1 < pipe2) { pipe_lock_nested(pipe1, I_MUTEX_PARENT); pipe_lock_nested(pipe2, I_MUTEX_CHILD); } else { pipe_lock_nested(pipe2, I_MUTEX_PARENT); pipe_lock_nested(pipe1, I_MUTEX_CHILD); } }

Contributors

PersonTokensPropCommitsCommitProp
miklos szeredimiklos szeredi5996.72%150.00%
peter zijlstrapeter zijlstra23.28%150.00%
Total61100.00%2100.00%

/* Drop the inode semaphore and wait for a pipe event, atomically */
void pipe_wait(struct pipe_inode_info *pipe) { 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); pipe_unlock(pipe); schedule(); finish_wait(&pipe->wait, &wait); pipe_lock(pipe); }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git3362.26%233.33%
ingo molnaringo molnar1324.53%233.33%
andrew mortonandrew morton59.43%116.67%
miklos szeredimiklos szeredi23.77%116.67%
Total53100.00%6100.00%


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 put_page(page); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds3465.38%233.33%
jens axboejens axboe1223.08%116.67%
ingo molnaringo molnar59.62%233.33%
kirill a. shutemovkirill a. shutemov11.92%116.67%
Total52100.00%6100.00%

/** * 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; }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe4697.87%480.00%
ingo molnaringo molnar12.13%120.00%
Total47100.00%5100.00%

EXPORT_SYMBOL(generic_pipe_buf_steal); /** * 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) { get_page(buf->page); }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe2195.45%375.00%
kirill a. shutemovkirill a. shutemov14.55%125.00%
Total22100.00%4100.00%

EXPORT_SYMBOL(generic_pipe_buf_get); /** * 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; }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe18100.00%2100.00%
Total18100.00%2100.00%

EXPORT_SYMBOL(generic_pipe_buf_confirm); /** * generic_pipe_buf_release - put a reference to a &struct pipe_buffer * @pipe: the pipe that the buffer belongs to * @buf: the buffer to put a reference to * * Description: * This function releases a reference to @buf. */
void generic_pipe_buf_release(struct pipe_inode_info *pipe, struct pipe_buffer *buf) { put_page(buf->page); }

Contributors

PersonTokensPropCommitsCommitProp
miklos szeredimiklos szeredi2195.45%150.00%
kirill a. shutemovkirill a. shutemov14.55%150.00%
Total22100.00%2100.00%

EXPORT_SYMBOL(generic_pipe_buf_release); static const struct pipe_buf_operations anon_pipe_buf_ops = { .can_merge = 1, .confirm = generic_pipe_buf_confirm, .release = anon_pipe_buf_release, .steal = generic_pipe_buf_steal, .get = generic_pipe_buf_get, }; static const struct pipe_buf_operations packet_pipe_buf_ops = { .can_merge = 0, .confirm = generic_pipe_buf_confirm, .release = anon_pipe_buf_release, .steal = generic_pipe_buf_steal, .get = generic_pipe_buf_get, };
static ssize_t pipe_read(struct kiocb *iocb, struct iov_iter *to) { size_t total_len = iov_iter_count(to); struct file *filp = iocb->ki_filp; struct pipe_inode_info *pipe = filp->private_data; int do_wakeup; ssize_t ret; /* Null read succeeds. */ if (unlikely(total_len == 0)) return 0; do_wakeup = 0; ret = 0; __pipe_lock(pipe); for (;;) { int bufs = pipe->nrbufs; if (bufs) { int curbuf = pipe->curbuf; struct pipe_buffer *buf = pipe->bufs + curbuf; const struct pipe_buf_operations *ops = buf->ops; size_t chars = buf->len; size_t written; int error; if (chars > total_len) chars = total_len; error = ops->confirm(pipe, buf); if (error) { if (!ret) ret = error; break; } written = copy_page_to_iter(buf->page, buf->offset, chars, to); if (unlikely(written < chars)) { if (!ret) ret = -EFAULT; break; } ret += chars; buf->offset += chars; buf->len -= chars; /* Was it a packet buffer? Clean up and exit */ if (buf->flags & PIPE_BUF_FLAG_PACKET) { total_len = chars; buf->len = 0; } if (!buf->len) { buf->ops = NULL; ops->release(pipe, buf); curbuf = (curbuf + 1) & (pipe->buffers - 1); pipe->curbuf = curbuf; pipe->nrbufs = --bufs; do_wakeup = 1; } total_len -= chars; if (!total_len) break; /* common path: read succeeded */ } if (bufs) /* More to do? */ continue; if (!pipe->writers) break; 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 * we can wait for that data without violating POSIX. */ if (ret) break; if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; break; } } if (signal_pending(current)) { if (!ret) ret = -ERESTARTSYS; break; } if (do_wakeup) { wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM); kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT); } pipe_wait(pipe); } __pipe_unlock(pipe); /* Signal writers asynchronously that there is more room. */ if (do_wakeup) { wake_up_interruptible_sync_poll(&pipe->wait, POLLOUT | POLLWRNORM); kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT); } if (ret > 0) file_accessed(filp); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds12827.47%512.50%
manfred spraulmanfred spraul10322.10%12.50%
pre-gitpre-git10121.67%1332.50%
al viroal viro367.73%717.50%
ingo molnaringo molnar326.87%37.50%
jens axboejens axboe224.72%512.50%
dave jonesdave jones163.43%12.50%
badari pulavartybadari pulavarty122.58%12.50%
andrew mortonandrew morton71.50%12.50%
davide libenzidavide libenzi61.29%12.50%
nicolas kaisernicolas kaiser20.43%12.50%
eric dumazeteric dumazet10.21%12.50%
Total466100.00%40100.00%


static inline int is_packetized(struct file *file) { return (file->f_flags & O_DIRECT) != 0; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds23100.00%1100.00%
Total23100.00%1100.00%


static ssize_t pipe_write(struct kiocb *iocb, struct iov_iter *from) { struct file *filp = iocb->ki_filp; struct pipe_inode_info *pipe = filp->private_data; ssize_t ret = 0; int do_wakeup = 0; size_t total_len = iov_iter_count(from); ssize_t chars; /* Null write succeeds. */ if (unlikely(total_len == 0)) return 0; __pipe_lock(pipe); if (!pipe->readers) { 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; const struct pipe_buf_operations *ops = buf->ops; int offset = buf->offset + buf->len; if (ops->can_merge && offset + chars <= PAGE_SIZE) { ret = ops->confirm(pipe, buf); if (ret) goto out; ret = copy_page_from_iter(buf->page, offset, chars, from); if (unlikely(ret < chars)) { ret = -EFAULT; goto out; } do_wakeup = 1; buf->len += ret; if (!iov_iter_count(from)) goto out; } } for (;;) { int bufs; if (!pipe->readers) { send_sig(SIGPIPE, current, 0); if (!ret) ret = -EPIPE; break; } bufs = pipe->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; int copied; if (!page) { page = alloc_page(GFP_HIGHUSER); if (unlikely(!page)) { ret = ret ? : -ENOMEM; break; } pipe->tmp_page = page; } /* 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? */ do_wakeup = 1; copied = copy_page_from_iter(page, 0, PAGE_SIZE, from); if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) { if (!ret) ret = -EFAULT; break; } ret += copied; /* Insert it into the buffer array */ buf->page = page; buf->ops = &anon_pipe_buf_ops; buf->offset = 0; buf->len = copied; buf->flags = 0; if (is_packetized(filp)) { buf->ops = &packet_pipe_buf_ops; buf->flags = PIPE_BUF_FLAG_PACKET; } pipe->nrbufs = ++bufs; pipe->tmp_page = NULL; if (!iov_iter_count(from)) break; } if (bufs < pipe->buffers) continue; if (filp->f_flags & O_NONBLOCK) { if (!ret) ret = -EAGAIN; break; } if (signal_pending(current)) { if (!ret) ret = -ERESTARTSYS; break; } if (do_wakeup) { wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM); kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN); do_wakeup = 0; } pipe->waiting_writers++; pipe_wait(pipe); pipe->waiting_writers--; } out: __pipe_unlock(pipe); if (do_wakeup) { wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM); kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN); } if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) { int err = file_update_time(filp); if (err) ret = err; sb_end_write(file_inode(filp)->i_sb); } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds24033.85%613.64%
manfred spraulmanfred spraul11616.36%12.27%
pre-gitpre-git7410.44%1329.55%
al viroal viro638.89%511.36%
ingo molnaringo molnar436.06%36.82%
jens axboejens axboe365.08%511.36%
prasanna medaprasanna meda233.24%12.27%
andrea arcangeliandrea arcangeli233.24%12.27%
dmitriy monakhovdmitriy monakhov202.82%12.27%
andrew mortonandrew morton162.26%12.27%
dave jonesdave jones162.26%12.27%
josef bacikjosef bacik131.83%12.27%
badari pulavartybadari pulavarty121.69%12.27%
davide libenzidavide libenzi60.85%12.27%
eric biggerseric biggers50.71%12.27%
christoph hellwigchristoph hellwig20.28%12.27%
eric dumazeteric dumazet10.14%12.27%
Total709100.00%44100.00%


static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct pipe_inode_info *pipe = filp->private_data; int count, buf, nrbufs; switch (cmd) { case FIONREAD: __pipe_lock(pipe); count = 0; buf = pipe->curbuf; nrbufs = pipe->nrbufs; while (--nrbufs >= 0) { count += pipe->bufs[buf].len; buf = (buf+1) & (pipe->buffers - 1); } __pipe_unlock(pipe); return put_user(count, (int __user *)arg); default: return -ENOIOCTLCMD; } }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds6754.03%216.67%
pre-gitpre-git3931.45%325.00%
al viroal viro86.45%325.00%
ingo molnaringo molnar43.23%18.33%
jens axboejens axboe32.42%18.33%
andi kleenandi kleen21.61%18.33%
will deaconwill deacon10.81%18.33%
Total124100.00%12100.00%

/* No kernel lock held - fine */
static unsigned int pipe_poll(struct file *filp, poll_table *wait) { unsigned int mask; struct pipe_inode_info *pipe = filp->private_data; int nrbufs; poll_wait(filp, &pipe->wait, wait); /* Reading only -- no need for acquiring the semaphore. */ nrbufs = pipe->nrbufs; mask = 0; if (filp->f_mode & FMODE_READ) { mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0; if (!pipe->writers && filp->f_version != pipe->w_counter) mask |= POLLHUP; } if (filp->f_mode & FMODE_WRITE) { mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0; /* * Most Unices do not set POLLERR for FIFOs but on Linux they * behave exactly like pipes for poll(). */ if (!pipe->readers) mask |= POLLERR; } return mask; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git6345.32%850.00%
linus torvaldslinus torvalds5539.57%212.50%
ingo molnaringo molnar1410.07%212.50%
jens axboejens axboe32.16%16.25%
al viroal viro32.16%212.50%
pekka j enbergpekka j enberg10.72%16.25%
Total139100.00%16100.00%


static void put_pipe_info(struct inode *inode, struct pipe_inode_info *pipe) { int kill = 0; spin_lock(&inode->i_lock); if (!--pipe->files) { inode->i_pipe = NULL; kill = 1; } spin_unlock(&inode->i_lock); if (kill) free_pipe_info(pipe); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds66100.00%1100.00%
Total66100.00%1100.00%


static int pipe_release(struct inode *inode, struct file *file) { struct pipe_inode_info *pipe = file->private_data; __pipe_lock(pipe); if (file->f_mode & FMODE_READ) pipe->readers--; if (file->f_mode & FMODE_WRITE) pipe->writers--; if (pipe->readers || pipe->writers) { wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM | POLLERR | POLLHUP); kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN); kill_fasync(&pipe->fasync_writers, SIGIO, POLL_OUT); } __pipe_unlock(pipe); put_pipe_info(inode, pipe); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro3628.35%323.08%
ingo molnaringo molnar3023.62%215.38%
dave jonesdave jones2318.11%17.69%
pre-gitpre-git2015.75%430.77%
linus torvaldslinus torvalds1310.24%215.38%
davide libenzidavide libenzi53.94%17.69%
Total127100.00%13100.00%


static int pipe_fasync(int fd, struct file *filp, int on) { struct pipe_inode_info *pipe = filp->private_data; int retval = 0; __pipe_lock(pipe); if (filp->f_mode & FMODE_READ) retval = fasync_helper(fd, filp, on, &pipe->fasync_readers); if ((filp->f_mode & FMODE_WRITE) && retval >= 0) { retval = fasync_helper(fd, filp, on, &pipe->fasync_writers); if (retval < 0 && (filp->f_mode & FMODE_READ)) /* this can happen only if on == T */ fasync_helper(-1, filp, 0, &pipe->fasync_readers); } __pipe_unlock(pipe); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
dave jonesdave jones5844.62%110.00%
al viroal viro3426.15%440.00%
oleg nesterovoleg nesterov2418.46%110.00%
ingo molnaringo molnar107.69%220.00%
pre-gitpre-git43.08%220.00%
Total130100.00%10100.00%


static void account_pipe_buffers(struct pipe_inode_info *pipe, unsigned long old, unsigned long new) { atomic_long_add(new - old, &pipe->user->pipe_bufs); }

Contributors

PersonTokensPropCommitsCommitProp
willy tarreauwilly tarreau33100.00%1100.00%
Total33100.00%1100.00%


static bool too_many_pipe_buffers_soft(struct user_struct *user) { return pipe_user_pages_soft && atomic_long_read(&user->pipe_bufs) >= pipe_user_pages_soft; }

Contributors

PersonTokensPropCommitsCommitProp
willy tarreauwilly tarreau24100.00%1100.00%
Total24100.00%1100.00%


static bool too_many_pipe_buffers_hard(struct user_struct *user) { return pipe_user_pages_hard && atomic_long_read(&user->pipe_bufs) >= pipe_user_pages_hard; }

Contributors

PersonTokensPropCommitsCommitProp
willy tarreauwilly tarreau24100.00%1100.00%
Total24100.00%1100.00%


struct pipe_inode_info *alloc_pipe_info(void) { struct pipe_inode_info *pipe; pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL); if (pipe) { unsigned long pipe_bufs = PIPE_DEF_BUFFERS; struct user_struct *user = get_current_user(); if (!too_many_pipe_buffers_hard(user)) { if (too_many_pipe_buffers_soft(user)) pipe_bufs = 1; pipe->bufs = kzalloc(sizeof(struct pipe_buffer) * pipe_bufs, GFP_KERNEL); } if (pipe->bufs) { init_waitqueue_head(&pipe->wait); pipe->r_counter = pipe->w_counter = 1; pipe->buffers = pipe_bufs; pipe->user = user; account_pipe_buffers(pipe, 0, pipe_bufs); mutex_init(&pipe->mutex); return pipe; } free_uid(user); kfree(pipe); } return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
willy tarreauwilly tarreau5736.54%114.29%
ingo molnaringo molnar5032.05%228.57%
jens axboejens axboe3623.08%114.29%
al viroal viro138.33%342.86%
Total156100.00%7100.00%


void free_pipe_info(struct pipe_inode_info *pipe) { int i; account_pipe_buffers(pipe, pipe->buffers, 0); free_uid(pipe->user); for (i = 0; i < pipe->buffers; i++) { struct pipe_buffer *buf = pipe->bufs + i; if (buf->ops) buf->ops->release(pipe, buf); } if (pipe->tmp_page) __free_page(pipe->tmp_page); kfree(pipe->bufs); kfree(pipe); }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds6564.36%550.00%
willy tarreauwilly tarreau1817.82%110.00%
jens axboejens axboe1110.89%220.00%
ingo molnaringo molnar65.94%110.00%
al viroal viro10.99%110.00%
Total101100.00%10100.00%

static struct vfsmount *pipe_mnt __read_mostly; /* * 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]", d_inode(dentry)->i_ino); }

Contributors

PersonTokensPropCommitsCommitProp
eric dumazeteric dumazet3592.11%150.00%
david howellsdavid howells37.89%150.00%
Total38100.00%2100.00%

static const struct dentry_operations pipefs_dentry_operations = { .d_dname = pipefs_dname, };
static struct inode * get_pipe_inode(void) { struct inode *inode = new_inode_pseudo(pipe_mnt->mnt_sb); struct pipe_inode_info *pipe; if (!inode) goto fail_inode; inode->i_ino = get_next_ino(); pipe = alloc_pipe_info(); if (!pipe) goto fail_iput; inode->i_pipe = pipe; pipe->files = 2; pipe->readers = pipe->writers = 1; inode->i_fop = &pipefifo_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; return inode; fail_iput: iput(inode); fail_inode: return NULL; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git9868.06%428.57%
ingo molnaringo molnar2114.58%321.43%
al viroal viro85.56%321.43%
christoph hellwigchristoph hellwig74.86%17.14%
linus torvaldslinus torvalds53.47%17.14%
david howellsdavid howells42.78%17.14%
eric dumazeteric dumazet10.69%17.14%
Total144100.00%14100.00%


int create_pipe_files(struct file **res, int flags) { int err; struct inode *inode = get_pipe_inode(); struct file *f; struct path path; static struct qstr name = { .name = "" }; if (!inode) return -ENFILE; err = -ENOMEM; path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name); if (!path.dentry) goto err_inode; path.mnt = mntget(pipe_mnt); d_instantiate(path.dentry, inode); f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops); if (IS_ERR(f)) { err = PTR_ERR(f); goto err_dentry; } f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT)); f->private_data = inode->i_pipe; res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops); if (IS_ERR(res[0])) { err = PTR_ERR(res[0]); goto err_file; } path_get(&path); res[0]->private_data = inode->i_pipe; res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK); res[1] = f; return 0; err_file: put_filp(f); err_dentry: free_pipe_info(inode->i_pipe); path_put(&path); return err; err_inode: free_pipe_info(inode->i_pipe); iput(inode); return err; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro12744.88%626.09%
pre-gitpre-git4616.25%834.78%
andi kleenandi kleen4415.55%14.35%
eric biggerseric biggers217.42%14.35%
dave hansendave hansen165.65%14.35%
eric dumazeteric dumazet103.53%28.70%
ulrich drepperulrich drepper82.83%14.35%
anatol pomozovanatol pomozov62.12%14.35%
linus torvaldslinus torvalds41.41%14.35%
nick pigginnick piggin10.35%14.35%
Total283100.00%23100.00%


static int __do_pipe_flags(int *fd, struct file **files, int flags) { int error; int fdw, fdr; if (flags & ~(O_CLOEXEC | O_NONBLOCK | O_DIRECT)) return -EINVAL; error = create_pipe_files(files, flags); if (error) return error; error = get_unused_fd_flags(flags); if (error < 0) goto err_read_pipe; fdr = error; error = get_unused_fd_flags(flags); if (error < 0) goto err_fdr; fdw = error; audit_fd_pair(fdr, fdw); fd[0] = fdr; fd[1] = fdw; return 0; err_fdr: put_unused_fd(fdr); err_read_pipe: fput(files[0]); fput(files[1]); return error; }

Contributors

PersonTokensPropCommitsCommitProp
andi kleenandi kleen5536.18%17.69%
pre-gitpre-git3623.68%646.15%
al viroal viro3221.05%323.08%
ulrich drepperulrich drepper2717.76%215.38%
linus torvaldslinus torvalds21.32%17.69%
Total152100.00%13100.00%


int do_pipe_flags(int *fd, int flags) { struct file *files[2]; int error = __do_pipe_flags(fd, files, flags); if (!error) { fd_install(fd[0], files[0]); fd_install(fd[1], files[1]); } return error; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro68100.00%1100.00%
Total68100.00%1100.00%

/* * sys_pipe() is the normal C calling standard for creating * a pipe. It's not the way Unix traditionally does this, though. */ SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags) { struct file *files[2]; int fd[2]; int error; error = __do_pipe_flags(fd, files, flags); if (!error) { if (unlikely(copy_to_user(fildes, fd, sizeof(fd)))) { fput(files[0]); fput(files[1]); put_unused_fd(fd[0]); put_unused_fd(fd[1]); error = -EFAULT; } else { fd_install(fd[0], files[0]); fd_install(fd[1], files[1]); } } return error; } SYSCALL_DEFINE1(pipe, int __user *, fildes) { return sys_pipe2(fildes, 0); }
static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt) { int cur = *cnt; while (cur == *cnt) { pipe_wait(pipe); if (signal_pending(current)) break; } return cur == *cnt ? -ERESTARTSYS : 0; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro55100.00%2100.00%
Total55100.00%2100.00%


static void wake_up_partner(struct pipe_inode_info *pipe) { wake_up_interruptible(&pipe->wait); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro19100.00%2100.00%
Total19100.00%2100.00%


static int fifo_open(struct inode *inode, struct file *filp) { struct pipe_inode_info *pipe; bool is_pipe = inode->i_sb->s_magic == PIPEFS_MAGIC; int ret; filp->f_version = 0; spin_lock(&inode->i_lock); if (inode->i_pipe) { pipe = inode->i_pipe; pipe->files++; spin_unlock(&inode->i_lock); } else { spin_unlock(&inode->i_lock); pipe = alloc_pipe_info(); if (!pipe) return -ENOMEM; pipe->files = 1; spin_lock(&inode->i_lock); if (unlikely(inode->i_pipe)) { inode->i_pipe->files++; spin_unlock(&inode->i_lock); free_pipe_info(pipe); pipe = inode->i_pipe; } else { inode->i_pipe = pipe; spin_unlock(&inode->i_lock); } } filp->private_data = pipe; /* OK, we have a pipe and it's pinned down */ __pipe_lock(pipe); /* We can only do regular read/write on fifos */ filp->f_mode &= (FMODE_READ | FMODE_WRITE); switch (filp->f_mode) { case FMODE_READ: /* * O_RDONLY * POSIX.1 says that O_NONBLOCK means return with the FIFO * opened, even when there is no process writing the FIFO. */ pipe->r_counter++; if (pipe->readers++ == 0) wake_up_partner(pipe); if (!is_pipe && !pipe->writers) { if ((filp->f_flags & O_NONBLOCK)) { /* suppress POLLHUP until we have * seen a writer */ filp->f_version = pipe->w_counter; } else { if (wait_for_partner(pipe, &pipe->w_counter)) goto err_rd; } } break; case FMODE_WRITE: /* * O_WRONLY * POSIX.1 says that O_NONBLOCK means return -1 with * errno=ENXIO when there is no process reading the FIFO. */ ret = -ENXIO; if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers) goto err; pipe->w_counter++; if (!pipe->writers++) wake_up_partner(pipe); if (!is_pipe && !pipe->readers) { if (wait_for_partner(pipe, &pipe->r_counter)) goto err_wr; } break; case FMODE_READ | FMODE_WRITE: /* * O_RDWR * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set. * This implementation will NEVER block on a O_RDWR open, since * the process can at least talk to itself. */ pipe->readers++; pipe->writers++; pipe->r_counter++; pipe->w_counter++; if (pipe->readers == 1 || pipe->writers == 1) wake_up_partner(pipe); break; default: ret = -EINVAL; goto err; } /* Ok! */ __pipe_unlock(pipe); return 0; err_rd: if (!--pipe->readers) wake_up_interruptible(&pipe->wait); ret = -ERESTARTSYS; goto err; err_wr: if (!--pipe->writers) wake_up_interruptible(&pipe->wait); ret = -ERESTARTSYS; goto err; err: __pipe_unlock(pipe); put_pipe_info(inode, pipe); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro48199.38%888.89%
linus torvaldslinus torvalds30.62%111.11%
Total484100.00%9100.00%

const struct file_operations pipefifo_fops = { .open = fifo_open, .llseek = no_llseek, .read_iter = pipe_read, .write_iter = pipe_write, .poll = pipe_poll, .unlocked_ioctl = pipe_ioctl, .release = pipe_release, .fasync = pipe_fasync, }; /* * Allocate a new array of pipe buffers and copy the info over. Returns the * pipe size if successful, or return -ERROR on error. */
static long pipe_set_size(struct pipe_inode_info *pipe, unsigned long nr_pages) { struct pipe_buffer *bufs; /* * We can shrink the pipe, if arg >= pipe->nrbufs. Since we don't * expect a lot of shrink+grow operations, just free and allocate * again like we would do for growing. If the pipe currently * contains more buffers than arg, then return busy. */ if (nr_pages < pipe->nrbufs) return -EBUSY; bufs = kcalloc(nr_pages, sizeof(*bufs), GFP_KERNEL | __GFP_NOWARN); if (unlikely(!bufs)) return -ENOMEM; /* * The pipe array wraps around, so just start the new one at zero * and adjust the indexes. */ if (pipe->nrbufs) { unsigned int tail; unsigned int head; tail = pipe->curbuf + pipe->nrbufs; if (tail < pipe->buffers) tail = 0; else tail &= (pipe->buffers - 1); head = pipe->nrbufs - tail; if (head) memcpy(bufs, pipe->bufs + pipe->curbuf, head * sizeof(struct pipe_buffer)); if (tail) memcpy(bufs + head, pipe->bufs, tail * sizeof(struct pipe_buffer)); } account_pipe_buffers(pipe, pipe->buffers, nr_pages); pipe->curbuf = 0; kfree(pipe->bufs); pipe->bufs = bufs; pipe->buffers = nr_pages; return nr_pages * PAGE_SIZE; }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe16478.47%240.00%
miklos szeredimiklos szeredi3014.35%120.00%
willy tarreauwilly tarreau115.26%120.00%
sasha levinsasha levin41.91%120.00%
Total209100.00%5100.00%

/* * Currently we rely on the pipe array holding a power-of-2 number * of pages. */
static inline unsigned int round_pipe_size(unsigned int size) { unsigned long nr_pages; nr_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; return roundup_pow_of_two(nr_pages) << PAGE_SHIFT; }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe36100.00%1100.00%
Total36100.00%1100.00%

/* * This should work even if CONFIG_PROC_FS isn't set, as proc_dointvec_minmax * will return an error. */
int pipe_proc_fn(struct ctl_table *table, int write, void __user *buf, size_t *lenp, loff_t *ppos) { int ret; ret = proc_dointvec_minmax(table, write, buf, lenp, ppos); if (ret < 0 || !write) return ret; pipe_max_size = round_pipe_size(pipe_max_size); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe66100.00%1100.00%
Total66100.00%1100.00%

/* * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same * location, so checking ->i_pipe is not enough to verify that this is a * pipe. */
struct pipe_inode_info *get_pipe_info(struct file *file) { return file->f_op == &pipefifo_fops ? file->private_data : NULL; }

Contributors

PersonTokensPropCommitsCommitProp
linus torvaldslinus torvalds1973.08%150.00%
al viroal viro726.92%150.00%
Total26100.00%2100.00%


long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg) { struct pipe_inode_info *pipe; long ret; pipe = get_pipe_info(file); if (!pipe) return -EBADF; __pipe_lock(pipe); switch (cmd) { case F_SETPIPE_SZ: { unsigned int size, nr_pages; size = round_pipe_size(arg); nr_pages = size >> PAGE_SHIFT; ret = -EINVAL; if (!nr_pages) goto out; if (!capable(CAP_SYS_RESOURCE) && size > pipe_max_size) { ret = -EPERM; goto out; } else if ((too_many_pipe_buffers_hard(pipe->user) || too_many_pipe_buffers_soft(pipe->user)) && !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN)) { ret = -EPERM; goto out; } ret = pipe_set_size(pipe, nr_pages); break; } case F_GETPIPE_SZ: ret = pipe->buffers * PAGE_SIZE; break; default: ret = -EINVAL; break; } out: __pipe_unlock(pipe); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
jens axboejens axboe12364.06%654.55%
willy tarreauwilly tarreau4121.35%19.09%
miklos szeredimiklos szeredi136.77%19.09%
julia lawalljulia lawall105.21%19.09%
linus torvaldslinus torvalds31.56%19.09%
al viroal viro21.04%19.09%
Total192100.00%11100.00%

static const struct super_operations pipefs_ops = { .destroy_inode = free_inode_nonrcu, .statfs = simple_statfs, }; /* * 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 struct dentry *pipefs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, void *data) { return mount_pseudo(fs_type, "pipe:", &pipefs_ops, &pipefs_dentry_operations, PIPEFS_MAGIC); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro3278.05%450.00%
pre-gitpre-git512.20%112.50%
nick pigginnick piggin24.88%112.50%
david howellsdavid howells12.44%112.50%
andries brouwerandries brouwer12.44%112.50%
Total41100.00%8100.00%

static struct file_system_type pipe_fs_type = { .name = "pipefs", .mount = pipefs_mount, .kill_sb = kill_anon_super, };
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)) { err = PTR_ERR(pipe_mnt); unregister_filesystem(&pipe_fs_type); } } return err; }

Contributors

PersonTokensPropCommitsCommitProp
pre-gitpre-git4984.48%266.67%
rusty russellrusty russell915.52%133.33%
Total58100.00%3100.00%

fs_initcall(init_pipe_fs);

Overall Contributors

PersonTokensPropCommitsCommitProp
al viroal viro120224.80%2716.36%
linus torvaldslinus torvalds78716.24%159.09%
jens axboejens axboe63513.10%169.70%
pre-gitpre-git60812.54%4225.45%
ingo molnaringo molnar2294.72%53.03%
miklos szeredimiklos szeredi2244.62%53.03%
willy tarreauwilly tarreau2214.56%10.61%
manfred spraulmanfred spraul2204.54%10.61%
dave jonesdave jones1162.39%21.21%
ulrich drepperulrich drepper1132.33%42.42%
andi kleenandi kleen1012.08%21.21%
eric dumazeteric dumazet541.11%53.03%
andrew mortonandrew morton340.70%31.82%
eric biggerseric biggers260.54%21.21%
badari pulavartybadari pulavarty240.50%10.61%
oleg nesterovoleg nesterov240.50%10.61%
andrea arcangeliandrea arcangeli230.47%10.61%
prasanna medaprasanna meda230.47%10.61%
heiko carstensheiko carstens200.41%21.21%
dmitriy monakhovdmitriy monakhov200.41%10.61%
davide libenzidavide libenzi170.35%10.61%
nick pigginnick piggin160.33%21.21%
dave hansendave hansen160.33%10.61%
christoph hellwigchristoph hellwig150.31%42.42%
josef bacikjosef bacik130.27%10.61%
julia lawalljulia lawall100.21%10.61%
rusty russellrusty russell90.19%10.61%
david howellsdavid howells80.17%31.82%
art haasart haas70.14%10.61%
anatol pomozovanatol pomozov60.12%10.61%
pavel emelianovpavel emelianov50.10%10.61%
sasha levinsasha levin40.08%10.61%
muthu kumarmuthu kumar30.06%10.61%
randy dunlaprandy dunlap30.06%21.21%
kirill a. shutemovkirill a. shutemov30.06%10.61%
nicolas kaisernicolas kaiser20.04%10.61%
peter zijlstrapeter zijlstra20.04%10.61%
kent overstreetkent overstreet10.02%10.61%
pekka j enbergpekka j enberg10.02%10.61%
will deaconwill deacon10.02%10.61%
andries brouwerandries brouwer10.02%10.61%
Total4847100.00%165100.00%
Directory: fs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}