X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream-class.c;fp=formats%2Fctf%2Fir%2Fstream-class.c;h=0000000000000000000000000000000000000000;hp=403f5dbbf51089a5d7783b0701faeaafbd86dff7;hb=dc3fffef7b84cc4af1a7c99828fd57a106cd2257;hpb=f3985ab106d89d8e764c1a8dd0c8bda09b755d10 diff --git a/formats/ctf/ir/stream-class.c b/formats/ctf/ir/stream-class.c deleted file mode 100644 index 403f5dbb..00000000 --- a/formats/ctf/ir/stream-class.c +++ /dev/null @@ -1,971 +0,0 @@ -/* - * stream-class.c - * - * Babeltrace CTF IR - Stream Class - * - * Copyright 2013, 2014 Jérémie Galarneau - * - * Author: Jérémie Galarneau - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -static -void bt_ctf_stream_class_destroy(struct bt_object *obj); -static -int init_event_header(struct bt_ctf_stream_class *stream_class); -static -int init_packet_context(struct bt_ctf_stream_class *stream_class); - -struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name) -{ - int ret; - struct bt_ctf_stream_class *stream_class = NULL; - - if (name && bt_ctf_validate_identifier(name)) { - goto error; - } - - stream_class = g_new0(struct bt_ctf_stream_class, 1); - if (!stream_class) { - goto error; - } - - stream_class->name = g_string_new(name); - stream_class->event_classes = g_ptr_array_new_with_free_func( - (GDestroyNotify) bt_object_release); - if (!stream_class->event_classes) { - goto error; - } - - stream_class->event_classes_ht = g_hash_table_new_full(g_int64_hash, - g_int64_equal, g_free, NULL); - - ret = init_event_header(stream_class); - if (ret) { - goto error; - } - - ret = init_packet_context(stream_class); - if (ret) { - goto error; - } - - bt_object_init(stream_class, bt_ctf_stream_class_destroy); - return stream_class; - -error: - BT_PUT(stream_class); - return stream_class; -} - -struct bt_ctf_trace *bt_ctf_stream_class_get_trace( - struct bt_ctf_stream_class *stream_class) -{ - return (struct bt_ctf_trace *) bt_object_get_parent( - stream_class); -} - -const char *bt_ctf_stream_class_get_name( - struct bt_ctf_stream_class *stream_class) -{ - const char *name = NULL; - - if (!stream_class) { - goto end; - } - - name = stream_class->name->str; -end: - return name; -} - -int bt_ctf_stream_class_set_name(struct bt_ctf_stream_class *stream_class, - const char *name) -{ - int ret = 0; - - if (!stream_class || stream_class->frozen) { - ret = -1; - goto end; - } - - g_string_assign(stream_class->name, name); -end: - return ret; -} - -struct bt_ctf_clock *bt_ctf_stream_class_get_clock( - struct bt_ctf_stream_class *stream_class) -{ - struct bt_ctf_clock *clock = NULL; - - if (!stream_class || !stream_class->clock) { - goto end; - } - - clock = bt_get(stream_class->clock); -end: - return clock; -} - -int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, - struct bt_ctf_clock *clock) -{ - int ret = 0; - struct bt_ctf_field_type *timestamp_field = NULL; - - if (!stream_class || !clock || stream_class->frozen) { - ret = -1; - goto end; - } - - /* - * Look for a "timestamp" integer field type in the stream - * class's event header field type and map the stream class's - * clock's class to that field type if there's no current - * mapping. - */ - timestamp_field = bt_ctf_field_type_structure_get_field_type_by_name( - stream_class->event_header_type, "timestamp"); - if (timestamp_field) { - struct bt_ctf_clock_class *mapped_clock_class = - bt_ctf_field_type_integer_get_mapped_clock_class( - timestamp_field); - - if (!mapped_clock_class) { - ret = bt_ctf_field_type_integer_set_mapped_clock_class( - timestamp_field, clock->clock_class); - if (ret) { - goto end; - } - } - - BT_PUT(mapped_clock_class); - } - - /* Replace the current clock of this stream class. */ - bt_put(stream_class->clock); - stream_class->clock = bt_get(clock); - -end: - bt_put(timestamp_field); - return ret; -} - -int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class) -{ - int64_t ret; - - if (!stream_class || !stream_class->id_set) { - ret = -1; - goto end; - } - - ret = (int64_t) stream_class->id; -end: - return ret; -} - -BT_HIDDEN -int _bt_ctf_stream_class_set_id( - struct bt_ctf_stream_class *stream_class, uint32_t id) -{ - stream_class->id = id; - stream_class->id_set = 1; - return 0; -} - -struct event_class_set_stream_id_data { - uint32_t stream_id; - int ret; -}; - -static -void event_class_set_stream_id(gpointer event_class, gpointer data) -{ - struct event_class_set_stream_id_data *typed_data = data; - - typed_data->ret |= bt_ctf_event_class_set_stream_id(event_class, - typed_data->stream_id); -} - -BT_HIDDEN -int bt_ctf_stream_class_set_id_no_check( - struct bt_ctf_stream_class *stream_class, uint32_t id) -{ - int ret = 0; - struct event_class_set_stream_id_data data = - { .stream_id = id, .ret = 0 }; - - /* - * Make sure all event classes have their "stream_id" attribute - * set to this value. - */ - g_ptr_array_foreach(stream_class->event_classes, - event_class_set_stream_id, &data); - ret = data.ret; - if (ret) { - goto end; - } - - ret = _bt_ctf_stream_class_set_id(stream_class, id); - if (ret) { - goto end; - } -end: - return ret; -} - -int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, - uint32_t id) -{ - int ret = 0; - - if (!stream_class || stream_class->frozen) { - ret = -1; - goto end; - } - - ret = bt_ctf_stream_class_set_id_no_check(stream_class, id); -end: - return ret; -} - -static -void event_class_exists(gpointer element, gpointer query) -{ - struct bt_ctf_event_class *event_class_a = element; - struct search_query *search_query = query; - struct bt_ctf_event_class *event_class_b = search_query->value; - int64_t id_a, id_b; - - if (search_query->value == element) { - search_query->found = 1; - goto end; - } - - /* - * Two event classes cannot share the same name in a given - * stream class. - */ - if (!strcmp(bt_ctf_event_class_get_name(event_class_a), - bt_ctf_event_class_get_name(event_class_b))) { - search_query->found = 1; - goto end; - } - - /* - * Two event classes cannot share the same ID in a given - * stream class. - */ - id_a = bt_ctf_event_class_get_id(event_class_a); - id_b = bt_ctf_event_class_get_id(event_class_b); - - if (id_a < 0 || id_b < 0) { - /* at least one ID is not set: will be automatically set later */ - goto end; - } - - if (id_a == id_b) { - search_query->found = 1; - goto end; - } - -end: - return; -} - -int bt_ctf_stream_class_add_event_class( - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_event_class *event_class) -{ - int ret = 0; - int64_t *event_id = NULL; - struct bt_ctf_trace *trace = NULL; - struct bt_ctf_stream_class *old_stream_class = NULL; - struct bt_ctf_validation_output validation_output = { 0 }; - struct bt_ctf_field_type *packet_header_type = NULL; - struct bt_ctf_field_type *packet_context_type = NULL; - struct bt_ctf_field_type *event_header_type = NULL; - struct bt_ctf_field_type *stream_event_ctx_type = NULL; - struct bt_ctf_field_type *event_context_type = NULL; - struct bt_ctf_field_type *event_payload_type = NULL; - const enum bt_ctf_validation_flag validation_flags = - BT_CTF_VALIDATION_FLAG_EVENT; - - if (!stream_class || !event_class) { - ret = -1; - goto end; - } - - event_id = g_new(int64_t, 1); - if (!event_id) { - ret = -1; - goto end; - } - - /* Check for duplicate event classes */ - struct search_query query = { .value = event_class, .found = 0 }; - g_ptr_array_foreach(stream_class->event_classes, event_class_exists, - &query); - if (query.found) { - ret = -1; - goto end; - } - - old_stream_class = bt_ctf_event_class_get_stream_class(event_class); - if (old_stream_class) { - /* Event class is already associated to a stream class. */ - ret = -1; - goto end; - } - - trace = bt_ctf_stream_class_get_trace(stream_class); - if (trace) { - /* - * If the stream class is associated with a trace, then - * both those objects are frozen. Also, this event class - * is about to be frozen. - * - * Therefore the event class must be validated here. - * The trace and stream class should be valid at this - * point. - */ - assert(trace->valid); - assert(stream_class->valid); - packet_header_type = - bt_ctf_trace_get_packet_header_type(trace); - packet_context_type = - bt_ctf_stream_class_get_packet_context_type( - stream_class); - event_header_type = - bt_ctf_stream_class_get_event_header_type(stream_class); - stream_event_ctx_type = - bt_ctf_stream_class_get_event_context_type( - stream_class); - event_context_type = - bt_ctf_event_class_get_context_type(event_class); - event_payload_type = - bt_ctf_event_class_get_payload_type(event_class); - ret = bt_ctf_validate_class_types( - trace->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); - - if (ret) { - /* - * This means something went wrong during the - * validation process, not that the objects are - * invalid. - */ - goto end; - } - - if ((validation_output.valid_flags & validation_flags) != - validation_flags) { - /* Invalid event class */ - ret = -1; - goto end; - } - } - - /* Only set an event ID if none was explicitly set before */ - *event_id = bt_ctf_event_class_get_id(event_class); - if (*event_id < 0) { - if (bt_ctf_event_class_set_id(event_class, - stream_class->next_event_id++)) { - ret = -1; - goto end; - } - *event_id = stream_class->next_event_id; - } - - ret = bt_ctf_event_class_set_stream_id(event_class, stream_class->id); - if (ret) { - goto end; - } - - bt_object_set_parent(event_class, stream_class); - - if (trace) { - /* - * At this point we know that the function will be - * successful. Therefore we can replace the event - * class's field types with what's in the validation - * output structure and mark this event class as valid. - */ - bt_ctf_validation_replace_types(NULL, NULL, event_class, - &validation_output, validation_flags); - event_class->valid = 1; - - /* - * Put what was not moved in - * bt_ctf_validation_replace_types(). - */ - bt_ctf_validation_output_put_types(&validation_output); - } - - /* Add to the event classes of the stream class */ - g_ptr_array_add(stream_class->event_classes, event_class); - g_hash_table_insert(stream_class->event_classes_ht, event_id, - event_class); - event_id = NULL; - - /* Freeze the event class */ - bt_ctf_event_class_freeze(event_class); - - if (stream_class->byte_order) { - /* - * Only set native byte order if it has been initialized - * when the stream class was added to a trace. - * - * If not set here, this will be set when the stream - * class is added to a trace. - */ - bt_ctf_event_class_set_native_byte_order(event_class, - stream_class->byte_order); - } - - /* Notifiy listeners of the trace's schema modification. */ - if (trace) { - struct bt_ctf_object obj = { .object = event_class, - .type = BT_CTF_OBJECT_TYPE_EVENT_CLASS }; - - (void) bt_ctf_trace_object_modification(&obj, trace); - } -end: - BT_PUT(trace); - BT_PUT(old_stream_class); - bt_ctf_validation_output_put_types(&validation_output); - assert(!packet_header_type); - assert(!packet_context_type); - assert(!event_header_type); - assert(!stream_event_ctx_type); - assert(!event_context_type); - assert(!event_payload_type); - g_free(event_id); - - return ret; -} - -int bt_ctf_stream_class_get_event_class_count( - struct bt_ctf_stream_class *stream_class) -{ - int ret; - - if (!stream_class) { - ret = -1; - goto end; - } - - ret = (int) stream_class->event_classes->len; -end: - return ret; -} - -struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class( - struct bt_ctf_stream_class *stream_class, int index) -{ - struct bt_ctf_event_class *event_class = NULL; - - if (!stream_class || index < 0 || - index >= stream_class->event_classes->len) { - goto end; - } - - event_class = g_ptr_array_index(stream_class->event_classes, index); - bt_get(event_class); -end: - return event_class; -} - -struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name( - struct bt_ctf_stream_class *stream_class, const char *name) -{ - size_t i; - struct bt_ctf_event_class *event_class = NULL; - - if (!stream_class || !name) { - goto end; - } - - for (i = 0; i < stream_class->event_classes->len; i++) { - struct bt_ctf_event_class *cur_event_class = - g_ptr_array_index(stream_class->event_classes, i); - const char *cur_event_class_name = - bt_ctf_event_class_get_name(cur_event_class); - - if (!strcmp(name, cur_event_class_name)) { - event_class = cur_event_class; - bt_get(event_class); - goto end; - } - } -end: - return event_class; -} - -struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_id( - struct bt_ctf_stream_class *stream_class, uint32_t id) -{ - int64_t id_key = id; - struct bt_ctf_event_class *event_class = NULL; - - if (!stream_class) { - goto end; - } - - event_class = g_hash_table_lookup(stream_class->event_classes_ht, - &id_key); - bt_get(event_class); -end: - return event_class; -} - -struct bt_ctf_field_type *bt_ctf_stream_class_get_packet_context_type( - struct bt_ctf_stream_class *stream_class) -{ - struct bt_ctf_field_type *ret = NULL; - - if (!stream_class) { - goto end; - } - - bt_get(stream_class->packet_context_type); - ret = stream_class->packet_context_type; -end: - return ret; -} - -int bt_ctf_stream_class_set_packet_context_type( - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_field_type *packet_context_type) -{ - int ret = 0; - - if (!stream_class || stream_class->frozen) { - ret = -1; - goto end; - } - - if (packet_context_type && - bt_ctf_field_type_get_type_id(packet_context_type) != - BT_CTF_TYPE_ID_STRUCT) { - /* A packet context must be a structure. */ - ret = -1; - goto end; - } - - bt_put(stream_class->packet_context_type); - bt_get(packet_context_type); - stream_class->packet_context_type = packet_context_type; -end: - return ret; -} - -struct bt_ctf_field_type *bt_ctf_stream_class_get_event_header_type( - struct bt_ctf_stream_class *stream_class) -{ - struct bt_ctf_field_type *ret = NULL; - - if (!stream_class || !stream_class->event_header_type) { - goto end; - } - - bt_get(stream_class->event_header_type); - ret = stream_class->event_header_type; -end: - return ret; -} - -int bt_ctf_stream_class_set_event_header_type( - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_field_type *event_header_type) -{ - int ret = 0; - - if (!stream_class || stream_class->frozen) { - ret = -1; - goto end; - } - - if (event_header_type && - bt_ctf_field_type_get_type_id(event_header_type) != - BT_CTF_TYPE_ID_STRUCT) { - /* An event header must be a structure. */ - ret = -1; - goto end; - } - - bt_put(stream_class->event_header_type); - stream_class->event_header_type = bt_get(event_header_type); -end: - return ret; -} - -struct bt_ctf_field_type *bt_ctf_stream_class_get_event_context_type( - struct bt_ctf_stream_class *stream_class) -{ - struct bt_ctf_field_type *ret = NULL; - - if (!stream_class || !stream_class->event_context_type) { - goto end; - } - - bt_get(stream_class->event_context_type); - ret = stream_class->event_context_type; -end: - return ret; -} - -int bt_ctf_stream_class_set_event_context_type( - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_field_type *event_context_type) -{ - int ret = 0; - - if (!stream_class || stream_class->frozen) { - ret = -1; - goto end; - } - - if (event_context_type && - bt_ctf_field_type_get_type_id(event_context_type) != - BT_CTF_TYPE_ID_STRUCT) { - /* A packet context must be a structure. */ - ret = -1; - goto end; - } - - bt_put(stream_class->event_context_type); - stream_class->event_context_type = bt_get(event_context_type); -end: - return ret; -} - -void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class) -{ - bt_get(stream_class); -} - -void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class) -{ - bt_put(stream_class); -} - -static -int get_event_class_count(void *element) -{ - return bt_ctf_stream_class_get_event_class_count( - (struct bt_ctf_stream_class *) element); -} - -static -void *get_event_class(void *element, int i) -{ - return bt_ctf_stream_class_get_event_class( - (struct bt_ctf_stream_class *) element, i); -} - -static -int visit_event_class(void *object, bt_ctf_visitor visitor,void *data) -{ - struct bt_ctf_object obj = - { .object = object, - .type = BT_CTF_OBJECT_TYPE_EVENT_CLASS }; - - return visitor(&obj, data); -} - -int bt_ctf_stream_class_visit(struct bt_ctf_stream_class *stream_class, - bt_ctf_visitor visitor, void *data) -{ - int ret; - struct bt_ctf_object obj = - { .object = stream_class, - .type = BT_CTF_OBJECT_TYPE_STREAM_CLASS }; - - if (!stream_class || !visitor) { - ret = -1; - goto end; - } - - ret = visitor_helper(&obj, get_event_class_count, - get_event_class, - visit_event_class, visitor, data); -end: - return ret; -} - -BT_HIDDEN -void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class) -{ - if (!stream_class) { - return; - } - - stream_class->frozen = 1; - bt_ctf_field_type_freeze(stream_class->event_header_type); - bt_ctf_field_type_freeze(stream_class->packet_context_type); - bt_ctf_field_type_freeze(stream_class->event_context_type); - - if (stream_class->clock) { - bt_ctf_clock_class_freeze(stream_class->clock->clock_class); - } -} - -BT_HIDDEN -void bt_ctf_stream_class_set_byte_order( - struct bt_ctf_stream_class *stream_class, int byte_order) -{ - int i; - - assert(stream_class); - assert(byte_order == LITTLE_ENDIAN || byte_order == BIG_ENDIAN); - stream_class->byte_order = byte_order; - - /* Set native byte order to little or big endian */ - bt_ctf_field_type_set_native_byte_order( - stream_class->event_header_type, byte_order); - bt_ctf_field_type_set_native_byte_order( - stream_class->packet_context_type, byte_order); - bt_ctf_field_type_set_native_byte_order( - stream_class->event_context_type, byte_order); - - /* Set all events' native byte order */ - for (i = 0; i < stream_class->event_classes->len; i++) { - struct bt_ctf_event_class *event_class = - g_ptr_array_index(stream_class->event_classes, i); - - bt_ctf_event_class_set_native_byte_order(event_class, - byte_order); - } -} - -BT_HIDDEN -int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class, - struct metadata_context *context) -{ - int64_t ret = 0; - size_t i; - - g_string_assign(context->field_name, ""); - context->current_indentation_level = 1; - if (!stream_class->id_set) { - ret = -1; - goto end; - } - - g_string_append_printf(context->string, - "stream {\n\tid = %" PRIu32 ";\n\tevent.header := ", - stream_class->id); - ret = bt_ctf_field_type_serialize(stream_class->event_header_type, - context); - if (ret) { - goto end; - } - - if (stream_class->packet_context_type) { - g_string_append(context->string, ";\n\n\tpacket.context := "); - ret = bt_ctf_field_type_serialize(stream_class->packet_context_type, - context); - if (ret) { - goto end; - } - } - - if (stream_class->event_context_type) { - g_string_append(context->string, ";\n\n\tevent.context := "); - ret = bt_ctf_field_type_serialize( - stream_class->event_context_type, context); - if (ret) { - goto end; - } - } - - g_string_append(context->string, ";\n};\n\n"); - for (i = 0; i < stream_class->event_classes->len; i++) { - struct bt_ctf_event_class *event_class = - stream_class->event_classes->pdata[i]; - - ret = bt_ctf_event_class_serialize(event_class, context); - if (ret) { - goto end; - } - } -end: - context->current_indentation_level = 0; - return ret; -} - -static -void bt_ctf_stream_class_destroy(struct bt_object *obj) -{ - struct bt_ctf_stream_class *stream_class; - - stream_class = container_of(obj, struct bt_ctf_stream_class, base); - bt_put(stream_class->clock); - - if (stream_class->event_classes_ht) { - g_hash_table_destroy(stream_class->event_classes_ht); - } - if (stream_class->event_classes) { - g_ptr_array_free(stream_class->event_classes, TRUE); - } - - if (stream_class->name) { - g_string_free(stream_class->name, TRUE); - } - - bt_put(stream_class->event_header_type); - bt_put(stream_class->packet_context_type); - bt_put(stream_class->event_context_type); - g_free(stream_class); -} - -static -int init_event_header(struct bt_ctf_stream_class *stream_class) -{ - int ret = 0; - struct bt_ctf_field_type *event_header_type = - bt_ctf_field_type_structure_create(); - struct bt_ctf_field_type *_uint32_t = - get_field_type(FIELD_TYPE_ALIAS_UINT32_T); - struct bt_ctf_field_type *_uint64_t = - get_field_type(FIELD_TYPE_ALIAS_UINT64_T); - - if (!event_header_type) { - ret = -1; - goto end; - } - - ret = bt_ctf_field_type_structure_add_field(event_header_type, - _uint32_t, "id"); - if (ret) { - goto end; - } - - ret = bt_ctf_field_type_structure_add_field(event_header_type, - _uint64_t, "timestamp"); - if (ret) { - goto end; - } - - if (stream_class->event_header_type) { - bt_put(stream_class->event_header_type); - } - stream_class->event_header_type = event_header_type; -end: - if (ret) { - bt_put(event_header_type); - } - - bt_put(_uint32_t); - bt_put(_uint64_t); - return ret; -} - -static -int init_packet_context(struct bt_ctf_stream_class *stream_class) -{ - int ret = 0; - struct bt_ctf_field_type *packet_context_type = - bt_ctf_field_type_structure_create(); - struct bt_ctf_field_type *_uint64_t = - get_field_type(FIELD_TYPE_ALIAS_UINT64_T); - - if (!packet_context_type) { - ret = -1; - goto end; - } - - /* - * We create a stream packet context as proposed in the CTF - * specification. - */ - ret = bt_ctf_field_type_structure_add_field(packet_context_type, - _uint64_t, "timestamp_begin"); - if (ret) { - goto end; - } - - ret = bt_ctf_field_type_structure_add_field(packet_context_type, - _uint64_t, "timestamp_end"); - if (ret) { - goto end; - } - - ret = bt_ctf_field_type_structure_add_field(packet_context_type, - _uint64_t, "content_size"); - if (ret) { - goto end; - } - - ret = bt_ctf_field_type_structure_add_field(packet_context_type, - _uint64_t, "packet_size"); - if (ret) { - goto end; - } - - ret = bt_ctf_field_type_structure_add_field(packet_context_type, - _uint64_t, "events_discarded"); - if (ret) { - goto end; - } - - bt_put(stream_class->packet_context_type); - stream_class->packet_context_type = packet_context_type; -end: - if (ret) { - bt_put(packet_context_type); - goto end; - } - - bt_put(_uint64_t); - return ret; -}