projects / lttng-ust.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update loglevel selection ABI
[lttng-ust.git] / liblttng-ust / ltt-events.c
1 /*
2 * ltt-events.c
3 *
4 * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 *
6 * Holds LTTng per-session event registry.
7 *
8 * Dual LGPL v2.1/GPL v2 license.
9 */
10
11 #define _GNU_SOURCE
12 #include <stdio.h>
13 #include <endian.h>
14 #include <urcu/list.h>
15 #include <urcu/hlist.h>
16 #include <pthread.h>
17 #include <uuid/uuid.h>
18 #include <errno.h>
19 #include <sys/shm.h>
20 #include <sys/ipc.h>
21 #include <stdint.h>
22 #include <stddef.h>
23 #include <inttypes.h>
24 #include <time.h>
25 #include "clock.h"
26
27 #include <urcu-bp.h>
28 #include <urcu/compiler.h>
29 #include <urcu/uatomic.h>
30 #include <urcu/arch.h>
31
32 #include <lttng/tracepoint.h>
33 #include <lttng/ust-events.h>
34
35 #include <usterr-signal-safe.h>
36 #include <helper.h>
37 #include "error.h"
38
39 #include "ltt-tracer.h"
40 #include "ltt-tracer-core.h"
41 #include "wait.h"
42 #include "../libringbuffer/shm.h"
43 #include "jhash.h"
44
45 /*
46 * The sessions mutex is the centralized mutex across UST tracing
47 * control and probe registration. All operations within this file are
48 * called by the communication thread, under ust_lock protection.
49 */
50 static pthread_mutex_t sessions_mutex = PTHREAD_MUTEX_INITIALIZER;
51
52 void ust_lock(void)
53 {
54 pthread_mutex_lock(&sessions_mutex);
55 }
56
57 void ust_unlock(void)
58 {
59 pthread_mutex_unlock(&sessions_mutex);
60 }
61
62 static CDS_LIST_HEAD(sessions);
63
64 /*
65 * Pending probes hash table, containing the registered ltt events for
66 * which tracepoint probes are still missing. Protected by the sessions
67 * mutex.
68 */
69 #define PENDING_PROBE_HASH_BITS 6
70 #define PENDING_PROBE_HASH_SIZE (1 << PENDING_PROBE_HASH_BITS)
71 static struct cds_hlist_head pending_probe_table[PENDING_PROBE_HASH_SIZE];
72
73 struct ust_pending_probe {
74 struct ltt_event *event;
75 struct cds_hlist_node node;
76 char name[];
77 };
78
79 static void _ltt_event_destroy(struct ltt_event *event);
80 static void _ltt_loglevel_destroy(struct session_loglevel *sl);
81 static void _ltt_wildcard_destroy(struct session_wildcard *sw);
82 static void _ltt_channel_destroy(struct ltt_channel *chan);
83 static int _ltt_event_unregister(struct ltt_event *event);
84 static
85 int _ltt_event_metadata_statedump(struct ltt_session *session,
86 struct ltt_channel *chan,
87 struct ltt_event *event);
88 static
89 int _ltt_session_metadata_statedump(struct ltt_session *session);
90
91 /*
92 * called at event creation if probe is missing.
93 * called with session mutex held.
94 */
95 static
96 int add_pending_probe(struct ltt_event *event, const char *name)
97 {
98 struct cds_hlist_head *head;
99 struct ust_pending_probe *e;
100 size_t name_len = strlen(name);
101 uint32_t hash;
102
103 if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) {
104 WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_SYM_NAME_LEN - 1);
105 name_len = LTTNG_UST_SYM_NAME_LEN - 1;
106 }
107 hash = jhash(name, name_len, 0);
108 head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)];
109 e = zmalloc(sizeof(struct ust_pending_probe) + name_len);
110 if (!e)
111 return -ENOMEM;
112 memcpy(&e->name[0], name, name_len + 1);
113 e->name[name_len] = '\0';
114 cds_hlist_add_head(&e->node, head);
115 e->event = event;
116 event->pending_probe = e;
117 return 0;
118 }
119
120 /*
121 * remove a pending probe. called when at event teardown and when an
122 * event is fixed (probe is loaded).
123 * called with session mutex held.
124 */
125 static
126 void remove_pending_probe(struct ust_pending_probe *e)
127 {
128 if (!e)
129 return;
130 cds_hlist_del(&e->node);
131 free(e);
132 }
133
134 /*
135 * Called at library load: connect the probe on the events pending on
136 * probe load.
137 * called with session mutex held.
138 */
139 int pending_probe_fix_events(const struct lttng_event_desc *desc)
140 {
141 struct cds_hlist_head *head;
142 struct cds_hlist_node *node, *p;
143 struct ust_pending_probe *e;
144 const char *name = desc->name;
145 int ret = 0;
146 struct lttng_ust_event event_param;
147 size_t name_len = strlen(name);
148 uint32_t hash;
149
150 /*
151 * For this event, we need to lookup the loglevel. If active (in
152 * the active loglevels hash table), we must create the event.
153 */
154 if (desc->loglevel) {
155 const struct tracepoint_loglevel_entry *ev_ll;
156 struct loglevel_entry *loglevel;
157
158 ev_ll = *desc->loglevel;
159 loglevel = get_loglevel(ev_ll->identifier);
160 if (!loglevel)
161 loglevel = get_loglevel_value(ev_ll->value);
162 if (loglevel) {
163 struct session_loglevel *sl;
164
165 cds_list_for_each_entry(sl, &loglevel->session_list,
166 session_list) {
167 struct ltt_event *ev;
168 int ret;
169
170 memcpy(&event_param, &sl->event_param,
171 sizeof(event_param));
172 memcpy(event_param.name,
173 desc->name,
174 sizeof(event_param.name));
175 /* create event */
176 ret = ltt_event_create(sl->chan,
177 &event_param, NULL,
178 &ev);
179 if (ret) {
180 DBG("Error creating event");
181 continue;
182 }
183 cds_list_add(&ev->loglevel_list,
184 &sl->events);
185 }
186 }
187 }
188
189 /* Wildcard */
190 {
191 struct wildcard_entry *wildcard;
192
193 wildcard = match_wildcard(desc->name);
194 if (strcmp(desc->name, "lttng_ust:metadata") && wildcard) {
195 struct session_wildcard *sw;
196
197 cds_list_for_each_entry(sw, &wildcard->session_list,
198 session_list) {
199 struct ltt_event *ev;
200 int ret;
201
202 memcpy(&event_param, &sw->event_param,
203 sizeof(event_param));
204 memcpy(event_param.name,
205 desc->name,
206 sizeof(event_param.name));
207 /* create event */
208 ret = ltt_event_create(sw->chan,
209 &event_param, NULL,
210 &ev);
211 if (ret) {
212 DBG("Error creating event");
213 continue;
214 }
215 cds_list_add(&ev->wildcard_list,
216 &sw->events);
217 }
218 }
219 }
220
221 if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) {
222 WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_SYM_NAME_LEN - 1);
223 name_len = LTTNG_UST_SYM_NAME_LEN - 1;
224 }
225 hash = jhash(name, name_len, 0);
226 head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)];
227 cds_hlist_for_each_entry_safe(e, node, p, head, node) {
228 struct ltt_event *event;
229 struct ltt_channel *chan;
230
231 if (strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1))
232 continue;
233 event = e->event;
234 chan = event->chan;
235 assert(!event->desc);
236 event->desc = desc;
237 event->pending_probe = NULL;
238 remove_pending_probe(e);
239 ret |= __tracepoint_probe_register(name,
240 event->desc->probe_callback,
241 event);
242 if (ret)
243 continue;
244 event->id = chan->free_event_id++;
245 ret |= _ltt_event_metadata_statedump(chan->session, chan,
246 event);
247 }
248 return ret;
249 }
250
251 void synchronize_trace(void)
252 {
253 synchronize_rcu();
254 }
255
256 struct ltt_session *ltt_session_create(void)
257 {
258 struct ltt_session *session;
259
260 session = zmalloc(sizeof(struct ltt_session));
261 if (!session)
262 return NULL;
263 CDS_INIT_LIST_HEAD(&session->chan);
264 CDS_INIT_LIST_HEAD(&session->events);
265 CDS_INIT_LIST_HEAD(&session->loglevels);
266 CDS_INIT_LIST_HEAD(&session->wildcards);
267 uuid_generate(session->uuid);
268 cds_list_add(&session->list, &sessions);
269 return session;
270 }
271
272 void ltt_session_destroy(struct ltt_session *session)
273 {
274 struct ltt_channel *chan, *tmpchan;
275 struct ltt_event *event, *tmpevent;
276 struct session_loglevel *loglevel, *tmploglevel;
277 struct session_wildcard *wildcard, *tmpwildcard;
278 int ret;
279
280 CMM_ACCESS_ONCE(session->active) = 0;
281 cds_list_for_each_entry(event, &session->events, list) {
282 ret = _ltt_event_unregister(event);
283 WARN_ON(ret);
284 }
285 synchronize_trace(); /* Wait for in-flight events to complete */
286 cds_list_for_each_entry_safe(loglevel, tmploglevel, &session->loglevels, list)
287 _ltt_loglevel_destroy(loglevel);
288 cds_list_for_each_entry_safe(wildcard, tmpwildcard, &session->wildcards, list)
289 _ltt_wildcard_destroy(wildcard);
290 cds_list_for_each_entry_safe(event, tmpevent, &session->events, list)
291 _ltt_event_destroy(event);
292 cds_list_for_each_entry_safe(chan, tmpchan, &session->chan, list)
293 _ltt_channel_destroy(chan);
294 cds_list_del(&session->list);
295 free(session);
296 }
297
298 int ltt_session_enable(struct ltt_session *session)
299 {
300 int ret = 0;
301 struct ltt_channel *chan;
302
303 if (session->active) {
304 ret = -EBUSY;
305 goto end;
306 }
307
308 /*
309 * Snapshot the number of events per channel to know the type of header
310 * we need to use.
311 */
312 cds_list_for_each_entry(chan, &session->chan, list) {
313 if (chan->header_type)
314 continue; /* don't change it if session stop/restart */
315 if (chan->free_event_id < 31)
316 chan->header_type = 1; /* compact */
317 else
318 chan->header_type = 2; /* large */
319 }
320
321 CMM_ACCESS_ONCE(session->active) = 1;
322 CMM_ACCESS_ONCE(session->been_active) = 1;
323 ret = _ltt_session_metadata_statedump(session);
324 if (ret)
325 CMM_ACCESS_ONCE(session->active) = 0;
326 end:
327 return ret;
328 }
329
330 int ltt_session_disable(struct ltt_session *session)
331 {
332 int ret = 0;
333
334 if (!session->active) {
335 ret = -EBUSY;
336 goto end;
337 }
338 CMM_ACCESS_ONCE(session->active) = 0;
339 end:
340 return ret;
341 }
342
343 int ltt_channel_enable(struct ltt_channel *channel)
344 {
345 int old;
346
347 if (channel == channel->session->metadata)
348 return -EPERM;
349 old = uatomic_xchg(&channel->enabled, 1);
350 if (old)
351 return -EEXIST;
352 return 0;
353 }
354
355 int ltt_channel_disable(struct ltt_channel *channel)
356 {
357 int old;
358
359 if (channel == channel->session->metadata)
360 return -EPERM;
361 old = uatomic_xchg(&channel->enabled, 0);
362 if (!old)
363 return -EEXIST;
364 return 0;
365 }
366
367 int ltt_event_enable(struct ltt_event *event)
368 {
369 int old;
370
371 if (event->chan == event->chan->session->metadata)
372 return -EPERM;
373 old = uatomic_xchg(&event->enabled, 1);
374 if (old)
375 return -EEXIST;
376 return 0;
377 }
378
379 int ltt_event_disable(struct ltt_event *event)
380 {
381 int old;
382
383 if (event->chan == event->chan->session->metadata)
384 return -EPERM;
385 old = uatomic_xchg(&event->enabled, 0);
386 if (!old)
387 return -EEXIST;
388 return 0;
389 }
390
391 struct ltt_channel *ltt_channel_create(struct ltt_session *session,
392 const char *transport_name,
393 void *buf_addr,
394 size_t subbuf_size, size_t num_subbuf,
395 unsigned int switch_timer_interval,
396 unsigned int read_timer_interval,
397 int **shm_fd, int **wait_fd,
398 uint64_t **memory_map_size,
399 struct ltt_channel *chan_priv_init)
400 {
401 struct ltt_channel *chan = NULL;
402 struct ltt_transport *transport;
403
404 if (session->been_active)
405 goto active; /* Refuse to add channel to active session */
406 transport = ltt_transport_find(transport_name);
407 if (!transport) {
408 DBG("LTTng transport %s not found\n",
409 transport_name);
410 goto notransport;
411 }
412 chan_priv_init->id = session->free_chan_id++;
413 chan_priv_init->session = session;
414 /*
415 * Note: the channel creation op already writes into the packet
416 * headers. Therefore the "chan" information used as input
417 * should be already accessible.
418 */
419 chan = transport->ops.channel_create("[lttng]", buf_addr,
420 subbuf_size, num_subbuf, switch_timer_interval,
421 read_timer_interval, shm_fd, wait_fd,
422 memory_map_size, chan_priv_init);
423 if (!chan)
424 goto create_error;
425 chan->enabled = 1;
426 chan->ops = &transport->ops;
427 cds_list_add(&chan->list, &session->chan);
428 return chan;
429
430 create_error:
431 notransport:
432 active:
433 return NULL;
434 }
435
436 /*
437 * Only used internally at session destruction.
438 */
439 static
440 void _ltt_channel_destroy(struct ltt_channel *chan)
441 {
442 cds_list_del(&chan->list);
443 lttng_destroy_context(chan->ctx);
444 chan->ops->channel_destroy(chan);
445 }
446
447 int ltt_loglevel_create(struct ltt_channel *chan,
448 struct lttng_ust_event *event_param,
449 struct session_loglevel **_sl)
450 {
451 struct session_loglevel *sl;
452
453 sl = add_loglevel(event_param->name, chan, event_param);
454 if (!sl || IS_ERR(sl)) {
455 return PTR_ERR(sl);
456 }
457 *_sl = sl;
458 return 0;
459 }
460
461 static
462 void _ltt_loglevel_destroy(struct session_loglevel *sl)
463 {
464 _remove_loglevel(sl);
465 }
466
467 int ltt_wildcard_create(struct ltt_channel *chan,
468 struct lttng_ust_event *event_param,
469 struct session_wildcard **_sw)
470 {
471 struct session_wildcard *sw;
472
473 sw = add_wildcard(event_param->name, chan, event_param);
474 if (!sw || IS_ERR(sw)) {
475 return PTR_ERR(sw);
476 }
477 *_sw = sw;
478 return 0;
479 }
480
481 static
482 void _ltt_wildcard_destroy(struct session_wildcard *sw)
483 {
484 _remove_wildcard(sw);
485 }
486
487 /*
488 * Supports event creation while tracing session is active.
489 */
490 int ltt_event_create(struct ltt_channel *chan,
491 struct lttng_ust_event *event_param,
492 void *filter,
493 struct ltt_event **_event)
494 {
495 struct ltt_event *event;
496 int ret = 0;
497
498 if (chan->used_event_id == -1UL) {
499 ret = -ENOMEM;
500 goto full;
501 }
502 /*
503 * This is O(n^2) (for each event, the loop is called at event
504 * creation). Might require a hash if we have lots of events.
505 */
506 cds_list_for_each_entry(event, &chan->session->events, list) {
507 if (event->desc && !strncmp(event->desc->name,
508 event_param->name,
509 LTTNG_UST_SYM_NAME_LEN - 1)) {
510 ret = -EEXIST;
511 goto exist;
512 }
513 }
514 event = zmalloc(sizeof(struct ltt_event));
515 if (!event) {
516 ret = -ENOMEM;
517 goto cache_error;
518 }
519 event->chan = chan;
520 event->filter = filter;
521 /*
522 * used_event_id counts the maximum number of event IDs that can
523 * register if all probes register.
524 */
525 chan->used_event_id++;
526 event->enabled = 1;
527 event->instrumentation = event_param->instrumentation;
528 /* Populate ltt_event structure before tracepoint registration. */
529 cmm_smp_wmb();
530 switch (event_param->instrumentation) {
531 case LTTNG_UST_TRACEPOINT:
532 event->desc = ltt_event_get(event_param->name);
533 if (event->desc) {
534 ret = __tracepoint_probe_register(event_param->name,
535 event->desc->probe_callback,
536 event);
537 if (ret)
538 goto register_error;
539 event->id = chan->free_event_id++;
540 } else {
541 /*
542 * If the probe is not present, event->desc stays NULL,
543 * waiting for the probe to register, and the event->id
544 * stays unallocated.
545 */
546 ret = add_pending_probe(event, event_param->name);
547 if (ret)
548 goto add_pending_error;
549 }
550 break;
551 default:
552 WARN_ON_ONCE(1);
553 }
554 if (event->desc) {
555 ret = _ltt_event_metadata_statedump(chan->session, chan, event);
556 if (ret)
557 goto statedump_error;
558 }
559 cds_list_add(&event->list, &chan->session->events);
560 *_event = event;
561 return 0;
562
563 statedump_error:
564 if (event->desc) {
565 WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name,
566 event->desc->probe_callback,
567 event));
568 ltt_event_put(event->desc);
569 }
570 add_pending_error:
571 register_error:
572 free(event);
573 cache_error:
574 exist:
575 full:
576 return ret;
577 }
578
579 /*
580 * Only used internally at session destruction.
581 */
582 int _ltt_event_unregister(struct ltt_event *event)
583 {
584 int ret = -EINVAL;
585
586 switch (event->instrumentation) {
587 case LTTNG_UST_TRACEPOINT:
588 if (event->desc) {
589 ret = __tracepoint_probe_unregister(event->desc->name,
590 event->desc->probe_callback,
591 event);
592 if (ret)
593 return ret;
594 } else {
595 remove_pending_probe(event->pending_probe);
596 ret = 0;
597 }
598 break;
599 default:
600 WARN_ON_ONCE(1);
601 }
602 return ret;
603 }
604
605 /*
606 * Only used internally at session destruction.
607 */
608 static
609 void _ltt_event_destroy(struct ltt_event *event)
610 {
611 switch (event->instrumentation) {
612 case LTTNG_UST_TRACEPOINT:
613 if (event->desc) {
614 ltt_event_put(event->desc);
615 }
616 break;
617 default:
618 WARN_ON_ONCE(1);
619 }
620 cds_list_del(&event->list);
621 lttng_destroy_context(event->ctx);
622 free(event);
623 }
624
625 /*
626 * We have exclusive access to our metadata buffer (protected by the
627 * ust_lock), so we can do racy operations such as looking for
628 * remaining space left in packet and write, since mutual exclusion
629 * protects us from concurrent writes.
630 */
631 int lttng_metadata_printf(struct ltt_session *session,
632 const char *fmt, ...)
633 {
634 struct lttng_ust_lib_ring_buffer_ctx ctx;
635 struct ltt_channel *chan = session->metadata;
636 char *str = NULL;
637 int ret = 0, waitret;
638 size_t len, reserve_len, pos;
639 va_list ap;
640
641 WARN_ON_ONCE(!CMM_ACCESS_ONCE(session->active));
642
643 va_start(ap, fmt);
644 ret = vasprintf(&str, fmt, ap);
645 va_end(ap);
646 if (ret < 0)
647 return -ENOMEM;
648
649 len = strlen(str);
650 pos = 0;
651
652 for (pos = 0; pos < len; pos += reserve_len) {
653 reserve_len = min_t(size_t,
654 chan->ops->packet_avail_size(chan->chan, chan->handle),
655 len - pos);
656 lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len,
657 sizeof(char), -1, chan->handle);
658 /*
659 * We don't care about metadata buffer's records lost
660 * count, because we always retry here. Report error if
661 * we need to bail out after timeout or being
662 * interrupted.
663 */
664 waitret = wait_cond_interruptible_timeout(
665 ({
666 ret = chan->ops->event_reserve(&ctx, 0);
667 ret != -ENOBUFS || !ret;
668 }),
669 LTTNG_METADATA_TIMEOUT_MSEC);
670 if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) {
671 DBG("LTTng: Failure to write metadata to buffers (%s)\n",
672 waitret == -EINTR ? "interrupted" :
673 (ret == -ENOBUFS ? "timeout" : "I/O error"));
674 if (waitret == -EINTR)
675 ret = waitret;
676 goto end;
677 }
678 chan->ops->event_write(&ctx, &str[pos], reserve_len);
679 chan->ops->event_commit(&ctx);
680 }
681 end:
682 free(str);
683 return ret;
684 }
685
686 static
687 int _ltt_field_statedump(struct ltt_session *session,
688 const struct lttng_event_field *field)
689 {
690 int ret = 0;
691
692 switch (field->type.atype) {
693 case atype_integer:
694 ret = lttng_metadata_printf(session,
695 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
696 field->type.u.basic.integer.size,
697 field->type.u.basic.integer.alignment,
698 field->type.u.basic.integer.signedness,
699 (field->type.u.basic.integer.encoding == lttng_encode_none)
700 ? "none"
701 : (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
702 ? "UTF8"
703 : "ASCII",
704 field->type.u.basic.integer.base,
705 #if (BYTE_ORDER == BIG_ENDIAN)
706 field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
707 #else
708 field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
709 #endif
710 field->name);
711 break;
712 case atype_float:
713 ret = lttng_metadata_printf(session,
714 " floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n",
715 field->type.u.basic._float.exp_dig,
716 field->type.u.basic._float.mant_dig,
717 field->type.u.basic._float.alignment,
718 #if (BYTE_ORDER == BIG_ENDIAN)
719 field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
720 #else
721 field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
722 #endif
723 field->name);
724 break;
725 case atype_enum:
726 ret = lttng_metadata_printf(session,
727 " %s %s;\n",
728 field->type.u.basic.enumeration.name,
729 field->name);
730 break;
731 case atype_array:
732 {
733 const struct lttng_basic_type *elem_type;
734
735 elem_type = &field->type.u.array.elem_type;
736 ret = lttng_metadata_printf(session,
737 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n",
738 elem_type->u.basic.integer.size,
739 elem_type->u.basic.integer.alignment,
740 elem_type->u.basic.integer.signedness,
741 (elem_type->u.basic.integer.encoding == lttng_encode_none)
742 ? "none"
743 : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
744 ? "UTF8"
745 : "ASCII",
746 elem_type->u.basic.integer.base,
747 #if (BYTE_ORDER == BIG_ENDIAN)
748 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
749 #else
750 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
751 #endif
752 field->name, field->type.u.array.length);
753 break;
754 }
755 case atype_sequence:
756 {
757 const struct lttng_basic_type *elem_type;
758 const struct lttng_basic_type *length_type;
759
760 elem_type = &field->type.u.sequence.elem_type;
761 length_type = &field->type.u.sequence.length_type;
762 ret = lttng_metadata_printf(session,
763 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n",
764 length_type->u.basic.integer.size,
765 (unsigned int) length_type->u.basic.integer.alignment,
766 length_type->u.basic.integer.signedness,
767 (length_type->u.basic.integer.encoding == lttng_encode_none)
768 ? "none"
769 : ((length_type->u.basic.integer.encoding == lttng_encode_UTF8)
770 ? "UTF8"
771 : "ASCII"),
772 length_type->u.basic.integer.base,
773 #if (BYTE_ORDER == BIG_ENDIAN)
774 length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
775 #else
776 length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
777 #endif
778 field->name);
779 if (ret)
780 return ret;
781
782 ret = lttng_metadata_printf(session,
783 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
784 elem_type->u.basic.integer.size,
785 (unsigned int) elem_type->u.basic.integer.alignment,
786 elem_type->u.basic.integer.signedness,
787 (elem_type->u.basic.integer.encoding == lttng_encode_none)
788 ? "none"
789 : ((elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
790 ? "UTF8"
791 : "ASCII"),
792 elem_type->u.basic.integer.base,
793 #if (BYTE_ORDER == BIG_ENDIAN)
794 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
795 #else
796 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
797 #endif
798 field->name,
799 field->name);
800 break;
801 }
802
803 case atype_string:
804 /* Default encoding is UTF8 */
805 ret = lttng_metadata_printf(session,
806 " string%s _%s;\n",
807 field->type.u.basic.string.encoding == lttng_encode_ASCII ?
808 " { encoding = ASCII; }" : "",
809 field->name);
810 break;
811 default:
812 WARN_ON_ONCE(1);
813 return -EINVAL;
814 }
815 return ret;
816 }
817
818 static
819 int _ltt_context_metadata_statedump(struct ltt_session *session,
820 struct lttng_ctx *ctx)
821 {
822 int ret = 0;
823 int i;
824
825 if (!ctx)
826 return 0;
827 for (i = 0; i < ctx->nr_fields; i++) {
828 const struct lttng_ctx_field *field = &ctx->fields[i];
829
830 ret = _ltt_field_statedump(session, &field->event_field);
831 if (ret)
832 return ret;
833 }
834 return ret;
835 }
836
837 static
838 int _ltt_fields_metadata_statedump(struct ltt_session *session,
839 struct ltt_event *event)
840 {
841 const struct lttng_event_desc *desc = event->desc;
842 int ret = 0;
843 int i;
844
845 for (i = 0; i < desc->nr_fields; i++) {
846 const struct lttng_event_field *field = &desc->fields[i];
847
848 ret = _ltt_field_statedump(session, field);
849 if (ret)
850 return ret;
851 }
852 return ret;
853 }
854
855 static
856 int _ltt_event_metadata_statedump(struct ltt_session *session,
857 struct ltt_channel *chan,
858 struct ltt_event *event)
859 {
860 int ret = 0;
861
862 if (event->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
863 return 0;
864 if (chan == session->metadata)
865 return 0;
866 /*
867 * Don't print events for which probe load is pending.
868 */
869 if (!event->desc)
870 return 0;
871
872 ret = lttng_metadata_printf(session,
873 "event {\n"
874 " name = \"%s\";\n"
875 " id = %u;\n"
876 " stream_id = %u;\n",
877 event->desc->name,
878 event->id,
879 event->chan->id);
880 if (ret)
881 goto end;
882
883 if (event->desc->loglevel) {
884 const struct tracepoint_loglevel_entry *ll_entry;
885
886 ll_entry = *event->desc->loglevel;
887 ret = lttng_metadata_printf(session,
888 " loglevel.identifier = \"%s\";\n"
889 " loglevel.value = %lld;\n",
890 ll_entry->identifier,
891 (long long) ll_entry->value);
892 if (ret)
893 goto end;
894 }
895
896 if (event->ctx) {
897 ret = lttng_metadata_printf(session,
898 " context := struct {\n");
899 if (ret)
900 goto end;
901 }
902 ret = _ltt_context_metadata_statedump(session, event->ctx);
903 if (ret)
904 goto end;
905 if (event->ctx) {
906 ret = lttng_metadata_printf(session,
907 " };\n");
908 if (ret)
909 goto end;
910 }
911
912 ret = lttng_metadata_printf(session,
913 " fields := struct {\n"
914 );
915 if (ret)
916 goto end;
917
918 ret = _ltt_fields_metadata_statedump(session, event);
919 if (ret)
920 goto end;
921
922 /*
923 * LTTng space reservation can only reserve multiples of the
924 * byte size.
925 */
926 ret = lttng_metadata_printf(session,
927 " };\n"
928 "};\n\n");
929 if (ret)
930 goto end;
931
932 event->metadata_dumped = 1;
933 end:
934 return ret;
935
936 }
937
938 static
939 int _ltt_channel_metadata_statedump(struct ltt_session *session,
940 struct ltt_channel *chan)
941 {
942 int ret = 0;
943
944 if (chan->metadata_dumped || !CMM_ACCESS_ONCE(session->active))
945 return 0;
946 if (chan == session->metadata)
947 return 0;
948
949 WARN_ON_ONCE(!chan->header_type);
950 ret = lttng_metadata_printf(session,
951 "stream {\n"
952 " id = %u;\n"
953 " event.header := %s;\n"
954 " packet.context := struct packet_context;\n",
955 chan->id,
956 chan->header_type == 1 ? "struct event_header_compact" :
957 "struct event_header_large");
958 if (ret)
959 goto end;
960
961 if (chan->ctx) {
962 ret = lttng_metadata_printf(session,
963 " event.context := struct {\n");
964 if (ret)
965 goto end;
966 }
967 ret = _ltt_context_metadata_statedump(session, chan->ctx);
968 if (ret)
969 goto end;
970 if (chan->ctx) {
971 ret = lttng_metadata_printf(session,
972 " };\n");
973 if (ret)
974 goto end;
975 }
976
977 ret = lttng_metadata_printf(session,
978 "};\n\n");
979
980 chan->metadata_dumped = 1;
981 end:
982 return ret;
983 }
984
985 static
986 int _ltt_stream_packet_context_declare(struct ltt_session *session)
987 {
988 return lttng_metadata_printf(session,
989 "struct packet_context {\n"
990 " uint64_clock_monotonic_t timestamp_begin;\n"
991 " uint64_clock_monotonic_t timestamp_end;\n"
992 " uint32_t events_discarded;\n"
993 " uint32_t content_size;\n"
994 " uint32_t packet_size;\n"
995 " uint32_t cpu_id;\n"
996 "};\n\n"
997 );
998 }
999
1000 /*
1001 * Compact header:
1002 * id: range: 0 - 30.
1003 * id 31 is reserved to indicate an extended header.
1004 *
1005 * Large header:
1006 * id: range: 0 - 65534.
1007 * id 65535 is reserved to indicate an extended header.
1008 */
1009 static
1010 int _ltt_event_header_declare(struct ltt_session *session)
1011 {
1012 return lttng_metadata_printf(session,
1013 "struct event_header_compact {\n"
1014 " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
1015 " variant <id> {\n"
1016 " struct {\n"
1017 " uint27_clock_monotonic_t timestamp;\n"
1018 " } compact;\n"
1019 " struct {\n"
1020 " uint32_t id;\n"
1021 " uint64_clock_monotonic_t timestamp;\n"
1022 " } extended;\n"
1023 " } v;\n"
1024 "} align(%u);\n"
1025 "\n"
1026 "struct event_header_large {\n"
1027 " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
1028 " variant <id> {\n"
1029 " struct {\n"
1030 " uint32_clock_monotonic_t timestamp;\n"
1031 " } compact;\n"
1032 " struct {\n"
1033 " uint32_t id;\n"
1034 " uint64_clock_monotonic_t timestamp;\n"
1035 " } extended;\n"
1036 " } v;\n"
1037 "} align(%u);\n\n",
1038 lttng_alignof(uint32_t) * CHAR_BIT,
1039 lttng_alignof(uint16_t) * CHAR_BIT
1040 );
1041 }
1042
1043 /*
1044 * Approximation of NTP time of day to clock monotonic correlation,
1045 * taken at start of trace.
1046 * Yes, this is only an approximation. Yes, we can (and will) do better
1047 * in future versions.
1048 */
1049 static
1050 uint64_t measure_clock_offset(void)
1051 {
1052 uint64_t offset, monotonic[2], realtime;
1053 struct timespec rts = { 0, 0 };
1054 int ret;
1055
1056 monotonic[0] = trace_clock_read64();
1057 ret = clock_gettime(CLOCK_REALTIME, &rts);
1058 if (ret < 0)
1059 return 0;
1060 monotonic[1] = trace_clock_read64();
1061 offset = (monotonic[0] + monotonic[1]) >> 1;
1062 realtime = rts.tv_sec * 1000000000ULL;
1063 realtime += rts.tv_nsec;
1064 offset = realtime - offset;
1065 return offset;
1066 }
1067
1068 /*
1069 * Output metadata into this session's metadata buffers.
1070 */
1071 static
1072 int _ltt_session_metadata_statedump(struct ltt_session *session)
1073 {
1074 unsigned char *uuid_c = session->uuid;
1075 char uuid_s[37], clock_uuid_s[CLOCK_UUID_LEN];
1076 struct ltt_channel *chan;
1077 struct ltt_event *event;
1078 int ret = 0;
1079
1080 if (!CMM_ACCESS_ONCE(session->active))
1081 return 0;
1082 if (session->metadata_dumped)
1083 goto skip_session;
1084 if (!session->metadata) {
1085 DBG("LTTng: attempt to start tracing, but metadata channel is not found. Operation abort.\n");
1086 return -EPERM;
1087 }
1088
1089 snprintf(uuid_s, sizeof(uuid_s),
1090 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
1091 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
1092 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
1093 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
1094 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
1095
1096 ret = lttng_metadata_printf(session,
1097 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
1098 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
1099 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
1100 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
1101 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
1102 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
1103 "\n"
1104 "trace {\n"
1105 " major = %u;\n"
1106 " minor = %u;\n"
1107 " uuid = \"%s\";\n"
1108 " byte_order = %s;\n"
1109 " packet.header := struct {\n"
1110 " uint32_t magic;\n"
1111 " uint8_t uuid[16];\n"
1112 " uint32_t stream_id;\n"
1113 " };\n"
1114 "};\n\n",
1115 lttng_alignof(uint8_t) * CHAR_BIT,
1116 lttng_alignof(uint16_t) * CHAR_BIT,
1117 lttng_alignof(uint32_t) * CHAR_BIT,
1118 lttng_alignof(uint64_t) * CHAR_BIT,
1119 CTF_VERSION_MAJOR,
1120 CTF_VERSION_MINOR,
1121 uuid_s,
1122 #if (BYTE_ORDER == BIG_ENDIAN)
1123 "be"
1124 #else
1125 "le"
1126 #endif
1127 );
1128 if (ret)
1129 goto end;
1130
1131 ret = lttng_metadata_printf(session,
1132 "clock {\n"
1133 " name = %s;\n",
1134 "monotonic"
1135 );
1136 if (ret)
1137 goto end;
1138
1139 if (!trace_clock_uuid(clock_uuid_s)) {
1140 ret = lttng_metadata_printf(session,
1141 " uuid = \"%s\";\n",
1142 clock_uuid_s
1143 );
1144 if (ret)
1145 goto end;
1146 }
1147
1148 ret = lttng_metadata_printf(session,
1149 " description = \"Monotonic Clock\";\n"
1150 " freq = %" PRIu64 "; /* Frequency, in Hz */\n"
1151 " /* clock value offset from Epoch is: offset * (1/freq) */\n"
1152 " offset = %" PRIu64 ";\n"
1153 "};\n\n",
1154 trace_clock_freq(),
1155 measure_clock_offset()
1156 );
1157 if (ret)
1158 goto end;
1159
1160 ret = lttng_metadata_printf(session,
1161 "typealias integer {\n"
1162 " size = 27; align = 1; signed = false;\n"
1163 " map = clock.monotonic.value;\n"
1164 "} := uint27_clock_monotonic_t;\n"
1165 "\n"
1166 "typealias integer {\n"
1167 " size = 32; align = %u; signed = false;\n"
1168 " map = clock.monotonic.value;\n"
1169 "} := uint32_clock_monotonic_t;\n"
1170 "\n"
1171 "typealias integer {\n"
1172 " size = 64; align = %u; signed = false;\n"
1173 " map = clock.monotonic.value;\n"
1174 "} := uint64_clock_monotonic_t;\n\n",
1175 lttng_alignof(uint32_t) * CHAR_BIT,
1176 lttng_alignof(uint64_t) * CHAR_BIT
1177 );
1178 if (ret)
1179 goto end;
1180
1181 ret = _ltt_stream_packet_context_declare(session);
1182 if (ret)
1183 goto end;
1184
1185 ret = _ltt_event_header_declare(session);
1186 if (ret)
1187 goto end;
1188
1189 skip_session:
1190 cds_list_for_each_entry(chan, &session->chan, list) {
1191 ret = _ltt_channel_metadata_statedump(session, chan);
1192 if (ret)
1193 goto end;
1194 }
1195
1196 cds_list_for_each_entry(event, &session->events, list) {
1197 ret = _ltt_event_metadata_statedump(session, event->chan, event);
1198 if (ret)
1199 goto end;
1200 }
1201 session->metadata_dumped = 1;
1202 end:
1203 return ret;
1204 }
1205
1206 void lttng_ust_events_exit(void)
1207 {
1208 struct ltt_session *session, *tmpsession;
1209
1210 cds_list_for_each_entry_safe(session, tmpsession, &sessions, list)
1211 ltt_session_destroy(session);
1212 }
LTTng 2.0 Userspace Tracer
This page took 0.065143 seconds and 4 git commands to generate.