* Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
*/
-#define BT_COMP_LOG_SELF_COMP (self_comp)
-#define BT_LOG_OUTPUT_LEVEL (log_level)
-#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/DS"
-#include "logging/comp-logging.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
#include <glib.h>
-#include <inttypes.h>
-#include "compat/mman.h"
-#include "compat/endian.h"
-#include <babeltrace2/babeltrace.h>
-#include "common/common.h"
-#include "file.hpp"
-#include "metadata.hpp"
-#include "../common/msg-iter/msg-iter.hpp"
-#include "common/assert.h"
+#include <stdint.h>
+#include <stdio.h>
+
+#include "compat/endian.h" /* IWYU pragma: keep */
+#include "compat/mman.h" /* IWYU: pragma keep */
+#include "cpp-common/bt2s/make-unique.hpp"
+#include "cpp-common/vendor/fmt/format.h"
+
+#include "../common/src/msg-iter/msg-iter.hpp"
#include "data-stream-file.hpp"
-#include <string.h>
+#include "file.hpp"
+#include "fs.hpp"
+#include "lttng-index.hpp"
static inline size_t remaining_mmap_bytes(struct ctf_fs_ds_file *ds_file)
{
static enum ctf_msg_iter_medium_status ds_file_munmap(struct ctf_fs_ds_file *ds_file)
{
enum ctf_msg_iter_medium_status status;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
BT_ASSERT(ds_file);
}
if (bt_munmap(ds_file->mmap_addr, ds_file->mmap_len)) {
- 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",
- ds_file->file ? ds_file->file->fp : NULL);
+ BT_CPPLOGE_ERRNO_SPEC(ds_file->logger, "Cannot memory-unmap file",
+ ": address={}, size={}, file_path=\"{}\", file={}",
+ fmt::ptr(ds_file->mmap_addr), ds_file->mmap_len,
+ ds_file->file ? ds_file->file->path : "NULL",
+ ds_file->file ? fmt::ptr(ds_file->file->fp) : NULL);
status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
goto end;
}
off_t requested_offset_in_file)
{
enum ctf_msg_iter_medium_status status;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
/* Ensure the requested offset is in the file range. */
BT_ASSERT(requested_offset_in_file >= 0);
* contains `requested_offset_in_file`.
*/
ds_file->request_offset_in_mapping =
- requested_offset_in_file % bt_mmap_get_offset_align_size(ds_file->log_level);
+ requested_offset_in_file %
+ bt_mmap_get_offset_align_size(static_cast<int>(ds_file->logger.level()));
ds_file->mmap_offset_in_file = requested_offset_in_file - ds_file->request_offset_in_mapping;
ds_file->mmap_len =
MIN(ds_file->file->size - ds_file->mmap_offset_in_file, ds_file->mmap_max_len);
BT_ASSERT(ds_file->mmap_len > 0);
ds_file->mmap_addr =
- bt_mmap((void *) 0, ds_file->mmap_len, PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp),
- ds_file->mmap_offset_in_file, ds_file->log_level);
+ bt_mmap(ds_file->mmap_len, PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp.get()),
+ ds_file->mmap_offset_in_file, static_cast<int>(ds_file->logger.level()));
if (ds_file->mmap_addr == MAP_FAILED) {
- 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_in_file, strerror(errno));
+ BT_CPPLOGE_SPEC(ds_file->logger,
+ "Cannot memory-map address (size {}) of file \"{}\" ({}) at offset {}: {}",
+ ds_file->mmap_len, ds_file->file->path, fmt::ptr(ds_file->file->fp),
+ (intmax_t) ds_file->mmap_offset_in_file, strerror(errno));
status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
goto end;
}
{
enum ctf_msg_iter_medium_status status = CTF_MSG_ITER_MEDIUM_STATUS_OK;
struct ctf_fs_ds_file *ds_file = (struct ctf_fs_ds_file *) data;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
BT_ASSERT(request_sz > 0);
if (remaining_mmap_bytes(ds_file) == 0) {
/* Are we at the end of the file? */
if (ds_file->mmap_offset_in_file >= ds_file->file->size) {
- BT_COMP_LOGD("Reached end of file \"%s\" (%p)", ds_file->file->path->str,
- ds_file->file->fp);
+ BT_CPPLOGD_SPEC(ds_file->logger, "Reached end of file \"{}\" ({})", ds_file->file->path,
+ fmt::ptr(ds_file->file->fp));
status = CTF_MSG_ITER_MEDIUM_STATUS_EOF;
goto end;
}
case CTF_MSG_ITER_MEDIUM_STATUS_EOF:
goto end;
default:
- BT_COMP_LOGE("Cannot memory-map next region of file \"%s\" (%p)",
- ds_file->file->path->str, ds_file->file->fp);
+ BT_CPPLOGE_SPEC(ds_file->logger, "Cannot memory-map next region of file \"{}\" ({})",
+ ds_file->file->path, fmt::ptr(ds_file->file->fp));
goto error;
}
}
return status;
}
-static bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t stream_id, void *data)
+static bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t, void *data)
{
struct ctf_fs_ds_file *ds_file = (struct ctf_fs_ds_file *) data;
bt_stream_class *ds_file_stream_class;
bt_stream *stream = NULL;
- ds_file_stream_class = bt_stream_borrow_class(ds_file->stream);
+ ds_file_stream_class = ds_file->stream->cls().libObjPtr();
if (stream_class != ds_file_stream_class) {
/*
goto end;
}
- stream = ds_file->stream;
+ stream = ds_file->stream->libObjPtr();
end:
return stream;
return ds_file_mmap(ds_file, offset);
}
-BT_HIDDEN
struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops = {
medop_request_bytes,
medop_seek,
struct ctf_fs_ds_group_medops_data
{
+ explicit ctf_fs_ds_group_medops_data(const bt2c::Logger& parentLogger) :
+ logger {parentLogger, "PLUGIN/SRC.CTF.FS/DS-GROUP-MEDOPS"}
+ {
+ }
+
+ bt2c::Logger logger;
+
/* Weak, set once at creation time. */
- struct ctf_fs_ds_file_group *ds_file_group;
+ struct ctf_fs_ds_file_group *ds_file_group = nullptr;
/*
* Index (as in element rank) of the index entry of ds_file_groups'
* index we will read next (so, the one after the one we are reading
* right now).
*/
- guint next_index_entry_index;
+ guint next_index_entry_index = 0;
/*
* File we are currently reading. Changes whenever we switch to
* reading another data file.
- *
- * Owned by this.
*/
- struct ctf_fs_ds_file *file;
+ ctf_fs_ds_file::UP file;
/* Weak, for context / logging / appending causes. */
- bt_self_message_iterator *self_msg_iter;
- bt_logging_level log_level;
+ bt_self_message_iterator *self_msg_iter = nullptr;
};
static enum ctf_msg_iter_medium_status medop_group_request_bytes(size_t request_sz,
struct ctf_fs_ds_group_medops_data *data = (struct ctf_fs_ds_group_medops_data *) void_data;
/* Return bytes from the current file. */
- return medop_request_bytes(request_sz, buffer_addr, buffer_sz, data->file);
+ return medop_request_bytes(request_sz, buffer_addr, buffer_sz, data->file.get());
}
static bt_stream *medop_group_borrow_stream(bt_stream_class *stream_class, int64_t stream_id,
{
struct ctf_fs_ds_group_medops_data *data = (struct ctf_fs_ds_group_medops_data *) void_data;
- return medop_borrow_stream(stream_class, stream_id, data->file);
+ return medop_borrow_stream(stream_class, stream_id, data->file.get());
}
/*
static enum ctf_msg_iter_medium_status
ctf_fs_ds_group_medops_set_file(struct ctf_fs_ds_group_medops_data *data,
- struct ctf_fs_ds_index_entry *index_entry,
- bt_self_message_iterator *self_msg_iter, bt_logging_level log_level)
+ struct ctf_fs_ds_index_entry *index_entry)
{
enum ctf_msg_iter_medium_status status;
BT_ASSERT(index_entry);
/* Check if that file is already the one mapped. */
- if (!data->file || strcmp(index_entry->path, data->file->file->path->str) != 0) {
- /* Destroy the previously used file. */
- ctf_fs_ds_file_destroy(data->file);
-
+ if (!data->file || data->file->file->path != index_entry->path) {
/* Create the new file. */
data->file =
- ctf_fs_ds_file_create(data->ds_file_group->ctf_fs_trace, self_msg_iter,
- data->ds_file_group->stream, index_entry->path, log_level);
+ ctf_fs_ds_file_create(data->ds_file_group->ctf_fs_trace, data->ds_file_group->stream,
+ index_entry->path, data->logger);
if (!data->file) {
- BT_MSG_ITER_LOGE_APPEND_CAUSE(self_msg_iter, "failed to create ctf_fs_ds_file.");
+ BT_CPPLOGE_APPEND_CAUSE_SPEC(data->logger, "failed to create ctf_fs_ds_file.");
status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
goto end;
}
* Ensure the right portion of the file will be returned on the next
* request_bytes call.
*/
- status = ds_file_mmap(data->file, index_entry->offset);
+ status = ds_file_mmap(data->file.get(), index_entry->offset.bytes());
if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
goto end;
}
enum ctf_msg_iter_medium_status status;
/* If we have gone through all index entries, we are done. */
- if (data->next_index_entry_index >= data->ds_file_group->index->entries->len) {
+ if (data->next_index_entry_index >= data->ds_file_group->index->entries.size()) {
status = CTF_MSG_ITER_MEDIUM_STATUS_EOF;
goto end;
}
* Otherwise, look up the next index entry / packet and prepare it
* for reading.
*/
- index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
- data->ds_file_group->index->entries, data->next_index_entry_index);
+ index_entry = data->ds_file_group->index->entries[data->next_index_entry_index].get();
- status =
- ctf_fs_ds_group_medops_set_file(data, index_entry, data->self_msg_iter, data->log_level);
+ status = ctf_fs_ds_group_medops_set_file(data, index_entry);
if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
goto end;
}
return status;
}
-BT_HIDDEN
-void ctf_fs_ds_group_medops_data_destroy(struct ctf_fs_ds_group_medops_data *data)
+void ctf_fs_ds_group_medops_data_deleter::operator()(ctf_fs_ds_group_medops_data *data) noexcept
{
- if (!data) {
- goto end;
- }
-
- ctf_fs_ds_file_destroy(data->file);
-
- g_free(data);
-
-end:
- return;
+ delete data;
}
enum ctf_msg_iter_medium_status ctf_fs_ds_group_medops_data_create(
struct ctf_fs_ds_file_group *ds_file_group, bt_self_message_iterator *self_msg_iter,
- bt_logging_level log_level, struct ctf_fs_ds_group_medops_data **out)
+ const bt2c::Logger& parentLogger, ctf_fs_ds_group_medops_data_up& out)
{
- struct ctf_fs_ds_group_medops_data *data;
- enum ctf_msg_iter_medium_status status;
-
BT_ASSERT(self_msg_iter);
BT_ASSERT(ds_file_group);
BT_ASSERT(ds_file_group->index);
- BT_ASSERT(ds_file_group->index->entries->len > 0);
+ BT_ASSERT(!ds_file_group->index->entries.empty());
- data = g_new0(struct ctf_fs_ds_group_medops_data, 1);
- if (!data) {
- BT_MSG_ITER_LOGE_APPEND_CAUSE(self_msg_iter,
- "Failed to allocate a struct ctf_fs_ds_group_medops_data");
- status = CTF_MSG_ITER_MEDIUM_STATUS_MEMORY_ERROR;
- goto error;
- }
+ out.reset(new ctf_fs_ds_group_medops_data {parentLogger});
- data->ds_file_group = ds_file_group;
- data->self_msg_iter = self_msg_iter;
- data->log_level = log_level;
+ out->ds_file_group = ds_file_group;
+ out->self_msg_iter = self_msg_iter;
/*
* No need to prepare the first file. ctf_msg_iter will call
* done then.
*/
- *out = data;
- status = CTF_MSG_ITER_MEDIUM_STATUS_OK;
- goto end;
-
-error:
- ctf_fs_ds_group_medops_data_destroy(data);
-
-end:
- return status;
+ return CTF_MSG_ITER_MEDIUM_STATUS_OK;
}
void ctf_fs_ds_group_medops_data_reset(struct ctf_fs_ds_group_medops_data *data)
.borrow_stream = medop_group_borrow_stream,
};
-static struct ctf_fs_ds_index_entry *ctf_fs_ds_index_entry_create(bt_self_component *self_comp,
- bt_logging_level log_level)
+static ctf_fs_ds_index_entry::UP ctf_fs_ds_index_entry_create(const bt2c::DataLen offset,
+ const bt2c::DataLen packetSize)
{
- struct ctf_fs_ds_index_entry *entry;
-
- entry = g_new0(struct ctf_fs_ds_index_entry, 1);
- if (!entry) {
- BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate a ctf_fs_ds_index_entry.");
- goto end;
- }
+ ctf_fs_ds_index_entry::UP entry = bt2s::make_unique<ctf_fs_ds_index_entry>(offset, packetSize);
entry->packet_seq_num = UINT64_MAX;
-end:
return entry;
}
clock_class->offset_cycles, ns);
}
-static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file *ds_file,
- struct ctf_fs_ds_file_info *file_info,
- struct ctf_msg_iter *msg_iter)
+static ctf_fs_ds_index::UP build_index_from_idx_file(struct ctf_fs_ds_file *ds_file,
+ struct ctf_fs_ds_file_info *file_info,
+ struct ctf_msg_iter *msg_iter)
{
int ret;
gchar *directory = NULL;
gsize filesize;
const char *mmap_begin = NULL, *file_pos = NULL;
const struct ctf_packet_index_file_hdr *header = NULL;
- struct ctf_fs_ds_index *index = NULL;
- struct ctf_fs_ds_index_entry *index_entry = NULL, *prev_index_entry = NULL;
- uint64_t total_packets_size = 0;
+ ctf_fs_ds_index::UP index;
+ ctf_fs_ds_index_entry::UP index_entry;
+ ctf_fs_ds_index_entry *prev_index_entry = NULL;
+ auto totalPacketsSize = bt2c::DataLen::fromBytes(0);
size_t file_index_entry_size;
size_t file_entry_count;
size_t i;
struct ctf_stream_class *sc;
struct ctf_msg_iter_packet_properties props;
uint32_t version_major, version_minor;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
- BT_COMP_LOGI("Building index from .idx file of stream file %s", ds_file->file->path->str);
+ BT_CPPLOGI_SPEC(ds_file->logger, "Building index from .idx file of stream file {}",
+ ds_file->file->path);
ret = ctf_msg_iter_get_packet_properties(msg_iter, &props);
if (ret) {
- BT_COMP_LOGI_STR("Cannot read first packet's header and context fields.");
+ BT_CPPLOGI_STR_SPEC(ds_file->logger,
+ "Cannot read first packet's header and context fields.");
goto error;
}
sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc, props.stream_class_id);
BT_ASSERT(sc);
if (!sc->default_clock_class) {
- BT_COMP_LOGI_STR("Cannot find stream class's default clock class.");
+ BT_CPPLOGI_STR_SPEC(ds_file->logger, "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);
+ basename = g_path_get_basename(ds_file->file->path.c_str());
if (!basename) {
- BT_COMP_LOGE("Cannot get the basename of datastream file %s", ds_file->file->path->str);
+ BT_CPPLOGE_SPEC(ds_file->logger, "Cannot get the basename of datastream file {}",
+ ds_file->file->path);
goto error;
}
- directory = g_path_get_dirname(ds_file->file->path->str);
+ directory = g_path_get_dirname(ds_file->file->path.c_str());
if (!directory) {
- BT_COMP_LOGE("Cannot get dirname of datastream file %s", ds_file->file->path->str);
+ BT_CPPLOGE_SPEC(ds_file->logger, "Cannot get dirname of datastream file {}",
+ ds_file->file->path);
goto error;
}
index_basename = g_string_new(basename);
if (!index_basename) {
- BT_COMP_LOGE_STR("Cannot allocate index file basename string");
+ BT_CPPLOGE_STR_SPEC(ds_file->logger, "Cannot allocate index file basename string");
goto error;
}
index_file_path = g_build_filename(directory, "index", index_basename->str, NULL);
mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL);
if (!mapped_file) {
- BT_COMP_LOGD("Cannot create new mapped file %s", index_file_path);
+ BT_CPPLOGD_SPEC(ds_file->logger, "Cannot create new mapped file {}", index_file_path);
goto error;
}
*/
filesize = g_mapped_file_get_length(mapped_file);
if (filesize < sizeof(*header)) {
- BT_COMP_LOGW("Invalid LTTng trace index file: "
- "file size (%zu bytes) < header size (%zu bytes)",
- filesize, sizeof(*header));
+ BT_CPPLOGW_SPEC(ds_file->logger,
+ "Invalid LTTng trace index file: "
+ "file size ({} bytes) < header size ({} bytes)",
+ filesize, sizeof(*header));
goto error;
}
file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header);
if (be32toh(header->magic) != CTF_INDEX_MAGIC) {
- BT_COMP_LOGW_STR("Invalid LTTng trace index: \"magic\" field validation failed");
+ BT_CPPLOGW_STR_SPEC(ds_file->logger,
+ "Invalid LTTng trace index: \"magic\" field validation failed");
goto error;
}
version_major = be32toh(header->index_major);
version_minor = be32toh(header->index_minor);
if (version_major != 1) {
- BT_COMP_LOGW("Unknown LTTng trace index version: "
- "major=%" PRIu32 ", minor=%" PRIu32,
- version_major, version_minor);
+ BT_CPPLOGW_SPEC(ds_file->logger, "Unknown LTTng trace index version: major={}, minor={}",
+ version_major, version_minor);
goto error;
}
file_index_entry_size = be32toh(header->packet_index_len);
if (file_index_entry_size < CTF_INDEX_1_0_SIZE) {
- BT_COMP_LOGW(
+ BT_CPPLOGW_SPEC(
+ ds_file->logger,
"Invalid `packet_index_len` in LTTng trace index file (`packet_index_len` < CTF index 1.0 index entry size): "
- "packet_index_len=%zu, CTF_INDEX_1_0_SIZE=%zu",
+ "packet_index_len={}, CTF_INDEX_1_0_SIZE={}",
file_index_entry_size, CTF_INDEX_1_0_SIZE);
goto error;
}
file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size;
if ((filesize - sizeof(*header)) % file_index_entry_size) {
- 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));
+ BT_CPPLOGW_SPEC(ds_file->logger,
+ "Invalid LTTng trace index: the index's size after the header "
+ "({} bytes) is not a multiple of the index entry size "
+ "({} bytes)",
+ (filesize - sizeof(*header)), sizeof(*header));
goto error;
}
- index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
+ index = ctf_fs_ds_index_create();
if (!index) {
goto error;
}
for (i = 0; i < file_entry_count; i++) {
struct ctf_packet_index *file_index = (struct ctf_packet_index *) file_pos;
- uint64_t packet_size = be64toh(file_index->packet_size);
+ const auto packetSize = bt2c::DataLen::fromBits(be64toh(file_index->packet_size));
- if (packet_size % CHAR_BIT) {
- BT_COMP_LOGW("Invalid packet size encountered in LTTng trace index file");
+ if (packetSize.hasExtraBits()) {
+ BT_CPPLOGW_SPEC(ds_file->logger,
+ "Invalid packet size encountered in LTTng trace index file");
goto error;
}
- index_entry = ctf_fs_ds_index_entry_create(ds_file->self_comp, ds_file->log_level);
- if (!index_entry) {
- BT_COMP_LOGE_APPEND_CAUSE(ds_file->self_comp,
- "Failed to create a ctf_fs_ds_index_entry.");
+ const auto offset = bt2c::DataLen::fromBytes(be64toh(file_index->offset));
+
+ if (i != 0 && offset < prev_index_entry->offset) {
+ BT_CPPLOGW_SPEC(
+ ds_file->logger,
+ "Invalid, non-monotonic, packet offset encountered in LTTng trace index file: "
+ "previous offset={} bytes, current offset={} bytes",
+ prev_index_entry->offset.bytes(), offset.bytes());
goto error;
}
- /* Set path to stream file. */
- index_entry->path = file_info->path->str;
-
- /* Convert size in bits to bytes. */
- packet_size /= CHAR_BIT;
- index_entry->packet_size = packet_size;
-
- index_entry->offset = be64toh(file_index->offset);
- if (i != 0 && index_entry->offset < prev_index_entry->offset) {
- BT_COMP_LOGW(
- "Invalid, non-monotonic, packet offset encountered in LTTng trace index file: "
- "previous offset=%" PRIu64 ", current offset=%" PRIu64,
- prev_index_entry->offset, index_entry->offset);
+ index_entry = ctf_fs_ds_index_entry_create(offset, packetSize);
+ if (!index_entry) {
+ BT_CPPLOGE_APPEND_CAUSE_SPEC(ds_file->logger,
+ "Failed to create a ctf_fs_ds_index_entry.");
goto error;
}
+ /* Set path to stream file. */
+ index_entry->path = file_info->path.c_str();
+
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_COMP_LOGW(
+ BT_CPPLOGW_SPEC(
+ ds_file->logger,
"Invalid packet time bounds encountered in LTTng trace index file (begin > end): "
- "timestamp_begin=%" PRIu64 "timestamp_end=%" PRIu64,
+ "timestamp_begin={}, timestamp_end={}",
index_entry->timestamp_begin, index_entry->timestamp_end);
goto error;
}
ret = convert_cycles_to_ns(sc->default_clock_class, index_entry->timestamp_begin,
&index_entry->timestamp_begin_ns);
if (ret) {
- BT_COMP_LOGI_STR(
+ BT_CPPLOGI_STR_SPEC(
+ ds_file->logger,
"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_COMP_LOGI_STR(
+ BT_CPPLOGI_STR_SPEC(
+ ds_file->logger,
"Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing");
goto error;
}
index_entry->packet_seq_num = be64toh(file_index->packet_seq_num);
}
- total_packets_size += packet_size;
+ totalPacketsSize += packetSize;
file_pos += file_index_entry_size;
- prev_index_entry = index_entry;
+ prev_index_entry = index_entry.get();
- /* Give ownership of `index_entry` to `index->entries`. */
- g_ptr_array_add(index->entries, index_entry);
- index_entry = NULL;
+ index->entries.emplace_back(std::move(index_entry));
}
/* Validate that the index addresses the complete stream. */
- if (ds_file->file->size != total_packets_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);
+ if (ds_file->file->size != totalPacketsSize.bytes()) {
+ BT_CPPLOGW_SPEC(ds_file->logger,
+ "Invalid LTTng trace index file; indexed size != stream file size: "
+ "file-size={} bytes, total-packets-size={} bytes",
+ ds_file->file->size, totalPacketsSize.bytes());
goto error;
}
end:
}
return index;
error:
- ctf_fs_ds_index_destroy(index);
- g_free(index_entry);
- index = NULL;
+ index.reset();
goto end;
}
static int init_index_entry(struct ctf_fs_ds_index_entry *entry, struct ctf_fs_ds_file *ds_file,
- struct ctf_msg_iter_packet_properties *props, off_t packet_size,
- off_t packet_offset)
+ struct ctf_msg_iter_packet_properties *props)
{
int ret = 0;
struct ctf_stream_class *sc;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc, props->stream_class_id);
BT_ASSERT(sc);
- BT_ASSERT(packet_offset >= 0);
- entry->offset = packet_offset;
- BT_ASSERT(packet_size >= 0);
- entry->packet_size = packet_size;
if (props->snapshots.beginning_clock != UINT64_C(-1)) {
entry->timestamp_begin = props->snapshots.beginning_clock;
ret = convert_cycles_to_ns(sc->default_clock_class, props->snapshots.beginning_clock,
&entry->timestamp_begin_ns);
if (ret) {
- BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
+ BT_CPPLOGI_STR_SPEC(ds_file->logger,
+ "Failed to convert raw timestamp to nanoseconds since Epoch.");
goto end;
}
} else {
ret = convert_cycles_to_ns(sc->default_clock_class, props->snapshots.end_clock,
&entry->timestamp_end_ns);
if (ret) {
- BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
+ BT_CPPLOGI_STR_SPEC(ds_file->logger,
+ "Failed to convert raw timestamp to nanoseconds since Epoch.");
goto end;
}
} else {
return ret;
}
-static struct ctf_fs_ds_index *build_index_from_stream_file(struct ctf_fs_ds_file *ds_file,
- struct ctf_fs_ds_file_info *file_info,
- struct ctf_msg_iter *msg_iter)
+static ctf_fs_ds_index::UP build_index_from_stream_file(struct ctf_fs_ds_file *ds_file,
+ struct ctf_fs_ds_file_info *file_info,
+ struct ctf_msg_iter *msg_iter)
{
int ret;
- struct ctf_fs_ds_index *index = NULL;
+ ctf_fs_ds_index::UP index;
enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK;
- off_t current_packet_offset_bytes = 0;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
+ auto currentPacketOffset = bt2c::DataLen::fromBytes(0);
- BT_COMP_LOGI("Indexing stream file %s", ds_file->file->path->str);
+ BT_CPPLOGI_SPEC(ds_file->logger, "Indexing stream file {}", ds_file->file->path);
- index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
+ index = ctf_fs_ds_index_create();
if (!index) {
goto error;
}
while (true) {
- off_t current_packet_size_bytes;
- struct ctf_fs_ds_index_entry *index_entry;
struct ctf_msg_iter_packet_properties props;
- if (current_packet_offset_bytes < 0) {
- BT_COMP_LOGE_STR("Cannot get the current packet's offset.");
+ if (currentPacketOffset.bytes() > ds_file->file->size) {
+ BT_CPPLOGE_STR_SPEC(ds_file->logger,
+ "Unexpected current packet's offset (larger than file).");
goto error;
- } else if (current_packet_offset_bytes > ds_file->file->size) {
- BT_COMP_LOGE_STR("Unexpected current packet's offset (larger than file).");
- goto error;
- } else if (current_packet_offset_bytes == ds_file->file->size) {
+ } else if (currentPacketOffset.bytes() == ds_file->file->size) {
/* No more data */
break;
}
- iter_status = ctf_msg_iter_seek(msg_iter, current_packet_offset_bytes);
+ iter_status = ctf_msg_iter_seek(msg_iter, currentPacketOffset.bytes());
if (iter_status != CTF_MSG_ITER_STATUS_OK) {
goto error;
}
goto error;
}
- if (props.exp_packet_total_size >= 0) {
- current_packet_size_bytes = (uint64_t) props.exp_packet_total_size / 8;
- } else {
- current_packet_size_bytes = ds_file->file->size;
- }
-
- if (current_packet_offset_bytes + current_packet_size_bytes > ds_file->file->size) {
- 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, (intmax_t) current_packet_offset_bytes,
- (intmax_t) current_packet_size_bytes, (intmax_t) ds_file->file->size);
+ /*
+ * Get the current packet size from the packet header, if set. Else,
+ * assume there is a single packet in the file, so take the file size
+ * as the packet size.
+ */
+ const auto currentPacketSize = props.exp_packet_total_size >= 0 ?
+ bt2c::DataLen::fromBits(props.exp_packet_total_size) :
+ bt2c::DataLen::fromBytes(ds_file->file->size);
+
+ if ((currentPacketOffset + currentPacketSize).bytes() > ds_file->file->size) {
+ BT_CPPLOGW_SPEC(ds_file->logger,
+ "Invalid packet size reported in file: stream=\"{}\", "
+ "packet-offset-bytes={}, packet-size-bytes={}, "
+ "file-size-bytes={}",
+ ds_file->file->path, currentPacketOffset.bytes(),
+ currentPacketSize.bytes(), ds_file->file->size);
goto error;
}
- index_entry = ctf_fs_ds_index_entry_create(ds_file->self_comp, ds_file->log_level);
+ auto index_entry = ctf_fs_ds_index_entry_create(currentPacketOffset, currentPacketSize);
if (!index_entry) {
- BT_COMP_LOGE_APPEND_CAUSE(ds_file->self_comp,
- "Failed to create a ctf_fs_ds_index_entry.");
+ BT_CPPLOGE_APPEND_CAUSE_SPEC(ds_file->logger,
+ "Failed to create a ctf_fs_ds_index_entry.");
goto error;
}
/* Set path to stream file. */
- index_entry->path = file_info->path->str;
+ index_entry->path = file_info->path.c_str();
- ret = init_index_entry(index_entry, ds_file, &props, current_packet_size_bytes,
- current_packet_offset_bytes);
+ ret = init_index_entry(index_entry.get(), ds_file, &props);
if (ret) {
- g_free(index_entry);
goto error;
}
- g_ptr_array_add(index->entries, index_entry);
+ index->entries.emplace_back(std::move(index_entry));
- current_packet_offset_bytes += current_packet_size_bytes;
- BT_COMP_LOGD("Seeking to next packet: current-packet-offset=%jd, "
- "next-packet-offset=%jd",
- (intmax_t) (current_packet_offset_bytes - current_packet_size_bytes),
- (intmax_t) current_packet_offset_bytes);
+ currentPacketOffset += currentPacketSize;
+ BT_CPPLOGD_SPEC(ds_file->logger,
+ "Seeking to next packet: current-packet-offset-bytes={}, "
+ "next-packet-offset-bytes={}",
+ (currentPacketOffset - currentPacketSize).bytes(),
+ currentPacketOffset.bytes());
}
end:
return index;
error:
- ctf_fs_ds_index_destroy(index);
- index = NULL;
+ index.reset();
goto end;
}
-BT_HIDDEN
-struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace,
- bt_self_message_iterator *self_msg_iter,
- bt_stream *stream, const char *path,
- bt_logging_level log_level)
+ctf_fs_ds_file::UP ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace,
+ bt2::Stream::Shared stream, const char *path,
+ const bt2c::Logger& parentLogger)
{
int ret;
- const size_t offset_align = bt_mmap_get_offset_align_size(log_level);
- struct ctf_fs_ds_file *ds_file = g_new0(struct ctf_fs_ds_file, 1);
+ auto ds_file = bt2s::make_unique<ctf_fs_ds_file>(parentLogger);
+ size_t offset_align;
- if (!ds_file) {
- goto error;
- }
-
- ds_file->log_level = log_level;
- ds_file->self_comp = ctf_fs_trace->self_comp;
- ds_file->self_msg_iter = self_msg_iter;
- ds_file->file = ctf_fs_file_create(log_level, ds_file->self_comp);
+ ds_file->file = ctf_fs_file_create(parentLogger);
if (!ds_file->file) {
goto error;
}
- ds_file->stream = stream;
- bt_stream_get_ref(ds_file->stream);
- ds_file->metadata = ctf_fs_trace->metadata;
- g_string_assign(ds_file->file->path, path);
- ret = ctf_fs_file_open(ds_file->file, "rb");
+ ds_file->stream = std::move(stream);
+ ds_file->metadata = ctf_fs_trace->metadata.get();
+ ds_file->file->path = path;
+ ret = ctf_fs_file_open(ds_file->file.get(), "rb");
if (ret) {
goto error;
}
+ offset_align = bt_mmap_get_offset_align_size(static_cast<int>(ds_file->logger.level()));
ds_file->mmap_max_len = offset_align * 2048;
goto end;
error:
/* Do not touch "borrowed" file. */
- ctf_fs_ds_file_destroy(ds_file);
- ds_file = NULL;
+ ds_file.reset();
end:
return ds_file;
}
-BT_HIDDEN
-struct ctf_fs_ds_index *ctf_fs_ds_file_build_index(struct ctf_fs_ds_file *ds_file,
- struct ctf_fs_ds_file_info *file_info,
- struct ctf_msg_iter *msg_iter)
+ctf_fs_ds_index::UP ctf_fs_ds_file_build_index(struct ctf_fs_ds_file *ds_file,
+ struct ctf_fs_ds_file_info *file_info,
+ struct ctf_msg_iter *msg_iter)
{
- struct ctf_fs_ds_index *index;
- bt_self_component *self_comp = ds_file->self_comp;
- bt_logging_level log_level = ds_file->log_level;
-
- index = build_index_from_idx_file(ds_file, file_info, msg_iter);
+ auto index = build_index_from_idx_file(ds_file, file_info, msg_iter);
if (index) {
goto end;
}
- BT_COMP_LOGI("Failed to build index from .index file; "
- "falling back to stream indexing.");
+ BT_CPPLOGI_SPEC(ds_file->logger, "Failed to build index from .index file; "
+ "falling back to stream indexing.");
index = build_index_from_stream_file(ds_file, file_info, msg_iter);
end:
return index;
}
-BT_HIDDEN
-struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level,
- bt_self_component *self_comp)
+ctf_fs_ds_index::UP ctf_fs_ds_index_create()
{
- struct ctf_fs_ds_index *index = g_new0(struct ctf_fs_ds_index, 1);
-
- if (!index) {
- 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_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
- "Failed to allocate index entries.");
- goto error;
- }
-
- goto end;
-
-error:
- ctf_fs_ds_index_destroy(index);
- index = NULL;
-end:
- return index;
+ return bt2s::make_unique<ctf_fs_ds_index>();
}
-BT_HIDDEN
-void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
+ctf_fs_ds_file::~ctf_fs_ds_file()
{
- if (!ds_file) {
- return;
- }
-
- bt_stream_put_ref(ds_file->stream);
- (void) ds_file_munmap(ds_file);
+ (void) ds_file_munmap(this);
+}
- if (ds_file->file) {
- ctf_fs_file_destroy(ds_file->file);
- }
+ctf_fs_ds_file_info::UP ctf_fs_ds_file_info_create(const char *path, int64_t begin_ns)
+{
+ ctf_fs_ds_file_info::UP ds_file_info = bt2s::make_unique<ctf_fs_ds_file_info>();
- g_free(ds_file);
+ ds_file_info->path = path;
+ ds_file_info->begin_ns = begin_ns;
+ return ds_file_info;
}
-BT_HIDDEN
-void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
+ctf_fs_ds_file_group::UP ctf_fs_ds_file_group_create(struct ctf_fs_trace *ctf_fs_trace,
+ struct ctf_stream_class *sc,
+ uint64_t stream_instance_id,
+ ctf_fs_ds_index::UP index)
{
- if (!index) {
- return;
- }
+ ctf_fs_ds_file_group::UP ds_file_group {new ctf_fs_ds_file_group};
- if (index->entries) {
- g_ptr_array_free(index->entries, TRUE);
- }
- g_free(index);
+ ds_file_group->index = std::move(index);
+
+ ds_file_group->stream_id = stream_instance_id;
+ BT_ASSERT(sc);
+ ds_file_group->sc = sc;
+ ds_file_group->ctf_fs_trace = ctf_fs_trace;
+
+ return ds_file_group;
}