#include <babeltrace/ctf/types.h>
#include <babeltrace/ctf/metadata.h>
#include <babeltrace/babeltrace-internal.h>
+#include <babeltrace/ctf/events-internal.h>
+#include <babeltrace/uuid.h>
+#include <babeltrace/endian.h>
#include <inttypes.h>
#include <stdio.h>
-#include <uuid/uuid.h>
#include <sys/mman.h>
#include <errno.h>
-#include <endian.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "metadata/ctf-scanner.h"
#include "metadata/ctf-parser.h"
#include "metadata/ctf-ast.h"
+#include "events-private.h"
/*
* We currently simply map a page to read the packet header and packet
*/
#define MAX_PACKET_HEADER_LEN (getpagesize() * CHAR_BIT)
#define WRITE_PACKET_LEN (getpagesize() * 8 * CHAR_BIT)
-#define UUID_LEN 16 /* uuid by value len */
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
static
struct trace_descriptor *ctf_open_trace(const char *path, int flags,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
- int whence), FILE *metadata_fp);
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
+ int whence),
+ FILE *metadata_fp);
static
struct trace_descriptor *ctf_open_mmap_trace(
struct mmap_stream_list *mmap_list,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset, int whence),
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
+ int whence),
FILE *metadata_fp);
static
uint64_t timestamp)
{
uint64_t ts_sec = 0, ts_nsec;
- struct ctf_trace *trace = stream->stream_class->trace;
- struct trace_collection *tc = trace->collection;
- uint64_t tc_offset = tc->single_clock_offset_avg;
- if (stream->current_clock->freq == 1000000000ULL) {
- ts_nsec = timestamp;
+ if (opt_clock_raw) {
+ ts_nsec = ctf_get_timestamp_raw(stream, timestamp);
} else {
- ts_nsec = (uint64_t) ((double) timestamp * 1000000000.0
- / (double) stream->current_clock->freq);
+ ts_nsec = ctf_get_timestamp(stream, timestamp);
}
- /* Add offsets */
- if (!opt_clock_raw) {
- ts_nsec += tc_offset;
- }
+ /* Add command-line offset */
ts_sec += opt_clock_offset;
ts_sec += ts_nsec / NSEC_PER_SEC;
pos->parent.rw_table = write_dispatch_table;
pos->parent.event_cb = ctf_write_event;
if (fd >= 0)
- ctf_move_pos_slow(pos, 0, SEEK_SET); /* position for write */
+ ctf_packet_seek(&pos->parent, 0, SEEK_SET); /* position for write */
break;
default:
assert(0);
(void) g_array_free(pos->packet_index, TRUE);
}
-void ctf_move_pos_slow(struct ctf_stream_pos *pos, size_t offset, int whence)
+/*
+ * for SEEK_CUR: go to next packet.
+ * for SEEK_POS: go to packet numer (index).
+ */
+void ctf_packet_seek(struct stream_pos *stream_pos, size_t index, int whence)
{
+ struct ctf_stream_pos *pos =
+ container_of(stream_pos, struct ctf_stream_pos, parent);
struct ctf_file_stream *file_stream =
container_of(pos, struct ctf_file_stream, pos);
int ret;
off_t off;
- struct packet_index *index;
+ struct packet_index *packet_index;
if (pos->prot == PROT_WRITE && pos->content_size_loc)
*pos->content_size_loc = pos->offset;
switch (whence) {
case SEEK_CUR:
/* The writer will add padding */
- assert(pos->offset + offset == pos->packet_size);
pos->mmap_offset += WRITE_PACKET_LEN / CHAR_BIT;
break;
case SEEK_SET:
- assert(offset == 0); /* only seek supported for now */
+ assert(index == 0); /* only seek supported for now */
pos->cur_index = 0;
break;
default:
return;
}
/* For printing discarded event count */
- index = &g_array_index(pos->packet_index,
+ packet_index = &g_array_index(pos->packet_index,
struct packet_index, pos->cur_index);
- events_discarded_diff = index->events_discarded;
+ events_discarded_diff = packet_index->events_discarded;
file_stream->parent.prev_timestamp_end =
- index->timestamp_end;
+ packet_index->timestamp_end;
if (pos->cur_index > 0) {
- index = &g_array_index(pos->packet_index,
+ packet_index = &g_array_index(pos->packet_index,
struct packet_index,
pos->cur_index - 1);
- events_discarded_diff -= index->events_discarded;
+ events_discarded_diff -= packet_index->events_discarded;
}
file_stream->parent.events_discarded = events_discarded_diff;
file_stream->parent.prev_timestamp = file_stream->parent.timestamp;
/* The reader will expect us to skip padding */
- assert(pos->offset + offset == pos->content_size);
++pos->cur_index;
break;
}
case SEEK_SET:
- if (offset == 0)
- pos->cur_index = 0;
+ pos->cur_index = index;
file_stream->parent.prev_timestamp = 0;
file_stream->parent.prev_timestamp_end = 0;
break;
* be printed in the output.
*/
if (file_stream->parent.events_discarded) {
- fflush(stdout);
- fprintf(stderr, "[warning] Tracer discarded %d events at end of stream between [",
- file_stream->parent.events_discarded);
- ctf_print_timestamp(stderr, &file_stream->parent,
- file_stream->parent.prev_timestamp);
- fprintf(stderr, "] and [");
- ctf_print_timestamp(stderr, &file_stream->parent,
- file_stream->parent.prev_timestamp_end);
- fprintf(stderr, "]. You should consider increasing the buffer size.\n");
- fflush(stderr);
+ /*
+ * We need to check if we are in trace
+ * read or called from packet indexing.
+ * In this last case, the collection is
+ * not there, so we cannot print the
+ * timestamps.
+ */
+ if ((&file_stream->parent)->stream_class->trace->collection) {
+ fflush(stdout);
+ fprintf(stderr, "[warning] Tracer discarded %d events at end of stream between [",
+ file_stream->parent.events_discarded);
+ ctf_print_timestamp(stderr, &file_stream->parent,
+ file_stream->parent.prev_timestamp);
+ fprintf(stderr, "] and [");
+ ctf_print_timestamp(stderr, &file_stream->parent,
+ file_stream->parent.prev_timestamp_end);
+ fprintf(stderr, "]. You should consider increasing the buffer size.\n");
+ fflush(stderr);
+ }
file_stream->parent.events_discarded = 0;
}
pos->offset = EOF;
return;
}
- index = &g_array_index(pos->packet_index, struct packet_index,
+ packet_index = &g_array_index(pos->packet_index, struct packet_index,
pos->cur_index);
- pos->mmap_offset = index->offset;
+ pos->mmap_offset = packet_index->offset;
/* Lookup context/packet size in index */
- file_stream->parent.timestamp = index->timestamp_begin;
- pos->content_size = index->content_size;
- pos->packet_size = index->packet_size;
- if (index->data_offset < index->content_size) {
+ file_stream->parent.timestamp = packet_index->timestamp_begin;
+ pos->content_size = packet_index->content_size;
+ pos->packet_size = packet_index->packet_size;
+ if (packet_index->data_offset < packet_index->content_size) {
pos->offset = 0; /* will read headers */
- } else if (index->data_offset == index->content_size) {
+ } else if (packet_index->data_offset == packet_index->content_size) {
/* empty packet */
- pos->offset = index->data_offset;
- offset = 0;
+ pos->offset = packet_index->data_offset;
whence = SEEK_CUR;
goto read_next_packet;
} else {
memcpy(td->uuid, header.uuid, sizeof(header.uuid));
CTF_TRACE_SET_FIELD(td, uuid);
} else {
- if (uuid_compare(header.uuid, td->uuid))
+ if (babeltrace_uuid_compare(header.uuid, td->uuid))
return -EINVAL;
}
static
int ctf_open_trace_metadata_read(struct ctf_trace *td,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp)
{
struct ctf_scanner *scanner;
metadata_stream = g_new0(struct ctf_file_stream, 1);
- if (move_pos_slow) {
- metadata_stream->pos.move_pos_slow = move_pos_slow;
+ if (packet_seek) {
+ metadata_stream->pos.packet_seek = packet_seek;
} else {
- fprintf(stderr, "[error] move_pos_slow function undefined.\n");
+ fprintf(stderr, "[error] packet_seek function undefined.\n");
ret = -1;
goto end_stream;
}
struct definition_array *defarray;
struct definition *field;
uint64_t i;
- uint8_t uuidval[UUID_LEN];
+ uint8_t uuidval[BABELTRACE_UUID_LEN];
field = struct_definition_get_field_from_index(file_stream->parent.trace_packet_header, len_index);
assert(field->declaration->id == CTF_TYPE_ARRAY);
defarray = container_of(field, struct definition_array, p);
- assert(array_len(defarray) == UUID_LEN);
+ assert(array_len(defarray) == BABELTRACE_UUID_LEN);
- for (i = 0; i < UUID_LEN; i++) {
+ for (i = 0; i < BABELTRACE_UUID_LEN; i++) {
struct definition *elem;
elem = array_index(defarray, i);
uuidval[i] = get_unsigned_int(elem);
}
- ret = uuid_compare(td->uuid, uuidval);
+ ret = babeltrace_uuid_compare(td->uuid, uuidval);
if (ret) {
fprintf(stderr, "[error] Unique Universal Identifiers do not match.\n");
return -EINVAL;
}
/* Move pos back to beginning of file */
- ctf_move_pos_slow(pos, 0, SEEK_SET); /* position for write */
+ ctf_packet_seek(&pos->parent, 0, SEEK_SET); /* position for write */
return 0;
}
*/
static
int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence))
{
int ret;
}
file_stream = g_new0(struct ctf_file_stream, 1);
- if (move_pos_slow) {
- file_stream->pos.move_pos_slow = move_pos_slow;
+ if (packet_seek) {
+ file_stream->pos.packet_seek = packet_seek;
} else {
- fprintf(stderr, "[error] move_pos_slow function undefined.\n");
+ fprintf(stderr, "[error] packet_seek function undefined.\n");
ret = -1;
goto error_def;
}
static
int ctf_open_trace_read(struct ctf_trace *td,
const char *path, int flags,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp)
{
int ret;
* Keep the metadata file separate.
*/
- ret = ctf_open_trace_metadata_read(td, move_pos_slow, metadata_fp);
+ ret = ctf_open_trace_metadata_read(td, packet_seek, metadata_fp);
if (ret) {
goto error_metadata;
}
|| !strcmp(diriter->d_name, "..")
|| !strcmp(diriter->d_name, "metadata"))
continue;
- ret = ctf_open_file_stream_read(td, diriter->d_name, flags, move_pos_slow);
+ ret = ctf_open_file_stream_read(td, diriter->d_name,
+ flags, packet_seek);
if (ret) {
fprintf(stderr, "[error] Open file stream error.\n");
goto readdir_error;
static
struct trace_descriptor *ctf_open_trace(const char *path, int flags,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp)
{
struct ctf_trace *td;
int ret;
+ /*
+ * If packet_seek is NULL, we provide our default version.
+ */
+ if (!packet_seek)
+ packet_seek = ctf_packet_seek;
+
td = g_new0(struct ctf_trace, 1);
switch (flags & O_ACCMODE) {
fprintf(stderr, "[error] Path missing for input CTF trace.\n");
goto error;
}
- ret = ctf_open_trace_read(td, path, flags, move_pos_slow, metadata_fp);
+ ret = ctf_open_trace_read(td, path, flags, packet_seek, metadata_fp);
if (ret)
goto error;
break;
static
int ctf_open_mmap_stream_read(struct ctf_trace *td,
struct mmap_stream *mmap_info,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence))
{
int ret;
file_stream = g_new0(struct ctf_file_stream, 1);
ctf_init_mmap_pos(&file_stream->pos, mmap_info);
- file_stream->pos.move_pos_slow = move_pos_slow;
+ file_stream->pos.packet_seek = packet_seek;
ret = create_trace_definitions(td, &file_stream->parent);
if (ret) {
int ctf_open_mmap_trace_read(struct ctf_trace *td,
struct mmap_stream_list *mmap_list,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence),
FILE *metadata_fp)
{
int ret;
struct mmap_stream *mmap_info;
- ret = ctf_open_trace_metadata_read(td, ctf_move_pos_slow, metadata_fp);
+ ret = ctf_open_trace_metadata_read(td, ctf_packet_seek, metadata_fp);
if (ret) {
goto error;
}
* for each stream, try to open, check magic number, and get the
* stream ID to add to the right location in the stream array.
*/
- cds_list_for_each_entry(mmap_info, &mmap_list->head, list) {
- ret = ctf_open_mmap_stream_read(td, mmap_info, move_pos_slow);
+ bt_list_for_each_entry(mmap_info, &mmap_list->head, list) {
+ ret = ctf_open_mmap_stream_read(td, mmap_info, packet_seek);
if (ret) {
fprintf(stderr, "[error] Open file mmap stream error.\n");
goto error;
static
struct trace_descriptor *ctf_open_mmap_trace(
struct mmap_stream_list *mmap_list,
- void (*move_pos_slow)(struct ctf_stream_pos *pos, size_t offset, int whence),
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
+ int whence),
FILE *metadata_fp)
{
struct ctf_trace *td;
"required for mmap parsing\n");
goto error;
}
- if (!move_pos_slow) {
- fprintf(stderr, "[error] move_pos_slow function undefined.\n");
+ if (!packet_seek) {
+ fprintf(stderr, "[error] packet_seek function undefined.\n");
goto error;
}
td = g_new0(struct ctf_trace, 1);
- ret = ctf_open_mmap_trace_read(td, mmap_list, move_pos_slow, metadata_fp);
+ ret = ctf_open_mmap_trace_read(td, mmap_list, packet_seek, metadata_fp);
if (ret)
goto error_free;