From 032fc0ad474c4c826089f385d6ae49dde54f6ee8 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Tue, 9 Apr 2024 17:10:11 -0400 Subject: [PATCH] src.ctf.fs: fs.cpp: declare variables on first use Move variable declarations to be at or closer to their first use. Change-Id: Iec7b1789a9cd007938b992292ad48a09d23f79e5 Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/8403 Reviewed-by: Philippe Proulx Reviewed-on: https://review.lttng.org/c/babeltrace/+/12346 Tested-by: jenkins --- src/plugins/ctf/fs-src/fs.cpp | 113 +++++++++++++--------------------- 1 file changed, 43 insertions(+), 70 deletions(-) diff --git a/src/plugins/ctf/fs-src/fs.cpp b/src/plugins/ctf/fs-src/fs.cpp index 26ec1539..6a963942 100644 --- a/src/plugins/ctf/fs-src/fs.cpp +++ b/src/plugins/ctf/fs-src/fs.cpp @@ -40,9 +40,9 @@ struct tracer_info static bt_message_iterator_class_next_method_status ctf_fs_iterator_next_one(struct ctf_fs_msg_iter_data *msg_iter_data, const bt_message **out_msg) { - bt_message_iterator_class_next_method_status status; const auto msg_iter_status = ctf_msg_iter_get_next_message(msg_iter_data->msg_iter.get(), out_msg); + bt_message_iterator_class_next_method_status status; switch (msg_iter_status) { case CTF_MSG_ITER_STATUS_OK: @@ -88,7 +88,6 @@ ctf_fs_iterator_next(bt_self_message_iterator *iterator, bt_message_array_const try { struct ctf_fs_msg_iter_data *msg_iter_data = (struct ctf_fs_msg_iter_data *) bt_self_message_iterator_get_data(iterator); - uint64_t i = 0; if (G_UNLIKELY(msg_iter_data->next_saved_error)) { /* @@ -101,6 +100,7 @@ ctf_fs_iterator_next(bt_self_message_iterator *iterator, bt_message_array_const } bt_message_iterator_class_next_method_status status; + uint64_t i = 0; do { status = ctf_fs_iterator_next_one(msg_iter_data, &msgs[i]); @@ -195,19 +195,16 @@ ctf_fs_iterator_init(bt_self_message_iterator *self_msg_iter, bt_self_component_port_output *self_port) { try { - struct ctf_fs_port_data *port_data; - enum ctf_msg_iter_medium_status medium_status; - - port_data = (struct ctf_fs_port_data *) bt_self_component_port_get_data( + ctf_fs_port_data *port_data = (struct ctf_fs_port_data *) bt_self_component_port_get_data( bt_self_component_port_output_as_self_component_port(self_port)); BT_ASSERT(port_data); auto msg_iter_data = bt2s::make_unique(self_msg_iter); msg_iter_data->ds_file_group = port_data->ds_file_group; - medium_status = ctf_fs_ds_group_medops_data_create(msg_iter_data->ds_file_group, - self_msg_iter, msg_iter_data->logger, - msg_iter_data->msg_iter_medops_data); + ctf_msg_iter_medium_status medium_status = ctf_fs_ds_group_medops_data_create( + msg_iter_data->ds_file_group, self_msg_iter, msg_iter_data->logger, + msg_iter_data->msg_iter_medops_data); BT_ASSERT(medium_status == CTF_MSG_ITER_MEDIUM_STATUS_OK || medium_status == CTF_MSG_ITER_MEDIUM_STATUS_ERROR || medium_status == CTF_MSG_ITER_MEDIUM_STATUS_MEMORY_ERROR); @@ -415,15 +412,6 @@ static void merge_ctf_fs_ds_indexes(struct ctf_fs_ds_index *dest, const ctf_fs_d static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const char *path) { - int64_t stream_instance_id = -1; - int64_t begin_ns = -1; - struct ctf_fs_ds_file_group *ds_file_group = NULL; - ctf_fs_ds_file_group::UP new_ds_file_group; - ctf_fs_ds_file_info::UP ds_file_info; - ctf_msg_iter_up msg_iter; - struct ctf_stream_class *sc = NULL; - struct ctf_msg_iter_packet_properties props; - /* * Create a temporary ds_file to read some properties about the data * stream file. @@ -435,7 +423,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const } /* Create a temporary iterator to read the ds_file. */ - msg_iter = ctf_msg_iter_create( + ctf_msg_iter_up msg_iter = ctf_msg_iter_create( ctf_fs_trace->metadata->tc, bt_common_get_page_size(static_cast(ctf_fs_trace->logger.level())) * 8, ctf_fs_ds_file_medops, ds_file.get(), nullptr, ctf_fs_trace->logger); @@ -446,6 +434,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const ctf_msg_iter_set_dry_run(msg_iter.get(), true); + ctf_msg_iter_packet_properties props; int ret = ctf_msg_iter_get_packet_properties(msg_iter.get(), &props); if (ret) { BT_CPPLOGE_APPEND_CAUSE_SPEC( @@ -454,9 +443,11 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const return ret; } - sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc, props.stream_class_id); + ctf_stream_class *sc = + ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc, props.stream_class_id); BT_ASSERT(sc); - stream_instance_id = props.data_stream_id; + int64_t stream_instance_id = props.data_stream_id; + int64_t begin_ns = -1; if (props.snapshots.beginning_clock != UINT64_C(-1)) { BT_ASSERT(sc->default_clock_class); @@ -472,7 +463,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const } } - ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns); + ctf_fs_ds_file_info::UP ds_file_info = ctf_fs_ds_file_info_create(path, begin_ns); if (!ds_file_info) { return -1; } @@ -501,7 +492,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const * there's no timestamp to order the file within its * group. */ - new_ds_file_group = + auto new_ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace, sc, UINT64_C(-1), std::move(*index)); if (!new_ds_file_group) { @@ -517,6 +508,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const BT_ASSERT(begin_ns != -1); /* Find an existing stream file group with this ID */ + ctf_fs_ds_file_group *ds_file_group = NULL; for (const auto& candidate : ctf_fs_trace->ds_file_groups) { if (candidate->sc == sc && candidate->stream_id == stream_instance_id) { ds_file_group = candidate.get(); @@ -524,6 +516,8 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const } } + ctf_fs_ds_file_group::UP new_ds_file_group; + if (!ds_file_group) { new_ds_file_group = ctf_fs_ds_file_group_create(ctf_fs_trace, sc, stream_instance_id, std::move(*index)); @@ -544,10 +538,8 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) { - const char *basename; - GError *error = NULL; - /* Check each file in the path directory, except specific ones */ + GError *error = NULL; const bt2c::GDirUP dir {g_dir_open(ctf_fs_trace->path.c_str(), 0, &error)}; if (!dir) { BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs_trace->logger, @@ -559,7 +551,7 @@ static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) return -1; } - while ((basename = g_dir_read_name(dir.get()))) { + while (const char *basename = g_dir_read_name(dir.get())) { if (strcmp(basename, CTF_FS_METADATA_FILENAME) == 0) { /* Ignore the metadata stream. */ BT_CPPLOGI_SPEC(ctf_fs_trace->logger, @@ -613,14 +605,13 @@ static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) static int set_trace_name(bt_trace *trace, const char *name_suffix) { - const bt_value *val; std::string name; /* * Check if we have a trace environment string value named `hostname`. * If so, use it as the trace name's prefix. */ - val = bt_trace_borrow_environment_entry_value_by_name_const(trace, "hostname"); + const bt_value *val = bt_trace_borrow_environment_entry_value_by_name_const(trace, "hostname"); if (val && bt_value_is_string(val)) { name += bt_value_string_get(val); @@ -694,16 +685,13 @@ static int ctf_fs_component_create_ctf_fs_trace_one_path(struct ctf_fs_component std::vector& traces, bt_self_component *selfComp) { - ctf_fs_trace::UP ctf_fs_trace; - int ret; - bt2c::GStringUP norm_path {bt_common_normalize_path(path_param, NULL)}; if (!norm_path) { BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs->logger, "Failed to normalize path: `{}`.", path_param); return -1; } - ret = path_is_ctf_trace(norm_path->str); + int ret = path_is_ctf_trace(norm_path->str); if (ret < 0) { BT_CPPLOGE_APPEND_CAUSE_SPEC( ctf_fs->logger, "Failed to check if path is a CTF trace: path={}", norm_path->str); @@ -721,8 +709,8 @@ static int ctf_fs_component_create_ctf_fs_trace_one_path(struct ctf_fs_component return -1; } - ctf_fs_trace = ctf_fs_trace_create(norm_path->str, trace_name, ctf_fs->clkClsCfg, selfComp, - ctf_fs->logger); + ctf_fs_trace::UP ctf_fs_trace = ctf_fs_trace_create( + norm_path->str, trace_name, ctf_fs->clkClsCfg, selfComp, ctf_fs->logger); if (!ctf_fs_trace) { BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs->logger, "Cannot create trace for `{}`.", norm_path->str); @@ -746,9 +734,8 @@ static int ctf_fs_component_create_ctf_fs_trace_one_path(struct ctf_fs_component static unsigned int metadata_count_stream_and_event_classes(struct ctf_fs_trace *trace) { unsigned int num = trace->metadata->tc->stream_classes->len; - guint i; - for (i = 0; i < trace->metadata->tc->stream_classes->len; i++) { + for (guint i = 0; i < trace->metadata->tc->stream_classes->len; i++) { struct ctf_stream_class *sc = (struct ctf_stream_class *) trace->metadata->tc->stream_classes->pdata[i]; num += sc->event_classes->len; @@ -824,10 +811,8 @@ static int merge_matching_ctf_fs_ds_file_groups(struct ctf_fs_trace *dest_trace, * trace chunk. */ if (!dest_group) { - struct ctf_stream_class *sc; - - sc = ctf_trace_class_borrow_stream_class_by_id(dest_trace->metadata->tc, - src_group->sc->id); + ctf_stream_class *sc = ctf_trace_class_borrow_stream_class_by_id( + dest_trace->metadata->tc, src_group->sc->id); BT_ASSERT(sc); auto new_dest_group = @@ -859,18 +844,14 @@ static int merge_matching_ctf_fs_ds_file_groups(struct ctf_fs_trace *dest_trace, static int merge_ctf_fs_traces(std::vector traces, ctf_fs_trace::UP& out_trace) { - unsigned int winner_count; - struct ctf_fs_trace *winner; - guint i, winner_i; - BT_ASSERT(traces.size() >= 2); - winner_count = metadata_count_stream_and_event_classes(traces[0].get()); - winner = traces[0].get(); - winner_i = 0; + unsigned int winner_count = metadata_count_stream_and_event_classes(traces[0].get()); + ctf_fs_trace *winner = traces[0].get(); + guint winner_i = 0; /* Find the trace with the largest metadata. */ - for (i = 1; i < traces.size(); i++) { + for (guint i = 1; i < traces.size(); i++) { ctf_fs_trace *candidate = traces[i].get(); unsigned int candidate_count; @@ -920,9 +901,6 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, enum target_event target_event, uint64_t *cs, int64_t *ts_ns) { - enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK; - ctf_msg_iter_up msg_iter; - BT_ASSERT(ctf_fs_trace); BT_ASSERT(index_entry.path); @@ -936,9 +914,10 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, BT_ASSERT(ctf_fs_trace->metadata); BT_ASSERT(ctf_fs_trace->metadata->tc); - msg_iter = ctf_msg_iter_create( + ctf_msg_iter_up msg_iter = ctf_msg_iter_create( ctf_fs_trace->metadata->tc, bt_common_get_page_size(static_cast(ctf_fs_trace->logger.level())) * 8, + ctf_fs_ds_file_medops, ds_file.get(), NULL, ctf_fs_trace->logger); if (!msg_iter) { /* ctf_msg_iter_create() logs errors. */ @@ -952,7 +931,8 @@ static int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, ctf_msg_iter_set_dry_run(msg_iter.get(), true); /* Seek to the beginning of the target packet. */ - iter_status = ctf_msg_iter_seek(msg_iter.get(), index_entry.offset.bytes()); + enum ctf_msg_iter_status iter_status = + ctf_msg_iter_seek(msg_iter.get(), index_entry.offset.bytes()); if (iter_status) { /* ctf_msg_iter_seek() logs errors. */ return -1; @@ -1029,8 +1009,6 @@ static int decode_packet_last_event_timestamp(struct ctf_fs_trace *ctf_fs_trace, static int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace) { for (const auto& ds_file_group : trace->ds_file_groups) { - struct ctf_clock_class *default_cc; - BT_ASSERT(ds_file_group); auto& index = ds_file_group->index; @@ -1059,7 +1037,7 @@ static int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace) auto& last_entry = index.entries.back(); BT_ASSERT(ds_file_group->sc->default_clock_class); - default_cc = ds_file_group->sc->default_clock_class; + ctf_clock_class *default_cc = ds_file_group->sc->default_clock_class; /* * Decode packet to read the timestamp of the last event of the @@ -1095,13 +1073,12 @@ static int fix_index_lttng_event_after_packet_bug(struct ctf_fs_trace *trace) static int fix_index_barectf_event_before_packet_bug(struct ctf_fs_trace *trace) { for (const auto& ds_file_group : trace->ds_file_groups) { - struct ctf_clock_class *default_cc; auto& index = ds_file_group->index; BT_ASSERT(!index.entries.empty()); BT_ASSERT(ds_file_group->sc->default_clock_class); - default_cc = ds_file_group->sc->default_clock_class; + ctf_clock_class *default_cc = ds_file_group->sc->default_clock_class; /* * 1. Iterate over the index, starting from the second entry @@ -1209,8 +1186,6 @@ static int fix_index_lttng_crash_quirk(struct ctf_fs_trace *trace) */ static int extract_tracer_info(struct ctf_fs_trace *trace, struct tracer_info *current_tracer_info) { - struct ctf_trace_class_env_entry *entry; - /* Clear the current_tracer_info struct */ memset(current_tracer_info, 0, sizeof(*current_tracer_info)); @@ -1219,7 +1194,8 @@ static int extract_tracer_info(struct ctf_fs_trace *trace, struct tracer_info *c * major version are needed. If one of these is missing, consider it an * extraction failure. */ - entry = ctf_trace_class_borrow_env_entry_by_name(trace->metadata->tc, "tracer_name"); + ctf_trace_class_env_entry *entry = + ctf_trace_class_borrow_env_entry_by_name(trace->metadata->tc, "tracer_name"); if (!entry || entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR) { return -1; } @@ -1418,13 +1394,11 @@ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, bt_self_component *selfComp) { std::vector paths; - std::vector traces; - const char *trace_name; BT_ASSERT(bt_value_get_type(paths_value) == BT_VALUE_TYPE_ARRAY); BT_ASSERT(!bt_value_array_is_empty(paths_value)); - trace_name = trace_name_value ? bt_value_string_get(trace_name_value) : NULL; + const char *trace_name = trace_name_value ? bt_value_string_get(trace_name_value) : NULL; /* * Create a sorted array of the paths, to make the execution of this @@ -1439,6 +1413,7 @@ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, std::sort(paths.begin(), paths.end()); /* Create a separate ctf_fs_trace object for each path. */ + std::vector traces; for (const auto& path : paths) { int ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs, path.c_str(), trace_name, traces, selfComp); @@ -1598,11 +1573,9 @@ static bt_param_validation_map_value_entry_descr fs_params_entries_descr[] = { bool read_src_fs_parameters(const bt_value *params, const bt_value **inputs, const bt_value **trace_name, struct ctf_fs_component *ctf_fs) { - const bt_value *value; - enum bt_param_validation_status validate_value_status; gchar *error = NULL; - - validate_value_status = bt_param_validation_validate(params, fs_params_entries_descr, &error); + bt_param_validation_status validate_value_status = + bt_param_validation_validate(params, fs_params_entries_descr, &error); if (validate_value_status != BT_PARAM_VALIDATION_STATUS_OK) { BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs->logger, "{}", error); g_free(error); @@ -1613,7 +1586,7 @@ bool read_src_fs_parameters(const bt_value *params, const bt_value **inputs, *inputs = bt_value_map_borrow_entry_value_const(params, "inputs"); /* clock-class-offset-s parameter */ - value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-s"); + const bt_value *value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-s"); if (value) { ctf_fs->clkClsCfg.offsetSec = bt_value_integer_signed_get(value); } -- 2.34.1