X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Fctf%2Ffs-sink%2Fwrite.c;h=b386eec88c14f6bf02d968ee4a49e94569a1e4b8;hb=40f4ba76dd6f9508ca51b6220eaed57632281a07;hp=519eb2cb1654560be0785c37b54f3f66df3bc8c2;hpb=8480c8cc7e985169ab42060d3cd3c72d6c8d240d;p=babeltrace.git diff --git a/plugins/ctf/fs-sink/write.c b/plugins/ctf/fs-sink/write.c index 519eb2cb..b386eec8 100644 --- a/plugins/ctf/fs-sink/write.c +++ b/plugins/ctf/fs-sink/write.c @@ -29,16 +29,8 @@ #define BT_LOG_TAG "PLUGIN-CTF-FS-SINK-WRITE" #include "logging.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include #include #include @@ -46,15 +38,15 @@ #include "writer.h" static -void unref_stream_class(struct bt_ctf_stream_class *writer_stream_class) +void unref_stream_class(const struct bt_stream_class *writer_stream_class) { - bt_put(writer_stream_class); + bt_object_put_ref(writer_stream_class); } static -void unref_stream(struct bt_ctf_stream_class *writer_stream) +void unref_stream(const struct bt_stream_class *writer_stream) { - bt_put(writer_stream); + bt_object_put_ref(writer_stream); } static @@ -67,9 +59,9 @@ static gboolean empty_streams_ht(gpointer key, gpointer value, gpointer user_data) { int ret; - struct bt_ctf_stream *writer_stream = value; + const struct bt_stream *writer_stream = value; - ret = bt_ctf_stream_flush(writer_stream); + ret = bt_stream_flush(writer_stream); if (ret) { BT_LOGD_STR("Failed to flush stream while emptying hash table."); } @@ -94,7 +86,7 @@ void check_completed_trace(gpointer key, gpointer value, gpointer user_data) } 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 fs_writer *fs_writer = data; int trace_completed = 1; @@ -111,21 +103,21 @@ void trace_is_static_listener(struct bt_ctf_trace *trace, void *data) } static -struct bt_ctf_stream_class *insert_new_stream_class( +const struct bt_stream_class *insert_new_stream_class( struct writer_component *writer_component, struct fs_writer *fs_writer, - 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 = NULL, *writer_trace = NULL; + const struct bt_stream_class *writer_stream_class = NULL; + const struct bt_trace *trace = NULL, *writer_trace = NULL; struct bt_ctf_writer *ctf_writer = fs_writer->writer; enum bt_component_status ret; - trace = bt_ctf_stream_class_get_trace(stream_class); - assert(trace); + trace = bt_stream_class_get_trace(stream_class); + BT_ASSERT(trace); writer_trace = bt_ctf_writer_get_trace(ctf_writer); - assert(writer_trace); + BT_ASSERT(writer_trace); ret = ctf_copy_clock_classes(writer_component->err, writer_trace, writer_stream_class, trace); @@ -141,7 +133,7 @@ struct bt_ctf_stream_class *insert_new_stream_class( goto error; } - ret = bt_ctf_trace_add_stream_class(writer_trace, writer_stream_class); + ret = bt_trace_add_stream_class(writer_trace, writer_stream_class); if (ret) { BT_LOGE_STR("Failed to add stream_class."); goto error; @@ -153,17 +145,17 @@ 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(writer_trace); - bt_put(trace); + bt_object_put_ref(writer_trace); + bt_object_put_ref(trace); return writer_stream_class; } static enum fs_writer_stream_state *insert_new_stream_state( struct writer_component *writer_component, - struct fs_writer *fs_writer, struct bt_ctf_stream *stream) + struct fs_writer *fs_writer, const struct bt_stream *stream) { enum fs_writer_stream_state *v = NULL; @@ -222,7 +214,7 @@ end: static int make_trace_path(struct writer_component *writer_component, - struct bt_ctf_trace *trace, char *trace_path) + const struct bt_trace *trace, char *trace_path) { int ret; const char *trace_name; @@ -230,7 +222,7 @@ int make_trace_path(struct writer_component *writer_component, if (writer_component->single_trace) { trace_name = "\0"; } else { - trace_name = bt_ctf_trace_get_name(trace); + trace_name = bt_trace_get_name(trace); if (!trace_name) { trace_name = writer_component->trace_name_base->str; } @@ -248,7 +240,7 @@ int make_trace_path(struct writer_component *writer_component, } - snprintf(trace_path, PATH_MAX, "%s/%s", + snprintf(trace_path, PATH_MAX, "%s" G_DIR_SEPARATOR_S "%s", writer_component->base_path->str, trace_name); /* @@ -265,7 +257,7 @@ int make_trace_path(struct writer_component *writer_component, int i = 0; do { - snprintf(trace_path, PATH_MAX, "%s/%s-%d", + snprintf(trace_path, PATH_MAX, "%s" G_DIR_SEPARATOR_S "%s-%d", writer_component->base_path->str, trace_name, ++i); } while (g_file_test(trace_path, G_FILE_TEST_EXISTS) && i < INT_MAX); @@ -288,13 +280,13 @@ end: static struct fs_writer *insert_new_writer( struct writer_component *writer_component, - struct bt_ctf_trace *trace) + const struct bt_trace *trace) { struct bt_ctf_writer *ctf_writer = NULL; - struct bt_ctf_trace *writer_trace = NULL; + const struct bt_trace *writer_trace = NULL; char trace_path[PATH_MAX]; enum bt_component_status ret; - struct bt_ctf_stream *stream = NULL; + const struct bt_stream *stream = NULL; struct fs_writer *fs_writer = NULL; int nr_stream, i; @@ -318,12 +310,12 @@ struct fs_writer *insert_new_writer( } writer_trace = bt_ctf_writer_get_trace(ctf_writer); - assert(writer_trace); + BT_ASSERT(writer_trace); ret = ctf_copy_trace(writer_component->err, trace, writer_trace); if (ret != BT_COMPONENT_STATUS_OK) { BT_LOGE_STR("Failed to copy trace."); - BT_PUT(ctf_writer); + BT_OBJECT_PUT_REF_AND_RESET(ctf_writer); goto error; } @@ -336,7 +328,7 @@ struct fs_writer *insert_new_writer( fs_writer->trace = trace; fs_writer->writer_trace = writer_trace; fs_writer->writer_component = writer_component; - BT_PUT(writer_trace); + BT_OBJECT_PUT_REF_AND_RESET(writer_trace); fs_writer->stream_class_map = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) unref_stream_class); fs_writer->stream_map = g_hash_table_new_full(g_direct_hash, @@ -345,23 +337,23 @@ struct fs_writer *insert_new_writer( g_direct_equal, NULL, destroy_stream_state_key); /* 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); - assert(stream); + stream = bt_trace_get_stream_by_index(trace, i); + BT_ASSERT(stream); insert_new_stream_state(writer_component, fs_writer, stream); - BT_PUT(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)) { fs_writer->trace_static = 1; fs_writer->static_listener_id = -1; } else { - ret = bt_ctf_trace_add_is_static_listener(trace, + ret = bt_trace_add_is_static_listener(trace, trace_is_static_listener, NULL, fs_writer); - assert(ret >= 0); + BT_ASSERT(ret >= 0); fs_writer->static_listener_id = ret; } @@ -374,29 +366,29 @@ struct fs_writer *insert_new_writer( error: g_free(fs_writer); fs_writer = NULL; - bt_put(writer_trace); - bt_put(stream); - BT_PUT(ctf_writer); + bt_object_put_ref(writer_trace); + bt_object_put_ref(stream); + BT_OBJECT_PUT_REF_AND_RESET(ctf_writer); end: return fs_writer; } static struct fs_writer *get_fs_writer(struct writer_component *writer_component, - struct bt_ctf_stream_class *stream_class) + const struct bt_stream_class *stream_class) { - struct bt_ctf_trace *trace = NULL; + const struct bt_trace *trace = NULL; struct fs_writer *fs_writer; - trace = bt_ctf_stream_class_get_trace(stream_class); - assert(trace); + trace = bt_stream_class_get_trace(stream_class); + BT_ASSERT(trace); fs_writer = g_hash_table_lookup(writer_component->trace_map, (gpointer) trace); if (!fs_writer) { fs_writer = insert_new_writer(writer_component, trace); } - BT_PUT(trace); + BT_OBJECT_PUT_REF_AND_RESET(trace); return fs_writer; } @@ -404,53 +396,53 @@ struct fs_writer *get_fs_writer(struct writer_component *writer_component, static struct fs_writer *get_fs_writer_from_stream( struct writer_component *writer_component, - struct bt_ctf_stream *stream) + const struct bt_stream *stream) { - struct bt_ctf_stream_class *stream_class = NULL; + const struct bt_stream_class *stream_class = NULL; struct fs_writer *fs_writer; - stream_class = bt_ctf_stream_get_class(stream); - assert(stream_class); + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); fs_writer = get_fs_writer(writer_component, stream_class); - bt_put(stream_class); + bt_object_put_ref(stream_class); return fs_writer; } static -struct bt_ctf_stream_class *lookup_stream_class( +const struct bt_stream_class *lookup_stream_class( struct writer_component *writer_component, - struct bt_ctf_stream_class *stream_class) + const struct bt_stream_class *stream_class) { struct fs_writer *fs_writer = get_fs_writer( writer_component, stream_class); - assert(fs_writer); - return (struct bt_ctf_stream_class *) g_hash_table_lookup( + BT_ASSERT(fs_writer); + return (const struct bt_stream_class *) g_hash_table_lookup( fs_writer->stream_class_map, (gpointer) stream_class); } static -struct bt_ctf_stream *lookup_stream(struct writer_component *writer_component, - struct bt_ctf_stream *stream) +const struct bt_stream *lookup_stream(struct writer_component *writer_component, + const struct bt_stream *stream) { struct fs_writer *fs_writer = get_fs_writer_from_stream( writer_component, stream); - assert(fs_writer); - return (struct bt_ctf_stream *) g_hash_table_lookup( + BT_ASSERT(fs_writer); + return (const struct bt_stream *) g_hash_table_lookup( fs_writer->stream_map, (gpointer) stream); } static -struct bt_ctf_stream *insert_new_stream( +const struct bt_stream *insert_new_stream( struct writer_component *writer_component, struct fs_writer *fs_writer, - struct bt_ctf_stream_class *stream_class, - struct bt_ctf_stream *stream) + const struct bt_stream_class *stream_class, + const struct bt_stream *stream) { - struct bt_ctf_stream *writer_stream = NULL; - struct bt_ctf_stream_class *writer_stream_class = NULL; - struct bt_ctf_writer *ctf_writer = bt_get(fs_writer->writer); + const struct bt_stream *writer_stream = NULL; + const struct bt_stream_class *writer_stream_class = NULL; + struct bt_ctf_writer *ctf_writer = bt_object_get_ref(fs_writer->writer); writer_stream_class = lookup_stream_class(writer_component, stream_class); @@ -462,11 +454,11 @@ struct bt_ctf_stream *insert_new_stream( goto error; } } - bt_get(writer_stream_class); + bt_object_get_ref(writer_stream_class); - writer_stream = bt_ctf_stream_create(writer_stream_class, - bt_ctf_stream_get_name(stream)); - assert(writer_stream); + writer_stream = bt_stream_create(writer_stream_class, + bt_stream_get_name(stream)); + BT_ASSERT(writer_stream); g_hash_table_insert(fs_writer->stream_map, (gpointer) stream, writer_stream); @@ -474,40 +466,40 @@ 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(ctf_writer); - bt_put(writer_stream_class); + bt_object_put_ref(ctf_writer); + bt_object_put_ref(writer_stream_class); return writer_stream; } static -struct bt_ctf_event_class *get_event_class(struct writer_component *writer_component, - struct bt_ctf_stream_class *writer_stream_class, - struct bt_ctf_event_class *event_class) +const struct bt_event_class *get_event_class(struct writer_component *writer_component, + 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 bt_ctf_stream *get_writer_stream( +const struct bt_stream *get_writer_stream( struct writer_component *writer_component, - struct bt_ctf_packet *packet, struct bt_ctf_stream *stream) + const struct bt_packet *packet, const struct bt_stream *stream) { - struct bt_ctf_stream *writer_stream = NULL; + const struct bt_stream *writer_stream = NULL; writer_stream = lookup_stream(writer_component, stream); if (!writer_stream) { 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: return writer_stream; } @@ -517,7 +509,7 @@ void writer_close(struct writer_component *writer_component, struct fs_writer *fs_writer) { if (fs_writer->static_listener_id >= 0) { - bt_ctf_trace_remove_is_static_listener(fs_writer->trace, + bt_trace_remove_is_static_listener(fs_writer->trace, fs_writer->static_listener_id); } @@ -540,16 +532,16 @@ void writer_close(struct writer_component *writer_component, BT_HIDDEN enum bt_component_status writer_stream_begin( struct writer_component *writer_component, - struct bt_ctf_stream *stream) + const struct bt_stream *stream) { - struct bt_ctf_stream_class *stream_class = NULL; + const struct bt_stream_class *stream_class = NULL; struct fs_writer *fs_writer; - struct bt_ctf_stream *writer_stream = NULL; + const struct bt_stream *writer_stream = NULL; enum bt_component_status ret = BT_COMPONENT_STATUS_OK; enum fs_writer_stream_state *state; - stream_class = bt_ctf_stream_get_class(stream); - assert(stream_class); + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); fs_writer = get_fs_writer(writer_component, stream_class); if (!fs_writer) { @@ -585,23 +577,23 @@ enum bt_component_status writer_stream_begin( error: ret = BT_COMPONENT_STATUS_ERROR; end: - bt_put(stream_class); + bt_object_put_ref(stream_class); return ret; } BT_HIDDEN enum bt_component_status writer_stream_end( struct writer_component *writer_component, - struct bt_ctf_stream *stream) + const struct bt_stream *stream) { - struct bt_ctf_stream_class *stream_class = NULL; + const struct bt_stream_class *stream_class = NULL; struct fs_writer *fs_writer; - struct bt_ctf_trace *trace = NULL; + const struct bt_trace *trace = NULL; enum bt_component_status ret = BT_COMPONENT_STATUS_OK; enum fs_writer_stream_state *state; - stream_class = bt_ctf_stream_get_class(stream); - assert(stream_class); + stream_class = bt_stream_get_class(stream); + BT_ASSERT(stream_class); fs_writer = get_fs_writer(writer_component, stream_class); if (!fs_writer) { @@ -635,29 +627,29 @@ enum bt_component_status writer_stream_end( error: ret = BT_COMPONENT_STATUS_ERROR; end: - BT_PUT(trace); - BT_PUT(stream_class); + BT_OBJECT_PUT_REF_AND_RESET(trace); + BT_OBJECT_PUT_REF_AND_RESET(stream_class); return ret; } BT_HIDDEN enum bt_component_status writer_new_packet( struct writer_component *writer_component, - struct bt_ctf_packet *packet) + const struct bt_packet *packet) { - struct bt_ctf_stream *stream = NULL, *writer_stream = NULL; + const struct bt_stream *stream = NULL, *writer_stream = NULL; enum bt_component_status ret = BT_COMPONENT_STATUS_OK; int int_ret; - stream = bt_ctf_packet_get_stream(packet); - assert(stream); + stream = bt_packet_get_stream(packet); + BT_ASSERT(stream); writer_stream = get_writer_stream(writer_component, packet, stream); if (!writer_stream) { BT_LOGE_STR("Failed to get writer_stream."); goto error; } - BT_PUT(stream); + BT_OBJECT_PUT_REF_AND_RESET(stream); int_ret = ctf_stream_copy_packet_context( writer_component->err, packet, writer_stream); @@ -678,38 +670,38 @@ enum bt_component_status writer_new_packet( error: ret = BT_COMPONENT_STATUS_ERROR; end: - bt_put(writer_stream); - bt_put(stream); + bt_object_put_ref(writer_stream); + bt_object_put_ref(stream); return ret; } BT_HIDDEN enum bt_component_status writer_close_packet( struct writer_component *writer_component, - struct bt_ctf_packet *packet) + const struct bt_packet *packet) { - struct bt_ctf_stream *stream = NULL, *writer_stream = NULL; + const struct bt_stream *stream = NULL, *writer_stream = NULL; enum bt_component_status ret; - stream = bt_ctf_packet_get_stream(packet); - assert(stream); + stream = bt_packet_get_stream(packet); + BT_ASSERT(stream); writer_stream = lookup_stream(writer_component, stream); if (!writer_stream) { BT_LOGE_STR("Failed to find existing stream."); goto error; } - BT_PUT(stream); + BT_OBJECT_PUT_REF_AND_RESET(stream); - bt_get(writer_stream); + bt_object_get_ref(writer_stream); - ret = bt_ctf_stream_flush(writer_stream); + ret = bt_stream_flush(writer_stream); if (ret) { BT_LOGE_STR("Failed to flush stream."); goto error; } - BT_PUT(writer_stream); + BT_OBJECT_PUT_REF_AND_RESET(writer_stream); ret = BT_COMPONENT_STATUS_OK; goto end; @@ -717,58 +709,62 @@ enum bt_component_status writer_close_packet( error: ret = BT_COMPONENT_STATUS_ERROR; end: - bt_put(writer_stream); - bt_put(stream); + bt_object_put_ref(writer_stream); + bt_object_put_ref(stream); return ret; } BT_HIDDEN enum bt_component_status writer_output_event( struct writer_component *writer_component, - struct bt_ctf_event *event) + const struct bt_event *event) { enum bt_component_status ret; - struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL; - struct bt_ctf_stream *stream = NULL, *writer_stream = NULL; - struct bt_ctf_stream_class *stream_class = NULL, *writer_stream_class = NULL; - struct bt_ctf_event *writer_event = NULL; + const struct bt_event_class *event_class = NULL, *writer_event_class = NULL; + const struct bt_stream *stream = NULL, *writer_stream = NULL; + const struct bt_stream_class *stream_class = NULL, *writer_stream_class = NULL; + const struct bt_event *writer_event = NULL; int int_ret; + const struct bt_trace *writer_trace = NULL; - event_class = bt_ctf_event_get_class(event); - assert(event_class); + event_class = bt_event_get_class(event); + BT_ASSERT(event_class); - stream = bt_ctf_event_get_stream(event); - assert(stream); + stream = bt_event_get_stream(event); + BT_ASSERT(stream); writer_stream = lookup_stream(writer_component, stream); - if (!writer_stream || !bt_get(writer_stream)) { + if (!writer_stream || !bt_object_get_ref(writer_stream)) { BT_LOGE_STR("Failed for find existing stream."); goto error; } - stream_class = bt_ctf_event_class_get_stream_class(event_class); - assert(stream_class); + stream_class = bt_event_class_get_stream_class(event_class); + BT_ASSERT(stream_class); writer_stream_class = lookup_stream_class(writer_component, stream_class); - if (!writer_stream_class || !bt_get(writer_stream_class)) { + if (!writer_stream_class || !bt_object_get_ref(writer_stream_class)) { BT_LOGE_STR("Failed to find existing stream_class."); goto error; } + writer_trace = bt_stream_class_get_trace(writer_stream_class); + BT_ASSERT(writer_trace); + writer_event_class = get_event_class(writer_component, writer_stream_class, event_class); if (!writer_event_class) { writer_event_class = ctf_copy_event_class(writer_component->err, - event_class); + writer_trace, event_class); if (!writer_event_class) { 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) { BT_LOGE("Failed to add event_class: event_name=\"%s\"", - bt_ctf_event_class_get_name(event_class)); + bt_event_class_get_name(event_class)); goto error; } } @@ -777,14 +773,14 @@ enum bt_component_status writer_output_event( writer_event_class, true); if (!writer_event) { BT_LOGE("Failed to copy event: event_class=\"%s\"", - bt_ctf_event_class_get_name(writer_event_class)); + bt_event_class_get_name(writer_event_class)); goto error; } - int_ret = bt_ctf_stream_append_event(writer_stream, writer_event); + int_ret = bt_stream_append_event(writer_stream, writer_event); if (int_ret < 0) { BT_LOGE("Failed to append event: event_class=\"%s\"", - bt_ctf_event_class_get_name(writer_event_class)); + bt_event_class_get_name(writer_event_class)); goto error; } @@ -794,12 +790,13 @@ enum bt_component_status writer_output_event( error: ret = BT_COMPONENT_STATUS_ERROR; end: - bt_put(writer_event); - bt_put(writer_event_class); - bt_put(writer_stream_class); - bt_put(stream_class); - bt_put(writer_stream); - bt_put(stream); - bt_put(event_class); + bt_object_put_ref(writer_trace); + bt_object_put_ref(writer_event); + bt_object_put_ref(writer_event_class); + bt_object_put_ref(writer_stream_class); + bt_object_put_ref(stream_class); + bt_object_put_ref(writer_stream); + bt_object_put_ref(stream); + bt_object_put_ref(event_class); return ret; }