[lttng-ust.git] / libringbuffer / ring_buffer_abi.c

/*
 * ring_buffer_abi.c
 *
 * Copyright (C) 2009-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Ring Buffer VFS file 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
852c2936	1	/*
9f3fdbc6	2	* ring_buffer_abi.c
852c2936 MD	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
4931a13e MD	11	#include "backend.h"
4931a13e MD	12	#include "frontend.h"
9f3fdbc6	13	#include <ust/ring-buffer-abi.h>
852c2936 MD	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	}
529b552a	243	case RING_BUFFER_FLUSH:
1d498196	244	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, handle);
529b552a	245	return 0;
852c2936 MD	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	}
529b552a	356	case RING_BUFFER_FLUSH:
1d498196	357	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, handle);
529b552a	358	return 0;
852c2936 MD	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	};