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

/*
 * ring_buffer_vfs.c
 *
 * Copyright (C) 2009-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Ring Buffer VFS file operations.
 *
 * Dual LGPL v2.1/GPL v2 license.
 */

#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

/**
 *	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.
 */
int lib_ring_buffer_open(struct inode *inode, struct file *file)
{
	struct lib_ring_buffer *buf = inode->i_private;
	int ret;

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

	file->private_data = buf;
	ret = nonseekable_open(inode, file);
	if (ret)
		goto release_read;
	return 0;

release_read:
	lib_ring_buffer_release_read(buf);
	return ret;
}

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

	lib_ring_buffer_release_read(buf);

	return 0;
}

/**
 *	lib_ring_buffer_poll - ring buffer poll file operation
 *	@filp: the file
 *	@wait: poll table
 *
 *	Poll implementation.
 */
unsigned int lib_ring_buffer_poll(struct file *filp, poll_table *wait)
{
	unsigned int mask = 0;
	struct lib_ring_buffer *buf = filp->private_data;
	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;
}

/**
 *	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.
 */
long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct lib_ring_buffer *buf = filp->private_data;
	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);
	}
	default:
		return -ENOIOCTLCMD;
	}
}

#ifdef CONFIG_COMPAT
long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
				  unsigned long arg)
{
	struct lib_ring_buffer *buf = filp->private_data;
	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 compat_put_ulong(buf->cons_snapshot, arg);
	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
		return compat_put_ulong(buf->prod_snapshot, arg);
	case RING_BUFFER_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_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:
	{
		unsigned long data_size;

		data_size = lib_ring_buffer_get_read_data_size(config, buf);
		if (data_size > UINT_MAX)
			return -EFBIG;
		return put_ulong(data_size, 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);
		if (size > UINT_MAX)
			return -EFBIG;
		return put_ulong(size, arg);
	}
	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
		if (chan->backend.subbuf_size > UINT_MAX)
			return -EFBIG;
		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 > UINT_MAX)
			return -EFBIG;
		return put_ulong(mmap_buf_len, arg);
	}
	case RING_BUFFER_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 put_ulong(read_offset, arg);
	}
	default:
		return -ENOIOCTLCMD;
	}
}
#endif

const struct file_operations lib_ring_buffer_file_operations = {
	.open = lib_ring_buffer_open,
	.release = lib_ring_buffer_release,
	.poll = lib_ring_buffer_poll,
	.splice_read = lib_ring_buffer_splice_read,
	.mmap = lib_ring_buffer_mmap,
	.unlocked_ioctl = lib_ring_buffer_ioctl,
	.llseek = lib_ring_buffer_no_llseek,
#ifdef CONFIG_COMPAT
	.compat_ioctl = 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	*
	4	* Copyright (C) 2009-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	5	*
	6	* Ring Buffer VFS file operations.
	7	*
	8	* Dual LGPL v2.1/GPL v2 license.
	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/fs.h>
	13	#include <linux/compat.h>
	14
	15	#include "../../wrapper/ringbuffer/backend.h"
	16	#include "../../wrapper/ringbuffer/frontend.h"
	17	#include "../../wrapper/ringbuffer/vfs.h"
	18	#include "../../wrapper/poll.h"
	19
	20	static int put_ulong(unsigned long val, unsigned long arg)
	21	{
	22	return put_user(val, (unsigned long __user *)arg);
	23	}
	24
	25	#ifdef CONFIG_COMPAT
	26	static int compat_put_ulong(compat_ulong_t val, unsigned long arg)
	27	{
	28	return put_user(val, (compat_ulong_t __user *)compat_ptr(arg));
	29	}
	30	#endif
	31
	32	/**
	33	* lib_ring_buffer_open - ring buffer open file operation
	34	* @inode: opened inode
	35	* @file: opened file
	36	*
	37	* Open implementation. Makes sure only one open instance of a buffer is
	38	* done at a given moment.
	39	*/
	40	int lib_ring_buffer_open(struct inode inode, struct file file)
	41	{
	42	struct lib_ring_buffer *buf = inode->i_private;
	43	int ret;
	44
	45	ret = lib_ring_buffer_open_read(buf);
	46	if (ret)
	47	return ret;
	48
	49	file->private_data = buf;
	50	ret = nonseekable_open(inode, file);
	51	if (ret)
	52	goto release_read;
	53	return 0;
	54
	55	release_read:
	56	lib_ring_buffer_release_read(buf);
	57	return ret;
	58	}
	59
	60	/**
	61	* lib_ring_buffer_release - ring buffer release file operation
	62	* @inode: opened inode
	63	* @file: opened file
	64	*
65	* Release implementation.
66	*/
67	int lib_ring_buffer_release(struct inode inode, struct file file)
68	{
69	struct lib_ring_buffer *buf = file->private_data;
70
71	lib_ring_buffer_release_read(buf);
72
73	return 0;
74	}
75
76	/**
77	* lib_ring_buffer_poll - ring buffer poll file operation
78	* @filp: the file
79	* @wait: poll table
80	*
81	* Poll implementation.
82	*/
83	unsigned int lib_ring_buffer_poll(struct file filp, poll_table wait)
84	{
85	unsigned int mask = 0;
86	struct lib_ring_buffer *buf = filp->private_data;
87	struct channel *chan = buf->backend.chan;
88	const struct lib_ring_buffer_config *config = chan->backend.config;
254ec7bc	89	int finalized, disabled;
f3bc08c5 MD	90
f3bc08c5 MD	91	if (filp->f_mode & FMODE_READ) {
a33e44a6	92	poll_wait_set_exclusive(wait);
f3bc08c5 MD	93	poll_wait(filp, &buf->read_wait, wait);
	94
	95	finalized = lib_ring_buffer_is_finalized(config, buf);
254ec7bc MD	96	disabled = lib_ring_buffer_channel_is_disabled(chan);
254ec7bc MD	97
f3bc08c5 MD	98	/*
	99	* lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
	100	* finalized load before offsets loads.
	101	*/
	102	WARN_ON(atomic_long_read(&buf->active_readers) != 1);
	103	retry:
254ec7bc MD	104	if (disabled)
	105	return POLLERR;
	106
f3bc08c5 MD	107	if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf), chan)
	108	- subbuf_trunc(lib_ring_buffer_get_consumed(config, buf), chan)
	109	== 0) {
	110	if (finalized)
	111	return POLLHUP;
	112	else {
	113	/*
	114	* The memory barriers
	115	* __wait_event()/wake_up_interruptible() take
	116	* care of "raw_spin_is_locked" memory ordering.
	117	*/
	118	if (raw_spin_is_locked(&buf->raw_tick_nohz_spinlock))
	119	goto retry;
	120	else
	121	return 0;
	122	}
	123	} else {
	124	if (subbuf_trunc(lib_ring_buffer_get_offset(config, buf),
	125	chan)
	126	- subbuf_trunc(lib_ring_buffer_get_consumed(config, buf),
	127	chan)
	128	>= chan->backend.buf_size)
	129	return POLLPRI \| POLLRDBAND;
	130	else
	131	return POLLIN \| POLLRDNORM;
	132	}
	133	}
	134	return mask;
	135	}
	136
	137	/**
	138	* lib_ring_buffer_ioctl - control ring buffer reader synchronization
	139	*
	140	* @filp: the file
	141	* @cmd: the command
	142	* @arg: command arg
	143	*
	144	* This ioctl implements commands necessary for producer/consumer
	145	* and flight recorder reader interaction :
	146	* RING_BUFFER_GET_NEXT_SUBBUF
	147	* Get the next sub-buffer that can be read. It never blocks.
	148	* RING_BUFFER_PUT_NEXT_SUBBUF
	149	* Release the currently read sub-buffer.
	150	* RING_BUFFER_GET_SUBBUF_SIZE
	151	* returns the size of the current sub-buffer.
	152	* RING_BUFFER_GET_MAX_SUBBUF_SIZE
	153	* returns the maximum size for sub-buffers.
	154	* RING_BUFFER_GET_NUM_SUBBUF
	155	* returns the number of reader-visible sub-buffers in the per cpu
	156	* channel (for mmap).
	157	* RING_BUFFER_GET_MMAP_READ_OFFSET
	158	* returns the offset of the subbuffer belonging to the reader.
	159	* Should only be used for mmap clients.
	160	*/
	161	long lib_ring_buffer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	162	{
	163	struct lib_ring_buffer *buf = filp->private_data;
	164	struct channel *chan = buf->backend.chan;
	165	const struct lib_ring_buffer_config *config = chan->backend.config;
	166
254ec7bc MD	167	if (lib_ring_buffer_channel_is_disabled(chan))
	168	return -EIO;
	169
f3bc08c5 MD	170	switch (cmd) {
	171	case RING_BUFFER_SNAPSHOT:
	172	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
	173	&buf->prod_snapshot);
	174	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
	175	return put_ulong(buf->cons_snapshot, arg);
	176	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
	177	return put_ulong(buf->prod_snapshot, arg);
	178	case RING_BUFFER_GET_SUBBUF:
	179	{
	180	unsigned long uconsume;
	181	long ret;
	182
	183	ret = get_user(uconsume, (unsigned long __user *) arg);
	184	if (ret)
	185	return ret; /* will return -EFAULT */
	186	ret = lib_ring_buffer_get_subbuf(buf, uconsume);
	187	if (!ret) {
	188	/* Set file position to zero at each successful "get" */
	189	filp->f_pos = 0;
	190	}
	191	return ret;
	192	}
	193	case RING_BUFFER_PUT_SUBBUF:
	194	lib_ring_buffer_put_subbuf(buf);
	195	return 0;
	196
	197	case RING_BUFFER_GET_NEXT_SUBBUF:
	198	{
	199	long ret;
	200
	201	ret = lib_ring_buffer_get_next_subbuf(buf);
	202	if (!ret) {
	203	/* Set file position to zero at each successful "get" */
	204	filp->f_pos = 0;
	205	}
	206	return ret;
	207	}
	208	case RING_BUFFER_PUT_NEXT_SUBBUF:
	209	lib_ring_buffer_put_next_subbuf(buf);
	210	return 0;
	211	case RING_BUFFER_GET_SUBBUF_SIZE:
	212	return put_ulong(lib_ring_buffer_get_read_data_size(config, buf),
	213	arg);
	214	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
	215	{
	216	unsigned long size;
	217
	218	size = lib_ring_buffer_get_read_data_size(config, buf);
	219	size = PAGE_ALIGN(size);
	220	return put_ulong(size, arg);
	221	}
	222	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
	223	return put_ulong(chan->backend.subbuf_size, arg);
	224	case RING_BUFFER_GET_MMAP_LEN:
	225	{
	226	unsigned long mmap_buf_len;
	227
	228	if (config->output != RING_BUFFER_MMAP)
	229	return -EINVAL;
	230	mmap_buf_len = chan->backend.buf_size;
	231	if (chan->backend.extra_reader_sb)
	232	mmap_buf_len += chan->backend.subbuf_size;
	233	if (mmap_buf_len > INT_MAX)
234	return -EFBIG;
235	return put_ulong(mmap_buf_len, arg);
236	}
237	case RING_BUFFER_GET_MMAP_READ_OFFSET:
238	{
239	unsigned long sb_bindex;
240
241	if (config->output != RING_BUFFER_MMAP)
242	return -EINVAL;
243	sb_bindex = subbuffer_id_get_index(config,
244	buf->backend.buf_rsb.id);
245	return put_ulong(buf->backend.array[sb_bindex]->mmap_offset,
246	arg);
247	}
248	default:
249	return -ENOIOCTLCMD;
250	}
251	}
252
253	#ifdef CONFIG_COMPAT
254	long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
255	unsigned long arg)
256	{
257	struct lib_ring_buffer *buf = filp->private_data;
258	struct channel *chan = buf->backend.chan;
259	const struct lib_ring_buffer_config *config = chan->backend.config;
254ec7bc MD	260
	261	if (lib_ring_buffer_channel_is_disabled(chan))
	262	return -EIO;
f3bc08c5 MD	263
	264	switch (cmd) {
	265	case RING_BUFFER_SNAPSHOT:
	266	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
	267	&buf->prod_snapshot);
	268	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
	269	return compat_put_ulong(buf->cons_snapshot, arg);
	270	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
	271	return compat_put_ulong(buf->prod_snapshot, arg);
	272	case RING_BUFFER_GET_SUBBUF:
	273	{
	274	__u32 uconsume;
	275	unsigned long consume;
	276	long ret;
	277
	278	ret = get_user(uconsume, (__u32 __user *) arg);
	279	if (ret)
	280	return ret; /* will return -EFAULT */
	281	consume = buf->cons_snapshot;
	282	consume &= ~0xFFFFFFFFL;
	283	consume \|= uconsume;
	284	ret = lib_ring_buffer_get_subbuf(buf, consume);
	285	if (!ret) {
	286	/* Set file position to zero at each successful "get" */
	287	filp->f_pos = 0;
	288	}
	289	return ret;
	290	}
	291	case RING_BUFFER_PUT_SUBBUF:
	292	lib_ring_buffer_put_subbuf(buf);
	293	return 0;
	294
	295	case RING_BUFFER_GET_NEXT_SUBBUF:
	296	{
	297	long ret;
	298
	299	ret = lib_ring_buffer_get_next_subbuf(buf);
	300	if (!ret) {
	301	/* Set file position to zero at each successful "get" */
	302	filp->f_pos = 0;
	303	}
	304	return ret;
	305	}
	306	case RING_BUFFER_PUT_NEXT_SUBBUF:
	307	lib_ring_buffer_put_next_subbuf(buf);
	308	return 0;
	309	case RING_BUFFER_GET_SUBBUF_SIZE:
	310	{
	311	unsigned long data_size;
	312
	313	data_size = lib_ring_buffer_get_read_data_size(config, buf);
	314	if (data_size > UINT_MAX)
	315	return -EFBIG;
	316	return put_ulong(data_size, arg);
	317	}
	318	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
	319	{
	320	unsigned long size;
	321
	322	size = lib_ring_buffer_get_read_data_size(config, buf);
	323	size = PAGE_ALIGN(size);
	324	if (size > UINT_MAX)
	325	return -EFBIG;
	326	return put_ulong(size, arg);
327	}
328	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
329	if (chan->backend.subbuf_size > UINT_MAX)
330	return -EFBIG;
331	return put_ulong(chan->backend.subbuf_size, arg);
332	case RING_BUFFER_GET_MMAP_LEN:
333	{
334	unsigned long mmap_buf_len;
335
336	if (config->output != RING_BUFFER_MMAP)
337	return -EINVAL;
338	mmap_buf_len = chan->backend.buf_size;
339	if (chan->backend.extra_reader_sb)
340	mmap_buf_len += chan->backend.subbuf_size;
341	if (mmap_buf_len > UINT_MAX)
342	return -EFBIG;
343	return put_ulong(mmap_buf_len, arg);
344	}
345	case RING_BUFFER_GET_MMAP_READ_OFFSET:
346	{
347	unsigned long sb_bindex, read_offset;
348
349	if (config->output != RING_BUFFER_MMAP)
350	return -EINVAL;
351	sb_bindex = subbuffer_id_get_index(config,
352	buf->backend.buf_rsb.id);
353	read_offset = buf->backend.array[sb_bindex]->mmap_offset;
354	if (read_offset > UINT_MAX)
355	return -EINVAL;
356	return put_ulong(read_offset, arg);
357	}
358	default:
359	return -ENOIOCTLCMD;
360	}
361	}
362	#endif
363
364	const struct file_operations lib_ring_buffer_file_operations = {
365	.open = lib_ring_buffer_open,
366	.release = lib_ring_buffer_release,
367	.poll = lib_ring_buffer_poll,
368	.splice_read = lib_ring_buffer_splice_read,
369	.mmap = lib_ring_buffer_mmap,
370	.unlocked_ioctl = lib_ring_buffer_ioctl,
371	.llseek = lib_ring_buffer_no_llseek,
372	#ifdef CONFIG_COMPAT
373	.compat_ioctl = lib_ring_buffer_compat_ioctl,
374	#endif
375	};
376	EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);
377
378	MODULE_LICENSE("GPL and additional rights");
379	MODULE_AUTHOR("Mathieu Desnoyers");
380	MODULE_DESCRIPTION("Ring Buffer Library VFS");