X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=lib%2Fctf-ir%2Fevent.c;h=5cfd5e14a124515e8bbcfc943722c71c8b75e005;hp=2fa1e953b19c12b21c736cb6c7fde3f5c51daf59;hb=312c056ae3d374b253fa0cfe5ed576c0b0e5e569;hpb=f6ccaed94e575af57fe6bf38154771bee4871a2a diff --git a/lib/ctf-ir/event.c b/lib/ctf-ir/event.c index 2fa1e953..5cfd5e14 100644 --- a/lib/ctf-ir/event.c +++ b/lib/ctf-ir/event.c @@ -29,6 +29,7 @@ #define BT_LOG_TAG "EVENT" #include +#include #include #include #include @@ -43,125 +44,68 @@ #include #include #include +#include #include #include #include #include -#include -#include #include #include #include #include -#include #include -#define BT_ASSERT_PRE_EVENT_HOT(_event, _name) \ - BT_ASSERT_PRE_HOT((_event), (_name), ": +%!+e", (_event)) - static -void bt_event_destroy(struct bt_object *obj); - -struct bt_event *bt_event_create(struct bt_event_class *event_class) +int bt_event_common_validate_types_for_create( + struct bt_event_class_common *event_class, + struct bt_validation_output *validation_output, + bt_validation_flag_copy_field_type_func copy_field_type_func) { int ret; enum bt_validation_flag validation_flags = BT_VALIDATION_FLAG_STREAM | BT_VALIDATION_FLAG_EVENT; - struct bt_event *event = NULL; - struct bt_trace *trace = NULL; - struct bt_stream_class *stream_class = NULL; - struct bt_field_type *packet_header_type = NULL; - struct bt_field_type *packet_context_type = NULL; - struct bt_field_type *event_header_type = NULL; - struct bt_field_type *stream_event_ctx_type = NULL; - struct bt_field_type *event_context_type = NULL; - struct bt_field_type *event_payload_type = NULL; - struct bt_field *event_header = NULL; - struct bt_field *stream_event_context = NULL; - struct bt_field *event_context = NULL; - struct bt_field *event_payload = NULL; - struct bt_value *environment = NULL; - struct bt_validation_output validation_output = { 0 }; + struct bt_trace_common *trace = NULL; + struct bt_stream_class_common *stream_class = NULL; + struct bt_field_type_common *packet_header_type = NULL; + struct bt_field_type_common *packet_context_type = NULL; + struct bt_field_type_common *event_header_type = NULL; + struct bt_field_type_common *stream_event_ctx_type = NULL; + struct bt_field_type_common *event_context_type = NULL; + struct bt_field_type_common *event_payload_type = NULL; int trace_valid = 0; - struct bt_clock_class *expected_clock_class = NULL; - - BT_ASSERT_PRE_NON_NULL(event_class, "Event class"); - BT_LOGD("Creating event object: event-class-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event_class, bt_event_class_get_name(event_class), - bt_event_class_get_id(event_class)); - - stream_class = bt_event_class_get_stream_class(event_class); - BT_ASSERT_PRE(stream_class, - "Event class is not part of a stream class: %!+E", event_class); - - /* The event class was frozen when added to its stream class */ - BT_ASSERT(event_class->frozen); - - if (!stream_class->frozen) { - if (stream_class->clock) { - expected_clock_class = - bt_get(stream_class->clock->clock_class); - } - - /* - * Because this function freezes the stream class, - * validate that this stream class contains at most a - * single clock class so that we set its expected clock - * class for future checks. - */ - ret = bt_stream_class_validate_single_clock_class( - stream_class, &expected_clock_class); - if (ret) { - BT_LOGW("Event class's stream class or one of its event " - "classes contains a field type which is not " - "recursively mapped to the expected " - "clock class: " - "stream-class-addr=%p, " - "stream-class-id=%" PRId64 ", " - "stream-class-name=\"%s\", " - "expected-clock-class-addr=%p, " - "expected-clock-class-name=\"%s\"", - stream_class, bt_stream_class_get_id(stream_class), - bt_stream_class_get_name(stream_class), - expected_clock_class, - expected_clock_class ? - bt_clock_class_get_name(expected_clock_class) : - NULL); - goto error; - } - } + struct bt_value *environment = NULL; - /* Validate the trace (if any), the stream class, and the event class */ - trace = bt_stream_class_get_trace(stream_class); + stream_class = bt_event_class_common_borrow_stream_class(event_class); + BT_ASSERT(stream_class); + trace = bt_stream_class_common_borrow_trace(stream_class); if (trace) { - BT_LOGD_STR("Event's class is part of a trace."); - packet_header_type = bt_trace_get_packet_header_type(trace); + BT_LOGD_STR("Event class is part of a trace."); + packet_header_type = + bt_trace_common_borrow_packet_header_field_type(trace); trace_valid = trace->valid; BT_ASSERT(trace_valid); environment = trace->environment; } - packet_context_type = bt_stream_class_get_packet_context_type( - stream_class); - event_header_type = bt_stream_class_get_event_header_type( - stream_class); - stream_event_ctx_type = bt_stream_class_get_event_context_type( - stream_class); - event_context_type = bt_event_class_get_context_type(event_class); - event_payload_type = bt_event_class_get_payload_type(event_class); + packet_context_type = + bt_stream_class_common_borrow_packet_context_field_type( + stream_class); + event_header_type = + bt_stream_class_common_borrow_event_header_field_type( + stream_class); + stream_event_ctx_type = + bt_stream_class_common_borrow_event_context_field_type( + stream_class); + event_context_type = + bt_event_class_common_borrow_context_field_type(event_class); + event_payload_type = + bt_event_class_common_borrow_payload_field_type(event_class); ret = bt_validate_class_types(environment, packet_header_type, packet_context_type, event_header_type, stream_event_ctx_type, event_context_type, event_payload_type, trace_valid, stream_class->valid, event_class->valid, - &validation_output, validation_flags); - BT_PUT(packet_header_type); - BT_PUT(packet_context_type); - BT_PUT(event_header_type); - BT_PUT(stream_event_ctx_type); - BT_PUT(event_context_type); - BT_PUT(event_payload_type); + validation_output, validation_flags, copy_field_type_func); if (ret) { /* * This means something went wrong during the validation @@ -171,108 +115,351 @@ struct bt_event *bt_event_create(struct bt_event_class *event_class) goto error; } - if ((validation_output.valid_flags & validation_flags) != + if ((validation_output->valid_flags & validation_flags) != validation_flags) { /* Invalid trace/stream class/event class */ BT_LOGW("Invalid trace, stream class, or event class: " - "valid-flags=0x%x", validation_output.valid_flags); + "valid-flags=0x%x", validation_output->valid_flags); goto error; } - /* - * Safe to automatically map selected fields to the stream's - * clock's class here because the stream class is about to be - * frozen. - */ - if (bt_stream_class_map_clock_class(stream_class, - validation_output.packet_context_type, - validation_output.event_header_type)) { - BT_LOGW_STR("Cannot automatically map selected stream class's " - "field types to stream class's clock's class."); - goto error; - } + goto end; - /* - * At this point we know the trace (if associated to the stream - * class), the stream class, and the event class, with their - * current types, are valid. We may proceed with creating - * the event. - */ - event = g_new0(struct bt_event, 1); - if (!event) { - BT_LOGE_STR("Failed to allocate one event."); - goto error; - } +error: + bt_validation_output_put_types(validation_output); + ret = -1; - bt_object_init(event, bt_event_destroy); +end: + return ret; +} - /* - * event does not share a common ancestor with the event class; it has - * to guarantee its existence by holding a reference. This reference - * shall be released once the event is associated to a stream since, - * from that point, the event and its class will share the same - * lifetime. - */ - event->event_class = bt_get(event_class); - event->clock_values = g_hash_table_new_full(g_direct_hash, - g_direct_equal, bt_put, bt_put); +static +int bt_event_common_create_fields( + struct bt_stream_class_common *stream_class, + struct bt_validation_output *validation_output, + void *(*create_field_func)(void *), + void (*release_field_func)(void *), + void *(*create_header_field_func)(void *, void *), + void (*release_header_field_func)(void *), + struct bt_field_wrapper **header_field, + struct bt_field_common **stream_event_context_field, + struct bt_field_common **context_field, + struct bt_field_common **payload_field) +{ + int ret = 0; - if (validation_output.event_header_type) { + if (validation_output->event_header_type) { BT_LOGD("Creating initial event header field: ft-addr=%p", - validation_output.event_header_type); - event_header = - bt_field_create(validation_output.event_header_type); - if (!event_header) { + validation_output->event_header_type); + *header_field = + create_header_field_func(stream_class, + validation_output->event_header_type); + if (!*header_field) { BT_LOGE_STR("Cannot create initial event header field object."); goto error; } } - if (validation_output.stream_event_ctx_type) { + if (validation_output->stream_event_ctx_type) { BT_LOGD("Creating initial stream event context field: ft-addr=%p", - validation_output.stream_event_ctx_type); - stream_event_context = bt_field_create( - validation_output.stream_event_ctx_type); - if (!stream_event_context) { + validation_output->stream_event_ctx_type); + *stream_event_context_field = create_field_func( + validation_output->stream_event_ctx_type); + if (!*stream_event_context_field) { BT_LOGE_STR("Cannot create initial stream event context field object."); goto error; } } - if (validation_output.event_context_type) { + if (validation_output->event_context_type) { BT_LOGD("Creating initial event context field: ft-addr=%p", - validation_output.event_context_type); - event_context = bt_field_create( - validation_output.event_context_type); - if (!event_context) { + validation_output->event_context_type); + *context_field = create_field_func( + validation_output->event_context_type); + if (!*context_field) { BT_LOGE_STR("Cannot create initial event context field object."); goto error; } } - if (validation_output.event_payload_type) { + if (validation_output->event_payload_type) { BT_LOGD("Creating initial event payload field: ft-addr=%p", - validation_output.event_payload_type); - event_payload = bt_field_create( - validation_output.event_payload_type); - if (!event_payload) { + validation_output->event_payload_type); + *payload_field = create_field_func( + validation_output->event_payload_type); + if (!*payload_field) { BT_LOGE_STR("Cannot create initial event payload field object."); goto error; } } + goto end; + +error: + if (*header_field) { + release_header_field_func(*header_field); + } + + if (*stream_event_context_field) { + release_field_func(*stream_event_context_field); + } + + if (*context_field) { + release_field_func(*context_field); + } + + if (*payload_field) { + release_field_func(*payload_field); + } + + ret = -1; + +end: + return ret; +} + +BT_HIDDEN +int _bt_event_common_validate(struct bt_event_common *event) +{ + int ret = 0; + struct bt_stream_class_common *stream_class; + + BT_ASSERT(event); + if (event->header_field) { + ret = bt_field_common_validate_recursive( + event->header_field->field); + if (ret) { + BT_ASSERT_PRE_MSG("Invalid event's header field: " + "%![event-]+_e, %![field-]+_f", + event, event->header_field->field); + goto end; + } + } + + stream_class = bt_event_class_common_borrow_stream_class(event->class); + + /* + * We should not have been able to create the event without associating + * the event class to a stream class. + */ + BT_ASSERT(stream_class); + + if (stream_class->event_context_field_type) { + ret = bt_field_common_validate_recursive( + event->stream_event_context_field); + if (ret) { + BT_ASSERT_PRE_MSG("Invalid event's stream event context field: " + "%![event-]+_e, %![field-]+_f", + event, event->stream_event_context_field); + goto end; + } + } + + if (event->class->context_field_type) { + ret = bt_field_common_validate_recursive(event->context_field); + if (ret) { + BT_ASSERT_PRE_MSG("Invalid event's payload field: " + "%![event-]+_e, %![field-]+_f", + event, event->context_field); + goto end; + } + } + + ret = bt_field_common_validate_recursive(event->payload_field); + if (ret) { + BT_ASSERT_PRE_MSG("Invalid event's payload field: " + "%![event-]+_e, %![field-]+_f", + event, event->payload_field); + goto end; + } + +end: + return ret; +} + +BT_HIDDEN +void _bt_event_common_freeze(struct bt_event_common *event) +{ + BT_ASSERT(event); + + if (event->frozen) { + return; + } + + BT_LOGD("Freezing event: addr=%p, " + "event-class-name=\"%s\", event-class-id=%" PRId64, + event, bt_event_class_common_get_name(event->class), + bt_event_class_common_get_id(event->class)); + + if (event->header_field) { + BT_LOGD_STR("Freezing event's header field."); + bt_field_common_set_is_frozen_recursive( + event->header_field->field, true); + } + + if (event->stream_event_context_field) { + BT_LOGD_STR("Freezing event's stream event context field."); + bt_field_common_set_is_frozen_recursive( + event->stream_event_context_field, true); + } + + if (event->context_field) { + BT_LOGD_STR("Freezing event's context field."); + bt_field_common_set_is_frozen_recursive(event->context_field, true); + } + + if (event->payload_field) { + BT_LOGD_STR("Freezing event's payload field."); + bt_field_common_set_is_frozen_recursive(event->payload_field, true); + } + + event->frozen = 1; +} + +BT_HIDDEN +int bt_event_common_initialize(struct bt_event_common *event, + struct bt_event_class_common *event_class, + struct bt_clock_class *init_expected_clock_class, + bt_object_release_func release_func, + bt_validation_flag_copy_field_type_func field_type_copy_func, + bool must_be_in_trace, + int (*map_clock_classes_func)(struct bt_stream_class_common *stream_class, + struct bt_field_type_common *packet_context_field_type, + struct bt_field_type_common *event_header_field_type), + void *(*create_field_func)(void *), + void (*release_field_func)(void *), + void *(*create_header_field_func)(void *, void *), + void (*release_header_field_func)(void *)) +{ + int ret; + struct bt_trace_common *trace = NULL; + struct bt_stream_class_common *stream_class = NULL; + struct bt_field_wrapper *event_header = NULL; + struct bt_field_common *stream_event_context = NULL; + struct bt_field_common *event_context = NULL; + struct bt_field_common *event_payload = NULL; + struct bt_validation_output validation_output = { 0 }; + struct bt_clock_class *expected_clock_class = + init_expected_clock_class ? bt_get(init_expected_clock_class) : + NULL; + + BT_ASSERT_PRE_NON_NULL(event_class, "Event class"); + BT_LOGD("Initializing common event object: event-class-addr=%p, " + "event-class-name=\"%s\", event-class-id=%" PRId64, + event_class, bt_event_class_common_get_name(event_class), + bt_event_class_common_get_id(event_class)); + + stream_class = bt_event_class_common_borrow_stream_class(event_class); + BT_ASSERT_PRE(stream_class, + "Event class is not part of a stream class: %!+_E", event_class); + + /* The event class was frozen when added to its stream class */ + BT_ASSERT(event_class->frozen); + trace = bt_stream_class_common_borrow_trace(stream_class); + + if (must_be_in_trace) { + BT_ASSERT_PRE(trace, + "Event class's stream class is not part of a trace: " + "%![ec-]+_E, %![ec-]+_S", event_class, stream_class); + } + + /* + * This must be called before anything that can fail because on + * failure, the caller releases the reference to `event` to + * destroy it. + */ + bt_object_init(event, release_func); + + if (!stream_class->frozen) { + /* + * Because this function freezes the stream class, + * validate that this stream class contains at most a + * single clock class so that we set its expected clock + * class for future checks. + */ + ret = bt_stream_class_common_validate_single_clock_class( + stream_class, &expected_clock_class); + if (ret) { + BT_LOGW("Event class's stream class or one of its event " + "classes contains a field type which is not " + "recursively mapped to the expected " + "clock class: " + "stream-class-addr=%p, " + "stream-class-id=%" PRId64 ", " + "stream-class-name=\"%s\", " + "expected-clock-class-addr=%p, " + "expected-clock-class-name=\"%s\"", + stream_class, + bt_stream_class_common_get_id(stream_class), + bt_stream_class_common_get_name(stream_class), + expected_clock_class, + expected_clock_class ? + bt_clock_class_get_name(expected_clock_class) : + NULL); + goto error; + } + } + + /* Validate the trace, the stream class, and the event class */ + ret = bt_event_common_validate_types_for_create( + event_class, &validation_output, field_type_copy_func); + if (ret) { + /* bt_event_common_validate_types_for_create() logs errors */ + goto error; + } + + if (map_clock_classes_func) { + /* + * Safe to automatically map selected fields to the + * stream's clock's class here because the stream class + * is about to be frozen. + */ + if (map_clock_classes_func(stream_class, + validation_output.packet_context_type, + validation_output.event_header_type)) { + BT_LOGW_STR("Cannot automatically map selected stream class's " + "field types to stream class's clock's class."); + goto error; + } + } + + /* + * event does not share a common ancestor with the event class; it has + * to guarantee its existence by holding a reference. This reference + * shall be released once the event is associated to a stream since, + * from that point, the event and its class will share the same + * lifetime. + */ + event->class = bt_get(event_class); + + ret = bt_event_common_create_fields(stream_class, + &validation_output, + create_field_func, release_field_func, + create_header_field_func, release_header_field_func, + &event_header, &stream_event_context, &event_context, + &event_payload); + if (ret) { + /* bt_event_common_create_fields() logs errors */ + goto error; + } + /* * At this point all the fields are created, potentially from * validated copies of field types, so that the field types and * fields can be replaced in the trace, stream class, * event class, and created event. */ - bt_validation_replace_types(trace, stream_class, - event_class, &validation_output, validation_flags); - BT_MOVE(event->event_header, event_header); - BT_MOVE(event->stream_event_context, stream_event_context); - BT_MOVE(event->context_payload, event_context); - BT_MOVE(event->fields_payload, event_payload); + bt_validation_replace_types(trace, stream_class, event_class, + &validation_output, + BT_VALIDATION_FLAG_STREAM | BT_VALIDATION_FLAG_EVENT); + event->header_field = event_header; + event_header = NULL; + event->stream_event_context_field = stream_event_context; + stream_event_context = NULL; + event->context_field = event_context; + event_context = NULL; + event->payload_field = event_payload; + event_payload = NULL; /* * Put what was not moved in bt_validation_replace_types(). @@ -283,7 +470,7 @@ struct bt_event *bt_event_create(struct bt_event_class *event_class) * Freeze the stream class since the event header must not be changed * anymore. */ - bt_stream_class_freeze(stream_class); + bt_stream_class_common_freeze(stream_class); /* * It is safe to set the stream class's unique clock class @@ -301,377 +488,306 @@ struct bt_event *bt_event_create(struct bt_event_class *event_class) event_class->valid = 1; /* Put stuff we borrowed from the event class */ - BT_PUT(stream_class); - BT_PUT(trace); - BT_LOGD("Created event object: addr=%p, event-class-name=\"%s\", " + BT_LOGD("Initialized event object: addr=%p, event-class-name=\"%s\", " "event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event_class)); - return event; + event, bt_event_class_common_get_name(event->class), + bt_event_class_common_get_id(event->class)); + goto end; error: bt_validation_output_put_types(&validation_output); - BT_PUT(event); - BT_PUT(stream_class); - BT_PUT(trace); - BT_PUT(event_header); - BT_PUT(stream_event_context); - BT_PUT(event_context); - BT_PUT(event_payload); bt_put(expected_clock_class); - BT_ASSERT(!packet_header_type); - BT_ASSERT(!packet_context_type); - BT_ASSERT(!event_header_type); - BT_ASSERT(!stream_event_ctx_type); - BT_ASSERT(!event_context_type); - BT_ASSERT(!event_payload_type); - return event; -} -struct bt_event_class *bt_event_get_class(struct bt_event *event) -{ - BT_ASSERT_PRE_NON_NULL(event, "Event"); - return bt_get(bt_event_borrow_event_class(event)); -} + if (event_header) { + release_header_field_func(event_header); + } -BT_HIDDEN -struct bt_stream *bt_event_borrow_stream(struct bt_event *event) -{ - struct bt_stream *stream = NULL; + if (stream_event_context) { + release_field_func(stream_event_context); + } - BT_ASSERT(event); + if (event_context) { + release_field_func(event_context); + } - /* - * If the event has a parent, then this is its (writer) stream. - * If the event has no parent, then if it has a packet, this - * is its (non-writer) stream. - */ - if (event->base.parent) { - stream = (struct bt_stream *) bt_object_borrow_parent(event); - } else { - if (event->packet) { - stream = event->packet->stream; - } + if (event_payload) { + release_field_func(event_payload); } - return stream; + ret = -1; + +end: + return ret; } -struct bt_stream *bt_event_get_stream(struct bt_event *event) +static +void bt_event_header_field_recycle(struct bt_field_wrapper *field_wrapper, + struct bt_stream_class *stream_class) { - BT_ASSERT_PRE_NON_NULL(event, "Event"); - return bt_get(bt_event_borrow_stream(event)); + BT_ASSERT(field_wrapper); + BT_LIB_LOGD("Recycling event header field: " + "addr=%p, %![sc-]+S, %![field-]+f", field_wrapper, + stream_class, field_wrapper->field); + bt_object_pool_recycle_object( + &stream_class->event_header_field_pool, + field_wrapper); } -int bt_event_set_payload(struct bt_event *event, const char *name, - struct bt_field *payload) +static +struct bt_field_wrapper *create_event_header_field( + struct bt_stream_class *stream_class, + struct bt_field_type_common *ft) { - int ret = 0; - - BT_ASSERT_PRE_NON_NULL(event, "Event"); - BT_ASSERT_PRE_NON_NULL(payload, "Payload field"); - BT_ASSERT_PRE_EVENT_HOT(event, "Event"); - - if (name) { - ret = bt_field_structure_set_field_by_name( - event->fields_payload, name, payload); - } else { - BT_ASSERT_PRE(bt_field_type_compare(payload->type, - event->event_class->fields) == 0, - "Payload field's type is different from the " - "expected field type: %![event-]+e, %![ft-]+F, " - "%![expected-ft-]+F", - event, payload->type, event->event_class->fields); + struct bt_field_wrapper *field_wrapper = NULL; - bt_put(event->fields_payload); - bt_get(payload); - event->fields_payload = payload; + field_wrapper = bt_field_wrapper_create( + &stream_class->event_header_field_pool, (void *) ft); + if (!field_wrapper) { + goto error; } - if (ret) { - BT_LOGW("Failed to set event's payload field: event-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64 ", " - "payload-field-name=\"%s\", payload-field-addr=%p", - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), - name, payload); - } else { - BT_LOGV("Set event's payload field: event-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64 ", " - "payload-field-name=\"%s\", payload-field-addr=%p", - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), - name, payload); + goto end; + +error: + if (field_wrapper) { + bt_event_header_field_recycle(field_wrapper, stream_class); + field_wrapper = NULL; } - return ret; +end: + return field_wrapper; } -struct bt_field *bt_event_get_event_payload(struct bt_event *event) +BT_HIDDEN +struct bt_event *bt_event_new(struct bt_event_class *event_class) { - struct bt_field *payload = NULL; + int ret; + struct bt_event *event = NULL; + struct bt_stream_class *stream_class; - BT_ASSERT_PRE_NON_NULL(event, "Event"); + event = g_new0(struct bt_event, 1); + if (!event) { + BT_LOGE_STR("Failed to allocate one event."); + goto error; + } - if (!event->fields_payload) { - BT_LOGV("Event has no current payload field: addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - goto end; + ret = bt_event_common_initialize(BT_TO_COMMON(event), + BT_TO_COMMON(event_class), NULL, NULL, + (bt_validation_flag_copy_field_type_func) bt_field_type_copy, + true, NULL, + (void *) bt_field_create_recursive, + (void *) bt_field_destroy_recursive, + (void *) create_event_header_field, + (void *) bt_event_header_field_recycle); + if (ret) { + /* bt_event_common_initialize() logs errors */ + goto error; } - payload = event->fields_payload; - bt_get(payload); + bt_object_set_is_shared((void *) event, false); + event->clock_values = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, + (GDestroyNotify) bt_clock_value_recycle); + BT_ASSERT(event->clock_values); + stream_class = bt_event_class_borrow_stream_class(event_class); + BT_ASSERT(stream_class); -end: - return payload; -} + if (stream_class->common.clock_class) { + struct bt_clock_value *clock_value; -int bt_event_set_event_payload(struct bt_event *event, - struct bt_field *payload) -{ - return bt_event_set_payload(event, NULL, payload); -} + clock_value = bt_clock_value_create( + stream_class->common.clock_class); + if (!clock_value) { + BT_LIB_LOGE("Cannot create clock value from clock class: " + "%![cc-]+K", stream_class->common.clock_class); + goto error; + } -struct bt_field *bt_event_get_payload(struct bt_event *event, - const char *name) -{ - struct bt_field *field = NULL; + g_hash_table_insert(event->clock_values, + stream_class->common.clock_class, clock_value); + } - BT_ASSERT_PRE_NON_NULL(event, "Event"); + goto end; - if (name) { - field = bt_field_structure_get_field_by_name( - event->fields_payload, name); - } else { - field = event->fields_payload; - bt_get(field); +error: + if (event) { + bt_event_destroy(event); + event = NULL; } - return field; +end: + return event; } -struct bt_field *bt_event_get_payload_by_index( - struct bt_event *event, uint64_t index) +BT_ASSERT_PRE_FUNC +static inline +void _bt_event_reset_dev_mode(struct bt_event *event) { - struct bt_field *field = NULL; + GHashTableIter iter; + gpointer key, value; - BT_ASSERT_PRE_NON_NULL(event, "Event"); - field = bt_field_structure_get_field_by_index(event->fields_payload, - index); + BT_ASSERT(event); - return field; -} + if (event->common.header_field) { + bt_field_common_set_is_frozen_recursive( + event->common.header_field->field, false); + bt_field_common_reset_recursive( + event->common.header_field->field); + } -struct bt_field *bt_event_get_header(struct bt_event *event) -{ - struct bt_field *header = NULL; + if (event->common.stream_event_context_field) { + bt_field_common_set_is_frozen_recursive( + event->common.stream_event_context_field, false); + bt_field_common_reset_recursive( + event->common.stream_event_context_field); + } - BT_ASSERT_PRE_NON_NULL(event, "Event"); + if (event->common.context_field) { + bt_field_common_set_is_frozen_recursive( + event->common.context_field, false); + bt_field_common_reset_recursive(event->common.context_field); + } - if (!event->event_header) { - BT_LOGV("Event has no current header field: addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - goto end; + if (event->common.payload_field) { + bt_field_common_set_is_frozen_recursive( + event->common.payload_field, false); + bt_field_common_reset_recursive(event->common.payload_field); } - header = event->event_header; - bt_get(header); + g_hash_table_iter_init(&iter, event->clock_values); + while (g_hash_table_iter_next(&iter, &key, &value)) { + struct bt_clock_value *clock_value = value; -end: - return header; + BT_ASSERT(clock_value); + bt_clock_value_reset(clock_value); + bt_clock_value_set_is_frozen(clock_value, false); + } } -int bt_event_set_header(struct bt_event *event, struct bt_field *header) -{ - BT_ASSERT_PRE_NON_NULL(event, "Event"); - BT_ASSERT_PRE_EVENT_HOT(event, "Event"); +#ifdef BT_DEV_MODE +# define bt_event_reset_dev_mode _bt_event_reset_dev_mode +#else +# define bt_event_reset_dev_mode(_x) +#endif - /* - * Ensure the provided header's type matches the one registered to the - * stream class. - */ - if (header) { - BT_ASSERT_PRE(bt_field_type_compare(header->type, - bt_event_class_borrow_stream_class(event->event_class)->event_header_type) == 0, - "Header field's type is different from the " - "expected field type: %![event-]+e, %![ft-]+F, " - "%![expected-ft-]+F", - event, header->type, - bt_event_class_borrow_stream_class(event->event_class)->event_header_type); - } else { - BT_ASSERT_PRE(!bt_event_class_borrow_stream_class(event->event_class)->event_header_type, - "Setting no event header field, " - "but event header field type is not NULL: ", - "%![event-]+e, %![header-ft-]+F", - event, - bt_event_class_borrow_stream_class(event->event_class)->event_header_type); - } - - bt_put(event->event_header); - event->event_header = bt_get(header); - BT_LOGV("Set event's header field: event-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64 ", " - "header-field-addr=%p", - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), header); - return 0; +static inline +void bt_event_reset(struct bt_event *event) +{ + BT_ASSERT(event); + event->common.frozen = false; + bt_event_reset_dev_mode(event); + BT_PUT(event->packet); } -struct bt_field *bt_event_get_event_context(struct bt_event *event) +BT_HIDDEN +struct bt_event *bt_event_create(struct bt_event_class *event_class, + struct bt_packet *packet) { - struct bt_field *context = NULL; + int ret; + struct bt_event *event = NULL; - BT_ASSERT_PRE_NON_NULL(event, "Event"); + BT_ASSERT(event_class); + event = bt_object_pool_create_object(&event_class->event_pool); + if (!event) { + BT_LIB_LOGE("Cannot allocate one event from event class's event pool: " + "%![event-class-]+E", event_class); + goto error; + } - if (!event->context_payload) { - BT_LOGV("Event has no current context field: addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - goto end; + if (!event->common.class) { + event->common.class = bt_get(event_class); } - context = event->context_payload; - bt_get(context); + BT_ASSERT(packet); + ret = bt_event_set_packet(event, packet); + if (ret) { + BT_LIB_LOGE("Cannot set event's packet: " + "%![event-]+e, %![packet-]+a", event, packet); + goto error; + } -end: - return context; -} + goto end; -int bt_event_set_event_context(struct bt_event *event, struct bt_field *context) -{ - BT_ASSERT_PRE_NON_NULL(event, "Event"); - BT_ASSERT_PRE_EVENT_HOT(event, "Event"); - - if (context) { - BT_ASSERT_PRE(bt_field_type_compare(context->type, - event->event_class->context) == 0, - "Context field's type is different from the " - "expected field type: %![event-]+e, %![ft-]+F, " - "%![expected-ft-]+F", - event, context->type, event->event_class->context); - } else { - BT_ASSERT_PRE(!event->event_class->context, - "Setting no event context field, " - "but event context field type is not NULL: ", - "%![event-]+e, %![context-ft-]+F", - event, event->event_class->context); +error: + if (event) { + bt_event_recycle(event); + event = NULL; } - bt_put(event->context_payload); - event->context_payload = bt_get(context); - BT_LOGV("Set event's context field: event-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64 ", " - "context-field-addr=%p", - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), context); - return 0; +end: + return event; } -struct bt_field *bt_event_get_stream_event_context( - struct bt_event *event) +struct bt_event_class *bt_event_borrow_class(struct bt_event *event) { - struct bt_field *stream_event_context = NULL; - BT_ASSERT_PRE_NON_NULL(event, "Event"); - - if (!event->stream_event_context) { - BT_LOGV("Event has no current stream event context field: addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - goto end; - } - - stream_event_context = event->stream_event_context; - -end: - return bt_get(stream_event_context); + return BT_FROM_COMMON( + bt_event_common_borrow_class(BT_TO_COMMON(event))); } -int bt_event_set_stream_event_context(struct bt_event *event, - struct bt_field *stream_event_context) +struct bt_stream *bt_event_borrow_stream(struct bt_event *event) { BT_ASSERT_PRE_NON_NULL(event, "Event"); - BT_ASSERT_PRE_EVENT_HOT(event, "Event"); + return event->packet ? event->packet->stream : NULL; +} - if (stream_event_context) { - BT_ASSERT_PRE(bt_field_type_compare(stream_event_context->type, - bt_event_class_borrow_stream_class(event->event_class)->event_context_type) == 0, - "Stream event context field's type is different from the " - "expected field type: %![event-]+e, %![ft-]+F, " - "%![expected-ft-]+F", - event, stream_event_context->type, - bt_event_class_borrow_stream_class(event->event_class)->event_context_type); - } else { - BT_ASSERT_PRE(!bt_event_class_borrow_stream_class(event->event_class)->event_context_type, - "Setting no stream event context field, " - "but stream event context field type is not NULL: ", - "%![event-]+e, %![context-ft-]+F", - event, - bt_event_class_borrow_stream_class(event->event_class)->event_context_type); - } +struct bt_field *bt_event_borrow_payload(struct bt_event *event) +{ + return BT_FROM_COMMON( + bt_event_common_borrow_payload(BT_TO_COMMON(event))); +} - bt_get(stream_event_context); - BT_MOVE(event->stream_event_context, stream_event_context); - BT_LOGV("Set event's stream event context field: event-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64 ", " - "stream-event-context-field-addr=%p", - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), - stream_event_context); - return 0; +struct bt_field *bt_event_borrow_header(struct bt_event *event) +{ + return BT_FROM_COMMON( + bt_event_common_borrow_header(BT_TO_COMMON(event))); } -/* Pre-2.0 CTF writer backward compatibility */ -void bt_ctf_event_get(struct bt_event *event) +struct bt_field *bt_event_borrow_context(struct bt_event *event) { - bt_get(event); + return BT_FROM_COMMON( + bt_event_common_borrow_context(BT_TO_COMMON(event))); } -/* Pre-2.0 CTF writer backward compatibility */ -void bt_ctf_event_put(struct bt_event *event) +struct bt_field *bt_event_borrow_stream_event_context( + struct bt_event *event) { - bt_put(event); + return BT_FROM_COMMON(bt_event_common_borrow_stream_event_context( + BT_TO_COMMON(event))); } -void bt_event_destroy(struct bt_object *obj) +static +void release_event_header_field(struct bt_field_wrapper *field_wrapper, + struct bt_event_common *event_common) { - struct bt_event *event; + struct bt_event *event = BT_FROM_COMMON(event_common); + struct bt_event_class *event_class = bt_event_borrow_class(event); - event = container_of(obj, struct bt_event, base); - BT_LOGD("Destroying event: addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); + if (!event_class) { + bt_field_wrapper_destroy(field_wrapper); + } else { + struct bt_stream_class *stream_class = + bt_event_class_borrow_stream_class(event_class); - if (!event->base.parent) { - /* - * Event was keeping a reference to its class since it shared no - * common ancestor with it to guarantee they would both have the - * same lifetime. - */ - bt_put(event->event_class); + BT_ASSERT(stream_class); + bt_event_header_field_recycle(field_wrapper, stream_class); } +} + +BT_HIDDEN +void bt_event_destroy(struct bt_event *event) +{ + BT_ASSERT(event); + bt_event_common_finalize((void *) event, + (void *) bt_field_destroy_recursive, + (void *) release_event_header_field); g_hash_table_destroy(event->clock_values); - BT_LOGD_STR("Putting event's header field."); - bt_put(event->event_header); - BT_LOGD_STR("Putting event's stream event context field."); - bt_put(event->stream_event_context); - BT_LOGD_STR("Putting event's context field."); - bt_put(event->context_payload); - BT_LOGD_STR("Putting event's payload field."); - bt_put(event->fields_payload); BT_LOGD_STR("Putting event's packet."); bt_put(event->packet); g_free(event); } -struct bt_clock_value *bt_event_get_clock_value( +struct bt_clock_value *bt_event_borrow_clock_value( struct bt_event *event, struct bt_clock_class *clock_class) { struct bt_clock_value *clock_value = NULL; @@ -684,155 +800,17 @@ struct bt_clock_value *bt_event_get_clock_value( "event-addr=%p, event-class-name=\"%s\", " "event-class-id=%" PRId64 ", clock-class-addr=%p, " "clock-class-name=\"%s\"", event, - bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), + bt_event_class_common_get_name(event->common.class), + bt_event_class_common_get_id(event->common.class), clock_class, bt_clock_class_get_name(clock_class)); goto end; } - bt_get(clock_value); - end: return clock_value; } -int bt_event_set_clock_value(struct bt_event *event, - struct bt_clock_value *value) -{ - struct bt_trace *trace; - struct bt_stream_class *stream_class; - struct bt_event_class *event_class; - struct bt_clock_class *clock_class = NULL; - - BT_ASSERT_PRE_NON_NULL(event, "Event"); - BT_ASSERT_PRE_NON_NULL(value, "Clock value"); - BT_ASSERT_PRE_EVENT_HOT(event, "Event"); - clock_class = bt_clock_value_get_class(value); - event_class = bt_event_borrow_event_class(event); - BT_ASSERT(event_class); - stream_class = bt_event_class_borrow_stream_class(event_class); - BT_ASSERT(stream_class); - trace = bt_stream_class_borrow_trace(stream_class); - BT_ASSERT(trace); - BT_ASSERT_PRE(bt_trace_has_clock_class(trace, clock_class), - "Clock class is not part of event's trace: " - "%![event-]+e, %![clock-class-]+K", - event, clock_class); - g_hash_table_insert(event->clock_values, clock_class, bt_get(value)); - BT_LOGV("Set event's clock value: " - "event-addr=%p, event-class-name=\"%s\", " - "event-class-id=%" PRId64 ", clock-class-addr=%p, " - "clock-class-name=\"%s\", clock-value-addr=%p, " - "clock-value-cycles=%" PRIu64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), - clock_class, bt_clock_class_get_name(clock_class), - value, value->value); - clock_class = NULL; - bt_put(clock_class); - return 0; -} - -BT_HIDDEN -int _bt_event_validate(struct bt_event *event) -{ - int ret = 0; - struct bt_stream_class *stream_class; - - BT_ASSERT(event); - if (event->event_header) { - ret = bt_field_validate_recursive(event->event_header); - if (ret) { - BT_ASSERT_PRE_MSG("Invalid event's header field: " - "%![event-]+e, %![field-]+f", - event, event->event_header); - goto end; - } - } - - stream_class = bt_event_class_borrow_stream_class(event->event_class); - - /* - * We should not have been able to create the event without associating - * the event class to a stream class. - */ - BT_ASSERT(stream_class); - - if (stream_class->event_context_type) { - ret = bt_field_validate_recursive(event->stream_event_context); - if (ret) { - BT_ASSERT_PRE_MSG("Invalid event's stream event context field: " - "%![event-]+e, %![field-]+f", - event, event->stream_event_context); - goto end; - } - } - - if (event->event_class->context) { - ret = bt_field_validate_recursive(event->context_payload); - if (ret) { - BT_ASSERT_PRE_MSG("Invalid event's payload field: " - "%![event-]+e, %![field-]+f", - event, event->context_payload); - goto end; - } - } - - ret = bt_field_validate_recursive(event->fields_payload); - if (ret) { - BT_ASSERT_PRE_MSG("Invalid event's payload field: " - "%![event-]+e, %![field-]+f", - event, event->fields_payload); - goto end; - } - -end: - return ret; -} - -BT_HIDDEN -int bt_event_serialize(struct bt_event *event, struct bt_stream_pos *pos, - enum bt_byte_order native_byte_order) -{ - int ret = 0; - - BT_ASSERT(event); - BT_ASSERT(pos); - - BT_LOGV_STR("Serializing event's context field."); - if (event->context_payload) { - ret = bt_field_serialize_recursive(event->context_payload, pos, - native_byte_order); - if (ret) { - BT_LOGW("Cannot serialize event's context field: " - "event-addr=%p, event-class-name=\"%s\", " - "event-class-id=%" PRId64, - event, - bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - goto end; - } - } - - BT_LOGV_STR("Serializing event's payload field."); - if (event->fields_payload) { - ret = bt_field_serialize_recursive(event->fields_payload, pos, - native_byte_order); - if (ret) { - BT_LOGW("Cannot serialize event's payload field: " - "event-addr=%p, event-class-name=\"%s\", " - "event-class-id=%" PRId64, - event, - bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - goto end; - } - } -end: - return ret; -} - -struct bt_packet *bt_event_get_packet(struct bt_event *event) +struct bt_packet *bt_event_borrow_packet(struct bt_event *event) { struct bt_packet *packet = NULL; @@ -840,23 +818,23 @@ struct bt_packet *bt_event_get_packet(struct bt_event *event) if (!event->packet) { BT_LOGV("Event has no current packet: addr=%p, " "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); + event, bt_event_class_common_get_name(event->common.class), + bt_event_class_common_get_id(event->common.class)); goto end; } - packet = bt_get(event->packet); + packet = event->packet; end: return packet; } -int bt_event_set_packet(struct bt_event *event, - struct bt_packet *packet) +BT_HIDDEN +int bt_event_set_packet(struct bt_event *event, struct bt_packet *packet) { BT_ASSERT_PRE_NON_NULL(event, "Event"); BT_ASSERT_PRE_NON_NULL(packet, "Packet"); - BT_ASSERT_PRE_EVENT_HOT(event, "Event"); + BT_ASSERT_PRE_EVENT_COMMON_HOT(BT_TO_COMMON(event), "Event"); /* * Make sure the new packet was created by this event's @@ -868,8 +846,9 @@ int bt_event_set_packet(struct bt_event *event, "%![event-]+e, %![packet-]+a", event, packet); } else { - BT_ASSERT_PRE(bt_event_class_borrow_stream_class(event->event_class) == - packet->stream->stream_class, + BT_ASSERT_PRE(bt_event_class_borrow_stream_class( + BT_FROM_COMMON(event->common.class)) == + BT_FROM_COMMON(packet->stream->common.stream_class), "Packet's stream class and event's stream class differ: " "%![event-]+e, %![packet-]+a", event, packet); @@ -880,32 +859,78 @@ int bt_event_set_packet(struct bt_event *event, BT_LOGV("Set event's packet: event-addr=%p, " "event-class-name=\"%s\", event-class-id=%" PRId64 ", " "packet-addr=%p", - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class), packet); + event, bt_event_class_common_get_name(event->common.class), + bt_event_class_common_get_id(event->common.class), packet); return 0; } BT_HIDDEN void _bt_event_freeze(struct bt_event *event) { + _bt_event_common_freeze(BT_TO_COMMON(event)); + BT_LOGD_STR("Freezing event's packet."); + bt_packet_freeze(event->packet); +} + +BT_HIDDEN +void bt_event_recycle(struct bt_event *event) +{ + struct bt_event_class *event_class; + BT_ASSERT(event); + BT_LIB_LOGD("Recycling event: %!+e", event); - if (event->frozen) { - return; - } + /* + * Those are the important ordered steps: + * + * 1. Reset the event object (put any permanent reference it + * has, unfreeze it and its fields in developer mode, etc.), + * but do NOT put its class's reference. This event class + * contains the pool to which we're about to recycle this + * event object, so we must guarantee its existence thanks + * to this existing reference. + * + * 2. Move the event class reference to our `event_class` + * variable so that we can set the event's class member + * to NULL before recycling it. We CANNOT do this after + * we put the event class reference because this bt_put() + * could destroy the event class, also destroying its + * event pool, thus also destroying our event object (this + * would result in an invalid write access). + * + * 3. Recycle the event object. + * + * 4. Put our event class reference. + */ + bt_event_reset(event); + event_class = BT_FROM_COMMON(event->common.class); + BT_ASSERT(event_class); + event->common.class = NULL; + bt_object_pool_recycle_object(&event_class->event_pool, event); + bt_put(event_class); +} - BT_LOGD("Freezing event: addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - event, bt_event_class_get_name(event->event_class), - bt_event_class_get_id(event->event_class)); - bt_packet_freeze(event->packet); - BT_LOGD_STR("Freezing event's header field."); - bt_field_freeze_recursive(event->event_header); - BT_LOGD_STR("Freezing event's stream event context field."); - bt_field_freeze_recursive(event->stream_event_context); - BT_LOGD_STR("Freezing event's context field."); - bt_field_freeze_recursive(event->context_payload); - BT_LOGD_STR("Freezing event's payload field."); - bt_field_freeze_recursive(event->fields_payload); - event->frozen = 1; +int bt_event_move_header(struct bt_event *event, + struct bt_event_header_field *header_field) +{ + struct bt_stream_class *stream_class; + struct bt_field_wrapper *field_wrapper = (void *) header_field; + + BT_ASSERT_PRE_NON_NULL(event, "Event"); + BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field"); + BT_ASSERT_PRE_HOT(BT_TO_COMMON(event), "Event", ": +%!+e", event); + stream_class = bt_event_class_borrow_stream_class( + bt_event_borrow_class(event)); + BT_ASSERT_PRE(stream_class->common.event_header_field_type, + "Stream class has no event header field type: %!+S", + stream_class); + + /* Recycle current header field: always exists */ + BT_ASSERT(event->common.header_field); + bt_event_header_field_recycle(event->common.header_field, + stream_class); + + /* Move new field */ + event->common.header_field = (void *) field_wrapper; + return 0; }