1 #ifndef _LINUX_RING_BUFFER_BACKEND_H
2 #define _LINUX_RING_BUFFER_BACKEND_H
5 * linux/ringbuffer/backend.h
7 * Copyright (C) 2008-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * Ring buffer backend (API).
11 * Dual LGPL v2.1/GPL v2 license.
13 * Credits to Steven Rostedt for proposing to use an extra-subbuffer owned by
14 * the reader in flight recorder mode.
21 /* Internal helpers */
22 #include "backend_internal.h"
23 #include "frontend_internal.h"
25 /* Ring buffer backend API */
27 /* Ring buffer backend access (read/write) */
29 extern size_t lib_ring_buffer_read(struct lib_ring_buffer_backend
*bufb
,
30 size_t offset
, void *dest
, size_t len
);
32 extern int lib_ring_buffer_read_cstr(struct lib_ring_buffer_backend
*bufb
,
33 size_t offset
, void *dest
, size_t len
);
36 * Return the address where a given offset is located.
37 * Should be used to get the current subbuffer header pointer. Given we know
38 * it's never on a page boundary, it's safe to write directly to this address,
39 * as long as the write is never bigger than a page size.
42 lib_ring_buffer_offset_address(struct lib_ring_buffer_backend
*bufb
,
45 lib_ring_buffer_read_offset_address(struct lib_ring_buffer_backend
*bufb
,
49 * lib_ring_buffer_write - write data to a buffer backend
50 * @config : ring buffer instance configuration
51 * @ctx: ring buffer context. (input arguments only)
52 * @src : source pointer to copy from
53 * @len : length of data to copy
55 * This function copies "len" bytes of data from a source pointer to a buffer
56 * backend, at the current context offset. This is more or less a buffer
57 * backend-specific memcpy() operation. Calls the slow path (_ring_buffer_write)
58 * if copy is crossing a page boundary.
61 void lib_ring_buffer_write(const struct lib_ring_buffer_config
*config
,
62 struct lib_ring_buffer_ctx
*ctx
,
63 const void *src
, size_t len
)
65 struct lib_ring_buffer_backend
*bufb
= &ctx
->buf
->backend
;
66 struct channel_backend
*chanb
= &ctx
->chan
->backend
;
68 size_t offset
= ctx
->buf_offset
;
69 struct lib_ring_buffer_backend_pages
*rpages
;
70 unsigned long sb_bindex
, id
;
72 offset
&= chanb
->buf_size
- 1;
73 sbidx
= offset
>> chanb
->subbuf_size_order
;
74 id
= shmp(bufb
->buf_wsb
)[sbidx
].id
;
75 sb_bindex
= subbuffer_id_get_index(config
, id
);
76 rpages
= shmp(bufb
->array
)[sb_bindex
];
77 CHAN_WARN_ON(ctx
->chan
,
78 config
->mode
== RING_BUFFER_OVERWRITE
79 && subbuffer_id_is_noref(config
, id
));
81 * Underlying layer should never ask for writes across
84 CHAN_WARN_ON(chanb
, offset
>= chanb
->buf_size
);
85 lib_ring_buffer_do_copy(config
,
86 shmp(rpages
->p
) + (offset
& ~(chanb
->subbuf_size
- 1)),
88 ctx
->buf_offset
+= len
;
92 * This accessor counts the number of unread records in a buffer.
93 * It only provides a consistent value if no reads not writes are performed
97 unsigned long lib_ring_buffer_get_records_unread(
98 const struct lib_ring_buffer_config
*config
,
99 struct lib_ring_buffer
*buf
)
101 struct lib_ring_buffer_backend
*bufb
= &buf
->backend
;
102 struct lib_ring_buffer_backend_pages
*pages
;
103 unsigned long records_unread
= 0, sb_bindex
, id
;
106 for (i
= 0; i
< shmp(bufb
->chan
)->backend
.num_subbuf
; i
++) {
107 id
= shmp(bufb
->buf_wsb
)[i
].id
;
108 sb_bindex
= subbuffer_id_get_index(config
, id
);
109 pages
= shmp(bufb
->array
)[sb_bindex
];
110 records_unread
+= v_read(config
, &pages
->records_unread
);
112 if (config
->mode
== RING_BUFFER_OVERWRITE
) {
113 id
= bufb
->buf_rsb
.id
;
114 sb_bindex
= subbuffer_id_get_index(config
, id
);
115 pages
= shmp(bufb
->array
)[sb_bindex
];
116 records_unread
+= v_read(config
, &pages
->records_unread
);
118 return records_unread
;
121 #endif /* _LINUX_RING_BUFFER_BACKEND_H */