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 #include <babeltrace/ctf-ir/fields-internal.h>
30 #include <babeltrace/ctf-ir/field-types-internal.h>
31 #include <babeltrace/ctf-ir/event-internal.h>
32 #include <babeltrace/ctf-ir/event-class.h>
33 #include <babeltrace/ctf-ir/event-class-internal.h>
34 #include <babeltrace/ctf-ir/stream-class.h>
35 #include <babeltrace/ctf-ir/stream-class-internal.h>
36 #include <babeltrace/ctf-ir/stream-internal.h>
37 #include <babeltrace/ctf-ir/packet.h>
38 #include <babeltrace/ctf-ir/packet-internal.h>
39 #include <babeltrace/ctf-ir/trace-internal.h>
40 #include <babeltrace/ctf-ir/validation-internal.h>
41 #include <babeltrace/ctf-ir/packet-internal.h>
42 #include <babeltrace/ctf-ir/clock-internal.h>
43 #include <babeltrace/ctf-ir/utils.h>
44 #include <babeltrace/ref.h>
45 #include <babeltrace/ctf-ir/attributes-internal.h>
46 #include <babeltrace/compiler.h>
49 void bt_ctf_event_destroy(struct bt_object
*obj
);
51 int set_integer_field_value(struct bt_ctf_field
*field
, uint64_t value
);
53 struct bt_ctf_event
*bt_ctf_event_create(struct bt_ctf_event_class
*event_class
)
56 enum bt_ctf_validation_flag validation_flags
=
57 BT_CTF_VALIDATION_FLAG_STREAM
|
58 BT_CTF_VALIDATION_FLAG_EVENT
;
59 struct bt_ctf_event
*event
= NULL
;
60 struct bt_ctf_trace
*trace
= NULL
;
61 struct bt_ctf_stream_class
*stream_class
= NULL
;
62 struct bt_ctf_field_type
*packet_header_type
= NULL
;
63 struct bt_ctf_field_type
*packet_context_type
= NULL
;
64 struct bt_ctf_field_type
*event_header_type
= NULL
;
65 struct bt_ctf_field_type
*stream_event_ctx_type
= NULL
;
66 struct bt_ctf_field_type
*event_context_type
= NULL
;
67 struct bt_ctf_field_type
*event_payload_type
= NULL
;
68 struct bt_ctf_field
*event_header
= NULL
;
69 struct bt_ctf_field
*stream_event_context
= NULL
;
70 struct bt_ctf_field
*event_context
= NULL
;
71 struct bt_ctf_field
*event_payload
= NULL
;
72 struct bt_value
*environment
= NULL
;
73 struct bt_ctf_validation_output validation_output
= { 0 };
80 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
83 * We disallow the creation of an event if its event class has not been
84 * associated to a stream class.
90 /* A stream class should always have an existing event header type */
91 assert(stream_class
->event_header_type
);
93 /* The event class was frozen when added to its stream class */
94 assert(event_class
->frozen
);
96 /* Validate the trace (if any), the stream class, and the event class */
97 trace
= bt_ctf_stream_class_get_trace(stream_class
);
99 packet_header_type
= bt_ctf_trace_get_packet_header_type(trace
);
100 trace_valid
= trace
->valid
;
102 environment
= trace
->environment
;
105 packet_context_type
= bt_ctf_stream_class_get_packet_context_type(
107 event_header_type
= bt_ctf_stream_class_get_event_header_type(
109 stream_event_ctx_type
= bt_ctf_stream_class_get_event_context_type(
111 event_context_type
= bt_ctf_event_class_get_context_type(event_class
);
112 event_payload_type
= bt_ctf_event_class_get_payload_type(event_class
);
113 ret
= bt_ctf_validate_class_types(environment
, packet_header_type
,
114 packet_context_type
, event_header_type
, stream_event_ctx_type
,
115 event_context_type
, event_payload_type
, trace_valid
,
116 stream_class
->valid
, event_class
->valid
,
117 &validation_output
, validation_flags
);
118 BT_PUT(packet_header_type
);
119 BT_PUT(packet_context_type
);
120 BT_PUT(event_header_type
);
121 BT_PUT(stream_event_ctx_type
);
122 BT_PUT(event_context_type
);
123 BT_PUT(event_payload_type
);
126 * This means something went wrong during the validation
127 * process, not that the objects are invalid.
132 if ((validation_output
.valid_flags
& validation_flags
) !=
134 /* Invalid trace/stream class/event class */
139 * At this point we know the trace (if associated to the stream
140 * class), the stream class, and the event class, with their
141 * current types, are valid. We may proceed with creating
144 event
= g_new0(struct bt_ctf_event
, 1);
149 bt_object_init(event
, bt_ctf_event_destroy
);
152 * event does not share a common ancestor with the event class; it has
153 * to guarantee its existence by holding a reference. This reference
154 * shall be released once the event is associated to a stream since,
155 * from that point, the event and its class will share the same
158 event
->event_class
= bt_get(event_class
);
159 event
->clock_values
= g_hash_table_new_full(g_direct_hash
,
160 g_direct_equal
, NULL
, g_free
);
162 bt_ctf_field_create(validation_output
.event_header_type
);
167 if (validation_output
.stream_event_ctx_type
) {
168 stream_event_context
= bt_ctf_field_create(
169 validation_output
.stream_event_ctx_type
);
170 if (!stream_event_context
) {
175 if (validation_output
.event_context_type
) {
176 event_context
= bt_ctf_field_create(
177 validation_output
.event_context_type
);
178 if (!event_context
) {
183 if (validation_output
.event_payload_type
) {
184 event_payload
= bt_ctf_field_create(
185 validation_output
.event_payload_type
);
186 if (!event_payload
) {
192 * At this point all the fields are created, potentially from
193 * validated copies of field types, so that the field types and
194 * fields can be replaced in the trace, stream class,
195 * event class, and created event.
197 bt_ctf_validation_replace_types(trace
, stream_class
,
198 event_class
, &validation_output
, validation_flags
);
199 BT_MOVE(event
->event_header
, event_header
);
200 BT_MOVE(event
->stream_event_context
, stream_event_context
);
201 BT_MOVE(event
->context_payload
, event_context
);
202 BT_MOVE(event
->fields_payload
, event_payload
);
205 * Put what was not moved in bt_ctf_validation_replace_types().
207 bt_ctf_validation_output_put_types(&validation_output
);
210 * Freeze the stream class since the event header must not be changed
213 bt_ctf_stream_class_freeze(stream_class
);
216 * Mark stream class, and event class as valid since
217 * they're all frozen now.
219 stream_class
->valid
= 1;
220 event_class
->valid
= 1;
222 /* Put stuff we borrowed from the event class */
223 BT_PUT(stream_class
);
229 bt_ctf_validation_output_put_types(&validation_output
);
231 BT_PUT(stream_class
);
233 BT_PUT(event_header
);
234 BT_PUT(stream_event_context
);
235 BT_PUT(event_context
);
236 BT_PUT(event_payload
);
237 assert(!packet_header_type
);
238 assert(!packet_context_type
);
239 assert(!event_header_type
);
240 assert(!stream_event_ctx_type
);
241 assert(!event_context_type
);
242 assert(!event_payload_type
);
247 struct bt_ctf_event_class
*bt_ctf_event_get_class(struct bt_ctf_event
*event
)
249 struct bt_ctf_event_class
*event_class
= NULL
;
255 event_class
= event
->event_class
;
261 struct bt_ctf_stream
*bt_ctf_event_get_stream(struct bt_ctf_event
*event
)
263 struct bt_ctf_stream
*stream
= NULL
;
270 * If the event has a parent, then this is its (writer) stream.
271 * If the event has no parent, then if it has a packet, this
272 * is its (non-writer) stream.
274 if (event
->base
.parent
) {
275 stream
= (struct bt_ctf_stream
*) bt_object_get_parent(event
);
278 stream
= bt_get(event
->packet
->stream
);
286 struct bt_ctf_clock
*bt_ctf_event_get_clock(struct bt_ctf_event
*event
)
288 struct bt_ctf_clock
*clock
= NULL
;
289 struct bt_ctf_event_class
*event_class
;
290 struct bt_ctf_stream_class
*stream_class
;
296 event_class
= bt_ctf_event_get_class(event
);
301 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
303 goto error_put_event_class
;
306 clock
= bt_ctf_stream_class_get_clock(stream_class
);
308 goto error_put_stream_class
;
311 error_put_stream_class
:
312 bt_put(stream_class
);
313 error_put_event_class
:
319 int bt_ctf_event_set_payload(struct bt_ctf_event
*event
,
321 struct bt_ctf_field
*payload
)
325 if (!event
|| !payload
|| event
->frozen
) {
331 ret
= bt_ctf_field_structure_set_field(event
->fields_payload
,
334 struct bt_ctf_field_type
*payload_type
;
336 payload_type
= bt_ctf_field_get_type(payload
);
338 if (bt_ctf_field_type_compare(payload_type
,
339 event
->event_class
->fields
) == 0) {
340 bt_put(event
->fields_payload
);
342 event
->fields_payload
= payload
;
347 bt_put(payload_type
);
353 struct bt_ctf_field
*bt_ctf_event_get_payload_field(struct bt_ctf_event
*event
)
355 struct bt_ctf_field
*payload
= NULL
;
357 if (!event
|| !event
->fields_payload
) {
361 payload
= event
->fields_payload
;
367 int bt_ctf_event_set_payload_field(struct bt_ctf_event
*event
,
368 struct bt_ctf_field
*payload
)
371 struct bt_ctf_field_type
*payload_type
= NULL
;
373 if (!event
|| !payload
|| event
->frozen
) {
378 payload_type
= bt_ctf_field_get_type(payload
);
384 if (bt_ctf_field_type_get_type_id(payload_type
) !=
385 BT_CTF_TYPE_ID_STRUCT
) {
391 bt_put(event
->fields_payload
);
392 event
->fields_payload
= payload
;
395 bt_put(payload_type
);
399 struct bt_ctf_field
*bt_ctf_event_get_payload(struct bt_ctf_event
*event
,
402 struct bt_ctf_field
*field
= NULL
;
409 field
= bt_ctf_field_structure_get_field(event
->fields_payload
,
412 field
= event
->fields_payload
;
419 struct bt_ctf_field
*bt_ctf_event_get_payload_by_index(
420 struct bt_ctf_event
*event
, int index
)
422 struct bt_ctf_field
*field
= NULL
;
424 if (!event
|| index
< 0) {
428 field
= bt_ctf_field_structure_get_field_by_index(event
->fields_payload
,
434 struct bt_ctf_field
*bt_ctf_event_get_header(
435 struct bt_ctf_event
*event
)
437 struct bt_ctf_field
*header
= NULL
;
439 if (!event
|| !event
->event_header
) {
443 header
= event
->event_header
;
449 int bt_ctf_event_set_header(struct bt_ctf_event
*event
,
450 struct bt_ctf_field
*header
)
453 struct bt_ctf_field_type
*field_type
= NULL
;
454 struct bt_ctf_stream_class
*stream_class
= NULL
;
456 if (!event
|| !header
|| event
->frozen
) {
461 stream_class
= (struct bt_ctf_stream_class
*) bt_object_get_parent(
464 * Ensure the provided header's type matches the one registered to the
467 field_type
= bt_ctf_field_get_type(header
);
468 if (bt_ctf_field_type_compare(field_type
,
469 stream_class
->event_header_type
)) {
475 bt_put(event
->event_header
);
476 event
->event_header
= header
;
478 bt_put(stream_class
);
483 struct bt_ctf_field
*bt_ctf_event_get_event_context(
484 struct bt_ctf_event
*event
)
486 struct bt_ctf_field
*context
= NULL
;
488 if (!event
|| !event
->context_payload
) {
492 context
= event
->context_payload
;
498 int bt_ctf_event_set_event_context(struct bt_ctf_event
*event
,
499 struct bt_ctf_field
*context
)
502 struct bt_ctf_field_type
*field_type
= NULL
;
504 if (!event
|| !context
|| event
->frozen
) {
509 field_type
= bt_ctf_field_get_type(context
);
510 if (bt_ctf_field_type_compare(field_type
,
511 event
->event_class
->context
)) {
517 bt_put(event
->context_payload
);
518 event
->context_payload
= context
;
524 struct bt_ctf_field
*bt_ctf_event_get_stream_event_context(
525 struct bt_ctf_event
*event
)
527 struct bt_ctf_field
*stream_event_context
= NULL
;
529 if (!event
|| !event
->stream_event_context
) {
533 stream_event_context
= event
->stream_event_context
;
535 return bt_get(stream_event_context
);
538 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event
*event
,
539 struct bt_ctf_field
*stream_event_context
)
542 struct bt_ctf_field_type
*field_type
= NULL
;
543 struct bt_ctf_stream_class
*stream_class
= NULL
;
545 if (!event
|| !stream_event_context
|| event
->frozen
) {
550 stream_class
= bt_ctf_event_class_get_stream_class(event
->event_class
);
552 * We should not have been able to create the event without associating
553 * the event class to a stream class.
555 assert(stream_class
);
557 field_type
= bt_ctf_field_get_type(stream_event_context
);
558 if (bt_ctf_field_type_compare(field_type
,
559 stream_class
->event_context_type
)) {
564 bt_get(stream_event_context
);
565 BT_MOVE(event
->stream_event_context
, stream_event_context
);
567 BT_PUT(stream_class
);
572 void bt_ctf_event_get(struct bt_ctf_event
*event
)
577 void bt_ctf_event_put(struct bt_ctf_event
*event
)
582 void bt_ctf_event_destroy(struct bt_object
*obj
)
584 struct bt_ctf_event
*event
;
586 event
= container_of(obj
, struct bt_ctf_event
, base
);
587 if (!event
->base
.parent
) {
589 * Event was keeping a reference to its class since it shared no
590 * common ancestor with it to guarantee they would both have the
593 bt_put(event
->event_class
);
595 g_hash_table_destroy(event
->clock_values
);
596 bt_put(event
->event_header
);
597 bt_put(event
->stream_event_context
);
598 bt_put(event
->context_payload
);
599 bt_put(event
->fields_payload
);
600 bt_put(event
->packet
);
605 int set_integer_field_value(struct bt_ctf_field
* field
, uint64_t value
)
608 struct bt_ctf_field_type
*field_type
= NULL
;
615 if (!bt_ctf_field_validate(field
)) {
616 /* Payload already set, skip! (not an error) */
620 field_type
= bt_ctf_field_get_type(field
);
623 if (bt_ctf_field_type_get_type_id(field_type
) !=
624 BT_CTF_TYPE_ID_INTEGER
) {
625 /* Not an integer and the value is unset, error. */
630 if (bt_ctf_field_type_integer_get_signed(field_type
)) {
631 ret
= bt_ctf_field_signed_integer_set_value(field
, (int64_t) value
);
633 /* Value is out of range, error. */
637 ret
= bt_ctf_field_unsigned_integer_set_value(field
, value
);
639 /* Value is out of range, error. */
649 int bt_ctf_event_validate(struct bt_ctf_event
*event
)
651 /* Make sure each field's payload has been set */
653 struct bt_ctf_stream_class
*stream_class
= NULL
;
656 ret
= bt_ctf_field_validate(event
->event_header
);
661 stream_class
= bt_ctf_event_class_get_stream_class(event
->event_class
);
663 * We should not have been able to create the event without associating
664 * the event class to a stream class.
666 assert(stream_class
);
667 if (stream_class
->event_context_type
) {
668 ret
= bt_ctf_field_validate(event
->stream_event_context
);
674 ret
= bt_ctf_field_validate(event
->fields_payload
);
679 if (event
->event_class
->context
) {
680 ret
= bt_ctf_field_validate(event
->context_payload
);
683 bt_put(stream_class
);
688 int bt_ctf_event_serialize(struct bt_ctf_event
*event
,
689 struct ctf_stream_pos
*pos
)
695 if (event
->context_payload
) {
696 ret
= bt_ctf_field_serialize(event
->context_payload
, pos
);
702 if (event
->fields_payload
) {
703 ret
= bt_ctf_field_serialize(event
->fields_payload
, pos
);
713 int bt_ctf_event_populate_event_header(struct bt_ctf_event
*event
)
716 struct bt_ctf_field
*id_field
= NULL
, *timestamp_field
= NULL
;
718 if (!event
|| event
->frozen
) {
723 id_field
= bt_ctf_field_structure_get_field(event
->event_header
, "id");
725 ret
= set_integer_field_value(id_field
,
726 (uint64_t) bt_ctf_event_class_get_id(
727 event
->event_class
));
733 timestamp_field
= bt_ctf_field_structure_get_field(event
->event_header
,
735 if (timestamp_field
) {
736 struct bt_ctf_field_type
*timestamp_field_type
=
737 bt_ctf_field_get_type(timestamp_field
);
738 struct bt_ctf_clock
*mapped_clock
;
740 assert(timestamp_field_type
);
741 mapped_clock
= bt_ctf_field_type_integer_get_mapped_clock(
742 timestamp_field_type
);
743 bt_put(timestamp_field_type
);
747 ret
= bt_ctf_clock_get_time(mapped_clock
, ×tamp
);
748 bt_put(mapped_clock
);
753 ret
= set_integer_field_value(timestamp_field
,
762 bt_put(timestamp_field
);
766 int bt_ctf_event_set_packet(struct bt_ctf_event
*event
,
767 struct bt_ctf_packet
*packet
)
769 struct bt_ctf_stream_class
*event_stream_class
= NULL
;
770 struct bt_ctf_stream_class
*packet_stream_class
= NULL
;
771 struct bt_ctf_stream
*stream
= NULL
;
774 if (!event
|| !packet
|| event
->frozen
) {
780 * Make sure the new packet was created by this event's
781 * stream, if it is set.
783 stream
= bt_ctf_event_get_stream(event
);
785 if (packet
->stream
!= stream
) {
791 bt_ctf_event_class_get_stream_class(event
->event_class
);
792 packet_stream_class
=
793 bt_ctf_stream_get_class(packet
->stream
);
795 assert(event_stream_class
);
796 assert(packet_stream_class
);
798 if (event_stream_class
!= packet_stream_class
) {
805 BT_MOVE(event
->packet
, packet
);
809 BT_PUT(event_stream_class
);
810 BT_PUT(packet_stream_class
);
816 void bt_ctf_event_freeze(struct bt_ctf_event
*event
)
819 bt_ctf_packet_freeze(event
->packet
);
820 bt_ctf_field_freeze(event
->event_header
);
821 bt_ctf_field_freeze(event
->stream_event_context
);
822 bt_ctf_field_freeze(event
->context_payload
);
823 bt_ctf_field_freeze(event
->fields_payload
);
828 void insert_stream_clock_value_into_event_clock_values(gpointer key
,
832 struct bt_ctf_event
*event
= data
;
833 uint64_t *clock_value
;
837 /* Copy clock value because it belongs to the hash table */
838 clock_value
= g_new0(uint64_t, 1);
839 *clock_value
= *((uint64_t *) value
);
841 /* Insert copy into event clock values */
842 g_hash_table_insert(event
->clock_values
, key
, clock_value
);
846 int bt_ctf_event_register_stream_clock_values(struct bt_ctf_event
*event
)
849 struct bt_ctf_stream
*stream
;
851 stream
= bt_ctf_event_get_stream(event
);
853 g_hash_table_remove_all(event
->clock_values
);
854 g_hash_table_foreach(stream
->clock_values
,
855 insert_stream_clock_value_into_event_clock_values
, event
);
861 uint64_t bt_ctf_event_get_clock_value(struct bt_ctf_event
*event
,
862 struct bt_ctf_clock
*clock
)
864 uint64_t ret
= -1ULL;
865 uint64_t *clock_value
;
867 if (!event
|| !clock
) {
871 clock_value
= g_hash_table_lookup(event
->clock_values
, clock
);