[lttng-modules.git] / lib / ringbuffer / ring_buffer_vfs.c

/*
 * ring_buffer_vfs.c
 *
 * Ring Buffer VFS file operations.
 *
 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; only
 * version 2.1 of the License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/compat.h>

#include "../../wrapper/ringbuffer/backend.h"
#include "../../wrapper/ringbuffer/frontend.h"
#include "../../wrapper/ringbuffer/vfs.h"
#include "../../wrapper/poll.h"

static int put_ulong(unsigned long val, unsigned long arg)
{
	return put_user(val, (unsigned long __user *)arg);
}

#ifdef CONFIG_COMPAT
static int compat_put_ulong(compat_ulong_t val, unsigned long arg)
{
	return put_user(val, (compat_ulong_t __user *)compat_ptr(arg));
}
#endif

int lib_ring_buffer_open(struct inode *inode, struct file *file,
		struct lib_ring_buffer *buf)
{
	int ret;

	if (!buf)
		return -EINVAL;

	ret = lib_ring_buffer_open_read(buf);
	if (ret)
		return ret;

	ret = nonseekable_open(inode, file);
	if (ret)
		goto release_read;
	return 0;

release_read:
	lib_ring_buffer_release_read(buf);
	return ret;
}
EXPORT_SYMBOL_GPL(lib_ring_buffer_open);

/**
 *	vfs_lib_ring_buffer_open - ring buffer open file operation
 *	@inode: opened inode
 *	@file: opened file
 *
 *	Open implementation. Makes sure only one open instance of a buffer is
 *	done at a given moment.
 */
static
int vfs_lib_ring_buffer_open(struct inode *inode, struct file *file)
{
	struct lib_ring_buffer *buf = inode->i_private;

	file->private_data = buf;
	return lib_ring_buffer_open(inode, file, buf);
}

int lib_ring_buffer_release(struct inode *inode, struct file *file,
		struct lib_ring_buffer *buf)
{
	lib_ring_buffer_release_read(buf);

	return 0;
}
EXPORT_SYMBOL_GPL(lib_ring_buffer_release);

/**
 *	vfs_lib_ring_buffer_release - ring buffer release file operation
 *	@inode: opened inode
 *	@file: opened file
 *
 *	Release implementation.
 */
static
int vfs_lib_ring_buffer_release(struct inode *inode, struct file *file)
{
	struct lib_ring_buffer *buf = file->private_data;

	return lib_ring_buffer_release(inode, file, buf);
}

unsigned int lib_ring_buffer_poll(struct file *filp, poll_table *wait,
		struct lib_ring_buffer *buf)
{
	unsigned int mask = 0;
	struct channel *chan = buf->backend.chan;
	const struct lib_ring_buffer_config *config = &chan->backend.config;
	int finalized, disabled;

	if (filp->f_mode & FMODE_READ) {
		poll_wait_set_exclusive(wait);
		poll_wait(filp, &buf->read_wait, wait);

		finalized = lib_ring_buffer_is_finalized(config, buf);
		disabled = lib_ring_buffer_channel_is_disabled(chan);

		/*
		 * lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
		 * finalized load before offsets loads.
		 */
		WARN_ON(atomic_long_read(&buf->active_readers) != 1);
retry:
		if (disabled)
			return POLLERR;

		if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf), chan)
		  - subbuf_trunc(lib_ring_buffer_get_consumed(config, buf), chan)
		  == 0) {
			if (finalized)
				return POLLHUP;
			else {
				/*
				 * The memory barriers
				 * __wait_event()/wake_up_interruptible() take
				 * care of "raw_spin_is_locked" memory ordering.
				 */
				if (raw_spin_is_locked(&buf->raw_tick_nohz_spinlock))
					goto retry;
				else
					return 0;
			}
		} else {
			if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf),
					 chan)
			  - subbuf_trunc(lib_ring_buffer_get_consumed(config, buf),
					 chan)
			  >= chan->backend.buf_size)
				return POLLPRI | POLLRDBAND;
			else
				return POLLIN | POLLRDNORM;
		}
	}
	return mask;
}
EXPORT_SYMBOL_GPL(lib_ring_buffer_poll);

/**
 *	vfs_lib_ring_buffer_poll - ring buffer poll file operation
 *	@filp: the file
 *	@wait: poll table
 *
 *	Poll implementation.
 */
static
unsigned int vfs_lib_ring_buffer_poll(struct file *filp, poll_table *wait)
{
	struct lib_ring_buffer *buf = filp->private_data;

	return lib_ring_buffer_poll(filp, wait, buf);
}

long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd,
		unsigned long arg, struct lib_ring_buffer *buf)
{
	struct channel *chan = buf->backend.chan;
	const struct lib_ring_buffer_config *config = &chan->backend.config;

	if (lib_ring_buffer_channel_is_disabled(chan))
		return -EIO;

	switch (cmd) {
	case RING_BUFFER_SNAPSHOT:
		return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
					    &buf->prod_snapshot);
	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
		return put_ulong(buf->cons_snapshot, arg);
	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
		return put_ulong(buf->prod_snapshot, arg);
	case RING_BUFFER_GET_SUBBUF:
	{
		unsigned long uconsume;
		long ret;

		ret = get_user(uconsume, (unsigned long __user *) arg);
		if (ret)
			return ret; /* will return -EFAULT */
		ret = lib_ring_buffer_get_subbuf(buf, uconsume);
		if (!ret) {
			/* Set file position to zero at each successful "get" */
			filp->f_pos = 0;
		}
		return ret;
	}
	case RING_BUFFER_PUT_SUBBUF:
		lib_ring_buffer_put_subbuf(buf);
		return 0;

	case RING_BUFFER_GET_NEXT_SUBBUF:
	{
		long ret;

		ret = lib_ring_buffer_get_next_subbuf(buf);
		if (!ret) {
			/* Set file position to zero at each successful "get" */
			filp->f_pos = 0;
		}
		return ret;
	}
	case RING_BUFFER_PUT_NEXT_SUBBUF:
		lib_ring_buffer_put_next_subbuf(buf);
		return 0;
	case RING_BUFFER_GET_SUBBUF_SIZE:
		return put_ulong(lib_ring_buffer_get_read_data_size(config, buf),
				 arg);
	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
	{
		unsigned long size;

		size = lib_ring_buffer_get_read_data_size(config, buf);
		size = PAGE_ALIGN(size);
		return put_ulong(size, arg);
	}
	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
		return put_ulong(chan->backend.subbuf_size, arg);
	case RING_BUFFER_GET_MMAP_LEN:
	{
		unsigned long mmap_buf_len;

		if (config->output != RING_BUFFER_MMAP)
			return -EINVAL;
		mmap_buf_len = chan->backend.buf_size;
		if (chan->backend.extra_reader_sb)
			mmap_buf_len += chan->backend.subbuf_size;
		if (mmap_buf_len > INT_MAX)
			return -EFBIG;
		return put_ulong(mmap_buf_len, arg);
	}
	case RING_BUFFER_GET_MMAP_READ_OFFSET:
	{
		unsigned long sb_bindex;

		if (config->output != RING_BUFFER_MMAP)
			return -EINVAL;
		sb_bindex = subbuffer_id_get_index(config,
						   buf->backend.buf_rsb.id);
		return put_ulong(buf->backend.array[sb_bindex]->mmap_offset,
				 arg);
	}
	case RING_BUFFER_FLUSH:
		lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
		return 0;
	default:
		return -ENOIOCTLCMD;
	}
}
EXPORT_SYMBOL_GPL(lib_ring_buffer_ioctl);

/**
 *	vfs_lib_ring_buffer_ioctl - control ring buffer reader synchronization
 *
 *	@filp: the file
 *	@cmd: the command
 *	@arg: command arg
 *
 *	This ioctl implements commands necessary for producer/consumer
 *	and flight recorder reader interaction :
 *	RING_BUFFER_GET_NEXT_SUBBUF
 *		Get the next sub-buffer that can be read. It never blocks.
 *	RING_BUFFER_PUT_NEXT_SUBBUF
 *		Release the currently read sub-buffer.
 *	RING_BUFFER_GET_SUBBUF_SIZE
 *		returns the size of the current sub-buffer.
 *	RING_BUFFER_GET_MAX_SUBBUF_SIZE
 *		returns the maximum size for sub-buffers.
 *	RING_BUFFER_GET_NUM_SUBBUF
 *		returns the number of reader-visible sub-buffers in the per cpu
 *              channel (for mmap).
 *      RING_BUFFER_GET_MMAP_READ_OFFSET
 *              returns the offset of the subbuffer belonging to the reader.
 *              Should only be used for mmap clients.
 */
static
long vfs_lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct lib_ring_buffer *buf = filp->private_data;

	return lib_ring_buffer_ioctl(filp, cmd, arg, buf);
}

#ifdef CONFIG_COMPAT
long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
		unsigned long arg, struct lib_ring_buffer *buf)
{
	struct channel *chan = buf->backend.chan;
	const struct lib_ring_buffer_config *config = &chan->backend.config;

	if (lib_ring_buffer_channel_is_disabled(chan))
		return -EIO;

	switch (cmd) {
	case RING_BUFFER_COMPAT_SNAPSHOT:
		return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
						&buf->prod_snapshot);
	case RING_BUFFER_COMPAT_SNAPSHOT_GET_CONSUMED:
		return compat_put_ulong(buf->cons_snapshot, arg);
	case RING_BUFFER_COMPAT_SNAPSHOT_GET_PRODUCED:
		return compat_put_ulong(buf->prod_snapshot, arg);
	case RING_BUFFER_COMPAT_GET_SUBBUF:
	{
		__u32 uconsume;
		unsigned long consume;
		long ret;

		ret = get_user(uconsume, (__u32 __user *) arg);
		if (ret)
			return ret; /* will return -EFAULT */
		consume = buf->cons_snapshot;
		consume &= ~0xFFFFFFFFL;
		consume |= uconsume;
		ret = lib_ring_buffer_get_subbuf(buf, consume);
		if (!ret) {
			/* Set file position to zero at each successful "get" */
			filp->f_pos = 0;
		}
		return ret;
	}
	case RING_BUFFER_COMPAT_PUT_SUBBUF:
		lib_ring_buffer_put_subbuf(buf);
		return 0;

	case RING_BUFFER_COMPAT_GET_NEXT_SUBBUF:
	{
		long ret;

		ret = lib_ring_buffer_get_next_subbuf(buf);
		if (!ret) {
			/* Set file position to zero at each successful "get" */
			filp->f_pos = 0;
		}
		return ret;
	}
	case RING_BUFFER_COMPAT_PUT_NEXT_SUBBUF:
		lib_ring_buffer_put_next_subbuf(buf);
		return 0;
	case RING_BUFFER_COMPAT_GET_SUBBUF_SIZE:
	{
		unsigned long data_size;

		data_size = lib_ring_buffer_get_read_data_size(config, buf);
		if (data_size > UINT_MAX)
			return -EFBIG;
		return compat_put_ulong(data_size, arg);
	}
	case RING_BUFFER_COMPAT_GET_PADDED_SUBBUF_SIZE:
	{
		unsigned long size;

		size = lib_ring_buffer_get_read_data_size(config, buf);
		size = PAGE_ALIGN(size);
		if (size > UINT_MAX)
			return -EFBIG;
		return compat_put_ulong(size, arg);
	}
	case RING_BUFFER_COMPAT_GET_MAX_SUBBUF_SIZE:
		if (chan->backend.subbuf_size > UINT_MAX)
			return -EFBIG;
		return compat_put_ulong(chan->backend.subbuf_size, arg);
	case RING_BUFFER_COMPAT_GET_MMAP_LEN:
	{
		unsigned long mmap_buf_len;

		if (config->output != RING_BUFFER_MMAP)
			return -EINVAL;
		mmap_buf_len = chan->backend.buf_size;
		if (chan->backend.extra_reader_sb)
			mmap_buf_len += chan->backend.subbuf_size;
		if (mmap_buf_len > UINT_MAX)
			return -EFBIG;
		return compat_put_ulong(mmap_buf_len, arg);
	}
	case RING_BUFFER_COMPAT_GET_MMAP_READ_OFFSET:
	{
		unsigned long sb_bindex, read_offset;

		if (config->output != RING_BUFFER_MMAP)
			return -EINVAL;
		sb_bindex = subbuffer_id_get_index(config,
						   buf->backend.buf_rsb.id);
		read_offset = buf->backend.array[sb_bindex]->mmap_offset;
		if (read_offset > UINT_MAX)
			return -EINVAL;
		return compat_put_ulong(read_offset, arg);
	}
	case RING_BUFFER_COMPAT_FLUSH:
		lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
		return 0;
	default:
		return -ENOIOCTLCMD;
	}
}
EXPORT_SYMBOL_GPL(lib_ring_buffer_compat_ioctl);

static
long vfs_lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
				  unsigned long arg)
{
	struct lib_ring_buffer *buf = filp->private_data;

	return lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
}
#endif

const struct file_operations lib_ring_buffer_file_operations = {
	.owner = THIS_MODULE,
	.open = vfs_lib_ring_buffer_open,
	.release = vfs_lib_ring_buffer_release,
	.poll = vfs_lib_ring_buffer_poll,
	.splice_read = vfs_lib_ring_buffer_splice_read,
	.mmap = vfs_lib_ring_buffer_mmap,
	.unlocked_ioctl = vfs_lib_ring_buffer_ioctl,
	.llseek = vfs_lib_ring_buffer_no_llseek,
#ifdef CONFIG_COMPAT
	.compat_ioctl = vfs_lib_ring_buffer_compat_ioctl,
#endif
};
EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);

MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("Ring Buffer Library VFS");
Commit	Line	Data
f3bc08c5 MD	1	/*
	2	* ring_buffer_vfs.c
	3	*
f3bc08c5 MD	4	* Ring Buffer VFS file operations.
f3bc08c5 MD	5	*
886d51a3 MD	6	* Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; only
	11	* version 2.1 of the License.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
f3bc08c5 MD	21	*/
	22
	23	#include <linux/module.h>
	24	#include <linux/fs.h>
	25	#include <linux/compat.h>
	26
	27	#include "../../wrapper/ringbuffer/backend.h"
	28	#include "../../wrapper/ringbuffer/frontend.h"
	29	#include "../../wrapper/ringbuffer/vfs.h"
	30	#include "../../wrapper/poll.h"
	31
	32	static int put_ulong(unsigned long val, unsigned long arg)
	33	{
	34	return put_user(val, (unsigned long __user *)arg);
	35	}
	36
	37	#ifdef CONFIG_COMPAT
	38	static int compat_put_ulong(compat_ulong_t val, unsigned long arg)
	39	{
	40	return put_user(val, (compat_ulong_t __user *)compat_ptr(arg));
	41	}
	42	#endif
	43
d83004aa JD	44	int lib_ring_buffer_open(struct inode inode, struct file file,
d83004aa JD	45	struct lib_ring_buffer *buf)
f3bc08c5	46	{
f3bc08c5 MD	47	int ret;
f3bc08c5 MD	48
733ce41d MD	49	if (!buf)
	50	return -EINVAL;
	51
f3bc08c5 MD	52	ret = lib_ring_buffer_open_read(buf);
	53	if (ret)
	54	return ret;
	55
f3bc08c5 MD	56	ret = nonseekable_open(inode, file);
	57	if (ret)
	58	goto release_read;
	59	return 0;
	60
	61	release_read:
	62	lib_ring_buffer_release_read(buf);
	63	return ret;
	64	}
d83004aa	65	EXPORT_SYMBOL_GPL(lib_ring_buffer_open);
f3bc08c5 MD	66
f3bc08c5 MD	67	/**
d83004aa	68	* vfs_lib_ring_buffer_open - ring buffer open file operation
f3bc08c5 MD	69	* @inode: opened inode
	70	* @file: opened file
	71	*
d83004aa JD	72	* Open implementation. Makes sure only one open instance of a buffer is
d83004aa JD	73	* done at a given moment.
f3bc08c5	74	*/
d83004aa JD	75	static
d83004aa JD	76	int vfs_lib_ring_buffer_open(struct inode inode, struct file file)
f3bc08c5	77	{
d83004aa JD	78	struct lib_ring_buffer *buf = inode->i_private;
	79
	80	file->private_data = buf;
	81	return lib_ring_buffer_open(inode, file, buf);
	82	}
f3bc08c5	83
d83004aa JD	84	int lib_ring_buffer_release(struct inode inode, struct file file,
	85	struct lib_ring_buffer *buf)
	86	{
f3bc08c5 MD	87	lib_ring_buffer_release_read(buf);
	88
	89	return 0;
	90	}
d83004aa	91	EXPORT_SYMBOL_GPL(lib_ring_buffer_release);
f3bc08c5 MD	92
f3bc08c5 MD	93	/**
d83004aa JD	94	* vfs_lib_ring_buffer_release - ring buffer release file operation
	95	* @inode: opened inode
	96	* @file: opened file
f3bc08c5	97	*
d83004aa	98	* Release implementation.
f3bc08c5	99	*/
d83004aa JD	100	static
	101	int vfs_lib_ring_buffer_release(struct inode inode, struct file file)
	102	{
	103	struct lib_ring_buffer *buf = file->private_data;
	104
	105	return lib_ring_buffer_release(inode, file, buf);
	106	}
	107
	108	unsigned int lib_ring_buffer_poll(struct file filp, poll_table wait,
	109	struct lib_ring_buffer *buf)
f3bc08c5 MD	110	{
f3bc08c5 MD	111	unsigned int mask = 0;
f3bc08c5	112	struct channel *chan = buf->backend.chan;
5a8fd222	113	const struct lib_ring_buffer_config *config = &chan->backend.config;
254ec7bc	114	int finalized, disabled;
f3bc08c5 MD	115
f3bc08c5 MD	116	if (filp->f_mode & FMODE_READ) {
a33e44a6	117	poll_wait_set_exclusive(wait);
f3bc08c5 MD	118	poll_wait(filp, &buf->read_wait, wait);
	119
	120	finalized = lib_ring_buffer_is_finalized(config, buf);
254ec7bc MD	121	disabled = lib_ring_buffer_channel_is_disabled(chan);
254ec7bc MD	122
f3bc08c5 MD	123	/*
	124	* lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
	125	* finalized load before offsets loads.
	126	*/
	127	WARN_ON(atomic_long_read(&buf->active_readers) != 1);
	128	retry:
254ec7bc MD	129	if (disabled)
	130	return POLLERR;
	131
f3bc08c5 MD	132	if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf), chan)
	133	- subbuf_trunc(lib_ring_buffer_get_consumed(config, buf), chan)
	134	== 0) {
	135	if (finalized)
	136	return POLLHUP;
	137	else {
	138	/*
	139	* The memory barriers
	140	* __wait_event()/wake_up_interruptible() take
	141	* care of "raw_spin_is_locked" memory ordering.
	142	*/
	143	if (raw_spin_is_locked(&buf->raw_tick_nohz_spinlock))
	144	goto retry;
	145	else
	146	return 0;
	147	}
	148	} else {
	149	if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf),
	150	chan)
	151	- subbuf_trunc(lib_ring_buffer_get_consumed(config, buf),
	152	chan)
	153	>= chan->backend.buf_size)
	154	return POLLPRI \| POLLRDBAND;
	155	else
	156	return POLLIN \| POLLRDNORM;
	157	}
	158	}
	159	return mask;
	160	}
d83004aa	161	EXPORT_SYMBOL_GPL(lib_ring_buffer_poll);
f3bc08c5 MD	162
f3bc08c5 MD	163	/**
d83004aa	164	* vfs_lib_ring_buffer_poll - ring buffer poll file operation
f3bc08c5	165	* @filp: the file
d83004aa	166	* @wait: poll table
f3bc08c5	167	*
d83004aa	168	* Poll implementation.
f3bc08c5	169	*/
d83004aa JD	170	static
d83004aa JD	171	unsigned int vfs_lib_ring_buffer_poll(struct file filp, poll_table wait)
f3bc08c5 MD	172	{
f3bc08c5 MD	173	struct lib_ring_buffer *buf = filp->private_data;
d83004aa JD	174
	175	return lib_ring_buffer_poll(filp, wait, buf);
	176	}
	177
	178	long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd,
	179	unsigned long arg, struct lib_ring_buffer *buf)
	180	{
f3bc08c5	181	struct channel *chan = buf->backend.chan;
5a8fd222	182	const struct lib_ring_buffer_config *config = &chan->backend.config;
f3bc08c5	183
254ec7bc MD	184	if (lib_ring_buffer_channel_is_disabled(chan))
	185	return -EIO;
	186
f3bc08c5 MD	187	switch (cmd) {
	188	case RING_BUFFER_SNAPSHOT:
	189	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
	190	&buf->prod_snapshot);
	191	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
	192	return put_ulong(buf->cons_snapshot, arg);
	193	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
	194	return put_ulong(buf->prod_snapshot, arg);
	195	case RING_BUFFER_GET_SUBBUF:
	196	{
	197	unsigned long uconsume;
	198	long ret;
	199
	200	ret = get_user(uconsume, (unsigned long __user *) arg);
	201	if (ret)
	202	return ret; /* will return -EFAULT */
	203	ret = lib_ring_buffer_get_subbuf(buf, uconsume);
	204	if (!ret) {
	205	/* Set file position to zero at each successful "get" */
	206	filp->f_pos = 0;
	207	}
	208	return ret;
	209	}
	210	case RING_BUFFER_PUT_SUBBUF:
	211	lib_ring_buffer_put_subbuf(buf);
	212	return 0;
	213
	214	case RING_BUFFER_GET_NEXT_SUBBUF:
	215	{
	216	long ret;
	217
	218	ret = lib_ring_buffer_get_next_subbuf(buf);
	219	if (!ret) {
	220	/* Set file position to zero at each successful "get" */
	221	filp->f_pos = 0;
	222	}
	223	return ret;
	224	}
	225	case RING_BUFFER_PUT_NEXT_SUBBUF:
	226	lib_ring_buffer_put_next_subbuf(buf);
	227	return 0;
	228	case RING_BUFFER_GET_SUBBUF_SIZE:
	229	return put_ulong(lib_ring_buffer_get_read_data_size(config, buf),
	230	arg);
	231	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
	232	{
	233	unsigned long size;
	234
	235	size = lib_ring_buffer_get_read_data_size(config, buf);
	236	size = PAGE_ALIGN(size);
	237	return put_ulong(size, arg);
	238	}
	239	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
	240	return put_ulong(chan->backend.subbuf_size, arg);
	241	case RING_BUFFER_GET_MMAP_LEN:
	242	{
	243	unsigned long mmap_buf_len;
	244
	245	if (config->output != RING_BUFFER_MMAP)
	246	return -EINVAL;
	247	mmap_buf_len = chan->backend.buf_size;
	248	if (chan->backend.extra_reader_sb)
	249	mmap_buf_len += chan->backend.subbuf_size;
	250	if (mmap_buf_len > INT_MAX)
251	return -EFBIG;
252	return put_ulong(mmap_buf_len, arg);
253	}
254	case RING_BUFFER_GET_MMAP_READ_OFFSET:
255	{
256	unsigned long sb_bindex;
257
258	if (config->output != RING_BUFFER_MMAP)
259	return -EINVAL;
260	sb_bindex = subbuffer_id_get_index(config,
261	buf->backend.buf_rsb.id);
262	return put_ulong(buf->backend.array[sb_bindex]->mmap_offset,
263	arg);
264	}
5c055266 MD	265	case RING_BUFFER_FLUSH:
	266	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
	267	return 0;
f3bc08c5 MD	268	default:
	269	return -ENOIOCTLCMD;
	270	}
	271	}
d83004aa JD	272	EXPORT_SYMBOL_GPL(lib_ring_buffer_ioctl);
	273
	274	/**
	275	* vfs_lib_ring_buffer_ioctl - control ring buffer reader synchronization
	276	*
	277	* @filp: the file
	278	* @cmd: the command
	279	* @arg: command arg
	280	*
	281	* This ioctl implements commands necessary for producer/consumer
	282	* and flight recorder reader interaction :
	283	* RING_BUFFER_GET_NEXT_SUBBUF
	284	* Get the next sub-buffer that can be read. It never blocks.
	285	* RING_BUFFER_PUT_NEXT_SUBBUF
	286	* Release the currently read sub-buffer.
	287	* RING_BUFFER_GET_SUBBUF_SIZE
	288	* returns the size of the current sub-buffer.
	289	* RING_BUFFER_GET_MAX_SUBBUF_SIZE
	290	* returns the maximum size for sub-buffers.
	291	* RING_BUFFER_GET_NUM_SUBBUF
	292	* returns the number of reader-visible sub-buffers in the per cpu
	293	* channel (for mmap).
	294	* RING_BUFFER_GET_MMAP_READ_OFFSET
	295	* returns the offset of the subbuffer belonging to the reader.
	296	* Should only be used for mmap clients.
	297	*/
	298	static
	299	long vfs_lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	300	{
	301	struct lib_ring_buffer *buf = filp->private_data;
	302
	303	return lib_ring_buffer_ioctl(filp, cmd, arg, buf);
	304	}
f3bc08c5 MD	305
	306	#ifdef CONFIG_COMPAT
	307	long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
d83004aa	308	unsigned long arg, struct lib_ring_buffer *buf)
f3bc08c5	309	{
f3bc08c5	310	struct channel *chan = buf->backend.chan;
5a8fd222	311	const struct lib_ring_buffer_config *config = &chan->backend.config;
254ec7bc MD	312
	313	if (lib_ring_buffer_channel_is_disabled(chan))
	314	return -EIO;
f3bc08c5 MD	315
f3bc08c5 MD	316	switch (cmd) {
216f7feb	317	case RING_BUFFER_COMPAT_SNAPSHOT:
f3bc08c5 MD	318	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
f3bc08c5 MD	319	&buf->prod_snapshot);
216f7feb	320	case RING_BUFFER_COMPAT_SNAPSHOT_GET_CONSUMED:
f3bc08c5	321	return compat_put_ulong(buf->cons_snapshot, arg);
216f7feb	322	case RING_BUFFER_COMPAT_SNAPSHOT_GET_PRODUCED:
f3bc08c5	323	return compat_put_ulong(buf->prod_snapshot, arg);
216f7feb	324	case RING_BUFFER_COMPAT_GET_SUBBUF:
f3bc08c5 MD	325	{
	326	__u32 uconsume;
	327	unsigned long consume;
	328	long ret;
	329
	330	ret = get_user(uconsume, (__u32 __user *) arg);
	331	if (ret)
	332	return ret; /* will return -EFAULT */
	333	consume = buf->cons_snapshot;
	334	consume &= ~0xFFFFFFFFL;
	335	consume \|= uconsume;
	336	ret = lib_ring_buffer_get_subbuf(buf, consume);
	337	if (!ret) {
	338	/* Set file position to zero at each successful "get" */
	339	filp->f_pos = 0;
	340	}
	341	return ret;
	342	}
216f7feb	343	case RING_BUFFER_COMPAT_PUT_SUBBUF:
f3bc08c5 MD	344	lib_ring_buffer_put_subbuf(buf);
	345	return 0;
	346
216f7feb	347	case RING_BUFFER_COMPAT_GET_NEXT_SUBBUF:
f3bc08c5 MD	348	{
	349	long ret;
	350
	351	ret = lib_ring_buffer_get_next_subbuf(buf);
	352	if (!ret) {
	353	/* Set file position to zero at each successful "get" */
	354	filp->f_pos = 0;
	355	}
	356	return ret;
	357	}
216f7feb	358	case RING_BUFFER_COMPAT_PUT_NEXT_SUBBUF:
f3bc08c5 MD	359	lib_ring_buffer_put_next_subbuf(buf);
f3bc08c5 MD	360	return 0;
216f7feb	361	case RING_BUFFER_COMPAT_GET_SUBBUF_SIZE:
f3bc08c5 MD	362	{
	363	unsigned long data_size;
	364
	365	data_size = lib_ring_buffer_get_read_data_size(config, buf);
	366	if (data_size > UINT_MAX)
	367	return -EFBIG;
4343ec8e	368	return compat_put_ulong(data_size, arg);
f3bc08c5	369	}
216f7feb	370	case RING_BUFFER_COMPAT_GET_PADDED_SUBBUF_SIZE:
f3bc08c5 MD	371	{
	372	unsigned long size;
	373
	374	size = lib_ring_buffer_get_read_data_size(config, buf);
	375	size = PAGE_ALIGN(size);
	376	if (size > UINT_MAX)
	377	return -EFBIG;
4343ec8e	378	return compat_put_ulong(size, arg);
f3bc08c5	379	}
216f7feb	380	case RING_BUFFER_COMPAT_GET_MAX_SUBBUF_SIZE:
f3bc08c5 MD	381	if (chan->backend.subbuf_size > UINT_MAX)
f3bc08c5 MD	382	return -EFBIG;
4343ec8e	383	return compat_put_ulong(chan->backend.subbuf_size, arg);
216f7feb	384	case RING_BUFFER_COMPAT_GET_MMAP_LEN:
f3bc08c5 MD	385	{
	386	unsigned long mmap_buf_len;
	387
	388	if (config->output != RING_BUFFER_MMAP)
	389	return -EINVAL;
	390	mmap_buf_len = chan->backend.buf_size;
	391	if (chan->backend.extra_reader_sb)
	392	mmap_buf_len += chan->backend.subbuf_size;
	393	if (mmap_buf_len > UINT_MAX)
	394	return -EFBIG;
4343ec8e	395	return compat_put_ulong(mmap_buf_len, arg);
f3bc08c5	396	}
216f7feb	397	case RING_BUFFER_COMPAT_GET_MMAP_READ_OFFSET:
f3bc08c5 MD	398	{
	399	unsigned long sb_bindex, read_offset;
	400
	401	if (config->output != RING_BUFFER_MMAP)
	402	return -EINVAL;
	403	sb_bindex = subbuffer_id_get_index(config,
	404	buf->backend.buf_rsb.id);
	405	read_offset = buf->backend.array[sb_bindex]->mmap_offset;
	406	if (read_offset > UINT_MAX)
	407	return -EINVAL;
4343ec8e	408	return compat_put_ulong(read_offset, arg);
f3bc08c5	409	}
216f7feb	410	case RING_BUFFER_COMPAT_FLUSH:
5c055266 MD	411	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE);
5c055266 MD	412	return 0;
f3bc08c5 MD	413	default:
	414	return -ENOIOCTLCMD;
	415	}
	416	}
d83004aa JD	417	EXPORT_SYMBOL_GPL(lib_ring_buffer_compat_ioctl);
	418
	419	static
	420	long vfs_lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
	421	unsigned long arg)
	422	{
	423	struct lib_ring_buffer *buf = filp->private_data;
	424
	425	return lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
	426	}
f3bc08c5 MD	427	#endif
	428
	429	const struct file_operations lib_ring_buffer_file_operations = {
a33c9927	430	.owner = THIS_MODULE,
d83004aa JD	431	.open = vfs_lib_ring_buffer_open,
	432	.release = vfs_lib_ring_buffer_release,
	433	.poll = vfs_lib_ring_buffer_poll,
	434	.splice_read = vfs_lib_ring_buffer_splice_read,
	435	.mmap = vfs_lib_ring_buffer_mmap,
	436	.unlocked_ioctl = vfs_lib_ring_buffer_ioctl,
	437	.llseek = vfs_lib_ring_buffer_no_llseek,
f3bc08c5	438	#ifdef CONFIG_COMPAT
d83004aa	439	.compat_ioctl = vfs_lib_ring_buffer_compat_ioctl,
f3bc08c5 MD	440	#endif
	441	};
	442	EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);
	443
	444	MODULE_LICENSE("GPL and additional rights");
	445	MODULE_AUTHOR("Mathieu Desnoyers");
	446	MODULE_DESCRIPTION("Ring Buffer Library VFS");