*/
#include <glib.h>
-#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
-#include <string.h>
-#include <babeltrace2/babeltrace.h>
+#include "compat/endian.h" /* IWYU pragma: keep */
+#include "compat/mman.h" /* IWYU: pragma keep */
+#include "cpp-common/vendor/fmt/format.h"
-#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 "common/assert.h"
-#include "compat/endian.h"
-#include "compat/mman.h"
-
-#include "../common/msg-iter/msg-iter.hpp"
+#include "../common/src/msg-iter/msg-iter.hpp"
#include "data-stream-file.hpp"
#include "file.hpp"
#include "fs.hpp"
#include "lttng-index.hpp"
-#include "plugins/ctf/common/metadata/ctf-meta.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->str : "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);
ds_file->mmap_addr =
bt_mmap(ds_file->mmap_len, PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp),
- ds_file->mmap_offset_in_file, ds_file->log_level);
+ 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->str, 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->str, 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->str, fmt::ptr(ds_file->file->fp));
goto error;
}
}
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
*
* Owned by this.
*/
- struct ctf_fs_ds_file *file;
+ struct ctf_fs_ds_file *file = nullptr;
/* 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,
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;
/* Create the new file. */
data->file =
ctf_fs_ds_file_create(data->ds_file_group->ctf_fs_trace, data->ds_file_group->stream,
- index_entry->path, log_level);
+ 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, index_entry->offset.bytes());
if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
goto end;
}
index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
data->ds_file_group->index->entries, data->next_index_entry_index);
- 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;
}
ctf_fs_ds_file_destroy(data->file);
- g_free(data);
+ delete data;
end:
return;
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, struct ctf_fs_ds_group_medops_data **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);
- 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;
- }
-
+ ctf_fs_ds_group_medops_data *data = 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;
/*
* No need to prepare the first file. ctf_msg_iter will call
*/
*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 void ctf_fs_ds_index_entry_destroy(ctf_fs_ds_index_entry *entry)
{
- struct ctf_fs_ds_index_entry *entry;
+ delete 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;
- }
+static struct ctf_fs_ds_index_entry *ctf_fs_ds_index_entry_create(const bt2c::DataLen offset,
+ const bt2c::DataLen packetSize)
+{
+ ctf_fs_ds_index_entry *entry = new ctf_fs_ds_index_entry {offset, packetSize};
entry->packet_seq_num = UINT64_MAX;
-end:
return entry;
}
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;
+ 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->str);
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);
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->str);
goto error;
}
directory = g_path_get_dirname(ds_file->file->path->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->str);
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(ds_file->logger);
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 (packetSize.hasExtraBits()) {
+ BT_CPPLOGW_SPEC(ds_file->logger,
+ "Invalid packet size encountered in LTTng trace index file");
+ goto error;
+ }
+
+ const auto offset = bt2c::DataLen::fromBytes(be64toh(file_index->offset));
- if (packet_size % CHAR_BIT) {
- BT_COMP_LOGW("Invalid packet size encountered in LTTng trace index file");
+ 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;
}
- index_entry = ctf_fs_ds_index_entry_create(ds_file->self_comp, ds_file->log_level);
+ index_entry = ctf_fs_ds_index_entry_create(offset, packetSize);
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;
- /* 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);
- goto error;
- }
-
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;
}
/* 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);
+ ctf_fs_ds_index_entry_destroy(index_entry);
index = NULL;
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 {
int ret;
struct ctf_fs_ds_index *index = NULL;
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->str);
- index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
+ index = ctf_fs_ds_index_create(ds_file->logger);
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->str, 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);
+ const 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;
- ret = init_index_entry(index_entry, ds_file, &props, current_packet_size_bytes,
- current_packet_offset_bytes);
+ ret = init_index_entry(index_entry, ds_file, &props);
if (ret) {
- g_free(index_entry);
+ ctf_fs_ds_index_entry_destroy(index_entry);
goto error;
}
g_ptr_array_add(index->entries, 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:
}
struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace, bt_stream *stream,
- const char *path, bt_logging_level log_level)
+ 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);
+ size_t offset_align;
+ ctf_fs_ds_file *ds_file = new ctf_fs_ds_file {parentLogger};
if (!ds_file) {
goto error;
}
- ds_file->log_level = log_level;
- ds_file->self_comp = ctf_fs_trace->self_comp;
- 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;
}
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;
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);
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;
}
-struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level,
- bt_self_component *self_comp)
+struct ctf_fs_ds_index *ctf_fs_ds_index_create(const bt2c::Logger& logger)
{
- 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);
+ ctf_fs_ds_index *index = new ctf_fs_ds_index;
+ index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_index_entry_destroy);
if (!index->entries) {
- BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
- "Failed to allocate index entries.");
+ BT_CPPLOGE_SPEC(logger, "Failed to allocate index entries.");
goto error;
}
ctf_fs_file_destroy(ds_file->file);
}
- g_free(ds_file);
+ delete ds_file;
}
void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
if (index->entries) {
g_ptr_array_free(index->entries, TRUE);
}
- g_free(index);
+
+ delete index;
+}
+
+void ctf_fs_ds_file_info_destroy(struct ctf_fs_ds_file_info *ds_file_info)
+{
+ if (!ds_file_info) {
+ return;
+ }
+
+ if (ds_file_info->path) {
+ g_string_free(ds_file_info->path, TRUE);
+ }
+
+ delete ds_file_info;
+}
+
+struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path, int64_t begin_ns)
+{
+ ctf_fs_ds_file_info *ds_file_info = new ctf_fs_ds_file_info;
+ ds_file_info->path = g_string_new(path);
+ if (!ds_file_info->path) {
+ ctf_fs_ds_file_info_destroy(ds_file_info);
+ ds_file_info = NULL;
+ goto end;
+ }
+
+ ds_file_info->begin_ns = begin_ns;
+
+end:
+ return ds_file_info;
+}
+
+void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
+{
+ if (!ds_file_group) {
+ return;
+ }
+
+ if (ds_file_group->ds_file_infos) {
+ g_ptr_array_free(ds_file_group->ds_file_infos, TRUE);
+ }
+
+ ctf_fs_ds_index_destroy(ds_file_group->index);
+
+ bt_stream_put_ref(ds_file_group->stream);
+ delete ds_file_group;
+}
+
+void ctf_fs_ds_file_group_deleter::operator()(ctf_fs_ds_file_group *group) noexcept
+{
+ ctf_fs_ds_file_group_destroy(group);
+}
+
+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,
+ struct ctf_fs_ds_index *index)
+{
+ ctf_fs_ds_file_group::UP ds_file_group {new ctf_fs_ds_file_group};
+
+ ds_file_group->ds_file_infos =
+ g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_file_info_destroy);
+ if (!ds_file_group->ds_file_infos) {
+ goto error;
+ }
+
+ ds_file_group->index = 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;
+ goto end;
+
+error:
+ ds_file_group.reset();
+ ctf_fs_ds_index_destroy(index);
+
+end:
+ return ds_file_group;
}