Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 599a0ac1 authored by Al Viro's avatar Al Viro
Browse files

pipe: fold file_operations instances in one 



Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent f776c738

fs/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -1803,7 +1803,7 @@ void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev) 
		inode->i_fop = &def_blk_fops;

		inode->i_rdev = rdev;

	} else if (S_ISFIFO(mode))

		inode->i_fop = &def_fifo_fops;

		inode->i_fop = &pipefifo_fops;

	else if (S_ISSOCK(mode))

		inode->i_fop = &bad_sock_fops;

	else

fs/internal.h

+5 −0
Original line number Diff line number Diff line
@@ -130,3 +130,8 @@ extern struct dentry *__d_alloc(struct super_block *, const struct qstr *); 
 * read_write.c

 */

extern ssize_t __kernel_write(struct file *, const char *, size_t, loff_t *);



/*

 * pipe.c

 */

extern const struct file_operations pipefifo_fops;

fs/pipe.c

+32 −189
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ 
#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
@@ -662,19 +664,6 @@ out: 
	return ret;

}



static ssize_t

bad_pipe_r(struct file *filp, char __user *buf, size_t count, loff_t *ppos)

{

	return -EBADF;

}



static ssize_t

bad_pipe_w(struct file *filp, const char __user *buf, size_t count,

	   loff_t *ppos)

{

	return -EBADF;

}



static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

	struct inode *inode = file_inode(filp);
@@ -734,14 +723,16 @@ pipe_poll(struct file *filp, poll_table *wait) 
}



static int

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

pipe_release(struct inode *inode, struct file *file)

{

	struct pipe_inode_info *pipe;



	mutex_lock(&inode->i_mutex);

	pipe = inode->i_pipe;

	pipe->readers -= decr;

	pipe->writers -= decw;

	if (file->f_mode & FMODE_READ)

		pipe->readers--;

	if (file->f_mode & FMODE_WRITE)

		pipe->writers--;



	if (!pipe->readers && !pipe->writers) {

		free_pipe_info(inode);
@@ -756,174 +747,25 @@ pipe_release(struct inode *inode, int decr, int decw) 
}



static int

pipe_read_fasync(int fd, struct file *filp, int on)

{

	struct inode *inode = file_inode(filp);

	int retval;



	mutex_lock(&inode->i_mutex);

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

	mutex_unlock(&inode->i_mutex);



	return retval;

}





static int

pipe_write_fasync(int fd, struct file *filp, int on)

{

	struct inode *inode = file_inode(filp);

	int retval;



	mutex_lock(&inode->i_mutex);

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

	mutex_unlock(&inode->i_mutex);



	return retval;

}





static int

pipe_rdwr_fasync(int fd, struct file *filp, int on)

pipe_fasync(int fd, struct file *filp, int on)

{

	struct inode *inode = file_inode(filp);

	struct pipe_inode_info *pipe = inode->i_pipe;

	int retval;

	int retval = 0;



	mutex_lock(&inode->i_mutex);

	if (filp->f_mode & FMODE_READ)

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

	if (retval >= 0) {

	if ((filp->f_mode & FMODE_WRITE) && retval >= 0) {

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

		if (retval < 0) /* this can happen only if on == T */

		if (retval < 0 && (filp->f_mode & FMODE_READ))

			/* this can happen only if on == T */

			fasync_helper(-1, filp, 0, &pipe->fasync_readers);

	}

	mutex_unlock(&inode->i_mutex);

	return retval;

}





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)

{

	int ret = -ENOENT;



	mutex_lock(&inode->i_mutex);



	if (inode->i_pipe) {

		ret = 0;

		inode->i_pipe->readers++;

	}



	mutex_unlock(&inode->i_mutex);



	return ret;

}



static int

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

{

	int ret = -ENOENT;



	mutex_lock(&inode->i_mutex);



	if (inode->i_pipe) {

		ret = 0;

		inode->i_pipe->writers++;

	}



	mutex_unlock(&inode->i_mutex);



	return ret;

}



static int

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

{

	int ret = -ENOENT;



	if (!(filp->f_mode & (FMODE_READ|FMODE_WRITE)))

		return -EINVAL;



	mutex_lock(&inode->i_mutex);



	if (inode->i_pipe) {

		ret = 0;

		if (filp->f_mode & FMODE_READ)

			inode->i_pipe->readers++;

		if (filp->f_mode & FMODE_WRITE)

			inode->i_pipe->writers++;

	}



	mutex_unlock(&inode->i_mutex);



	return ret;

}



/*

 * The file_operations structs are not static because they

 * are also used in linux/fs/fifo.c to do operations on FIFOs.

 *

 * Pipes reuse fifos' file_operations structs.

 */

const struct file_operations read_pipefifo_fops = {

	.llseek		= no_llseek,

	.read		= do_sync_read,

	.aio_read	= pipe_read,

	.write		= bad_pipe_w,

	.poll		= pipe_poll,

	.unlocked_ioctl	= pipe_ioctl,

	.open		= pipe_read_open,

	.release	= pipe_read_release,

	.fasync		= pipe_read_fasync,

};



const struct file_operations write_pipefifo_fops = {

	.llseek		= no_llseek,

	.read		= bad_pipe_r,

	.write		= do_sync_write,

	.aio_write	= pipe_write,

	.poll		= pipe_poll,

	.unlocked_ioctl	= pipe_ioctl,

	.open		= pipe_write_open,

	.release	= pipe_write_release,

	.fasync		= pipe_write_fasync,

};



const struct file_operations rdwr_pipefifo_fops = {

	.llseek		= no_llseek,

	.read		= do_sync_read,

	.aio_read	= pipe_read,

	.write		= do_sync_write,

	.aio_write	= pipe_write,

	.poll		= pipe_poll,

	.unlocked_ioctl	= pipe_ioctl,

	.open		= pipe_rdwr_open,

	.release	= pipe_rdwr_release,

	.fasync		= pipe_rdwr_fasync,

};



struct pipe_inode_info * alloc_pipe_info(struct inode *inode)

{

	struct pipe_inode_info *pipe;
@@ -996,7 +838,7 @@ static struct inode * get_pipe_inode(void) 
	inode->i_pipe = pipe;



	pipe->readers = pipe->writers = 1;

	inode->i_fop = &rdwr_pipefifo_fops;

	inode->i_fop = &pipefifo_fops;



	/*

	 * Mark the inode dirty from the very beginning,
@@ -1039,13 +881,13 @@ int create_pipe_files(struct file **res, int flags) 
	d_instantiate(path.dentry, inode);



	err = -ENFILE;

	f = alloc_file(&path, FMODE_WRITE, &write_pipefifo_fops);

	f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops);

	if (IS_ERR(f))

		goto err_dentry;



	f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT));



	res[0] = alloc_file(&path, FMODE_READ, &read_pipefifo_fops);

	res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops);

	if (IS_ERR(res[0]))

		goto err_file;
@@ -1164,6 +1006,7 @@ static void wake_up_partner(struct inode* inode) 
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;



	mutex_lock(&inode->i_mutex);
@@ -1187,12 +1030,11 @@ static int fifo_open(struct inode *inode, struct file *filp) 
	 *  POSIX.1 says that O_NONBLOCK means return with the FIFO

	 *  opened, even when there is no process writing the FIFO.

	 */

		filp->f_op = &read_pipefifo_fops;

		pipe->r_counter++;

		if (pipe->readers++ == 0)

			wake_up_partner(inode);



		if (!pipe->writers) {

		if (!is_pipe && !pipe->writers) {

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

				/* suppress POLLHUP until we have

				 * seen a writer */
@@ -1211,15 +1053,14 @@ 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)

		if (!is_pipe && (filp->f_flags & O_NONBLOCK) && !pipe->readers)

			goto err;



		filp->f_op = &write_pipefifo_fops;

		pipe->w_counter++;

		if (!pipe->writers++)

			wake_up_partner(inode);



		if (!pipe->readers) {

		if (!is_pipe && !pipe->readers) {

			if (wait_for_partner(inode, &pipe->r_counter))

				goto err_wr;

		}
@@ -1232,7 +1073,6 @@ static int fifo_open(struct inode *inode, struct file *filp) 
	 *  This implementation will NEVER block on a O_RDWR open, since

	 *  the process can at least talk to itself.

	 */

		filp->f_op = &rdwr_pipefifo_fops;



		pipe->readers++;

		pipe->writers++;
@@ -1272,14 +1112,17 @@ err_nocleanup: 
	return ret;

}



/*

 * Dummy default file-operations: the only thing this does

 * is contain the open that then fills in the correct operations

 * depending on the access mode of the file...

 */

const struct file_operations def_fifo_fops = {

	.open		= fifo_open,	/* will set read_ or write_pipefifo_fops */

	.llseek		= noop_llseek,

const struct file_operations pipefifo_fops = {

	.open		= fifo_open,

	.llseek		= no_llseek,

	.read		= do_sync_read,

	.aio_read	= pipe_read,

	.write		= do_sync_write,

	.aio_write	= pipe_write,

	.poll		= pipe_poll,

	.unlocked_ioctl	= pipe_ioctl,

	.release	= pipe_release,

	.fasync		= pipe_fasync,

};



/*

include/linux/fs.h

+0 −5
Original line number Diff line number Diff line
@@ -2080,7 +2080,6 @@ extern int sync_filesystem(struct super_block *); 
extern const struct file_operations def_blk_fops;

extern const struct file_operations def_chr_fops;

extern const struct file_operations bad_sock_fops;

extern const struct file_operations def_fifo_fops;

#ifdef CONFIG_BLOCK

extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);

extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
@@ -2152,10 +2151,6 @@ extern void init_special_inode(struct inode *, umode_t, dev_t); 
extern void make_bad_inode(struct inode *);

extern int is_bad_inode(struct inode *);



extern const struct file_operations read_pipefifo_fops;

extern const struct file_operations write_pipefifo_fops;

extern const struct file_operations rdwr_pipefifo_fops;



#ifdef CONFIG_BLOCK

/*

 * return READ, READA, or WRITE