4 * Copyright (C) 2009-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6 * Ring Buffer VFS file operations.
8 * Dual LGPL v2.1/GPL v2 license.
11 #include <linux/module.h>
13 #include <linux/compat.h>
15 #include "../../wrapper/ringbuffer/backend.h"
16 #include "../../wrapper/ringbuffer/frontend.h"
17 #include "../../wrapper/ringbuffer/vfs.h"
18 #include "../../wrapper/poll.h"
20 static int put_ulong(unsigned long val
, unsigned long arg
)
22 return put_user(val
, (unsigned long __user
*)arg
);
26 static int compat_put_ulong(compat_ulong_t val
, unsigned long arg
)
28 return put_user(val
, (compat_ulong_t __user
*)compat_ptr(arg
));
33 * lib_ring_buffer_open - ring buffer open file operation
34 * @inode: opened inode
37 * Open implementation. Makes sure only one open instance of a buffer is
38 * done at a given moment.
40 int lib_ring_buffer_open(struct inode
*inode
, struct file
*file
)
42 struct lib_ring_buffer
*buf
= inode
->i_private
;
45 ret
= lib_ring_buffer_open_read(buf
);
49 file
->private_data
= buf
;
50 ret
= nonseekable_open(inode
, file
);
56 lib_ring_buffer_release_read(buf
);
61 * lib_ring_buffer_release - ring buffer release file operation
62 * @inode: opened inode
65 * Release implementation.
67 int lib_ring_buffer_release(struct inode
*inode
, struct file
*file
)
69 struct lib_ring_buffer
*buf
= file
->private_data
;
71 lib_ring_buffer_release_read(buf
);
77 * lib_ring_buffer_poll - ring buffer poll file operation
81 * Poll implementation.
83 unsigned int lib_ring_buffer_poll(struct file
*filp
, poll_table
*wait
)
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
;
91 if (filp
->f_mode
& FMODE_READ
) {
92 init_poll_funcptr(wait
, wrapper_pollwait_exclusive
);
93 poll_wait(filp
, &buf
->read_wait
, wait
);
95 finalized
= lib_ring_buffer_is_finalized(config
, buf
);
97 * lib_ring_buffer_is_finalized() contains a smp_rmb() ordering
98 * finalized load before offsets loads.
100 WARN_ON(atomic_long_read(&buf
->active_readers
) != 1);
102 if (subbuf_trunc(lib_ring_buffer_get_offset(config
, buf
), chan
)
103 - subbuf_trunc(lib_ring_buffer_get_consumed(config
, buf
), chan
)
109 * The memory barriers
110 * __wait_event()/wake_up_interruptible() take
111 * care of "raw_spin_is_locked" memory ordering.
113 if (raw_spin_is_locked(&buf
->raw_tick_nohz_spinlock
))
119 if (subbuf_trunc(lib_ring_buffer_get_offset(config
, buf
),
121 - subbuf_trunc(lib_ring_buffer_get_consumed(config
, buf
),
123 >= chan
->backend
.buf_size
)
124 return POLLPRI
| POLLRDBAND
;
126 return POLLIN
| POLLRDNORM
;
133 * lib_ring_buffer_ioctl - control ring buffer reader synchronization
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.
156 long lib_ring_buffer_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
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
;
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
:
172 unsigned long uconsume
;
175 ret
= get_user(uconsume
, (unsigned long __user
*) arg
);
177 return ret
; /* will return -EFAULT */
178 ret
= lib_ring_buffer_get_subbuf(buf
, uconsume
);
180 /* Set file position to zero at each successful "get" */
185 case RING_BUFFER_PUT_SUBBUF
:
186 lib_ring_buffer_put_subbuf(buf
);
189 case RING_BUFFER_GET_NEXT_SUBBUF
:
193 ret
= lib_ring_buffer_get_next_subbuf(buf
);
195 /* Set file position to zero at each successful "get" */
200 case RING_BUFFER_PUT_NEXT_SUBBUF
:
201 lib_ring_buffer_put_next_subbuf(buf
);
203 case RING_BUFFER_GET_SUBBUF_SIZE
:
204 return put_ulong(lib_ring_buffer_get_read_data_size(config
, buf
),
206 case RING_BUFFER_GET_PADDED_SUBBUF_SIZE
:
210 size
= lib_ring_buffer_get_read_data_size(config
, buf
);
211 size
= PAGE_ALIGN(size
);
212 return put_ulong(size
, arg
);
214 case RING_BUFFER_GET_MAX_SUBBUF_SIZE
:
215 return put_ulong(chan
->backend
.subbuf_size
, arg
);
216 case RING_BUFFER_GET_MMAP_LEN
:
218 unsigned long mmap_buf_len
;
220 if (config
->output
!= RING_BUFFER_MMAP
)
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
)
227 return put_ulong(mmap_buf_len
, arg
);
229 case RING_BUFFER_GET_MMAP_READ_OFFSET
:
231 unsigned long sb_bindex
;
233 if (config
->output
!= RING_BUFFER_MMAP
)
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
,
246 long lib_ring_buffer_compat_ioctl(struct file
*filp
, unsigned int cmd
,
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
;
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
:
264 unsigned long consume
;
267 ret
= get_user(uconsume
, (__u32 __user
*) arg
);
269 return ret
; /* will return -EFAULT */
270 consume
= buf
->cons_snapshot
;
271 consume
&= ~0xFFFFFFFFL
;
273 ret
= lib_ring_buffer_get_subbuf(buf
, consume
);
275 /* Set file position to zero at each successful "get" */
280 case RING_BUFFER_PUT_SUBBUF
:
281 lib_ring_buffer_put_subbuf(buf
);
284 case RING_BUFFER_GET_NEXT_SUBBUF
:
288 ret
= lib_ring_buffer_get_next_subbuf(buf
);
290 /* Set file position to zero at each successful "get" */
295 case RING_BUFFER_PUT_NEXT_SUBBUF
:
296 lib_ring_buffer_put_next_subbuf(buf
);
298 case RING_BUFFER_GET_SUBBUF_SIZE
:
300 unsigned long data_size
;
302 data_size
= lib_ring_buffer_get_read_data_size(config
, buf
);
303 if (data_size
> UINT_MAX
)
305 return put_ulong(data_size
, arg
);
307 case RING_BUFFER_GET_PADDED_SUBBUF_SIZE
:
311 size
= lib_ring_buffer_get_read_data_size(config
, buf
);
312 size
= PAGE_ALIGN(size
);
315 return put_ulong(size
, arg
);
317 case RING_BUFFER_GET_MAX_SUBBUF_SIZE
:
318 if (chan
->backend
.subbuf_size
> UINT_MAX
)
320 return put_ulong(chan
->backend
.subbuf_size
, arg
);
321 case RING_BUFFER_GET_MMAP_LEN
:
323 unsigned long mmap_buf_len
;
325 if (config
->output
!= RING_BUFFER_MMAP
)
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
)
332 return put_ulong(mmap_buf_len
, arg
);
334 case RING_BUFFER_GET_MMAP_READ_OFFSET
:
336 unsigned long sb_bindex
, read_offset
;
338 if (config
->output
!= RING_BUFFER_MMAP
)
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
)
345 return put_ulong(read_offset
, arg
);
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
,
362 .compat_ioctl
= lib_ring_buffer_compat_ioctl
,
365 EXPORT_SYMBOL_GPL(lib_ring_buffer_file_operations
);
367 MODULE_LICENSE("GPL and additional rights");
368 MODULE_AUTHOR("Mathieu Desnoyers");
369 MODULE_DESCRIPTION("Ring Buffer Library VFS");