From 4c65a157ea67009b883f7d9069c710385fff90bd Mon Sep 17 00:00:00 2001 From: Philippe Proulx Date: Wed, 19 Jun 2019 02:38:56 -0400 Subject: [PATCH] src.ctf.fs: use BT_COMP_LOG*() instead of BT_LOG*() Signed-off-by: Philippe Proulx Change-Id: Iee65b871881b4719d429b6343e3a7e437bac732c Reviewed-on: https://review.lttng.org/c/babeltrace/+/1510 --- src/plugins/ctf/fs-src/data-stream-file.c | 79 +++++++------ src/plugins/ctf/fs-src/data-stream-file.h | 6 +- src/plugins/ctf/fs-src/file.c | 23 ++-- src/plugins/ctf/fs-src/file.h | 3 +- src/plugins/ctf/fs-src/fs.c | 134 ++++++++++++---------- src/plugins/ctf/fs-src/fs.h | 17 ++- src/plugins/ctf/fs-src/metadata.c | 19 +-- src/plugins/ctf/fs-src/metadata.h | 2 +- src/plugins/ctf/fs-src/query.c | 2 +- 9 files changed, 163 insertions(+), 122 deletions(-) diff --git a/src/plugins/ctf/fs-src/data-stream-file.c b/src/plugins/ctf/fs-src/data-stream-file.c index 69074dbd..18db1d0c 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.c +++ b/src/plugins/ctf/fs-src/data-stream-file.c @@ -22,9 +22,10 @@ * SOFTWARE. */ +#define BT_COMP_LOG_SELF_COMP (ds_file->self_comp) #define BT_LOG_OUTPUT_LEVEL (ds_file->log_level) #define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/DS" -#include "logging/log.h" +#include "plugins/comp-logging.h" #include #include @@ -60,7 +61,7 @@ int ds_file_munmap(struct ctf_fs_ds_file *ds_file) } if (bt_munmap(ds_file->mmap_addr, ds_file->mmap_len)) { - BT_LOGE_ERRNO("Cannot memory-unmap file", + BT_COMP_LOGE_ERRNO("Cannot memory-unmap file", ": address=%p, size=%zu, file_path=\"%s\", file=%p", ds_file->mmap_addr, ds_file->mmap_len, ds_file->file ? ds_file->file->path->str : "NULL", @@ -109,7 +110,7 @@ enum bt_msg_iter_medium_status ds_file_mmap_next( PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp), ds_file->mmap_offset); if (ds_file->mmap_addr == MAP_FAILED) { - BT_LOGE("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %jd: %s", + BT_COMP_LOGE("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %jd: %s", ds_file->mmap_len, ds_file->file->path->str, ds_file->file->fp, (intmax_t) ds_file->mmap_offset, strerror(errno)); @@ -141,7 +142,7 @@ enum bt_msg_iter_medium_status medop_request_bytes( if (remaining_mmap_bytes(ds_file) == 0) { /* Are we at the end of the file? */ if (ds_file->mmap_offset >= ds_file->file->size) { - BT_LOGD("Reached end of file \"%s\" (%p)", + BT_COMP_LOGD("Reached end of file \"%s\" (%p)", ds_file->file->path->str, ds_file->file->fp); status = BT_MSG_ITER_MEDIUM_STATUS_EOF; goto end; @@ -154,7 +155,7 @@ enum bt_msg_iter_medium_status medop_request_bytes( case BT_MSG_ITER_MEDIUM_STATUS_EOF: goto end; default: - BT_LOGE("Cannot memory-map next region of file \"%s\" (%p)", + BT_COMP_LOGE("Cannot memory-map next region of file \"%s\" (%p)", ds_file->file->path->str, ds_file->file->fp); goto error; @@ -209,7 +210,7 @@ enum bt_msg_iter_medium_status medop_seek(enum bt_msg_iter_seek_whence whence, if (whence != BT_MSG_ITER_SEEK_WHENCE_SET || offset < 0 || offset > file_size) { - BT_LOGE("Invalid medium seek request: whence=%d, offset=%jd, " + BT_COMP_LOGE("Invalid medium seek request: whence=%d, offset=%jd, " "file-size=%jd", (int) whence, offset, file_size); ret = BT_MSG_ITER_MEDIUM_STATUS_INVAL; @@ -226,7 +227,7 @@ enum bt_msg_iter_medium_status medop_seek(enum bt_msg_iter_seek_whence whence, off_t offset_in_mapping = offset % bt_common_get_page_size(ds_file->log_level); - BT_LOGD("Medium seek request cannot be accomodated by the current " + BT_COMP_LOGD("Medium seek request cannot be accomodated by the current " "file mapping: offset=%jd, mmap-offset=%jd, " "mmap-len=%zu", offset, ds_file->mmap_offset, ds_file->mmap_len); @@ -289,11 +290,11 @@ struct ctf_fs_ds_index *build_index_from_idx_file( struct ctf_stream_class *sc; struct bt_msg_iter_packet_properties props; - BT_LOGI("Building index from .idx file of stream file %s", + BT_COMP_LOGI("Building index from .idx file of stream file %s", ds_file->file->path->str); ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props); if (ret) { - BT_LOGI_STR("Cannot read first packet's header and context fields."); + BT_COMP_LOGI_STR("Cannot read first packet's header and context fields."); goto error; } @@ -301,28 +302,28 @@ struct ctf_fs_ds_index *build_index_from_idx_file( props.stream_class_id); BT_ASSERT(sc); if (!sc->default_clock_class) { - BT_LOGI_STR("Cannot find stream class's default clock class."); + BT_COMP_LOGI_STR("Cannot find stream class's default clock class."); goto error; } /* Look for index file in relative path index/name.idx. */ basename = g_path_get_basename(ds_file->file->path->str); if (!basename) { - BT_LOGE("Cannot get the basename of datastream file %s", + BT_COMP_LOGE("Cannot get the basename of datastream file %s", ds_file->file->path->str); goto error; } directory = g_path_get_dirname(ds_file->file->path->str); if (!directory) { - BT_LOGE("Cannot get dirname of datastream file %s", + BT_COMP_LOGE("Cannot get dirname of datastream file %s", ds_file->file->path->str); goto error; } index_basename = g_string_new(basename); if (!index_basename) { - BT_LOGE_STR("Cannot allocate index file basename string"); + BT_COMP_LOGE_STR("Cannot allocate index file basename string"); goto error; } @@ -331,7 +332,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( index_basename->str, NULL); mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL); if (!mapped_file) { - BT_LOGD("Cannot create new mapped file %s", + BT_COMP_LOGD("Cannot create new mapped file %s", index_file_path); goto error; } @@ -343,7 +344,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( */ filesize = g_mapped_file_get_length(mapped_file); if (filesize < sizeof(*header)) { - BT_LOGW("Invalid LTTng trace index file: " + BT_COMP_LOGW("Invalid LTTng trace index file: " "file size (%zu bytes) < header size (%zu bytes)", filesize, sizeof(*header)); goto error; @@ -354,21 +355,21 @@ struct ctf_fs_ds_index *build_index_from_idx_file( file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header); if (be32toh(header->magic) != CTF_INDEX_MAGIC) { - BT_LOGW_STR("Invalid LTTng trace index: \"magic\" field validation failed"); + BT_COMP_LOGW_STR("Invalid LTTng trace index: \"magic\" field validation failed"); goto error; } file_index_entry_size = be32toh(header->packet_index_len); file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size; if ((filesize - sizeof(*header)) % file_index_entry_size) { - BT_LOGW("Invalid LTTng trace index: the index's size after the header " + BT_COMP_LOGW("Invalid LTTng trace index: the index's size after the header " "(%zu bytes) is not a multiple of the index entry size " "(%zu bytes)", (filesize - sizeof(*header)), sizeof(*header)); goto error; } - index = ctf_fs_ds_index_create(ds_file->log_level); + index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp); if (!index) { goto error; } @@ -379,7 +380,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( uint64_t packet_size = be64toh(file_index->packet_size); if (packet_size % CHAR_BIT) { - BT_LOGW("Invalid packet size encountered in LTTng trace index file"); + BT_COMP_LOGW("Invalid packet size encountered in LTTng trace index file"); goto error; } @@ -394,7 +395,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( index_entry->offset = be64toh(file_index->offset); if (i != 0 && index_entry->offset < (index_entry - 1)->offset) { - BT_LOGW("Invalid, non-monotonic, packet offset encountered in LTTng trace index file: " + BT_COMP_LOGW("Invalid, non-monotonic, packet offset encountered in LTTng trace index file: " "previous offset=%" PRIu64 ", current offset=%" PRIu64, (index_entry - 1)->offset, index_entry->offset); goto error; @@ -403,7 +404,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( index_entry->timestamp_begin = be64toh(file_index->timestamp_begin); index_entry->timestamp_end = be64toh(file_index->timestamp_end); if (index_entry->timestamp_end < index_entry->timestamp_begin) { - BT_LOGW("Invalid packet time bounds encountered in LTTng trace index file (begin > end): " + BT_COMP_LOGW("Invalid packet time bounds encountered in LTTng trace index file (begin > end): " "timestamp_begin=%" PRIu64 "timestamp_end=%" PRIu64, index_entry->timestamp_begin, index_entry->timestamp_end); @@ -415,14 +416,14 @@ struct ctf_fs_ds_index *build_index_from_idx_file( index_entry->timestamp_begin, &index_entry->timestamp_begin_ns); if (ret) { - BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing"); + BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing"); goto error; } ret = convert_cycles_to_ns(sc->default_clock_class, index_entry->timestamp_end, &index_entry->timestamp_end_ns); if (ret) { - BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing"); + BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing"); goto error; } @@ -434,7 +435,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( /* Validate that the index addresses the complete stream. */ if (ds_file->file->size != total_packets_size) { - BT_LOGW("Invalid LTTng trace index file; indexed size != stream file size: " + BT_COMP_LOGW("Invalid LTTng trace index file; indexed size != stream file size: " "file-size=%" PRIu64 ", total-packets-size=%" PRIu64, ds_file->file->size, total_packets_size); goto error; @@ -480,7 +481,7 @@ int init_index_entry(struct ctf_fs_ds_index_entry *entry, props->snapshots.beginning_clock, &entry->timestamp_begin_ns); if (ret) { - BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch."); + BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch."); goto end; } } else { @@ -492,7 +493,7 @@ int init_index_entry(struct ctf_fs_ds_index_entry *entry, props->snapshots.end_clock, &entry->timestamp_end_ns); if (ret) { - BT_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch."); + BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch."); goto end; } } else { @@ -512,9 +513,9 @@ struct ctf_fs_ds_index *build_index_from_stream_file( enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK; off_t current_packet_offset_bytes = 0; - BT_LOGI("Indexing stream file %s", ds_file->file->path->str); + BT_COMP_LOGI("Indexing stream file %s", ds_file->file->path->str); - index = ctf_fs_ds_index_create(ds_file->log_level); + index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp); if (!index) { goto error; } @@ -525,10 +526,10 @@ struct ctf_fs_ds_index *build_index_from_stream_file( struct bt_msg_iter_packet_properties props; if (current_packet_offset_bytes < 0) { - BT_LOGE_STR("Cannot get the current packet's offset."); + BT_COMP_LOGE_STR("Cannot get the current packet's offset."); goto error; } else if (current_packet_offset_bytes > ds_file->file->size) { - BT_LOGE_STR("Unexpected current packet's offset (larger than file)."); + BT_COMP_LOGE_STR("Unexpected current packet's offset (larger than file)."); goto error; } else if (current_packet_offset_bytes == ds_file->file->size) { /* No more data */ @@ -556,7 +557,7 @@ struct ctf_fs_ds_index *build_index_from_stream_file( if (current_packet_offset_bytes + current_packet_size_bytes > ds_file->file->size) { - BT_LOGW("Invalid packet size reported in file: stream=\"%s\", " + BT_COMP_LOGW("Invalid packet size reported in file: stream=\"%s\", " "packet-offset=%jd, packet-size-bytes=%jd, " "file-size=%jd", ds_file->file->path->str, @@ -568,7 +569,7 @@ struct ctf_fs_ds_index *build_index_from_stream_file( index_entry = g_new0(struct ctf_fs_ds_index_entry, 1); if (!index_entry) { - BT_LOGE_STR("Failed to allocate a new index entry."); + BT_COMP_LOGE_STR("Failed to allocate a new index entry."); goto error; } @@ -582,7 +583,7 @@ struct ctf_fs_ds_index *build_index_from_stream_file( g_ptr_array_add(index->entries, index_entry); current_packet_offset_bytes += current_packet_size_bytes; - BT_LOGD("Seeking to next packet: current-packet-offset=%jd, " + BT_COMP_LOGD("Seeking to next packet: current-packet-offset=%jd, " "next-packet-offset=%jd", current_packet_offset_bytes - current_packet_size_bytes, current_packet_offset_bytes); @@ -619,8 +620,9 @@ struct ctf_fs_ds_file *ctf_fs_ds_file_create( } ds_file->log_level = log_level; + ds_file->self_comp = ctf_fs_trace->self_comp; ds_file->pc_msg_iter = pc_msg_iter; - ds_file->file = ctf_fs_file_create(log_level); + ds_file->file = ctf_fs_file_create(log_level, ds_file->self_comp); if (!ds_file->file) { goto error; } @@ -664,7 +666,7 @@ struct ctf_fs_ds_index *ctf_fs_ds_file_build_index( goto end; } - BT_LOGI("Failed to build index from .index file; " + BT_COMP_LOGI("Failed to build index from .index file; " "falling back to stream indexing."); index = build_index_from_stream_file(ds_file); end: @@ -672,19 +674,20 @@ end: } BT_HIDDEN -struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level) +struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level, + bt_self_component *self_comp) { struct ctf_fs_ds_index *index = g_new0(struct ctf_fs_ds_index, 1); if (!index) { - BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG, + BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, "Failed to allocate index"); goto error; } index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) g_free); if (!index->entries) { - BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG, + BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, "Failed to allocate index entries."); goto error; } diff --git a/src/plugins/ctf/fs-src/data-stream-file.h b/src/plugins/ctf/fs-src/data-stream-file.h index 64b5b50b..50f91b36 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.h +++ b/src/plugins/ctf/fs-src/data-stream-file.h @@ -50,6 +50,9 @@ struct ctf_fs_metadata; struct ctf_fs_ds_file { bt_logging_level log_level; + /* Weak */ + bt_self_component *self_comp; + /* Weak */ struct ctf_fs_metadata *metadata; @@ -109,7 +112,8 @@ struct ctf_fs_ds_index *ctf_fs_ds_file_build_index( struct ctf_fs_ds_file *ds_file); BT_HIDDEN -struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level); +struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level, + bt_self_component *self_comp); BT_HIDDEN void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index); diff --git a/src/plugins/ctf/fs-src/file.c b/src/plugins/ctf/fs-src/file.c index c1af7c69..84d85cc2 100644 --- a/src/plugins/ctf/fs-src/file.c +++ b/src/plugins/ctf/fs-src/file.c @@ -20,9 +20,10 @@ * SOFTWARE. */ +#define BT_COMP_LOG_SELF_COMP (file->self_comp) #define BT_LOG_OUTPUT_LEVEL (file->log_level) #define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/FILE" -#include "logging/log.h" +#include "plugins/comp-logging.h" #include #include @@ -39,11 +40,11 @@ void ctf_fs_file_destroy(struct ctf_fs_file *file) } if (file->fp) { - BT_LOGD("Closing file \"%s\" (%p)", + BT_COMP_LOGD("Closing file \"%s\" (%p)", file->path ? file->path->str : NULL, file->fp); if (fclose(file->fp)) { - BT_LOGE("Cannot close file \"%s\": %s", + BT_COMP_LOGE("Cannot close file \"%s\": %s", file->path ? file->path->str : "NULL", strerror(errno)); } @@ -57,7 +58,8 @@ void ctf_fs_file_destroy(struct ctf_fs_file *file) } BT_HIDDEN -struct ctf_fs_file *ctf_fs_file_create(bt_logging_level log_level) +struct ctf_fs_file *ctf_fs_file_create(bt_logging_level log_level, + bt_self_component *self_comp) { struct ctf_fs_file *file = g_new0(struct ctf_fs_file, 1); @@ -66,6 +68,7 @@ struct ctf_fs_file *ctf_fs_file_create(bt_logging_level log_level) } file->log_level = log_level; + file->self_comp = self_comp; file->path = g_string_new(NULL); if (!file->path) { goto error; @@ -87,23 +90,23 @@ int ctf_fs_file_open(struct ctf_fs_file *file, const char *mode) int ret = 0; struct stat stat; - BT_LOGI("Opening file \"%s\" with mode \"%s\"", file->path->str, mode); + BT_COMP_LOGI("Opening file \"%s\" with mode \"%s\"", file->path->str, mode); file->fp = fopen(file->path->str, mode); if (!file->fp) { - BT_LOGE("Cannot open file \"%s\" with mode \"%s\": %s", + BT_COMP_LOGE("Cannot open file \"%s\" with mode \"%s\": %s", file->path->str, mode, strerror(errno)); goto error; } - BT_LOGI("Opened file: %p", file->fp); + BT_COMP_LOGI("Opened file: %p", file->fp); if (fstat(fileno(file->fp), &stat)) { - BT_LOGE("Cannot get file information: %s", strerror(errno)); + BT_COMP_LOGE("Cannot get file information: %s", strerror(errno)); goto error; } file->size = stat.st_size; - BT_LOGI("File is %jd bytes", (intmax_t) file->size); + BT_COMP_LOGI("File is %jd bytes", (intmax_t) file->size); goto end; error: @@ -111,7 +114,7 @@ error: if (file->fp) { if (fclose(file->fp)) { - BT_LOGE("Cannot close file \"%s\": %s", file->path->str, + BT_COMP_LOGE("Cannot close file \"%s\": %s", file->path->str, strerror(errno)); } } diff --git a/src/plugins/ctf/fs-src/file.h b/src/plugins/ctf/fs-src/file.h index e2845f5c..d608a66e 100644 --- a/src/plugins/ctf/fs-src/file.h +++ b/src/plugins/ctf/fs-src/file.h @@ -32,7 +32,8 @@ BT_HIDDEN void ctf_fs_file_destroy(struct ctf_fs_file *file); BT_HIDDEN -struct ctf_fs_file *ctf_fs_file_create(bt_logging_level log_level); +struct ctf_fs_file *ctf_fs_file_create(bt_logging_level log_level, + bt_self_component *self_comp); BT_HIDDEN int ctf_fs_file_open(struct ctf_fs_file *file, const char *mode); diff --git a/src/plugins/ctf/fs-src/fs.c b/src/plugins/ctf/fs-src/fs.c index 1c3f6e1a..b100680f 100644 --- a/src/plugins/ctf/fs-src/fs.c +++ b/src/plugins/ctf/fs-src/fs.c @@ -25,9 +25,10 @@ * SOFTWARE. */ +#define BT_COMP_LOG_SELF_COMP self_comp #define BT_LOG_OUTPUT_LEVEL log_level #define BT_LOG_TAG "PLUGIN/SRC.CTF.FS" -#include "logging/log.h" +#include "plugins/comp-logging.h" #include "common/common.h" #include @@ -240,7 +241,7 @@ void ctf_fs_iterator_finalize(bt_self_message_iterator *it) BT_HIDDEN bt_self_message_iterator_status ctf_fs_iterator_init( bt_self_message_iterator *self_msg_iter, - bt_self_component_source *self_comp, + bt_self_component_source *self_comp_src, bt_self_component_port_output *self_port) { struct ctf_fs_port_data *port_data; @@ -248,12 +249,14 @@ bt_self_message_iterator_status ctf_fs_iterator_init( bt_self_message_iterator_status ret = BT_SELF_MESSAGE_ITERATOR_STATUS_OK; bt_logging_level log_level; + bt_self_component *self_comp; port_data = bt_self_component_port_get_data( bt_self_component_port_output_as_self_component_port( self_port)); BT_ASSERT(port_data); log_level = port_data->ctf_fs->log_level; + self_comp = port_data->ctf_fs->self_comp; msg_iter_data = g_new0(struct ctf_fs_msg_iter_data, 1); if (!msg_iter_data) { ret = BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM; @@ -261,13 +264,15 @@ bt_self_message_iterator_status ctf_fs_iterator_init( } msg_iter_data->log_level = log_level; + msg_iter_data->self_comp = self_comp; msg_iter_data->pc_msg_iter = self_msg_iter; msg_iter_data->msg_iter = bt_msg_iter_create( port_data->ds_file_group->ctf_fs_trace->metadata->tc, bt_common_get_page_size(msg_iter_data->log_level) * 8, - ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level, NULL); + ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level, + self_comp); if (!msg_iter_data->msg_iter) { - BT_LOGE_STR("Cannot create a CTF message iterator."); + BT_COMP_LOGE_STR("Cannot create a CTF message iterator."); ret = BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM; goto error; } @@ -364,7 +369,8 @@ void ctf_fs_trace_destroy_notifier(void *data) ctf_fs_trace_destroy(trace); } -struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level) +struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level, + bt_self_component *self_comp) { struct ctf_fs_component *ctf_fs; @@ -374,6 +380,7 @@ struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level) } ctf_fs->log_level = log_level; + ctf_fs->self_comp = self_comp; ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy_notifier); if (!ctf_fs->port_data) { @@ -456,13 +463,14 @@ int create_one_port_for_trace(struct ctf_fs_component *ctf_fs, struct ctf_fs_port_data *port_data = NULL; gchar *port_name; bt_logging_level log_level = ctf_fs->log_level; + bt_self_component *self_comp = ctf_fs->self_comp; port_name = ctf_fs_make_port_name(ds_file_group); if (!port_name) { goto error; } - BT_LOGI("Creating one port named `%s`", port_name); + BT_COMP_LOGI("Creating one port named `%s`", port_name); /* Create output port for this file */ port_data = g_new0(struct ctf_fs_port_data, 1); @@ -473,7 +481,7 @@ int create_one_port_for_trace(struct ctf_fs_component *ctf_fs, port_data->ctf_fs = ctf_fs; port_data->ds_file_group = ds_file_group; ret = bt_self_component_source_add_output_port( - ctf_fs->self_comp, port_name, port_data, NULL); + ctf_fs->self_comp_src, port_name, port_data, NULL); if (ret) { goto error; } @@ -501,6 +509,7 @@ int create_ports_for_trace(struct ctf_fs_component *ctf_fs, int ret = 0; size_t i; bt_logging_level log_level = ctf_fs_trace->log_level; + bt_self_component *self_comp = ctf_fs_trace->self_comp; /* Create one output port for each stream file group */ for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) { @@ -510,7 +519,7 @@ int create_ports_for_trace(struct ctf_fs_component *ctf_fs, ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace, ds_file_group); if (ret) { - BT_LOGE("Cannot create output port."); + BT_COMP_LOGE("Cannot create output port."); goto end; } } @@ -727,12 +736,13 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, struct ctf_stream_class *sc = NULL; struct bt_msg_iter_packet_properties props; bt_logging_level log_level = ctf_fs_trace->log_level; + bt_self_component *self_comp = ctf_fs_trace->self_comp; msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc, bt_common_get_page_size(log_level) * 8, - ctf_fs_ds_file_medops, NULL, log_level, NULL); + ctf_fs_ds_file_medops, NULL, log_level, self_comp); if (!msg_iter) { - BT_LOGE_STR("Cannot create a CTF message iterator."); + BT_COMP_LOGE_STR("Cannot create a CTF message iterator."); goto error; } @@ -744,7 +754,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props); if (ret) { - BT_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).", + BT_COMP_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).", path); goto error; } @@ -762,7 +772,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, sc->default_clock_class->offset_seconds, sc->default_clock_class->offset_cycles, &begin_ns); if (ret) { - BT_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).", + BT_COMP_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).", path); goto error; } @@ -770,7 +780,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, index = ctf_fs_ds_file_build_index(ds_file); if (!index) { - BT_LOGW("Failed to index CTF stream file \'%s\'", + BT_COMP_LOGW("Failed to index CTF stream file \'%s\'", ds_file->file->path->str); } @@ -875,11 +885,12 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) GError *error = NULL; GDir *dir = NULL; bt_logging_level log_level = ctf_fs_trace->log_level; + bt_self_component *self_comp = ctf_fs_trace->self_comp; /* Check each file in the path directory, except specific ones */ dir = g_dir_open(ctf_fs_trace->path->str, 0, &error); if (!dir) { - BT_LOGE("Cannot open directory `%s`: %s (code %d)", + BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)", ctf_fs_trace->path->str, error->message, error->code); goto error; @@ -890,21 +901,21 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) { /* Ignore the metadata stream. */ - BT_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`", + BT_COMP_LOGI("Ignoring metadata file `%s" G_DIR_SEPARATOR_S "%s`", ctf_fs_trace->path->str, basename); continue; } if (basename[0] == '.') { - BT_LOGI("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`", + BT_COMP_LOGI("Ignoring hidden file `%s" G_DIR_SEPARATOR_S "%s`", ctf_fs_trace->path->str, basename); continue; } /* Create the file. */ - file = ctf_fs_file_create(log_level); + file = ctf_fs_file_create(log_level, self_comp); if (!file) { - BT_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`", + BT_COMP_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`", ctf_fs_trace->path->str, basename); goto error; } @@ -913,7 +924,7 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) g_string_append_printf(file->path, "%s" G_DIR_SEPARATOR_S "%s", ctf_fs_trace->path->str, basename); if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) { - BT_LOGI("Ignoring non-regular file `%s`", + BT_COMP_LOGI("Ignoring non-regular file `%s`", file->path->str); ctf_fs_file_destroy(file); file = NULL; @@ -922,13 +933,13 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) ret = ctf_fs_file_open(file, "rb"); if (ret) { - BT_LOGE("Cannot open stream file `%s`", file->path->str); + BT_COMP_LOGE("Cannot open stream file `%s`", file->path->str); goto error; } if (file->size == 0) { /* Skip empty stream. */ - BT_LOGI("Ignoring empty file `%s`", file->path->str); + BT_COMP_LOGI("Ignoring empty file `%s`", file->path->str); ctf_fs_file_destroy(file); continue; } @@ -936,7 +947,7 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) ret = add_ds_file_to_ds_file_group(ctf_fs_trace, file->path->str); if (ret) { - BT_LOGE("Cannot add stream file `%s` to stream file group", + BT_COMP_LOGE("Cannot add stream file `%s` to stream file group", file->path->str); ctf_fs_file_destroy(file); goto error; @@ -965,7 +976,7 @@ end: static int set_trace_name(bt_trace *trace, const char *name_suffix, - bt_logging_level log_level) + bt_logging_level log_level, bt_self_component *self_comp) { int ret = 0; const bt_trace_class *tc = bt_trace_borrow_class_const(trace); @@ -974,7 +985,7 @@ int set_trace_name(bt_trace *trace, const char *name_suffix, name = g_string_new(NULL); if (!name) { - BT_LOGE_STR("Failed to allocate a GString."); + BT_COMP_LOGE_STR("Failed to allocate a GString."); ret = -1; goto end; } @@ -1013,7 +1024,7 @@ end: } static -struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp, +struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp, const char *path, const char *name, struct ctf_fs_metadata_config *metadata_config, bt_logging_level log_level) @@ -1027,6 +1038,7 @@ struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp, } ctf_fs_trace->log_level = log_level; + ctf_fs_trace->self_comp = self_comp; ctf_fs_trace->path = g_string_new(path); if (!ctf_fs_trace->path) { goto error; @@ -1049,8 +1061,8 @@ struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp, goto error; } - ret = ctf_fs_metadata_set_trace_class(self_comp, - ctf_fs_trace, metadata_config); + ret = ctf_fs_metadata_set_trace_class(self_comp, ctf_fs_trace, + metadata_config); if (ret) { goto error; } @@ -1064,7 +1076,8 @@ struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component_source *self_comp, } if (ctf_fs_trace->trace) { - ret = set_trace_name(ctf_fs_trace->trace, name, log_level); + ret = set_trace_name(ctf_fs_trace->trace, name, log_level, + self_comp); if (ret) { goto error; } @@ -1110,21 +1123,21 @@ end: static int add_trace_path(GList **trace_paths, const char *path, - bt_logging_level log_level) + bt_logging_level log_level, bt_self_component *self_comp) { GString *norm_path = NULL; int ret = 0; norm_path = bt_common_normalize_path(path, NULL); if (!norm_path) { - BT_LOGE("Failed to normalize path `%s`.", path); + BT_COMP_LOGE("Failed to normalize path `%s`.", path); ret = -1; goto end; } // FIXME: Remove or ifdef for __MINGW32__ if (strcmp(norm_path->str, "/") == 0) { - BT_LOGE("Opening a trace in `/` is not supported."); + BT_COMP_LOGE("Opening a trace in `/` is not supported."); ret = -1; goto end; } @@ -1143,7 +1156,7 @@ end: static int ctf_fs_find_traces(GList **trace_paths, const char *start_path, - bt_logging_level log_level) + bt_logging_level log_level, bt_self_component *self_comp) { int ret; GError *error = NULL; @@ -1161,7 +1174,8 @@ int ctf_fs_find_traces(GList **trace_paths, const char *start_path, * Stop recursion: a CTF trace cannot contain another * CTF trace. */ - ret = add_trace_path(trace_paths, start_path, log_level); + ret = add_trace_path(trace_paths, start_path, log_level, + self_comp); goto end; } @@ -1174,12 +1188,12 @@ int ctf_fs_find_traces(GList **trace_paths, const char *start_path, dir = g_dir_open(start_path, 0, &error); if (!dir) { if (error->code == G_FILE_ERROR_ACCES) { - BT_LOGI("Cannot open directory `%s`: %s (code %d): continuing", + BT_COMP_LOGI("Cannot open directory `%s`: %s (code %d): continuing", start_path, error->message, error->code); goto end; } - BT_LOGE("Cannot open directory `%s`: %s (code %d)", + BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)", start_path, error->message, error->code); ret = -1; goto end; @@ -1195,7 +1209,7 @@ int ctf_fs_find_traces(GList **trace_paths, const char *start_path, g_string_printf(sub_path, "%s" G_DIR_SEPARATOR_S "%s", start_path, basename); ret = ctf_fs_find_traces(trace_paths, sub_path->str, - log_level); + log_level, self_comp); g_string_free(sub_path, TRUE); if (ret) { goto end; @@ -1270,7 +1284,7 @@ GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) { /* Helper for ctf_fs_component_create_ctf_fs_traces, to handle a single path/root. */ static -int ctf_fs_component_create_ctf_fs_traces_one_root(bt_self_component_source *self_comp, +int ctf_fs_component_create_ctf_fs_traces_one_root( struct ctf_fs_component *ctf_fs, const char *path_param) { @@ -1282,28 +1296,30 @@ int ctf_fs_component_create_ctf_fs_traces_one_root(bt_self_component_source *sel GList *tp_node; GList *tn_node; bt_logging_level log_level = ctf_fs->log_level; + bt_self_component *self_comp = ctf_fs->self_comp; norm_path = bt_common_normalize_path(path_param, NULL); if (!norm_path) { - BT_LOGE("Failed to normalize path: `%s`.", + BT_COMP_LOGE("Failed to normalize path: `%s`.", path_param); goto error; } - ret = ctf_fs_find_traces(&trace_paths, norm_path->str, log_level); + ret = ctf_fs_find_traces(&trace_paths, norm_path->str, log_level, + self_comp); if (ret) { goto error; } if (!trace_paths) { - BT_LOGE("No CTF traces recursively found in `%s`.", + BT_COMP_LOGE("No CTF traces recursively found in `%s`.", path_param); goto error; } trace_names = ctf_fs_create_trace_names(trace_paths, norm_path->str); if (!trace_names) { - BT_LOGE("Cannot create trace names from trace paths."); + BT_COMP_LOGE("Cannot create trace names from trace paths."); goto error; } @@ -1318,7 +1334,7 @@ int ctf_fs_component_create_ctf_fs_traces_one_root(bt_self_component_source *sel &ctf_fs->metadata_config, log_level); if (!ctf_fs_trace) { - BT_LOGE("Cannot create trace for `%s`.", + BT_COMP_LOGE("Cannot create trace for `%s`.", trace_path->str); goto error; } @@ -1510,7 +1526,8 @@ int merge_matching_ctf_fs_ds_file_groups( dest_trace->metadata->tc, src_group->sc->id); BT_ASSERT(sc); - index = ctf_fs_ds_index_create(dest_trace->log_level); + index = ctf_fs_ds_index_create(dest_trace->log_level, + dest_trace->self_comp); if (!index) { ret = -1; goto end; @@ -1682,7 +1699,8 @@ int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i); const char *path = bt_value_string_get(path_value); - ret = ctf_fs_component_create_ctf_fs_traces_one_root(self_comp, ctf_fs, path); + ret = ctf_fs_component_create_ctf_fs_traces_one_root(ctf_fs, + path); if (ret) { goto end; } @@ -1728,6 +1746,7 @@ int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) GString *name = NULL; guint i; bt_logging_level log_level = ctf_fs_trace->log_level; + bt_self_component *self_comp = ctf_fs_trace->self_comp; for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) { struct ctf_fs_ds_file_group *ds_file_group = @@ -1760,7 +1779,7 @@ int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) } if (!ds_file_group->stream) { - BT_LOGE("Cannot create stream for DS file group: " + BT_COMP_LOGE("Cannot create stream for DS file group: " "addr=%p, stream-name=\"%s\"", ds_file_group, name->str); goto error; @@ -1769,7 +1788,7 @@ int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) ret = bt_stream_set_name(ds_file_group->stream, name->str); if (ret) { - BT_LOGE("Cannot set stream's name: " + BT_COMP_LOGE("Cannot set stream's name: " "addr=%p, stream-name=\"%s\"", ds_file_group->stream, name->str); goto error; @@ -1806,15 +1825,16 @@ bool validate_paths_parameter(struct ctf_fs_component *ctf_fs, bt_value_type type; uint64_t i; bt_logging_level log_level = ctf_fs->log_level; + bt_self_component *self_comp = ctf_fs->self_comp; if (!paths) { - BT_LOGE("missing \"paths\" parameter"); + BT_COMP_LOGE("missing \"paths\" parameter"); goto error; } type = bt_value_get_type(paths); if (type != BT_VALUE_TYPE_ARRAY) { - BT_LOGE("`paths` parameter: expecting array value: type=%s", + BT_COMP_LOGE("`paths` parameter: expecting array value: type=%s", bt_common_value_type_string(type)); goto error; } @@ -1825,7 +1845,7 @@ bool validate_paths_parameter(struct ctf_fs_component *ctf_fs, elem = bt_value_array_borrow_element_by_index_const(paths, i); type = bt_value_get_type(elem); if (type != BT_VALUE_TYPE_STRING) { - BT_LOGE("`paths` parameter: expecting string value: index=%" PRIu64 ", type=%s", + BT_COMP_LOGE("`paths` parameter: expecting string value: index=%" PRIu64 ", type=%s", i, bt_common_value_type_string(type)); goto error; } @@ -1846,6 +1866,7 @@ bool read_src_fs_parameters(const bt_value *params, bool ret; const bt_value *value; bt_logging_level log_level = ctf_fs->log_level; + bt_self_component *self_comp = ctf_fs->self_comp; /* paths parameter */ *paths = bt_value_map_borrow_entry_value_const(params, "paths"); @@ -1858,7 +1879,7 @@ bool read_src_fs_parameters(const bt_value *params, "clock-class-offset-s"); if (value) { if (!bt_value_is_signed_integer(value)) { - BT_LOGE("clock-class-offset-s must be an integer"); + BT_COMP_LOGE("clock-class-offset-s must be an integer"); goto error; } ctf_fs->metadata_config.clock_class_offset_s = @@ -1870,7 +1891,7 @@ bool read_src_fs_parameters(const bt_value *params, "clock-class-offset-ns"); if (value) { if (!bt_value_is_signed_integer(value)) { - BT_LOGE("clock-class-offset-ns must be an integer"); + BT_COMP_LOGE("clock-class-offset-ns must be an integer"); goto error; } ctf_fs->metadata_config.clock_class_offset_ns = @@ -1900,7 +1921,7 @@ struct ctf_fs_component *ctf_fs_create( bt_self_component_source_as_self_component(self_comp_src); ctf_fs = ctf_fs_component_create(bt_component_get_logging_level( - bt_self_component_as_component(self_comp))); + bt_self_component_as_component(self_comp)), self_comp); if (!ctf_fs) { goto error; } @@ -1910,13 +1931,8 @@ struct ctf_fs_component *ctf_fs_create( } bt_self_component_set_data(self_comp, ctf_fs); - - /* - * We don't need to get a new reference here because as long as - * our private ctf_fs_component object exists, the containing - * private component should also exist. - */ - ctf_fs->self_comp = self_comp_src; + ctf_fs->self_comp = self_comp; + ctf_fs->self_comp_src = self_comp_src; if (ctf_fs_component_create_ctf_fs_traces(self_comp_src, ctf_fs, paths_value)) { goto error; diff --git a/src/plugins/ctf/fs-src/fs.h b/src/plugins/ctf/fs-src/fs.h index d4dec888..8819f018 100644 --- a/src/plugins/ctf/fs-src/fs.h +++ b/src/plugins/ctf/fs-src/fs.h @@ -41,6 +41,9 @@ extern bool ctf_fs_debug; struct ctf_fs_file { bt_logging_level log_level; + /* Weak */ + bt_self_component *self_comp; + /* Owned by this */ GString *path; @@ -72,7 +75,10 @@ struct ctf_fs_component { bt_logging_level log_level; /* Weak, guaranteed to exist */ - bt_self_component_source *self_comp; + bt_self_component_source *self_comp_src; + + /* Weak */ + bt_self_component *self_comp; /* Array of struct ctf_fs_port_data *, owned by this */ GPtrArray *port_data; @@ -86,6 +92,9 @@ struct ctf_fs_component { struct ctf_fs_trace { bt_logging_level log_level; + /* Weak */ + bt_self_component *self_comp; + /* Owned by this */ struct ctf_fs_metadata *metadata; @@ -176,6 +185,9 @@ struct ctf_fs_port_data { struct ctf_fs_msg_iter_data { bt_logging_level log_level; + /* Weak */ + bt_self_component *self_comp; + /* Weak */ bt_self_message_iterator *pc_msg_iter; @@ -230,7 +242,8 @@ bt_self_message_iterator_status ctf_fs_iterator_seek_beginning( /* Create and initialize a new, empty ctf_fs_component. */ BT_HIDDEN -struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level); +struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level, + bt_self_component *self_comp); /* * Search recursively under all paths in `paths_value` (an array of strings), diff --git a/src/plugins/ctf/fs-src/metadata.c b/src/plugins/ctf/fs-src/metadata.c index 403ed03d..94ff889a 100644 --- a/src/plugins/ctf/fs-src/metadata.c +++ b/src/plugins/ctf/fs-src/metadata.c @@ -23,9 +23,10 @@ * SOFTWARE. */ +#define BT_COMP_LOG_SELF_COMP self_comp #define BT_LOG_OUTPUT_LEVEL log_level #define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/META" -#include "logging/log.h" +#include "plugins/comp-logging.h" #include #include @@ -61,9 +62,9 @@ end: } static struct ctf_fs_file *get_file(const char *trace_path, - bt_logging_level log_level) + bt_logging_level log_level, bt_self_component *self_comp) { - struct ctf_fs_file *file = ctf_fs_file_create(log_level); + struct ctf_fs_file *file = ctf_fs_file_create(log_level, self_comp); if (!file) { goto error; @@ -90,7 +91,7 @@ end: BT_HIDDEN int ctf_fs_metadata_set_trace_class( - bt_self_component_source *self_comp, + bt_self_component *self_comp, struct ctf_fs_trace *ctf_fs_trace, struct ctf_fs_metadata_config *config) { @@ -98,15 +99,15 @@ int ctf_fs_metadata_set_trace_class( struct ctf_fs_file *file = NULL; struct ctf_metadata_decoder_config decoder_config = { .log_level = ctf_fs_trace->log_level, - .self_comp = bt_self_component_source_as_self_component(self_comp), + .self_comp = self_comp, .clock_class_offset_s = config ? config->clock_class_offset_s : 0, .clock_class_offset_ns = config ? config->clock_class_offset_ns : 0, }; bt_logging_level log_level = ctf_fs_trace->log_level; - file = get_file(ctf_fs_trace->path->str, log_level); + file = get_file(ctf_fs_trace->path->str, log_level, self_comp); if (!file) { - BT_LOGE("Cannot create metadata file object"); + BT_COMP_LOGE("Cannot create metadata file object"); ret = -1; goto end; } @@ -114,7 +115,7 @@ int ctf_fs_metadata_set_trace_class( ctf_fs_trace->metadata->decoder = ctf_metadata_decoder_create( &decoder_config); if (!ctf_fs_trace->metadata->decoder) { - BT_LOGE("Cannot create metadata decoder object"); + BT_COMP_LOGE("Cannot create metadata decoder object"); ret = -1; goto end; } @@ -122,7 +123,7 @@ int ctf_fs_metadata_set_trace_class( ret = ctf_metadata_decoder_decode(ctf_fs_trace->metadata->decoder, file->fp); if (ret) { - BT_LOGE("Cannot decode metadata file"); + BT_COMP_LOGE("Cannot decode metadata file"); goto end; } diff --git a/src/plugins/ctf/fs-src/metadata.h b/src/plugins/ctf/fs-src/metadata.h index 7af06182..a5d0986d 100644 --- a/src/plugins/ctf/fs-src/metadata.h +++ b/src/plugins/ctf/fs-src/metadata.h @@ -45,7 +45,7 @@ BT_HIDDEN void ctf_fs_metadata_fini(struct ctf_fs_metadata *metadata); BT_HIDDEN -int ctf_fs_metadata_set_trace_class(bt_self_component_source *self_comp, +int ctf_fs_metadata_set_trace_class(bt_self_component *self_comp, struct ctf_fs_trace *ctf_fs_trace, struct ctf_fs_metadata_config *config); diff --git a/src/plugins/ctf/fs-src/query.c b/src/plugins/ctf/fs-src/query.c index 6f78505b..a32f1bbd 100644 --- a/src/plugins/ctf/fs-src/query.c +++ b/src/plugins/ctf/fs-src/query.c @@ -489,7 +489,7 @@ bt_query_status trace_info_query( goto error; } - ctf_fs = ctf_fs_component_create(log_level); + ctf_fs = ctf_fs_component_create(log_level, NULL); if (!ctf_fs) { goto error; } -- 2.34.1