[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;

	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);
		/*
		 * 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 (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;

	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;

	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;
89	int finalized;
90
91	if (filp->f_mode & FMODE_READ) {
92	poll_wait_set_exclusive(wait);
93	poll_wait(filp, &buf->read_wait, wait);
94
95	finalized = lib_ring_buffer_is_finalized(config, buf);
96	/*
97	* lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
98	* finalized load before offsets loads.
99	*/
100	WARN_ON(atomic_long_read(&buf->active_readers) != 1);
101	retry:
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	switch (cmd) {
163	case RING_BUFFER_SNAPSHOT:
164	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
165	&buf->prod_snapshot);
166	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
167	return put_ulong(buf->cons_snapshot, arg);
168	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
169	return put_ulong(buf->prod_snapshot, arg);
170	case RING_BUFFER_GET_SUBBUF:
171	{
172	unsigned long uconsume;
173	long ret;
174
175	ret = get_user(uconsume, (unsigned long __user *) arg);
176	if (ret)
177	return ret; /* will return -EFAULT */
178	ret = lib_ring_buffer_get_subbuf(buf, uconsume);
179	if (!ret) {
180	/* Set file position to zero at each successful "get" */
181	filp->f_pos = 0;
182	}
183	return ret;
184	}
185	case RING_BUFFER_PUT_SUBBUF:
186	lib_ring_buffer_put_subbuf(buf);
187	return 0;
188
189	case RING_BUFFER_GET_NEXT_SUBBUF:
190	{
191	long ret;
192
193	ret = lib_ring_buffer_get_next_subbuf(buf);
194	if (!ret) {
195	/* Set file position to zero at each successful "get" */
196	filp->f_pos = 0;
197	}
198	return ret;
199	}
200	case RING_BUFFER_PUT_NEXT_SUBBUF:
201	lib_ring_buffer_put_next_subbuf(buf);
202	return 0;
203	case RING_BUFFER_GET_SUBBUF_SIZE:
204	return put_ulong(lib_ring_buffer_get_read_data_size(config, buf),
205	arg);
206	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
207	{
208	unsigned long size;
209
210	size = lib_ring_buffer_get_read_data_size(config, buf);
211	size = PAGE_ALIGN(size);
212	return put_ulong(size, arg);
213	}
214	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
215	return put_ulong(chan->backend.subbuf_size, arg);
216	case RING_BUFFER_GET_MMAP_LEN:
217	{
218	unsigned long mmap_buf_len;
219
220	if (config->output != RING_BUFFER_MMAP)
221	return -EINVAL;
222	mmap_buf_len = chan->backend.buf_size;
223	if (chan->backend.extra_reader_sb)
224	mmap_buf_len += chan->backend.subbuf_size;
225	if (mmap_buf_len > INT_MAX)
226	return -EFBIG;
227	return put_ulong(mmap_buf_len, arg);
228	}
229	case RING_BUFFER_GET_MMAP_READ_OFFSET:
230	{
231	unsigned long sb_bindex;
232
233	if (config->output != RING_BUFFER_MMAP)
234	return -EINVAL;
235	sb_bindex = subbuffer_id_get_index(config,
236	buf->backend.buf_rsb.id);
237	return put_ulong(buf->backend.array[sb_bindex]->mmap_offset,
238	arg);
239	}
240	default:
241	return -ENOIOCTLCMD;
242	}
243	}
244
245	#ifdef CONFIG_COMPAT
246	long lib_ring_buffer_compat_ioctl(struct file *filp, unsigned int cmd,
247	unsigned long arg)
248	{
249	struct lib_ring_buffer *buf = filp->private_data;
250	struct channel *chan = buf->backend.chan;
251	const struct lib_ring_buffer_config *config = chan->backend.config;
252
253	switch (cmd) {
254	case RING_BUFFER_SNAPSHOT:
255	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
256	&buf->prod_snapshot);
257	case RING_BUFFER_SNAPSHOT_GET_CONSUMED:
258	return compat_put_ulong(buf->cons_snapshot, arg);
259	case RING_BUFFER_SNAPSHOT_GET_PRODUCED:
260	return compat_put_ulong(buf->prod_snapshot, arg);
261	case RING_BUFFER_GET_SUBBUF:
262	{
263	__u32 uconsume;
264	unsigned long consume;
265	long ret;
266
267	ret = get_user(uconsume, (__u32 __user *) arg);
268	if (ret)
269	return ret; /* will return -EFAULT */
270	consume = buf->cons_snapshot;
271	consume &= ~0xFFFFFFFFL;
272	consume \|= uconsume;
273	ret = lib_ring_buffer_get_subbuf(buf, consume);
274	if (!ret) {
275	/* Set file position to zero at each successful "get" */
276	filp->f_pos = 0;
277	}
278	return ret;
279	}
280	case RING_BUFFER_PUT_SUBBUF:
281	lib_ring_buffer_put_subbuf(buf);
282	return 0;
283
284	case RING_BUFFER_GET_NEXT_SUBBUF:
285	{
286	long ret;
287
288	ret = lib_ring_buffer_get_next_subbuf(buf);
289	if (!ret) {
290	/* Set file position to zero at each successful "get" */
291	filp->f_pos = 0;
292	}
293	return ret;
294	}
295	case RING_BUFFER_PUT_NEXT_SUBBUF:
296	lib_ring_buffer_put_next_subbuf(buf);
297	return 0;
298	case RING_BUFFER_GET_SUBBUF_SIZE:
299	{
300	unsigned long data_size;
301
302	data_size = lib_ring_buffer_get_read_data_size(config, buf);
303	if (data_size > UINT_MAX)
304	return -EFBIG;
305	return put_ulong(data_size, arg);
306	}
307	case RING_BUFFER_GET_PADDED_SUBBUF_SIZE:
308	{
309	unsigned long size;
310
311	size = lib_ring_buffer_get_read_data_size(config, buf);
312	size = PAGE_ALIGN(size);
313	if (size > UINT_MAX)
314	return -EFBIG;
315	return put_ulong(size, arg);
316	}
317	case RING_BUFFER_GET_MAX_SUBBUF_SIZE:
318	if (chan->backend.subbuf_size > UINT_MAX)
319	return -EFBIG;
320	return put_ulong(chan->backend.subbuf_size, arg);
321	case RING_BUFFER_GET_MMAP_LEN:
322	{
323	unsigned long mmap_buf_len;
324
325	if (config->output != RING_BUFFER_MMAP)
326	return -EINVAL;
327	mmap_buf_len = chan->backend.buf_size;
328	if (chan->backend.extra_reader_sb)
329	mmap_buf_len += chan->backend.subbuf_size;
330	if (mmap_buf_len > UINT_MAX)
331	return -EFBIG;
332	return put_ulong(mmap_buf_len, arg);
333	}
334	case RING_BUFFER_GET_MMAP_READ_OFFSET:
335	{
336	unsigned long sb_bindex, read_offset;
337
338	if (config->output != RING_BUFFER_MMAP)
339	return -EINVAL;
340	sb_bindex = subbuffer_id_get_index(config,
341	buf->backend.buf_rsb.id);
342	read_offset = buf->backend.array[sb_bindex]->mmap_offset;
343	if (read_offset > UINT_MAX)
344	return -EINVAL;
345	return put_ulong(read_offset, arg);
346	}
347	default:
348	return -ENOIOCTLCMD;
349	}
350	}
351	#endif
352
353	const struct file_operations lib_ring_buffer_file_operations = {
354	.open = lib_ring_buffer_open,
355	.release = lib_ring_buffer_release,
356	.poll = lib_ring_buffer_poll,
357	.splice_read = lib_ring_buffer_splice_read,
358	.mmap = lib_ring_buffer_mmap,
359	.unlocked_ioctl = lib_ring_buffer_ioctl,
360	.llseek = lib_ring_buffer_no_llseek,
361	#ifdef CONFIG_COMPAT
362	.compat_ioctl = lib_ring_buffer_compat_ioctl,
363	#endif
364	};
365	EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations);
366
367	MODULE_LICENSE("GPL and additional rights");
368	MODULE_AUTHOR("Mathieu Desnoyers");
369	MODULE_DESCRIPTION("Ring Buffer Library VFS");