X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Flttng-utils%2Fcopy.c;h=adb6619e184f365fbdad592c26fefb3846d013a5;hb=40f4ba76dd6f9508ca51b6220eaed57632281a07;hp=52d5b4899b7b3f63abaa10ba1da4e4963809eb11;hpb=30480ffea774b704d1890837162d1fdf012babfb;p=babeltrace.git diff --git a/plugins/lttng-utils/copy.c b/plugins/lttng-utils/copy.c index 52d5b489..adb6619e 100644 --- a/plugins/lttng-utils/copy.c +++ b/plugins/lttng-utils/copy.c @@ -26,42 +26,38 @@ * SOFTWARE. */ +#define BT_LOG_TAG "PLUGIN-LTTNG-UTILS-DEBUG-INFO-FLT-COPY" +#include "logging.h" + #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include #include #include "debug-info.h" static -struct bt_ctf_stream *insert_new_stream( +const struct bt_stream *insert_new_stream( struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream, + const struct bt_stream *stream, struct debug_info_trace *di_trace); static -void unref_stream(struct bt_ctf_stream *stream) +void unref_stream(const struct bt_stream *stream) { - bt_put(stream); + bt_object_put_ref(stream); } static -void unref_packet(struct bt_ctf_packet *packet) +void unref_packet(const struct bt_packet *packet) { - bt_put(packet); + bt_object_put_ref(packet); } static -void unref_stream_class(struct bt_ctf_stream_class *stream_class) +void unref_stream_class(const struct bt_stream_class *stream_class) { - bt_put(stream_class); + bt_object_put_ref(stream_class); } static @@ -77,123 +73,112 @@ void destroy_stream_state_key(gpointer key) } static -struct bt_ctf_field *get_payload_field(FILE *err, - struct bt_ctf_event *event, const char *field_name) +const struct bt_field *get_payload_field(FILE *err, + const struct bt_event *event, const char *field_name) { - struct bt_ctf_field *field = NULL, *sec = NULL; - struct bt_ctf_field_type *sec_type = NULL; + const struct bt_field *field = NULL, *payload = NULL; + const struct bt_field_class *payload_class = NULL; - sec = bt_ctf_event_get_payload(event, NULL); - if (!sec) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; - } + payload = bt_event_get_payload(event, NULL); + BT_ASSERT(payload); - sec_type = bt_ctf_field_get_type(sec); - if (!sec_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; - } + payload_class = bt_field_get_class(payload); + BT_ASSERT(payload_class); - if (bt_ctf_field_type_get_type_id(sec_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_id(payload_class) != BT_FIELD_CLASS_TYPE_STRUCT) { + BT_LOGE("Wrong type, expected struct: field-name=\"%s\"", + field_name); goto end; } - field = bt_ctf_field_structure_get_field(sec, field_name); + field = bt_field_structure_get_field_by_name(payload, field_name); end: - bt_put(sec_type); - bt_put(sec); + bt_object_put_ref(payload_class); + bt_object_put_ref(payload); return field; } static -struct bt_ctf_field *get_stream_event_context_field(FILE *err, - struct bt_ctf_event *event, const char *field_name) +const struct bt_field *get_stream_event_context_field(FILE *err, + const struct bt_event *event, const char *field_name) { - struct bt_ctf_field *field = NULL, *sec = NULL; - struct bt_ctf_field_type *sec_type = NULL; + const struct bt_field *field = NULL, *sec = NULL; + const struct bt_field_class *sec_class = NULL; - sec = bt_ctf_event_get_stream_event_context(event); + sec = bt_event_get_stream_event_context(event); if (!sec) { goto end; } - sec_type = bt_ctf_field_get_type(sec); - if (!sec_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; - } + sec_class = bt_field_get_class(sec); + BT_ASSERT(sec_class); - if (bt_ctf_field_type_get_type_id(sec_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_id(sec_class) != BT_FIELD_CLASS_TYPE_STRUCT) { + BT_LOGE("Wrong type, expected struct, field-name=\"%s\"", + field_name); goto end; } - field = bt_ctf_field_structure_get_field(sec, field_name); + field = bt_field_structure_get_field_by_name(sec, field_name); end: - bt_put(sec_type); - bt_put(sec); + bt_object_put_ref(sec_class); + bt_object_put_ref(sec); return field; } BT_HIDDEN int get_stream_event_context_unsigned_int_field_value(FILE *err, - struct bt_ctf_event *event, const char *field_name, + const struct bt_event *event, const char *field_name, uint64_t *value) { int ret; - struct bt_ctf_field *field = NULL; - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field *field = NULL; + const struct bt_field_class *field_class = NULL; field = get_stream_event_context_field(err, event, field_name); if (!field) { goto error; } - field_type = bt_ctf_field_get_type(field); - if (!field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + field_class = bt_field_get_class(field); + BT_ASSERT(field_class); + + if (bt_field_class_id(field_class) != BT_FIELD_CLASS_TYPE_INTEGER) { + BT_LOGE("Wrong type, expected integer: field-name=\"%s\"", + field_name); goto error; } - if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_ctf_field_class_integer_get_signed(field_class) != 0) { + BT_LOGE("Wrong type, expected unsigned integer: field-name=\"%s\"", + field_name); goto error; } - if (bt_ctf_field_type_integer_get_signed(field_type) != 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + ret = bt_field_unsigned_integer_get_value(field, value); + if (ret) { + BT_LOGE("Failed to get value: field-name=\"%s\"", + field_name); goto error; } - - ret = bt_ctf_field_unsigned_integer_get_value(field, value); goto end; error: ret = -1; end: - bt_put(field_type); - bt_put(field); + bt_object_put_ref(field_class); + bt_object_put_ref(field); return ret; } BT_HIDDEN -int get_stream_event_context_int_field_value(FILE *err, struct bt_ctf_event *event, +int get_stream_event_context_int_field_value(FILE *err, const struct bt_event *event, const char *field_name, int64_t *value) { - struct bt_ctf_field *field = NULL; - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field *field = NULL; + const struct bt_field_class *field_class = NULL; int ret; field = get_stream_event_context_field(err, event, field_name); @@ -201,134 +186,128 @@ int get_stream_event_context_int_field_value(FILE *err, struct bt_ctf_event *eve goto error; } - field_type = bt_ctf_field_get_type(field); - if (!field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + field_class = bt_field_get_class(field); + BT_ASSERT(field_class); - if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_id(field_class) != BT_FIELD_CLASS_TYPE_INTEGER) { + BT_LOGE("Wrong type, expected integer: field-name=\"%s\"", field_name); goto error; } - if (bt_ctf_field_type_integer_get_signed(field_type) != 1) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_ctf_field_class_integer_get_signed(field_class) != 1) { + BT_LOGE("Wrong type, expected signed integer: field-name=\"%s\"", + field_name); goto error; } - ret = bt_ctf_field_signed_integer_get_value(field, value); + ret = bt_field_signed_integer_get_value(field, value); goto end; error: ret = -1; end: - bt_put(field_type); - bt_put(field); + bt_object_put_ref(field_class); + bt_object_put_ref(field); return ret; } BT_HIDDEN int get_payload_unsigned_int_field_value(FILE *err, - struct bt_ctf_event *event, const char *field_name, + const struct bt_event *event, const char *field_name, uint64_t *value) { - struct bt_ctf_field *field = NULL; - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field *field = NULL; + const struct bt_field_class *field_class = NULL; int ret; field = get_payload_field(err, event, field_name); if (!field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get payload: field-name=\"%s\"", field_name); goto error; } - field_type = bt_ctf_field_get_type(field); - if (!field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + field_class = bt_field_get_class(field); + BT_ASSERT(field_class); + + if (bt_field_class_id(field_class) != BT_FIELD_CLASS_TYPE_INTEGER) { + BT_LOGE("Wrong type, expected integer: field-name=\"%s\"", + field_name); goto error; } - if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_ctf_field_class_integer_get_signed(field_class) != 0) { + BT_LOGE("Wrong type, expected unsigned integer: field-name=\"%s\"", + field_name); goto error; } - if (bt_ctf_field_type_integer_get_signed(field_type) != 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + ret = bt_field_unsigned_integer_get_value(field, value); + if (ret) { + BT_LOGE("Failed to get value: field-name=\"%s\"", + field_name); goto error; } - - ret = bt_ctf_field_unsigned_integer_get_value(field, value); goto end; error: ret = -1; end: - bt_put(field_type); - bt_put(field); + bt_object_put_ref(field_class); + bt_object_put_ref(field); return ret; } BT_HIDDEN -int get_payload_int_field_value(FILE *err, struct bt_ctf_event *event, +int get_payload_int_field_value(FILE *err, const struct bt_event *event, const char *field_name, int64_t *value) { - struct bt_ctf_field *field = NULL; - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field *field = NULL; + const struct bt_field_class *field_class = NULL; int ret; field = get_payload_field(err, event, field_name); if (!field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get payload: field-name=\"%s\"", field_name); goto error; } - field_type = bt_ctf_field_get_type(field); - if (!field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + field_class = bt_field_get_class(field); + BT_ASSERT(field_class); + + if (bt_field_class_id(field_class) != BT_FIELD_CLASS_TYPE_INTEGER) { + BT_LOGE("Wrong type, expected integer: field-name=\"%s\"", field_name); goto error; } - if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_INTEGER) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_ctf_field_class_integer_get_signed(field_class) != 1) { + BT_LOGE("Wrong type, expected signed integer field-name=\"%s\"", + field_name); goto error; } - if (bt_ctf_field_type_integer_get_signed(field_type) != 1) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + ret = bt_field_signed_integer_get_value(field, value); + if (ret) { + BT_LOGE("Failed to get value: field-name=\"%s\"", + field_name); goto error; } - - ret = bt_ctf_field_signed_integer_get_value(field, value); goto end; error: ret = -1; end: - bt_put(field_type); - bt_put(field); + bt_object_put_ref(field_class); + bt_object_put_ref(field); return ret; } BT_HIDDEN int get_payload_string_field_value(FILE *err, - struct bt_ctf_event *event, const char *field_name, + const struct bt_event *event, const char *field_name, const char **value) { - struct bt_ctf_field *field = NULL; - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field *field = NULL; + const struct bt_field_class *field_class = NULL; int ret; /* @@ -339,23 +318,19 @@ int get_payload_string_field_value(FILE *err, goto error; } - field_type = bt_ctf_field_get_type(field); - if (!field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + field_class = bt_field_get_class(field); + BT_ASSERT(field_class); - if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_STRING) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_id(field_class) != BT_FIELD_CLASS_TYPE_STRING) { + BT_LOGE("Wrong type, expected string: field-name=\"%s\"", + field_name); goto error; } - *value = bt_ctf_field_string_get_value(field); + *value = bt_field_string_get_value(field); if (!*value) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get value: field-name=\"%s\"", + field_name); goto error; } @@ -365,19 +340,19 @@ int get_payload_string_field_value(FILE *err, error: ret = -1; end: - bt_put(field_type); - bt_put(field); + bt_object_put_ref(field_class); + bt_object_put_ref(field); return ret; } BT_HIDDEN int get_payload_build_id_field_value(FILE *err, - struct bt_ctf_event *event, const char *field_name, + const struct bt_event *event, const char *field_name, uint8_t **build_id, uint64_t *build_id_len) { - struct bt_ctf_field *field = NULL, *seq_len = NULL; - struct bt_ctf_field_type *field_type = NULL; - struct bt_ctf_field *seq_field = NULL; + const struct bt_field *field = NULL, *seq_len = NULL; + const struct bt_field_class *field_class = NULL; + const struct bt_field *seq_field = NULL; uint64_t i; int ret; @@ -385,64 +360,54 @@ int get_payload_build_id_field_value(FILE *err, field = get_payload_field(err, event, field_name); if (!field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get payload: field-name=\"%s\"", field_name); goto error; } - field_type = bt_ctf_field_get_type(field); - if (!field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + field_class = bt_field_get_class(field); + BT_ASSERT(field_class); - if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_FIELD_TYPE_ID_SEQUENCE) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_id(field_class) != BT_FIELD_CLASS_TYPE_SEQUENCE) { + BT_LOGE("Wrong type, expected sequence: field-name=\"%s\"", field_name); goto error; } - BT_PUT(field_type); + BT_OBJECT_PUT_REF_AND_RESET(field_class); - seq_len = bt_ctf_field_sequence_get_length(field); - if (!seq_len) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + seq_len = bt_field_sequence_get_length(field); + BT_ASSERT(seq_len); - ret = bt_ctf_field_unsigned_integer_get_value(seq_len, build_id_len); + ret = bt_field_unsigned_integer_get_value(seq_len, build_id_len); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get value: field-name=\"%s\"", + field_name); goto error; } - BT_PUT(seq_len); + BT_OBJECT_PUT_REF_AND_RESET(seq_len); *build_id = g_new0(uint8_t, *build_id_len); if (!*build_id) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to allocate build_id."); goto error; } for (i = 0; i < *build_id_len; i++) { uint64_t tmp; - seq_field = bt_ctf_field_sequence_get_field(field, i); + seq_field = bt_field_sequence_get_field(field, i); if (!seq_field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get field in sequence: sequence-name=\"%s\", index=%" PRIu64, + field_name, i); goto error; } - ret = bt_ctf_field_unsigned_integer_get_value(seq_field, &tmp); + ret = bt_field_unsigned_integer_get_value(seq_field, &tmp); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to get value: field-name=\"%s\"", + field_name); goto error; } - BT_PUT(seq_field); + + BT_OBJECT_PUT_REF_AND_RESET(seq_field); (*build_id)[i] = (uint8_t) tmp; } ret = 0; @@ -452,14 +417,14 @@ error: g_free(*build_id); ret = -1; end: - bt_put(field_type); - bt_put(field); + bt_object_put_ref(field_class); + bt_object_put_ref(field); return ret; } static struct debug_info *lookup_trace_debug_info(struct debug_info_iterator *debug_it, - struct bt_ctf_trace *writer_trace, + const struct bt_trace *writer_trace, struct debug_info_trace *di_trace) { return (struct debug_info *) g_hash_table_lookup( @@ -469,7 +434,7 @@ struct debug_info *lookup_trace_debug_info(struct debug_info_iterator *debug_it, static struct debug_info *insert_new_debug_info(struct debug_info_iterator *debug_it, - struct bt_ctf_trace *writer_trace, + const struct bt_trace *writer_trace, struct debug_info_trace *di_trace) { struct debug_info *debug_info = NULL; @@ -477,47 +442,38 @@ struct debug_info *insert_new_debug_info(struct debug_info_iterator *debug_it, const char *str_value; enum bt_value_status ret; - field = bt_ctf_trace_get_environment_field_value_by_name(writer_trace, + field = bt_trace_get_environment_field_value_by_name(writer_trace, "domain"); /* No domain field, no debug info */ if (!field) { goto end; } - ret = bt_value_string_get(field, &str_value); - if (ret != BT_VALUE_STATUS_OK) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; - } + str_value = bt_value_string_get(field); + /* Domain not ust, no debug info */ if (strcmp(str_value, "ust") != 0) { goto end; } - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field); /* No tracer_name, no debug info */ - field = bt_ctf_trace_get_environment_field_value_by_name(writer_trace, + field = bt_trace_get_environment_field_value_by_name(writer_trace, "tracer_name"); /* No tracer_name, no debug info */ if (!field) { goto end; } - ret = bt_value_string_get(field, &str_value); - if (ret != BT_VALUE_STATUS_OK) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; - } + str_value = bt_value_string_get(field); + /* Tracer_name not lttng-ust, no debug info */ if (strcmp(str_value, "lttng-ust") != 0) { goto end; } - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field); debug_info = debug_info_create(debug_it->debug_info_component); if (!debug_info) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to create debug info."); goto end; } @@ -525,13 +481,13 @@ struct debug_info *insert_new_debug_info(struct debug_info_iterator *debug_it, debug_info); end: - bt_put(field); + bt_object_put_ref(field); return debug_info; } static struct debug_info *get_trace_debug_info(struct debug_info_iterator *debug_it, - struct bt_ctf_trace *writer_trace, + const struct bt_trace *writer_trace, struct debug_info_trace *di_trace) { struct debug_info *debug_info; @@ -549,7 +505,7 @@ end: static struct debug_info_trace *lookup_trace(struct debug_info_iterator *debug_it, - struct bt_ctf_trace *trace) + const struct bt_trace *trace) { return (struct debug_info_trace *) g_hash_table_lookup( debug_it->trace_map, @@ -559,14 +515,13 @@ struct debug_info_trace *lookup_trace(struct debug_info_iterator *debug_it, static enum debug_info_stream_state *insert_new_stream_state( struct debug_info_iterator *debug_it, - struct debug_info_trace *di_trace, struct bt_ctf_stream *stream) + struct debug_info_trace *di_trace, const struct bt_stream *stream) { enum debug_info_stream_state *v = NULL; v = g_new0(enum debug_info_stream_state, 1); if (!v) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to allocate debug_info_stream_state."); goto end; } *v = DEBUG_INFO_UNKNOWN_STREAM; @@ -599,7 +554,7 @@ void debug_info_close_trace(struct debug_info_iterator *debug_it, struct debug_info_trace *di_trace) { if (di_trace->static_listener_id >= 0) { - bt_ctf_trace_remove_is_static_listener(di_trace->trace, + bt_trace_remove_is_static_listener(di_trace->trace, di_trace->static_listener_id); } @@ -631,31 +586,24 @@ void debug_info_close_trace(struct debug_info_iterator *debug_it, static int sync_event_classes(struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream, - struct bt_ctf_stream *writer_stream) + const struct bt_stream *stream, + const struct bt_stream *writer_stream) { int int_ret; - struct bt_ctf_stream_class *stream_class = NULL, + const struct bt_stream_class *stream_class = NULL, *writer_stream_class = NULL; enum bt_component_status ret; - stream_class = bt_ctf_stream_get_class(stream); - if (!stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); - writer_stream_class = bt_ctf_stream_get_class(writer_stream); - if (!writer_stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + writer_stream_class = bt_stream_get_class(writer_stream); + BT_ASSERT(writer_stream_class); ret = ctf_copy_event_classes(debug_it->err, stream_class, writer_stream_class); if (ret != BT_COMPONENT_STATUS_OK) { + BT_LOGE_STR("Failed to copy event classes."); goto error; } @@ -665,53 +613,42 @@ int sync_event_classes(struct debug_info_iterator *debug_it, error: int_ret = -1; end: - bt_put(stream_class); - bt_put(writer_stream_class); + bt_object_put_ref(stream_class); + bt_object_put_ref(writer_stream_class); return int_ret; } static -void trace_is_static_listener(struct bt_ctf_trace *trace, void *data) +void trace_is_static_listener(const struct bt_trace *trace, void *data) { struct debug_info_trace *di_trace = data; - struct debug_info_iterator *debug_it = di_trace->debug_it; int trace_completed = 1, ret, nr_stream, i; - struct bt_ctf_stream *stream = NULL, *writer_stream = NULL; - struct bt_ctf_trace *writer_trace = di_trace->writer_trace; + const struct bt_stream *stream = NULL, *writer_stream = NULL; + const struct bt_trace *writer_trace = di_trace->writer_trace; /* * When the trace becomes static, make sure that we have all * the event classes in our stream_class copies before setting it * static as well. */ - nr_stream = bt_ctf_trace_get_stream_count(trace); + nr_stream = bt_trace_get_stream_count(trace); for (i = 0; i < nr_stream; i++) { - stream = bt_ctf_trace_get_stream_by_index(trace, i); - if (!stream) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } - writer_stream = bt_ctf_trace_get_stream_by_index(writer_trace, i); - if (!writer_stream) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + stream = bt_trace_get_stream_by_index(trace, i); + BT_ASSERT(stream); + + writer_stream = bt_trace_get_stream_by_index(writer_trace, i); + BT_ASSERT(writer_stream); + ret = sync_event_classes(di_trace->debug_it, stream, writer_stream); if (ret) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to synchronize the event classes."); goto error; } - BT_PUT(stream); - BT_PUT(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); } - bt_ctf_trace_set_is_static(di_trace->writer_trace); + bt_trace_set_is_static(di_trace->writer_trace); di_trace->trace_static = 1; g_hash_table_foreach(di_trace->stream_states, @@ -723,52 +660,41 @@ void trace_is_static_listener(struct bt_ctf_trace *trace, void *data) } error: - bt_put(writer_stream); - bt_put(stream); + bt_object_put_ref(writer_stream); + bt_object_put_ref(stream); } static struct debug_info_trace *insert_new_trace(struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream) { - struct bt_ctf_trace *writer_trace = NULL; + const struct bt_stream *stream) { + const struct bt_trace *writer_trace = NULL; struct debug_info_trace *di_trace = NULL; - struct bt_ctf_trace *trace = NULL; - struct bt_ctf_stream_class *stream_class = NULL; - struct bt_ctf_stream *writer_stream = NULL; + const struct bt_trace *trace = NULL; + const struct bt_stream_class *stream_class = NULL; + const struct bt_stream *writer_stream = NULL; int ret, nr_stream, i; - writer_trace = bt_ctf_trace_create(); + writer_trace = bt_trace_create(); if (!writer_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to create a new trace."); goto error; } - stream_class = bt_ctf_stream_get_class(stream); - if (!stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); - trace = bt_ctf_stream_class_get_trace(stream_class); - if (!trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + trace = bt_stream_class_get_trace(stream_class); + BT_ASSERT(trace); ret = ctf_copy_trace(debug_it->err, trace, writer_trace); if (ret != BT_COMPONENT_STATUS_OK) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy CTF trace."); goto error; } di_trace = g_new0(struct debug_info_trace, 1); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to allocate debug_info_trace."); goto error; } @@ -789,49 +715,36 @@ struct debug_info_trace *insert_new_trace(struct debug_info_iterator *debug_it, g_hash_table_insert(debug_it->trace_map, (gpointer) trace, di_trace); /* Set all the existing streams in the unknown state. */ - nr_stream = bt_ctf_trace_get_stream_count(trace); + nr_stream = bt_trace_get_stream_count(trace); for (i = 0; i < nr_stream; i++) { - stream = bt_ctf_trace_get_stream_by_index(trace, i); - if (!stream) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + stream = bt_trace_get_stream_by_index(trace, i); + BT_ASSERT(stream); + insert_new_stream_state(debug_it, di_trace, stream); writer_stream = insert_new_stream(debug_it, stream, di_trace); if (!writer_stream) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to insert new stream."); goto error; } - bt_get(writer_stream); + bt_object_get_ref(writer_stream); ret = sync_event_classes(debug_it, stream, writer_stream); if (ret) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to synchronize event classes."); goto error; } - BT_PUT(writer_stream); - BT_PUT(stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(stream); } /* Check if the trace is already static or register a listener. */ - if (bt_ctf_trace_is_static(trace)) { + if (bt_trace_is_static(trace)) { di_trace->trace_static = 1; di_trace->static_listener_id = -1; - bt_ctf_trace_set_is_static(writer_trace); + bt_trace_set_is_static(writer_trace); } else { - ret = bt_ctf_trace_add_is_static_listener(trace, - trace_is_static_listener, di_trace); - if (ret < 0) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto error; - } + ret = bt_trace_add_is_static_listener(trace, + trace_is_static_listener, NULL, di_trace); + BT_ASSERT(ret >= 0); di_trace->static_listener_id = ret; } @@ -839,47 +752,45 @@ struct debug_info_trace *insert_new_trace(struct debug_info_iterator *debug_it, goto end; error: - BT_PUT(writer_trace); + BT_OBJECT_PUT_REF_AND_RESET(writer_trace); g_free(di_trace); di_trace = NULL; end: - bt_put(stream); - bt_put(writer_stream); - bt_put(stream_class); - bt_put(trace); + bt_object_put_ref(stream); + bt_object_put_ref(writer_stream); + bt_object_put_ref(stream_class); + bt_object_put_ref(trace); return di_trace; } static -struct bt_ctf_packet *lookup_packet(struct debug_info_iterator *debug_it, - struct bt_ctf_packet *packet, +const struct bt_packet *lookup_packet(struct debug_info_iterator *debug_it, + const struct bt_packet *packet, struct debug_info_trace *di_trace) { - return (struct bt_ctf_packet *) g_hash_table_lookup( + return (const struct bt_packet *) g_hash_table_lookup( di_trace->packet_map, (gpointer) packet); } static -struct bt_ctf_packet *insert_new_packet(struct debug_info_iterator *debug_it, - struct bt_ctf_packet *packet, - struct bt_ctf_stream *writer_stream, +const struct bt_packet *insert_new_packet(struct debug_info_iterator *debug_it, + const struct bt_packet *packet, + const struct bt_stream *writer_stream, struct debug_info_trace *di_trace) { - struct bt_ctf_packet *writer_packet; + const struct bt_packet *writer_packet; int ret; - writer_packet = bt_ctf_packet_create(writer_stream); + writer_packet = bt_packet_create(writer_stream); if (!writer_packet) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to create new packet."); goto error; } ret = ctf_packet_copy_header(debug_it->err, packet, writer_packet); if (ret) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy packet header."); goto error; } @@ -888,94 +799,86 @@ struct bt_ctf_packet *insert_new_packet(struct debug_info_iterator *debug_it, goto end; error: - BT_PUT(writer_packet); + BT_OBJECT_PUT_REF_AND_RESET(writer_packet); end: return writer_packet; } static int add_debug_info_fields(FILE *err, - struct bt_ctf_field_type *writer_event_context_type, + const struct bt_field_class *writer_event_context_class, struct debug_info_component *component) { - struct bt_ctf_field_type *ip_field = NULL, *debug_field_type = NULL, - *bin_field_type = NULL, *func_field_type = NULL, - *src_field_type = NULL; + const struct bt_field_class *ip_field = NULL, *debug_field_class = NULL, + *bin_field_class = NULL, *func_field_class = NULL, + *src_field_class = NULL; int ret = 0; - ip_field = bt_ctf_field_type_structure_get_field_type_by_name( - writer_event_context_type, "_ip"); + ip_field = bt_field_class_structure_get_field_class_by_name( + writer_event_context_class, IP_FIELD_NAME); /* No ip field, so no debug info. */ if (!ip_field) { goto end; } - BT_PUT(ip_field); + BT_OBJECT_PUT_REF_AND_RESET(ip_field); - debug_field_type = bt_ctf_field_type_structure_get_field_type_by_name( - writer_event_context_type, + debug_field_class = bt_field_class_structure_get_field_class_by_name( + writer_event_context_class, component->arg_debug_info_field_name); /* Already existing debug_info field, no need to add it. */ - if (debug_field_type) { + if (debug_field_class) { goto end; } - debug_field_type = bt_ctf_field_type_structure_create(); - if (!debug_field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + debug_field_class = bt_field_class_structure_create(); + if (!debug_field_class) { + BT_LOGE_STR("Failed to create debug_info structure."); goto error; } - bin_field_type = bt_ctf_field_type_string_create(); - if (!bin_field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + bin_field_class = bt_field_class_string_create(); + if (!bin_field_class) { + BT_LOGE_STR("Failed to create string for field=bin."); goto error; } - func_field_type = bt_ctf_field_type_string_create(); - if (!func_field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + func_field_class = bt_field_class_string_create(); + if (!func_field_class) { + BT_LOGE_STR("Failed to create string for field=func."); goto error; } - src_field_type = bt_ctf_field_type_string_create(); - if (!src_field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + src_field_class = bt_field_class_string_create(); + if (!src_field_class) { + BT_LOGE_STR("Failed to create string for field=src."); goto error; } - ret = bt_ctf_field_type_structure_add_field(debug_field_type, - bin_field_type, "bin"); + ret = bt_field_class_structure_add_field(debug_field_class, + bin_field_class, "bin"); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add a field to debug_info struct: field=bin."); goto error; } - ret = bt_ctf_field_type_structure_add_field(debug_field_type, - func_field_type, "func"); + ret = bt_field_class_structure_add_field(debug_field_class, + func_field_class, "func"); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add a field to debug_info struct: field=func."); goto error; } - ret = bt_ctf_field_type_structure_add_field(debug_field_type, - src_field_type, "src"); + ret = bt_field_class_structure_add_field(debug_field_class, + src_field_class, "src"); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add a field to debug_info struct: field=src."); goto error; } - ret = bt_ctf_field_type_structure_add_field(writer_event_context_type, - debug_field_type, component->arg_debug_info_field_name); + ret = bt_field_class_structure_add_field(writer_event_context_class, + debug_field_class, component->arg_debug_info_field_name); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add debug_info field to event_context."); goto error; } @@ -983,47 +886,47 @@ int add_debug_info_fields(FILE *err, goto end; error: - BT_PUT(debug_field_type); + BT_OBJECT_PUT_REF_AND_RESET(debug_field_class); ret = -1; end: - bt_put(src_field_type); - bt_put(func_field_type); - bt_put(bin_field_type); - bt_put(debug_field_type); + bt_object_put_ref(src_field_class); + bt_object_put_ref(func_field_class); + bt_object_put_ref(bin_field_class); + bt_object_put_ref(debug_field_class); return ret; } static -int create_debug_info_event_context_type(FILE *err, - struct bt_ctf_field_type *event_context_type, - struct bt_ctf_field_type *writer_event_context_type, +int create_debug_info_event_context_class(FILE *err, + const struct bt_field_class *event_context_class, + const struct bt_field_class *writer_event_context_class, struct debug_info_component *component) { int ret, nr_fields, i; - nr_fields = bt_ctf_field_type_structure_get_field_count(event_context_type); + nr_fields = bt_field_class_structure_get_field_count(event_context_class); for (i = 0; i < nr_fields; i++) { - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field_class *field_class = NULL; const char *field_name; - if (bt_ctf_field_type_structure_get_field(event_context_type, - &field_name, &field_type, i) < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_structure_get_field_by_index(event_context_class, + &field_name, &field_class, i) < 0) { + BT_LOGE("Failed to get a field from the event-context: field-name=\"%s\"", + field_name); goto error; } - ret = bt_ctf_field_type_structure_add_field(writer_event_context_type, - field_type, field_name); - BT_PUT(field_type); + ret = bt_field_class_structure_add_field(writer_event_context_class, + field_class, field_name); + BT_OBJECT_PUT_REF_AND_RESET(field_class); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE("Failed to add a field to the event-context: field-name=\"%s\"", + field_name); goto error; } } - ret = add_debug_info_fields(err, writer_event_context_type, + ret = add_debug_info_fields(err, writer_event_context_class, component); goto end; @@ -1034,82 +937,76 @@ end: } static -struct bt_ctf_stream_class *copy_stream_class_debug_info(FILE *err, - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_trace *writer_trace, +const struct bt_stream_class *copy_stream_class_debug_info(FILE *err, + const struct bt_stream_class *stream_class, + const struct bt_trace *writer_trace, struct debug_info_component *component) { - struct bt_ctf_field_type *type = NULL; - struct bt_ctf_stream_class *writer_stream_class = NULL; - struct bt_ctf_field_type *writer_event_context_type = NULL; + const struct bt_field_class *cls = NULL; + const struct bt_stream_class *writer_stream_class = NULL; + const struct bt_field_class *writer_event_context_class = NULL; int ret_int; - const char *name = bt_ctf_stream_class_get_name(stream_class); + const char *name = bt_stream_class_get_name(stream_class); - writer_stream_class = bt_ctf_stream_class_create_empty(name); + writer_stream_class = bt_stream_class_create_empty(name); if (!writer_stream_class) { - fprintf(err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to create empty stream class."); goto error; } - type = bt_ctf_stream_class_get_packet_context_type(stream_class); + type = bt_stream_class_get_packet_context_class(stream_class); if (type) { - ret_int = bt_ctf_stream_class_set_packet_context_type( + ret_int = bt_stream_class_set_packet_context_class( writer_stream_class, type); if (ret_int < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to set packet_context type."); goto error; } - BT_PUT(type); + BT_OBJECT_PUT_REF_AND_RESET(type); } - type = bt_ctf_stream_class_get_event_header_type(stream_class); + type = bt_stream_class_get_event_header_type(stream_class); if (type) { - ret_int = bt_ctf_stream_class_set_event_header_type( + ret_int = bt_stream_class_set_event_header_type( writer_stream_class, type); if (ret_int < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to set event_header type."); goto error; } - BT_PUT(type); + BT_OBJECT_PUT_REF_AND_RESET(type); } - type = bt_ctf_stream_class_get_event_context_type(stream_class); + type = bt_stream_class_get_event_context_class(stream_class); if (type) { - writer_event_context_type = bt_ctf_field_type_structure_create(); - if (!writer_event_context_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + writer_event_context_class = bt_field_class_structure_create(); + if (!writer_event_context_class) { + BT_LOGE_STR("Failed to create writer_event_context struct type."); goto error; } - ret_int = create_debug_info_event_context_type(err, type, - writer_event_context_type, component); + ret_int = create_debug_info_event_context_class(err, type, + writer_event_context_class, component); if (ret_int) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to create debug_info event_context type."); goto error; } - BT_PUT(type); + BT_OBJECT_PUT_REF_AND_RESET(type); - ret_int = bt_ctf_stream_class_set_event_context_type( - writer_stream_class, writer_event_context_type); + ret_int = bt_stream_class_set_event_context_class( + writer_stream_class, writer_event_context_class); if (ret_int < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to set event_context type."); goto error; } - BT_PUT(writer_event_context_type); + BT_OBJECT_PUT_REF_AND_RESET(writer_event_context_class); } goto end; error: - BT_PUT(writer_stream_class); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream_class); end: - bt_put(writer_event_context_type); - bt_put(type); + bt_object_put_ref(writer_event_context_class); + bt_object_put_ref(type); return writer_stream_class; } @@ -1119,38 +1016,33 @@ end: * to update the integers mapping to a clock. */ static -int add_clock_classes(FILE *err, struct bt_ctf_trace *writer_trace, - struct bt_ctf_stream_class *writer_stream_class, - struct bt_ctf_trace *trace) +int add_clock_classes(FILE *err, const struct bt_trace *writer_trace, + const struct bt_stream_class *writer_stream_class, + const struct bt_trace *trace) { int ret, clock_class_count, i; - clock_class_count = bt_ctf_trace_get_clock_class_count(trace); + clock_class_count = bt_trace_get_clock_class_count(trace); for (i = 0; i < clock_class_count; i++) { - struct bt_ctf_clock_class *clock_class = - bt_ctf_trace_get_clock_class_by_index(trace, i); - struct bt_ctf_clock_class *existing_clock_class = NULL; + const struct bt_clock_class *clock_class = + bt_trace_get_clock_class_by_index(trace, i); + const struct bt_clock_class *existing_clock_class = NULL; - if (!clock_class) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto error; - } + BT_ASSERT(clock_class); - existing_clock_class = bt_ctf_trace_get_clock_class_by_name( - writer_trace, bt_ctf_clock_class_get_name(clock_class)); - bt_put(existing_clock_class); + existing_clock_class = bt_trace_get_clock_class_by_name( + writer_trace, bt_clock_class_get_name(clock_class)); + bt_object_put_ref(existing_clock_class); if (existing_clock_class) { - bt_put(clock_class); + bt_object_put_ref(clock_class); continue; } - ret = bt_ctf_trace_add_clock_class(writer_trace, clock_class); - BT_PUT(clock_class); + ret = bt_trace_add_clock_class(writer_trace, clock_class); + BT_OBJECT_PUT_REF_AND_RESET(clock_class); if (ret != 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add clock_class."); goto error; } } @@ -1166,57 +1058,45 @@ end: } static -struct bt_ctf_stream_class *insert_new_stream_class( +const struct bt_stream_class *insert_new_stream_class( struct debug_info_iterator *debug_it, - struct bt_ctf_stream_class *stream_class) + const struct bt_stream_class *stream_class) { - struct bt_ctf_stream_class *writer_stream_class = NULL; - struct bt_ctf_trace *trace, *writer_trace = NULL; + const struct bt_stream_class *writer_stream_class = NULL; + const struct bt_trace *trace, *writer_trace = NULL; struct debug_info_trace *di_trace; enum bt_component_status ret; int int_ret; - trace = bt_ctf_stream_class_get_trace(stream_class); - if (!trace) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto error; - } + trace = bt_stream_class_get_trace(stream_class); + BT_ASSERT(trace); di_trace = lookup_trace(debug_it, trace); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing trace."); ret = BT_COMPONENT_STATUS_ERROR; goto error; } writer_trace = di_trace->writer_trace; - bt_get(writer_trace); + bt_object_get_ref(writer_trace); writer_stream_class = copy_stream_class_debug_info(debug_it->err, stream_class, writer_trace, debug_it->debug_info_component); if (!writer_stream_class) { - fprintf(debug_it->err, "[error] Failed to copy stream class\n"); - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy stream class."); goto error; } - int_ret = bt_ctf_trace_add_stream_class(writer_trace, writer_stream_class); + int_ret = bt_trace_add_stream_class(writer_trace, writer_stream_class); if (int_ret) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add stream class."); goto error; } ret = add_clock_classes(debug_it->err, writer_trace, writer_stream_class, trace); if (ret != BT_COMPONENT_STATUS_OK) { - fprintf(debug_it->err, - "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to add clock classes."); goto error; } @@ -1226,29 +1106,26 @@ struct bt_ctf_stream_class *insert_new_stream_class( goto end; error: - BT_PUT(writer_stream_class); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream_class); end: - bt_put(trace); - bt_put(writer_trace); + bt_object_put_ref(trace); + bt_object_put_ref(writer_trace); return writer_stream_class; } static -struct bt_ctf_stream *insert_new_stream( +const struct bt_stream *insert_new_stream( struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream, + const struct bt_stream *stream, struct debug_info_trace *di_trace) { - struct bt_ctf_stream *writer_stream = NULL; - struct bt_ctf_stream_class *stream_class = NULL; - struct bt_ctf_stream_class *writer_stream_class = NULL; - - stream_class = bt_ctf_stream_get_class(stream); - if (!stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto error; - } + const struct bt_stream *writer_stream = NULL; + const struct bt_stream_class *stream_class = NULL; + const struct bt_stream_class *writer_stream_class = NULL; + int64_t id; + + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); writer_stream_class = g_hash_table_lookup( di_trace->stream_class_map, @@ -1258,18 +1135,24 @@ struct bt_ctf_stream *insert_new_stream( writer_stream_class = insert_new_stream_class(debug_it, stream_class); if (!writer_stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to insert new stream class."); goto error; } } - bt_get(writer_stream_class); + bt_object_get_ref(writer_stream_class); + + id = bt_stream_get_id(stream); + if (id < 0) { + writer_stream = bt_stream_create(writer_stream_class, + bt_stream_get_name(stream)); + } else { + writer_stream = bt_stream_create_with_id( + writer_stream_class, + bt_stream_get_name(stream), id); + } - writer_stream = bt_ctf_stream_create(writer_stream_class, - bt_ctf_stream_get_name(stream)); if (!writer_stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to create writer_stream."); goto error; } @@ -1279,132 +1162,111 @@ struct bt_ctf_stream *insert_new_stream( goto end; error: - BT_PUT(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); end: - bt_put(stream_class); - bt_put(writer_stream_class); + bt_object_put_ref(stream_class); + bt_object_put_ref(writer_stream_class); return writer_stream; } static -struct bt_ctf_stream *lookup_stream(struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream, +const struct bt_stream *lookup_stream(struct debug_info_iterator *debug_it, + const struct bt_stream *stream, struct debug_info_trace *di_trace) { - return (struct bt_ctf_stream *) g_hash_table_lookup( + return (const struct bt_stream *) g_hash_table_lookup( di_trace->stream_map, (gpointer) stream); } static -struct bt_ctf_event_class *get_event_class(struct debug_info_iterator *debug_it, - struct bt_ctf_stream_class *writer_stream_class, - struct bt_ctf_event_class *event_class) +const struct bt_event_class *get_event_class(struct debug_info_iterator *debug_it, + const struct bt_stream_class *writer_stream_class, + const struct bt_event_class *event_class) { - return bt_ctf_stream_class_get_event_class_by_id(writer_stream_class, - bt_ctf_event_class_get_id(event_class)); + return bt_stream_class_get_event_class_by_id(writer_stream_class, + bt_event_class_get_id(event_class)); } static struct debug_info_trace *lookup_di_trace_from_stream( struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream) + const struct bt_stream *stream) { - struct bt_ctf_stream_class *stream_class = NULL; - struct bt_ctf_trace *trace = NULL; + const struct bt_stream_class *stream_class = NULL; + const struct bt_trace *trace = NULL; struct debug_info_trace *di_trace = NULL; - stream_class = bt_ctf_stream_get_class(stream); - if (!stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto end; - } + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); - trace = bt_ctf_stream_class_get_trace(stream_class); - if (!trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto end; - } + trace = bt_stream_class_get_trace(stream_class); + BT_ASSERT(trace); di_trace = (struct debug_info_trace *) g_hash_table_lookup( debug_it->trace_map, (gpointer) trace); -end: - BT_PUT(stream_class); - BT_PUT(trace); + BT_OBJECT_PUT_REF_AND_RESET(stream_class); + BT_OBJECT_PUT_REF_AND_RESET(trace); return di_trace; } static -struct bt_ctf_stream *get_writer_stream( +const struct bt_stream *get_writer_stream( struct debug_info_iterator *debug_it, - struct bt_ctf_packet *packet, struct bt_ctf_stream *stream) + const struct bt_packet *packet, const struct bt_stream *stream) { - struct bt_ctf_stream_class *stream_class = NULL; - struct bt_ctf_stream *writer_stream = NULL; + const struct bt_stream_class *stream_class = NULL; + const struct bt_stream *writer_stream = NULL; struct debug_info_trace *di_trace = NULL; - stream_class = bt_ctf_stream_get_class(stream); - if (!stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto error; - } + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); di_trace = lookup_di_trace_from_stream(debug_it, stream); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing trace from stream."); goto error; } writer_stream = lookup_stream(debug_it, stream, di_trace); if (!writer_stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing stream."); goto error; } - bt_get(writer_stream); + bt_object_get_ref(writer_stream); goto end; error: - BT_PUT(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); end: - bt_put(stream_class); + bt_object_put_ref(stream_class); return writer_stream; } BT_HIDDEN -struct bt_ctf_packet *debug_info_new_packet( +const struct bt_packet *debug_info_new_packet( struct debug_info_iterator *debug_it, - struct bt_ctf_packet *packet) + const struct bt_packet *packet) { - struct bt_ctf_stream *stream = NULL, *writer_stream = NULL; - struct bt_ctf_packet *writer_packet = NULL; - struct bt_ctf_field *packet_context = NULL; + const struct bt_stream *stream = NULL, *writer_stream = NULL; + const struct bt_packet *writer_packet = NULL; + const struct bt_field *packet_context = NULL; struct debug_info_trace *di_trace; int int_ret; - stream = bt_ctf_packet_get_stream(packet); - if (!stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); - goto error; - } + stream = bt_packet_get_stream(packet); + BT_ASSERT(stream); writer_stream = get_writer_stream(debug_it, packet, stream); if (!writer_stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to get writer stream."); goto error; } di_trace = lookup_di_trace_from_stream(debug_it, stream); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing trace from stream."); goto error; } @@ -1415,84 +1277,76 @@ struct bt_ctf_packet *debug_info_new_packet( writer_packet = lookup_packet(debug_it, packet, di_trace); if (writer_packet) { g_hash_table_remove(di_trace->packet_map, packet); - BT_PUT(writer_packet); + BT_OBJECT_PUT_REF_AND_RESET(writer_packet); } writer_packet = insert_new_packet(debug_it, packet, writer_stream, di_trace); if (!writer_packet) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to insert new packet."); goto error; } - packet_context = bt_ctf_packet_get_context(packet); + packet_context = bt_packet_get_context(packet); if (packet_context) { int_ret = ctf_packet_copy_context(debug_it->err, packet, writer_stream, writer_packet); if (int_ret < 0) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy packet context."); goto error; } - BT_PUT(packet_context); + BT_OBJECT_PUT_REF_AND_RESET(packet_context); } - bt_get(writer_packet); + bt_object_get_ref(writer_packet); goto end; error: end: - bt_put(packet_context); - bt_put(writer_stream); - bt_put(stream); + bt_object_put_ref(packet_context); + bt_object_put_ref(writer_stream); + bt_object_put_ref(stream); return writer_packet; } BT_HIDDEN -struct bt_ctf_packet *debug_info_close_packet( +const struct bt_packet *debug_info_close_packet( struct debug_info_iterator *debug_it, - struct bt_ctf_packet *packet) + const struct bt_packet *packet) { - struct bt_ctf_packet *writer_packet = NULL; - struct bt_ctf_stream *stream = NULL; + const struct bt_packet *writer_packet = NULL; + const struct bt_stream *stream = NULL; struct debug_info_trace *di_trace; - stream = bt_ctf_packet_get_stream(packet); - if (!stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto end; - } + stream = bt_packet_get_stream(packet); + BT_ASSERT(stream); di_trace = lookup_di_trace_from_stream(debug_it, stream); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to find trace from stream."); goto end; } writer_packet = lookup_packet(debug_it, packet, di_trace); if (!writer_packet) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing packet."); goto end; } - bt_get(writer_packet); + bt_object_get_ref(writer_packet); g_hash_table_remove(di_trace->packet_map, packet); end: - bt_put(stream); + bt_object_put_ref(stream); return writer_packet; } BT_HIDDEN -struct bt_ctf_stream *debug_info_stream_begin( +const struct bt_stream *debug_info_stream_begin( struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream) + const struct bt_stream *stream) { - struct bt_ctf_stream *writer_stream = NULL; + const struct bt_stream *writer_stream = NULL; enum debug_info_stream_state *state; struct debug_info_trace *di_trace = NULL; @@ -1500,8 +1354,7 @@ struct bt_ctf_stream *debug_info_stream_begin( if (!di_trace) { di_trace = insert_new_trace(debug_it, stream); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to insert new trace."); goto error; } } @@ -1510,21 +1363,18 @@ struct bt_ctf_stream *debug_info_stream_begin( state = g_hash_table_lookup(di_trace->stream_states, stream); if (!state) { if (di_trace->trace_static) { - fprintf(debug_it->err, "[error] Adding a new stream " - "on a static trace\n"); + BT_LOGE_STR("Failed to add a new stream, trace is static."); goto error; } state = insert_new_stream_state(debug_it, di_trace, stream); if (!state) { - fprintf(debug_it->err, "[error] Adding a new stream " - "on a static trace\n"); + BT_LOGE_STR("Failed to add new stream state."); goto error; } } if (*state != DEBUG_INFO_UNKNOWN_STREAM) { - fprintf(debug_it->err, "[error] Unexpected stream state %d\n", - *state); + BT_LOGE("Unexpected stream state: state=%d", *state); goto error; } *state = DEBUG_INFO_ACTIVE_STREAM; @@ -1533,47 +1383,44 @@ struct bt_ctf_stream *debug_info_stream_begin( if (!writer_stream) { writer_stream = insert_new_stream(debug_it, stream, di_trace); } - bt_get(writer_stream); + bt_object_get_ref(writer_stream); goto end; error: - BT_PUT(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); end: return writer_stream; } BT_HIDDEN -struct bt_ctf_stream *debug_info_stream_end(struct debug_info_iterator *debug_it, - struct bt_ctf_stream *stream) +const struct bt_stream *debug_info_stream_end(struct debug_info_iterator *debug_it, + const struct bt_stream *stream) { - struct bt_ctf_stream *writer_stream = NULL; + const struct bt_stream *writer_stream = NULL; struct debug_info_trace *di_trace = NULL; enum debug_info_stream_state *state; di_trace = lookup_di_trace_from_stream(debug_it, stream); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing trace from stream."); goto error; } writer_stream = lookup_stream(debug_it, stream, di_trace); if (!writer_stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing stream."); goto error; } /* * Take the ref on the stream and keep it until the notification * is created. */ - bt_get(writer_stream); + bt_object_get_ref(writer_stream); state = g_hash_table_lookup(di_trace->stream_states, stream); if (*state != DEBUG_INFO_ACTIVE_STREAM) { - fprintf(debug_it->err, "[error] Unexpected stream " - "state %d\n", *state); + BT_LOGE("Unexpected stream state: state=%d", *state); goto error; } *state = DEBUG_INFO_COMPLETED_STREAM; @@ -1595,7 +1442,7 @@ struct bt_ctf_stream *debug_info_stream_end(struct debug_info_iterator *debug_it goto end; error: - BT_PUT(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); end: return writer_stream; @@ -1603,7 +1450,7 @@ end: static struct debug_info_source *lookup_debug_info(FILE *err, - struct bt_ctf_event *event, + const struct bt_event *event, struct debug_info *debug_info) { int64_t vpid; @@ -1612,13 +1459,13 @@ struct debug_info_source *lookup_debug_info(FILE *err, int ret; ret = get_stream_event_context_int_field_value(err, event, - "_vpid", &vpid); + VPID_FIELD_NAME, &vpid); if (ret) { goto end; } ret = get_stream_event_context_unsigned_int_field_value(err, event, - "_ip", &ip); + IP_FIELD_NAME, &ip); if (ret) { goto end; } @@ -1631,35 +1478,31 @@ end: } static -int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field, +int set_debug_info_field(FILE *err, const struct bt_field *debug_field, struct debug_info_source *dbg_info_src, struct debug_info_component *component) { int i, nr_fields, ret = 0; - struct bt_ctf_field_type *debug_field_type = NULL; - struct bt_ctf_field *field = NULL; - struct bt_ctf_field_type *field_type = NULL; - - debug_field_type = bt_ctf_field_get_type(debug_field); - if (!debug_field_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + const struct bt_field_class *debug_field_class = NULL; + const struct bt_field *field = NULL; + const struct bt_field_class *field_class = NULL; + + debug_field_class = bt_field_get_class(debug_field); + BT_ASSERT(debug_field_class); - nr_fields = bt_ctf_field_type_structure_get_field_count(debug_field_type); + nr_fields = bt_field_class_structure_get_field_count(debug_field_class); for (i = 0; i < nr_fields; i++) { const char *field_name; - if (bt_ctf_field_type_structure_get_field(debug_field_type, - &field_name, &field_type, i) < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_structure_get_field_by_index(debug_field_class, + &field_name, &field_class, i) < 0) { + BT_LOGE("Failed to get field from debug_info struct: field-name=\"%s\"", + field_name); goto error; } - BT_PUT(field_type); + BT_OBJECT_PUT_REF_AND_RESET(field_class); - field = bt_ctf_field_structure_get_field_by_index(debug_field, i); + field = bt_field_structure_get_field_by_index(debug_field, i); if (!strcmp(field_name, "bin")) { if (dbg_info_src && dbg_info_src->bin_path) { GString *tmp = g_string_new(NULL); @@ -1673,17 +1516,17 @@ int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field, dbg_info_src->short_bin_path, dbg_info_src->bin_loc); } - ret = bt_ctf_field_string_set_value(field, tmp->str); + ret = bt_field_string_set_value(field, tmp->str); g_string_free(tmp, true); } else { - ret = bt_ctf_field_string_set_value(field, ""); + ret = bt_field_string_set_value(field, ""); } } else if (!strcmp(field_name, "func")) { if (dbg_info_src && dbg_info_src->func) { - ret = bt_ctf_field_string_set_value(field, + ret = bt_field_string_set_value(field, dbg_info_src->func); } else { - ret = bt_ctf_field_string_set_value(field, ""); + ret = bt_field_string_set_value(field, ""); } } else if (!strcmp(field_name, "src")) { if (dbg_info_src && dbg_info_src->src_path) { @@ -1698,16 +1541,16 @@ int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field, dbg_info_src->short_src_path, dbg_info_src->line_no); } - ret = bt_ctf_field_string_set_value(field, tmp->str); + ret = bt_field_string_set_value(field, tmp->str); g_string_free(tmp, true); } else { - ret = bt_ctf_field_string_set_value(field, ""); + ret = bt_field_string_set_value(field, ""); } } - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to set value in debug-info struct: field-name=\"%s\"", + field_name); goto error; } } @@ -1717,75 +1560,64 @@ int set_debug_info_field(FILE *err, struct bt_ctf_field *debug_field, error: ret = -1; end: - bt_put(field_type); - bt_put(field); - bt_put(debug_field_type); + bt_object_put_ref(field_class); + bt_object_put_ref(field); + bt_object_put_ref(debug_field_class); return ret; } static int copy_set_debug_info_stream_event_context(FILE *err, - struct bt_ctf_field *event_context, - struct bt_ctf_event *event, - struct bt_ctf_event *writer_event, + const struct bt_field *event_context, + const struct bt_event *event, + const struct bt_event *writer_event, struct debug_info *debug_info, struct debug_info_component *component) { - struct bt_ctf_field_type *writer_event_context_type = NULL, - *event_context_type = NULL; - struct bt_ctf_field *writer_event_context = NULL; - struct bt_ctf_field *field = NULL, *copy_field = NULL, *debug_field = NULL; - struct bt_ctf_field_type *field_type = NULL; + const struct bt_field_class *writer_event_context_class = NULL, + *event_context_class = NULL; + const struct bt_field *writer_event_context = NULL; + const struct bt_field *field = NULL, *copy_field = NULL, *debug_field = NULL; + const struct bt_field_class *field_class = NULL; struct debug_info_source *dbg_info_src; int ret, nr_fields, i; - writer_event_context = bt_ctf_event_get_stream_event_context(writer_event); - if (!writer_event_context) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); - goto error; - } + writer_event_context = bt_event_get_stream_event_context(writer_event); + BT_ASSERT(writer_event_context); - writer_event_context_type = bt_ctf_field_get_type(writer_event_context); - if (!writer_event_context_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + writer_event_context_class = bt_field_get_class(writer_event_context); + BT_ASSERT(writer_event_context_class); - event_context_type = bt_ctf_field_get_type(event_context); - if (!event_context_type) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + event_context_class = bt_field_get_class(event_context); + BT_ASSERT(event_context_class); /* * If it is not a structure, we did not modify it to add the debug info * fields, so just assign it as is. */ - if (bt_ctf_field_type_get_type_id(writer_event_context_type) != BT_CTF_FIELD_TYPE_ID_STRUCT) { - ret = bt_ctf_event_set_event_context(writer_event, event_context); + if (bt_field_class_id(writer_event_context_class) != BT_FIELD_CLASS_TYPE_STRUCT) { + ret = bt_event_set_event_context(writer_event, event_context); goto end; } dbg_info_src = lookup_debug_info(err, event, debug_info); - nr_fields = bt_ctf_field_type_structure_get_field_count(writer_event_context_type); + nr_fields = bt_field_class_structure_get_field_count(writer_event_context_class); for (i = 0; i < nr_fields; i++) { const char *field_name; - if (bt_ctf_field_type_structure_get_field(writer_event_context_type, - &field_name, &field_type, i) < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + if (bt_field_class_structure_get_field_by_index(writer_event_context_class, + &field_name, &field_class, i) < 0) { + BT_LOGE("Failed to get field from event-context: field-name=\"%s\"", + field_name); goto error; } /* * Prevent illegal access in the event_context. */ - if (i < bt_ctf_field_type_structure_get_field_count(event_context_type)) { - field = bt_ctf_field_structure_get_field_by_index(event_context, i); + if (i < bt_field_class_structure_get_field_count(event_context_class)) { + field = bt_field_structure_get_field_by_index(event_context, i); } /* * The debug_info field, only exists in the writer event or @@ -1793,41 +1625,37 @@ int copy_set_debug_info_stream_event_context(FILE *err, */ if (!strcmp(field_name, component->arg_debug_info_field_name) && !field) { - debug_field = bt_ctf_field_structure_get_field_by_index( + debug_field = bt_field_structure_get_field_by_index( writer_event_context, i); - if (!debug_field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + BT_ASSERT(debug_field); + ret = set_debug_info_field(err, debug_field, dbg_info_src, component); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set debug_info field."); goto error; } - BT_PUT(debug_field); + BT_OBJECT_PUT_REF_AND_RESET(debug_field); } else { - copy_field = bt_ctf_field_copy(field); + copy_field = bt_field_copy(field); if (!copy_field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to copy field: field-name=\"%s\"", + field_name); goto error; } - ret = bt_ctf_field_structure_set_field_by_name( + ret = bt_field_structure_set_field_by_name( writer_event_context, field_name, copy_field); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE("Failed to set field: field-name=\"%s\"", + field_name); goto error; } - BT_PUT(copy_field); + BT_OBJECT_PUT_REF_AND_RESET(copy_field); } - BT_PUT(field_type); - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field_class); + BT_OBJECT_PUT_REF_AND_RESET(field); } ret = 0; @@ -1836,82 +1664,68 @@ int copy_set_debug_info_stream_event_context(FILE *err, error: ret = -1; end: - bt_put(event_context_type); - bt_put(writer_event_context_type); - bt_put(writer_event_context); - bt_put(field); - bt_put(copy_field); - bt_put(debug_field); - bt_put(field_type); + bt_object_put_ref(event_context_class); + bt_object_put_ref(writer_event_context_class); + bt_object_put_ref(writer_event_context); + bt_object_put_ref(field); + bt_object_put_ref(copy_field); + bt_object_put_ref(debug_field); + bt_object_put_ref(field_class); return ret; } static -struct bt_ctf_clock_class *stream_class_get_clock_class(FILE *err, - struct bt_ctf_stream_class *stream_class) +const struct bt_clock_class *stream_class_get_clock_class(FILE *err, + const struct bt_stream_class *stream_class) { - struct bt_ctf_trace *trace = NULL; - struct bt_ctf_clock_class *clock_class = NULL; + const struct bt_trace *trace = NULL; + const struct bt_clock_class *clock_class = NULL; - trace = bt_ctf_stream_class_get_trace(stream_class); - if (!trace) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto end; - } + trace = bt_stream_class_get_trace(stream_class); + BT_ASSERT(trace); - if (!bt_ctf_trace_get_clock_class_count(trace)) { + if (!bt_trace_get_clock_class_count(trace)) { /* No clock. */ goto end; } /* FIXME multi-clock? */ - clock_class = bt_ctf_trace_get_clock_class_by_index(trace, 0); + clock_class = bt_trace_get_clock_class_by_index(trace, 0); - bt_put(trace); + bt_object_put_ref(trace); end: return clock_class; } static -struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event *event) +const struct bt_clock_class *event_get_clock_class(FILE *err, const struct bt_event *event) { - struct bt_ctf_event_class *event_class = NULL; - struct bt_ctf_stream_class *stream_class = NULL; - struct bt_ctf_clock_class *clock_class = NULL; - - event_class = bt_ctf_event_get_class(event); - if (!event_class) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto error; - } + const struct bt_event_class *event_class = NULL; + const struct bt_stream_class *stream_class = NULL; + const struct bt_clock_class *clock_class = NULL; - stream_class = bt_ctf_event_class_get_stream_class(event_class); - if (!stream_class) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto error; - } + event_class = bt_event_get_class(event); + BT_ASSERT(event_class); + + stream_class = bt_event_class_get_stream_class(event_class); + BT_ASSERT(stream_class); clock_class = stream_class_get_clock_class(err, stream_class); goto end; -error: - BT_PUT(clock_class); end: - bt_put(stream_class); - bt_put(event_class); + bt_object_put_ref(stream_class); + bt_object_put_ref(event_class); return clock_class; } static -int set_event_clock_value(FILE *err, struct bt_ctf_event *event, - struct bt_ctf_event *writer_event) +int set_event_clock_value(FILE *err, const struct bt_event *event, + const struct bt_event *writer_event) { - struct bt_ctf_clock_class *clock_class = NULL; - struct bt_ctf_clock_value *clock_value = NULL; + const struct bt_clock_class *clock_class = NULL; + struct bt_clock_value *clock_value = NULL; int ret = 0; clock_class = event_get_clock_class(err, event); @@ -1920,21 +1734,19 @@ int set_event_clock_value(FILE *err, struct bt_ctf_event *event, goto end; } - clock_value = bt_ctf_event_get_clock_value(event, clock_class); + clock_value = bt_event_get_clock_value(event, clock_class); if (!clock_value) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); - goto error; + ret = 0; + goto end; } /* * We share the same clocks, so we can assign the clock value to the * writer event. */ - ret = bt_ctf_event_set_clock_value(writer_event, clock_value); + ret = bt_event_set_clock_value(writer_event, clock_value); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to set clock value."); goto error; } @@ -1944,155 +1756,126 @@ int set_event_clock_value(FILE *err, struct bt_ctf_event *event, error: ret = -1; end: - bt_put(clock_class); - bt_put(clock_value); + bt_object_put_ref(clock_class); + bt_object_put_ref(clock_value); return ret; } static -struct bt_ctf_event *debug_info_copy_event(FILE *err, struct bt_ctf_event *event, - struct bt_ctf_event_class *writer_event_class, +const struct bt_event *debug_info_copy_event(FILE *err, const struct bt_event *event, + const struct bt_event_class *writer_event_class, struct debug_info *debug_info, struct debug_info_component *component) { - struct bt_ctf_event *writer_event = NULL; - struct bt_ctf_field *field = NULL, *copy_field = NULL; + const struct bt_event *writer_event = NULL; + const struct bt_field *field = NULL, *copy_field = NULL; int ret; - writer_event = bt_ctf_event_create(writer_event_class); + writer_event = bt_event_create(writer_event_class); if (!writer_event) { - fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, - __LINE__); + BT_LOGE_STR("Failed to create new event."); goto error; } ret = set_event_clock_value(err, event, writer_event); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set clock value."); goto error; } /* Optional field, so it can fail silently. */ - field = bt_ctf_event_get_header(event); + field = bt_event_get_header(event); if (field) { ret = ctf_copy_event_header(err, event, writer_event_class, writer_event, field); if (ret) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy event header."); goto error; } - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field); } /* Optional field, so it can fail silently. */ - field = bt_ctf_event_get_stream_event_context(event); + field = bt_event_get_stream_event_context(event); if (field) { ret = copy_set_debug_info_stream_event_context(err, field, event, writer_event, debug_info, component); if (ret < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to debug_info stream event context."); goto error; } - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field); } /* Optional field, so it can fail silently. */ - field = bt_ctf_event_get_event_context(event); + field = bt_event_get_event_context(event); if (field) { - copy_field = bt_ctf_field_copy(field); + copy_field = bt_field_copy(field); if (!copy_field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy field."); goto error; } - ret = bt_ctf_event_set_event_context(writer_event, copy_field); + ret = bt_event_set_event_context(writer_event, copy_field); if (ret < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set event_context."); goto error; } - BT_PUT(copy_field); - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(copy_field); + BT_OBJECT_PUT_REF_AND_RESET(field); } - field = bt_ctf_event_get_event_payload(event); - if (!field) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } - copy_field = bt_ctf_field_copy(field); + field = bt_event_get_event_payload(event); + BT_ASSERT(field); + + copy_field = bt_field_copy(field); if (copy_field) { - ret = bt_ctf_event_set_event_payload(writer_event, copy_field); + ret = bt_event_set_event_payload(writer_event, copy_field); if (ret < 0) { - fprintf(err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to set event payload."); goto error; } - BT_PUT(copy_field); + BT_OBJECT_PUT_REF_AND_RESET(copy_field); } - BT_PUT(field); + BT_OBJECT_PUT_REF_AND_RESET(field); goto end; error: - BT_PUT(writer_event); + BT_OBJECT_PUT_REF_AND_RESET(writer_event); end: - bt_put(copy_field); - bt_put(field); + bt_object_put_ref(copy_field); + bt_object_put_ref(field); return writer_event; } BT_HIDDEN -struct bt_ctf_event *debug_info_output_event( +const struct bt_event *debug_info_output_event( struct debug_info_iterator *debug_it, - struct bt_ctf_event *event) + const struct bt_event *event) { - struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL; - struct bt_ctf_stream_class *stream_class = NULL, *writer_stream_class = NULL; - struct bt_ctf_event *writer_event = NULL; - struct bt_ctf_packet *packet = NULL, *writer_packet = NULL; - struct bt_ctf_trace *writer_trace = NULL; - struct bt_ctf_stream *stream = NULL; + const struct bt_event_class *event_class = NULL, *writer_event_class = NULL; + const struct bt_stream_class *stream_class = NULL, *writer_stream_class = NULL; + const struct bt_event *writer_event = NULL; + const struct bt_packet *packet = NULL, *writer_packet = NULL; + const struct bt_trace *writer_trace = NULL; + const struct bt_stream *stream = NULL; struct debug_info_trace *di_trace; struct debug_info *debug_info; - const char *event_name; int int_ret; - event_class = bt_ctf_event_get_class(event); - if (!event_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + event_class = bt_event_get_class(event); + BT_ASSERT(event_class); - event_name = bt_ctf_event_class_get_name(event_class); - if (!event_name) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + stream_class = bt_event_class_get_stream_class(event_class); + BT_ASSERT(stream_class); + + stream = bt_event_get_stream(event); + BT_ASSERT(stream); - stream_class = bt_ctf_event_class_get_stream_class(event_class); - if (!stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } - stream = bt_ctf_event_get_stream(event); - if (!stream) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } di_trace = lookup_di_trace_from_stream(debug_it, stream); if (!di_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing trace from stream."); goto error; } @@ -2100,38 +1883,29 @@ struct bt_ctf_event *debug_info_output_event( di_trace->stream_class_map, (gpointer) stream_class); if (!writer_stream_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing stream_class."); goto error; } - bt_get(writer_stream_class); - + bt_object_get_ref(writer_stream_class); + writer_trace = bt_stream_class_get_trace(writer_stream_class); + BT_ASSERT(writer_trace); writer_event_class = get_event_class(debug_it, writer_stream_class, event_class); if (!writer_event_class) { writer_event_class = ctf_copy_event_class(debug_it->err, - event_class); + writer_trace, event_class); if (!writer_event_class) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to copy event_class."); goto error; } - int_ret = bt_ctf_stream_class_add_event_class( + int_ret = bt_stream_class_add_event_class( writer_stream_class, writer_event_class); if (int_ret) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", - __func__, __FILE__, __LINE__); + BT_LOGE_STR("Failed to add event_class."); goto error; } } - writer_trace = bt_ctf_stream_class_get_trace(writer_stream_class); - if (!writer_trace) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } - debug_info = get_trace_debug_info(debug_it, writer_trace, di_trace); if (debug_info) { debug_info_handle_event(debug_it->err, event, debug_info); @@ -2141,34 +1915,25 @@ struct bt_ctf_event *debug_info_output_event( writer_event_class, debug_info, debug_it->debug_info_component); if (!writer_event) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - fprintf(debug_it->err, "[error] Failed to copy event %s\n", - bt_ctf_event_class_get_name(writer_event_class)); + BT_LOGE("Failed to copy event: event-class-name=\"%s\"", + bt_event_class_get_name(writer_event_class)); goto error; } - packet = bt_ctf_event_get_packet(event); - if (!packet) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - goto error; - } + packet = bt_event_get_packet(event); + BT_ASSERT(packet); writer_packet = lookup_packet(debug_it, packet, di_trace); if (!writer_packet) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); + BT_LOGE_STR("Failed to find existing packet."); goto error; } - bt_get(writer_packet); + bt_object_get_ref(writer_packet); - int_ret = bt_ctf_event_set_packet(writer_event, writer_packet); + int_ret = bt_event_set_packet(writer_event, writer_packet); if (int_ret < 0) { - fprintf(debug_it->err, "[error] %s in %s:%d\n", __func__, - __FILE__, __LINE__); - fprintf(debug_it->err, "[error] Failed to append event %s\n", - bt_ctf_event_class_get_name(writer_event_class)); + BT_LOGE("Failed to append event to event-class-name=\"%s\"", + bt_event_class_get_name(writer_event_class)); goto error; } @@ -2176,16 +1941,16 @@ struct bt_ctf_event *debug_info_output_event( goto end; error: - BT_PUT(writer_event); + BT_OBJECT_PUT_REF_AND_RESET(writer_event); end: - bt_put(stream); - bt_put(writer_trace); - bt_put(writer_packet); - bt_put(packet); - bt_put(writer_event_class); - bt_put(writer_stream_class); - bt_put(stream_class); - bt_put(event_class); + bt_object_put_ref(stream); + bt_object_put_ref(writer_trace); + bt_object_put_ref(writer_packet); + bt_object_put_ref(packet); + bt_object_put_ref(writer_event_class); + bt_object_put_ref(writer_stream_class); + bt_object_put_ref(stream_class); + bt_object_put_ref(event_class); return writer_event; }