From d23b766e7b7542ddff2211264b4ece1f3a347773 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Tue, 13 Aug 2019 11:56:18 -0400 Subject: [PATCH] ctf: make src.ctf.fs append error causes This patch makes the src.ctf.fs plugin code append error causes whenever an error status is returned. A few new macros are added to comp-logging.h to support that. Some functions are called both in component context and component class context. When appending error causes, we need to call the function/macro for the right context. My solution to this is to pass both bt_self_component and bt_self_component_class pointers, but expect only one of them to be set. The new macro BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE takes care of calling the right function for whichever is set. Change-Id: I8d54f463d9a13066abdc140ef41f374e4daed303 Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/1966 Tested-by: jenkins Reviewed-by: Francis Deslauriers Reviewed-by: Philippe Proulx --- include/Makefile.am | 1 + include/babeltrace2/babeltrace.h | 1 + .../babeltrace2/graph/self-component-class.h | 47 ++++++ src/logging/comp-logging.h | 67 ++++++++ src/plugins/ctf/fs-src/fs.c | 159 ++++++++++-------- src/plugins/ctf/fs-src/fs.h | 22 ++- src/plugins/ctf/fs-src/query.c | 55 ++++-- 7 files changed, 260 insertions(+), 92 deletions(-) create mode 100644 include/babeltrace2/graph/self-component-class.h diff --git a/include/Makefile.am b/include/Makefile.am index 1033ec3b..3ff5c579 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -120,6 +120,7 @@ babeltrace2graphinclude_HEADERS = \ babeltrace2/graph/self-component-class-filter.h \ babeltrace2/graph/self-component-class-sink.h \ babeltrace2/graph/self-component-class-source.h \ + babeltrace2/graph/self-component-class.h \ babeltrace2/graph/self-component-filter.h \ babeltrace2/graph/self-component-port-input-message-iterator.h \ babeltrace2/graph/self-component-port-input.h \ diff --git a/include/babeltrace2/babeltrace.h b/include/babeltrace2/babeltrace.h index fd0bb7fa..ed17a864 100644 --- a/include/babeltrace2/babeltrace.h +++ b/include/babeltrace2/babeltrace.h @@ -95,6 +95,7 @@ #include #include #include +#include /* Component API */ #include diff --git a/include/babeltrace2/graph/self-component-class.h b/include/babeltrace2/graph/self-component-class.h new file mode 100644 index 00000000..7cdd441e --- /dev/null +++ b/include/babeltrace2/graph/self-component-class.h @@ -0,0 +1,47 @@ +#ifndef BABELTRACE2_GRAPH_SELF_COMPONENT_CLASS_H +#define BABELTRACE2_GRAPH_SELF_COMPONENT_CLASS_H + +/* + * Copyright (c) 2010-2019 EfficiOS Inc. and Linux Foundation + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef __BT_IN_BABELTRACE_H +# error "Please include instead." +#endif + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +static inline +const bt_component_class *bt_self_component_class_as_component_class( + bt_self_component_class *self_component_class) +{ + return __BT_UPCAST(bt_component_class, self_component_class); +} + +#ifdef __cplusplus +} +#endif + +#endif /* BABELTRACE2_GRAPH_SELF_COMPONENT_CLASS_H */ diff --git a/src/logging/comp-logging.h b/src/logging/comp-logging.h index 22e9bdae..aae775c5 100644 --- a/src/logging/comp-logging.h +++ b/src/logging/comp-logging.h @@ -43,6 +43,13 @@ _BT_COMP_LOG_COMP_NA_STR, \ ##__VA_ARGS__) +/* Logs with level `_lvl` for self component class `_self_comp_class` */ +#define BT_COMP_CLASS_LOG(_lvl, _self_comp_class, _fmt, ...) \ + BT_LOG_WRITE((_lvl), BT_LOG_TAG, _BT_COMP_LOG_COMP_PREFIX _fmt, \ + bt_component_class_get_name( \ + bt_self_component_class_as_component_class( \ + _self_comp_class)), ##__VA_ARGS__) + #define BT_COMP_LOG_CUR_LVL(_lvl, _cur_lvl, _self_comp, _fmt, ...) \ BT_LOG_WRITE_CUR_LVL((_lvl), (_cur_lvl), BT_LOG_TAG, \ _BT_COMP_LOG_COMP_PREFIX _fmt, \ @@ -131,4 +138,64 @@ #define BT_COMP_LOG_SUPPORTED +/* Logs and appends error cause from component context. */ +#define BT_COMP_LOG_APPEND_CAUSE(_self_comp, _lvl, _fmt, ...) \ + do { \ + BT_COMP_LOG(_lvl, _self_comp, _fmt, ##__VA_ARGS__); \ + (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT( \ + _self_comp, _fmt, ##__VA_ARGS__); \ + } while (0) + +/* Logs error and appends error cause from component context. */ +#define BT_COMP_LOGE_APPEND_CAUSE(_self_comp, _fmt, ...) \ + BT_COMP_LOG_APPEND_CAUSE(_self_comp, BT_LOG_ERROR, _fmt, ##__VA_ARGS__) + +/* Logs and appends error cause from component class context. */ +#define BT_COMP_CLASS_LOG_APPEND_CAUSE(_self_comp_class, _lvl, _fmt, ...) \ + do { \ + BT_COMP_CLASS_LOG(_lvl, _self_comp_class, _fmt, ##__VA_ARGS__); \ + (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT_CLASS( \ + _self_comp_class, _fmt, ##__VA_ARGS__); \ + } while (0) + +/* Logs error and appends error cause from component class context. */ +#define BT_COMP_CLASS_LOGE_APPEND_CAUSE(_self_comp_class, _fmt, ...) \ + BT_COMP_CLASS_LOG_APPEND_CAUSE(_self_comp_class, BT_LOG_ERROR, _fmt, ##__VA_ARGS__) + +/* + * Logs and appends error cause from component class context - the errno + * edition. + */ +#define BT_COMP_CLASS_LOG_APPEND_CAUSE_ERRNO(_self_comp_class, _lvl, _msg, _fmt, ...) \ + do { \ + const char *error_str = g_strerror(errno); \ + BT_COMP_CLASS_LOG(_lvl, _self_comp_class, _msg ": %s" _fmt, error_str, \ + ##__VA_ARGS__); \ + (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT_CLASS( \ + _self_comp_class, _msg ": %s" _fmt, error_str, ##__VA_ARGS__); \ + } while (0) + +/* + * Logs error and appends error cause from component class context - the errno + * edition. + */ +#define BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(_self_comp_class, _fmt, ...) \ + BT_COMP_CLASS_LOG_APPEND_CAUSE_ERRNO(_self_comp_class, BT_LOG_ERROR, _fmt, \ + ##__VA_ARGS__) + +/* + * Logs error and appends error cause from component or component class context, + * depending on whichever is set. + */ +#define BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(_self_comp, _self_comp_class, _fmt, ...) \ + do { \ + /* Only one of `_self_comp` and `_self_comp_class` must be set. */ \ + BT_ASSERT((!!(_self_comp) != (!!_self_comp_class))); \ + if (_self_comp) { \ + BT_COMP_LOGE_APPEND_CAUSE(_self_comp, _fmt, ##__VA_ARGS__); \ + } else { \ + BT_COMP_CLASS_LOGE_APPEND_CAUSE(_self_comp_class, _fmt, ##__VA_ARGS__); \ + } \ + } while (0) + #endif /* BABELTRACE_LOGGING_COMP_LOGGING_H */ diff --git a/src/plugins/ctf/fs-src/fs.c b/src/plugins/ctf/fs-src/fs.c index 8036fe15..24209943 100644 --- a/src/plugins/ctf/fs-src/fs.c +++ b/src/plugins/ctf/fs-src/fs.c @@ -258,14 +258,14 @@ bt_component_class_message_iterator_init_method_status ctf_fs_iterator_init( bt_component_class_message_iterator_init_method_status ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_OK; bt_logging_level log_level; - bt_self_component *self_comp; + bt_self_component *self_comp = + bt_self_component_source_as_self_component(self_comp_src); 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_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_MEMORY_ERROR; @@ -281,7 +281,7 @@ bt_component_class_message_iterator_init_method_status ctf_fs_iterator_init( ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level, self_comp); if (!msg_iter_data->msg_iter) { - BT_COMP_LOGE_STR("Cannot create a CTF message iterator."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create a CTF message iterator."); ret = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_INIT_METHOD_STATUS_MEMORY_ERROR; goto error; } @@ -389,7 +389,6 @@ 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) { @@ -465,13 +464,15 @@ gchar *ctf_fs_make_port_name(struct ctf_fs_ds_file_group *ds_file_group) static int create_one_port_for_trace(struct ctf_fs_component *ctf_fs, struct ctf_fs_trace *ctf_fs_trace, - struct ctf_fs_ds_file_group *ds_file_group) + struct ctf_fs_ds_file_group *ds_file_group, + bt_self_component_source *self_comp_src) { int ret = 0; 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; + bt_self_component *self_comp = + bt_self_component_source_as_self_component(self_comp_src); port_name = ctf_fs_make_port_name(ds_file_group); if (!port_name) { @@ -489,7 +490,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_src, port_name, port_data, NULL); + self_comp_src, port_name, port_data, NULL); if (ret) { goto error; } @@ -510,12 +511,14 @@ end: static int create_ports_for_trace(struct ctf_fs_component *ctf_fs, - struct ctf_fs_trace *ctf_fs_trace) + struct ctf_fs_trace *ctf_fs_trace, + bt_self_component_source *self_comp_src) { 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; + bt_self_component *self_comp = + bt_self_component_source_as_self_component(self_comp_src); /* Create one output port for each stream file group */ for (i = 0; i < ctf_fs_trace->ds_file_groups->len; i++) { @@ -523,9 +526,9 @@ int create_ports_for_trace(struct ctf_fs_component *ctf_fs, g_ptr_array_index(ctf_fs_trace->ds_file_groups, i); ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace, - ds_file_group); + ds_file_group, self_comp_src); if (ret) { - BT_COMP_LOGE("Cannot create output port."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create output port."); goto end; } } @@ -731,7 +734,8 @@ 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_COMP_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot get stream file's first packet's header and context fields (`%s`).", path); goto error; } @@ -749,7 +753,8 @@ 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_COMP_LOGE("Cannot convert clock cycles to nanoseconds from origin (`%s`).", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot convert clock cycles to nanoseconds from origin (`%s`).", path); goto error; } @@ -864,7 +869,7 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) /* Check each file in the path directory, except specific ones */ dir = g_dir_open(ctf_fs_trace->path->str, 0, &error); if (!dir) { - BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open directory `%s`: %s (code %d)", ctf_fs_trace->path->str, error->message, error->code); goto error; @@ -889,7 +894,8 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) /* Create the file. */ file = ctf_fs_file_create(log_level, self_comp); if (!file) { - BT_COMP_LOGE("Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot create stream file object for file `%s" G_DIR_SEPARATOR_S "%s`", ctf_fs_trace->path->str, basename); goto error; } @@ -907,7 +913,8 @@ int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) ret = ctf_fs_file_open(file, "rb"); if (ret) { - BT_COMP_LOGE("Cannot open stream file `%s`", file->path->str); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open stream file `%s`", + file->path->str); goto error; } @@ -921,7 +928,8 @@ 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_COMP_LOGE("Cannot add stream file `%s` to stream file group", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot add stream file `%s` to stream file group", file->path->str); ctf_fs_file_destroy(file); goto error; @@ -1109,14 +1117,14 @@ int add_trace_path(GList **trace_paths, const char *path, norm_path = bt_common_normalize_path(path, NULL); if (!norm_path) { - BT_COMP_LOGE("Failed to normalize path `%s`.", path); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to normalize path `%s`.", path); ret = -1; goto end; } // FIXME: Remove or ifdef for __MINGW32__ if (strcmp(norm_path->str, "/") == 0) { - BT_COMP_LOGE("Opening a trace in `/` is not supported."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Opening a trace in `/` is not supported."); ret = -1; goto end; } @@ -1172,7 +1180,7 @@ int ctf_fs_find_traces(GList **trace_paths, const char *start_path, goto end; } - BT_COMP_LOGE("Cannot open directory `%s`: %s (code %d)", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot open directory `%s`: %s (code %d)", start_path, error->message, error->code); ret = -1; goto end; @@ -1265,7 +1273,9 @@ GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) { static int ctf_fs_component_create_ctf_fs_traces_one_root( struct ctf_fs_component *ctf_fs, - const char *path_param) + const char *path_param, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { struct ctf_fs_trace *ctf_fs_trace = NULL; int ret = 0; @@ -1275,12 +1285,11 @@ int ctf_fs_component_create_ctf_fs_traces_one_root( 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_COMP_LOGE("Failed to normalize path: `%s`.", - path_param); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to normalize path: `%s`.", path_param); goto error; } @@ -1291,17 +1300,15 @@ int ctf_fs_component_create_ctf_fs_traces_one_root( } if (!trace_paths) { - BT_COMP_LOGE("No CTF traces recursively found in `%s`.", - path_param); - (void) BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT( - ctf_fs->self_comp, + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, "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_COMP_LOGE("Cannot create trace names from trace paths."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot create trace names from trace paths."); goto error; } @@ -1316,7 +1323,7 @@ int ctf_fs_component_create_ctf_fs_traces_one_root( &ctf_fs->metadata_config, log_level); if (!ctf_fs_trace) { - BT_COMP_LOGE("Cannot create trace for `%s`.", + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create trace for `%s`.", trace_path->str); goto error; } @@ -1707,7 +1714,7 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, ds_file = ctf_fs_ds_file_create(ctf_fs_trace, NULL, msg_iter, NULL, index_entry->path, log_level); if (!ds_file) { - BT_LOGE_STR("Failed to create a ctf_fs_ds_file"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create a ctf_fs_ds_file"); ret = -1; goto end; } @@ -1754,7 +1761,8 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, default_cc->frequency, default_cc->offset_seconds, default_cc->offset_cycles, ts_ns); if (ret) { - BT_LOGE_STR("Failed to convert clock snapshot to timestamp"); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to convert clock snapshot to timestamp"); goto end; } @@ -1868,7 +1876,8 @@ int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace) last_entry, &last_entry->timestamp_end, &last_entry->timestamp_end_ns); if (ret) { - BT_LOGE_STR("Failed to decode stream's last packet to get its last event's clock snapshot."); + BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp, + "Failed to decode stream's last packet to get its last event's clock snapshot."); goto end; } } @@ -1932,7 +1941,8 @@ int fix_index_barectf_event_before_packet_bug(struct ctf_fs_trace *trace) curr_entry, &curr_entry->timestamp_begin, &curr_entry->timestamp_begin_ns); if (ret) { - BT_LOGE_STR("Failed to decode first event's clock snapshot"); + BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp, + "Failed to decode first event's clock snapshot"); goto end; } @@ -2010,7 +2020,8 @@ int fix_index_lttng_crash_quirk(struct ctf_fs_trace *trace) &last_entry->timestamp_end, &last_entry->timestamp_end_ns); if (ret) { - BT_LOGE_STR("Failed to decode last event's clock snapshot"); + BT_COMP_LOGE_APPEND_CAUSE(trace->self_comp, + "Failed to decode last event's clock snapshot"); goto end; } } @@ -2196,7 +2207,8 @@ bool is_tracer_affected_by_lttng_crash_quirk( * produced earlier. */ static -int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs) +int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs, + bt_self_component *self_comp) { int ret = 0; guint trace_i; @@ -2232,7 +2244,8 @@ int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs) BT_LOGI_STR("Trace may be affected by LTTng tracer packet timestamp bug. Fixing up."); ret = fix_index_lttng_event_after_packet_bug(trace); if (ret) { - BT_LOGE_STR("Failed to fix LTTng event-after-packet bug."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to fix LTTng event-after-packet bug."); goto end; } trace->metadata->tc->quirks.lttng_event_after_packet = true; @@ -2243,7 +2256,8 @@ int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs) BT_LOGI_STR("Trace may be affected by barectf tracer packet timestamp bug. Fixing up."); ret = fix_index_barectf_event_before_packet_bug(trace); if (ret) { - BT_LOGE_STR("Failed to fix barectf event-before-packet bug."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to fix barectf event-before-packet bug."); goto end; } trace->metadata->tc->quirks.barectf_event_before_packet = true; @@ -2253,7 +2267,8 @@ int fix_packet_index_tracer_bugs(struct ctf_fs_component *ctf_fs) ¤t_tracer_info)) { ret = fix_index_lttng_crash_quirk(trace); if (ret) { - BT_LOGE_STR("Failed to fix lttng-crash timestamp quirks."); + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Failed to fix lttng-crash timestamp quirks."); goto end; } trace->metadata->tc->quirks.lttng_crash = true; @@ -2263,9 +2278,11 @@ end: return ret; } -int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, +int ctf_fs_component_create_ctf_fs_traces( struct ctf_fs_component *ctf_fs, - const bt_value *paths_value) + const bt_value *paths_value, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { int ret = 0; uint64_t i; @@ -2276,7 +2293,7 @@ int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, const char *input = bt_value_string_get(path_value); ret = ctf_fs_component_create_ctf_fs_traces_one_root(ctf_fs, - input); + input, self_comp, self_comp_class); if (ret) { goto end; } @@ -2284,12 +2301,14 @@ int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, ret = merge_traces_with_same_uuid(ctf_fs); if (ret) { - BT_LOGE_STR("Failed to merge traces with the same UUID."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to merge traces with the same UUID."); } - ret = fix_packet_index_tracer_bugs(ctf_fs); + ret = fix_packet_index_tracer_bugs(ctf_fs, self_comp); if (ret) { - BT_LOGE_STR("Failed to fix packet index tracer bugs."); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "Failed to fix packet index tracer bugs."); } end: return ret; @@ -2362,7 +2381,8 @@ int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) } if (!ds_file_group->stream) { - BT_COMP_LOGE("Cannot create stream for DS file group: " + BT_COMP_LOGE_APPEND_CAUSE(self_comp, + "Cannot create stream for DS file group: " "addr=%p, stream-name=\"%s\"", ds_file_group, name->str); goto error; @@ -2371,7 +2391,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_COMP_LOGE("Cannot set stream's name: " + BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot set stream's name: " "addr=%p, stream-name=\"%s\"", ds_file_group->stream, name->str); goto error; @@ -2402,22 +2422,24 @@ end: static bool validate_inputs_parameter(struct ctf_fs_component *ctf_fs, - const bt_value *inputs) + const bt_value *inputs, bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { bool ret; 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 (!inputs) { - BT_COMP_LOGE("missing \"inputs\" parameter"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "missing \"inputs\" parameter"); goto error; } type = bt_value_get_type(inputs); if (type != BT_VALUE_TYPE_ARRAY) { - BT_COMP_LOGE("`inputs` parameter: expecting array value: type=%s", + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, + self_comp_class, "`inputs` parameter: expecting array value: type=%s", bt_common_value_type_string(type)); goto error; } @@ -2428,7 +2450,8 @@ bool validate_inputs_parameter(struct ctf_fs_component *ctf_fs, elem = bt_value_array_borrow_element_by_index_const(inputs, i); type = bt_value_get_type(elem); if (type != BT_VALUE_TYPE_STRING) { - BT_COMP_LOGE("`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s", + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "`inputs` parameter: expecting string value: index=%" PRIu64 ", type=%s", i, bt_common_value_type_string(type)); goto error; } @@ -2445,15 +2468,16 @@ end: } bool read_src_fs_parameters(const bt_value *params, - const bt_value **inputs, struct ctf_fs_component *ctf_fs) { + const bt_value **inputs, struct ctf_fs_component *ctf_fs, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class) { bool ret; const bt_value *value; bt_logging_level log_level = ctf_fs->log_level; - bt_self_component *self_comp = ctf_fs->self_comp; /* inputs parameter */ *inputs = bt_value_map_borrow_entry_value_const(params, "inputs"); - if (!validate_inputs_parameter(ctf_fs, *inputs)) { + if (!validate_inputs_parameter(ctf_fs, *inputs, self_comp, self_comp_class)) { goto error; } @@ -2462,7 +2486,8 @@ bool read_src_fs_parameters(const bt_value *params, "clock-class-offset-s"); if (value) { if (!bt_value_is_signed_integer(value)) { - BT_COMP_LOGE("clock-class-offset-s must be an integer"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "clock-class-offset-s must be an integer"); goto error; } ctf_fs->metadata_config.clock_class_offset_s = @@ -2474,7 +2499,8 @@ bool read_src_fs_parameters(const bt_value *params, "clock-class-offset-ns"); if (value) { if (!bt_value_is_signed_integer(value)) { - BT_COMP_LOGE("clock-class-offset-ns must be an integer"); + BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, + "clock-class-offset-ns must be an integer"); goto error; } ctf_fs->metadata_config.clock_class_offset_ns = @@ -2494,8 +2520,9 @@ end: static struct ctf_fs_component *ctf_fs_create( - bt_self_component_source *self_comp_src, - const bt_value *params) + const bt_value *params, + bt_self_component_source *self_comp_src, + bt_self_component_class *self_comp_class) { struct ctf_fs_component *ctf_fs = NULL; guint i; @@ -2509,15 +2536,15 @@ struct ctf_fs_component *ctf_fs_create( goto error; } - if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) { + if (!read_src_fs_parameters(params, &inputs_value, ctf_fs, + self_comp, self_comp_class)) { goto error; } bt_self_component_set_data(self_comp, ctf_fs); - 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, inputs_value)) { + if (ctf_fs_component_create_ctf_fs_traces(ctf_fs, inputs_value, + self_comp, self_comp_class)) { goto error; } @@ -2528,7 +2555,7 @@ struct ctf_fs_component *ctf_fs_create( goto error; } - if (create_ports_for_trace(ctf_fs, trace)) { + if (create_ports_for_trace(ctf_fs, trace, self_comp_src)) { goto error; } } @@ -2546,14 +2573,14 @@ end: BT_HIDDEN bt_component_class_init_method_status ctf_fs_init( - bt_self_component_source *self_comp, + bt_self_component_source *self_comp_src, const bt_value *params, __attribute__((unused)) void *init_method_data) { struct ctf_fs_component *ctf_fs; bt_component_class_init_method_status ret = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_OK; - ctf_fs = ctf_fs_create(self_comp, params); + ctf_fs = ctf_fs_create(params, self_comp_src, NULL); if (!ctf_fs) { ret = BT_COMPONENT_CLASS_INIT_METHOD_STATUS_ERROR; } diff --git a/src/plugins/ctf/fs-src/fs.h b/src/plugins/ctf/fs-src/fs.h index 5ba3d571..4c0aa2ef 100644 --- a/src/plugins/ctf/fs-src/fs.h +++ b/src/plugins/ctf/fs-src/fs.h @@ -72,12 +72,6 @@ struct ctf_fs_metadata { struct ctf_fs_component { bt_logging_level log_level; - /* Weak, guaranteed to exist */ - 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; @@ -249,12 +243,17 @@ struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level, * Search recursively under all paths in `paths_value` (an array of strings), * for CTF traces. For each CTF trace found, create a ctf_fs_trace in * `ctf_fs` representing that trace. + * + * `self_comp` and `self_comp_class` are used for logging, only one of them + * should be set. */ BT_HIDDEN -int ctf_fs_component_create_ctf_fs_traces(bt_self_component_source *self_comp, +int ctf_fs_component_create_ctf_fs_traces( struct ctf_fs_component *ctf_fs, - const bt_value *paths_value); + const bt_value *paths_value, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class); /* Free `ctf_fs` and everything it owns. */ @@ -268,12 +267,17 @@ void ctf_fs_destroy(struct ctf_fs_component *ctf_fs); * - The optional `clock-class-offset-s` and `clock-class-offset-ns`, if * present, are recorded in the `ctf_fs` structure. * + * `self_comp` and `self_comp_class` are used for logging, only one of them + * should be set. + * * Return true on success, false if any parameter didn't pass validation. */ BT_HIDDEN bool read_src_fs_parameters(const bt_value *params, - const bt_value **paths, struct ctf_fs_component *ctf_fs); + const bt_value **paths, struct ctf_fs_component *ctf_fs, + bt_self_component *self_comp, + bt_self_component_class *self_comp_class); /* * Generate the port name to be used for a given data stream file group. diff --git a/src/plugins/ctf/fs-src/query.c b/src/plugins/ctf/fs-src/query.c index b2e5248d..e69699c2 100644 --- a/src/plugins/ctf/fs-src/query.c +++ b/src/plugins/ctf/fs-src/query.c @@ -37,6 +37,7 @@ #include "common/macros.h" #include #include "fs.h" +#include "logging/comp-logging.h" #define METADATA_TEXT_SIG "/* CTF 1.8" @@ -48,12 +49,14 @@ struct range { BT_HIDDEN bt_component_class_query_method_status metadata_info_query( - bt_self_component_class_source *comp_class, + bt_self_component_class_source *self_comp_class_src, const bt_value *params, bt_logging_level log_level, const bt_value **user_result) { bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; + bt_self_component_class *self_comp_class = + bt_self_component_class_source_as_self_component_class(self_comp_class_src); bt_value *result = NULL; const bt_value *path_value = NULL; char *metadata_text = NULL; @@ -73,20 +76,23 @@ bt_component_class_query_method_status metadata_info_query( BT_ASSERT(params); if (!bt_value_is_map(params)) { - BT_LOGE_STR("Query parameters is not a map value object."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Query parameters is not a map value object."); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } path_value = bt_value_map_borrow_entry_value_const(params, "path"); if (!path_value) { - BT_LOGE_STR("Mandatory `path` parameter missing"); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Mandatory `path` parameter missing"); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } if (!bt_value_is_string(path_value)) { - BT_LOGE_STR("`path` parameter is required to be a string value"); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "`path` parameter is required to be a string value"); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } @@ -96,7 +102,8 @@ bt_component_class_query_method_status metadata_info_query( BT_ASSERT(path); metadata_fp = ctf_fs_metadata_open_file(path); if (!metadata_fp) { - BT_LOGE("Cannot open trace metadata: path=\"%s\".", path); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Cannot open trace metadata: path=\"%s\".", path); goto error; } @@ -108,7 +115,8 @@ bt_component_class_query_method_status metadata_info_query( metadata_fp, &metadata_text, bo, NULL, NULL, log_level, NULL); if (ret) { - BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"", + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Cannot decode packetized metadata file: path=\"%s\"", path); goto error; } @@ -117,25 +125,29 @@ bt_component_class_query_method_status metadata_info_query( ret = fseek(metadata_fp, 0, SEEK_END); if (ret) { - BT_LOGE_ERRNO("Failed to seek to the end of the metadata file", + BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(self_comp_class, + "Failed to seek to the end of the metadata file", ": path=\"%s\"", path); goto error; } filesize = ftell(metadata_fp); if (filesize < 0) { - BT_LOGE_ERRNO("Failed to get the current position in the metadata file", + BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(self_comp_class, + "Failed to get the current position in the metadata file", ": path=\"%s\"", path); goto error; } rewind(metadata_fp); metadata_text = malloc(filesize + 1); if (!metadata_text) { - BT_LOGE_STR("Cannot allocate buffer for metadata text."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Cannot allocate buffer for metadata text."); goto error; } if (fread(metadata_text, filesize, 1, metadata_fp) != 1) { - BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"", + BT_COMP_CLASS_LOGE_APPEND_CAUSE_ERRNO(self_comp_class, + "Cannot read metadata file", ": path=\"%s\"", path); goto error; } @@ -159,14 +171,16 @@ bt_component_class_query_method_status metadata_info_query( ret = bt_value_map_insert_string_entry(result, "text", g_metadata_text->str); if (ret) { - BT_LOGE_STR("Cannot insert metadata text into query result."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Cannot insert metadata text into query result."); goto error; } ret = bt_value_map_insert_bool_entry(result, "is-packetized", is_packetized); if (ret) { - BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Cannot insert \"is-packetized\" attribute into query result."); goto error; } @@ -476,13 +490,16 @@ end: BT_HIDDEN bt_component_class_query_method_status trace_info_query( - bt_self_component_class_source *comp_class, + bt_self_component_class_source *self_comp_class_src, const bt_value *params, bt_logging_level log_level, const bt_value **user_result) { struct ctf_fs_component *ctf_fs = NULL; bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; + bt_self_component_class *self_comp_class = + bt_self_component_class_source_as_self_component_class( + self_comp_class_src); bt_value *result = NULL; const bt_value *inputs_value = NULL; int ret = 0; @@ -491,7 +508,8 @@ bt_component_class_query_method_status trace_info_query( BT_ASSERT(params); if (!bt_value_is_map(params)) { - BT_LOGE("Query parameters is not a map value object."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Query parameters is not a map value object."); status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } @@ -501,12 +519,14 @@ bt_component_class_query_method_status trace_info_query( goto error; } - if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) { + if (!read_src_fs_parameters(params, &inputs_value, ctf_fs, NULL, + self_comp_class)) { status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; goto error; } - if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, inputs_value)) { + if (ctf_fs_component_create_ctf_fs_traces(ctf_fs, inputs_value, NULL, + self_comp_class)) { goto error; } @@ -526,7 +546,8 @@ bt_component_class_query_method_status trace_info_query( trace_info = bt_value_map_create(); if (!trace_info) { - BT_LOGE("Failed to create trace info map."); + BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class, + "Failed to create trace info map."); goto error; } -- 2.34.1