X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Ffs-src%2Ffs.cpp;h=e86d30cecf8544041365c4d23890b44722c01fe4;hb=HEAD;hp=6123487d971d18808ef4da935db7e6d0a395f47e;hpb=1cb63a528ae1a60a19b6e4f827864018e48cc7fe;p=babeltrace.git diff --git a/src/plugins/ctf/fs-src/fs.cpp b/src/plugins/ctf/fs-src/fs.cpp index 6123487d..e86d30ce 100644 --- a/src/plugins/ctf/fs-src/fs.cpp +++ b/src/plugins/ctf/fs-src/fs.cpp @@ -358,12 +358,12 @@ static bool ds_index_entries_equal(const ctf_fs_ds_index_entry& left, * The entry is inserted only if there isn't an identical entry already. */ -static void ds_index_insert_ds_index_entry_sorted(struct ctf_fs_ds_index *index, +static void ds_index_insert_ds_index_entry_sorted(ctf_fs_ds_index& index, const ctf_fs_ds_index_entry& entry) { /* Find the spot where to insert this index entry. */ - auto otherEntry = index->entries.begin(); - for (; otherEntry != index->entries.end(); ++otherEntry) { + auto otherEntry = index.entries.begin(); + for (; otherEntry != index.entries.end(); ++otherEntry) { if (entry.timestamp_begin_ns <= otherEntry->timestamp_begin_ns) { break; } @@ -376,12 +376,12 @@ static void ds_index_insert_ds_index_entry_sorted(struct ctf_fs_ds_index *index, * snapshots of the same trace. We then want the index to contain * a reference to only one copy of that packet. */ - if (otherEntry == index->entries.end() || !ds_index_entries_equal(entry, *otherEntry)) { - index->entries.emplace(otherEntry, entry); + if (otherEntry == index.entries.end() || !ds_index_entries_equal(entry, *otherEntry)) { + index.entries.emplace(otherEntry, entry); } } -static void merge_ctf_fs_ds_indexes(struct ctf_fs_ds_index *dest, const ctf_fs_ds_index& src) +static void merge_ctf_fs_ds_indexes(ctf_fs_ds_index& dest, const ctf_fs_ds_index& src) { for (const auto& entry : src.entries) { ds_index_insert_ds_index_entry_sorted(dest, entry); @@ -406,7 +406,7 @@ static int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, const 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); if (!msg_iter) { - BT_CPPLOGE_STR_SPEC(ctf_fs_trace->logger, "Cannot create a CTF message iterator."); + BT_CPPLOGE_SPEC(ctf_fs_trace->logger, "Cannot create a CTF message iterator."); return -1; } @@ -470,15 +470,9 @@ 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. */ - 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) { - return -1; - } - - new_ds_file_group->insert_ds_file_info_sorted(std::move(ds_file_info)); - ctf_fs_trace->ds_file_groups.emplace_back(std::move(new_ds_file_group)); + ctf_fs_trace->ds_file_groups.emplace_back(bt2s::make_unique( + ctf_fs_trace, sc, UINT64_C(-1), std::move(*index))); + ctf_fs_trace->ds_file_groups.back()->insert_ds_file_info_sorted(std::move(ds_file_info)); return 0; } @@ -494,19 +488,12 @@ 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)); - if (!new_ds_file_group) { - return -1; - } - - ds_file_group = new_ds_file_group.get(); - ctf_fs_trace->ds_file_groups.emplace_back(std::move(new_ds_file_group)); + ctf_fs_trace->ds_file_groups.emplace_back(bt2s::make_unique( + ctf_fs_trace, sc, static_cast(stream_instance_id), std::move(*index))); + ds_file_group = ctf_fs_trace->ds_file_groups.back().get(); } else { - merge_ctf_fs_ds_indexes(&ds_file_group->index, *index); + merge_ctf_fs_ds_indexes(ds_file_group->index, *index); } ds_file_group->insert_ds_file_info_sorted(std::move(ds_file_info)); @@ -581,7 +568,7 @@ static int create_ds_file_groups(struct ctf_fs_trace *ctf_fs_trace) return 0; } -static int set_trace_name(bt_trace *trace, const char *name_suffix) +static void set_trace_name(const bt2::Trace trace, const char *name_suffix) { std::string name; @@ -589,9 +576,9 @@ static int set_trace_name(bt_trace *trace, const char *name_suffix) * Check if we have a trace environment string value named `hostname`. * If so, use it as the trace name's prefix. */ - 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); + const auto val = trace.environmentEntry("hostname"); + if (val && val->isString()) { + name += val->asString().value(); if (name_suffix) { name += G_DIR_SEPARATOR; @@ -602,7 +589,7 @@ static int set_trace_name(bt_trace *trace, const char *name_suffix) name += name_suffix; } - return bt_trace_set_name(trace, name.c_str()); + trace.name(name); } static ctf_fs_trace::UP ctf_fs_trace_create(const char *path, const char *name, @@ -629,16 +616,9 @@ static ctf_fs_trace::UP ctf_fs_trace_create(const char *path, const char *name, } if (ctf_fs_trace->trace) { - ret = ctf_trace_class_configure_ir_trace(ctf_fs_trace->metadata->tc, - ctf_fs_trace->trace->libObjPtr()); - if (ret) { - return nullptr; - } + ctf_trace_class_configure_ir_trace(ctf_fs_trace->metadata->tc, *ctf_fs_trace->trace); - ret = set_trace_name(ctf_fs_trace->trace->libObjPtr(), name); - if (ret) { - return nullptr; - } + set_trace_name(*ctf_fs_trace->trace, name); } ret = create_ds_file_groups(ctf_fs_trace.get()); @@ -735,7 +715,7 @@ static void merge_ctf_fs_ds_file_groups(struct ctf_fs_ds_file_group *dest, } /* Merge both indexes. */ - merge_ctf_fs_ds_indexes(&dest->index, src->index); + merge_ctf_fs_ds_indexes(dest->index, src->index); } /* Merge src_trace's data stream file groups into dest_trace's. */ @@ -793,15 +773,9 @@ static int merge_matching_ctf_fs_ds_file_groups(struct ctf_fs_trace *dest_trace, dest_trace->metadata->tc, src_group->sc->id); BT_ASSERT(sc); - auto new_dest_group = - ctf_fs_ds_file_group_create(dest_trace, sc, src_group->stream_id, {}); - - if (!new_dest_group) { - return -1; - } - - dest_group = new_dest_group.get(); - dest_trace->ds_file_groups.emplace_back(std::move(new_dest_group)); + dest_trace->ds_file_groups.emplace_back(bt2s::make_unique( + dest_trace, sc, src_group->stream_id, ctf_fs_ds_index {})); + dest_group = dest_trace->ds_file_groups.back().get(); } BT_ASSERT(dest_group); @@ -973,10 +947,10 @@ static int decode_packet_last_event_timestamp(struct ctf_fs_trace *ctf_fs_trace, * * To fix up this erroneous data we do the following: * 1. If it's not the stream file's last packet: set the packet index entry's - * end time to the next packet's beginning time. + * end time to the next packet's beginning time. * 2. If it's the stream file's last packet, set the packet index entry's end - * time to the packet's last event's time, if any, or to the packet's - * beginning time otherwise. + * time to the packet's last event's time, if any, or to the packet's + * beginning time otherwise. * * Known buggy tracer versions: * - before lttng-ust 2.11.0 @@ -1308,7 +1282,7 @@ static int fix_packet_index_tracer_bugs(ctf_fs_trace *trace) * are needed. Failing to extract these entries is not * an error. */ - BT_CPPLOGI_STR_SPEC( + BT_CPPLOGI_SPEC( trace->logger, "Cannot extract tracer information necessary to compare with buggy versions."); return 0; @@ -1316,9 +1290,8 @@ static int fix_packet_index_tracer_bugs(ctf_fs_trace *trace) /* Check if the trace may be affected by old tracer bugs. */ if (is_tracer_affected_by_lttng_event_after_packet_bug(¤t_tracer_info)) { - BT_CPPLOGI_STR_SPEC( - trace->logger, - "Trace may be affected by LTTng tracer packet timestamp bug. Fixing up."); + BT_CPPLOGI_SPEC(trace->logger, + "Trace may be affected by LTTng tracer packet timestamp bug. Fixing up."); ret = fix_index_lttng_event_after_packet_bug(trace); if (ret) { BT_CPPLOGE_APPEND_CAUSE_SPEC(trace->logger, @@ -1329,9 +1302,8 @@ static int fix_packet_index_tracer_bugs(ctf_fs_trace *trace) } if (is_tracer_affected_by_barectf_event_before_packet_bug(¤t_tracer_info)) { - BT_CPPLOGI_STR_SPEC( - trace->logger, - "Trace may be affected by barectf tracer packet timestamp bug. Fixing up."); + BT_CPPLOGI_SPEC(trace->logger, + "Trace may be affected by barectf tracer packet timestamp bug. Fixing up."); ret = fix_index_barectf_event_before_packet_bug(trace); if (ret) { BT_CPPLOGE_APPEND_CAUSE_SPEC(trace->logger, @@ -1367,25 +1339,20 @@ static bool compare_ds_file_groups_by_first_path(const ctf_fs_ds_file_group::UP& } int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, - const bt_value *paths_value, - const bt_value *trace_name_value, - bt_self_component *selfComp) + const bt2::ConstArrayValue pathsValue, + const char *traceName, bt_self_component *selfComp) { std::vector paths; - BT_ASSERT(bt_value_get_type(paths_value) == BT_VALUE_TYPE_ARRAY); - BT_ASSERT(!bt_value_array_is_empty(paths_value)); - - const char *trace_name = trace_name_value ? bt_value_string_get(trace_name_value) : NULL; + BT_ASSERT(!pathsValue.isEmpty()); /* * Create a sorted array of the paths, to make the execution of this * component deterministic. */ - for (std::uint64_t i = 0; i < bt_value_array_get_length(paths_value); i++) { - const bt_value *path_value = bt_value_array_borrow_element_by_index_const(paths_value, i); - const char *input = bt_value_string_get(path_value); - paths.emplace_back(input); + for (const auto pathValue : pathsValue) { + BT_ASSERT(pathValue.isString()); + paths.emplace_back(pathValue.asString().value().str()); } std::sort(paths.begin(), paths.end()); @@ -1393,7 +1360,7 @@ int ctf_fs_component_create_ctf_fs_trace(struct ctf_fs_component *ctf_fs, /* 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, + int ret = ctf_fs_component_create_ctf_fs_trace_one_path(ctf_fs, path.c_str(), traceName, traces, selfComp); if (ret) { return ret; @@ -1493,31 +1460,18 @@ static int create_streams_for_trace(struct ctf_fs_trace *ctf_fs_trace) BT_ASSERT(ds_file_group->sc->ir_sc); BT_ASSERT(ctf_fs_trace->trace); - bt_stream *stream; + const bt2::StreamClass sc {ds_file_group->sc->ir_sc}; if (ds_file_group->stream_id == UINT64_C(-1)) { /* No stream ID: use 0 */ - stream = - bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace->libObjPtr(), - ctf_fs_trace->next_stream_id); + ds_file_group->stream = + sc.instantiate(*ctf_fs_trace->trace, ctf_fs_trace->next_stream_id); ctf_fs_trace->next_stream_id++; } else { /* Specific stream ID */ - stream = - bt_stream_create_with_id(ds_file_group->sc->ir_sc, ctf_fs_trace->trace->libObjPtr(), - (uint64_t) ds_file_group->stream_id); - } - - if (!stream) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs_trace->logger, - "Cannot create stream for DS file group: " - "addr={}, stream-name=\"{}\"", - fmt::ptr(ds_file_group), name); - return -1; + ds_file_group->stream = sc.instantiate(*ctf_fs_trace->trace, ds_file_group->stream_id); } - ds_file_group->stream = bt2::Stream::Shared::createWithoutRef(stream); - int ret = bt_stream_set_name(ds_file_group->stream->libObjPtr(), name.c_str()); if (ret) { BT_CPPLOGE_APPEND_CAUSE_SPEC(ctf_fs_trace->logger, @@ -1548,61 +1502,55 @@ static bt_param_validation_map_value_entry_descr fs_params_entries_descr[] = { bt_param_validation_value_descr::makeBool()}, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END}; -bool read_src_fs_parameters(const bt_value *params, const bt_value **inputs, - const bt_value **trace_name, struct ctf_fs_component *ctf_fs) +ctf::src::fs::Parameters read_src_fs_parameters(const bt2::ConstMapValue params, + const bt2c::Logger& logger) { gchar *error = NULL; bt_param_validation_status validate_value_status = - bt_param_validation_validate(params, fs_params_entries_descr, &error); + bt_param_validation_validate(params.libObjPtr(), 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); - return false; + bt2c::GCharUP errorFreer {error}; + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2c::Error, "{}", error); } - /* inputs parameter */ - *inputs = bt_value_map_borrow_entry_value_const(params, "inputs"); + ctf::src::fs::Parameters parameters {params["inputs"]->asArray()}; /* clock-class-offset-s parameter */ - 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); + if (const auto clockClassOffsetS = params["clock-class-offset-s"]) { + parameters.clkClsCfg.offsetSec = clockClassOffsetS->asSignedInteger().value(); } /* clock-class-offset-ns parameter */ - value = bt_value_map_borrow_entry_value_const(params, "clock-class-offset-ns"); - if (value) { - ctf_fs->clkClsCfg.offsetNanoSec = bt_value_integer_signed_get(value); + if (const auto clockClassOffsetNs = params["clock-class-offset-ns"]) { + parameters.clkClsCfg.offsetNanoSec = clockClassOffsetNs->asSignedInteger().value(); } /* force-clock-class-origin-unix-epoch parameter */ - value = bt_value_map_borrow_entry_value_const(params, "force-clock-class-origin-unix-epoch"); - if (value) { - ctf_fs->clkClsCfg.forceOriginIsUnixEpoch = bt_value_bool_get(value); + if (const auto forceClockClassOriginUnixEpoch = params["force-clock-class-origin-unix-epoch"]) { + parameters.clkClsCfg.forceOriginIsUnixEpoch = + forceClockClassOriginUnixEpoch->asBool().value(); } /* trace-name parameter */ - *trace_name = bt_value_map_borrow_entry_value_const(params, "trace-name"); + if (const auto traceName = params["trace-name"]) { + parameters.traceName = traceName->asString().value().str(); + } - return true; + return parameters; } -static ctf_fs_component::UP ctf_fs_create(const bt_value *params, +static ctf_fs_component::UP ctf_fs_create(const bt2::ConstMapValue params, bt_self_component_source *self_comp_src) { - const bt_value *inputs_value; - const bt_value *trace_name_value; bt_self_component *self_comp = bt_self_component_source_as_self_component(self_comp_src); + const bt2c::Logger logger {bt2::SelfSourceComponent {self_comp_src}, "PLUGIN/SRC.CTF.FS/COMP"}; + const auto parameters = read_src_fs_parameters(params, logger); + auto ctf_fs = bt2s::make_unique(parameters.clkClsCfg, logger); - ctf_fs_component::UP ctf_fs = bt2s::make_unique( - bt2c::Logger {bt2::SelfSourceComponent {self_comp_src}, "PLUGIN/SRC.CTF.FS/COMP"}); - - if (!read_src_fs_parameters(params, &inputs_value, &trace_name_value, ctf_fs.get())) { - return nullptr; - } - - if (ctf_fs_component_create_ctf_fs_trace(ctf_fs.get(), inputs_value, trace_name_value, - self_comp)) { + if (ctf_fs_component_create_ctf_fs_trace( + ctf_fs.get(), parameters.inputs, + parameters.traceName ? parameters.traceName->c_str() : nullptr, self_comp)) { return nullptr; } @@ -1625,7 +1573,7 @@ bt_component_class_initialize_method_status ctf_fs_init(bt_self_component_source bt_component_class_initialize_method_status ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK; - ctf_fs_component::UP ctf_fs = ctf_fs_create(params, self_comp_src); + ctf_fs_component::UP ctf_fs = ctf_fs_create(bt2::ConstMapValue {params}, self_comp_src); if (!ctf_fs) { ret = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR; }