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_common_validate_types_for_create(
60 struct bt_event_class_common
*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_common
*trace
= NULL
;
69 struct bt_stream_class_common
*stream_class
= NULL
;
70 struct bt_field_type_common
*packet_header_type
= NULL
;
71 struct bt_field_type_common
*packet_context_type
= NULL
;
72 struct bt_field_type_common
*event_header_type
= NULL
;
73 struct bt_field_type_common
*stream_event_ctx_type
= NULL
;
74 struct bt_field_type_common
*event_context_type
= NULL
;
75 struct bt_field_type_common
*event_payload_type
= NULL
;
77 struct bt_value
*environment
= NULL
;
79 stream_class
= bt_event_class_common_borrow_stream_class(event_class
);
80 BT_ASSERT(stream_class
);
81 trace
= bt_stream_class_common_borrow_trace(stream_class
);
83 BT_LOGD_STR("Event class is part of a trace.");
85 bt_trace_common_borrow_packet_header_field_type(trace
);
86 trace_valid
= trace
->valid
;
87 BT_ASSERT(trace_valid
);
88 environment
= trace
->environment
;
92 bt_stream_class_common_borrow_packet_context_field_type(
95 bt_stream_class_common_borrow_event_header_field_type(
97 stream_event_ctx_type
=
98 bt_stream_class_common_borrow_event_context_field_type(
101 bt_event_class_common_borrow_context_field_type(event_class
);
103 bt_event_class_common_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_common_create_fields(
138 struct bt_stream_class_common
*stream_class
,
139 struct bt_validation_output
*validation_output
,
140 void *(*create_field_func
)(void *),
141 void (*release_field_func
)(void *),
142 void *(*create_header_field_func
)(void *, void *),
143 void (*release_header_field_func
)(void *),
144 struct bt_field_wrapper
**header_field
,
145 struct bt_field_common
**stream_event_context_field
,
146 struct bt_field_common
**context_field
,
147 struct bt_field_common
**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
);
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_common_validate(struct bt_event_common
*event
)
225 struct bt_stream_class_common
*stream_class
;
228 if (event
->header_field
) {
229 ret
= bt_field_common_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_common_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_common_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_common_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_common_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_common_freeze(struct bt_event_common
*event
)
289 BT_LOGD("Freezing event: addr=%p, "
290 "event-class-name=\"%s\", event-class-id=%" PRId64
,
291 event
, bt_event_class_common_get_name(event
->class),
292 bt_event_class_common_get_id(event
->class));
294 if (event
->header_field
) {
295 BT_LOGD_STR("Freezing event's header field.");
296 bt_field_common_set_is_frozen_recursive(
297 event
->header_field
->field
, true);
300 if (event
->stream_event_context_field
) {
301 BT_LOGD_STR("Freezing event's stream event context field.");
302 bt_field_common_set_is_frozen_recursive(
303 event
->stream_event_context_field
, true);
306 if (event
->context_field
) {
307 BT_LOGD_STR("Freezing event's context field.");
308 bt_field_common_set_is_frozen_recursive(event
->context_field
, true);
311 if (event
->payload_field
) {
312 BT_LOGD_STR("Freezing event's payload field.");
313 bt_field_common_set_is_frozen_recursive(event
->payload_field
, true);
320 int bt_event_common_initialize(struct bt_event_common
*event
,
321 struct bt_event_class_common
*event_class
,
322 struct bt_clock_class
*init_expected_clock_class
,
323 bt_object_release_func release_func
,
324 bt_validation_flag_copy_field_type_func field_type_copy_func
,
325 bool must_be_in_trace
,
326 int (*map_clock_classes_func
)(struct bt_stream_class_common
*stream_class
,
327 struct bt_field_type_common
*packet_context_field_type
,
328 struct bt_field_type_common
*event_header_field_type
),
329 void *(*create_field_func
)(void *),
330 void (*release_field_func
)(void *),
331 void *(*create_header_field_func
)(void *, void *),
332 void (*release_header_field_func
)(void *))
335 struct bt_trace_common
*trace
= NULL
;
336 struct bt_stream_class_common
*stream_class
= NULL
;
337 struct bt_field_wrapper
*event_header
= NULL
;
338 struct bt_field_common
*stream_event_context
= NULL
;
339 struct bt_field_common
*event_context
= NULL
;
340 struct bt_field_common
*event_payload
= NULL
;
341 struct bt_validation_output validation_output
= { 0 };
342 struct bt_clock_class
*expected_clock_class
=
343 init_expected_clock_class
? bt_get(init_expected_clock_class
) :
346 BT_ASSERT_PRE_NON_NULL(event_class
, "Event class");
347 BT_LOGD("Initializing common event object: event-class-addr=%p, "
348 "event-class-name=\"%s\", event-class-id=%" PRId64
,
349 event_class
, bt_event_class_common_get_name(event_class
),
350 bt_event_class_common_get_id(event_class
));
352 stream_class
= bt_event_class_common_borrow_stream_class(event_class
);
353 BT_ASSERT_PRE(stream_class
,
354 "Event class is not part of a stream class: %!+_E", event_class
);
356 /* The event class was frozen when added to its stream class */
357 BT_ASSERT(event_class
->frozen
);
358 trace
= bt_stream_class_common_borrow_trace(stream_class
);
360 if (must_be_in_trace
) {
362 "Event class's stream class is not part of a trace: "
363 "%![ec-]+_E, %![ec-]+_S", event_class
, stream_class
);
367 * This must be called before anything that can fail because on
368 * failure, the caller releases the reference to `event` to
371 bt_object_init(event
, release_func
);
373 if (!stream_class
->frozen
) {
375 * Because this function freezes the stream class,
376 * validate that this stream class contains at most a
377 * single clock class so that we set its expected clock
378 * class for future checks.
380 ret
= bt_stream_class_common_validate_single_clock_class(
381 stream_class
, &expected_clock_class
);
383 BT_LOGW("Event class's stream class or one of its event "
384 "classes contains a field type which is not "
385 "recursively mapped to the expected "
387 "stream-class-addr=%p, "
388 "stream-class-id=%" PRId64
", "
389 "stream-class-name=\"%s\", "
390 "expected-clock-class-addr=%p, "
391 "expected-clock-class-name=\"%s\"",
393 bt_stream_class_common_get_id(stream_class
),
394 bt_stream_class_common_get_name(stream_class
),
395 expected_clock_class
,
396 expected_clock_class
?
397 bt_clock_class_get_name(expected_clock_class
) :
403 /* Validate the trace, the stream class, and the event class */
404 ret
= bt_event_common_validate_types_for_create(
405 event_class
, &validation_output
, field_type_copy_func
);
407 /* bt_event_common_validate_types_for_create() logs errors */
411 if (map_clock_classes_func
) {
413 * Safe to automatically map selected fields to the
414 * stream's clock's class here because the stream class
415 * is about to be frozen.
417 if (map_clock_classes_func(stream_class
,
418 validation_output
.packet_context_type
,
419 validation_output
.event_header_type
)) {
420 BT_LOGW_STR("Cannot automatically map selected stream class's "
421 "field types to stream class's clock's class.");
427 * event does not share a common ancestor with the event class; it has
428 * to guarantee its existence by holding a reference. This reference
429 * shall be released once the event is associated to a stream since,
430 * from that point, the event and its class will share the same
433 event
->class = bt_get(event_class
);
435 ret
= bt_event_common_create_fields(stream_class
,
437 create_field_func
, release_field_func
,
438 create_header_field_func
, release_header_field_func
,
439 &event_header
, &stream_event_context
, &event_context
,
442 /* bt_event_common_create_fields() logs errors */
447 * At this point all the fields are created, potentially from
448 * validated copies of field types, so that the field types and
449 * fields can be replaced in the trace, stream class,
450 * event class, and created event.
452 bt_validation_replace_types(trace
, stream_class
, event_class
,
454 BT_VALIDATION_FLAG_STREAM
| BT_VALIDATION_FLAG_EVENT
);
455 event
->header_field
= event_header
;
457 event
->stream_event_context_field
= stream_event_context
;
458 stream_event_context
= NULL
;
459 event
->context_field
= event_context
;
460 event_context
= NULL
;
461 event
->payload_field
= event_payload
;
462 event_payload
= NULL
;
465 * Put what was not moved in bt_validation_replace_types().
467 bt_validation_output_put_types(&validation_output
);
470 * Freeze the stream class since the event header must not be changed
473 bt_stream_class_common_freeze(stream_class
);
476 * It is safe to set the stream class's unique clock class
477 * now because the stream class is frozen.
479 if (expected_clock_class
) {
480 BT_MOVE(stream_class
->clock_class
, expected_clock_class
);
484 * Mark stream class, and event class as valid since
485 * they're all frozen now.
487 stream_class
->valid
= 1;
488 event_class
->valid
= 1;
490 /* Put stuff we borrowed from the event class */
491 BT_LOGD("Initialized event object: addr=%p, event-class-name=\"%s\", "
492 "event-class-id=%" PRId64
,
493 event
, bt_event_class_common_get_name(event
->class),
494 bt_event_class_common_get_id(event
->class));
498 bt_validation_output_put_types(&validation_output
);
499 bt_put(expected_clock_class
);
502 release_header_field_func(event_header
);
505 if (stream_event_context
) {
506 release_field_func(stream_event_context
);
510 release_field_func(event_context
);
514 release_field_func(event_payload
);
524 void bt_event_header_field_recycle(struct bt_field_wrapper
*field_wrapper
,
525 struct bt_stream_class
*stream_class
)
527 BT_ASSERT(field_wrapper
);
528 BT_LIB_LOGD("Recycling event header field: "
529 "addr=%p, %![sc-]+S, %![field-]+f", field_wrapper
,
530 stream_class
, field_wrapper
->field
);
531 bt_object_pool_recycle_object(
532 &stream_class
->event_header_field_pool
,
537 struct bt_field_wrapper
*create_event_header_field(
538 struct bt_stream_class
*stream_class
,
539 struct bt_field_type_common
*ft
)
541 struct bt_field_wrapper
*field_wrapper
= NULL
;
543 field_wrapper
= bt_field_wrapper_create(
544 &stream_class
->event_header_field_pool
, (void *) ft
);
545 if (!field_wrapper
) {
553 bt_event_header_field_recycle(field_wrapper
, stream_class
);
554 field_wrapper
= NULL
;
558 return field_wrapper
;
562 struct bt_event
*bt_event_new(struct bt_event_class
*event_class
)
565 struct bt_event
*event
= NULL
;
566 struct bt_stream_class
*stream_class
;
568 event
= g_new0(struct bt_event
, 1);
570 BT_LOGE_STR("Failed to allocate one event.");
574 ret
= bt_event_common_initialize(BT_TO_COMMON(event
),
575 BT_TO_COMMON(event_class
), NULL
, NULL
,
576 (bt_validation_flag_copy_field_type_func
) bt_field_type_copy
,
578 (void *) bt_field_create_recursive
,
579 (void *) bt_field_destroy_recursive
,
580 (void *) create_event_header_field
,
581 (void *) bt_event_header_field_recycle
);
583 /* bt_event_common_initialize() logs errors */
587 bt_object_set_is_shared((void *) event
, false);
588 event
->clock_values
= g_hash_table_new_full(g_direct_hash
,
589 g_direct_equal
, NULL
,
590 (GDestroyNotify
) bt_clock_value_recycle
);
591 BT_ASSERT(event
->clock_values
);
592 stream_class
= bt_event_class_borrow_stream_class(event_class
);
593 BT_ASSERT(stream_class
);
595 if (stream_class
->common
.clock_class
) {
596 struct bt_clock_value
*clock_value
;
598 clock_value
= bt_clock_value_create(
599 stream_class
->common
.clock_class
);
601 BT_LIB_LOGE("Cannot create clock value from clock class: "
602 "%![cc-]+K", stream_class
->common
.clock_class
);
606 g_hash_table_insert(event
->clock_values
,
607 stream_class
->common
.clock_class
, clock_value
);
614 bt_event_destroy(event
);
624 void _bt_event_reset_dev_mode(struct bt_event
*event
)
631 if (event
->common
.header_field
) {
632 bt_field_common_set_is_frozen_recursive(
633 event
->common
.header_field
->field
, false);
634 bt_field_common_reset_recursive(
635 event
->common
.header_field
->field
);
638 if (event
->common
.stream_event_context_field
) {
639 bt_field_common_set_is_frozen_recursive(
640 event
->common
.stream_event_context_field
, false);
641 bt_field_common_reset_recursive(
642 event
->common
.stream_event_context_field
);
645 if (event
->common
.context_field
) {
646 bt_field_common_set_is_frozen_recursive(
647 event
->common
.context_field
, false);
648 bt_field_common_reset_recursive(event
->common
.context_field
);
651 if (event
->common
.payload_field
) {
652 bt_field_common_set_is_frozen_recursive(
653 event
->common
.payload_field
, false);
654 bt_field_common_reset_recursive(event
->common
.payload_field
);
657 g_hash_table_iter_init(&iter
, event
->clock_values
);
658 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
659 struct bt_clock_value
*clock_value
= value
;
661 BT_ASSERT(clock_value
);
662 bt_clock_value_reset(clock_value
);
663 bt_clock_value_set_is_frozen(clock_value
, false);
668 # define bt_event_reset_dev_mode _bt_event_reset_dev_mode
670 # define bt_event_reset_dev_mode(_x)
674 void bt_event_reset(struct bt_event
*event
)
677 event
->common
.frozen
= false;
678 bt_event_reset_dev_mode(event
);
679 BT_PUT(event
->packet
);
683 struct bt_event
*bt_event_create(struct bt_event_class
*event_class
,
684 struct bt_packet
*packet
)
687 struct bt_event
*event
= NULL
;
689 BT_ASSERT(event_class
);
690 event
= bt_object_pool_create_object(&event_class
->event_pool
);
692 BT_LIB_LOGE("Cannot allocate one event from event class's event pool: "
693 "%![event-class-]+E", event_class
);
697 if (!event
->common
.class) {
698 event
->common
.class = bt_get(event_class
);
702 ret
= bt_event_set_packet(event
, packet
);
704 BT_LIB_LOGE("Cannot set event's packet: "
705 "%![event-]+e, %![packet-]+a", event
, packet
);
713 bt_event_recycle(event
);
721 struct bt_event_class
*bt_event_borrow_class(struct bt_event
*event
)
723 BT_ASSERT_PRE_NON_NULL(event
, "Event");
724 return BT_FROM_COMMON(
725 bt_event_common_borrow_class(BT_TO_COMMON(event
)));
728 struct bt_stream
*bt_event_borrow_stream(struct bt_event
*event
)
730 BT_ASSERT_PRE_NON_NULL(event
, "Event");
731 return event
->packet
? event
->packet
->stream
: NULL
;
734 struct bt_field
*bt_event_borrow_payload(struct bt_event
*event
)
736 return BT_FROM_COMMON(
737 bt_event_common_borrow_payload(BT_TO_COMMON(event
)));
740 struct bt_field
*bt_event_borrow_header(struct bt_event
*event
)
742 return BT_FROM_COMMON(
743 bt_event_common_borrow_header(BT_TO_COMMON(event
)));
746 struct bt_field
*bt_event_borrow_context(struct bt_event
*event
)
748 return BT_FROM_COMMON(
749 bt_event_common_borrow_context(BT_TO_COMMON(event
)));
752 struct bt_field
*bt_event_borrow_stream_event_context(
753 struct bt_event
*event
)
755 return BT_FROM_COMMON(bt_event_common_borrow_stream_event_context(
756 BT_TO_COMMON(event
)));
760 void release_event_header_field(struct bt_field_wrapper
*field_wrapper
,
761 struct bt_event_common
*event_common
)
763 struct bt_event
*event
= BT_FROM_COMMON(event_common
);
764 struct bt_event_class
*event_class
= bt_event_borrow_class(event
);
767 bt_field_wrapper_destroy(field_wrapper
);
769 struct bt_stream_class
*stream_class
=
770 bt_event_class_borrow_stream_class(event_class
);
772 BT_ASSERT(stream_class
);
773 bt_event_header_field_recycle(field_wrapper
, stream_class
);
778 void bt_event_destroy(struct bt_event
*event
)
781 bt_event_common_finalize((void *) event
,
782 (void *) bt_field_destroy_recursive
,
783 (void *) release_event_header_field
);
784 g_hash_table_destroy(event
->clock_values
);
785 BT_LOGD_STR("Putting event's packet.");
786 bt_put(event
->packet
);
790 struct bt_clock_value
*bt_event_borrow_clock_value(
791 struct bt_event
*event
, struct bt_clock_class
*clock_class
)
793 struct bt_clock_value
*clock_value
= NULL
;
795 BT_ASSERT_PRE_NON_NULL(event
, "Event");
796 BT_ASSERT_PRE_NON_NULL(clock_class
, "Clock class");
797 clock_value
= g_hash_table_lookup(event
->clock_values
, clock_class
);
799 BT_LOGV("No clock value associated to the given clock class: "
800 "event-addr=%p, event-class-name=\"%s\", "
801 "event-class-id=%" PRId64
", clock-class-addr=%p, "
802 "clock-class-name=\"%s\"", event
,
803 bt_event_class_common_get_name(event
->common
.class),
804 bt_event_class_common_get_id(event
->common
.class),
805 clock_class
, bt_clock_class_get_name(clock_class
));
813 struct bt_packet
*bt_event_borrow_packet(struct bt_event
*event
)
815 struct bt_packet
*packet
= NULL
;
817 BT_ASSERT_PRE_NON_NULL(event
, "Event");
818 if (!event
->packet
) {
819 BT_LOGV("Event has no current packet: addr=%p, "
820 "event-class-name=\"%s\", event-class-id=%" PRId64
,
821 event
, bt_event_class_common_get_name(event
->common
.class),
822 bt_event_class_common_get_id(event
->common
.class));
826 packet
= event
->packet
;
833 int bt_event_set_packet(struct bt_event
*event
, struct bt_packet
*packet
)
835 BT_ASSERT_PRE_NON_NULL(event
, "Event");
836 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
837 BT_ASSERT_PRE_EVENT_COMMON_HOT(BT_TO_COMMON(event
), "Event");
840 * Make sure the new packet was created by this event's
841 * stream, if it is set.
843 if (bt_event_borrow_stream(event
)) {
844 BT_ASSERT_PRE(packet
->stream
== bt_event_borrow_stream(event
),
845 "Packet's stream and event's stream differ: "
846 "%![event-]+e, %![packet-]+a",
849 BT_ASSERT_PRE(bt_event_class_borrow_stream_class(
850 BT_FROM_COMMON(event
->common
.class)) ==
851 BT_FROM_COMMON(packet
->stream
->common
.stream_class
),
852 "Packet's stream class and event's stream class differ: "
853 "%![event-]+e, %![packet-]+a",
858 BT_MOVE(event
->packet
, packet
);
859 BT_LOGV("Set event's packet: event-addr=%p, "
860 "event-class-name=\"%s\", event-class-id=%" PRId64
", "
862 event
, bt_event_class_common_get_name(event
->common
.class),
863 bt_event_class_common_get_id(event
->common
.class), packet
);
868 void _bt_event_freeze(struct bt_event
*event
)
870 _bt_event_common_freeze(BT_TO_COMMON(event
));
871 BT_LOGD_STR("Freezing event's packet.");
872 bt_packet_freeze(event
->packet
);
876 void bt_event_recycle(struct bt_event
*event
)
878 struct bt_event_class
*event_class
;
881 BT_LIB_LOGD("Recycling event: %!+e", event
);
884 * Those are the important ordered steps:
886 * 1. Reset the event object (put any permanent reference it
887 * has, unfreeze it and its fields in developer mode, etc.),
888 * but do NOT put its class's reference. This event class
889 * contains the pool to which we're about to recycle this
890 * event object, so we must guarantee its existence thanks
891 * to this existing reference.
893 * 2. Move the event class reference to our `event_class`
894 * variable so that we can set the event's class member
895 * to NULL before recycling it. We CANNOT do this after
896 * we put the event class reference because this bt_put()
897 * could destroy the event class, also destroying its
898 * event pool, thus also destroying our event object (this
899 * would result in an invalid write access).
901 * 3. Recycle the event object.
903 * 4. Put our event class reference.
905 bt_event_reset(event
);
906 event_class
= BT_FROM_COMMON(event
->common
.class);
907 BT_ASSERT(event_class
);
908 event
->common
.class = NULL
;
909 bt_object_pool_recycle_object(&event_class
->event_pool
, event
);
913 int bt_event_move_header(struct bt_event
*event
,
914 struct bt_event_header_field
*header_field
)
916 struct bt_stream_class
*stream_class
;
917 struct bt_field_wrapper
*field_wrapper
= (void *) header_field
;
919 BT_ASSERT_PRE_NON_NULL(event
, "Event");
920 BT_ASSERT_PRE_NON_NULL(field_wrapper
, "Header field");
921 BT_ASSERT_PRE_HOT(BT_TO_COMMON(event
), "Event", ": +%!+e", event
);
922 stream_class
= bt_event_class_borrow_stream_class(
923 bt_event_borrow_class(event
));
924 BT_ASSERT_PRE(stream_class
->common
.event_header_field_type
,
925 "Stream class has no event header field type: %!+S",
928 /* Recycle current header field: always exists */
929 BT_ASSERT(event
->common
.header_field
);
930 bt_event_header_field_recycle(event
->common
.header_field
,
934 event
->common
.header_field
= (void *) field_wrapper
;