GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-07-06 14:31:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[PATCH] get rid of the PIPE_*() macros

Browse source 
get rid of the PIPE_*() macros. Scripted transformation.

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Jens Axboe <axboe@suse.de>
This commit is contained in:
Ingo Molnar 2006-04-11 13:53:10 +02:00 • committed by Jens Axboe
parent 7480a90435
commit 9aeedfc471
3 changed files with 76 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

48
fs/fifo.c
View file

@ -28,14 +28,14 @@ static void wait_for_partner(struct inode* inode, unsigned int *cnt)
static void wake_up_partner(struct inode* inode) static void wake_up_partner(struct inode* inode)
{ {
wake_up_interruptible(PIPE_WAIT(*inode)); wake_up_interruptible(&inode->i_pipe->wait);
} }
static int fifo_open(struct inode *inode, struct file *filp) static int fifo_open(struct inode *inode, struct file *filp)
{ {
int ret; int ret;
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
if (!inode->i_pipe) { if (!inode->i_pipe) {
ret = -ENOMEM; ret = -ENOMEM;
inode->i_pipe = alloc_pipe_info(inode); inode->i_pipe = alloc_pipe_info(inode);
@ -55,18 +55,18 @@ static int fifo_open(struct inode *inode, struct file *filp)
* opened, even when there is no process writing the FIFO. * opened, even when there is no process writing the FIFO.
*/ */
filp->f_op = &read_fifo_fops; filp->f_op = &read_fifo_fops;
PIPE_RCOUNTER(*inode)++; inode->i_pipe->r_counter++;
if (PIPE_READERS(*inode)++ == 0) if (inode->i_pipe->readers++ == 0)
wake_up_partner(inode); wake_up_partner(inode);
if (!PIPE_WRITERS(*inode)) { if (!inode->i_pipe->writers) {
if ((filp->f_flags & O_NONBLOCK)) { if ((filp->f_flags & O_NONBLOCK)) {
/* suppress POLLHUP until we have /* suppress POLLHUP until we have
* seen a writer */ * seen a writer */
filp->f_version = PIPE_WCOUNTER(*inode); filp->f_version = inode->i_pipe->w_counter;
} else } else
{ {
wait_for_partner(inode, &PIPE_WCOUNTER(*inode)); wait_for_partner(inode, &inode->i_pipe->w_counter);
if(signal_pending(current)) if(signal_pending(current))
goto err_rd; goto err_rd;
} }
@ -80,16 +80,16 @@ static int fifo_open(struct inode *inode, struct file *filp)
* errno=ENXIO when there is no process reading the FIFO. * errno=ENXIO when there is no process reading the FIFO.
*/ */
ret = -ENXIO; ret = -ENXIO;
if ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode)) if ((filp->f_flags & O_NONBLOCK) && !inode->i_pipe->readers)
goto err; goto err;
filp->f_op = &write_fifo_fops; filp->f_op = &write_fifo_fops;
PIPE_WCOUNTER(*inode)++; inode->i_pipe->w_counter++;
if (!PIPE_WRITERS(*inode)++) if (!inode->i_pipe->writers++)
wake_up_partner(inode); wake_up_partner(inode);
if (!PIPE_READERS(*inode)) { if (!inode->i_pipe->readers) {
wait_for_partner(inode, &PIPE_RCOUNTER(*inode)); wait_for_partner(inode, &inode->i_pipe->r_counter);
if (signal_pending(current)) if (signal_pending(current))
goto err_wr; goto err_wr;
} }
@ -104,11 +104,11 @@ static int fifo_open(struct inode *inode, struct file *filp)
*/ */
filp->f_op = &rdwr_fifo_fops; filp->f_op = &rdwr_fifo_fops;
PIPE_READERS(*inode)++; inode->i_pipe->readers++;
PIPE_WRITERS(*inode)++; inode->i_pipe->writers++;
PIPE_RCOUNTER(*inode)++; inode->i_pipe->r_counter++;
PIPE_WCOUNTER(*inode)++; inode->i_pipe->w_counter++;
if (PIPE_READERS(*inode) == 1 || PIPE_WRITERS(*inode) == 1) if (inode->i_pipe->readers == 1 || inode->i_pipe->writers == 1)
wake_up_partner(inode); wake_up_partner(inode);
break; break;
@ -118,27 +118,27 @@ static int fifo_open(struct inode *inode, struct file *filp)
} }
/* Ok! */ /* Ok! */
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return 0; return 0;
err_rd: err_rd:
if (!--PIPE_READERS(*inode)) if (!--inode->i_pipe->readers)
wake_up_interruptible(PIPE_WAIT(*inode)); wake_up_interruptible(&inode->i_pipe->wait);
ret = -ERESTARTSYS; ret = -ERESTARTSYS;
goto err; goto err;
err_wr: err_wr:
if (!--PIPE_WRITERS(*inode)) if (!--inode->i_pipe->writers)
wake_up_interruptible(PIPE_WAIT(*inode)); wake_up_interruptible(&inode->i_pipe->wait);
ret = -ERESTARTSYS; ret = -ERESTARTSYS;
goto err; goto err;
err: err:
if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) if (!inode->i_pipe->readers && !inode->i_pipe->writers)
free_pipe_info(inode); free_pipe_info(inode);
err_nocleanup: err_nocleanup:
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return ret; return ret;
} }

104
fs/pipe.c
View file

@ -158,7 +158,7 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
do_wakeup = 0; do_wakeup = 0;
ret = 0; ret = 0;
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
info = inode->i_pipe; info = inode->i_pipe;
for (;;) { for (;;) {
int bufs = info->nrbufs; int bufs = info->nrbufs;
@ -202,9 +202,9 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
} }
if (bufs) /* More to do? */ if (bufs) /* More to do? */
continue; continue;
if (!PIPE_WRITERS(*inode)) if (!inode->i_pipe->writers)
break; break;
if (!PIPE_WAITING_WRITERS(*inode)) { if (!inode->i_pipe->waiting_writers) {
/* syscall merging: Usually we must not sleep /* syscall merging: Usually we must not sleep
* if O_NONBLOCK is set, or if we got some data. * if O_NONBLOCK is set, or if we got some data.
* But if a writer sleeps in kernel space, then * But if a writer sleeps in kernel space, then
@ -222,16 +222,16 @@ pipe_readv(struct file *filp, const struct iovec *_iov,
break; break;
} }
if (do_wakeup) { if (do_wakeup) {
wake_up_interruptible_sync(PIPE_WAIT(*inode)); wake_up_interruptible_sync(&inode->i_pipe->wait);
kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT); kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);
} }
pipe_wait(inode->i_pipe); pipe_wait(inode->i_pipe);
} }
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
/* Signal writers asynchronously that there is more room. */ /* Signal writers asynchronously that there is more room. */
if (do_wakeup) { if (do_wakeup) {
wake_up_interruptible(PIPE_WAIT(*inode)); wake_up_interruptible(&inode->i_pipe->wait);
kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT); kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);
} }
if (ret > 0) if (ret > 0)
file_accessed(filp); file_accessed(filp);
@ -264,10 +264,10 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
do_wakeup = 0; do_wakeup = 0;
ret = 0; ret = 0;
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
info = inode->i_pipe; info = inode->i_pipe;
if (!PIPE_READERS(*inode)) { if (!inode->i_pipe->readers) {
send_sig(SIGPIPE, current, 0); send_sig(SIGPIPE, current, 0);
ret = -EPIPE; ret = -EPIPE;
goto out; goto out;
@ -306,7 +306,7 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
for (;;) { for (;;) {
int bufs; int bufs;
if (!PIPE_READERS(*inode)) { if (!inode->i_pipe->readers) {
send_sig(SIGPIPE, current, 0); send_sig(SIGPIPE, current, 0);
if (!ret) ret = -EPIPE; if (!ret) ret = -EPIPE;
break; break;
@ -367,19 +367,19 @@ pipe_writev(struct file *filp, const struct iovec *_iov,
break; break;
} }
if (do_wakeup) { if (do_wakeup) {
wake_up_interruptible_sync(PIPE_WAIT(*inode)); wake_up_interruptible_sync(&inode->i_pipe->wait);
kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN); kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);
do_wakeup = 0; do_wakeup = 0;
} }
PIPE_WAITING_WRITERS(*inode)++; inode->i_pipe->waiting_writers++;
pipe_wait(inode->i_pipe); pipe_wait(inode->i_pipe);
PIPE_WAITING_WRITERS(*inode)--; inode->i_pipe->waiting_writers--;
} }
out: out:
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
if (do_wakeup) { if (do_wakeup) {
wake_up_interruptible(PIPE_WAIT(*inode)); wake_up_interruptible(&inode->i_pipe->wait);
kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN); kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);
} }
if (ret > 0) if (ret > 0)
file_update_time(filp); file_update_time(filp);
@ -416,7 +416,7 @@ pipe_ioctl(struct inode *pino, struct file *filp,
switch (cmd) { switch (cmd) {
case FIONREAD: case FIONREAD:
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
info = inode->i_pipe; info = inode->i_pipe;
count = 0; count = 0;
buf = info->curbuf; buf = info->curbuf;
@ -425,7 +425,7 @@ pipe_ioctl(struct inode *pino, struct file *filp,
count += info->bufs[buf].len; count += info->bufs[buf].len;
buf = (buf+1) & (PIPE_BUFFERS-1); buf = (buf+1) & (PIPE_BUFFERS-1);
} }
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return put_user(count, (int __user *)arg); return put_user(count, (int __user *)arg);
default: default:
return -EINVAL; return -EINVAL;
@ -441,14 +441,14 @@ pipe_poll(struct file *filp, poll_table *wait)
struct pipe_inode_info *info = inode->i_pipe; struct pipe_inode_info *info = inode->i_pipe;
int nrbufs; int nrbufs;
poll_wait(filp, PIPE_WAIT(*inode), wait); poll_wait(filp, &inode->i_pipe->wait, wait);
/* Reading only -- no need for acquiring the semaphore. */ /* Reading only -- no need for acquiring the semaphore. */
nrbufs = info->nrbufs; nrbufs = info->nrbufs;
mask = 0; mask = 0;
if (filp->f_mode & FMODE_READ) { if (filp->f_mode & FMODE_READ) {
mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0; mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode)) if (!inode->i_pipe->writers && filp->f_version != inode->i_pipe->w_counter)
mask |= POLLHUP; mask |= POLLHUP;
} }
@ -458,7 +458,7 @@ pipe_poll(struct file *filp, poll_table *wait)
* Most Unices do not set POLLERR for FIFOs but on Linux they * Most Unices do not set POLLERR for FIFOs but on Linux they
* behave exactly like pipes for poll(). * behave exactly like pipes for poll().
*/ */
if (!PIPE_READERS(*inode)) if (!inode->i_pipe->readers)
mask |= POLLERR; mask |= POLLERR;
} }
@ -468,17 +468,17 @@ pipe_poll(struct file *filp, poll_table *wait)
static int static int
pipe_release(struct inode *inode, int decr, int decw) pipe_release(struct inode *inode, int decr, int decw)
{ {
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
PIPE_READERS(*inode) -= decr; inode->i_pipe->readers -= decr;
PIPE_WRITERS(*inode) -= decw; inode->i_pipe->writers -= decw;
if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) { if (!inode->i_pipe->readers && !inode->i_pipe->writers) {
free_pipe_info(inode); free_pipe_info(inode);
} else { } else {
wake_up_interruptible(PIPE_WAIT(*inode)); wake_up_interruptible(&inode->i_pipe->wait);
kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN); kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);
kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT); kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);
} }
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return 0; return 0;
} }
@ -489,9 +489,9 @@ pipe_read_fasync(int fd, struct file *filp, int on)
struct inode *inode = filp->f_dentry->d_inode; struct inode *inode = filp->f_dentry->d_inode;
int retval; int retval;
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode)); retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
if (retval < 0) if (retval < 0)
return retval; return retval;
@ -506,9 +506,9 @@ pipe_write_fasync(int fd, struct file *filp, int on)
struct inode *inode = filp->f_dentry->d_inode; struct inode *inode = filp->f_dentry->d_inode;
int retval; int retval;
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode)); retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
if (retval < 0) if (retval < 0)
return retval; return retval;
@ -523,14 +523,14 @@ pipe_rdwr_fasync(int fd, struct file *filp, int on)
struct inode *inode = filp->f_dentry->d_inode; struct inode *inode = filp->f_dentry->d_inode;
int retval; int retval;
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode)); retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);
if (retval >= 0) if (retval >= 0)
retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode)); retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
if (retval < 0) if (retval < 0)
return retval; return retval;
@ -569,9 +569,9 @@ pipe_read_open(struct inode *inode, struct file *filp)
{ {
/* We could have perhaps used atomic_t, but this and friends /* We could have perhaps used atomic_t, but this and friends
below are the only places. So it doesn't seem worthwhile. */ below are the only places. So it doesn't seem worthwhile. */
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
PIPE_READERS(*inode)++; inode->i_pipe->readers++;
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return 0; return 0;
} }
@ -579,9 +579,9 @@ pipe_read_open(struct inode *inode, struct file *filp)
static int static int
pipe_write_open(struct inode *inode, struct file *filp) pipe_write_open(struct inode *inode, struct file *filp)
{ {
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
PIPE_WRITERS(*inode)++; inode->i_pipe->writers++;
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return 0; return 0;
} }
@ -589,12 +589,12 @@ pipe_write_open(struct inode *inode, struct file *filp)
static int static int
pipe_rdwr_open(struct inode *inode, struct file *filp) pipe_rdwr_open(struct inode *inode, struct file *filp)
{ {
mutex_lock(PIPE_MUTEX(*inode)); mutex_lock(&inode->i_mutex);
if (filp->f_mode & FMODE_READ) if (filp->f_mode & FMODE_READ)
PIPE_READERS(*inode)++; inode->i_pipe->readers++;
if (filp->f_mode & FMODE_WRITE) if (filp->f_mode & FMODE_WRITE)
PIPE_WRITERS(*inode)++; inode->i_pipe->writers++;
mutex_unlock(PIPE_MUTEX(*inode)); mutex_unlock(&inode->i_mutex);
return 0; return 0;
} }
@ -731,7 +731,7 @@ static struct inode * get_pipe_inode(void)
if (!inode->i_pipe) if (!inode->i_pipe)
goto fail_iput; goto fail_iput;
PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1; inode->i_pipe->readers = inode->i_pipe->writers = 1;
inode->i_fop = &rdwr_pipe_fops; inode->i_fop = &rdwr_pipe_fops;
/* /*

10
include/linux/pipe_fs_i.h
View file

@ -43,16 +43,6 @@ struct pipe_inode_info {
memory allocation, whereas PIPE_BUF makes atomicity guarantees. */ memory allocation, whereas PIPE_BUF makes atomicity guarantees. */
#define PIPE_SIZE PAGE_SIZE #define PIPE_SIZE PAGE_SIZE
#define PIPE_MUTEX(inode) (&(inode).i_mutex)
#define PIPE_WAIT(inode) (&(inode).i_pipe->wait)
#define PIPE_READERS(inode) ((inode).i_pipe->readers)
#define PIPE_WRITERS(inode) ((inode).i_pipe->writers)
#define PIPE_WAITING_WRITERS(inode) ((inode).i_pipe->waiting_writers)
#define PIPE_RCOUNTER(inode) ((inode).i_pipe->r_counter)
#define PIPE_WCOUNTER(inode) ((inode).i_pipe->w_counter)
#define PIPE_FASYNC_READERS(inode) (&((inode).i_pipe->fasync_readers))
#define PIPE_FASYNC_WRITERS(inode) (&((inode).i_pipe->fasync_writers))
/* Drop the inode semaphore and wait for a pipe event, atomically */ /* Drop the inode semaphore and wait for a pipe event, atomically */
void pipe_wait(struct pipe_inode_info *pipe); void pipe_wait(struct pipe_inode_info *pipe);