X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=lib%2Fctf-ir%2Fstream-class.c;h=fe33b61d59af38f7335e14d737dfea851a8c05cd;hb=464ebc311d460b29f681703aea0aa00eef9e6475;hp=ab2ec84ff1c25abff9c0295fd1c5e6a9ea51744a;hpb=40f7101a75ea717f16509d39608777e1c7988ab8;p=babeltrace.git diff --git a/lib/ctf-ir/stream-class.c b/lib/ctf-ir/stream-class.c index ab2ec84f..fe33b61d 100644 --- a/lib/ctf-ir/stream-class.c +++ b/lib/ctf-ir/stream-class.c @@ -43,27 +43,29 @@ #include #include #include +#include #include #include #include #include #include #include +#include static -void bt_ctf_stream_class_destroy(struct bt_object *obj); +void bt_stream_class_destroy(struct bt_object *obj); static -int init_event_header(struct bt_ctf_stream_class *stream_class); +int init_event_header(struct bt_stream_class *stream_class); static -int init_packet_context(struct bt_ctf_stream_class *stream_class); +int init_packet_context(struct bt_stream_class *stream_class); -struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name) +struct bt_stream_class *bt_stream_class_create(const char *name) { - struct bt_ctf_stream_class *stream_class; + struct bt_stream_class *stream_class; int ret; BT_LOGD("Creating default stream class object: name=\"%s\"", name); - stream_class = bt_ctf_stream_class_create_empty(name); + stream_class = bt_stream_class_create_empty(name); if (!stream_class) { BT_LOGD_STR("Cannot create empty stream class."); goto error; @@ -90,19 +92,13 @@ error: return stream_class; } -struct bt_ctf_stream_class *bt_ctf_stream_class_create_empty(const char *name) +struct bt_stream_class *bt_stream_class_create_empty(const char *name) { - struct bt_ctf_stream_class *stream_class = NULL; + struct bt_stream_class *stream_class = NULL; BT_LOGD("Creating empty stream class object: name=\"%s\"", name); - if (name && bt_ctf_validate_identifier(name)) { - BT_LOGW("Invalid parameter: stream class's name is not a valid CTF identifier: " - "name=\"%s\"", name); - goto error; - } - - stream_class = g_new0(struct bt_ctf_stream_class, 1); + stream_class = g_new0(struct bt_stream_class, 1); if (!stream_class) { BT_LOGE_STR("Failed to allocate one stream class."); goto error; @@ -123,25 +119,7 @@ struct bt_ctf_stream_class *bt_ctf_stream_class_create_empty(const char *name) goto error; } - stream_class->packet_context_type = bt_ctf_field_type_structure_create(); - if (!stream_class->packet_context_type) { - BT_LOGE_STR("Cannot create stream class's initial packet context field type."); - goto error; - } - - stream_class->event_header_type = bt_ctf_field_type_structure_create(); - if (!stream_class->event_header_type) { - BT_LOGE_STR("Cannot create stream class's initial event header field type."); - goto error; - } - - stream_class->event_context_type = bt_ctf_field_type_structure_create(); - if (!stream_class->event_context_type) { - BT_LOGE_STR("Cannot create stream class's initial event context field type."); - goto error; - } - - bt_object_init(stream_class, bt_ctf_stream_class_destroy); + bt_object_init(stream_class, bt_stream_class_destroy); BT_LOGD("Created empty stream class object: addr=%p, name=\"%s\"", stream_class, name); return stream_class; @@ -151,16 +129,16 @@ error: return stream_class; } -struct bt_ctf_trace *bt_ctf_stream_class_get_trace( - struct bt_ctf_stream_class *stream_class) +struct bt_trace *bt_stream_class_get_trace( + struct bt_stream_class *stream_class) { return stream_class ? - bt_get(bt_ctf_stream_class_borrow_trace(stream_class)) : + bt_get(bt_stream_class_borrow_trace(stream_class)) : NULL; } -const char *bt_ctf_stream_class_get_name( - struct bt_ctf_stream_class *stream_class) +const char *bt_stream_class_get_name( + struct bt_stream_class *stream_class) { const char *name = NULL; @@ -169,12 +147,12 @@ const char *bt_ctf_stream_class_get_name( goto end; } - name = stream_class->name->str; + name = stream_class->name->len > 0 ? stream_class->name->str : NULL; end: return name; } -int bt_ctf_stream_class_set_name(struct bt_ctf_stream_class *stream_class, +int bt_stream_class_set_name(struct bt_stream_class *stream_class, const char *name) { int ret = 0; @@ -188,23 +166,34 @@ int bt_ctf_stream_class_set_name(struct bt_ctf_stream_class *stream_class, if (stream_class->frozen) { BT_LOGW("Invalid parameter: stream class is frozen: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); ret = -1; goto end; } - g_string_assign(stream_class->name, name); + if (!name) { + g_string_assign(stream_class->name, ""); + } else { + if (strlen(name) == 0) { + BT_LOGW("Invalid parameter: name is empty."); + ret = -1; + goto end; + } + + g_string_assign(stream_class->name, name); + } + BT_LOGV("Set stream class's name: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); end: return ret; } -struct bt_ctf_clock *bt_ctf_stream_class_get_clock( - struct bt_ctf_stream_class *stream_class) +struct bt_ctf_clock *bt_stream_class_get_clock( + struct bt_stream_class *stream_class) { struct bt_ctf_clock *clock = NULL; @@ -216,8 +205,8 @@ struct bt_ctf_clock *bt_ctf_stream_class_get_clock( if (!stream_class->clock) { BT_LOGV("Stream class has no clock: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); goto end; } @@ -226,11 +215,11 @@ end: return clock; } -int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, +int bt_stream_class_set_clock(struct bt_stream_class *stream_class, struct bt_ctf_clock *clock) { int ret = 0; - struct bt_ctf_field_type *timestamp_field = NULL; + struct bt_field_type *timestamp_field = NULL; if (!stream_class || !clock) { BT_LOGW("Invalid parameter: stream class or clock is NULL: " @@ -243,44 +232,20 @@ int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, if (stream_class->frozen) { BT_LOGW("Invalid parameter: stream class is frozen: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); 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); BT_LOGV("Set stream class's clock: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "clock-addr=%p, clock-name=\"%s\"", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), stream_class->clock, bt_ctf_clock_get_name(stream_class->clock)); @@ -289,7 +254,7 @@ end: return ret; } -int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class) +int64_t bt_stream_class_get_id(struct bt_stream_class *stream_class) { int64_t ret; @@ -302,7 +267,7 @@ int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class) if (!stream_class->id_set) { BT_LOGV("Stream class's ID is not set: addr=%p, name=\"%s\"", stream_class, - bt_ctf_stream_class_get_name(stream_class)); + bt_stream_class_get_name(stream_class)); ret = (int64_t) -1; goto end; } @@ -313,16 +278,16 @@ end: } BT_HIDDEN -void _bt_ctf_stream_class_set_id( - struct bt_ctf_stream_class *stream_class, int64_t id) +void _bt_stream_class_set_id( + struct bt_stream_class *stream_class, int64_t id) { assert(stream_class); stream_class->id = id; stream_class->id_set = 1; BT_LOGV("Set stream class's ID (internal): " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); } struct event_class_set_stream_class_id_data { @@ -330,44 +295,15 @@ struct event_class_set_stream_class_id_data { int ret; }; -static -void event_class_set_stream_id(gpointer event_class, gpointer data) -{ - struct event_class_set_stream_class_id_data *typed_data = data; - - typed_data->ret |= bt_ctf_event_class_set_stream_id(event_class, - typed_data->stream_class_id); -} - BT_HIDDEN -int bt_ctf_stream_class_set_id_no_check( - struct bt_ctf_stream_class *stream_class, int64_t id) +int bt_stream_class_set_id_no_check( + struct bt_stream_class *stream_class, int64_t id) { - int ret = 0; - struct event_class_set_stream_class_id_data data = - { .stream_class_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) { - BT_LOGE("Cannot set the IDs of all stream class's event classes: " - "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); - goto end; - } - - _bt_ctf_stream_class_set_id(stream_class, id); -end: - return ret; + _bt_stream_class_set_id(stream_class, id); + return 0; } -int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, +int bt_stream_class_set_id(struct bt_stream_class *stream_class, uint64_t id_param) { int ret = 0; @@ -382,8 +318,8 @@ int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, if (stream_class->frozen) { BT_LOGW("Invalid parameter: stream class is frozen: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); ret = -1; goto end; } @@ -392,19 +328,19 @@ int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, BT_LOGW("Invalid parameter: invalid stream class's ID: " "stream-class-addr=%p, stream-class-name=\"%s\", " "stream-class-id=%" PRId64 ", id=%" PRIu64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), id_param); ret = -1; goto end; } - ret = bt_ctf_stream_class_set_id_no_check(stream_class, id); + ret = bt_stream_class_set_id_no_check(stream_class, id); if (ret == 0) { BT_LOGV("Set stream class's ID: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); } end: return ret; @@ -413,9 +349,9 @@ end: static void event_class_exists(gpointer element, gpointer query) { - struct bt_ctf_event_class *event_class_a = element; + struct bt_event_class *event_class_a = element; struct search_query *search_query = query; - struct bt_ctf_event_class *event_class_b = search_query->value; + struct bt_event_class *event_class_b = search_query->value; int64_t id_a, id_b; if (search_query->value == element) { @@ -427,8 +363,8 @@ void event_class_exists(gpointer element, gpointer query) * 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); + id_a = bt_event_class_get_id(event_class_a); + id_b = bt_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 */ @@ -438,7 +374,7 @@ void event_class_exists(gpointer element, gpointer query) if (id_a == id_b) { BT_LOGW("Event class with this ID already exists in the stream class: " "id=%" PRId64 ", name=\"%s\"", - id_a, bt_ctf_event_class_get_name(event_class_a)); + id_a, bt_event_class_get_name(event_class_a)); search_query->found = 1; goto end; } @@ -447,33 +383,24 @@ 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 bt_stream_class_add_event_class( + struct bt_stream_class *stream_class, + struct bt_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; - - BT_LOGD("Adding event class to stream class: " - "stream-class-addr=%p, stream-class-name=\"%s\", " - "stream-class-id=%" PRId64 ", event-class-addr=%p, " - "event-class-name=\"%s\", event-class-id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), - event_class, - bt_ctf_event_class_get_name(event_class), - bt_ctf_event_class_get_id(event_class)); + struct bt_trace *trace = NULL; + struct bt_stream_class *old_stream_class = NULL; + struct bt_validation_output validation_output = { 0 }; + 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; + const enum bt_validation_flag validation_flags = + BT_VALIDATION_FLAG_EVENT; + struct bt_clock_class *expected_clock_class = NULL; if (!stream_class || !event_class) { BT_LOGW("Invalid parameter: stream class or event class is NULL: " @@ -483,12 +410,67 @@ int bt_ctf_stream_class_add_event_class( goto end; } - trace = bt_ctf_stream_class_get_trace(stream_class); + BT_LOGD("Adding event class to stream class: " + "stream-class-addr=%p, stream-class-name=\"%s\", " + "stream-class-id=%" PRId64 ", event-class-addr=%p, " + "event-class-name=\"%s\", event-class-id=%" PRId64, + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), + event_class, + bt_event_class_get_name(event_class), + bt_event_class_get_id(event_class)); + + trace = bt_stream_class_get_trace(stream_class); if (trace && trace->is_static) { + BT_LOGW("Invalid parameter: stream class's trace is static: " + "trace-addr=%p, trace-name=\"%s\"", + trace, bt_trace_get_name(trace)); ret = -1; goto end; } + if (stream_class->frozen) { + /* + * We only check that the event class to be added has a + * single class which matches the stream class's + * expected clock class if the stream class is frozen. + * If it's not, then this event class is added "as is" + * and the validation will be performed when calling + * either bt_trace_add_stream_class() or + * bt_event_create(). This is because the stream class's + * field types (packet context, event header, event + * context) could change before the next call to one of + * those two functions. + */ + expected_clock_class = bt_get(stream_class->clock_class); + + /* + * At this point, `expected_clock_class` can be NULL, + * and bt_event_class_validate_single_clock_class() + * below can set it. + */ + ret = bt_event_class_validate_single_clock_class( + event_class, &expected_clock_class); + if (ret) { + BT_LOGW("Event class contains a field type which is not " + "recursively mapped to its stream class's " + "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 end; + } + } + event_id = g_new(int64_t, 1); if (!event_id) { BT_LOGE_STR("Failed to allocate one int64_t."); @@ -506,7 +488,7 @@ int bt_ctf_stream_class_add_event_class( goto end; } - old_stream_class = bt_ctf_event_class_get_stream_class(event_class); + old_stream_class = bt_event_class_get_stream_class(event_class); if (old_stream_class) { /* Event class is already associated to a stream class. */ BT_LOGW("Event class is already part of another stream class: " @@ -514,8 +496,8 @@ int bt_ctf_stream_class_add_event_class( "event-class-stream-class-name=\"%s\", " "event-class-stream-class-id=%" PRId64, old_stream_class, - bt_ctf_stream_class_get_name(old_stream_class), - bt_ctf_stream_class_get_id(old_stream_class)); + bt_stream_class_get_name(old_stream_class), + bt_stream_class_get_id(old_stream_class)); ret = -1; goto end; } @@ -533,20 +515,20 @@ int bt_ctf_stream_class_add_event_class( assert(trace->valid); assert(stream_class->valid); packet_header_type = - bt_ctf_trace_get_packet_header_type(trace); + bt_trace_get_packet_header_type(trace); packet_context_type = - bt_ctf_stream_class_get_packet_context_type( + bt_stream_class_get_packet_context_type( stream_class); event_header_type = - bt_ctf_stream_class_get_event_header_type(stream_class); + bt_stream_class_get_event_header_type(stream_class); stream_event_ctx_type = - bt_ctf_stream_class_get_event_context_type( + bt_stream_class_get_event_context_type( stream_class); event_context_type = - bt_ctf_event_class_get_context_type(event_class); + bt_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( + bt_event_class_get_payload_type(event_class); + ret = bt_validate_class_types( trace->environment, packet_header_type, packet_context_type, event_header_type, stream_event_ctx_type, event_context_type, @@ -582,12 +564,12 @@ int bt_ctf_stream_class_add_event_class( } /* Only set an event ID if none was explicitly set before */ - *event_id = bt_ctf_event_class_get_id(event_class); + *event_id = bt_event_class_get_id(event_class); if (*event_id < 0) { BT_LOGV("Event class has no ID: automatically setting it: " "id=%" PRId64, stream_class->next_event_id); - if (bt_ctf_event_class_set_id(event_class, + if (bt_event_class_set_id(event_class, stream_class->next_event_id)) { BT_LOGE("Cannot set event class's ID: id=%" PRId64, stream_class->next_event_id); @@ -598,13 +580,6 @@ int bt_ctf_stream_class_add_event_class( *event_id = stream_class->next_event_id; } - ret = bt_ctf_event_class_set_stream_id(event_class, stream_class->id); - if (ret) { - BT_LOGE("Cannot set event class's stream class ID attribute: ret=%d", - ret); - goto end; - } - bt_object_set_parent(event_class, stream_class); if (trace) { @@ -614,15 +589,15 @@ int bt_ctf_stream_class_add_event_class( * 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, + bt_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_validation_replace_types(). */ - bt_ctf_validation_output_put_types(&validation_output); + bt_validation_output_put_types(&validation_output); } /* Add to the event classes of the stream class */ @@ -632,30 +607,41 @@ int bt_ctf_stream_class_add_event_class( event_id = NULL; /* Freeze the event class */ - bt_ctf_event_class_freeze(event_class); + bt_event_class_freeze(event_class); + + /* + * It is safe to set the stream class's unique clock class + * now if the stream class is frozen. + */ + if (stream_class->frozen && expected_clock_class) { + assert(!stream_class->clock_class || + stream_class->clock_class == expected_clock_class); + BT_MOVE(stream_class->clock_class, expected_clock_class); + } /* 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 }; + struct bt_visitor_object obj = { .object = event_class, + .type = BT_VISITOR_OBJECT_TYPE_EVENT_CLASS }; - (void) bt_ctf_trace_object_modification(&obj, trace); + (void) bt_trace_object_modification(&obj, trace); } BT_LOGD("Added event class to stream class: " "stream-class-addr=%p, stream-class-name=\"%s\", " "stream-class-id=%" PRId64 ", event-class-addr=%p, " "event-class-name=\"%s\", event-class-id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), event_class, - bt_ctf_event_class_get_name(event_class), - bt_ctf_event_class_get_id(event_class)); + bt_event_class_get_name(event_class), + bt_event_class_get_id(event_class)); end: BT_PUT(trace); BT_PUT(old_stream_class); - bt_ctf_validation_output_put_types(&validation_output); + bt_validation_output_put_types(&validation_output); + bt_put(expected_clock_class); assert(!packet_header_type); assert(!packet_context_type); assert(!event_header_type); @@ -667,8 +653,8 @@ end: return ret; } -int64_t bt_ctf_stream_class_get_event_class_count( - struct bt_ctf_stream_class *stream_class) +int64_t bt_stream_class_get_event_class_count( + struct bt_stream_class *stream_class) { int64_t ret; @@ -683,10 +669,10 @@ end: return ret; } -struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_index( - struct bt_ctf_stream_class *stream_class, uint64_t index) +struct bt_event_class *bt_stream_class_get_event_class_by_index( + struct bt_stream_class *stream_class, uint64_t index) { - struct bt_ctf_event_class *event_class = NULL; + struct bt_event_class *event_class = NULL; if (!stream_class) { BT_LOGW_STR("Invalid parameter: stream class is NULL."); @@ -697,8 +683,8 @@ struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_index( BT_LOGW("Invalid parameter: index is out of bounds: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "index=%" PRIu64 ", count=%u", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), index, stream_class->event_classes->len); goto end; } @@ -709,11 +695,11 @@ 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, uint64_t id) +struct bt_event_class *bt_stream_class_get_event_class_by_id( + struct bt_stream_class *stream_class, uint64_t id) { int64_t id_key = (int64_t) id; - struct bt_ctf_event_class *event_class = NULL; + struct bt_event_class *event_class = NULL; if (!stream_class) { BT_LOGW_STR("Invalid parameter: stream class is NULL."); @@ -725,8 +711,8 @@ struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_id( "stream-class-addr=%p, stream-class-name=\"%s\", " "stream-class-id=%" PRId64 ", event-class-id=%" PRIu64, stream_class, - bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), id); + bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), id); goto end; } @@ -737,10 +723,10 @@ 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_field_type *bt_stream_class_get_packet_context_type( + struct bt_stream_class *stream_class) { - struct bt_ctf_field_type *ret = NULL; + struct bt_field_type *ret = NULL; if (!stream_class) { BT_LOGW_STR("Invalid parameter: stream class is NULL."); @@ -753,9 +739,9 @@ 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 bt_stream_class_set_packet_context_type( + struct bt_stream_class *stream_class, + struct bt_field_type *packet_context_type) { int ret = 0; @@ -768,24 +754,24 @@ int bt_ctf_stream_class_set_packet_context_type( if (stream_class->frozen) { BT_LOGW("Invalid parameter: stream class is frozen: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); ret = -1; goto end; } if (packet_context_type && - bt_ctf_field_type_get_type_id(packet_context_type) != - BT_CTF_FIELD_TYPE_ID_STRUCT) { + bt_field_type_get_type_id(packet_context_type) != + BT_FIELD_TYPE_ID_STRUCT) { /* A packet context must be a structure. */ BT_LOGW("Invalid parameter: stream class's packet context field type must be a structure: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "packet-context-ft-addr=%p, packet-context-ft-id=%s", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), packet_context_type, - bt_ctf_field_type_id_string( - bt_ctf_field_type_get_type_id(packet_context_type))); + bt_field_type_id_string( + bt_field_type_get_type_id(packet_context_type))); ret = -1; goto end; } @@ -796,18 +782,18 @@ int bt_ctf_stream_class_set_packet_context_type( BT_LOGV("Set stream class's packet context field type: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "packet-context-ft-addr=%p", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), 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_field_type *bt_stream_class_get_event_header_type( + struct bt_stream_class *stream_class) { - struct bt_ctf_field_type *ret = NULL; + struct bt_field_type *ret = NULL; if (!stream_class) { BT_LOGW_STR("Invalid parameter: stream class is NULL."); @@ -817,8 +803,8 @@ struct bt_ctf_field_type *bt_ctf_stream_class_get_event_header_type( if (!stream_class->event_header_type) { BT_LOGV("Stream class has no event header field type: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); goto end; } @@ -828,9 +814,9 @@ 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 bt_stream_class_set_event_header_type( + struct bt_stream_class *stream_class, + struct bt_field_type *event_header_type) { int ret = 0; @@ -843,24 +829,24 @@ int bt_ctf_stream_class_set_event_header_type( if (stream_class->frozen) { BT_LOGW("Invalid parameter: stream class is frozen: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); ret = -1; goto end; } if (event_header_type && - bt_ctf_field_type_get_type_id(event_header_type) != - BT_CTF_FIELD_TYPE_ID_STRUCT) { + bt_field_type_get_type_id(event_header_type) != + BT_FIELD_TYPE_ID_STRUCT) { /* An event header must be a structure. */ BT_LOGW("Invalid parameter: stream class's event header field type must be a structure: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "event-header-ft-addr=%p, event-header-ft-id=%s", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), event_header_type, - bt_ctf_field_type_id_string( - bt_ctf_field_type_get_type_id(event_header_type))); + bt_field_type_id_string( + bt_field_type_get_type_id(event_header_type))); ret = -1; goto end; } @@ -870,17 +856,17 @@ int bt_ctf_stream_class_set_event_header_type( BT_LOGV("Set stream class's event header field type: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "event-header-ft-addr=%p", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), 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_field_type *bt_stream_class_get_event_context_type( + struct bt_stream_class *stream_class) { - struct bt_ctf_field_type *ret = NULL; + struct bt_field_type *ret = NULL; if (!stream_class) { BT_LOGW_STR("Invalid parameter: stream class is NULL."); @@ -897,9 +883,9 @@ 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 bt_stream_class_set_event_context_type( + struct bt_stream_class *stream_class, + struct bt_field_type *event_context_type) { int ret = 0; @@ -912,24 +898,24 @@ int bt_ctf_stream_class_set_event_context_type( if (stream_class->frozen) { BT_LOGW("Invalid parameter: stream class is frozen: " "addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); ret = -1; goto end; } if (event_context_type && - bt_ctf_field_type_get_type_id(event_context_type) != - BT_CTF_FIELD_TYPE_ID_STRUCT) { + bt_field_type_get_type_id(event_context_type) != + BT_FIELD_TYPE_ID_STRUCT) { /* A packet context must be a structure. */ BT_LOGW("Invalid parameter: stream class's event context field type must be a structure: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "event-context-ft-addr=%p, event-context-ft-id=%s", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), event_context_type, - bt_ctf_field_type_id_string( - bt_ctf_field_type_get_type_id(event_context_type))); + bt_field_type_id_string( + bt_field_type_get_type_id(event_context_type))); ret = -1; goto end; } @@ -939,21 +925,21 @@ int bt_ctf_stream_class_set_event_context_type( BT_LOGV("Set stream class's event context field type: " "addr=%p, name=\"%s\", id=%" PRId64 ", " "event-context-ft-addr=%p", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), event_context_type); end: return ret; } /* Pre-2.0 CTF writer backward compatibility */ -void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class) +void bt_ctf_stream_class_get(struct bt_stream_class *stream_class) { bt_get(stream_class); } /* Pre-2.0 CTF writer backward compatibility */ -void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class) +void bt_ctf_stream_class_put(struct bt_stream_class *stream_class) { bt_put(stream_class); } @@ -961,34 +947,34 @@ void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class) static int64_t get_event_class_count(void *element) { - return bt_ctf_stream_class_get_event_class_count( - (struct bt_ctf_stream_class *) element); + return bt_stream_class_get_event_class_count( + (struct bt_stream_class *) element); } static void *get_event_class(void *element, int i) { - return bt_ctf_stream_class_get_event_class_by_index( - (struct bt_ctf_stream_class *) element, i); + return bt_stream_class_get_event_class_by_index( + (struct bt_stream_class *) element, i); } static -int visit_event_class(void *object, bt_ctf_visitor visitor,void *data) +int visit_event_class(void *object, bt_visitor visitor,void *data) { - struct bt_ctf_object obj = + struct bt_visitor_object obj = { .object = object, - .type = BT_CTF_OBJECT_TYPE_EVENT_CLASS }; + .type = BT_VISITOR_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 bt_stream_class_visit(struct bt_stream_class *stream_class, + bt_visitor visitor, void *data) { int ret; - struct bt_ctf_object obj = + struct bt_visitor_object obj = { .object = stream_class, - .type = BT_CTF_OBJECT_TYPE_STREAM_CLASS }; + .type = BT_VISITOR_OBJECT_TYPE_STREAM_CLASS }; if (!stream_class || !visitor) { BT_LOGW("Invalid parameter: stream class or visitor is NULL: " @@ -1007,37 +993,39 @@ end: } BT_HIDDEN -void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class) +void bt_stream_class_freeze(struct bt_stream_class *stream_class) { if (!stream_class || stream_class->frozen) { return; } BT_LOGD("Freezing stream class: addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); 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); + bt_field_type_freeze(stream_class->event_header_type); + bt_field_type_freeze(stream_class->packet_context_type); + bt_field_type_freeze(stream_class->event_context_type); if (stream_class->clock) { - bt_ctf_clock_class_freeze(stream_class->clock->clock_class); + bt_clock_class_freeze(stream_class->clock->clock_class); } } BT_HIDDEN -int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class, +int bt_stream_class_serialize(struct bt_stream_class *stream_class, struct metadata_context *context) { int ret = 0; size_t i; + struct bt_trace *trace; + struct bt_field_type *packet_header_type = NULL; BT_LOGD("Serializing stream class's metadata: " "stream-class-addr=%p, stream-class-name=\"%s\", " "stream-class-id=%" PRId64 ", metadata-context-addr=%p", - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class), context); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), context); g_string_assign(context->field_name, ""); context->current_indentation_level = 1; if (!stream_class->id_set) { @@ -1046,75 +1034,118 @@ int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class, goto end; } - g_string_append_printf(context->string, - "stream {\n\tid = %" PRId64 ";\n\tevent.header := ", - stream_class->id); - ret = bt_ctf_field_type_serialize(stream_class->event_header_type, - context); - if (ret) { - BT_LOGW("Cannot serialize stream class's event header field type's metadata: " - "ret=%d", ret); - goto end; + g_string_append(context->string, "stream {\n"); + + /* + * The reference to the trace is only borrowed since the + * serialization of the stream class might have been triggered + * by the trace's destruction. In such a case, the trace's + * reference count would, unexepectedly, go through the sequence + * 1 -> 0 -> 1 -> 0 -> ..., provoking an endless loop of destruction + * and serialization. + */ + trace = bt_stream_class_borrow_trace(stream_class); + assert(trace); + packet_header_type = bt_trace_get_packet_header_type(trace); + trace = NULL; + if (packet_header_type) { + struct bt_field_type *stream_id_type; + + stream_id_type = + bt_field_type_structure_get_field_type_by_name( + packet_header_type, "stream_id"); + if (stream_id_type) { + /* + * Only set the stream's id if the trace's packet header + * contains a stream_id field. This field is only + * needed if the trace contains only one stream + * class. + */ + g_string_append_printf(context->string, + "\tid = %" PRId64 ";\n", stream_class->id); + } + bt_put(stream_id_type); + } + if (stream_class->event_header_type) { + BT_LOGD_STR("Serializing stream class's event header field type's metadata."); + g_string_append(context->string, "\tevent.header := "); + ret = bt_field_type_serialize(stream_class->event_header_type, + context); + if (ret) { + BT_LOGW("Cannot serialize stream class's event header field type's metadata: " + "ret=%d", ret); + goto end; + } + g_string_append(context->string, ";"); } + 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, + BT_LOGD_STR("Serializing stream class's packet context field type's metadata."); + g_string_append(context->string, "\n\n\tpacket.context := "); + ret = bt_field_type_serialize(stream_class->packet_context_type, context); if (ret) { BT_LOGW("Cannot serialize stream class's packet context field type's metadata: " "ret=%d", ret); goto end; } + g_string_append(context->string, ";"); } if (stream_class->event_context_type) { - g_string_append(context->string, ";\n\n\tevent.context := "); - ret = bt_ctf_field_type_serialize( + BT_LOGD_STR("Serializing stream class's event context field type's metadata."); + g_string_append(context->string, "\n\n\tevent.context := "); + ret = bt_field_type_serialize( stream_class->event_context_type, context); if (ret) { BT_LOGW("Cannot serialize stream class's event context field type's metadata: " "ret=%d", ret); goto end; } + g_string_append(context->string, ";"); } - g_string_append(context->string, ";\n};\n\n"); + 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 = + struct bt_event_class *event_class = stream_class->event_classes->pdata[i]; - ret = bt_ctf_event_class_serialize(event_class, context); + ret = bt_event_class_serialize(event_class, context); if (ret) { BT_LOGW("Cannot serialize event class's metadata: " "event-class-addr=%p, event-class-name=\"%s\", " "event-class-id=%" PRId64, event_class, - bt_ctf_event_class_get_name(event_class), - bt_ctf_event_class_get_id(event_class)); + bt_event_class_get_name(event_class), + bt_event_class_get_id(event_class)); goto end; } } end: + bt_put(packet_header_type); context->current_indentation_level = 0; return ret; } static -void bt_ctf_stream_class_destroy(struct bt_object *obj) +void bt_stream_class_destroy(struct bt_object *obj) { - struct bt_ctf_stream_class *stream_class; + struct bt_stream_class *stream_class; - stream_class = container_of(obj, struct bt_ctf_stream_class, base); + stream_class = container_of(obj, struct bt_stream_class, base); BT_LOGD("Destroying stream class: addr=%p, name=\"%s\", id=%" PRId64, - stream_class, bt_ctf_stream_class_get_name(stream_class), - bt_ctf_stream_class_get_id(stream_class)); + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class)); bt_put(stream_class->clock); + bt_put(stream_class->clock_class); if (stream_class->event_classes_ht) { g_hash_table_destroy(stream_class->event_classes_ht); } if (stream_class->event_classes) { + BT_LOGD_STR("Destroying event classes."); g_ptr_array_free(stream_class->event_classes, TRUE); } @@ -1122,21 +1153,24 @@ void bt_ctf_stream_class_destroy(struct bt_object *obj) g_string_free(stream_class->name, TRUE); } + BT_LOGD_STR("Putting event header field type."); bt_put(stream_class->event_header_type); + BT_LOGD_STR("Putting packet context field type."); bt_put(stream_class->packet_context_type); + BT_LOGD_STR("Putting event context field 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 init_event_header(struct bt_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 = + struct bt_field_type *event_header_type = + bt_field_type_structure_create(); + struct bt_field_type *_uint32_t = get_field_type(FIELD_TYPE_ALIAS_UINT32_T); - struct bt_ctf_field_type *_uint64_t = + struct bt_field_type *_uint64_t = get_field_type(FIELD_TYPE_ALIAS_UINT64_T); if (!event_header_type) { @@ -1145,14 +1179,14 @@ int init_event_header(struct bt_ctf_stream_class *stream_class) goto end; } - ret = bt_ctf_field_type_structure_add_field(event_header_type, + ret = bt_field_type_structure_add_field(event_header_type, _uint32_t, "id"); if (ret) { BT_LOGE_STR("Cannot add `id` field to event header field type."); goto end; } - ret = bt_ctf_field_type_structure_add_field(event_header_type, + ret = bt_field_type_structure_add_field(event_header_type, _uint64_t, "timestamp"); if (ret) { BT_LOGE_STR("Cannot add `timestamp` field to event header field type."); @@ -1171,13 +1205,14 @@ end: } static -int init_packet_context(struct bt_ctf_stream_class *stream_class) +int init_packet_context(struct bt_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 = + struct bt_field_type *packet_context_type = + bt_field_type_structure_create(); + struct bt_field_type *_uint64_t = get_field_type(FIELD_TYPE_ALIAS_UINT64_T); + struct bt_field_type *ts_begin_end_uint64_t; if (!packet_context_type) { BT_LOGE_STR("Cannot create empty structure field type."); @@ -1185,39 +1220,46 @@ int init_packet_context(struct bt_ctf_stream_class *stream_class) goto end; } + ts_begin_end_uint64_t = bt_field_type_copy(_uint64_t); + if (!ts_begin_end_uint64_t) { + BT_LOGE_STR("Cannot copy integer field type for `timestamp_begin` and `timestamp_end` fields."); + 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"); + ret = bt_field_type_structure_add_field(packet_context_type, + ts_begin_end_uint64_t, "timestamp_begin"); if (ret) { BT_LOGE_STR("Cannot add `timestamp_begin` field to event header field type."); goto end; } - ret = bt_ctf_field_type_structure_add_field(packet_context_type, - _uint64_t, "timestamp_end"); + ret = bt_field_type_structure_add_field(packet_context_type, + ts_begin_end_uint64_t, "timestamp_end"); if (ret) { BT_LOGE_STR("Cannot add `timestamp_end` field to event header field type."); goto end; } - ret = bt_ctf_field_type_structure_add_field(packet_context_type, + ret = bt_field_type_structure_add_field(packet_context_type, _uint64_t, "content_size"); if (ret) { BT_LOGE_STR("Cannot add `content_size` field to event header field type."); goto end; } - ret = bt_ctf_field_type_structure_add_field(packet_context_type, + ret = bt_field_type_structure_add_field(packet_context_type, _uint64_t, "packet_size"); if (ret) { BT_LOGE_STR("Cannot add `packet_size` field to event header field type."); goto end; } - ret = bt_ctf_field_type_structure_add_field(packet_context_type, + ret = bt_field_type_structure_add_field(packet_context_type, _uint64_t, "events_discarded"); if (ret) { BT_LOGE_STR("Cannot add `events_discarded` field to event header field type."); @@ -1232,5 +1274,195 @@ end: } bt_put(_uint64_t); + bt_put(ts_begin_end_uint64_t); + return ret; +} + +static +int try_map_clock_class(struct bt_stream_class *stream_class, + struct bt_field_type *parent_ft, const char *field_name) +{ + struct bt_clock_class *mapped_clock_class = NULL; + int ret = 0; + struct bt_field_type *ft = + bt_field_type_structure_get_field_type_by_name(parent_ft, + field_name); + + assert(stream_class->clock); + + if (!ft) { + /* Field does not exist: not an error */ + goto end; + } + + assert(bt_field_type_is_integer(ft)); + mapped_clock_class = + bt_field_type_integer_get_mapped_clock_class(ft); + if (!mapped_clock_class) { + struct bt_field_type *ft_copy; + + if (!stream_class->clock) { + BT_LOGW("Cannot automatically set field's type mapped clock class: stream class's clock is not set: " + "stream-class-addr=%p, stream-class-name=\"%s\", " + "stream-class-id=%" PRId64 ", ft-addr=%p", + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), ft); + ret = -1; + goto end; + } + + ft_copy = bt_field_type_copy(ft); + if (!ft_copy) { + BT_LOGE("Failed to copy integer field type: ft-addr=%p", + ft); + } + + ret = bt_field_type_integer_set_mapped_clock_class_no_check( + ft_copy, stream_class->clock->clock_class); + assert(ret == 0); + ret = bt_field_type_structure_replace_field(parent_ft, + field_name, ft_copy); + bt_put(ft_copy); + BT_LOGV("Automatically mapped field type to stream class's clock class: " + "stream-class-addr=%p, stream-class-name=\"%s\", " + "stream-class-id=%" PRId64 ", ft-addr=%p, " + "ft-copy-addr=%p", + stream_class, bt_stream_class_get_name(stream_class), + bt_stream_class_get_id(stream_class), ft, ft_copy); + } + +end: + bt_put(ft); + bt_put(mapped_clock_class); + return ret; +} + +BT_HIDDEN +int bt_stream_class_map_clock_class( + struct bt_stream_class *stream_class, + struct bt_field_type *packet_context_type, + struct bt_field_type *event_header_type) +{ + int ret = 0; + + assert(stream_class); + + if (!stream_class->clock) { + /* No clock class to map to */ + goto end; + } + + if (packet_context_type) { + if (try_map_clock_class(stream_class, packet_context_type, + "timestamp_begin")) { + BT_LOGE_STR("Cannot automatically set stream class's packet context field type's `timestamp_begin` field's mapped clock class."); + ret = -1; + goto end; + } + + if (try_map_clock_class(stream_class, packet_context_type, + "timestamp_end")) { + BT_LOGE_STR("Cannot automatically set stream class's packet context field type's `timestamp_end` field's mapped clock class."); + ret = -1; + goto end; + } + } + + if (event_header_type) { + if (try_map_clock_class(stream_class, event_header_type, + "timestamp")) { + BT_LOGE_STR("Cannot automatically set stream class's event header field type's `timestamp` field's mapped clock class."); + ret = -1; + goto end; + } + } + +end: + return ret; +} + +BT_HIDDEN +int bt_stream_class_validate_single_clock_class( + struct bt_stream_class *stream_class, + struct bt_clock_class **expected_clock_class) +{ + int ret; + uint64_t i; + + assert(stream_class); + assert(expected_clock_class); + ret = bt_validate_single_clock_class(stream_class->packet_context_type, + expected_clock_class); + if (ret) { + BT_LOGW("Stream class's packet context field type " + "is not recursively mapped to the " + "expected clock class: " + "stream-class-addr=%p, " + "stream-class-name=\"%s\", " + "stream-class-id=%" PRId64 ", " + "ft-addr=%p", + stream_class, + bt_stream_class_get_name(stream_class), + stream_class->id, + stream_class->packet_context_type); + goto end; + } + + ret = bt_validate_single_clock_class(stream_class->event_header_type, + expected_clock_class); + if (ret) { + BT_LOGW("Stream class's event header field type " + "is not recursively mapped to the " + "expected clock class: " + "stream-class-addr=%p, " + "stream-class-name=\"%s\", " + "stream-class-id=%" PRId64 ", " + "ft-addr=%p", + stream_class, + bt_stream_class_get_name(stream_class), + stream_class->id, + stream_class->event_header_type); + goto end; + } + + ret = bt_validate_single_clock_class(stream_class->event_context_type, + expected_clock_class); + if (ret) { + BT_LOGW("Stream class's event context field type " + "is not recursively mapped to the " + "expected clock class: " + "stream-class-addr=%p, " + "stream-class-name=\"%s\", " + "stream-class-id=%" PRId64 ", " + "ft-addr=%p", + stream_class, + bt_stream_class_get_name(stream_class), + stream_class->id, + stream_class->event_context_type); + goto end; + } + + for (i = 0; i < stream_class->event_classes->len; i++) { + struct bt_event_class *event_class = + g_ptr_array_index(stream_class->event_classes, i); + + assert(event_class); + ret = bt_event_class_validate_single_clock_class(event_class, + expected_clock_class); + if (ret) { + BT_LOGW("Stream class's event class contains a " + "field type which is not recursively mapped to " + "the expected clock class: " + "stream-class-addr=%p, " + "stream-class-name=\"%s\", " + "stream-class-id=%" PRId64, + stream_class, + bt_stream_class_get_name(stream_class), + stream_class->id); + goto end; + } + } + +end: return ret; }