#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"
* 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;
}
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);
if (status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
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());
ctf_fs_ds_group_medops_data *data = new ctf_fs_ds_group_medops_data {parentLogger};
data->ds_file_group = ds_file_group;
.borrow_stream = medop_group_borrow_stream,
};
-static void ctf_fs_ds_index_entry_destroy(ctf_fs_ds_index_entry *entry)
+static ctf_fs_ds_index_entry::UP ctf_fs_ds_index_entry_create(const bt2c::DataLen offset,
+ const bt2c::DataLen packetSize)
{
- delete entry;
-}
+ ctf_fs_ds_index_entry::UP entry = bt2s::make_unique<ctf_fs_ds_index_entry>(offset, packetSize);
-static struct ctf_fs_ds_index_entry *ctf_fs_ds_index_entry_create()
-{
- ctf_fs_ds_index_entry *entry = new ctf_fs_ds_index_entry;
entry->packet_seq_num = UINT64_MAX;
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;
goto error;
}
- index = ctf_fs_ds_index_create(ds_file->logger);
+ 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) {
+ 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();
+ 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;
+ }
+
+ 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.");
}
/* 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_CPPLOGW_SPEC(
- ds_file->logger,
- "Invalid, non-monotonic, packet offset encountered in LTTng trace index file: "
- "previous offset={}, current offset={}",
- prev_index_entry->offset, index_entry->offset);
- goto error;
- }
+ 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);
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) {
+ 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={}, total-packets-size={}",
- ds_file->file->size, total_packets_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);
- ctf_fs_ds_index_entry_destroy(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;
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;
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;
+ auto currentPacketOffset = bt2c::DataLen::fromBytes(0);
BT_CPPLOGI_SPEC(ds_file->logger, "Indexing stream file {}", ds_file->file->path->str);
- index = ctf_fs_ds_index_create(ds_file->logger);
+ 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_CPPLOGE_STR_SPEC(ds_file->logger, "Cannot get the current packet's offset.");
- goto error;
- } else if (current_packet_offset_bytes > ds_file->file->size) {
+ 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) {
+ } 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;
- }
+ /*
+ * 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 (current_packet_offset_bytes + current_packet_size_bytes > 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={}, packet-size-bytes={}, "
- "file-size={}",
- ds_file->file->path->str, (intmax_t) current_packet_offset_bytes,
- (intmax_t) current_packet_size_bytes, (intmax_t) ds_file->file->size);
+ "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();
+ auto index_entry = ctf_fs_ds_index_entry_create(currentPacketOffset, currentPacketSize);
if (!index_entry) {
BT_CPPLOGE_APPEND_CAUSE_SPEC(ds_file->logger,
"Failed to create a ctf_fs_ds_index_entry.");
}
/* 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) {
- ctf_fs_ds_index_entry_destroy(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;
+ currentPacketOffset += currentPacketSize;
BT_CPPLOGD_SPEC(ds_file->logger,
- "Seeking to next packet: current-packet-offset={}, "
- "next-packet-offset={}",
- (intmax_t) (current_packet_offset_bytes - current_packet_size_bytes),
- (intmax_t) current_packet_offset_bytes);
+ "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;
}
return ds_file;
}
-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;
-
- 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;
}
return index;
}
-struct ctf_fs_ds_index *ctf_fs_ds_index_create(const bt2c::Logger& logger)
+ctf_fs_ds_index::UP ctf_fs_ds_index_create()
{
- 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_CPPLOGE_SPEC(logger, "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>();
}
void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
delete ds_file;
}
-void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
+ctf_fs_ds_file_info::UP ctf_fs_ds_file_info_create(const char *path, int64_t begin_ns)
{
- if (!index) {
+ ctf_fs_ds_file_info::UP ds_file_info = bt2s::make_unique<ctf_fs_ds_file_info>();
+
+ ds_file_info->path = path;
+ ds_file_info->begin_ns = begin_ns;
+ return ds_file_info;
+}
+
+static void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_group)
+{
+ if (!ds_file_group) {
return;
}
- if (index->entries) {
- g_ptr_array_free(index->entries, TRUE);
- }
+ 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,
+ ctf_fs_ds_index::UP index)
+{
+ ctf_fs_ds_file_group::UP ds_file_group {new ctf_fs_ds_file_group};
+
+ 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;
- delete index;
+ return ds_file_group;
}
projects / babeltrace.git / blobdiff