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/trace-internal.h>
37 #include <babeltrace/ctf-ir/validation-internal.h>
38 #include <babeltrace/ctf-ir/utils.h>
39 #include <babeltrace/ref.h>
40 #include <babeltrace/ctf-ir/attributes-internal.h>
41 #include <babeltrace/compiler.h>
44 void bt_ctf_event_destroy(struct bt_object
*obj
);
46 int set_integer_field_value(struct bt_ctf_field
*field
, uint64_t value
);
48 struct bt_ctf_event
*bt_ctf_event_create(struct bt_ctf_event_class
*event_class
)
51 enum bt_ctf_validation_flag validation_flags
=
52 BT_CTF_VALIDATION_FLAG_STREAM
|
53 BT_CTF_VALIDATION_FLAG_EVENT
;
54 struct bt_ctf_event
*event
= NULL
;
55 struct bt_ctf_trace
*trace
= NULL
;
56 struct bt_ctf_stream_class
*stream_class
= NULL
;
57 struct bt_ctf_field_type
*packet_header_type
= NULL
;
58 struct bt_ctf_field_type
*packet_context_type
= NULL
;
59 struct bt_ctf_field_type
*event_header_type
= NULL
;
60 struct bt_ctf_field_type
*stream_event_ctx_type
= NULL
;
61 struct bt_ctf_field_type
*event_context_type
= NULL
;
62 struct bt_ctf_field_type
*event_payload_type
= NULL
;
63 struct bt_ctf_field
*event_header
= NULL
;
64 struct bt_ctf_field
*stream_event_context
= NULL
;
65 struct bt_ctf_field
*event_context
= NULL
;
66 struct bt_ctf_field
*event_payload
= NULL
;
67 struct bt_value
*environment
= NULL
;
68 struct bt_ctf_validation_output validation_output
= { 0 };
75 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
78 * We disallow the creation of an event if its event class has not been
79 * associated to a stream class.
85 /* A stream class should always have an existing event header type */
86 assert(stream_class
->event_header_type
);
88 /* The event class was frozen when added to its stream class */
89 assert(event_class
->frozen
);
91 /* Validate the trace (if any), the stream class, and the event class */
92 trace
= bt_ctf_stream_class_get_trace(stream_class
);
94 packet_header_type
= bt_ctf_trace_get_packet_header_type(trace
);
95 trace_valid
= trace
->valid
;
97 environment
= trace
->environment
;
100 packet_context_type
= bt_ctf_stream_class_get_packet_context_type(
102 event_header_type
= bt_ctf_stream_class_get_event_header_type(
104 stream_event_ctx_type
= bt_ctf_stream_class_get_event_context_type(
106 event_context_type
= bt_ctf_event_class_get_context_type(event_class
);
107 event_payload_type
= bt_ctf_event_class_get_payload_type(event_class
);
108 ret
= bt_ctf_validate_class_types(environment
, packet_header_type
,
109 packet_context_type
, event_header_type
, stream_event_ctx_type
,
110 event_context_type
, event_payload_type
, trace_valid
,
111 stream_class
->valid
, event_class
->valid
,
112 &validation_output
, validation_flags
);
113 BT_PUT(packet_header_type
);
114 BT_PUT(packet_context_type
);
115 BT_PUT(event_header_type
);
116 BT_PUT(stream_event_ctx_type
);
117 BT_PUT(event_context_type
);
118 BT_PUT(event_payload_type
);
121 * This means something went wrong during the validation
122 * process, not that the objects are invalid.
127 if ((validation_output
.valid_flags
& validation_flags
) !=
129 /* Invalid trace/stream class/event class */
134 * At this point we know the trace (if associated to the stream
135 * class), the stream class, and the event class, with their
136 * current types, are valid. We may proceed with creating
139 event
= g_new0(struct bt_ctf_event
, 1);
144 bt_object_init(event
, bt_ctf_event_destroy
);
147 * event does not share a common ancestor with the event class; it has
148 * to guarantee its existence by holding a reference. This reference
149 * shall be released once the event is associated to a stream since,
150 * from that point, the event and its class will share the same
153 event
->event_class
= bt_get(event_class
);
155 bt_ctf_field_create(validation_output
.event_header_type
);
160 if (validation_output
.stream_event_ctx_type
) {
161 stream_event_context
= bt_ctf_field_create(
162 validation_output
.stream_event_ctx_type
);
163 if (!stream_event_context
) {
168 if (validation_output
.event_context_type
) {
169 event_context
= bt_ctf_field_create(
170 validation_output
.event_context_type
);
171 if (!event_context
) {
176 if (validation_output
.event_payload_type
) {
177 event_payload
= bt_ctf_field_create(
178 validation_output
.event_payload_type
);
179 if (!event_payload
) {
185 * At this point all the fields are created, potentially from
186 * validated copies of field types, so that the field types and
187 * fields can be replaced in the trace, stream class,
188 * event class, and created event.
190 bt_ctf_validation_replace_types(trace
, stream_class
,
191 event_class
, &validation_output
, validation_flags
);
192 BT_MOVE(event
->event_header
, event_header
);
193 BT_MOVE(event
->stream_event_context
, stream_event_context
);
194 BT_MOVE(event
->context_payload
, event_context
);
195 BT_MOVE(event
->fields_payload
, event_payload
);
198 * Put what was not moved in bt_ctf_validation_replace_types().
200 bt_ctf_validation_output_put_types(&validation_output
);
203 * Freeze the stream class since the event header must not be changed
206 bt_ctf_stream_class_freeze(stream_class
);
209 * Mark stream class, and event class as valid since
210 * they're all frozen now.
212 stream_class
->valid
= 1;
213 event_class
->valid
= 1;
215 /* Put stuff we borrowed from the event class */
216 BT_PUT(stream_class
);
222 bt_ctf_validation_output_put_types(&validation_output
);
224 BT_PUT(stream_class
);
226 BT_PUT(event_header
);
227 BT_PUT(stream_event_context
);
228 BT_PUT(event_context
);
229 BT_PUT(event_payload
);
230 assert(!packet_header_type
);
231 assert(!packet_context_type
);
232 assert(!event_header_type
);
233 assert(!stream_event_ctx_type
);
234 assert(!event_context_type
);
235 assert(!event_payload_type
);
240 struct bt_ctf_event_class
*bt_ctf_event_get_class(struct bt_ctf_event
*event
)
242 struct bt_ctf_event_class
*event_class
= NULL
;
248 event_class
= event
->event_class
;
254 struct bt_ctf_stream
*bt_ctf_event_get_stream(struct bt_ctf_event
*event
)
256 return (struct bt_ctf_stream
*) bt_object_get_parent(event
);
259 struct bt_ctf_clock
*bt_ctf_event_get_clock(struct bt_ctf_event
*event
)
261 struct bt_ctf_clock
*clock
= NULL
;
262 struct bt_ctf_event_class
*event_class
;
263 struct bt_ctf_stream_class
*stream_class
;
269 event_class
= bt_ctf_event_get_class(event
);
274 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
276 goto error_put_event_class
;
279 clock
= bt_ctf_stream_class_get_clock(stream_class
);
281 goto error_put_stream_class
;
284 error_put_stream_class
:
285 bt_put(stream_class
);
286 error_put_event_class
:
292 int bt_ctf_event_set_payload(struct bt_ctf_event
*event
,
294 struct bt_ctf_field
*payload
)
298 if (!event
|| !payload
) {
304 ret
= bt_ctf_field_structure_set_field(event
->fields_payload
,
307 struct bt_ctf_field_type
*payload_type
;
309 payload_type
= bt_ctf_field_get_type(payload
);
311 if (bt_ctf_field_type_compare(payload_type
,
312 event
->event_class
->fields
) == 0) {
313 bt_put(event
->fields_payload
);
315 event
->fields_payload
= payload
;
320 bt_put(payload_type
);
326 struct bt_ctf_field
*bt_ctf_event_get_payload_field(struct bt_ctf_event
*event
)
328 struct bt_ctf_field
*payload
= NULL
;
330 if (!event
|| !event
->fields_payload
) {
334 payload
= event
->fields_payload
;
340 int bt_ctf_event_set_payload_field(struct bt_ctf_event
*event
,
341 struct bt_ctf_field
*payload
)
344 struct bt_ctf_field_type
*payload_type
= NULL
;
346 if (!event
|| !payload
) {
351 payload_type
= bt_ctf_field_get_type(payload
);
357 if (bt_ctf_field_type_get_type_id(payload_type
) !=
358 BT_CTF_TYPE_ID_STRUCT
) {
364 bt_put(event
->fields_payload
);
365 event
->fields_payload
= payload
;
368 bt_put(payload_type
);
372 struct bt_ctf_field
*bt_ctf_event_get_payload(struct bt_ctf_event
*event
,
375 struct bt_ctf_field
*field
= NULL
;
382 field
= bt_ctf_field_structure_get_field(event
->fields_payload
,
385 field
= event
->fields_payload
;
392 struct bt_ctf_field
*bt_ctf_event_get_payload_by_index(
393 struct bt_ctf_event
*event
, int index
)
395 struct bt_ctf_field
*field
= NULL
;
397 if (!event
|| index
< 0) {
401 field
= bt_ctf_field_structure_get_field_by_index(event
->fields_payload
,
407 struct bt_ctf_field
*bt_ctf_event_get_header(
408 struct bt_ctf_event
*event
)
410 struct bt_ctf_field
*header
= NULL
;
412 if (!event
|| !event
->event_header
) {
416 header
= event
->event_header
;
422 int bt_ctf_event_set_header(struct bt_ctf_event
*event
,
423 struct bt_ctf_field
*header
)
426 struct bt_ctf_field_type
*field_type
= NULL
;
427 struct bt_ctf_stream_class
*stream_class
= NULL
;
429 if (!event
|| !header
) {
434 stream_class
= (struct bt_ctf_stream_class
*) bt_object_get_parent(
437 * Ensure the provided header's type matches the one registered to the
440 field_type
= bt_ctf_field_get_type(header
);
441 if (bt_ctf_field_type_compare(field_type
,
442 stream_class
->event_header_type
)) {
448 bt_put(event
->event_header
);
449 event
->event_header
= header
;
451 bt_put(stream_class
);
456 struct bt_ctf_field
*bt_ctf_event_get_event_context(
457 struct bt_ctf_event
*event
)
459 struct bt_ctf_field
*context
= NULL
;
461 if (!event
|| !event
->context_payload
) {
465 context
= event
->context_payload
;
471 int bt_ctf_event_set_event_context(struct bt_ctf_event
*event
,
472 struct bt_ctf_field
*context
)
475 struct bt_ctf_field_type
*field_type
= NULL
;
477 if (!event
|| !context
) {
482 field_type
= bt_ctf_field_get_type(context
);
483 if (bt_ctf_field_type_compare(field_type
,
484 event
->event_class
->context
)) {
490 bt_put(event
->context_payload
);
491 event
->context_payload
= context
;
497 struct bt_ctf_field
*bt_ctf_event_get_stream_event_context(
498 struct bt_ctf_event
*event
)
500 struct bt_ctf_field
*stream_event_context
= NULL
;
502 if (!event
|| !event
->stream_event_context
) {
506 stream_event_context
= event
->stream_event_context
;
508 return bt_get(stream_event_context
);
511 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event
*event
,
512 struct bt_ctf_field
*stream_event_context
)
515 struct bt_ctf_field_type
*field_type
= NULL
;
516 struct bt_ctf_stream_class
*stream_class
= NULL
;
518 if (!event
|| !stream_event_context
) {
523 stream_class
= bt_ctf_event_class_get_stream_class(event
->event_class
);
525 * We should not have been able to create the event without associating
526 * the event class to a stream class.
528 assert(stream_class
);
530 field_type
= bt_ctf_field_get_type(stream_event_context
);
531 if (bt_ctf_field_type_compare(field_type
,
532 stream_class
->event_context_type
)) {
537 bt_get(stream_event_context
);
538 BT_MOVE(event
->stream_event_context
, stream_event_context
);
540 BT_PUT(stream_class
);
545 void bt_ctf_event_get(struct bt_ctf_event
*event
)
550 void bt_ctf_event_put(struct bt_ctf_event
*event
)
555 void bt_ctf_event_destroy(struct bt_object
*obj
)
557 struct bt_ctf_event
*event
;
559 event
= container_of(obj
, struct bt_ctf_event
, base
);
560 if (!event
->base
.parent
) {
562 * Event was keeping a reference to its class since it shared no
563 * common ancestor with it to guarantee they would both have the
566 bt_put(event
->event_class
);
568 bt_put(event
->event_header
);
569 bt_put(event
->stream_event_context
);
570 bt_put(event
->context_payload
);
571 bt_put(event
->fields_payload
);
576 int set_integer_field_value(struct bt_ctf_field
* field
, uint64_t value
)
579 struct bt_ctf_field_type
*field_type
= NULL
;
586 if (!bt_ctf_field_validate(field
)) {
587 /* Payload already set, skip! (not an error) */
591 field_type
= bt_ctf_field_get_type(field
);
594 if (bt_ctf_field_type_get_type_id(field_type
) !=
595 BT_CTF_TYPE_ID_INTEGER
) {
596 /* Not an integer and the value is unset, error. */
601 if (bt_ctf_field_type_integer_get_signed(field_type
)) {
602 ret
= bt_ctf_field_signed_integer_set_value(field
, (int64_t) value
);
604 /* Value is out of range, error. */
608 ret
= bt_ctf_field_unsigned_integer_set_value(field
, value
);
610 /* Value is out of range, error. */
620 int bt_ctf_event_validate(struct bt_ctf_event
*event
)
622 /* Make sure each field's payload has been set */
624 struct bt_ctf_stream_class
*stream_class
= NULL
;
627 ret
= bt_ctf_field_validate(event
->event_header
);
632 stream_class
= bt_ctf_event_class_get_stream_class(event
->event_class
);
634 * We should not have been able to create the event without associating
635 * the event class to a stream class.
637 assert(stream_class
);
638 if (stream_class
->event_context_type
) {
639 ret
= bt_ctf_field_validate(event
->stream_event_context
);
645 ret
= bt_ctf_field_validate(event
->fields_payload
);
650 if (event
->event_class
->context
) {
651 ret
= bt_ctf_field_validate(event
->context_payload
);
654 bt_put(stream_class
);
659 int bt_ctf_event_serialize(struct bt_ctf_event
*event
,
660 struct ctf_stream_pos
*pos
)
666 if (event
->context_payload
) {
667 ret
= bt_ctf_field_serialize(event
->context_payload
, pos
);
673 if (event
->fields_payload
) {
674 ret
= bt_ctf_field_serialize(event
->fields_payload
, pos
);
684 int bt_ctf_event_populate_event_header(struct bt_ctf_event
*event
)
687 struct bt_ctf_field
*id_field
= NULL
, *timestamp_field
= NULL
;
694 id_field
= bt_ctf_field_structure_get_field(event
->event_header
, "id");
696 ret
= set_integer_field_value(id_field
,
697 (uint64_t) bt_ctf_event_class_get_id(
698 event
->event_class
));
704 timestamp_field
= bt_ctf_field_structure_get_field(event
->event_header
,
706 if (timestamp_field
) {
707 struct bt_ctf_field_type
*timestamp_field_type
=
708 bt_ctf_field_get_type(timestamp_field
);
709 struct bt_ctf_clock
*mapped_clock
;
711 assert(timestamp_field_type
);
712 mapped_clock
= bt_ctf_field_type_integer_get_mapped_clock(
713 timestamp_field_type
);
714 bt_put(timestamp_field_type
);
718 ret
= bt_ctf_clock_get_time(mapped_clock
, ×tamp
);
719 bt_put(mapped_clock
);
724 ret
= set_integer_field_value(timestamp_field
,
733 bt_put(timestamp_field
);
737 struct bt_ctf_event
*bt_ctf_event_copy(struct bt_ctf_event
*event
)
739 struct bt_ctf_event
*copy
= NULL
;
745 copy
= g_new0(struct bt_ctf_event
, 1);
750 bt_object_init(copy
, bt_ctf_event_destroy
);
751 copy
->event_class
= bt_get(event
->event_class
);
753 if (event
->event_header
) {
754 copy
->event_header
= bt_ctf_field_copy(event
->event_header
);
755 if (!copy
->event_header
) {
760 if (event
->stream_event_context
) {
761 copy
->stream_event_context
=
762 bt_ctf_field_copy(event
->stream_event_context
);
763 if (!copy
->stream_event_context
) {
768 if (event
->context_payload
) {
769 copy
->context_payload
= bt_ctf_field_copy(
770 event
->context_payload
);
771 if (!copy
->context_payload
) {
776 if (event
->fields_payload
) {
777 copy
->fields_payload
= bt_ctf_field_copy(event
->fields_payload
);
778 if (!copy
->fields_payload
) {