4 * Babeltrace CTF IR - Event
6 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 #define BT_LOG_TAG "EVENT"
30 #include <babeltrace/lib-logging-internal.h>
32 #include <babeltrace/assert-pre-internal.h>
33 #include <babeltrace/ctf-ir/fields-internal.h>
34 #include <babeltrace/ctf-ir/field-types-internal.h>
35 #include <babeltrace/ctf-ir/clock-class.h>
36 #include <babeltrace/ctf-ir/clock-value.h>
37 #include <babeltrace/ctf-ir/clock-value-internal.h>
38 #include <babeltrace/ctf-ir/clock-class-internal.h>
39 #include <babeltrace/ctf-ir/event-internal.h>
40 #include <babeltrace/ctf-ir/event-class.h>
41 #include <babeltrace/ctf-ir/event-class-internal.h>
42 #include <babeltrace/ctf-ir/stream-class.h>
43 #include <babeltrace/ctf-ir/stream-class-internal.h>
44 #include <babeltrace/ctf-ir/stream-internal.h>
45 #include <babeltrace/ctf-ir/packet.h>
46 #include <babeltrace/ctf-ir/packet-internal.h>
47 #include <babeltrace/ctf-ir/trace.h>
48 #include <babeltrace/ctf-ir/trace-internal.h>
49 #include <babeltrace/ctf-ir/validation-internal.h>
50 #include <babeltrace/ctf-ir/packet-internal.h>
51 #include <babeltrace/ctf-ir/utils.h>
52 #include <babeltrace/ref.h>
53 #include <babeltrace/ctf-ir/attributes-internal.h>
54 #include <babeltrace/compiler-internal.h>
55 #include <babeltrace/assert-internal.h>
59 int bt_event_validate_types_for_create(
60 struct bt_event_class
*event_class
,
61 struct bt_validation_output
*validation_output
,
62 bt_validation_flag_copy_field_type_func copy_field_type_func
)
65 enum bt_validation_flag validation_flags
=
66 BT_VALIDATION_FLAG_STREAM
|
67 BT_VALIDATION_FLAG_EVENT
;
68 struct bt_trace
*trace
= NULL
;
69 struct bt_stream_class
*stream_class
= NULL
;
70 struct bt_field_type
*packet_header_type
= NULL
;
71 struct bt_field_type
*packet_context_type
= NULL
;
72 struct bt_field_type
*event_header_type
= NULL
;
73 struct bt_field_type
*stream_event_ctx_type
= NULL
;
74 struct bt_field_type
*event_context_type
= NULL
;
75 struct bt_field_type
*event_payload_type
= NULL
;
77 struct bt_value
*environment
= NULL
;
79 stream_class
= bt_event_class_borrow_stream_class(event_class
);
80 BT_ASSERT(stream_class
);
81 trace
= bt_stream_class_borrow_trace(stream_class
);
83 BT_LOGD_STR("Event class is part of a trace.");
85 bt_trace_borrow_packet_header_field_type(trace
);
86 trace_valid
= trace
->valid
;
87 BT_ASSERT(trace_valid
);
88 environment
= trace
->environment
;
92 bt_stream_class_borrow_packet_context_field_type(
95 bt_stream_class_borrow_event_header_field_type(
97 stream_event_ctx_type
=
98 bt_stream_class_borrow_event_context_field_type(
101 bt_event_class_borrow_context_field_type(event_class
);
103 bt_event_class_borrow_payload_field_type(event_class
);
104 ret
= bt_validate_class_types(environment
, packet_header_type
,
105 packet_context_type
, event_header_type
, stream_event_ctx_type
,
106 event_context_type
, event_payload_type
, trace_valid
,
107 stream_class
->valid
, event_class
->valid
,
108 validation_output
, validation_flags
, copy_field_type_func
);
111 * This means something went wrong during the validation
112 * process, not that the objects are invalid.
114 BT_LOGE("Failed to validate event and parents: ret=%d", ret
);
118 if ((validation_output
->valid_flags
& validation_flags
) !=
120 /* Invalid trace/stream class/event class */
121 BT_LOGW("Invalid trace, stream class, or event class: "
122 "valid-flags=0x%x", validation_output
->valid_flags
);
129 bt_validation_output_put_types(validation_output
);
137 int bt_event_create_fields(
138 struct bt_stream_class
*stream_class
,
139 struct bt_validation_output
*validation_output
,
140 create_field_func create_field_func
,
141 release_field_func release_field_func
,
142 create_header_field_func create_header_field_func
,
143 release_header_field_func release_header_field_func
,
144 struct bt_field_wrapper
**header_field
,
145 struct bt_field
**stream_event_context_field
,
146 struct bt_field
**context_field
,
147 struct bt_field
**payload_field
)
151 if (validation_output
->event_header_type
) {
152 BT_LOGD("Creating initial event header field: ft-addr=%p",
153 validation_output
->event_header_type
);
155 create_header_field_func(stream_class
,
156 validation_output
->event_header_type
);
157 if (!*header_field
) {
158 BT_LOGE_STR("Cannot create initial event header field object.");
163 if (validation_output
->stream_event_ctx_type
) {
164 BT_LOGD("Creating initial stream event context field: ft-addr=%p",
165 validation_output
->stream_event_ctx_type
);
166 *stream_event_context_field
= create_field_func(
167 validation_output
->stream_event_ctx_type
);
168 if (!*stream_event_context_field
) {
169 BT_LOGE_STR("Cannot create initial stream event context field object.");
174 if (validation_output
->event_context_type
) {
175 BT_LOGD("Creating initial event context field: ft-addr=%p",
176 validation_output
->event_context_type
);
177 *context_field
= create_field_func(
178 validation_output
->event_context_type
);
179 if (!*context_field
) {
180 BT_LOGE_STR("Cannot create initial event context field object.");
185 if (validation_output
->event_payload_type
) {
186 BT_LOGD("Creating initial event payload field: ft-addr=%p",
187 validation_output
->event_payload_type
);
188 *payload_field
= create_field_func(
189 validation_output
->event_payload_type
);
190 if (!*payload_field
) {
191 BT_LOGE_STR("Cannot create initial event payload field object.");
200 release_header_field_func(*header_field
, stream_class
);
203 if (*stream_event_context_field
) {
204 release_field_func(*stream_event_context_field
);
207 if (*context_field
) {
208 release_field_func(*context_field
);
211 if (*payload_field
) {
212 release_field_func(*payload_field
);
222 int _bt_event_validate(struct bt_event
*event
)
225 struct bt_stream_class
*stream_class
;
228 if (event
->header_field
) {
229 ret
= bt_field_validate_recursive(
230 event
->header_field
->field
);
232 BT_ASSERT_PRE_MSG("Invalid event's header field: "
233 "%![event-]+e, %![field-]+f",
234 event
, event
->header_field
->field
);
239 stream_class
= bt_event_class_borrow_stream_class(event
->class);
242 * We should not have been able to create the event without associating
243 * the event class to a stream class.
245 BT_ASSERT(stream_class
);
247 if (stream_class
->event_context_field_type
) {
248 ret
= bt_field_validate_recursive(
249 event
->stream_event_context_field
);
251 BT_ASSERT_PRE_MSG("Invalid event's stream event context field: "
252 "%![event-]+e, %![field-]+f",
253 event
, event
->stream_event_context_field
);
258 if (event
->class->context_field_type
) {
259 ret
= bt_field_validate_recursive(event
->context_field
);
261 BT_ASSERT_PRE_MSG("Invalid event's payload field: "
262 "%![event-]+e, %![field-]+f",
263 event
, event
->context_field
);
268 ret
= bt_field_validate_recursive(event
->payload_field
);
270 BT_ASSERT_PRE_MSG("Invalid event's payload field: "
271 "%![event-]+e, %![field-]+f",
272 event
, event
->payload_field
);
281 void _bt_event_set_is_frozen(struct bt_event
*event
,
285 BT_LOGD("Freezing event: addr=%p, "
286 "event-class-name=\"%s\", event-class-id=%" PRId64
,
287 event
, bt_event_class_get_name(event
->class),
288 bt_event_class_get_id(event
->class));
290 if (event
->header_field
) {
291 BT_LOGD_STR("Freezing event's header field.");
292 bt_field_set_is_frozen_recursive(
293 event
->header_field
->field
, is_frozen
);
296 if (event
->stream_event_context_field
) {
297 BT_LOGD_STR("Freezing event's stream event context field.");
298 bt_field_set_is_frozen_recursive(
299 event
->stream_event_context_field
, is_frozen
);
302 if (event
->context_field
) {
303 BT_LOGD_STR("Freezing event's context field.");
304 bt_field_set_is_frozen_recursive(event
->context_field
,
308 if (event
->payload_field
) {
309 BT_LOGD_STR("Freezing event's payload field.");
310 bt_field_set_is_frozen_recursive(event
->payload_field
,
314 event
->frozen
= is_frozen
;
315 BT_LOGD_STR("Freezing event's packet.");
316 bt_packet_set_is_frozen(event
->packet
, is_frozen
);
320 int bt_event_initialize(struct bt_event
*event
,
321 struct bt_event_class
*event_class
,
322 bt_validation_flag_copy_field_type_func field_type_copy_func
,
323 create_field_func create_field_func
,
324 release_field_func release_field_func
,
325 create_header_field_func create_header_field_func
,
326 release_header_field_func release_header_field_func
)
329 struct bt_trace
*trace
= NULL
;
330 struct bt_stream_class
*stream_class
= NULL
;
331 struct bt_field_wrapper
*event_header
= NULL
;
332 struct bt_field
*stream_event_context
= NULL
;
333 struct bt_field
*event_context
= NULL
;
334 struct bt_field
*event_payload
= NULL
;
335 struct bt_validation_output validation_output
= { 0 };
336 struct bt_clock_class
*expected_clock_class
= NULL
;
338 BT_ASSERT_PRE_NON_NULL(event_class
, "Event class");
339 BT_LOGD("Initializing event object: event-class-addr=%p, "
340 "event-class-name=\"%s\", event-class-id=%" PRId64
,
341 event_class
, bt_event_class_get_name(event_class
),
342 bt_event_class_get_id(event_class
));
344 stream_class
= bt_event_class_borrow_stream_class(event_class
);
345 BT_ASSERT_PRE(stream_class
,
346 "Event class is not part of a stream class: %!+E", event_class
);
348 /* The event class was frozen when added to its stream class */
349 BT_ASSERT(event_class
->frozen
);
350 trace
= bt_stream_class_borrow_trace(stream_class
);
352 "Event class's stream class is not part of a trace: "
353 "%![ec-]+E, %![ec-]+S", event_class
, stream_class
);
356 * This must be called before anything that can fail because on
357 * failure, the caller releases the reference to `event` to
360 bt_object_init_unique(&event
->base
);
362 if (!stream_class
->frozen
) {
364 * Because this function freezes the stream class,
365 * validate that this stream class contains at most a
366 * single clock class so that we set its expected clock
367 * class for future checks.
369 ret
= bt_stream_class_validate_single_clock_class(
370 stream_class
, &expected_clock_class
);
372 BT_LOGW("Event class's stream class or one of its event "
373 "classes contains a field type which is not "
374 "recursively mapped to the expected "
376 "stream-class-addr=%p, "
377 "stream-class-id=%" PRId64
", "
378 "stream-class-name=\"%s\", "
379 "expected-clock-class-addr=%p, "
380 "expected-clock-class-name=\"%s\"",
382 bt_stream_class_get_id(stream_class
),
383 bt_stream_class_get_name(stream_class
),
384 expected_clock_class
,
385 expected_clock_class
?
386 bt_clock_class_get_name(expected_clock_class
) :
392 /* Validate the trace, the stream class, and the event class */
393 ret
= bt_event_validate_types_for_create(
394 event_class
, &validation_output
, field_type_copy_func
);
396 /* bt_event_validate_types_for_create() logs errors */
401 * event does not share a common ancestor with the event class; it has
402 * to guarantee its existence by holding a reference. This reference
403 * shall be released once the event is associated to a stream since,
404 * from that point, the event and its class will share the same
407 * TODO: Is this still true now that this API and CTF writer are
408 * two different implementations?
410 event
->class = bt_get(event_class
);
411 ret
= bt_event_create_fields(stream_class
,
413 create_field_func
, release_field_func
,
414 create_header_field_func
, release_header_field_func
,
415 &event_header
, &stream_event_context
, &event_context
,
418 /* bt_event_create_fields() logs errors */
423 * At this point all the fields are created, potentially from
424 * validated copies of field types, so that the field types and
425 * fields can be replaced in the trace, stream class,
426 * event class, and created event.
428 bt_validation_replace_types(trace
, stream_class
, event_class
,
430 BT_VALIDATION_FLAG_STREAM
| BT_VALIDATION_FLAG_EVENT
);
431 event
->header_field
= event_header
;
433 event
->stream_event_context_field
= stream_event_context
;
434 stream_event_context
= NULL
;
435 event
->context_field
= event_context
;
436 event_context
= NULL
;
437 event
->payload_field
= event_payload
;
438 event_payload
= NULL
;
441 * Put what was not moved in bt_validation_replace_types().
443 bt_validation_output_put_types(&validation_output
);
446 * Freeze the stream class since the event header must not be changed
449 bt_stream_class_freeze(stream_class
);
452 * It is safe to set the stream class's unique clock class
453 * now because the stream class is frozen.
455 if (expected_clock_class
) {
456 BT_MOVE(stream_class
->clock_class
, expected_clock_class
);
460 * Mark stream class, and event class as valid since
461 * they're all frozen now.
463 stream_class
->valid
= 1;
464 event_class
->valid
= 1;
466 /* Put stuff we borrowed from the event class */
467 BT_LOGD("Initialized event object: addr=%p, event-class-name=\"%s\", "
468 "event-class-id=%" PRId64
,
469 event
, bt_event_class_get_name(event
->class),
470 bt_event_class_get_id(event
->class));
474 bt_validation_output_put_types(&validation_output
);
475 bt_put(expected_clock_class
);
478 release_header_field_func(event_header
, stream_class
);
481 if (stream_event_context
) {
482 release_field_func(stream_event_context
);
486 release_field_func(event_context
);
490 release_field_func(event_payload
);
500 void bt_event_header_field_recycle(struct bt_field_wrapper
*field_wrapper
,
501 struct bt_stream_class
*stream_class
)
503 BT_ASSERT(field_wrapper
);
504 BT_LIB_LOGD("Recycling event header field: "
505 "addr=%p, %![sc-]+S, %![field-]+f", field_wrapper
,
506 stream_class
, field_wrapper
->field
);
507 bt_object_pool_recycle_object(
508 &stream_class
->event_header_field_pool
,
513 struct bt_field_wrapper
*create_event_header_field(
514 struct bt_stream_class
*stream_class
,
515 struct bt_field_type
*ft
)
517 struct bt_field_wrapper
*field_wrapper
= NULL
;
519 field_wrapper
= bt_field_wrapper_create(
520 &stream_class
->event_header_field_pool
, (void *) ft
);
521 if (!field_wrapper
) {
529 bt_event_header_field_recycle(field_wrapper
, stream_class
);
530 field_wrapper
= NULL
;
534 return field_wrapper
;
538 struct bt_event
*bt_event_new(struct bt_event_class
*event_class
)
541 struct bt_event
*event
= NULL
;
542 struct bt_stream_class
*stream_class
;
544 event
= g_new0(struct bt_event
, 1);
546 BT_LOGE_STR("Failed to allocate one event.");
550 ret
= bt_event_initialize(event
, event_class
,
551 (bt_validation_flag_copy_field_type_func
) bt_field_type_copy
,
552 (create_field_func
) bt_field_create_recursive
,
553 (release_field_func
) bt_field_destroy_recursive
,
554 (create_header_field_func
) create_event_header_field
,
555 (release_header_field_func
) bt_event_header_field_recycle
);
557 /* bt_event_initialize() logs errors */
561 stream_class
= bt_event_class_borrow_stream_class(event_class
);
562 BT_ASSERT(stream_class
);
563 ret
= bt_clock_value_set_initialize(&event
->cv_set
);
572 bt_event_destroy(event
);
580 struct bt_event_class
*bt_event_borrow_class(struct bt_event
*event
)
582 BT_ASSERT_PRE_NON_NULL(event
, "Event");
586 struct bt_stream
*bt_event_borrow_stream(struct bt_event
*event
)
588 BT_ASSERT_PRE_NON_NULL(event
, "Event");
589 return event
->packet
? event
->packet
->stream
: NULL
;
592 struct bt_field
*bt_event_borrow_payload(struct bt_event
*event
)
594 struct bt_field
*payload
= NULL
;
596 BT_ASSERT_PRE_NON_NULL(event
, "Event");
598 if (!event
->payload_field
) {
599 BT_LOGV("Event has no current payload field: addr=%p, "
600 "event-class-name=\"%s\", event-class-id=%" PRId64
,
601 event
, bt_event_class_get_name(event
->class),
602 bt_event_class_get_id(event
->class));
606 payload
= event
->payload_field
;
612 struct bt_field
*bt_event_borrow_header(struct bt_event
*event
)
614 struct bt_field
*header
= NULL
;
616 BT_ASSERT_PRE_NON_NULL(event
, "Event");
618 if (!event
->header_field
) {
619 BT_LOGV("Event has no current header field: addr=%p, "
620 "event-class-name=\"%s\", event-class-id=%" PRId64
,
621 event
, bt_event_class_get_name(event
->class),
622 bt_event_class_get_id(event
->class));
626 header
= event
->header_field
->field
;
632 struct bt_field
*bt_event_borrow_context(struct bt_event
*event
)
634 struct bt_field
*context
= NULL
;
636 BT_ASSERT_PRE_NON_NULL(event
, "Event");
638 if (!event
->context_field
) {
639 BT_LOGV("Event has no current context field: addr=%p, "
640 "event-class-name=\"%s\", event-class-id=%" PRId64
,
641 event
, bt_event_class_get_name(event
->class),
642 bt_event_class_get_id(event
->class));
646 context
= event
->context_field
;
652 struct bt_field
*bt_event_borrow_stream_event_context(
653 struct bt_event
*event
)
655 struct bt_field
*stream_event_context
= NULL
;
657 BT_ASSERT_PRE_NON_NULL(event
, "Event");
659 if (!event
->stream_event_context_field
) {
660 BT_LOGV("Event has no current stream event context field: addr=%p, "
661 "event-class-name=\"%s\", event-class-id=%" PRId64
,
662 event
, bt_event_class_get_name(event
->class),
663 bt_event_class_get_id(event
->class));
667 stream_event_context
= event
->stream_event_context_field
;
670 return stream_event_context
;
674 void release_event_header_field(struct bt_field_wrapper
*field_wrapper
,
675 struct bt_event
*event
)
677 struct bt_event_class
*event_class
= bt_event_borrow_class(event
);
680 bt_field_wrapper_destroy(field_wrapper
);
682 struct bt_stream_class
*stream_class
=
683 bt_event_class_borrow_stream_class(event_class
);
685 BT_ASSERT(stream_class
);
686 bt_event_header_field_recycle(field_wrapper
, stream_class
);
691 void bt_event_finalize(struct bt_object
*obj
,
692 void (*field_release_func
)(void *),
693 void (*header_field_release_func
)(void *, struct bt_event
*))
695 struct bt_event
*event
= (void *) obj
;
697 BT_LOGD("Destroying event: addr=%p, "
698 "event-class-name=\"%s\", event-class-id=%" PRId64
,
700 event
->class ? bt_event_class_get_name(event
->class) : NULL
,
701 event
->class ? bt_event_class_get_id(event
->class) : INT64_C(-1));
703 if (event
->header_field
) {
704 BT_LOGD_STR("Releasing event's header field.");
705 header_field_release_func(event
->header_field
, event
);
708 if (event
->stream_event_context_field
) {
709 BT_LOGD_STR("Releasing event's stream event context field.");
710 field_release_func(event
->stream_event_context_field
);
713 if (event
->context_field
) {
714 BT_LOGD_STR("Releasing event's context field.");
715 field_release_func(event
->context_field
);
718 if (event
->payload_field
) {
719 BT_LOGD_STR("Releasing event's payload field.");
720 field_release_func(event
->payload_field
);
724 * Leave this after calling header_field_release_func() because
725 * this function receives the event object and could need its
726 * class to perform some cleanup.
728 if (!event
->base
.parent
) {
730 * Event was keeping a reference to its class since it shared no
731 * common ancestor with it to guarantee they would both have the
734 bt_put(event
->class);
739 void bt_event_destroy(struct bt_event
*event
)
742 bt_event_finalize((void *) event
,
743 (void *) bt_field_destroy_recursive
,
744 (void *) release_event_header_field
);
745 bt_clock_value_set_finalize(&event
->cv_set
);
746 BT_LOGD_STR("Putting event's packet.");
747 bt_put(event
->packet
);
751 int bt_event_set_clock_value(struct bt_event
*event
,
752 struct bt_clock_class
*clock_class
, uint64_t raw_value
,
755 BT_ASSERT_PRE_NON_NULL(event
, "Event");
756 BT_ASSERT_PRE_NON_NULL(clock_class
, "Clock class");
757 BT_ASSERT_PRE_HOT(event
, "Event", ": %!+e", event
);
758 BT_ASSERT_PRE(is_default
,
759 "You can only set a default clock value as of this version.");
760 return bt_clock_value_set_set_clock_value(&event
->cv_set
, clock_class
,
761 raw_value
, is_default
);
764 struct bt_clock_value
*bt_event_borrow_default_clock_value(
765 struct bt_event
*event
)
767 struct bt_clock_value
*clock_value
= NULL
;
769 BT_ASSERT_PRE_NON_NULL(event
, "Event");
770 clock_value
= event
->cv_set
.default_cv
;
772 BT_LIB_LOGV("No default clock value: %![event-]+e", event
);
778 struct bt_packet
*bt_event_borrow_packet(struct bt_event
*event
)
780 struct bt_packet
*packet
= NULL
;
782 BT_ASSERT_PRE_NON_NULL(event
, "Event");
783 if (!event
->packet
) {
784 BT_LOGV("Event has no current packet: addr=%p, "
785 "event-class-name=\"%s\", event-class-id=%" PRId64
,
786 event
, bt_event_class_get_name(event
->class),
787 bt_event_class_get_id(event
->class));
791 packet
= event
->packet
;
797 int bt_event_move_header(struct bt_event
*event
,
798 struct bt_event_header_field
*header_field
)
800 struct bt_stream_class
*stream_class
;
801 struct bt_field_wrapper
*field_wrapper
= (void *) header_field
;
803 BT_ASSERT_PRE_NON_NULL(event
, "Event");
804 BT_ASSERT_PRE_NON_NULL(field_wrapper
, "Header field");
805 BT_ASSERT_PRE_HOT(event
, "Event", ": %!+e", event
);
806 stream_class
= bt_event_class_borrow_stream_class(
807 bt_event_borrow_class(event
));
808 BT_ASSERT_PRE(stream_class
->event_header_field_type
,
809 "Stream class has no event header field type: %!+S",
812 /* Recycle current header field: always exists */
813 BT_ASSERT(event
->header_field
);
814 bt_event_header_field_recycle(event
->header_field
,
818 event
->header_field
= (void *) field_wrapper
;