Commit 9aeedfc4 authored by Ingo Molnar's avatar Ingo Molnar Committed by Jens Axboe
Browse files

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



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

Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
Signed-off-by: default avatarJens Axboe <axboe@suse.de>
parent 7480a904

fs/fifo.c

+24 −24
Original line number Diff line number Diff line
@@ -28,14 +28,14 @@ static void wait_for_partner(struct inode* inode, unsigned int *cnt) 


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)

{

	int ret;



	mutex_lock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	if (!inode->i_pipe) {

		ret = -ENOMEM;

		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.

	 */

		filp->f_op = &read_fifo_fops;

		PIPE_RCOUNTER(*inode)++;

		if (PIPE_READERS(*inode)++ == 0)

		inode->i_pipe->r_counter++;

		if (inode->i_pipe->readers++ == 0)

			wake_up_partner(inode);



		if (!PIPE_WRITERS(*inode)) {

		if (!inode->i_pipe->writers) {

			if ((filp->f_flags & O_NONBLOCK)) {

				/* suppress POLLHUP until we have

				 * seen a writer */

				filp->f_version = PIPE_WCOUNTER(*inode);

				filp->f_version = inode->i_pipe->w_counter;

			} else 

			{

				wait_for_partner(inode, &PIPE_WCOUNTER(*inode));

				wait_for_partner(inode, &inode->i_pipe->w_counter);

				if(signal_pending(current))

					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.

	 */

		ret = -ENXIO;

		if ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode))

		if ((filp->f_flags & O_NONBLOCK) && !inode->i_pipe->readers)

			goto err;



		filp->f_op = &write_fifo_fops;

		PIPE_WCOUNTER(*inode)++;

		if (!PIPE_WRITERS(*inode)++)

		inode->i_pipe->w_counter++;

		if (!inode->i_pipe->writers++)

			wake_up_partner(inode);



		if (!PIPE_READERS(*inode)) {

			wait_for_partner(inode, &PIPE_RCOUNTER(*inode));

		if (!inode->i_pipe->readers) {

			wait_for_partner(inode, &inode->i_pipe->r_counter);

			if (signal_pending(current))

				goto err_wr;

		}
@@ -104,11 +104,11 @@ static int fifo_open(struct inode *inode, struct file *filp) 
	 */

		filp->f_op = &rdwr_fifo_fops;



		PIPE_READERS(*inode)++;

		PIPE_WRITERS(*inode)++;

		PIPE_RCOUNTER(*inode)++;

		PIPE_WCOUNTER(*inode)++;

		if (PIPE_READERS(*inode) == 1 || PIPE_WRITERS(*inode) == 1)

		inode->i_pipe->readers++;

		inode->i_pipe->writers++;

		inode->i_pipe->r_counter++;

		inode->i_pipe->w_counter++;

		if (inode->i_pipe->readers == 1 || inode->i_pipe->writers == 1)

			wake_up_partner(inode);

		break;
@@ -118,27 +118,27 @@ static int fifo_open(struct inode *inode, struct file *filp) 
	}



	/* Ok! */

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_unlock(&inode->i_mutex);

	return 0;



err_rd:

	if (!--PIPE_READERS(*inode))

		wake_up_interruptible(PIPE_WAIT(*inode));

	if (!--inode->i_pipe->readers)

		wake_up_interruptible(&inode->i_pipe->wait);

	ret = -ERESTARTSYS;

	goto err;



err_wr:

	if (!--PIPE_WRITERS(*inode))

		wake_up_interruptible(PIPE_WAIT(*inode));

	if (!--inode->i_pipe->writers)

		wake_up_interruptible(&inode->i_pipe->wait);

	ret = -ERESTARTSYS;

	goto err;



err:

	if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode))

	if (!inode->i_pipe->readers && !inode->i_pipe->writers)

		free_pipe_info(inode);



err_nocleanup:

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_unlock(&inode->i_mutex);

	return ret;

}

fs/pipe.c

+52 −52
Original line number Diff line number Diff line
@@ -158,7 +158,7 @@ pipe_readv(struct file *filp, const struct iovec *_iov, 


	do_wakeup = 0;

	ret = 0;

	mutex_lock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	info = inode->i_pipe;

	for (;;) {

		int bufs = info->nrbufs;
@@ -202,9 +202,9 @@ pipe_readv(struct file *filp, const struct iovec *_iov, 
		}

		if (bufs)	/* More to do? */

			continue;

		if (!PIPE_WRITERS(*inode))

		if (!inode->i_pipe->writers)

			break;

		if (!PIPE_WAITING_WRITERS(*inode)) {

		if (!inode->i_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
@@ -222,16 +222,16 @@ pipe_readv(struct file *filp, const struct iovec *_iov, 
			break;

		}

		if (do_wakeup) {

			wake_up_interruptible_sync(PIPE_WAIT(*inode));

 			kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);

			wake_up_interruptible_sync(&inode->i_pipe->wait);

 			kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);

		}

		pipe_wait(inode->i_pipe);

	}

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_unlock(&inode->i_mutex);

	/* Signal writers asynchronously that there is more room.  */

	if (do_wakeup) {

		wake_up_interruptible(PIPE_WAIT(*inode));

		kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);

		wake_up_interruptible(&inode->i_pipe->wait);

		kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);

	}

	if (ret > 0)

		file_accessed(filp);
@@ -264,10 +264,10 @@ pipe_writev(struct file *filp, const struct iovec *_iov, 


	do_wakeup = 0;

	ret = 0;

	mutex_lock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	info = inode->i_pipe;



	if (!PIPE_READERS(*inode)) {

	if (!inode->i_pipe->readers) {

		send_sig(SIGPIPE, current, 0);

		ret = -EPIPE;

		goto out;
@@ -306,7 +306,7 @@ pipe_writev(struct file *filp, const struct iovec *_iov, 


	for (;;) {

		int bufs;

		if (!PIPE_READERS(*inode)) {

		if (!inode->i_pipe->readers) {

			send_sig(SIGPIPE, current, 0);

			if (!ret) ret = -EPIPE;

			break;
@@ -367,19 +367,19 @@ pipe_writev(struct file *filp, const struct iovec *_iov, 
			break;

		}

		if (do_wakeup) {

			wake_up_interruptible_sync(PIPE_WAIT(*inode));

			kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);

			wake_up_interruptible_sync(&inode->i_pipe->wait);

			kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);

			do_wakeup = 0;

		}

		PIPE_WAITING_WRITERS(*inode)++;

		inode->i_pipe->waiting_writers++;

		pipe_wait(inode->i_pipe);

		PIPE_WAITING_WRITERS(*inode)--;

		inode->i_pipe->waiting_writers--;

	}

out:

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_unlock(&inode->i_mutex);

	if (do_wakeup) {

		wake_up_interruptible(PIPE_WAIT(*inode));

		kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);

		wake_up_interruptible(&inode->i_pipe->wait);

		kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);

	}

	if (ret > 0)

		file_update_time(filp);
@@ -416,7 +416,7 @@ pipe_ioctl(struct inode *pino, struct file *filp, 


	switch (cmd) {

		case FIONREAD:

			mutex_lock(PIPE_MUTEX(*inode));

			mutex_lock(&inode->i_mutex);

			info =  inode->i_pipe;

			count = 0;

			buf = info->curbuf;
@@ -425,7 +425,7 @@ pipe_ioctl(struct inode *pino, struct file *filp, 
				count += info->bufs[buf].len;

				buf = (buf+1) & (PIPE_BUFFERS-1);

			}

			mutex_unlock(PIPE_MUTEX(*inode));

			mutex_unlock(&inode->i_mutex);

			return put_user(count, (int __user *)arg);

		default:

			return -EINVAL;
@@ -441,14 +441,14 @@ pipe_poll(struct file *filp, poll_table *wait) 
	struct pipe_inode_info *info = inode->i_pipe;

	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.  */

	nrbufs = info->nrbufs;

	mask = 0;

	if (filp->f_mode & FMODE_READ) {

		mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;

		if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))

		if (!inode->i_pipe->writers && filp->f_version != inode->i_pipe->w_counter)

			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

		 * behave exactly like pipes for poll().

		 */

		if (!PIPE_READERS(*inode))

		if (!inode->i_pipe->readers)

			mask |= POLLERR;

	}
@@ -468,17 +468,17 @@ pipe_poll(struct file *filp, poll_table *wait) 
static int

pipe_release(struct inode *inode, int decr, int decw)

{

	mutex_lock(PIPE_MUTEX(*inode));

	PIPE_READERS(*inode) -= decr;

	PIPE_WRITERS(*inode) -= decw;

	if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {

	mutex_lock(&inode->i_mutex);

	inode->i_pipe->readers -= decr;

	inode->i_pipe->writers -= decw;

	if (!inode->i_pipe->readers && !inode->i_pipe->writers) {

		free_pipe_info(inode);

	} else {

		wake_up_interruptible(PIPE_WAIT(*inode));

		kill_fasync(PIPE_FASYNC_READERS(*inode), SIGIO, POLL_IN);

		kill_fasync(PIPE_FASYNC_WRITERS(*inode), SIGIO, POLL_OUT);

		wake_up_interruptible(&inode->i_pipe->wait);

		kill_fasync(&inode->i_pipe->fasync_readers, SIGIO, POLL_IN);

		kill_fasync(&inode->i_pipe->fasync_writers, SIGIO, POLL_OUT);

	}

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_unlock(&inode->i_mutex);



	return 0;

}
@@ -489,9 +489,9 @@ pipe_read_fasync(int fd, struct file *filp, int on) 
	struct inode *inode = filp->f_dentry->d_inode;

	int retval;



	mutex_lock(PIPE_MUTEX(*inode));

	retval = fasync_helper(fd, filp, on, PIPE_FASYNC_READERS(*inode));

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_readers);

	mutex_unlock(&inode->i_mutex);



	if (retval < 0)

		return retval;
@@ -506,9 +506,9 @@ pipe_write_fasync(int fd, struct file *filp, int on) 
	struct inode *inode = filp->f_dentry->d_inode;

	int retval;



	mutex_lock(PIPE_MUTEX(*inode));

	retval = fasync_helper(fd, filp, on, PIPE_FASYNC_WRITERS(*inode));

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	retval = fasync_helper(fd, filp, on, &inode->i_pipe->fasync_writers);

	mutex_unlock(&inode->i_mutex);



	if (retval < 0)

		return retval;
@@ -523,14 +523,14 @@ pipe_rdwr_fasync(int fd, struct file *filp, int on) 
	struct inode *inode = filp->f_dentry->d_inode;

	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)

		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)

		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

	   below are the only places.  So it doesn't seem worthwhile.  */

	mutex_lock(PIPE_MUTEX(*inode));

	PIPE_READERS(*inode)++;

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	inode->i_pipe->readers++;

	mutex_unlock(&inode->i_mutex);



	return 0;

}
@@ -579,9 +579,9 @@ pipe_read_open(struct inode *inode, struct file *filp) 
static int

pipe_write_open(struct inode *inode, struct file *filp)

{

	mutex_lock(PIPE_MUTEX(*inode));

	PIPE_WRITERS(*inode)++;

	mutex_unlock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	inode->i_pipe->writers++;

	mutex_unlock(&inode->i_mutex);



	return 0;

}
@@ -589,12 +589,12 @@ pipe_write_open(struct inode *inode, struct file *filp) 
static int

pipe_rdwr_open(struct inode *inode, struct file *filp)

{

	mutex_lock(PIPE_MUTEX(*inode));

	mutex_lock(&inode->i_mutex);

	if (filp->f_mode & FMODE_READ)

		PIPE_READERS(*inode)++;

		inode->i_pipe->readers++;

	if (filp->f_mode & FMODE_WRITE)

		PIPE_WRITERS(*inode)++;

	mutex_unlock(PIPE_MUTEX(*inode));

		inode->i_pipe->writers++;

	mutex_unlock(&inode->i_mutex);



	return 0;

}
@@ -731,7 +731,7 @@ static struct inode * get_pipe_inode(void) 
	if (!inode->i_pipe)

		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;



	/*

include/linux/pipe_fs_i.h

+0 −10
Original line number Diff line number Diff line
@@ -43,16 +43,6 @@ struct pipe_inode_info { 
   memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */

#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 */

void pipe_wait(struct pipe_inode_info *pipe);