X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Fctf%2Ffs%2Ffs.c;h=da7180b6f011d8fbd909ab3febaeebb06da76f4e;hb=64cadc660bbd0400df65da3534d28dbe59395ec7;hp=6b80d04a3258755c80fd50dfcd2368d4934a0342;hpb=ea0e619ec5a367076b752c24fa385af7aa82994a;p=babeltrace.git diff --git a/plugins/ctf/fs/fs.c b/plugins/ctf/fs/fs.c index 6b80d04a..da7180b6 100644 --- a/plugins/ctf/fs/fs.c +++ b/plugins/ctf/fs/fs.c @@ -26,14 +26,17 @@ * SOFTWARE. */ -#include #include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -45,20 +48,20 @@ #define PRINT_ERR_STREAM ctf_fs->error_fp #define PRINT_PREFIX "ctf-fs" #include "print.h" +#define METADATA_TEXT_SIG "/* CTF 1.8" BT_HIDDEN bool ctf_fs_debug; -static enum bt_notification_iterator_status ctf_fs_iterator_next( - struct bt_notification_iterator *iterator); + struct bt_private_notification_iterator *iterator); -static struct bt_notification *ctf_fs_iterator_get( - struct bt_notification_iterator *iterator) + struct bt_private_notification_iterator *iterator) { struct ctf_fs_iterator *ctf_it = - bt_notification_iterator_get_private_data(iterator); + bt_private_notification_iterator_get_user_data( + iterator); if (!ctf_it->current_notification) { (void) ctf_fs_iterator_next(iterator); @@ -246,9 +249,8 @@ end: return ret; } -static enum bt_notification_iterator_status ctf_fs_iterator_next( - struct bt_notification_iterator *iterator) + struct bt_private_notification_iterator *iterator) { int heap_ret; struct bt_ctf_stream *stream = NULL; @@ -258,7 +260,8 @@ enum bt_notification_iterator_status ctf_fs_iterator_next( enum bt_notification_iterator_status ret = BT_NOTIFICATION_ITERATOR_STATUS_OK; struct ctf_fs_iterator *ctf_it = - bt_notification_iterator_get_private_data(iterator); + bt_private_notification_iterator_get_user_data( + iterator); notification = bt_notification_heap_pop(ctf_it->pending_notifications); if (!notification && !ctf_it->pending_streams) { @@ -353,6 +356,9 @@ end: static void ctf_fs_iterator_destroy_data(struct ctf_fs_iterator *ctf_it) { + if (!ctf_it) { + return; + } bt_put(ctf_it->current_notification); bt_put(ctf_it->pending_notifications); if (ctf_it->pending_streams) { @@ -364,10 +370,9 @@ void ctf_fs_iterator_destroy_data(struct ctf_fs_iterator *ctf_it) g_free(ctf_it); } -static -void ctf_fs_iterator_destroy(struct bt_notification_iterator *it) +void ctf_fs_iterator_finalize(struct bt_private_notification_iterator *it) { - void *data = bt_notification_iterator_get_private_data(it); + void *data = bt_private_notification_iterator_get_user_data(it); ctf_fs_iterator_destroy_data(data); } @@ -377,7 +382,7 @@ bool compare_event_notifications(struct bt_notification *a, struct bt_notification *b) { int ret; - struct bt_ctf_clock *clock; + struct bt_ctf_clock_class *clock_class; struct bt_ctf_clock_value *a_clock_value, *b_clock_value; struct bt_ctf_stream_class *a_stream_class; struct bt_ctf_stream *a_stream; @@ -398,9 +403,9 @@ bool compare_event_notifications(struct bt_notification *a, trace = bt_ctf_stream_class_get_trace(a_stream_class); assert(trace); - clock = bt_ctf_trace_get_clock(trace, 0); - a_clock_value = bt_ctf_event_get_clock_value(a_event, clock); - b_clock_value = bt_ctf_event_get_clock_value(b_event, clock); + clock_class = bt_ctf_trace_get_clock_class(trace, 0); + a_clock_value = bt_ctf_event_get_clock_value(a_event, clock_class); + b_clock_value = bt_ctf_event_get_clock_value(b_event, clock_class); assert(a_clock_value); assert(b_clock_value); @@ -415,7 +420,7 @@ bool compare_event_notifications(struct bt_notification *a, bt_put(b_clock_value); bt_put(a_stream); bt_put(a_stream_class); - bt_put(clock); + bt_put(clock_class); bt_put(trace); return a_ts < b_ts; } @@ -584,25 +589,26 @@ end: return ret; } -static -enum bt_component_status ctf_fs_iterator_init(struct bt_component *source, - struct bt_notification_iterator *it) +enum bt_notification_iterator_status ctf_fs_iterator_init( + struct bt_private_component *source, + struct bt_private_port *port, + struct bt_private_notification_iterator *it) { struct ctf_fs_iterator *ctf_it; struct ctf_fs_component *ctf_fs; - enum bt_component_status ret = BT_COMPONENT_STATUS_OK; + enum bt_notification_iterator_status ret = BT_NOTIFICATION_ITERATOR_STATUS_OK; assert(source && it); - ctf_fs = bt_component_get_private_data(source); + ctf_fs = bt_private_component_get_user_data(source); if (!ctf_fs) { - ret = BT_COMPONENT_STATUS_INVALID; + ret = BT_NOTIFICATION_ITERATOR_STATUS_INVAL; goto end; } ctf_it = g_new0(struct ctf_fs_iterator, 1); if (!ctf_it) { - ret = BT_COMPONENT_STATUS_NOMEM; + ret = BT_NOTIFICATION_ITERATOR_STATUS_NOMEM; goto end; } @@ -627,23 +633,7 @@ enum bt_component_status ctf_fs_iterator_init(struct bt_component *source, goto error; } - ret = bt_notification_iterator_set_get_cb(it, ctf_fs_iterator_get); - if (ret) { - goto error; - } - - ret = bt_notification_iterator_set_next_cb(it, ctf_fs_iterator_next); - if (ret) { - goto error; - } - - ret = bt_notification_iterator_set_destroy_cb(it, - ctf_fs_iterator_destroy); - if (ret) { - goto error; - } - - ret = bt_notification_iterator_set_private_data(it, ctf_it); + ret = bt_private_notification_iterator_set_user_data(it, ctf_it); if (ret) { goto error; } @@ -651,7 +641,7 @@ enum bt_component_status ctf_fs_iterator_init(struct bt_component *source, end: return ret; error: - (void) bt_notification_iterator_set_private_data(it, NULL); + (void) bt_private_notification_iterator_set_user_data(it, NULL); ctf_fs_iterator_destroy_data(ctf_it); goto end; } @@ -659,6 +649,9 @@ error: static void ctf_fs_destroy_data(struct ctf_fs_component *ctf_fs) { + if (!ctf_fs) { + return; + } if (ctf_fs->trace_path) { g_string_free(ctf_fs->trace_path, TRUE); } @@ -669,10 +662,9 @@ void ctf_fs_destroy_data(struct ctf_fs_component *ctf_fs) g_free(ctf_fs); } -static -void ctf_fs_destroy(struct bt_component *component) +void ctf_fs_finalize(struct bt_private_component *component) { - void *data = bt_component_get_private_data(component); + void *data = bt_private_component_get_user_data(component); ctf_fs_destroy_data(data); } @@ -725,8 +717,8 @@ end: } BT_HIDDEN -enum bt_component_status ctf_fs_init(struct bt_component *source, - struct bt_value *params) +enum bt_component_status ctf_fs_init(struct bt_private_component *source, + struct bt_value *params, UNUSED_VAR void *init_method_data) { struct ctf_fs_component *ctf_fs; enum bt_component_status ret = BT_COMPONENT_STATUS_OK; @@ -739,25 +731,140 @@ enum bt_component_status ctf_fs_init(struct bt_component *source, goto end; } - ret = bt_component_set_destroy_cb(source, ctf_fs_destroy); - if (ret != BT_COMPONENT_STATUS_OK) { - goto error; - } - - ret = bt_component_set_private_data(source, ctf_fs); - if (ret != BT_COMPONENT_STATUS_OK) { - goto error; - } - - ret = bt_component_source_set_iterator_init_cb(source, - ctf_fs_iterator_init); + ret = bt_private_component_set_user_data(source, ctf_fs); if (ret != BT_COMPONENT_STATUS_OK) { goto error; } end: return ret; error: - (void) bt_component_set_private_data(source, NULL); + (void) bt_private_component_set_user_data(source, NULL); ctf_fs_destroy_data(ctf_fs); return ret; } + +BT_HIDDEN +struct bt_value *ctf_fs_query(struct bt_component_class *comp_class, + const char *object, struct bt_value *params) +{ + struct bt_value *results = NULL; + struct bt_value *path_value = NULL; + char *metadata_text = NULL; + FILE *metadata_fp = NULL; + GString *g_metadata_text = NULL; + + if (strcmp(object, "metadata-info") == 0) { + int ret; + int bo; + const char *path; + bool is_packetized; + + results = bt_value_map_create(); + if (!results) { + goto error; + } + + if (!bt_value_is_map(params)) { + fprintf(stderr, + "Query parameters is not a map value object\n"); + goto error; + } + + path_value = bt_value_map_get(params, "path"); + ret = bt_value_string_get(path_value, &path); + if (ret) { + fprintf(stderr, + "Cannot get `path` string parameter\n"); + goto error; + } + + assert(path); + metadata_fp = ctf_fs_metadata_open_file(path); + if (!metadata_fp) { + fprintf(stderr, + "Cannot open trace at path `%s`\n", path); + goto error; + } + + is_packetized = ctf_metadata_is_packetized(metadata_fp, &bo); + + if (is_packetized) { + ret = ctf_metadata_packetized_file_to_buf(NULL, + metadata_fp, (uint8_t **) &metadata_text, bo); + if (ret) { + fprintf(stderr, + "Cannot decode packetized metadata file\n"); + goto error; + } + } else { + long filesize; + + fseek(metadata_fp, 0, SEEK_END); + filesize = ftell(metadata_fp); + rewind(metadata_fp); + metadata_text = malloc(filesize + 1); + if (!metadata_text) { + fprintf(stderr, + "Cannot allocate buffer for metadata text\n"); + goto error; + } + + if (fread(metadata_text, filesize, 1, metadata_fp) != + 1) { + fprintf(stderr, + "Cannot read metadata file\n"); + goto error; + } + + metadata_text[filesize] = '\0'; + } + + g_metadata_text = g_string_new(NULL); + if (!g_metadata_text) { + goto error; + } + + if (strncmp(metadata_text, METADATA_TEXT_SIG, + sizeof(METADATA_TEXT_SIG) - 1) != 0) { + g_string_assign(g_metadata_text, METADATA_TEXT_SIG); + g_string_append(g_metadata_text, " */\n\n"); + } + + g_string_append(g_metadata_text, metadata_text); + + ret = bt_value_map_insert_string(results, "text", + g_metadata_text->str); + if (ret) { + fprintf(stderr, "Cannot insert metadata text into results\n"); + goto error; + } + + ret = bt_value_map_insert_bool(results, "is-packetized", + is_packetized); + if (ret) { + fprintf(stderr, "Cannot insert is packetized into results\n"); + goto error; + } + } else { + fprintf(stderr, "Unknown query object `%s`\n", object); + goto error; + } + + goto end; + +error: + BT_PUT(results); + +end: + bt_put(path_value); + free(metadata_text); + + if (g_metadata_text) { + g_string_free(g_metadata_text, TRUE); + } + + if (metadata_fp) { + fclose(metadata_fp); + } + return results; +}