Write context fields into trace
[lttng-modules.git] / ltt-ring-buffer-client.h
CommitLineData
7514523f 1/*
3d084699 2 * ltt-ring-buffer-client.h
7514523f
MD
3 *
4 * Copyright (C) 2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 *
3d084699 6 * LTTng lib ring buffer client template.
7514523f
MD
7 *
8 * Dual LGPL v2.1/GPL v2 license.
9 */
10
11#include <linux/module.h>
c0e31d2e 12#include <linux/types.h>
9115fbdc 13#include "lib/bitfield.h"
b13f3ebe 14#include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */
f3bc08c5 15#include "wrapper/trace-clock.h"
c0e31d2e 16#include "ltt-events.h"
7514523f 17#include "ltt-tracer.h"
9115fbdc 18#include "wrapper/ringbuffer/frontend_types.h"
7514523f 19
d793d5e1
MD
20/*
21 * Keep the natural field alignment for _each field_ within this structure if
22 * you ever add/remove a field from this header. Packed attribute is not used
23 * because gcc generates poor code on at least powerpc and mips. Don't ever
24 * let gcc add padding between the structure elements.
25 */
9115fbdc 26
d793d5e1 27struct packet_header {
9115fbdc 28 /* Trace packet header */
d793d5e1
MD
29 uint32_t magic; /*
30 * Trace magic number.
31 * contains endianness information.
32 */
1ec3f75a 33 uint8_t uuid[16];
d793d5e1 34 uint32_t stream_id;
9115fbdc
MD
35
36 struct {
37 /* Stream packet context */
38 uint64_t timestamp_begin; /* Cycle count at subbuffer start */
39 uint64_t timestamp_end; /* Cycle count at subbuffer end */
40 uint32_t events_discarded; /*
41 * Events lost in this subbuffer since
42 * the beginning of the trace.
43 * (may overflow)
44 */
45 uint32_t content_size; /* Size of data in subbuffer */
46 uint32_t packet_size; /* Subbuffer size (include padding) */
47 uint32_t cpu_id; /* CPU id associated with stream */
48 uint8_t header_end; /* End of header */
49 } ctx;
d793d5e1
MD
50};
51
52
881833e3
MD
53static inline notrace u64 lib_ring_buffer_clock_read(struct channel *chan)
54{
55 return trace_clock_read64();
56}
57
f1676205
MD
58static inline
59size_t ctx_get_size(size_t offset, struct lttng_ctx *ctx)
60{
61 int i;
62 size_t orig_offset = offset;
63
64 if (likely(!ctx))
65 return 0;
66 for (i = 0; i < ctx->nr_fields; i++)
67 offset += ctx->fields[i].get_size(offset);
68 return offset - orig_offset;
69}
70
71static inline
72void ctx_record(struct lib_ring_buffer_ctx *bufctx,
73 struct ltt_channel *chan,
74 struct lttng_ctx *ctx)
75{
76 int i;
77
78 if (likely(!ctx))
79 return;
80 for (i = 0; i < ctx->nr_fields; i++)
81 ctx->fields[i].record(&ctx->fields[i], bufctx, chan);
82}
83
881833e3
MD
84/*
85 * record_header_size - Calculate the header size and padding necessary.
86 * @config: ring buffer instance configuration
87 * @chan: channel
88 * @offset: offset in the write buffer
881833e3 89 * @pre_header_padding: padding to add before the header (output)
881833e3
MD
90 * @ctx: reservation context
91 *
92 * Returns the event header size (including padding).
93 *
881833e3
MD
94 * The payload must itself determine its own alignment from the biggest type it
95 * contains.
96 */
97static __inline__
98unsigned char record_header_size(const struct lib_ring_buffer_config *config,
99 struct channel *chan, size_t offset,
64c796d8 100 size_t *pre_header_padding,
881833e3
MD
101 struct lib_ring_buffer_ctx *ctx)
102{
9115fbdc 103 struct ltt_channel *ltt_chan = channel_get_private(chan);
f1676205 104 struct ltt_event *event = ctx->priv;
881833e3
MD
105 size_t orig_offset = offset;
106 size_t padding;
107
9115fbdc
MD
108 switch (ltt_chan->header_type) {
109 case 1: /* compact */
110 padding = lib_ring_buffer_align(offset, ltt_alignof(uint32_t));
111 offset += padding;
64c796d8 112 if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTT_RFLAG_EXTENDED))) {
9115fbdc
MD
113 offset += sizeof(uint32_t); /* id and timestamp */
114 } else {
115 /* Minimum space taken by 5-bit id */
116 offset += sizeof(uint8_t);
117 /* Align extended struct on largest member */
118 offset += lib_ring_buffer_align(offset, ltt_alignof(uint64_t));
119 offset += sizeof(uint32_t); /* id */
120 offset += lib_ring_buffer_align(offset, ltt_alignof(uint64_t));
121 offset += sizeof(uint64_t); /* timestamp */
122 }
123 break;
124 case 2: /* large */
125 padding = lib_ring_buffer_align(offset, ltt_alignof(uint16_t));
126 offset += padding;
127 offset += sizeof(uint16_t);
64c796d8 128 if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTT_RFLAG_EXTENDED))) {
9115fbdc
MD
129 offset += lib_ring_buffer_align(offset, ltt_alignof(uint32_t));
130 offset += sizeof(uint32_t); /* timestamp */
131 } else {
132 /* Align extended struct on largest member */
133 offset += lib_ring_buffer_align(offset, ltt_alignof(uint64_t));
134 offset += sizeof(uint32_t); /* id */
135 offset += lib_ring_buffer_align(offset, ltt_alignof(uint64_t));
136 offset += sizeof(uint64_t); /* timestamp */
137
881833e3 138 }
9115fbdc
MD
139 break;
140 default:
64c796d8 141 WARN_ON_ONCE(1);
881833e3 142 }
f1676205
MD
143 offset += ctx_get_size(offset, event->ctx);
144 offset += ctx_get_size(offset, ltt_chan->ctx);
145 offset += ctx_get_size(offset, ltt_chan->session->ctx);
881833e3
MD
146
147 *pre_header_padding = padding;
148 return offset - orig_offset;
149}
150
151#include "wrapper/ringbuffer/api.h"
152
153extern
154void ltt_write_event_header_slow(const struct lib_ring_buffer_config *config,
155 struct lib_ring_buffer_ctx *ctx,
64c796d8 156 uint32_t event_id);
881833e3
MD
157
158/*
159 * ltt_write_event_header
160 *
161 * Writes the event header to the offset (already aligned on 32-bits).
162 *
163 * @config: ring buffer instance configuration
164 * @ctx: reservation context
4e1f08f4 165 * @event_id: event ID
881833e3
MD
166 */
167static __inline__
168void ltt_write_event_header(const struct lib_ring_buffer_config *config,
169 struct lib_ring_buffer_ctx *ctx,
64c796d8 170 uint32_t event_id)
881833e3 171{
9115fbdc 172 struct ltt_channel *ltt_chan = channel_get_private(ctx->chan);
f1676205 173 struct ltt_event *event = ctx->priv;
881833e3
MD
174
175 if (unlikely(ctx->rflags))
176 goto slow_path;
177
9115fbdc
MD
178 switch (ltt_chan->header_type) {
179 case 1: /* compact */
180 {
181 uint32_t id_time = 0;
182
4e1f08f4 183 bt_bitfield_write(&id_time, uint32_t, 0, 5, event_id);
9115fbdc
MD
184 bt_bitfield_write(&id_time, uint32_t, 5, 27, ctx->tsc);
185 lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time));
186 break;
187 }
188 case 2: /* large */
189 {
9115fbdc
MD
190 uint32_t timestamp = (uint32_t) ctx->tsc;
191
192 lib_ring_buffer_write(config, ctx, &event_id, sizeof(event_id));
193 lib_ring_buffer_align_ctx(ctx, ltt_alignof(uint32_t));
194 lib_ring_buffer_write(config, ctx, &timestamp, sizeof(timestamp));
195 break;
196 }
197 default:
64c796d8 198 WARN_ON_ONCE(1);
9115fbdc 199 }
f1676205
MD
200
201 ctx_record(ctx, ltt_chan, event->ctx);
202 ctx_record(ctx, ltt_chan, ltt_chan->ctx);
203 ctx_record(ctx, ltt_chan, ltt_chan->session->ctx);
204
9115fbdc 205 return;
881833e3
MD
206
207slow_path:
4e1f08f4 208 ltt_write_event_header_slow(config, ctx, event_id);
881833e3
MD
209}
210
881833e3 211void ltt_write_event_header_slow(const struct lib_ring_buffer_config *config,
64c796d8
MD
212 struct lib_ring_buffer_ctx *ctx,
213 uint32_t event_id)
881833e3 214{
9115fbdc 215 struct ltt_channel *ltt_chan = channel_get_private(ctx->chan);
f1676205 216 struct ltt_event *event = ctx->priv;
9115fbdc
MD
217
218 switch (ltt_chan->header_type) {
219 case 1: /* compact */
64c796d8 220 if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTT_RFLAG_EXTENDED))) {
9115fbdc
MD
221 uint32_t id_time = 0;
222
4e1f08f4 223 bt_bitfield_write(&id_time, uint32_t, 0, 5, event_id);
9115fbdc
MD
224 bt_bitfield_write(&id_time, uint32_t, 5, 27, ctx->tsc);
225 lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time));
226 } else {
227 uint8_t id = 0;
9115fbdc
MD
228 uint64_t timestamp = ctx->tsc;
229
230 bt_bitfield_write(&id, uint8_t, 0, 5, 31);
231 lib_ring_buffer_write(config, ctx, &id, sizeof(id));
232 /* Align extended struct on largest member */
233 lib_ring_buffer_align_ctx(ctx, ltt_alignof(uint64_t));
234 lib_ring_buffer_write(config, ctx, &event_id, sizeof(event_id));
235 lib_ring_buffer_align_ctx(ctx, ltt_alignof(uint64_t));
236 lib_ring_buffer_write(config, ctx, &timestamp, sizeof(timestamp));
237 }
881833e3 238 break;
9115fbdc
MD
239 case 2: /* large */
240 {
64c796d8 241 if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTT_RFLAG_EXTENDED))) {
9115fbdc
MD
242 uint32_t timestamp = (uint32_t) ctx->tsc;
243
244 lib_ring_buffer_write(config, ctx, &event_id, sizeof(event_id));
245 lib_ring_buffer_align_ctx(ctx, ltt_alignof(uint32_t));
246 lib_ring_buffer_write(config, ctx, &timestamp, sizeof(timestamp));
247 } else {
64c796d8 248 uint16_t id = 65535;
9115fbdc
MD
249 uint64_t timestamp = ctx->tsc;
250
64c796d8 251 lib_ring_buffer_write(config, ctx, &id, sizeof(id));
9115fbdc
MD
252 /* Align extended struct on largest member */
253 lib_ring_buffer_align_ctx(ctx, ltt_alignof(uint64_t));
64c796d8 254 lib_ring_buffer_write(config, ctx, &event_id, sizeof(event_id));
9115fbdc
MD
255 lib_ring_buffer_align_ctx(ctx, ltt_alignof(uint64_t));
256 lib_ring_buffer_write(config, ctx, &timestamp, sizeof(timestamp));
257 }
881833e3 258 break;
881833e3 259 }
9115fbdc 260 default:
64c796d8 261 WARN_ON_ONCE(1);
881833e3 262 }
f1676205
MD
263 ctx_record(ctx, ltt_chan, event->ctx);
264 ctx_record(ctx, ltt_chan, ltt_chan->ctx);
265 ctx_record(ctx, ltt_chan, ltt_chan->session->ctx);
881833e3
MD
266}
267
7514523f
MD
268static const struct lib_ring_buffer_config client_config;
269
270static u64 client_ring_buffer_clock_read(struct channel *chan)
271{
272 return lib_ring_buffer_clock_read(chan);
273}
274
1e2015dc 275static
7514523f
MD
276size_t client_record_header_size(const struct lib_ring_buffer_config *config,
277 struct channel *chan, size_t offset,
7514523f 278 size_t *pre_header_padding,
7514523f
MD
279 struct lib_ring_buffer_ctx *ctx)
280{
64c796d8
MD
281 return record_header_size(config, chan, offset,
282 pre_header_padding, ctx);
7514523f
MD
283}
284
285/**
1c25284c 286 * client_packet_header_size - called on buffer-switch to a new sub-buffer
7514523f
MD
287 *
288 * Return header size without padding after the structure. Don't use packed
289 * structure because gcc generates inefficient code on some architectures
290 * (powerpc, mips..)
291 */
1c25284c 292static size_t client_packet_header_size(void)
7514523f 293{
9115fbdc 294 return offsetof(struct packet_header, ctx.header_end);
7514523f
MD
295}
296
297static void client_buffer_begin(struct lib_ring_buffer *buf, u64 tsc,
298 unsigned int subbuf_idx)
299{
300 struct channel *chan = buf->backend.chan;
1c25284c
MD
301 struct packet_header *header =
302 (struct packet_header *)
7514523f
MD
303 lib_ring_buffer_offset_address(&buf->backend,
304 subbuf_idx * chan->backend.subbuf_size);
9115fbdc
MD
305 struct ltt_channel *ltt_chan = channel_get_private(chan);
306 struct ltt_session *session = ltt_chan->session;
7514523f 307
d793d5e1 308 header->magic = CTF_MAGIC_NUMBER;
1ec3f75a 309 memcpy(header->uuid, session->uuid.b, sizeof(session->uuid));
9115fbdc
MD
310 header->stream_id = ltt_chan->id;
311 header->ctx.timestamp_begin = tsc;
312 header->ctx.timestamp_end = 0;
313 header->ctx.events_discarded = 0;
314 header->ctx.content_size = 0xFFFFFFFF; /* for debugging */
315 header->ctx.packet_size = 0xFFFFFFFF;
316 header->ctx.cpu_id = buf->backend.cpu;
7514523f
MD
317}
318
319/*
320 * offset is assumed to never be 0 here : never deliver a completely empty
321 * subbuffer. data_size is between 1 and subbuf_size.
322 */
323static void client_buffer_end(struct lib_ring_buffer *buf, u64 tsc,
324 unsigned int subbuf_idx, unsigned long data_size)
325{
326 struct channel *chan = buf->backend.chan;
1c25284c
MD
327 struct packet_header *header =
328 (struct packet_header *)
7514523f
MD
329 lib_ring_buffer_offset_address(&buf->backend,
330 subbuf_idx * chan->backend.subbuf_size);
331 unsigned long records_lost = 0;
332
9115fbdc 333 header->ctx.timestamp_end = tsc;
05d32c64
MD
334 header->ctx.content_size = data_size * CHAR_BIT; /* in bits */
335 header->ctx.packet_size = PAGE_ALIGN(data_size) * CHAR_BIT; /* in bits */
7514523f
MD
336 records_lost += lib_ring_buffer_get_records_lost_full(&client_config, buf);
337 records_lost += lib_ring_buffer_get_records_lost_wrap(&client_config, buf);
338 records_lost += lib_ring_buffer_get_records_lost_big(&client_config, buf);
9115fbdc 339 header->ctx.events_discarded = records_lost;
7514523f
MD
340}
341
342static int client_buffer_create(struct lib_ring_buffer *buf, void *priv,
343 int cpu, const char *name)
344{
1c25284c 345 return 0;
7514523f
MD
346}
347
348static void client_buffer_finalize(struct lib_ring_buffer *buf, void *priv, int cpu)
349{
7514523f
MD
350}
351
352static const struct lib_ring_buffer_config client_config = {
353 .cb.ring_buffer_clock_read = client_ring_buffer_clock_read,
354 .cb.record_header_size = client_record_header_size,
1c25284c 355 .cb.subbuffer_header_size = client_packet_header_size,
7514523f
MD
356 .cb.buffer_begin = client_buffer_begin,
357 .cb.buffer_end = client_buffer_end,
358 .cb.buffer_create = client_buffer_create,
359 .cb.buffer_finalize = client_buffer_finalize,
360
361 .tsc_bits = 32,
362 .alloc = RING_BUFFER_ALLOC_PER_CPU,
363 .sync = RING_BUFFER_SYNC_PER_CPU,
3d084699 364 .mode = RING_BUFFER_MODE_TEMPLATE,
7514523f
MD
365 .backend = RING_BUFFER_PAGE,
366 .output = RING_BUFFER_SPLICE,
367 .oops = RING_BUFFER_OOPS_CONSISTENCY,
368 .ipi = RING_BUFFER_IPI_BARRIER,
369 .wakeup = RING_BUFFER_WAKEUP_BY_TIMER,
370};
371
1e2015dc 372static
1c25284c 373struct channel *_channel_create(const char *name,
9115fbdc 374 struct ltt_channel *ltt_chan, void *buf_addr,
1c25284c
MD
375 size_t subbuf_size, size_t num_subbuf,
376 unsigned int switch_timer_interval,
377 unsigned int read_timer_interval)
7514523f 378{
9115fbdc 379 return channel_create(&client_config, name, ltt_chan, buf_addr,
7514523f
MD
380 subbuf_size, num_subbuf, switch_timer_interval,
381 read_timer_interval);
7514523f
MD
382}
383
1e2015dc 384static
7514523f
MD
385void ltt_channel_destroy(struct channel *chan)
386{
7514523f 387 channel_destroy(chan);
7514523f
MD
388}
389
ad1c05e1
MD
390static
391struct lib_ring_buffer *ltt_buffer_read_open(struct channel *chan)
392{
393 struct lib_ring_buffer *buf;
394 int cpu;
395
1c25284c
MD
396 for_each_channel_cpu(cpu, chan) {
397 buf = channel_get_ring_buffer(&client_config, chan, cpu);
ad1c05e1
MD
398 if (!lib_ring_buffer_open_read(buf))
399 return buf;
400 }
401 return NULL;
402}
403
404static
1c25284c 405void ltt_buffer_read_close(struct lib_ring_buffer *buf)
ad1c05e1
MD
406{
407 lib_ring_buffer_release_read(buf);
1c25284c
MD
408
409}
410
c099397a 411static
4e1f08f4 412int ltt_event_reserve(struct lib_ring_buffer_ctx *ctx,
64c796d8 413 uint32_t event_id)
1c25284c 414{
64c796d8 415 struct ltt_channel *ltt_chan = channel_get_private(ctx->chan);
1c25284c
MD
416 int ret, cpu;
417
418 cpu = lib_ring_buffer_get_cpu(&client_config);
419 if (cpu < 0)
420 return -EPERM;
421 ctx->cpu = cpu;
422
64c796d8
MD
423 switch (ltt_chan->header_type) {
424 case 1: /* compact */
425 if (event_id > 30)
426 ctx->rflags |= LTT_RFLAG_EXTENDED;
427 break;
428 case 2: /* large */
429 if (event_id > 65534)
430 ctx->rflags |= LTT_RFLAG_EXTENDED;
431 break;
432 default:
433 WARN_ON_ONCE(1);
434 }
435
1c25284c
MD
436 ret = lib_ring_buffer_reserve(&client_config, ctx);
437 if (ret)
438 goto put;
4e1f08f4
MD
439 ltt_write_event_header(&client_config, ctx, event_id);
440 return 0;
1c25284c
MD
441put:
442 lib_ring_buffer_put_cpu(&client_config);
443 return ret;
ad1c05e1
MD
444}
445
c099397a 446static
1c25284c
MD
447void ltt_event_commit(struct lib_ring_buffer_ctx *ctx)
448{
449 lib_ring_buffer_commit(&client_config, ctx);
450 lib_ring_buffer_put_cpu(&client_config);
451}
452
c099397a 453static
e763dbf5
MD
454void ltt_event_write(struct lib_ring_buffer_ctx *ctx, const void *src,
455 size_t len)
456{
457 lib_ring_buffer_write(&client_config, ctx, src, len);
458}
1c25284c 459
c099397a
MD
460static
461wait_queue_head_t *ltt_get_reader_wait_queue(struct ltt_channel *chan)
462{
463 return &chan->chan->read_wait;
464}
465
7514523f 466static struct ltt_transport ltt_relay_transport = {
3d084699 467 .name = "relay-" RING_BUFFER_MODE_TEMPLATE_STRING,
7514523f
MD
468 .owner = THIS_MODULE,
469 .ops = {
1c25284c
MD
470 .channel_create = _channel_create,
471 .channel_destroy = ltt_channel_destroy,
ad1c05e1
MD
472 .buffer_read_open = ltt_buffer_read_open,
473 .buffer_read_close = ltt_buffer_read_close,
1c25284c
MD
474 .event_reserve = ltt_event_reserve,
475 .event_commit = ltt_event_commit,
e763dbf5 476 .event_write = ltt_event_write,
1ec3f75a 477 .packet_avail_size = NULL, /* Would be racy anyway */
c099397a 478 .get_reader_wait_queue = ltt_get_reader_wait_queue,
7514523f
MD
479 },
480};
481
3d084699 482static int __init ltt_ring_buffer_client_init(void)
7514523f 483{
a509e133
MD
484 /*
485 * This vmalloc sync all also takes care of the lib ring buffer
486 * vmalloc'd module pages when it is built as a module into LTTng.
487 */
6d2a620c 488 wrapper_vmalloc_sync_all();
7514523f
MD
489 printk(KERN_INFO "LTT : ltt ring buffer client init\n");
490 ltt_transport_register(&ltt_relay_transport);
491 return 0;
492}
493
1c25284c
MD
494module_init(ltt_ring_buffer_client_init);
495
3d084699 496static void __exit ltt_ring_buffer_client_exit(void)
7514523f
MD
497{
498 printk(KERN_INFO "LTT : ltt ring buffer client exit\n");
499 ltt_transport_unregister(&ltt_relay_transport);
500}
501
1c25284c
MD
502module_exit(ltt_ring_buffer_client_exit);
503
7514523f
MD
504MODULE_LICENSE("GPL and additional rights");
505MODULE_AUTHOR("Mathieu Desnoyers");
3d084699
MD
506MODULE_DESCRIPTION("LTTng ring buffer " RING_BUFFER_MODE_TEMPLATE_STRING
507 " client");
This page took 0.046922 seconds and 4 git commands to generate.