[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>
#include <lttng-tracer.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

/*
 * This is not used by anonymous file descriptors. This code is left
 * there if we ever want to implement an inode with open() operation.
 */
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:
		/*
		 * First, ensure we perform a "final" flush onto the
		 * stream.  This will ensure we create a packet of
		 * padding if we encounter an empty packet. This ensures
		 * the time-stamps right before the snapshot is used as
		 * end of packet timestamp.
		 */
		if (!buf->quiescent)
			lib_ring_buffer_switch_remote_empty(buf);
		return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
					    &buf->prod_snapshot);
	case RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS:
		return lib_ring_buffer_snapshot_sample_positions(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_remote(buf);
		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:
		/*
		 * First, ensure we perform a "final" flush onto the
		 * stream.  This will ensure we create a packet of
		 * padding if we encounter an empty packet. This ensures
		 * the time-stamps right before the snapshot is used as
		 * end of packet timestamp.
		 */
		if (!buf->quiescent)
			lib_ring_buffer_switch_remote_empty(buf);
		return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
						&buf->prod_snapshot);
	case RING_BUFFER_COMPAT_SNAPSHOT_SAMPLE_POSITIONS:
		return lib_ring_buffer_snapshot_sample_positions(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_remote(buf);
		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");
MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
	LTTNG_MODULES_EXTRAVERSION);
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
c075712b MD	27	#include <wrapper/ringbuffer/backend.h>
	28	#include <wrapper/ringbuffer/frontend.h>
	29	#include <wrapper/ringbuffer/vfs.h>
	30	#include <wrapper/poll.h>
	31	#include <lttng-tracer.h>
f3bc08c5 MD	32
	33	static int put_ulong(unsigned long val, unsigned long arg)
	34	{
	35	return put_user(val, (unsigned long __user *)arg);
	36	}
	37
	38	#ifdef CONFIG_COMPAT
	39	static int compat_put_ulong(compat_ulong_t val, unsigned long arg)
	40	{
	41	return put_user(val, (compat_ulong_t __user *)compat_ptr(arg));
	42	}
	43	#endif
	44
b3b8072b MD	45	/*
	46	* This is not used by anonymous file descriptors. This code is left
	47	* there if we ever want to implement an inode with open() operation.
	48	*/
d83004aa JD	49	int lib_ring_buffer_open(struct inode inode, struct file file,
d83004aa JD	50	struct lib_ring_buffer *buf)
f3bc08c5	51	{
f3bc08c5 MD	52	int ret;
f3bc08c5 MD	53
733ce41d MD	54	if (!buf)
	55	return -EINVAL;
	56
f3bc08c5 MD	57	ret = lib_ring_buffer_open_read(buf);
	58	if (ret)
	59	return ret;
	60
f3bc08c5 MD	61	ret = nonseekable_open(inode, file);
	62	if (ret)
	63	goto release_read;
	64	return 0;
	65
	66	release_read:
	67	lib_ring_buffer_release_read(buf);
	68	return ret;
	69	}
d83004aa	70	EXPORT_SYMBOL_GPL(lib_ring_buffer_open);
f3bc08c5 MD	71
f3bc08c5 MD	72	/**
d83004aa	73	* vfs_lib_ring_buffer_open - ring buffer open file operation
f3bc08c5 MD	74	* @inode: opened inode
	75	* @file: opened file
	76	*
d83004aa JD	77	* Open implementation. Makes sure only one open instance of a buffer is
d83004aa JD	78	* done at a given moment.
f3bc08c5	79	*/
d83004aa JD	80	static
d83004aa JD	81	int vfs_lib_ring_buffer_open(struct inode inode, struct file file)
f3bc08c5	82	{
d83004aa JD	83	struct lib_ring_buffer *buf = inode->i_private;
	84
	85	file->private_data = buf;
	86	return lib_ring_buffer_open(inode, file, buf);
	87	}
f3bc08c5	88
d83004aa JD	89	int lib_ring_buffer_release(struct inode inode, struct file file,
	90	struct lib_ring_buffer *buf)
	91	{
f3bc08c5 MD	92	lib_ring_buffer_release_read(buf);
	93
	94	return 0;
	95	}
d83004aa	96	EXPORT_SYMBOL_GPL(lib_ring_buffer_release);
f3bc08c5 MD	97
f3bc08c5 MD	98	/**
d83004aa JD	99	* vfs_lib_ring_buffer_release - ring buffer release file operation
	100	* @inode: opened inode
	101	* @file: opened file
f3bc08c5	102	*
d83004aa	103	* Release implementation.
f3bc08c5	104	*/
d83004aa JD	105	static
	106	int vfs_lib_ring_buffer_release(struct inode inode, struct file file)
	107	{
	108	struct lib_ring_buffer *buf = file->private_data;
	109
	110	return lib_ring_buffer_release(inode, file, buf);
	111	}
	112
	113	unsigned int lib_ring_buffer_poll(struct file filp, poll_table wait,
	114	struct lib_ring_buffer *buf)
f3bc08c5 MD	115	{
f3bc08c5 MD	116	unsigned int mask = 0;
f3bc08c5	117	struct channel *chan = buf->backend.chan;
5a8fd222	118	const struct lib_ring_buffer_config *config = &chan->backend.config;
254ec7bc	119	int finalized, disabled;
f3bc08c5 MD	120
f3bc08c5 MD	121	if (filp->f_mode & FMODE_READ) {
a33e44a6	122	poll_wait_set_exclusive(wait);
f3bc08c5 MD	123	poll_wait(filp, &buf->read_wait, wait);
	124
	125	finalized = lib_ring_buffer_is_finalized(config, buf);
254ec7bc MD	126	disabled = lib_ring_buffer_channel_is_disabled(chan);
254ec7bc MD	127
f3bc08c5 MD	128	/*
	129	* lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
	130	* finalized load before offsets loads.
	131	*/
	132	WARN_ON(atomic_long_read(&buf->active_readers) != 1);
	133	retry:
254ec7bc MD	134	if (disabled)
	135	return POLLERR;
	136
f3bc08c5 MD	137	if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf), chan)
	138	- subbuf_trunc(lib_ring_buffer_get_consumed(config, buf), chan)
	139	== 0) {
	140	if (finalized)
	141	return POLLHUP;
	142	else {
	143	/*
	144	* The memory barriers
	145	* __wait_event()/wake_up_interruptible() take
	146	* care of "raw_spin_is_locked" memory ordering.
	147	*/
	148	if (raw_spin_is_locked(&buf->raw_tick_nohz_spinlock))
	149	goto retry;
	150	else
	151	return 0;
	152	}
	153	} else {
	154	if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf),
	155	chan)
	156	- subbuf_trunc(lib_ring_buffer_get_consumed(config, buf),
	157	chan)
	158	>= chan->backend.buf_size)
	159	return POLLPRI \| POLLRDBAND;
	160	else
	161	return POLLIN \| POLLRDNORM;
	162	}
	163	}
	164	return mask;
	165	}
d83004aa	166	EXPORT_SYMBOL_GPL(lib_ring_buffer_poll);
f3bc08c5 MD	167
f3bc08c5 MD	168	/**
d83004aa	169	* vfs_lib_ring_buffer_poll - ring buffer poll file operation
f3bc08c5	170	* @filp: the file
d83004aa	171	* @wait: poll table
f3bc08c5	172	*
d83004aa	173	* Poll implementation.
f3bc08c5	174	*/
d83004aa JD	175	static
d83004aa JD	176	unsigned int vfs_lib_ring_buffer_poll(struct file filp, poll_table wait)
f3bc08c5 MD	177	{
f3bc08c5 MD	178	struct lib_ring_buffer *buf = filp->private_data;
d83004aa JD	179
	180	return lib_ring_buffer_poll(filp, wait, buf);
	181	}
	182
	183	long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd,
	184	unsigned long arg, struct lib_ring_buffer *buf)
	185	{
f3bc08c5	186	struct channel *chan = buf->backend.chan;
5a8fd222	187	const struct lib_ring_buffer_config *config = &chan->backend.config;
f3bc08c5	188
254ec7bc MD	189	if (lib_ring_buffer_channel_is_disabled(chan))
	190	return -EIO;
	191
f3bc08c5 MD	192	switch (cmd) {
f3bc08c5 MD	193	case RING_BUFFER_SNAPSHOT:
7cf44d03 MD	194	/*
	195	* First, ensure we perform a "final" flush onto the
	196	* stream. This will ensure we create a packet of
	197	* padding if we encounter an empty packet. This ensures
	198	* the time-stamps right before the snapshot is used as
	199	* end of packet timestamp.
	200	*/
	201	if (!buf->quiescent)
	202	lib_ring_buffer_switch_remote_empty(buf);
f3bc08c5 MD	203	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
f3bc08c5 MD	204	&buf->prod_snapshot);
4dce5a48 JG	205	case RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS:
	206	return lib_ring_buffer_snapshot_sample_positions(buf,
	207	&buf->cons_snapshot, &buf->prod_snapshot);
f3bc08c5 MD	208	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
	209	return put_ulong(buf->cons_snapshot, arg);
	210	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
	211	return put_ulong(buf->prod_snapshot, arg);
	212	case RING_BUFFER_GET_SUBBUF:
	213	{
	214	unsigned long uconsume;
	215	long ret;
	216
	217	ret = get_user(uconsume, (unsigned long __user *) arg);
	218	if (ret)
	219	return ret; /* will return -EFAULT */
	220	ret = lib_ring_buffer_get_subbuf(buf, uconsume);
	221	if (!ret) {
	222	/* Set file position to zero at each successful "get" */
	223	filp->f_pos = 0;
	224	}
	225	return ret;
	226	}
	227	case RING_BUFFER_PUT_SUBBUF:
	228	lib_ring_buffer_put_subbuf(buf);
	229	return 0;
	230
	231	case RING_BUFFER_GET_NEXT_SUBBUF:
	232	{
	233	long ret;
	234
	235	ret = lib_ring_buffer_get_next_subbuf(buf);
	236	if (!ret) {
	237	/* Set file position to zero at each successful "get" */
	238	filp->f_pos = 0;
	239	}
	240	return ret;
	241	}
	242	case RING_BUFFER_PUT_NEXT_SUBBUF:
	243	lib_ring_buffer_put_next_subbuf(buf);
	244	return 0;
	245	case RING_BUFFER_GET_SUBBUF_SIZE:
	246	return put_ulong(lib_ring_buffer_get_read_data_size(config, buf),
	247	arg);
	248	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
	249	{
	250	unsigned long size;
	251
	252	size = lib_ring_buffer_get_read_data_size(config, buf);
	253	size = PAGE_ALIGN(size);
	254	return put_ulong(size, arg);
	255	}
	256	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
	257	return put_ulong(chan->backend.subbuf_size, arg);
	258	case RING_BUFFER_GET_MMAP_LEN:
	259	{
	260	unsigned long mmap_buf_len;
	261
	262	if (config->output != RING_BUFFER_MMAP)
	263	return -EINVAL;
	264	mmap_buf_len = chan->backend.buf_size;
	265	if (chan->backend.extra_reader_sb)
	266	mmap_buf_len += chan->backend.subbuf_size;
	267	if (mmap_buf_len > INT_MAX)
	268	return -EFBIG;
	269	return put_ulong(mmap_buf_len, arg);
	270	}
	271	case RING_BUFFER_GET_MMAP_READ_OFFSET:
272	{
273	unsigned long sb_bindex;
274
275	if (config->output != RING_BUFFER_MMAP)
276	return -EINVAL;
277	sb_bindex = subbuffer_id_get_index(config,
278	buf->backend.buf_rsb.id);
279	return put_ulong(buf->backend.array[sb_bindex]->mmap_offset,
280	arg);
281	}
5c055266	282	case RING_BUFFER_FLUSH:
5e391252	283	lib_ring_buffer_switch_remote(buf);
5c055266	284	return 0;
f3bc08c5 MD	285	default:
	286	return -ENOIOCTLCMD;
	287	}
	288	}
d83004aa JD	289	EXPORT_SYMBOL_GPL(lib_ring_buffer_ioctl);
	290
	291	/**
	292	* vfs_lib_ring_buffer_ioctl - control ring buffer reader synchronization
	293	*
	294	* @filp: the file
	295	* @cmd: the command
	296	* @arg: command arg
	297	*
	298	* This ioctl implements commands necessary for producer/consumer
	299	* and flight recorder reader interaction :
	300	* RING_BUFFER_GET_NEXT_SUBBUF
	301	* Get the next sub-buffer that can be read. It never blocks.
	302	* RING_BUFFER_PUT_NEXT_SUBBUF
	303	* Release the currently read sub-buffer.
	304	* RING_BUFFER_GET_SUBBUF_SIZE
	305	* returns the size of the current sub-buffer.
	306	* RING_BUFFER_GET_MAX_SUBBUF_SIZE
	307	* returns the maximum size for sub-buffers.
	308	* RING_BUFFER_GET_NUM_SUBBUF
	309	* returns the number of reader-visible sub-buffers in the per cpu
	310	* channel (for mmap).
	311	* RING_BUFFER_GET_MMAP_READ_OFFSET
	312	* returns the offset of the subbuffer belonging to the reader.
	313	* Should only be used for mmap clients.
	314	*/
	315	static
	316	long vfs_lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	317	{
	318	struct lib_ring_buffer *buf = filp->private_data;
	319
	320	return lib_ring_buffer_ioctl(filp, cmd, arg, buf);
	321	}
f3bc08c5 MD	322
	323	#ifdef CONFIG_COMPAT
	324	long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
d83004aa	325	unsigned long arg, struct lib_ring_buffer *buf)
f3bc08c5	326	{
f3bc08c5	327	struct channel *chan = buf->backend.chan;
5a8fd222	328	const struct lib_ring_buffer_config *config = &chan->backend.config;
254ec7bc MD	329
	330	if (lib_ring_buffer_channel_is_disabled(chan))
	331	return -EIO;
f3bc08c5 MD	332
f3bc08c5 MD	333	switch (cmd) {
216f7feb	334	case RING_BUFFER_COMPAT_SNAPSHOT:
7cf44d03 MD	335	/*
	336	* First, ensure we perform a "final" flush onto the
	337	* stream. This will ensure we create a packet of
	338	* padding if we encounter an empty packet. This ensures
	339	* the time-stamps right before the snapshot is used as
	340	* end of packet timestamp.
	341	*/
	342	if (!buf->quiescent)
	343	lib_ring_buffer_switch_remote_empty(buf);
f3bc08c5 MD	344	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
f3bc08c5 MD	345	&buf->prod_snapshot);
4dce5a48 JG	346	case RING_BUFFER_COMPAT_SNAPSHOT_SAMPLE_POSITIONS:
	347	return lib_ring_buffer_snapshot_sample_positions(buf,
	348	&buf->cons_snapshot, &buf->prod_snapshot);
216f7feb	349	case RING_BUFFER_COMPAT_SNAPSHOT_GET_CONSUMED:
f3bc08c5	350	return compat_put_ulong(buf->cons_snapshot, arg);
216f7feb	351	case RING_BUFFER_COMPAT_SNAPSHOT_GET_PRODUCED:
f3bc08c5	352	return compat_put_ulong(buf->prod_snapshot, arg);
216f7feb	353	case RING_BUFFER_COMPAT_GET_SUBBUF:
f3bc08c5 MD	354	{
	355	__u32 uconsume;
	356	unsigned long consume;
	357	long ret;
	358
	359	ret = get_user(uconsume, (__u32 __user *) arg);
	360	if (ret)
	361	return ret; /* will return -EFAULT */
	362	consume = buf->cons_snapshot;
	363	consume &= ~0xFFFFFFFFL;
	364	consume \|= uconsume;
	365	ret = lib_ring_buffer_get_subbuf(buf, consume);
	366	if (!ret) {
	367	/* Set file position to zero at each successful "get" */
	368	filp->f_pos = 0;
	369	}
	370	return ret;
	371	}
216f7feb	372	case RING_BUFFER_COMPAT_PUT_SUBBUF:
f3bc08c5 MD	373	lib_ring_buffer_put_subbuf(buf);
	374	return 0;
	375
216f7feb	376	case RING_BUFFER_COMPAT_GET_NEXT_SUBBUF:
f3bc08c5 MD	377	{
	378	long ret;
	379
	380	ret = lib_ring_buffer_get_next_subbuf(buf);
	381	if (!ret) {
	382	/* Set file position to zero at each successful "get" */
	383	filp->f_pos = 0;
	384	}
	385	return ret;
	386	}
216f7feb	387	case RING_BUFFER_COMPAT_PUT_NEXT_SUBBUF:
f3bc08c5 MD	388	lib_ring_buffer_put_next_subbuf(buf);
f3bc08c5 MD	389	return 0;
216f7feb	390	case RING_BUFFER_COMPAT_GET_SUBBUF_SIZE:
f3bc08c5 MD	391	{
	392	unsigned long data_size;
	393
	394	data_size = lib_ring_buffer_get_read_data_size(config, buf);
	395	if (data_size > UINT_MAX)
	396	return -EFBIG;
4343ec8e	397	return compat_put_ulong(data_size, arg);
f3bc08c5	398	}
216f7feb	399	case RING_BUFFER_COMPAT_GET_PADDED_SUBBUF_SIZE:
f3bc08c5 MD	400	{
	401	unsigned long size;
	402
	403	size = lib_ring_buffer_get_read_data_size(config, buf);
	404	size = PAGE_ALIGN(size);
	405	if (size > UINT_MAX)
	406	return -EFBIG;
4343ec8e	407	return compat_put_ulong(size, arg);
f3bc08c5	408	}
216f7feb	409	case RING_BUFFER_COMPAT_GET_MAX_SUBBUF_SIZE:
f3bc08c5 MD	410	if (chan->backend.subbuf_size > UINT_MAX)
f3bc08c5 MD	411	return -EFBIG;
4343ec8e	412	return compat_put_ulong(chan->backend.subbuf_size, arg);
216f7feb	413	case RING_BUFFER_COMPAT_GET_MMAP_LEN:
f3bc08c5 MD	414	{
	415	unsigned long mmap_buf_len;
	416
	417	if (config->output != RING_BUFFER_MMAP)
	418	return -EINVAL;
	419	mmap_buf_len = chan->backend.buf_size;
	420	if (chan->backend.extra_reader_sb)
	421	mmap_buf_len += chan->backend.subbuf_size;
	422	if (mmap_buf_len > UINT_MAX)
	423	return -EFBIG;
4343ec8e	424	return compat_put_ulong(mmap_buf_len, arg);
f3bc08c5	425	}
216f7feb	426	case RING_BUFFER_COMPAT_GET_MMAP_READ_OFFSET:
f3bc08c5 MD	427	{
	428	unsigned long sb_bindex, read_offset;
	429
	430	if (config->output != RING_BUFFER_MMAP)
	431	return -EINVAL;
	432	sb_bindex = subbuffer_id_get_index(config,
	433	buf->backend.buf_rsb.id);
	434	read_offset = buf->backend.array[sb_bindex]->mmap_offset;
	435	if (read_offset > UINT_MAX)
	436	return -EINVAL;
4343ec8e	437	return compat_put_ulong(read_offset, arg);
f3bc08c5	438	}
216f7feb	439	case RING_BUFFER_COMPAT_FLUSH:
5e391252	440	lib_ring_buffer_switch_remote(buf);
5c055266	441	return 0;
f3bc08c5 MD	442	default:
	443	return -ENOIOCTLCMD;
	444	}
	445	}
d83004aa JD	446	EXPORT_SYMBOL_GPL(lib_ring_buffer_compat_ioctl);
	447
	448	static
	449	long vfs_lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
	450	unsigned long arg)
	451	{
	452	struct lib_ring_buffer *buf = filp->private_data;
	453
	454	return lib_ring_buffer_compat_ioctl(filp, cmd, arg, buf);
	455	}
f3bc08c5 MD	456	#endif
	457
	458	const struct file_operations lib_ring_buffer_file_operations = {
a33c9927	459	.owner = THIS_MODULE,
d83004aa JD	460	.open = vfs_lib_ring_buffer_open,
	461	.release = vfs_lib_ring_buffer_release,
	462	.poll = vfs_lib_ring_buffer_poll,
	463	.splice_read = vfs_lib_ring_buffer_splice_read,
	464	.mmap = vfs_lib_ring_buffer_mmap,
	465	.unlocked_ioctl = vfs_lib_ring_buffer_ioctl,
	466	.llseek = vfs_lib_ring_buffer_no_llseek,
f3bc08c5	467	#ifdef CONFIG_COMPAT
d83004aa	468	.compat_ioctl = vfs_lib_ring_buffer_compat_ioctl,
f3bc08c5 MD	469	#endif
	470	};
	471	EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);
	472
	473	MODULE_LICENSE("GPL and additional rights");
	474	MODULE_AUTHOR("Mathieu Desnoyers");
	475	MODULE_DESCRIPTION("Ring Buffer Library VFS");
13ab8b0a MD	476	MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
	477	__stringify(LTTNG_MODULES_MINOR_VERSION) "."
	478	__stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
	479	LTTNG_MODULES_EXTRAVERSION);