lib: add aliases for Babeltrace enumeration types
[babeltrace.git] / 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
0fbb9a9f 25#include <stdlib.h>
e98a2d6e
PP
26#include <stdio.h>
27#include <stdint.h>
28#include <stdlib.h>
29#include <stdbool.h>
30#include <glib.h>
31#include <inttypes.h>
8f76831a 32#include <babeltrace/compat/mman-internal.h>
e9383dfd 33#include <babeltrace/endian-internal.h>
e0831b38 34#include <babeltrace/babeltrace.h>
55314f2a 35#include <babeltrace/common-internal.h>
78586d8a
JG
36#include "file.h"
37#include "metadata.h"
b09a5592 38#include "../common/msg-iter/msg-iter.h"
8b45963b 39#include <babeltrace/assert-internal.h>
94cf822e 40#include "data-stream-file.h"
e9383dfd 41#include <string.h>
e98a2d6e 42
55314f2a
JG
43#define BT_LOG_TAG "PLUGIN-CTF-FS-SRC-DS"
44#include "logging.h"
e98a2d6e 45
4f1f88a6 46static inline
94cf822e 47size_t remaining_mmap_bytes(struct ctf_fs_ds_file *ds_file)
e98a2d6e 48{
52eb1a72 49 return ds_file->mmap_len - ds_file->request_offset;
e98a2d6e
PP
50}
51
5b29e799 52static
94cf822e 53int ds_file_munmap(struct ctf_fs_ds_file *ds_file)
e98a2d6e 54{
fc9a526c 55 int ret = 0;
e98a2d6e 56
d238196d 57 if (!ds_file || !ds_file->mmap_addr) {
94cf822e
PP
58 goto end;
59 }
60
a555e971 61 if (bt_munmap(ds_file->mmap_addr, ds_file->mmap_len)) {
2a48e5ae
JG
62 BT_LOGE_ERRNO("Cannot memory-unmap file",
63 ": address=%p, size=%zu, file_path=\"%s\", file=%p",
94cf822e 64 ds_file->mmap_addr, ds_file->mmap_len,
bb230c9b 65 ds_file->file ? ds_file->file->path->str : "NULL",
2a48e5ae 66 ds_file->file ? ds_file->file->fp : NULL);
fc9a526c
JG
67 ret = -1;
68 goto end;
e98a2d6e 69 }
94cf822e
PP
70
71 ds_file->mmap_addr = NULL;
72
fc9a526c
JG
73end:
74 return ret;
e98a2d6e
PP
75}
76
5b29e799 77static
b09a5592 78enum bt_msg_iter_medium_status ds_file_mmap_next(
94cf822e 79 struct ctf_fs_ds_file *ds_file)
e98a2d6e 80{
b09a5592
PP
81 enum bt_msg_iter_medium_status ret =
82 BT_MSG_ITER_MEDIUM_STATUS_OK;
e98a2d6e
PP
83
84 /* Unmap old region */
94cf822e
PP
85 if (ds_file->mmap_addr) {
86 if (ds_file_munmap(ds_file)) {
e98a2d6e
PP
87 goto error;
88 }
89
7b7d8091 90 /*
52eb1a72 91 * mmap_len is guaranteed to be page-aligned except on the
7b7d8091
JG
92 * last mapping where it may not be possible (since the file's
93 * size itself may not be a page multiple).
94 */
52eb1a72 95 ds_file->mmap_offset += ds_file->mmap_len;
94cf822e 96 ds_file->request_offset = 0;
e98a2d6e
PP
97 }
98
52eb1a72 99 ds_file->mmap_len = MIN(ds_file->file->size - ds_file->mmap_offset,
94cf822e 100 ds_file->mmap_max_len);
52eb1a72 101 if (ds_file->mmap_len == 0) {
b09a5592 102 ret = BT_MSG_ITER_MEDIUM_STATUS_EOF;
e0f6a64a
JG
103 goto end;
104 }
e98a2d6e 105 /* Map new region */
8b45963b 106 BT_ASSERT(ds_file->mmap_len);
a555e971 107 ds_file->mmap_addr = bt_mmap((void *) 0, ds_file->mmap_len,
94cf822e
PP
108 PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp),
109 ds_file->mmap_offset);
110 if (ds_file->mmap_addr == MAP_FAILED) {
41342c71 111 BT_LOGE("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %jd: %s",
94cf822e 112 ds_file->mmap_len, ds_file->file->path->str,
41342c71 113 ds_file->file->fp, (intmax_t) ds_file->mmap_offset,
78586d8a 114 strerror(errno));
e98a2d6e
PP
115 goto error;
116 }
117
118 goto end;
e98a2d6e 119error:
94cf822e 120 ds_file_munmap(ds_file);
b09a5592 121 ret = BT_MSG_ITER_MEDIUM_STATUS_ERROR;
e98a2d6e
PP
122end:
123 return ret;
124}
125
5b29e799 126static
b09a5592 127enum bt_msg_iter_medium_status medop_request_bytes(
e98a2d6e
PP
128 size_t request_sz, uint8_t **buffer_addr,
129 size_t *buffer_sz, void *data)
130{
b09a5592
PP
131 enum bt_msg_iter_medium_status status =
132 BT_MSG_ITER_MEDIUM_STATUS_OK;
94cf822e 133 struct ctf_fs_ds_file *ds_file = data;
e98a2d6e
PP
134
135 if (request_sz == 0) {
136 goto end;
137 }
138
e98a2d6e 139 /* Check if we have at least one memory-mapped byte left */
94cf822e 140 if (remaining_mmap_bytes(ds_file) == 0) {
e98a2d6e 141 /* Are we at the end of the file? */
94cf822e 142 if (ds_file->mmap_offset >= ds_file->file->size) {
55314f2a 143 BT_LOGD("Reached end of file \"%s\" (%p)",
94cf822e 144 ds_file->file->path->str, ds_file->file->fp);
b09a5592 145 status = BT_MSG_ITER_MEDIUM_STATUS_EOF;
e98a2d6e
PP
146 goto end;
147 }
148
94cf822e 149 status = ds_file_mmap_next(ds_file);
e0f6a64a 150 switch (status) {
b09a5592 151 case BT_MSG_ITER_MEDIUM_STATUS_OK:
e0f6a64a 152 break;
b09a5592 153 case BT_MSG_ITER_MEDIUM_STATUS_EOF:
e0f6a64a
JG
154 goto end;
155 default:
55314f2a 156 BT_LOGE("Cannot memory-map next region of file \"%s\" (%p)",
94cf822e
PP
157 ds_file->file->path->str,
158 ds_file->file->fp);
e98a2d6e
PP
159 goto error;
160 }
161 }
162
94cf822e
PP
163 *buffer_sz = MIN(remaining_mmap_bytes(ds_file), request_sz);
164 *buffer_addr = ((uint8_t *) ds_file->mmap_addr) + ds_file->request_offset;
165 ds_file->request_offset += *buffer_sz;
e98a2d6e
PP
166 goto end;
167
168error:
b09a5592 169 status = BT_MSG_ITER_MEDIUM_STATUS_ERROR;
e98a2d6e
PP
170
171end:
172 return status;
173}
174
5b29e799 175static
8eee8ea2
PP
176bt_stream *medop_borrow_stream(
177 bt_stream_class *stream_class, int64_t stream_id,
0659c536 178 void *data)
e98a2d6e 179{
94cf822e 180 struct ctf_fs_ds_file *ds_file = data;
8eee8ea2
PP
181 bt_stream_class *ds_file_stream_class;
182 bt_stream *stream = NULL;
9e550e5f 183
78cf9df6 184 ds_file_stream_class = bt_stream_borrow_class(
9e550e5f 185 ds_file->stream);
94cf822e 186
94cf822e
PP
187 if (stream_class != ds_file_stream_class) {
188 /*
189 * Not supported: two packets described by two different
190 * stream classes within the same data stream file.
191 */
192 goto end;
e98a2d6e
PP
193 }
194
94cf822e
PP
195 stream = ds_file->stream;
196
197end:
198 return stream;
e98a2d6e
PP
199}
200
bb230c9b 201static
b09a5592
PP
202enum bt_msg_iter_medium_status medop_seek(
203 enum bt_msg_iter_seek_whence whence, off_t offset,
bb230c9b
JG
204 void *data)
205{
b09a5592
PP
206 enum bt_msg_iter_medium_status ret =
207 BT_MSG_ITER_MEDIUM_STATUS_OK;
bb230c9b
JG
208 struct ctf_fs_ds_file *ds_file = data;
209 off_t file_size = ds_file->file->size;
210
b09a5592 211 if (whence != BT_MSG_ITER_SEEK_WHENCE_SET ||
bb230c9b
JG
212 offset < 0 || offset > file_size) {
213 BT_LOGE("Invalid medium seek request: whence=%d, offset=%jd, "
214 "file-size=%jd", (int) whence, offset,
215 file_size);
b09a5592 216 ret = BT_MSG_ITER_MEDIUM_STATUS_INVAL;
bb230c9b
JG
217 goto end;
218 }
219
220 /*
221 * Determine whether or not the destination is contained within the
222 * current mapping.
223 */
224 if (ds_file->mmap_addr && (offset < ds_file->mmap_offset ||
225 offset >= ds_file->mmap_offset + ds_file->mmap_len)) {
226 int unmap_ret;
227 off_t offset_in_mapping = offset % bt_common_get_page_size();
228
229 BT_LOGD("Medium seek request cannot be accomodated by the current "
af5e91e4 230 "file mapping: offset=%jd, mmap-offset=%jd, "
bb230c9b
JG
231 "mmap-len=%zu", offset, ds_file->mmap_offset,
232 ds_file->mmap_len);
233 unmap_ret = ds_file_munmap(ds_file);
234 if (unmap_ret) {
b09a5592 235 ret = BT_MSG_ITER_MEDIUM_STATUS_ERROR;
bb230c9b
JG
236 goto end;
237 }
238
239 ds_file->mmap_offset = offset - offset_in_mapping;
240 ds_file->request_offset = offset_in_mapping;
241 ret = ds_file_mmap_next(ds_file);
b09a5592 242 if (ret != BT_MSG_ITER_MEDIUM_STATUS_OK) {
bb230c9b
JG
243 goto end;
244 }
245 } else {
246 ds_file->request_offset = offset - ds_file->mmap_offset;
247 }
248
249 ds_file->end_reached = (offset == file_size);
250end:
251 return ret;
252}
253
55fa6491 254BT_HIDDEN
b09a5592 255struct bt_msg_iter_medium_ops ctf_fs_ds_file_medops = {
e98a2d6e 256 .request_bytes = medop_request_bytes,
a6918753 257 .borrow_stream = medop_borrow_stream,
bb230c9b 258 .seek = medop_seek,
e98a2d6e 259};
55fa6491 260
97ade20b
JG
261static
262struct ctf_fs_ds_index *ctf_fs_ds_index_create(size_t length)
263{
264 struct ctf_fs_ds_index *index = g_new0(struct ctf_fs_ds_index, 1);
265
266 if (!index) {
267 BT_LOGE_STR("Failed to allocate index");
268 goto error;
269 }
270
271 index->entries = g_array_sized_new(FALSE, TRUE,
272 sizeof(struct ctf_fs_ds_index_entry), length);
273 if (!index->entries) {
274 BT_LOGE("Failed to allocate %zu index entries.", length);
275 goto error;
276 }
277 g_array_set_size(index->entries, length);
278end:
279 return index;
280error:
281 ctf_fs_ds_index_destroy(index);
282 goto end;
283}
e98a2d6e 284
bb230c9b
JG
285/* Returns a new, zeroed, index entry. */
286static
287struct ctf_fs_ds_index_entry *ctf_fs_ds_index_add_new_entry(
288 struct ctf_fs_ds_index *index)
289{
290 g_array_set_size(index->entries, index->entries->len + 1);
291 return &g_array_index(index->entries, struct ctf_fs_ds_index_entry,
292 index->entries->len - 1);
293}
294
97ade20b 295static
8eee8ea2 296int convert_cycles_to_ns(bt_clock_class *clock_class,
97ade20b 297 uint64_t cycles, int64_t *ns)
b6c3dcb2 298{
78cf9df6
PP
299 return bt_clock_class_cycles_to_ns_from_origin(clock_class, cycles,
300 ns);
97ade20b
JG
301}
302
303static
304struct ctf_fs_ds_index *build_index_from_idx_file(
305 struct ctf_fs_ds_file *ds_file)
306{
307 int ret;
b6c3dcb2
JG
308 gchar *directory = NULL;
309 gchar *basename = NULL;
310 GString *index_basename = NULL;
311 gchar *index_file_path = NULL;
312 GMappedFile *mapped_file = NULL;
313 gsize filesize;
97ade20b
JG
314 const char *mmap_begin = NULL, *file_pos = NULL;
315 const struct ctf_packet_index_file_hdr *header = NULL;
316 struct ctf_fs_ds_index *index = NULL;
317 struct ctf_fs_ds_index_entry *index_entry = NULL;
b6c3dcb2
JG
318 uint64_t total_packets_size = 0;
319 size_t file_index_entry_size;
320 size_t file_entry_count;
321 size_t i;
7b33a0e0 322 struct ctf_stream_class *sc;
b09a5592 323 struct bt_msg_iter_packet_properties props;
97ade20b
JG
324
325 BT_LOGD("Building index from .idx file of stream file %s",
326 ds_file->file->path->str);
327
b09a5592
PP
328 ret = bt_msg_iter_borrow_packet_header_context_fields(
329 ds_file->msg_iter, NULL, NULL);
97ade20b 330 if (ret) {
7b33a0e0
PP
331 BT_LOGD_STR("Cannot borrow first packet's header and context "
332 "fields.");
333 goto error;
334 }
335
b09a5592 336 ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
7b33a0e0
PP
337 BT_ASSERT(ret == 0);
338 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
339 props.stream_class_id);
340 BT_ASSERT(sc);
341 if (!sc->default_clock_class) {
342 BT_LOGD_STR("Cannot find stream class's default clock class.");
97ade20b
JG
343 goto error;
344 }
b6c3dcb2
JG
345
346 /* Look for index file in relative path index/name.idx. */
94cf822e 347 basename = g_path_get_basename(ds_file->file->path->str);
b6c3dcb2 348 if (!basename) {
97ade20b 349 BT_LOGE("Cannot get the basename of datastream file %s",
55314f2a 350 ds_file->file->path->str);
97ade20b 351 goto error;
b6c3dcb2
JG
352 }
353
94cf822e 354 directory = g_path_get_dirname(ds_file->file->path->str);
b6c3dcb2 355 if (!directory) {
97ade20b 356 BT_LOGE("Cannot get dirname of datastream file %s",
55314f2a 357 ds_file->file->path->str);
97ade20b 358 goto error;
b6c3dcb2
JG
359 }
360
361 index_basename = g_string_new(basename);
362 if (!index_basename) {
bb230c9b 363 BT_LOGE_STR("Cannot allocate index file basename string");
97ade20b 364 goto error;
b6c3dcb2
JG
365 }
366
367 g_string_append(index_basename, ".idx");
368 index_file_path = g_build_filename(directory, "index",
369 index_basename->str, NULL);
370 mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL);
06367fa3 371 if (!mapped_file) {
97ade20b 372 BT_LOGD("Cannot create new mapped file %s",
55314f2a 373 index_file_path);
97ade20b 374 goto error;
06367fa3 375 }
65cbebef
JG
376
377 /*
378 * The g_mapped_file API limits us to 4GB files on 32-bit.
379 * Traces with such large indexes have never been seen in the wild,
380 * but this would need to be adjusted to support them.
381 */
b6c3dcb2
JG
382 filesize = g_mapped_file_get_length(mapped_file);
383 if (filesize < sizeof(*header)) {
65cbebef
JG
384 BT_LOGW("Invalid LTTng trace index file: "
385 "file size (%zu bytes) < header size (%zu bytes)",
386 filesize, sizeof(*header));
97ade20b 387 goto error;
b6c3dcb2
JG
388 }
389
390 mmap_begin = g_mapped_file_get_contents(mapped_file);
391 header = (struct ctf_packet_index_file_hdr *) mmap_begin;
392
393 file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header);
394 if (be32toh(header->magic) != CTF_INDEX_MAGIC) {
bb230c9b 395 BT_LOGW_STR("Invalid LTTng trace index: \"magic\" field validation failed");
97ade20b 396 goto error;
b6c3dcb2 397 }
b6c3dcb2
JG
398
399 file_index_entry_size = be32toh(header->packet_index_len);
400 file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size;
97ade20b 401 if ((filesize - sizeof(*header)) % file_index_entry_size) {
65cbebef
JG
402 BT_LOGW("Invalid LTTng trace index: the index's size after the header "
403 "(%zu bytes) is not a multiple of the index entry size "
404 "(%zu bytes)", (filesize - sizeof(*header)),
405 sizeof(*header));
97ade20b 406 goto error;
b6c3dcb2
JG
407 }
408
97ade20b
JG
409 index = ctf_fs_ds_index_create(file_entry_count);
410 if (!index) {
411 goto error;
b6c3dcb2 412 }
97ade20b
JG
413
414 index_entry = (struct ctf_fs_ds_index_entry *) &g_array_index(
415 index->entries, struct ctf_fs_ds_index_entry, 0);
b6c3dcb2
JG
416 for (i = 0; i < file_entry_count; i++) {
417 struct ctf_packet_index *file_index =
418 (struct ctf_packet_index *) file_pos;
419 uint64_t packet_size = be64toh(file_index->packet_size);
420
421 if (packet_size % CHAR_BIT) {
65cbebef 422 BT_LOGW("Invalid packet size encountered in LTTng trace index file");
97ade20b 423 goto error;
b6c3dcb2
JG
424 }
425
426 /* Convert size in bits to bytes. */
427 packet_size /= CHAR_BIT;
97ade20b 428 index_entry->packet_size = packet_size;
b6c3dcb2 429
97ade20b
JG
430 index_entry->offset = be64toh(file_index->offset);
431 if (i != 0 && index_entry->offset < (index_entry - 1)->offset) {
65cbebef
JG
432 BT_LOGW("Invalid, non-monotonic, packet offset encountered in LTTng trace index file: "
433 "previous offset=%" PRIu64 ", current offset=%" PRIu64,
434 (index_entry - 1)->offset, index_entry->offset);
97ade20b 435 goto error;
b6c3dcb2
JG
436 }
437
97ade20b
JG
438 index_entry->timestamp_begin = be64toh(file_index->timestamp_begin);
439 index_entry->timestamp_end = be64toh(file_index->timestamp_end);
440 if (index_entry->timestamp_end < index_entry->timestamp_begin) {
65cbebef
JG
441 BT_LOGW("Invalid packet time bounds encountered in LTTng trace index file (begin > end): "
442 "timestamp_begin=%" PRIu64 "timestamp_end=%" PRIu64,
443 index_entry->timestamp_begin,
444 index_entry->timestamp_end);
97ade20b
JG
445 goto error;
446 }
447
448 /* Convert the packet's bound to nanoseconds since Epoch. */
7b33a0e0 449 ret = convert_cycles_to_ns(sc->default_clock_class,
97ade20b
JG
450 index_entry->timestamp_begin,
451 &index_entry->timestamp_begin_ns);
452 if (ret) {
bb230c9b 453 BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing");
97ade20b
JG
454 goto error;
455 }
7b33a0e0 456 ret = convert_cycles_to_ns(sc->default_clock_class,
97ade20b
JG
457 index_entry->timestamp_end,
458 &index_entry->timestamp_end_ns);
459 if (ret) {
bb230c9b 460 BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing");
97ade20b 461 goto error;
b6c3dcb2
JG
462 }
463
464 total_packets_size += packet_size;
465 file_pos += file_index_entry_size;
97ade20b 466 index_entry++;
b6c3dcb2
JG
467 }
468
469 /* Validate that the index addresses the complete stream. */
94cf822e 470 if (ds_file->file->size != total_packets_size) {
65cbebef 471 BT_LOGW("Invalid LTTng trace index file; indexed size != stream file size: "
bb230c9b 472 "file-size=%" PRIu64 ", total-packets-size=%" PRIu64,
65cbebef 473 ds_file->file->size, total_packets_size);
97ade20b 474 goto error;
b6c3dcb2
JG
475 }
476end:
477 g_free(directory);
478 g_free(basename);
479 g_free(index_file_path);
06367fa3
JG
480 if (index_basename) {
481 g_string_free(index_basename, TRUE);
482 }
483 if (mapped_file) {
484 g_mapped_file_unref(mapped_file);
485 }
97ade20b
JG
486 return index;
487error:
488 ctf_fs_ds_index_destroy(index);
489 index = NULL;
b6c3dcb2
JG
490 goto end;
491}
492
bb230c9b
JG
493static
494int init_index_entry(struct ctf_fs_ds_index_entry *entry,
7b33a0e0 495 struct ctf_fs_ds_file *ds_file,
b09a5592 496 struct bt_msg_iter_packet_properties *props,
7b33a0e0 497 off_t packet_size, off_t packet_offset)
bb230c9b
JG
498{
499 int ret;
7b33a0e0 500 struct ctf_stream_class *sc;
bb230c9b 501
7b33a0e0
PP
502 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
503 props->stream_class_id);
504 BT_ASSERT(sc);
8b45963b 505 BT_ASSERT(packet_offset >= 0);
bb230c9b 506 entry->offset = packet_offset;
8b45963b 507 BT_ASSERT(packet_size >= 0);
bb230c9b
JG
508 entry->packet_size = packet_size;
509
bb230c9b 510 /* Convert the packet's bound to nanoseconds since Epoch. */
7b33a0e0
PP
511 ret = convert_cycles_to_ns(sc->default_clock_class,
512 props->snapshots.beginning_clock,
bb230c9b
JG
513 &entry->timestamp_begin_ns);
514 if (ret) {
515 BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
516 goto end;
517 }
518
7b33a0e0
PP
519 ret = convert_cycles_to_ns(sc->default_clock_class,
520 props->snapshots.end_clock,
bb230c9b
JG
521 &entry->timestamp_end_ns);
522 if (ret) {
523 BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
524 goto end;
525 }
c43f6ee2 526
bb230c9b 527end:
bb230c9b
JG
528 return ret;
529}
530
531static
532struct ctf_fs_ds_index *build_index_from_stream_file(
533 struct ctf_fs_ds_file *ds_file)
534{
535 int ret;
536 struct ctf_fs_ds_index *index = NULL;
b09a5592 537 enum bt_msg_iter_status iter_status;
bb230c9b
JG
538
539 BT_LOGD("Indexing stream file %s", ds_file->file->path->str);
540
541 index = ctf_fs_ds_index_create(0);
542 if (!index) {
543 goto error;
544 }
545
546 do {
547 off_t current_packet_offset;
548 off_t next_packet_offset;
7b33a0e0 549 off_t current_packet_size_bytes;
bb230c9b 550 struct ctf_fs_ds_index_entry *entry;
b09a5592 551 struct bt_msg_iter_packet_properties props;
bb230c9b 552
b09a5592
PP
553 iter_status = bt_msg_iter_borrow_packet_header_context_fields(
554 ds_file->msg_iter, NULL, NULL);
555 if (iter_status != BT_MSG_ITER_STATUS_OK) {
556 if (iter_status == BT_MSG_ITER_STATUS_EOF) {
bb230c9b
JG
557 break;
558 }
559 goto error;
560 }
a6918753 561
b09a5592 562 ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter,
7b33a0e0
PP
563 &props);
564 BT_ASSERT(ret == 0);
565
bb230c9b 566 current_packet_offset =
b09a5592
PP
567 bt_msg_iter_get_current_packet_offset(
568 ds_file->msg_iter);
bb230c9b
JG
569 if (current_packet_offset < 0) {
570 BT_LOGE_STR("Cannot get the current packet's offset.");
571 goto error;
572 }
573
bb230c9b 574 current_packet_size_bytes =
7b33a0e0 575 ((props.exp_packet_total_size + 7) & ~7) / CHAR_BIT;
bb230c9b
JG
576
577 if (current_packet_offset + current_packet_size_bytes >
578 ds_file->file->size) {
579 BT_LOGW("Invalid packet size reported in file: stream=\"%s\", "
580 "packet-offset=%jd, packet-size-bytes=%jd, "
581 "file-size=%jd",
582 ds_file->file->path->str,
583 current_packet_offset,
584 current_packet_size_bytes,
585 ds_file->file->size);
586 goto error;
587 }
588
589 next_packet_offset = current_packet_offset +
a6918753 590 current_packet_size_bytes;
bb230c9b 591 BT_LOGD("Seeking to next packet: current-packet-offset=%jd, "
a6918753
PP
592 "next-packet-offset=%jd", current_packet_offset,
593 next_packet_offset);
bb230c9b
JG
594
595 entry = ctf_fs_ds_index_add_new_entry(index);
596 if (!entry) {
597 BT_LOGE_STR("Failed to allocate a new index entry.");
598 goto error;
599 }
600
7b33a0e0
PP
601 ret = init_index_entry(entry, ds_file, &props,
602 current_packet_size_bytes, current_packet_offset);
bb230c9b
JG
603 if (ret) {
604 goto error;
605 }
606
b09a5592 607 iter_status = bt_msg_iter_seek(ds_file->msg_iter,
bb230c9b 608 next_packet_offset);
b09a5592 609 } while (iter_status == BT_MSG_ITER_STATUS_OK);
bb230c9b 610
b09a5592 611 if (iter_status != BT_MSG_ITER_STATUS_EOF) {
bb230c9b
JG
612 goto error;
613 }
a6918753 614
bb230c9b 615end:
bb230c9b 616 return index;
a6918753 617
bb230c9b
JG
618error:
619 ctf_fs_ds_index_destroy(index);
620 index = NULL;
621 goto end;
622}
623
e7a4393b 624BT_HIDDEN
94cf822e
PP
625struct ctf_fs_ds_file *ctf_fs_ds_file_create(
626 struct ctf_fs_trace *ctf_fs_trace,
b09a5592
PP
627 bt_self_message_iterator *pc_msg_iter,
628 struct bt_msg_iter *msg_iter,
8eee8ea2 629 bt_stream *stream, const char *path)
e98a2d6e 630{
b6c3dcb2 631 int ret;
55314f2a 632 const size_t page_size = bt_common_get_page_size();
94cf822e 633 struct ctf_fs_ds_file *ds_file = g_new0(struct ctf_fs_ds_file, 1);
e98a2d6e 634
94cf822e 635 if (!ds_file) {
e98a2d6e
PP
636 goto error;
637 }
638
b09a5592 639 ds_file->pc_msg_iter = pc_msg_iter;
55314f2a 640 ds_file->file = ctf_fs_file_create();
94cf822e 641 if (!ds_file->file) {
4f1f88a6
PP
642 goto error;
643 }
644
4b70020d 645 ds_file->stream = stream;
8c6884d9 646 bt_stream_get_ref(ds_file->stream);
7b33a0e0 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
b09a5592
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{
bb230c9b
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
684 BT_LOGD("Failed to build index from .index file; "
685 "falling back to stream indexing.");
686 index = build_index_from_stream_file(ds_file);
687end:
688 return index;
97ade20b
JG
689}
690
5b29e799 691BT_HIDDEN
94cf822e 692void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
e98a2d6e 693{
94cf822e 694 if (!ds_file) {
5b29e799 695 return;
043e2020
JG
696 }
697
8c6884d9 698 bt_stream_put_ref(ds_file->stream);
94cf822e 699 (void) ds_file_munmap(ds_file);
0982a26d 700
94cf822e
PP
701 if (ds_file->file) {
702 ctf_fs_file_destroy(ds_file->file);
e98a2d6e
PP
703 }
704
94cf822e 705 g_free(ds_file);
e98a2d6e 706}
4f1f88a6
PP
707
708BT_HIDDEN
ee78f405 709bt_message_iterator_status ctf_fs_ds_file_next(
3fd7b79d 710 struct ctf_fs_ds_file *ds_file,
b09a5592 711 bt_message **msg)
4f1f88a6 712{
b09a5592 713 enum bt_msg_iter_status msg_iter_status;
ee78f405 714 bt_message_iterator_status status;
4f1f88a6 715
b09a5592
PP
716 msg_iter_status = bt_msg_iter_get_next_message(
717 ds_file->msg_iter, ds_file->pc_msg_iter, msg);
4f1f88a6 718
b09a5592
PP
719 switch (msg_iter_status) {
720 case BT_MSG_ITER_STATUS_EOF:
721 status = BT_MESSAGE_ITERATOR_STATUS_END;
4f1f88a6 722 break;
b09a5592
PP
723 case BT_MSG_ITER_STATUS_OK:
724 status = BT_MESSAGE_ITERATOR_STATUS_OK;
4f1f88a6 725 break;
b09a5592 726 case BT_MSG_ITER_STATUS_AGAIN:
4f1f88a6
PP
727 /*
728 * Should not make it this far as this is
729 * medium-specific; there is nothing for the user to do
730 * and it should have been handled upstream.
731 */
0fbb9a9f 732 abort();
b09a5592
PP
733 case BT_MSG_ITER_STATUS_INVAL:
734 case BT_MSG_ITER_STATUS_ERROR:
4f1f88a6 735 default:
b09a5592 736 status = BT_MESSAGE_ITERATOR_STATUS_ERROR;
4f1f88a6
PP
737 break;
738 }
3fd7b79d 739 return status;
4f1f88a6 740}
94cf822e
PP
741
742BT_HIDDEN
a6918753 743int ctf_fs_ds_file_borrow_packet_header_context_fields(
97ade20b 744 struct ctf_fs_ds_file *ds_file,
8eee8ea2
PP
745 bt_field **packet_header_field,
746 bt_field **packet_context_field)
94cf822e 747{
b09a5592 748 enum bt_msg_iter_status msg_iter_status;
94cf822e
PP
749 int ret = 0;
750
8b45963b 751 BT_ASSERT(ds_file);
b09a5592
PP
752 msg_iter_status = bt_msg_iter_borrow_packet_header_context_fields(
753 ds_file->msg_iter, packet_header_field, packet_context_field);
754 switch (msg_iter_status) {
755 case BT_MSG_ITER_STATUS_EOF:
756 case BT_MSG_ITER_STATUS_OK:
94cf822e 757 break;
b09a5592 758 case BT_MSG_ITER_STATUS_AGAIN:
0fbb9a9f 759 abort();
b09a5592
PP
760 case BT_MSG_ITER_STATUS_INVAL:
761 case BT_MSG_ITER_STATUS_ERROR:
94cf822e
PP
762 default:
763 goto error;
764 break;
765 }
766
767 goto end;
768
769error:
770 ret = -1;
771
94cf822e 772end:
94cf822e
PP
773 return ret;
774}
97ade20b
JG
775
776BT_HIDDEN
777void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
778{
779 if (!index) {
780 return;
781 }
782
783 if (index->entries) {
784 g_array_free(index->entries, TRUE);
785 }
786 g_free(index);
787}
This page took 0.078263 seconds and 4 git commands to generate.