[ust.git] / libringbuffer / ring_buffer_abi.c

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

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