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 lib_ring_buffer_read_get_page(struct lib_ring_buffer_backend
*bufb
, size_t offset
,
40 * Return the address where a given offset is located.
41 * Should be used to get the current subbuffer header pointer. Given we know
42 * it's never on a page boundary, it's safe to write directly to this address,
43 * as long as the write is never bigger than a page size.
46 lib_ring_buffer_offset_address(struct lib_ring_buffer_backend
*bufb
,
49 lib_ring_buffer_read_offset_address(struct lib_ring_buffer_backend
*bufb
,
53 * lib_ring_buffer_write - write data to a buffer backend
54 * @config : ring buffer instance configuration
55 * @ctx: ring buffer context. (input arguments only)
56 * @src : source pointer to copy from
57 * @len : length of data to copy
59 * This function copies "len" bytes of data from a source pointer to a buffer
60 * backend, at the current context offset. This is more or less a buffer
61 * backend-specific memcpy() operation. Calls the slow path (_ring_buffer_write)
62 * if copy is crossing a page boundary.
65 void lib_ring_buffer_write(const struct lib_ring_buffer_config
*config
,
66 struct lib_ring_buffer_ctx
*ctx
,
67 const void *src
, size_t len
)
69 struct lib_ring_buffer_backend
*bufb
= &ctx
->buf
->backend
;
70 struct channel_backend
*chanb
= &ctx
->chan
->backend
;
72 size_t offset
= ctx
->buf_offset
;
74 struct lib_ring_buffer_backend_pages
*rpages
;
75 unsigned long sb_bindex
, id
;
77 offset
&= chanb
->buf_size
- 1;
78 sbidx
= offset
>> chanb
->subbuf_size_order
;
79 index
= (offset
& (chanb
->subbuf_size
- 1)) >> get_count_order(PAGE_SIZE
);
80 pagecpy
= min_t(size_t, len
, (-offset
) & ~PAGE_MASK
);
81 id
= bufb
->buf_wsb
[sbidx
].id
;
82 sb_bindex
= subbuffer_id_get_index(config
, id
);
83 rpages
= bufb
->array
[sb_bindex
];
84 CHAN_WARN_ON(ctx
->chan
,
85 config
->mode
== RING_BUFFER_OVERWRITE
86 && subbuffer_id_is_noref(config
, id
));
87 if (likely(pagecpy
== len
))
88 lib_ring_buffer_do_copy(config
,
90 + (offset
& ~PAGE_MASK
),
93 _lib_ring_buffer_write(bufb
, offset
, src
, len
, 0);
94 ctx
->buf_offset
+= len
;
98 * This accessor counts the number of unread records in a buffer.
99 * It only provides a consistent value if no reads not writes are performed
103 unsigned long lib_ring_buffer_get_records_unread(
104 const struct lib_ring_buffer_config
*config
,
105 struct lib_ring_buffer
*buf
)
107 struct lib_ring_buffer_backend
*bufb
= &buf
->backend
;
108 struct lib_ring_buffer_backend_pages
*pages
;
109 unsigned long records_unread
= 0, sb_bindex
, id
;
112 for (i
= 0; i
< bufb
->chan
->backend
.num_subbuf
; i
++) {
113 id
= bufb
->buf_wsb
[i
].id
;
114 sb_bindex
= subbuffer_id_get_index(config
, id
);
115 pages
= bufb
->array
[sb_bindex
];
116 records_unread
+= v_read(config
, &pages
->records_unread
);
118 if (config
->mode
== RING_BUFFER_OVERWRITE
) {
119 id
= bufb
->buf_rsb
.id
;
120 sb_bindex
= subbuffer_id_get_index(config
, id
);
121 pages
= bufb
->array
[sb_bindex
];
122 records_unread
+= v_read(config
, &pages
->records_unread
);
124 return records_unread
;
127 #endif /* _LINUX_RING_BUFFER_BACKEND_H */