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
*event_context
= NULL
;
65 struct bt_ctf_field
*event_payload
= NULL
;
66 struct bt_value
*environment
= NULL
;
67 struct bt_ctf_validation_output validation_output
= { 0 };
74 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
77 * We disallow the creation of an event if its event class has not been
78 * associated to a stream class.
84 /* A stream class should always have an existing event header type */
85 assert(stream_class
->event_header_type
);
87 /* The event class was frozen when added to its stream class */
88 assert(event_class
->frozen
);
90 /* Validate the trace (if any), the stream class, and the event class */
91 trace
= bt_ctf_stream_class_get_trace(stream_class
);
93 packet_header_type
= bt_ctf_trace_get_packet_header_type(trace
);
94 trace_valid
= trace
->valid
;
96 environment
= trace
->environment
;
99 packet_context_type
= bt_ctf_stream_class_get_packet_context_type(
101 event_header_type
= bt_ctf_stream_class_get_event_header_type(
103 stream_event_ctx_type
= bt_ctf_stream_class_get_event_context_type(
105 event_context_type
= bt_ctf_event_class_get_context_type(event_class
);
106 event_payload_type
= bt_ctf_event_class_get_payload_type(event_class
);
107 ret
= bt_ctf_validate_class_types(environment
, packet_header_type
,
108 packet_context_type
, event_header_type
, stream_event_ctx_type
,
109 event_context_type
, event_payload_type
, trace_valid
,
110 stream_class
->valid
, event_class
->valid
,
111 &validation_output
, validation_flags
);
112 BT_PUT(packet_header_type
);
113 BT_PUT(packet_context_type
);
114 BT_PUT(event_header_type
);
115 BT_PUT(stream_event_ctx_type
);
116 BT_PUT(event_context_type
);
117 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
);
161 if (validation_output
.event_context_type
) {
162 event_context
= bt_ctf_field_create(
163 validation_output
.event_context_type
);
164 if (!event_context
) {
169 if (validation_output
.event_payload_type
) {
170 event_payload
= bt_ctf_field_create(
171 validation_output
.event_payload_type
);
172 if (!event_payload
) {
178 * At this point all the fields are created, potentially from
179 * validated copies of field types, so that the field types and
180 * fields can be replaced in the trace, stream class,
181 * event class, and created event.
183 bt_ctf_validation_replace_types(trace
, stream_class
,
184 event_class
, &validation_output
, validation_flags
);
185 BT_MOVE(event
->event_header
, event_header
);
186 BT_MOVE(event
->context_payload
, event_context
);
187 BT_MOVE(event
->fields_payload
, event_payload
);
190 * Put what was not moved in bt_ctf_validation_replace_types().
192 bt_ctf_validation_output_put_types(&validation_output
);
195 * Freeze the stream class since the event header must not be changed
198 bt_ctf_stream_class_freeze(stream_class
);
201 * Mark stream class, and event class as valid since
202 * they're all frozen now.
204 stream_class
->valid
= 1;
205 event_class
->valid
= 1;
207 /* Put stuff we borrowed from the event class */
208 BT_PUT(stream_class
);
214 bt_ctf_validation_output_put_types(&validation_output
);
216 BT_PUT(stream_class
);
218 BT_PUT(event_header
);
219 BT_PUT(event_context
);
220 BT_PUT(event_payload
);
221 assert(!packet_header_type
);
222 assert(!packet_context_type
);
223 assert(!event_header_type
);
224 assert(!stream_event_ctx_type
);
225 assert(!event_context_type
);
226 assert(!event_payload_type
);
231 struct bt_ctf_event_class
*bt_ctf_event_get_class(struct bt_ctf_event
*event
)
233 struct bt_ctf_event_class
*event_class
= NULL
;
239 event_class
= event
->event_class
;
245 struct bt_ctf_stream
*bt_ctf_event_get_stream(struct bt_ctf_event
*event
)
247 return (struct bt_ctf_stream
*) bt_object_get_parent(event
);
250 struct bt_ctf_clock
*bt_ctf_event_get_clock(struct bt_ctf_event
*event
)
252 struct bt_ctf_clock
*clock
= NULL
;
253 struct bt_ctf_event_class
*event_class
;
254 struct bt_ctf_stream_class
*stream_class
;
260 event_class
= bt_ctf_event_get_class(event
);
265 stream_class
= bt_ctf_event_class_get_stream_class(event_class
);
267 goto error_put_event_class
;
270 clock
= bt_ctf_stream_class_get_clock(stream_class
);
272 goto error_put_stream_class
;
275 error_put_stream_class
:
276 bt_put(stream_class
);
277 error_put_event_class
:
283 int bt_ctf_event_set_payload(struct bt_ctf_event
*event
,
285 struct bt_ctf_field
*payload
)
289 if (!event
|| !payload
) {
295 ret
= bt_ctf_field_structure_set_field(event
->fields_payload
,
298 struct bt_ctf_field_type
*payload_type
;
300 payload_type
= bt_ctf_field_get_type(payload
);
302 if (bt_ctf_field_type_compare(payload_type
,
303 event
->event_class
->fields
) == 0) {
304 bt_put(event
->fields_payload
);
306 event
->fields_payload
= payload
;
311 bt_put(payload_type
);
317 struct bt_ctf_field
*bt_ctf_event_get_payload_field(struct bt_ctf_event
*event
)
319 struct bt_ctf_field
*payload
= NULL
;
321 if (!event
|| !event
->fields_payload
) {
325 payload
= event
->fields_payload
;
331 int bt_ctf_event_set_payload_field(struct bt_ctf_event
*event
,
332 struct bt_ctf_field
*payload
)
335 struct bt_ctf_field_type
*payload_type
= NULL
;
337 if (!event
|| !payload
) {
342 payload_type
= bt_ctf_field_get_type(payload
);
348 if (bt_ctf_field_type_get_type_id(payload_type
) !=
349 BT_CTF_TYPE_ID_STRUCT
) {
355 bt_put(event
->fields_payload
);
356 event
->fields_payload
= 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
|| !header
) {
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
)) {
439 bt_put(event
->event_header
);
440 event
->event_header
= header
;
442 bt_put(stream_class
);
447 struct bt_ctf_field
*bt_ctf_event_get_event_context(
448 struct bt_ctf_event
*event
)
450 struct bt_ctf_field
*context
= NULL
;
452 if (!event
|| !event
->context_payload
) {
456 context
= event
->context_payload
;
462 int bt_ctf_event_set_event_context(struct bt_ctf_event
*event
,
463 struct bt_ctf_field
*context
)
466 struct bt_ctf_field_type
*field_type
= NULL
;
468 if (!event
|| !context
) {
473 field_type
= bt_ctf_field_get_type(context
);
474 if (bt_ctf_field_type_compare(field_type
,
475 event
->event_class
->context
)) {
481 bt_put(event
->context_payload
);
482 event
->context_payload
= context
;
488 void bt_ctf_event_get(struct bt_ctf_event
*event
)
493 void bt_ctf_event_put(struct bt_ctf_event
*event
)
498 void bt_ctf_event_destroy(struct bt_object
*obj
)
500 struct bt_ctf_event
*event
;
502 event
= container_of(obj
, struct bt_ctf_event
, base
);
503 if (!event
->base
.parent
) {
505 * Event was keeping a reference to its class since it shared no
506 * common ancestor with it to guarantee they would both have the
509 bt_put(event
->event_class
);
511 bt_put(event
->event_header
);
512 bt_put(event
->context_payload
);
513 bt_put(event
->fields_payload
);
518 int set_integer_field_value(struct bt_ctf_field
* field
, uint64_t value
)
521 struct bt_ctf_field_type
*field_type
= NULL
;
528 if (!bt_ctf_field_validate(field
)) {
529 /* Payload already set, skip! (not an error) */
533 field_type
= bt_ctf_field_get_type(field
);
536 if (bt_ctf_field_type_get_type_id(field_type
) !=
537 BT_CTF_TYPE_ID_INTEGER
) {
538 /* Not an integer and the value is unset, error. */
543 if (bt_ctf_field_type_integer_get_signed(field_type
)) {
544 ret
= bt_ctf_field_signed_integer_set_value(field
, (int64_t) value
);
546 /* Value is out of range, error. */
550 ret
= bt_ctf_field_unsigned_integer_set_value(field
, value
);
552 /* Value is out of range, error. */
562 int bt_ctf_event_validate(struct bt_ctf_event
*event
)
564 /* Make sure each field's payload has been set */
568 ret
= bt_ctf_field_validate(event
->event_header
);
573 ret
= bt_ctf_field_validate(event
->fields_payload
);
578 if (event
->event_class
->context
) {
579 ret
= bt_ctf_field_validate(event
->context_payload
);
586 int bt_ctf_event_serialize(struct bt_ctf_event
*event
,
587 struct ctf_stream_pos
*pos
)
593 if (event
->context_payload
) {
594 ret
= bt_ctf_field_serialize(event
->context_payload
, pos
);
600 if (event
->fields_payload
) {
601 ret
= bt_ctf_field_serialize(event
->fields_payload
, pos
);
611 int bt_ctf_event_populate_event_header(struct bt_ctf_event
*event
)
614 struct bt_ctf_field
*id_field
= NULL
, *timestamp_field
= NULL
;
621 id_field
= bt_ctf_field_structure_get_field(event
->event_header
, "id");
623 ret
= set_integer_field_value(id_field
,
624 (uint64_t) bt_ctf_event_class_get_id(
625 event
->event_class
));
631 timestamp_field
= bt_ctf_field_structure_get_field(event
->event_header
,
633 if (timestamp_field
) {
634 struct bt_ctf_field_type
*timestamp_field_type
=
635 bt_ctf_field_get_type(timestamp_field
);
636 struct bt_ctf_clock
*mapped_clock
;
638 assert(timestamp_field_type
);
639 mapped_clock
= bt_ctf_field_type_integer_get_mapped_clock(
640 timestamp_field_type
);
641 bt_put(timestamp_field_type
);
645 ret
= bt_ctf_clock_get_time(mapped_clock
, ×tamp
);
646 bt_put(mapped_clock
);
651 ret
= set_integer_field_value(timestamp_field
,
660 bt_put(timestamp_field
);
664 struct bt_ctf_event
*bt_ctf_event_copy(struct bt_ctf_event
*event
)
666 struct bt_ctf_event
*copy
= NULL
;
672 copy
= g_new0(struct bt_ctf_event
, 1);
677 bt_object_init(copy
, bt_ctf_event_destroy
);
678 copy
->event_class
= bt_get(event
->event_class
);
680 if (event
->event_header
) {
681 copy
->event_header
= bt_ctf_field_copy(event
->event_header
);
683 if (!copy
->event_header
) {
688 if (event
->context_payload
) {
689 copy
->context_payload
= bt_ctf_field_copy(
690 event
->context_payload
);
692 if (!copy
->context_payload
) {
697 if (event
->fields_payload
) {
698 copy
->fields_payload
= bt_ctf_field_copy(event
->fields_payload
);
700 if (!copy
->fields_payload
) {