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/clock-class.h>
32 #include <babeltrace/ctf-ir/event-internal.h>
33 #include <babeltrace/ctf-ir/event-class.h>
34 #include <babeltrace/ctf-ir/event-class-internal.h>
35 #include <babeltrace/ctf-ir/stream-class.h>
36 #include <babeltrace/ctf-ir/stream-class-internal.h>
37 #include <babeltrace/ctf-ir/stream-internal.h>
38 #include <babeltrace/ctf-ir/packet.h>
39 #include <babeltrace/ctf-ir/packet-internal.h>
40 #include <babeltrace/ctf-ir/trace-internal.h>
41 #include <babeltrace/ctf-ir/validation-internal.h>
42 #include <babeltrace/ctf-ir/packet-internal.h>
43 #include <babeltrace/ctf-ir/utils.h>
44 #include <babeltrace/ctf-writer/serialize-internal.h>
45 #include <babeltrace/ref.h>
46 #include <babeltrace/ctf-ir/attributes-internal.h>
47 #include <babeltrace/compiler.h>
50 void bt_ctf_event_destroy(struct bt_object
*obj
);
52 struct bt_ctf_event
*bt_ctf_event_create(struct bt_ctf_event_class
*event_class
)
55 enum bt_ctf_validation_flag validation_flags
=
56 BT_CTF_VALIDATION_FLAG_STREAM
|
57 BT_CTF_VALIDATION_FLAG_EVENT
;
58 struct bt_ctf_event
*event
= NULL
;
59 struct bt_ctf_trace
*trace
= NULL
;
60 struct bt_ctf_stream_class
*stream_class
= NULL
;
61 struct bt_ctf_field_type
*packet_header_type
= NULL
;
62 struct bt_ctf_field_type
*packet_context_type
= NULL
;
63 struct bt_ctf_field_type
*event_header_type
= NULL
;
64 struct bt_ctf_field_type
*stream_event_ctx_type
= NULL
;
65 struct bt_ctf_field_type
*event_context_type
= NULL
;
66 struct bt_ctf_field_type
*event_payload_type
= NULL
;
67 struct bt_ctf_field
*event_header
= NULL
;
68 struct bt_ctf_field
*stream_event_context
= NULL
;
69 struct bt_ctf_field
*event_context
= NULL
;
70 struct bt_ctf_field
*event_payload
= NULL
;
71 struct bt_value
*environment
= NULL
;
72 struct bt_ctf_validation_output validation_output
= { 0 };
79 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
82 * We disallow the creation of an event if its event class has not been
83 * associated to a stream class.
89 /* A stream class should always have an existing event header type */
90 assert(stream_class
->event_header_type
);
92 /* The event class was frozen when added to its stream class */
93 assert(event_class
->frozen
);
95 /* Validate the trace (if any), the stream class, and the event class */
96 trace
= bt_ctf_stream_class_get_trace(stream_class
);
98 packet_header_type
= bt_ctf_trace_get_packet_header_type(trace
);
99 trace_valid
= trace
->valid
;
101 environment
= trace
->environment
;
104 packet_context_type
= bt_ctf_stream_class_get_packet_context_type(
106 event_header_type
= bt_ctf_stream_class_get_event_header_type(
108 stream_event_ctx_type
= bt_ctf_stream_class_get_event_context_type(
110 event_context_type
= bt_ctf_event_class_get_context_type(event_class
);
111 event_payload_type
= bt_ctf_event_class_get_payload_type(event_class
);
112 ret
= bt_ctf_validate_class_types(environment
, packet_header_type
,
113 packet_context_type
, event_header_type
, stream_event_ctx_type
,
114 event_context_type
, event_payload_type
, trace_valid
,
115 stream_class
->valid
, event_class
->valid
,
116 &validation_output
, validation_flags
);
117 BT_PUT(packet_header_type
);
118 BT_PUT(packet_context_type
);
119 BT_PUT(event_header_type
);
120 BT_PUT(stream_event_ctx_type
);
121 BT_PUT(event_context_type
);
122 BT_PUT(event_payload_type
);
125 * This means something went wrong during the validation
126 * process, not that the objects are invalid.
131 if ((validation_output
.valid_flags
& validation_flags
) !=
133 /* Invalid trace/stream class/event class */
138 * At this point we know the trace (if associated to the stream
139 * class), the stream class, and the event class, with their
140 * current types, are valid. We may proceed with creating
143 event
= g_new0(struct bt_ctf_event
, 1);
148 bt_object_init(event
, bt_ctf_event_destroy
);
151 * event does not share a common ancestor with the event class; it has
152 * to guarantee its existence by holding a reference. This reference
153 * shall be released once the event is associated to a stream since,
154 * from that point, the event and its class will share the same
157 event
->event_class
= bt_get(event_class
);
158 event
->clock_values
= g_hash_table_new_full(g_direct_hash
,
159 g_direct_equal
, bt_put
, bt_put
);
161 bt_ctf_field_create(validation_output
.event_header_type
);
166 if (validation_output
.stream_event_ctx_type
) {
167 stream_event_context
= bt_ctf_field_create(
168 validation_output
.stream_event_ctx_type
);
169 if (!stream_event_context
) {
174 if (validation_output
.event_context_type
) {
175 event_context
= bt_ctf_field_create(
176 validation_output
.event_context_type
);
177 if (!event_context
) {
182 if (validation_output
.event_payload_type
) {
183 event_payload
= bt_ctf_field_create(
184 validation_output
.event_payload_type
);
185 if (!event_payload
) {
191 * At this point all the fields are created, potentially from
192 * validated copies of field types, so that the field types and
193 * fields can be replaced in the trace, stream class,
194 * event class, and created event.
196 bt_ctf_validation_replace_types(trace
, stream_class
,
197 event_class
, &validation_output
, validation_flags
);
198 BT_MOVE(event
->event_header
, event_header
);
199 BT_MOVE(event
->stream_event_context
, stream_event_context
);
200 BT_MOVE(event
->context_payload
, event_context
);
201 BT_MOVE(event
->fields_payload
, event_payload
);
204 * Put what was not moved in bt_ctf_validation_replace_types().
206 bt_ctf_validation_output_put_types(&validation_output
);
209 * Freeze the stream class since the event header must not be changed
212 bt_ctf_stream_class_freeze(stream_class
);
215 * Mark stream class, and event class as valid since
216 * they're all frozen now.
218 stream_class
->valid
= 1;
219 event_class
->valid
= 1;
221 /* Put stuff we borrowed from the event class */
222 BT_PUT(stream_class
);
228 bt_ctf_validation_output_put_types(&validation_output
);
230 BT_PUT(stream_class
);
232 BT_PUT(event_header
);
233 BT_PUT(stream_event_context
);
234 BT_PUT(event_context
);
235 BT_PUT(event_payload
);
236 assert(!packet_header_type
);
237 assert(!packet_context_type
);
238 assert(!event_header_type
);
239 assert(!stream_event_ctx_type
);
240 assert(!event_context_type
);
241 assert(!event_payload_type
);
246 struct bt_ctf_event_class
*bt_ctf_event_get_class(struct bt_ctf_event
*event
)
248 struct bt_ctf_event_class
*event_class
= NULL
;
254 event_class
= event
? bt_get(bt_ctf_event_borrow_event_class(event
)) :
260 struct bt_ctf_stream
*bt_ctf_event_get_stream(struct bt_ctf_event
*event
)
262 struct bt_ctf_stream
*stream
= NULL
;
269 * If the event has a parent, then this is its (writer) stream.
270 * If the event has no parent, then if it has a packet, this
271 * is its (non-writer) stream.
273 if (event
->base
.parent
) {
274 stream
= (struct bt_ctf_stream
*) bt_object_get_parent(event
);
277 stream
= bt_get(event
->packet
->stream
);
285 int bt_ctf_event_set_payload(struct bt_ctf_event
*event
,
287 struct bt_ctf_field
*payload
)
291 if (!event
|| !payload
|| event
->frozen
) {
297 ret
= bt_ctf_field_structure_set_field(event
->fields_payload
,
300 struct bt_ctf_field_type
*payload_type
;
302 payload_type
= bt_ctf_field_get_type(payload
);
304 if (bt_ctf_field_type_compare(payload_type
,
305 event
->event_class
->fields
) == 0) {
306 bt_put(event
->fields_payload
);
308 event
->fields_payload
= payload
;
313 bt_put(payload_type
);
319 struct bt_ctf_field
*bt_ctf_event_get_payload_field(struct bt_ctf_event
*event
)
321 struct bt_ctf_field
*payload
= NULL
;
323 if (!event
|| !event
->fields_payload
) {
327 payload
= event
->fields_payload
;
333 int bt_ctf_event_set_payload_field(struct bt_ctf_event
*event
,
334 struct bt_ctf_field
*payload
)
337 struct bt_ctf_field_type
*payload_type
= NULL
;
339 if (!event
|| event
->frozen
) {
344 payload_type
= bt_ctf_field_get_type(payload
);
350 if (bt_ctf_field_type_get_type_id(payload_type
) !=
351 BT_CTF_FIELD_TYPE_ID_STRUCT
) {
356 bt_put(event
->fields_payload
);
357 event
->fields_payload
= bt_get(payload
);
359 bt_put(payload_type
);
363 struct bt_ctf_field
*bt_ctf_event_get_payload(struct bt_ctf_event
*event
,
366 struct bt_ctf_field
*field
= NULL
;
373 field
= bt_ctf_field_structure_get_field(event
->fields_payload
,
376 field
= event
->fields_payload
;
383 struct bt_ctf_field
*bt_ctf_event_get_payload_by_index(
384 struct bt_ctf_event
*event
, int index
)
386 struct bt_ctf_field
*field
= NULL
;
388 if (!event
|| index
< 0) {
392 field
= bt_ctf_field_structure_get_field_by_index(event
->fields_payload
,
398 struct bt_ctf_field
*bt_ctf_event_get_header(
399 struct bt_ctf_event
*event
)
401 struct bt_ctf_field
*header
= NULL
;
403 if (!event
|| !event
->event_header
) {
407 header
= event
->event_header
;
413 int bt_ctf_event_set_header(struct bt_ctf_event
*event
,
414 struct bt_ctf_field
*header
)
417 struct bt_ctf_field_type
*field_type
= NULL
;
418 struct bt_ctf_stream_class
*stream_class
= NULL
;
420 if (!event
|| event
->frozen
) {
425 stream_class
= (struct bt_ctf_stream_class
*) bt_object_get_parent(
428 * Ensure the provided header's type matches the one registered to the
431 field_type
= bt_ctf_field_get_type(header
);
432 if (bt_ctf_field_type_compare(field_type
,
433 stream_class
->event_header_type
)) {
438 bt_put(event
->event_header
);
439 event
->event_header
= bt_get(header
);
441 bt_put(stream_class
);
446 struct bt_ctf_field
*bt_ctf_event_get_event_context(
447 struct bt_ctf_event
*event
)
449 struct bt_ctf_field
*context
= NULL
;
451 if (!event
|| !event
->context_payload
) {
455 context
= event
->context_payload
;
461 int bt_ctf_event_set_event_context(struct bt_ctf_event
*event
,
462 struct bt_ctf_field
*context
)
465 struct bt_ctf_field_type
*field_type
= NULL
;
467 if (!event
|| event
->frozen
) {
472 field_type
= bt_ctf_field_get_type(context
);
473 if (bt_ctf_field_type_compare(field_type
,
474 event
->event_class
->context
)) {
479 bt_put(event
->context_payload
);
480 event
->context_payload
= bt_get(context
);
486 struct bt_ctf_field
*bt_ctf_event_get_stream_event_context(
487 struct bt_ctf_event
*event
)
489 struct bt_ctf_field
*stream_event_context
= NULL
;
491 if (!event
|| !event
->stream_event_context
) {
495 stream_event_context
= event
->stream_event_context
;
497 return bt_get(stream_event_context
);
500 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event
*event
,
501 struct bt_ctf_field
*stream_event_context
)
504 struct bt_ctf_field_type
*field_type
= NULL
;
505 struct bt_ctf_stream_class
*stream_class
= NULL
;
507 if (!event
|| event
->frozen
) {
512 stream_class
= bt_ctf_event_class_get_stream_class(event
->event_class
);
514 * We should not have been able to create the event without associating
515 * the event class to a stream class.
517 assert(stream_class
);
519 field_type
= bt_ctf_field_get_type(stream_event_context
);
520 if (bt_ctf_field_type_compare(field_type
,
521 stream_class
->event_context_type
)) {
526 bt_get(stream_event_context
);
527 BT_MOVE(event
->stream_event_context
, stream_event_context
);
529 BT_PUT(stream_class
);
534 void bt_ctf_event_get(struct bt_ctf_event
*event
)
539 void bt_ctf_event_put(struct bt_ctf_event
*event
)
544 void bt_ctf_event_destroy(struct bt_object
*obj
)
546 struct bt_ctf_event
*event
;
548 event
= container_of(obj
, struct bt_ctf_event
, base
);
549 if (!event
->base
.parent
) {
551 * Event was keeping a reference to its class since it shared no
552 * common ancestor with it to guarantee they would both have the
555 bt_put(event
->event_class
);
557 g_hash_table_destroy(event
->clock_values
);
558 bt_put(event
->event_header
);
559 bt_put(event
->stream_event_context
);
560 bt_put(event
->context_payload
);
561 bt_put(event
->fields_payload
);
562 bt_put(event
->packet
);
566 struct bt_ctf_clock_value
*bt_ctf_event_get_clock_value(
567 struct bt_ctf_event
*event
, struct bt_ctf_clock_class
*clock_class
)
569 struct bt_ctf_clock_value
*clock_value
= NULL
;
571 if (!event
|| !clock_class
) {
575 clock_value
= g_hash_table_lookup(event
->clock_values
, clock_class
);
585 int bt_ctf_event_set_clock_value(struct bt_ctf_event
*event
,
586 struct bt_ctf_clock_value
*value
)
590 if (!event
|| !value
|| event
->frozen
) {
595 g_hash_table_insert(event
->clock_values
,
596 bt_ctf_clock_value_get_class(value
), bt_get(value
));
602 int bt_ctf_event_validate(struct bt_ctf_event
*event
)
604 /* Make sure each field's payload has been set */
606 struct bt_ctf_stream_class
*stream_class
= NULL
;
609 ret
= bt_ctf_field_validate(event
->event_header
);
614 stream_class
= bt_ctf_event_class_get_stream_class(event
->event_class
);
616 * We should not have been able to create the event without associating
617 * the event class to a stream class.
619 assert(stream_class
);
620 if (stream_class
->event_context_type
) {
621 ret
= bt_ctf_field_validate(event
->stream_event_context
);
627 ret
= bt_ctf_field_validate(event
->fields_payload
);
632 if (event
->event_class
->context
) {
633 ret
= bt_ctf_field_validate(event
->context_payload
);
636 bt_put(stream_class
);
641 int bt_ctf_event_serialize(struct bt_ctf_event
*event
,
642 struct bt_ctf_stream_pos
*pos
,
643 enum bt_ctf_byte_order native_byte_order
)
650 if (event
->context_payload
) {
651 ret
= bt_ctf_field_serialize(event
->context_payload
, pos
,
658 if (event
->fields_payload
) {
659 ret
= bt_ctf_field_serialize(event
->fields_payload
, pos
,
669 struct bt_ctf_packet
*bt_ctf_event_get_packet(struct bt_ctf_event
*event
)
671 struct bt_ctf_packet
*packet
= NULL
;
673 if (!event
|| !event
->packet
) {
677 packet
= bt_get(event
->packet
);
682 int bt_ctf_event_set_packet(struct bt_ctf_event
*event
,
683 struct bt_ctf_packet
*packet
)
685 struct bt_ctf_stream_class
*event_stream_class
= NULL
;
686 struct bt_ctf_stream_class
*packet_stream_class
= NULL
;
687 struct bt_ctf_stream
*stream
= NULL
;
690 if (!event
|| !packet
|| event
->frozen
) {
696 * Make sure the new packet was created by this event's
697 * stream, if it is set.
699 stream
= bt_ctf_event_get_stream(event
);
701 if (packet
->stream
!= stream
) {
707 bt_ctf_event_class_get_stream_class(event
->event_class
);
708 packet_stream_class
=
709 bt_ctf_stream_get_class(packet
->stream
);
711 assert(event_stream_class
);
712 assert(packet_stream_class
);
714 if (event_stream_class
!= packet_stream_class
) {
721 BT_MOVE(event
->packet
, packet
);
725 BT_PUT(event_stream_class
);
726 BT_PUT(packet_stream_class
);
732 void bt_ctf_event_freeze(struct bt_ctf_event
*event
)
735 bt_ctf_packet_freeze(event
->packet
);
736 bt_ctf_field_freeze(event
->event_header
);
737 bt_ctf_field_freeze(event
->stream_event_context
);
738 bt_ctf_field_freeze(event
->context_payload
);
739 bt_ctf_field_freeze(event
->fields_payload
);