X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fevent.c;h=c4fe4b4870726a0310a4abdf5b4fc9834ad680cc;hb=9a220c32dde6dc2a6a6950c470cff957e630e494;hp=943295cb5e0d845615b9a68a405913cbb028961e;hpb=f655a84dcc6d5f38206e8ed083e5ea4007032486;p=babeltrace.git diff --git a/formats/ctf/ir/event.c b/formats/ctf/ir/event.c index 943295cb..c4fe4b48 100644 --- a/formats/ctf/ir/event.c +++ b/formats/ctf/ir/event.c @@ -33,19 +33,23 @@ #include #include #include +#include #include +#include #include static void bt_ctf_event_class_destroy(struct bt_ctf_ref *ref); static void bt_ctf_event_destroy(struct bt_ctf_ref *ref); +static +int set_integer_field_value(struct bt_ctf_field *field, uint64_t value); struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name) { struct bt_ctf_event_class *event_class = NULL; - if (validate_identifier(name)) { + if (bt_ctf_validate_identifier(name)) { goto end; } @@ -133,7 +137,7 @@ int bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class, { int ret = 0; - if (!event_class || !type || validate_identifier(name) || + if (!event_class || !type || bt_ctf_validate_identifier(name) || event_class->frozen) { ret = -1; goto end; @@ -284,13 +288,45 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class) bt_ctf_event_class_get(event_class); bt_ctf_event_class_freeze(event_class); event->event_class = event_class; + + /* + * The event class does not keep ownership of the stream class to + * which it as been added. Therefore, it can't assume it has been + * set. However, we disallow the creation of an event if its + * associated stream class has been reclaimed. + */ + if (!event_class->stream_class) { + goto error_destroy; + } + assert(event_class->stream_class->event_header_type); + + event->event_header = bt_ctf_field_create( + event_class->stream_class->event_header_type); + if (!event->event_header) { + goto error_destroy; + } if (event_class->context) { event->context_payload = bt_ctf_field_create( event_class->context); + if (!event->context_payload) { + goto error_destroy; + } } event->fields_payload = bt_ctf_field_create(event_class->fields); + if (!event->fields_payload) { + goto error_destroy; + } + + /* + * Freeze the stream class since the event header must not be changed + * anymore. + */ + bt_ctf_stream_class_freeze(event_class->stream_class); end: return event; +error_destroy: + bt_ctf_event_destroy(&event->ref_count); + return NULL; } struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event) @@ -346,7 +382,7 @@ int bt_ctf_event_set_payload(struct bt_ctf_event *event, { int ret = 0; - if (!event || !value || validate_identifier(name)) { + if (!event || !value || bt_ctf_validate_identifier(name)) { ret = -1; goto end; } @@ -387,6 +423,58 @@ end: return field; } +struct bt_ctf_field *bt_ctf_event_get_event_header( + struct bt_ctf_event *event) +{ + struct bt_ctf_field *header = NULL; + + if (!event || !event->event_header) { + goto end; + } + + header = event->event_header; + bt_ctf_field_get(header); +end: + return header; +} + +int bt_ctf_event_set_event_header(struct bt_ctf_event *event, + struct bt_ctf_field *header) +{ + int ret = 0; + struct bt_ctf_field_type *field_type = NULL; + + if (!event || !header) { + ret = -1; + goto end; + } + + /* Could be NULL since an event class doesn't own a stream class */ + if (!event->event_class->stream_class) { + ret = -1; + goto end; + } + + /* + * Ensure the provided header's type matches the one registered to the + * stream class. + */ + field_type = bt_ctf_field_get_type(header); + if (field_type != event->event_class->stream_class->event_header_type) { + ret = -1; + goto end; + } + + bt_ctf_field_get(header); + bt_ctf_field_put(event->event_header); + event->event_header = header; +end: + if (field_type) { + bt_ctf_field_type_put(field_type); + } + return ret; +} + struct bt_ctf_field *bt_ctf_event_get_event_context( struct bt_ctf_event *event) { @@ -484,6 +572,9 @@ void bt_ctf_event_destroy(struct bt_ctf_ref *ref) if (event->event_class) { bt_ctf_event_class_put(event->event_class); } + if (event->event_header) { + bt_ctf_field_put(event->event_header); + } if (event->context_payload) { bt_ctf_field_put(event->context_payload); } @@ -493,6 +584,49 @@ void bt_ctf_event_destroy(struct bt_ctf_ref *ref) g_free(event); } +static +int set_integer_field_value(struct bt_ctf_field* field, uint64_t value) +{ + int ret = 0; + struct bt_ctf_field_type *field_type = NULL; + + if (!field) { + ret = -1; + goto end; + } + + if (!bt_ctf_field_validate(field)) { + /* Payload already set, skip! (not an error) */ + goto end; + } + + field_type = bt_ctf_field_get_type(field); + assert(field_type); + + if (bt_ctf_field_type_get_type_id(field_type) != CTF_TYPE_INTEGER) { + /* Not an integer and the value is unset, error. */ + ret = -1; + goto end; + } + + if (bt_ctf_field_type_integer_get_signed(field_type)) { + ret = bt_ctf_field_signed_integer_set_value(field, (int64_t) value); + if (ret) { + /* Value is out of range, error. */ + goto end; + } + } else { + ret = bt_ctf_field_unsigned_integer_set_value(field, value); + if (ret) { + /* Value is out of range, error. */ + goto end; + } + } +end: + bt_ctf_field_type_put(field_type); + return ret; +} + BT_HIDDEN void bt_ctf_event_class_freeze(struct bt_ctf_event_class *event_class) { @@ -549,7 +683,8 @@ int bt_ctf_event_class_serialize(struct bt_ctf_event_class *event_class, context->current_indentation_level = 1; g_string_assign(context->field_name, ""); - g_string_append_printf(context->string, "event {\n\tname = \"%s\";\n\tid = %u;\n\tstream_id = %" PRId64 ";\n", + g_string_append_printf(context->string, + "event {\n\tname = \"%s\";\n\tid = %u;\n\tstream_id = %" PRId64 ";\n", g_quark_to_string(event_class->name), event_class->id, stream_id); @@ -579,6 +714,20 @@ end: return ret; } +void bt_ctf_event_class_set_native_byte_order( + struct bt_ctf_event_class *event_class, + int byte_order) +{ + if (!event_class) { + return; + } + + bt_ctf_field_type_set_native_byte_order(event_class->context, + byte_order); + bt_ctf_field_type_set_native_byte_order(event_class->fields, + byte_order); +} + BT_HIDDEN int bt_ctf_event_validate(struct bt_ctf_event *event) { @@ -586,6 +735,11 @@ int bt_ctf_event_validate(struct bt_ctf_event *event) int ret; assert(event); + ret = bt_ctf_field_validate(event->event_header); + if (ret) { + goto end; + } + ret = bt_ctf_field_validate(event->fields_payload); if (ret) { goto end; @@ -624,25 +778,58 @@ end: } BT_HIDDEN -int bt_ctf_event_set_timestamp(struct bt_ctf_event *event, - uint64_t timestamp) +int bt_ctf_event_populate_event_header(struct bt_ctf_event *event) { int ret = 0; + struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL; - assert(event); - if (event->timestamp) { + if (!event) { ret = -1; goto end; } - event->timestamp = timestamp; + id_field = bt_ctf_field_structure_get_field(event->event_header, "id"); + if (id_field) { + ret = set_integer_field_value(id_field, + (uint64_t) event->event_class->id); + if (ret) { + goto end; + } + } + + timestamp_field = bt_ctf_field_structure_get_field(event->event_header, + "timestamp"); + if (timestamp_field) { + struct bt_ctf_field_type *timestamp_field_type = + bt_ctf_field_get_type(timestamp_field); + struct bt_ctf_clock *mapped_clock; + + assert(timestamp_field_type); + mapped_clock = bt_ctf_field_type_integer_get_mapped_clock( + timestamp_field_type); + bt_ctf_field_type_put(timestamp_field_type); + if (mapped_clock) { + uint64_t timestamp = bt_ctf_clock_get_time( + mapped_clock); + + bt_ctf_clock_put(mapped_clock); + if (timestamp == (uint64_t) -1ULL) { + goto end; + } + + ret = set_integer_field_value(timestamp_field, + timestamp); + if (ret) { + goto end; + } + } + } end: + if (id_field) { + bt_ctf_field_put(id_field); + } + if (timestamp_field) { + bt_ctf_field_put(timestamp_field); + } return ret; } - -BT_HIDDEN -uint64_t bt_ctf_event_get_timestamp(struct bt_ctf_event *event) -{ - assert(event); - return event->timestamp; -}