[lttng-ust.git] / libringbuffer / 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 "backend.h"
#include "frontend.h"
#include "vfs.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
852c2936 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
4931a13e MD	11	#include "backend.h"
	12	#include "frontend.h"
	13	#include "vfs.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	}
243	default:
244	return -ENOIOCTLCMD;
245	}
246	}
247
248	#ifdef CONFIG_COMPAT
249	long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
250	unsigned long arg)
251	{
252	struct lib_ring_buffer *buf = filp->private_data;
253	struct channel *chan = buf->backend.chan;
254	const struct lib_ring_buffer_config *config = chan->backend.config;
255
256	if (lib_ring_buffer_channel_is_disabled(chan))
257	return -EIO;
258
259	switch (cmd) {
260	case RING_BUFFER_SNAPSHOT:
261	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
262	&buf->prod_snapshot);
263	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
264	return compat_put_ulong(buf->cons_snapshot, arg);
265	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
266	return compat_put_ulong(buf->prod_snapshot, arg);
267	case RING_BUFFER_GET_SUBBUF:
268	{
269	__u32 uconsume;
270	unsigned long consume;
271	long ret;
272
273	ret = get_user(uconsume, (__u32 __user *) arg);
274	if (ret)
275	return ret; /* will return -EFAULT */
276	consume = buf->cons_snapshot;
277	consume &= ~0xFFFFFFFFL;
278	consume \|= uconsume;
279	ret = lib_ring_buffer_get_subbuf(buf, consume);
280	if (!ret) {
281	/* Set file position to zero at each successful "get" */
282	filp->f_pos = 0;
283	}
284	return ret;
285	}
286	case RING_BUFFER_PUT_SUBBUF:
287	lib_ring_buffer_put_subbuf(buf);
288	return 0;
289
290	case RING_BUFFER_GET_NEXT_SUBBUF:
291	{
292	long ret;
293
294	ret = lib_ring_buffer_get_next_subbuf(buf);
295	if (!ret) {
296	/* Set file position to zero at each successful "get" */
297	filp->f_pos = 0;
298	}
299	return ret;
300	}
301	case RING_BUFFER_PUT_NEXT_SUBBUF:
302	lib_ring_buffer_put_next_subbuf(buf);
303	return 0;
304	case RING_BUFFER_GET_SUBBUF_SIZE:
305	{
306	unsigned long data_size;
307
308	data_size = lib_ring_buffer_get_read_data_size(config, buf);
309	if (data_size > UINT_MAX)
310	return -EFBIG;
311	return put_ulong(data_size, arg);
312	}
313	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
314	{
315	unsigned long size;
316
317	size = lib_ring_buffer_get_read_data_size(config, buf);
318	size = PAGE_ALIGN(size);
319	if (size > UINT_MAX)
320	return -EFBIG;
321	return put_ulong(size, arg);
322	}
323	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
324	if (chan->backend.subbuf_size > UINT_MAX)
325	return -EFBIG;
326	return put_ulong(chan->backend.subbuf_size, arg);
327	case RING_BUFFER_GET_MMAP_LEN:
328	{
329	unsigned long mmap_buf_len;
330
331	if (config->output != RING_BUFFER_MMAP)
332	return -EINVAL;
333	mmap_buf_len = chan->backend.buf_size;
334	if (chan->backend.extra_reader_sb)
335	mmap_buf_len += chan->backend.subbuf_size;
336	if (mmap_buf_len > UINT_MAX)
337	return -EFBIG;
338	return put_ulong(mmap_buf_len, arg);
339	}
340	case RING_BUFFER_GET_MMAP_READ_OFFSET:
341	{
342	unsigned long sb_bindex, read_offset;
343
344	if (config->output != RING_BUFFER_MMAP)
345	return -EINVAL;
346	sb_bindex = subbuffer_id_get_index(config,
347	buf->backend.buf_rsb.id);
348	read_offset = buf->backend.array[sb_bindex]->mmap_offset;
349	if (read_offset > UINT_MAX)
350	return -EINVAL;
351	return put_ulong(read_offset, arg);
352	}
353	default:
354	return -ENOIOCTLCMD;
355	}
356	}
357	#endif
358
359	const struct file_operations lib_ring_buffer_file_operations = {
360	.open = lib_ring_buffer_open,
361	.release = lib_ring_buffer_release,
362	.poll = lib_ring_buffer_poll,
363	.splice_read = lib_ring_buffer_splice_read,
364	.mmap = lib_ring_buffer_mmap,
365	.unlocked_ioctl = lib_ring_buffer_ioctl,
366	.llseek = lib_ring_buffer_no_llseek,
367	#ifdef CONFIG_COMPAT
368	.compat_ioctl = lib_ring_buffer_compat_ioctl,
369	#endif
370	};
371	EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);
372
373	MODULE_LICENSE("GPL and additional rights");
374	MODULE_AUTHOR("Mathieu Desnoyers");
375	MODULE_DESCRIPTION("Ring Buffer Library VFS");