1 #ifndef _LIB_RING_BUFFER_BACKEND_H
2 #define _LIB_RING_BUFFER_BACKEND_H
5 * lib/ringbuffer/backend.h
7 * Ring buffer backend (API).
9 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; only
14 * version 2.1 of the License.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * Credits to Steven Rostedt for proposing to use an extra-subbuffer owned by
26 * the reader in flight recorder mode.
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/timer.h>
32 #include <linux/wait.h>
33 #include <linux/poll.h>
34 #include <linux/list.h>
38 /* Internal helpers */
39 #include "../../wrapper/ringbuffer/backend_internal.h"
40 #include "../../wrapper/ringbuffer/frontend_internal.h"
42 /* Ring buffer backend API */
44 /* Ring buffer backend access (read/write) */
46 extern size_t lib_ring_buffer_read(struct lib_ring_buffer_backend
*bufb
,
47 size_t offset
, void *dest
, size_t len
);
49 extern int __lib_ring_buffer_copy_to_user(struct lib_ring_buffer_backend
*bufb
,
50 size_t offset
, void __user
*dest
,
53 extern int lib_ring_buffer_read_cstr(struct lib_ring_buffer_backend
*bufb
,
54 size_t offset
, void *dest
, size_t len
);
57 lib_ring_buffer_read_get_page(struct lib_ring_buffer_backend
*bufb
, size_t offset
,
61 * Return the address where a given offset is located.
62 * Should be used to get the current subbuffer header pointer. Given we know
63 * it's never on a page boundary, it's safe to write directly to this address,
64 * as long as the write is never bigger than a page size.
67 lib_ring_buffer_offset_address(struct lib_ring_buffer_backend
*bufb
,
70 lib_ring_buffer_read_offset_address(struct lib_ring_buffer_backend
*bufb
,
74 * lib_ring_buffer_write - write data to a buffer backend
75 * @config : ring buffer instance configuration
76 * @ctx: ring buffer context. (input arguments only)
77 * @src : source pointer to copy from
78 * @len : length of data to copy
80 * This function copies "len" bytes of data from a source pointer to a buffer
81 * backend, at the current context offset. This is more or less a buffer
82 * backend-specific memcpy() operation. Calls the slow path (_ring_buffer_write)
83 * if copy is crossing a page boundary.
86 void lib_ring_buffer_write(const struct lib_ring_buffer_config
*config
,
87 struct lib_ring_buffer_ctx
*ctx
,
88 const void *src
, size_t len
)
90 struct lib_ring_buffer_backend
*bufb
= &ctx
->buf
->backend
;
91 struct channel_backend
*chanb
= &ctx
->chan
->backend
;
93 size_t offset
= ctx
->buf_offset
;
95 struct lib_ring_buffer_backend_pages
*rpages
;
96 unsigned long sb_bindex
, id
;
98 offset
&= chanb
->buf_size
- 1;
99 sbidx
= offset
>> chanb
->subbuf_size_order
;
100 index
= (offset
& (chanb
->subbuf_size
- 1)) >> PAGE_SHIFT
;
101 pagecpy
= min_t(size_t, len
, (-offset
) & ~PAGE_MASK
);
102 id
= bufb
->buf_wsb
[sbidx
].id
;
103 sb_bindex
= subbuffer_id_get_index(config
, id
);
104 rpages
= bufb
->array
[sb_bindex
];
105 CHAN_WARN_ON(ctx
->chan
,
106 config
->mode
== RING_BUFFER_OVERWRITE
107 && subbuffer_id_is_noref(config
, id
));
108 if (likely(pagecpy
== len
))
109 lib_ring_buffer_do_copy(config
,
110 rpages
->p
[index
].virt
111 + (offset
& ~PAGE_MASK
),
114 _lib_ring_buffer_write(bufb
, offset
, src
, len
, 0);
115 ctx
->buf_offset
+= len
;
119 * lib_ring_buffer_memset - write len bytes of c to a buffer backend
120 * @config : ring buffer instance configuration
121 * @bufb : ring buffer backend
122 * @offset : offset within the buffer
123 * @c : the byte to copy
124 * @len : number of bytes to copy
126 * This function writes "len" bytes of "c" to a buffer backend, at a specific
127 * offset. This is more or less a buffer backend-specific memset() operation.
128 * Calls the slow path (_ring_buffer_memset) if write is crossing a page
132 void lib_ring_buffer_memset(const struct lib_ring_buffer_config
*config
,
133 struct lib_ring_buffer_ctx
*ctx
, int c
, size_t len
)
136 struct lib_ring_buffer_backend
*bufb
= &ctx
->buf
->backend
;
137 struct channel_backend
*chanb
= &ctx
->chan
->backend
;
139 size_t offset
= ctx
->buf_offset
;
141 struct lib_ring_buffer_backend_pages
*rpages
;
142 unsigned long sb_bindex
, id
;
144 offset
&= chanb
->buf_size
- 1;
145 sbidx
= offset
>> chanb
->subbuf_size_order
;
146 index
= (offset
& (chanb
->subbuf_size
- 1)) >> PAGE_SHIFT
;
147 pagecpy
= min_t(size_t, len
, (-offset
) & ~PAGE_MASK
);
148 id
= bufb
->buf_wsb
[sbidx
].id
;
149 sb_bindex
= subbuffer_id_get_index(config
, id
);
150 rpages
= bufb
->array
[sb_bindex
];
151 CHAN_WARN_ON(ctx
->chan
,
152 config
->mode
== RING_BUFFER_OVERWRITE
153 && subbuffer_id_is_noref(config
, id
));
154 if (likely(pagecpy
== len
))
155 lib_ring_buffer_do_memset(rpages
->p
[index
].virt
156 + (offset
& ~PAGE_MASK
),
159 _lib_ring_buffer_memset(bufb
, offset
, c
, len
, 0);
160 ctx
->buf_offset
+= len
;
164 * lib_ring_buffer_copy_from_user - write userspace data to a buffer backend
165 * @config : ring buffer instance configuration
166 * @ctx: ring buffer context. (input arguments only)
167 * @src : userspace source pointer to copy from
168 * @len : length of data to copy
170 * This function copies "len" bytes of data from a userspace pointer to a
171 * buffer backend, at the current context offset. This is more or less a buffer
172 * backend-specific memcpy() operation. Calls the slow path
173 * (_ring_buffer_write_from_user) if copy is crossing a page boundary.
176 void lib_ring_buffer_copy_from_user(const struct lib_ring_buffer_config
*config
,
177 struct lib_ring_buffer_ctx
*ctx
,
178 const void __user
*src
, size_t len
)
180 struct lib_ring_buffer_backend
*bufb
= &ctx
->buf
->backend
;
181 struct channel_backend
*chanb
= &ctx
->chan
->backend
;
183 size_t offset
= ctx
->buf_offset
;
185 struct lib_ring_buffer_backend_pages
*rpages
;
186 unsigned long sb_bindex
, id
;
189 offset
&= chanb
->buf_size
- 1;
190 sbidx
= offset
>> chanb
->subbuf_size_order
;
191 index
= (offset
& (chanb
->subbuf_size
- 1)) >> PAGE_SHIFT
;
192 pagecpy
= min_t(size_t, len
, (-offset
) & ~PAGE_MASK
);
193 id
= bufb
->buf_wsb
[sbidx
].id
;
194 sb_bindex
= subbuffer_id_get_index(config
, id
);
195 rpages
= bufb
->array
[sb_bindex
];
196 CHAN_WARN_ON(ctx
->chan
,
197 config
->mode
== RING_BUFFER_OVERWRITE
198 && subbuffer_id_is_noref(config
, id
));
200 if (unlikely(!access_ok(VERIFY_READ
, src
, len
)))
203 if (likely(pagecpy
== len
)) {
204 ret
= lib_ring_buffer_do_copy_from_user(
205 rpages
->p
[index
].virt
+ (offset
& ~PAGE_MASK
),
207 if (unlikely(ret
> 0)) {
208 len
-= (pagecpy
- ret
);
209 offset
+= (pagecpy
- ret
);
213 _lib_ring_buffer_copy_from_user(bufb
, offset
, src
, len
, 0);
215 ctx
->buf_offset
+= len
;
221 * In the error path we call the slow path version to avoid
222 * the pollution of static inline code.
224 _lib_ring_buffer_memset(bufb
, offset
, 0, len
, 0);
228 * This accessor counts the number of unread records in a buffer.
229 * It only provides a consistent value if no reads not writes are performed
233 unsigned long lib_ring_buffer_get_records_unread(
234 const struct lib_ring_buffer_config
*config
,
235 struct lib_ring_buffer
*buf
)
237 struct lib_ring_buffer_backend
*bufb
= &buf
->backend
;
238 struct lib_ring_buffer_backend_pages
*pages
;
239 unsigned long records_unread
= 0, sb_bindex
, id
;
242 for (i
= 0; i
< bufb
->chan
->backend
.num_subbuf
; i
++) {
243 id
= bufb
->buf_wsb
[i
].id
;
244 sb_bindex
= subbuffer_id_get_index(config
, id
);
245 pages
= bufb
->array
[sb_bindex
];
246 records_unread
+= v_read(config
, &pages
->records_unread
);
248 if (config
->mode
== RING_BUFFER_OVERWRITE
) {
249 id
= bufb
->buf_rsb
.id
;
250 sb_bindex
= subbuffer_id_get_index(config
, id
);
251 pages
= bufb
->array
[sb_bindex
];
252 records_unread
+= v_read(config
, &pages
->records_unread
);
254 return records_unread
;
257 ssize_t
lib_ring_buffer_file_splice_read(struct file
*in
, loff_t
*ppos
,
258 struct pipe_inode_info
*pipe
,
259 size_t len
, unsigned int flags
);
260 loff_t
lib_ring_buffer_no_llseek(struct file
*file
, loff_t offset
, int origin
);
262 #endif /* _LIB_RING_BUFFER_BACKEND_H */