ctf: msg-iter: add event timestamp accessors
[babeltrace.git] / src / plugins / ctf / fs-src / data-stream-file.c
CommitLineData
e98a2d6e 1/*
94cf822e 2 * Copyright 2016-2017 - Philippe Proulx <pproulx@efficios.com>
fc9a526c 3 * Copyright 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
e98a2d6e
PP
4 * Copyright 2010-2011 - EfficiOS Inc. and Linux Foundation
5 *
e98a2d6e
PP
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
4c65a157 25#define BT_COMP_LOG_SELF_COMP (ds_file->self_comp)
98903a3e
PP
26#define BT_LOG_OUTPUT_LEVEL (ds_file->log_level)
27#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/DS"
d9c39b0a 28#include "logging/comp-logging.h"
98903a3e 29
0fbb9a9f 30#include <stdlib.h>
e98a2d6e
PP
31#include <stdio.h>
32#include <stdint.h>
33#include <stdlib.h>
34#include <stdbool.h>
35#include <glib.h>
36#include <inttypes.h>
578e048b
MJ
37#include "compat/mman.h"
38#include "compat/endian.h"
3fadfbc0 39#include <babeltrace2/babeltrace.h>
578e048b 40#include "common/common.h"
78586d8a
JG
41#include "file.h"
42#include "metadata.h"
d6e69534 43#include "../common/msg-iter/msg-iter.h"
578e048b 44#include "common/assert.h"
94cf822e 45#include "data-stream-file.h"
e9383dfd 46#include <string.h>
e98a2d6e 47
4f1f88a6 48static inline
94cf822e 49size_t remaining_mmap_bytes(struct ctf_fs_ds_file *ds_file)
e98a2d6e 50{
de2abea4 51 BT_ASSERT(ds_file->mmap_len >= ds_file->request_offset);
2c701ca6 52 return ds_file->mmap_len - ds_file->request_offset;
e98a2d6e
PP
53}
54
5b29e799 55static
94cf822e 56int ds_file_munmap(struct ctf_fs_ds_file *ds_file)
e98a2d6e 57{
fc9a526c 58 int ret = 0;
e98a2d6e 59
d238196d 60 if (!ds_file || !ds_file->mmap_addr) {
94cf822e
PP
61 goto end;
62 }
63
04394229 64 if (bt_munmap(ds_file->mmap_addr, ds_file->mmap_len)) {
4c65a157 65 BT_COMP_LOGE_ERRNO("Cannot memory-unmap file",
cd232764 66 ": address=%p, size=%zu, file_path=\"%s\", file=%p",
94cf822e 67 ds_file->mmap_addr, ds_file->mmap_len,
9e0c8dbb 68 ds_file->file ? ds_file->file->path->str : "NULL",
cd232764 69 ds_file->file ? ds_file->file->fp : NULL);
fc9a526c
JG
70 ret = -1;
71 goto end;
e98a2d6e 72 }
94cf822e
PP
73
74 ds_file->mmap_addr = NULL;
75
fc9a526c
JG
76end:
77 return ret;
e98a2d6e
PP
78}
79
5b29e799 80static
d6e69534 81enum bt_msg_iter_medium_status ds_file_mmap_next(
94cf822e 82 struct ctf_fs_ds_file *ds_file)
e98a2d6e 83{
d6e69534
PP
84 enum bt_msg_iter_medium_status ret =
85 BT_MSG_ITER_MEDIUM_STATUS_OK;
e98a2d6e
PP
86
87 /* Unmap old region */
94cf822e
PP
88 if (ds_file->mmap_addr) {
89 if (ds_file_munmap(ds_file)) {
e98a2d6e
PP
90 goto error;
91 }
92
2f5a009b 93 /*
2c701ca6 94 * mmap_len is guaranteed to be page-aligned except on the
2f5a009b
JG
95 * last mapping where it may not be possible (since the file's
96 * size itself may not be a page multiple).
97 */
2c701ca6 98 ds_file->mmap_offset += ds_file->mmap_len;
94cf822e 99 ds_file->request_offset = 0;
e98a2d6e
PP
100 }
101
2c701ca6 102 ds_file->mmap_len = MIN(ds_file->file->size - ds_file->mmap_offset,
94cf822e 103 ds_file->mmap_max_len);
2c701ca6 104 if (ds_file->mmap_len == 0) {
d6e69534 105 ret = BT_MSG_ITER_MEDIUM_STATUS_EOF;
e0f6a64a
JG
106 goto end;
107 }
e98a2d6e 108 /* Map new region */
f6ccaed9 109 BT_ASSERT(ds_file->mmap_len);
04394229 110 ds_file->mmap_addr = bt_mmap((void *) 0, ds_file->mmap_len,
94cf822e 111 PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp),
95c324a4 112 ds_file->mmap_offset, ds_file->log_level);
94cf822e 113 if (ds_file->mmap_addr == MAP_FAILED) {
4c65a157 114 BT_COMP_LOGE("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %jd: %s",
94cf822e 115 ds_file->mmap_len, ds_file->file->path->str,
1974687e 116 ds_file->file->fp, (intmax_t) ds_file->mmap_offset,
78586d8a 117 strerror(errno));
e98a2d6e
PP
118 goto error;
119 }
120
121 goto end;
e98a2d6e 122error:
94cf822e 123 ds_file_munmap(ds_file);
d6e69534 124 ret = BT_MSG_ITER_MEDIUM_STATUS_ERROR;
e98a2d6e
PP
125end:
126 return ret;
127}
128
5b29e799 129static
d6e69534 130enum bt_msg_iter_medium_status medop_request_bytes(
e98a2d6e
PP
131 size_t request_sz, uint8_t **buffer_addr,
132 size_t *buffer_sz, void *data)
133{
d6e69534
PP
134 enum bt_msg_iter_medium_status status =
135 BT_MSG_ITER_MEDIUM_STATUS_OK;
94cf822e 136 struct ctf_fs_ds_file *ds_file = data;
e98a2d6e
PP
137
138 if (request_sz == 0) {
139 goto end;
140 }
141
de2abea4
FD
142 /*
143 * Check if we have at least one memory-mapped byte left. If we don't,
144 * mmap the next file.
145 */
94cf822e 146 if (remaining_mmap_bytes(ds_file) == 0) {
e98a2d6e 147 /* Are we at the end of the file? */
94cf822e 148 if (ds_file->mmap_offset >= ds_file->file->size) {
4c65a157 149 BT_COMP_LOGD("Reached end of file \"%s\" (%p)",
94cf822e 150 ds_file->file->path->str, ds_file->file->fp);
d6e69534 151 status = BT_MSG_ITER_MEDIUM_STATUS_EOF;
e98a2d6e
PP
152 goto end;
153 }
154
94cf822e 155 status = ds_file_mmap_next(ds_file);
e0f6a64a 156 switch (status) {
d6e69534 157 case BT_MSG_ITER_MEDIUM_STATUS_OK:
e0f6a64a 158 break;
d6e69534 159 case BT_MSG_ITER_MEDIUM_STATUS_EOF:
e0f6a64a
JG
160 goto end;
161 default:
4c65a157 162 BT_COMP_LOGE("Cannot memory-map next region of file \"%s\" (%p)",
94cf822e
PP
163 ds_file->file->path->str,
164 ds_file->file->fp);
e98a2d6e
PP
165 goto error;
166 }
167 }
168
94cf822e 169 *buffer_sz = MIN(remaining_mmap_bytes(ds_file), request_sz);
de2abea4 170 BT_ASSERT(ds_file->mmap_addr);
94cf822e
PP
171 *buffer_addr = ((uint8_t *) ds_file->mmap_addr) + ds_file->request_offset;
172 ds_file->request_offset += *buffer_sz;
e98a2d6e
PP
173 goto end;
174
175error:
d6e69534 176 status = BT_MSG_ITER_MEDIUM_STATUS_ERROR;
e98a2d6e
PP
177
178end:
179 return status;
180}
181
5b29e799 182static
fc917f65 183bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t stream_id,
b92735af 184 void *data)
e98a2d6e 185{
94cf822e 186 struct ctf_fs_ds_file *ds_file = data;
b19ff26f
PP
187 bt_stream_class *ds_file_stream_class;
188 bt_stream *stream = NULL;
e5be10ef 189
40f4ba76 190 ds_file_stream_class = bt_stream_borrow_class(
e5be10ef 191 ds_file->stream);
94cf822e 192
94cf822e
PP
193 if (stream_class != ds_file_stream_class) {
194 /*
195 * Not supported: two packets described by two different
196 * stream classes within the same data stream file.
197 */
198 goto end;
e98a2d6e
PP
199 }
200
94cf822e
PP
201 stream = ds_file->stream;
202
203end:
204 return stream;
e98a2d6e
PP
205}
206
9e0c8dbb 207static
fc917f65
PP
208enum bt_msg_iter_medium_status medop_seek(enum bt_msg_iter_seek_whence whence,
209 off_t offset, void *data)
9e0c8dbb 210{
d6e69534
PP
211 enum bt_msg_iter_medium_status ret =
212 BT_MSG_ITER_MEDIUM_STATUS_OK;
9e0c8dbb 213 struct ctf_fs_ds_file *ds_file = data;
de2abea4 214 off_t offset_in_mapping, file_size = ds_file->file->size;
9e0c8dbb 215
d6e69534 216 if (whence != BT_MSG_ITER_SEEK_WHENCE_SET ||
9e0c8dbb 217 offset < 0 || offset > file_size) {
4c65a157 218 BT_COMP_LOGE("Invalid medium seek request: whence=%d, offset=%jd, "
df0fc0bf
JR
219 "file-size=%jd", (int) whence, (intmax_t) offset,
220 (intmax_t) file_size);
d6e69534 221 ret = BT_MSG_ITER_MEDIUM_STATUS_INVAL;
9e0c8dbb
JG
222 goto end;
223 }
224
de2abea4
FD
225 /* If there is no current mapping, map the right file directly. */
226 if (!ds_file->mmap_addr) {
227 goto map_requested_offset;
228 }
229
9e0c8dbb
JG
230 /*
231 * Determine whether or not the destination is contained within the
232 * current mapping.
233 */
de2abea4
FD
234 if (offset < ds_file->mmap_offset ||
235 offset >= ds_file->mmap_offset + ds_file->mmap_len) {
9e0c8dbb 236 int unmap_ret;
4c65a157 237 BT_COMP_LOGD("Medium seek request cannot be accomodated by the current "
63489ca2 238 "file mapping: offset=%jd, mmap-offset=%jd, "
df0fc0bf 239 "mmap-len=%zu", (intmax_t) offset, (intmax_t) ds_file->mmap_offset,
9e0c8dbb
JG
240 ds_file->mmap_len);
241 unmap_ret = ds_file_munmap(ds_file);
242 if (unmap_ret) {
d6e69534 243 ret = BT_MSG_ITER_MEDIUM_STATUS_ERROR;
9e0c8dbb
JG
244 goto end;
245 }
de2abea4 246 goto map_requested_offset;
9e0c8dbb
JG
247 } else {
248 ds_file->request_offset = offset - ds_file->mmap_offset;
de2abea4
FD
249 goto test_end;
250 }
251
252map_requested_offset:
253 offset_in_mapping = offset %
254 bt_common_get_page_size(ds_file->log_level);
255
256 ds_file->mmap_offset = offset - offset_in_mapping;
257 ds_file->request_offset = offset_in_mapping;
258 ret = ds_file_mmap_next(ds_file);
259 if (ret != BT_MSG_ITER_MEDIUM_STATUS_OK) {
260 goto end;
9e0c8dbb
JG
261 }
262
de2abea4 263test_end:
9e0c8dbb
JG
264 ds_file->end_reached = (offset == file_size);
265end:
266 return ret;
267}
268
6de92955 269BT_HIDDEN
d6e69534 270struct bt_msg_iter_medium_ops ctf_fs_ds_file_medops = {
e98a2d6e 271 .request_bytes = medop_request_bytes,
312c056a 272 .borrow_stream = medop_borrow_stream,
9e0c8dbb 273 .seek = medop_seek,
e98a2d6e 274};
6de92955 275
97ade20b 276static
0f2d58c9 277int convert_cycles_to_ns(struct ctf_clock_class *clock_class,
97ade20b 278 uint64_t cycles, int64_t *ns)
b6c3dcb2 279{
0f2d58c9
PP
280 return bt_util_clock_cycles_to_ns_from_origin(cycles,
281 clock_class->frequency, clock_class->offset_seconds,
282 clock_class->offset_cycles, ns);
97ade20b
JG
283}
284
285static
286struct ctf_fs_ds_index *build_index_from_idx_file(
287 struct ctf_fs_ds_file *ds_file)
288{
289 int ret;
b6c3dcb2
JG
290 gchar *directory = NULL;
291 gchar *basename = NULL;
292 GString *index_basename = NULL;
293 gchar *index_file_path = NULL;
294 GMappedFile *mapped_file = NULL;
295 gsize filesize;
97ade20b
JG
296 const char *mmap_begin = NULL, *file_pos = NULL;
297 const struct ctf_packet_index_file_hdr *header = NULL;
298 struct ctf_fs_ds_index *index = NULL;
de38c26a 299 struct ctf_fs_ds_index_entry *index_entry = NULL, *prev_index_entry = NULL;
b6c3dcb2
JG
300 uint64_t total_packets_size = 0;
301 size_t file_index_entry_size;
302 size_t file_entry_count;
303 size_t i;
44c440bc 304 struct ctf_stream_class *sc;
d6e69534 305 struct bt_msg_iter_packet_properties props;
97ade20b 306
4c65a157 307 BT_COMP_LOGI("Building index from .idx file of stream file %s",
97ade20b 308 ds_file->file->path->str);
41693723 309 ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
97ade20b 310 if (ret) {
4c65a157 311 BT_COMP_LOGI_STR("Cannot read first packet's header and context fields.");
44c440bc
PP
312 goto error;
313 }
314
44c440bc
PP
315 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
316 props.stream_class_id);
317 BT_ASSERT(sc);
318 if (!sc->default_clock_class) {
4c65a157 319 BT_COMP_LOGI_STR("Cannot find stream class's default clock class.");
97ade20b
JG
320 goto error;
321 }
b6c3dcb2
JG
322
323 /* Look for index file in relative path index/name.idx. */
94cf822e 324 basename = g_path_get_basename(ds_file->file->path->str);
b6c3dcb2 325 if (!basename) {
4c65a157 326 BT_COMP_LOGE("Cannot get the basename of datastream file %s",
55314f2a 327 ds_file->file->path->str);
97ade20b 328 goto error;
b6c3dcb2
JG
329 }
330
94cf822e 331 directory = g_path_get_dirname(ds_file->file->path->str);
b6c3dcb2 332 if (!directory) {
4c65a157 333 BT_COMP_LOGE("Cannot get dirname of datastream file %s",
55314f2a 334 ds_file->file->path->str);
97ade20b 335 goto error;
b6c3dcb2
JG
336 }
337
338 index_basename = g_string_new(basename);
339 if (!index_basename) {
4c65a157 340 BT_COMP_LOGE_STR("Cannot allocate index file basename string");
97ade20b 341 goto error;
b6c3dcb2
JG
342 }
343
344 g_string_append(index_basename, ".idx");
345 index_file_path = g_build_filename(directory, "index",
346 index_basename->str, NULL);
347 mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL);
06367fa3 348 if (!mapped_file) {
4c65a157 349 BT_COMP_LOGD("Cannot create new mapped file %s",
55314f2a 350 index_file_path);
97ade20b 351 goto error;
06367fa3 352 }
d14940a7
JG
353
354 /*
355 * The g_mapped_file API limits us to 4GB files on 32-bit.
356 * Traces with such large indexes have never been seen in the wild,
357 * but this would need to be adjusted to support them.
358 */
b6c3dcb2
JG
359 filesize = g_mapped_file_get_length(mapped_file);
360 if (filesize < sizeof(*header)) {
4c65a157 361 BT_COMP_LOGW("Invalid LTTng trace index file: "
d14940a7
JG
362 "file size (%zu bytes) < header size (%zu bytes)",
363 filesize, sizeof(*header));
97ade20b 364 goto error;
b6c3dcb2
JG
365 }
366
367 mmap_begin = g_mapped_file_get_contents(mapped_file);
368 header = (struct ctf_packet_index_file_hdr *) mmap_begin;
369
370 file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header);
371 if (be32toh(header->magic) != CTF_INDEX_MAGIC) {
4c65a157 372 BT_COMP_LOGW_STR("Invalid LTTng trace index: \"magic\" field validation failed");
97ade20b 373 goto error;
b6c3dcb2 374 }
b6c3dcb2
JG
375
376 file_index_entry_size = be32toh(header->packet_index_len);
377 file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size;
97ade20b 378 if ((filesize - sizeof(*header)) % file_index_entry_size) {
4c65a157 379 BT_COMP_LOGW("Invalid LTTng trace index: the index's size after the header "
d14940a7
JG
380 "(%zu bytes) is not a multiple of the index entry size "
381 "(%zu bytes)", (filesize - sizeof(*header)),
382 sizeof(*header));
97ade20b 383 goto error;
b6c3dcb2
JG
384 }
385
4c65a157 386 index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
97ade20b
JG
387 if (!index) {
388 goto error;
b6c3dcb2 389 }
97ade20b 390
b6c3dcb2
JG
391 for (i = 0; i < file_entry_count; i++) {
392 struct ctf_packet_index *file_index =
393 (struct ctf_packet_index *) file_pos;
394 uint64_t packet_size = be64toh(file_index->packet_size);
395
396 if (packet_size % CHAR_BIT) {
4c65a157 397 BT_COMP_LOGW("Invalid packet size encountered in LTTng trace index file");
97ade20b 398 goto error;
b6c3dcb2
JG
399 }
400
7ed5243a
FD
401 index_entry = g_new0(struct ctf_fs_ds_index_entry, 1);
402 if (!index_entry) {
403 goto error;
404 }
405
b6c3dcb2
JG
406 /* Convert size in bits to bytes. */
407 packet_size /= CHAR_BIT;
97ade20b 408 index_entry->packet_size = packet_size;
b6c3dcb2 409
97ade20b 410 index_entry->offset = be64toh(file_index->offset);
de38c26a 411 if (i != 0 && index_entry->offset < prev_index_entry->offset) {
4c65a157 412 BT_COMP_LOGW("Invalid, non-monotonic, packet offset encountered in LTTng trace index file: "
d14940a7 413 "previous offset=%" PRIu64 ", current offset=%" PRIu64,
9dd33658 414 prev_index_entry->offset, index_entry->offset);
97ade20b 415 goto error;
b6c3dcb2
JG
416 }
417
97ade20b
JG
418 index_entry->timestamp_begin = be64toh(file_index->timestamp_begin);
419 index_entry->timestamp_end = be64toh(file_index->timestamp_end);
420 if (index_entry->timestamp_end < index_entry->timestamp_begin) {
4c65a157 421 BT_COMP_LOGW("Invalid packet time bounds encountered in LTTng trace index file (begin > end): "
d14940a7
JG
422 "timestamp_begin=%" PRIu64 "timestamp_end=%" PRIu64,
423 index_entry->timestamp_begin,
424 index_entry->timestamp_end);
97ade20b
JG
425 goto error;
426 }
427
428 /* Convert the packet's bound to nanoseconds since Epoch. */
44c440bc 429 ret = convert_cycles_to_ns(sc->default_clock_class,
97ade20b
JG
430 index_entry->timestamp_begin,
431 &index_entry->timestamp_begin_ns);
432 if (ret) {
4c65a157 433 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing");
97ade20b
JG
434 goto error;
435 }
44c440bc 436 ret = convert_cycles_to_ns(sc->default_clock_class,
97ade20b
JG
437 index_entry->timestamp_end,
438 &index_entry->timestamp_end_ns);
439 if (ret) {
4c65a157 440 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing");
97ade20b 441 goto error;
b6c3dcb2
JG
442 }
443
444 total_packets_size += packet_size;
445 file_pos += file_index_entry_size;
7ed5243a
FD
446
447 g_ptr_array_add(index->entries, index_entry);
de38c26a 448 prev_index_entry = index_entry;
b6c3dcb2
JG
449 }
450
451 /* Validate that the index addresses the complete stream. */
94cf822e 452 if (ds_file->file->size != total_packets_size) {
4c65a157 453 BT_COMP_LOGW("Invalid LTTng trace index file; indexed size != stream file size: "
9e0c8dbb 454 "file-size=%" PRIu64 ", total-packets-size=%" PRIu64,
d14940a7 455 ds_file->file->size, total_packets_size);
97ade20b 456 goto error;
b6c3dcb2
JG
457 }
458end:
459 g_free(directory);
460 g_free(basename);
461 g_free(index_file_path);
06367fa3
JG
462 if (index_basename) {
463 g_string_free(index_basename, TRUE);
464 }
465 if (mapped_file) {
466 g_mapped_file_unref(mapped_file);
467 }
97ade20b
JG
468 return index;
469error:
470 ctf_fs_ds_index_destroy(index);
7ed5243a 471 g_free(index_entry);
97ade20b 472 index = NULL;
b6c3dcb2
JG
473 goto end;
474}
475
9e0c8dbb
JG
476static
477int init_index_entry(struct ctf_fs_ds_index_entry *entry,
44c440bc 478 struct ctf_fs_ds_file *ds_file,
d6e69534 479 struct bt_msg_iter_packet_properties *props,
44c440bc 480 off_t packet_size, off_t packet_offset)
9e0c8dbb 481{
ca79a87c 482 int ret = 0;
44c440bc 483 struct ctf_stream_class *sc;
9e0c8dbb 484
44c440bc
PP
485 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
486 props->stream_class_id);
487 BT_ASSERT(sc);
f6ccaed9 488 BT_ASSERT(packet_offset >= 0);
9e0c8dbb 489 entry->offset = packet_offset;
f6ccaed9 490 BT_ASSERT(packet_size >= 0);
9e0c8dbb
JG
491 entry->packet_size = packet_size;
492
83ebb7f1
PP
493 if (props->snapshots.beginning_clock != UINT64_C(-1)) {
494 /* Convert the packet's bound to nanoseconds since Epoch. */
495 ret = convert_cycles_to_ns(sc->default_clock_class,
496 props->snapshots.beginning_clock,
497 &entry->timestamp_begin_ns);
498 if (ret) {
4c65a157 499 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
83ebb7f1
PP
500 goto end;
501 }
502 } else {
503 entry->timestamp_begin_ns = UINT64_C(-1);
9e0c8dbb
JG
504 }
505
83ebb7f1
PP
506 if (props->snapshots.end_clock != UINT64_C(-1)) {
507 ret = convert_cycles_to_ns(sc->default_clock_class,
508 props->snapshots.end_clock,
509 &entry->timestamp_end_ns);
510 if (ret) {
4c65a157 511 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
83ebb7f1
PP
512 goto end;
513 }
514 } else {
515 entry->timestamp_end_ns = UINT64_C(-1);
9e0c8dbb 516 }
0b29603d 517
9e0c8dbb 518end:
9e0c8dbb
JG
519 return ret;
520}
521
522static
523struct ctf_fs_ds_index *build_index_from_stream_file(
524 struct ctf_fs_ds_file *ds_file)
525{
526 int ret;
527 struct ctf_fs_ds_index *index = NULL;
9eb4d33d 528 enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK;
fc917f65 529 off_t current_packet_offset_bytes = 0;
9e0c8dbb 530
4c65a157 531 BT_COMP_LOGI("Indexing stream file %s", ds_file->file->path->str);
9e0c8dbb 532
4c65a157 533 index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
9e0c8dbb
JG
534 if (!index) {
535 goto error;
536 }
537
538 do {
44c440bc 539 off_t current_packet_size_bytes;
7ed5243a 540 struct ctf_fs_ds_index_entry *index_entry;
d6e69534 541 struct bt_msg_iter_packet_properties props;
9e0c8dbb 542
fc917f65 543 if (current_packet_offset_bytes < 0) {
4c65a157 544 BT_COMP_LOGE_STR("Cannot get the current packet's offset.");
fc917f65
PP
545 goto error;
546 } else if (current_packet_offset_bytes > ds_file->file->size) {
4c65a157 547 BT_COMP_LOGE_STR("Unexpected current packet's offset (larger than file).");
fc917f65
PP
548 goto error;
549 } else if (current_packet_offset_bytes == ds_file->file->size) {
550 /* No more data */
551 break;
552 }
553
554 iter_status = bt_msg_iter_seek(ds_file->msg_iter,
555 current_packet_offset_bytes);
d6e69534 556 if (iter_status != BT_MSG_ITER_STATUS_OK) {
9e0c8dbb
JG
557 goto error;
558 }
312c056a 559
fc917f65
PP
560 iter_status = bt_msg_iter_get_packet_properties(
561 ds_file->msg_iter, &props);
562 if (iter_status != BT_MSG_ITER_STATUS_OK) {
9e0c8dbb
JG
563 goto error;
564 }
565
fc917f65
PP
566 if (props.exp_packet_total_size >= 0) {
567 current_packet_size_bytes =
568 (uint64_t) props.exp_packet_total_size / 8;
569 } else {
570 current_packet_size_bytes = ds_file->file->size;
571 }
9e0c8dbb 572
fc917f65 573 if (current_packet_offset_bytes + current_packet_size_bytes >
9e0c8dbb 574 ds_file->file->size) {
4c65a157 575 BT_COMP_LOGW("Invalid packet size reported in file: stream=\"%s\", "
9e0c8dbb
JG
576 "packet-offset=%jd, packet-size-bytes=%jd, "
577 "file-size=%jd",
578 ds_file->file->path->str,
df0fc0bf
JR
579 (intmax_t) current_packet_offset_bytes,
580 (intmax_t) current_packet_size_bytes,
581 (intmax_t) ds_file->file->size);
9e0c8dbb
JG
582 goto error;
583 }
584
7ed5243a
FD
585 index_entry = g_new0(struct ctf_fs_ds_index_entry, 1);
586 if (!index_entry) {
4c65a157 587 BT_COMP_LOGE_STR("Failed to allocate a new index entry.");
9e0c8dbb
JG
588 goto error;
589 }
590
7ed5243a 591 ret = init_index_entry(index_entry, ds_file, &props,
fc917f65 592 current_packet_size_bytes, current_packet_offset_bytes);
9e0c8dbb 593 if (ret) {
7ed5243a 594 g_free(index_entry);
9e0c8dbb
JG
595 goto error;
596 }
7ed5243a
FD
597
598 g_ptr_array_add(index->entries, index_entry);
599
ca633588 600 current_packet_offset_bytes += current_packet_size_bytes;
4c65a157 601 BT_COMP_LOGD("Seeking to next packet: current-packet-offset=%jd, "
ca633588 602 "next-packet-offset=%jd",
df0fc0bf
JR
603 (intmax_t) (current_packet_offset_bytes - current_packet_size_bytes),
604 (intmax_t) current_packet_offset_bytes);
ca633588 605
d6e69534 606 } while (iter_status == BT_MSG_ITER_STATUS_OK);
9e0c8dbb 607
60363f2f 608 if (iter_status != BT_MSG_ITER_STATUS_OK) {
9e0c8dbb
JG
609 goto error;
610 }
312c056a 611
9e0c8dbb 612end:
9e0c8dbb 613 return index;
312c056a 614
9e0c8dbb
JG
615error:
616 ctf_fs_ds_index_destroy(index);
617 index = NULL;
618 goto end;
619}
620
e7a4393b 621BT_HIDDEN
94cf822e
PP
622struct ctf_fs_ds_file *ctf_fs_ds_file_create(
623 struct ctf_fs_trace *ctf_fs_trace,
d6e69534
PP
624 bt_self_message_iterator *pc_msg_iter,
625 struct bt_msg_iter *msg_iter,
98903a3e
PP
626 bt_stream *stream, const char *path,
627 bt_logging_level log_level)
e98a2d6e 628{
b6c3dcb2 629 int ret;
98903a3e 630 const size_t page_size = bt_common_get_page_size(log_level);
94cf822e 631 struct ctf_fs_ds_file *ds_file = g_new0(struct ctf_fs_ds_file, 1);
e98a2d6e 632
94cf822e 633 if (!ds_file) {
e98a2d6e
PP
634 goto error;
635 }
636
98903a3e 637 ds_file->log_level = log_level;
4c65a157 638 ds_file->self_comp = ctf_fs_trace->self_comp;
d6e69534 639 ds_file->pc_msg_iter = pc_msg_iter;
4c65a157 640 ds_file->file = ctf_fs_file_create(log_level, ds_file->self_comp);
94cf822e 641 if (!ds_file->file) {
4f1f88a6
PP
642 goto error;
643 }
644
398454ed 645 ds_file->stream = stream;
c5b9b441 646 bt_stream_get_ref(ds_file->stream);
44c440bc 647 ds_file->metadata = ctf_fs_trace->metadata;
94cf822e 648 g_string_assign(ds_file->file->path, path);
55314f2a 649 ret = ctf_fs_file_open(ds_file->file, "rb");
4f1f88a6
PP
650 if (ret) {
651 goto error;
652 }
653
d6e69534
PP
654 ds_file->msg_iter = msg_iter;
655 bt_msg_iter_set_medops_data(ds_file->msg_iter, ds_file);
656 if (!ds_file->msg_iter) {
e98a2d6e
PP
657 goto error;
658 }
5b29e799 659
55314f2a 660 ds_file->mmap_max_len = page_size * 2048;
94cf822e 661
e98a2d6e 662 goto end;
1a9f7075 663
e98a2d6e 664error:
78586d8a 665 /* Do not touch "borrowed" file. */
94cf822e
PP
666 ctf_fs_ds_file_destroy(ds_file);
667 ds_file = NULL;
1a9f7075 668
e98a2d6e 669end:
94cf822e 670 return ds_file;
e98a2d6e
PP
671}
672
97ade20b
JG
673BT_HIDDEN
674struct ctf_fs_ds_index *ctf_fs_ds_file_build_index(
675 struct ctf_fs_ds_file *ds_file)
676{
9e0c8dbb
JG
677 struct ctf_fs_ds_index *index;
678
679 index = build_index_from_idx_file(ds_file);
680 if (index) {
681 goto end;
682 }
683
4c65a157 684 BT_COMP_LOGI("Failed to build index from .index file; "
9e0c8dbb
JG
685 "falling back to stream indexing.");
686 index = build_index_from_stream_file(ds_file);
687end:
688 return index;
97ade20b
JG
689}
690
7ed5243a 691BT_HIDDEN
4c65a157
PP
692struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level,
693 bt_self_component *self_comp)
7ed5243a
FD
694{
695 struct ctf_fs_ds_index *index = g_new0(struct ctf_fs_ds_index, 1);
696
697 if (!index) {
4c65a157 698 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
98903a3e 699 "Failed to allocate index");
7ed5243a
FD
700 goto error;
701 }
702
703 index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) g_free);
704 if (!index->entries) {
4c65a157 705 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
98903a3e 706 "Failed to allocate index entries.");
7ed5243a
FD
707 goto error;
708 }
709
710 goto end;
711
712error:
713 ctf_fs_ds_index_destroy(index);
714 index = NULL;
715end:
716 return index;
717}
718
5b29e799 719BT_HIDDEN
94cf822e 720void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
e98a2d6e 721{
94cf822e 722 if (!ds_file) {
5b29e799 723 return;
043e2020
JG
724 }
725
c5b9b441 726 bt_stream_put_ref(ds_file->stream);
94cf822e 727 (void) ds_file_munmap(ds_file);
0982a26d 728
94cf822e
PP
729 if (ds_file->file) {
730 ctf_fs_file_destroy(ds_file->file);
e98a2d6e
PP
731 }
732
94cf822e 733 g_free(ds_file);
e98a2d6e 734}
4f1f88a6
PP
735
736BT_HIDDEN
d24d5663 737bt_component_class_message_iterator_next_method_status ctf_fs_ds_file_next(
d4393e08 738 struct ctf_fs_ds_file *ds_file,
d6e69534 739 bt_message **msg)
4f1f88a6 740{
d6e69534 741 enum bt_msg_iter_status msg_iter_status;
d24d5663 742 bt_component_class_message_iterator_next_method_status status;
4f1f88a6 743
d6e69534
PP
744 msg_iter_status = bt_msg_iter_get_next_message(
745 ds_file->msg_iter, ds_file->pc_msg_iter, msg);
4f1f88a6 746
d6e69534
PP
747 switch (msg_iter_status) {
748 case BT_MSG_ITER_STATUS_EOF:
d24d5663 749 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_END;
4f1f88a6 750 break;
d6e69534 751 case BT_MSG_ITER_STATUS_OK:
d24d5663 752 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK;
4f1f88a6 753 break;
d6e69534 754 case BT_MSG_ITER_STATUS_AGAIN:
4f1f88a6
PP
755 /*
756 * Should not make it this far as this is
757 * medium-specific; there is nothing for the user to do
758 * and it should have been handled upstream.
759 */
0fbb9a9f 760 abort();
d6e69534
PP
761 case BT_MSG_ITER_STATUS_INVAL:
762 case BT_MSG_ITER_STATUS_ERROR:
4f1f88a6 763 default:
d24d5663 764 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR;
4f1f88a6
PP
765 break;
766 }
d4393e08 767 return status;
4f1f88a6 768}
94cf822e 769
97ade20b
JG
770BT_HIDDEN
771void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
772{
773 if (!index) {
774 return;
775 }
776
777 if (index->entries) {
7ed5243a 778 g_ptr_array_free(index->entries, TRUE);
97ade20b
JG
779 }
780 g_free(index);
781}
This page took 0.097172 seconds and 4 git commands to generate.