#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 (*packet_seek)(struct 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 (*packet_seek)(struct 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;
(void) g_array_free(pos->packet_index, TRUE);
}
-void ctf_packet_seek(struct stream_pos *stream_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);
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 (*packet_seek)(struct 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;
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;
*/
static
int ctf_open_file_stream_read(struct ctf_trace *td, const char *path, int flags,
- void (*packet_seek)(struct stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence))
{
int ret;
static
int ctf_open_trace_read(struct ctf_trace *td,
const char *path, int flags,
- void (*packet_seek)(struct stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence), FILE *metadata_fp)
{
int ret;
static
struct trace_descriptor *ctf_open_trace(const char *path, int flags,
- void (*packet_seek)(struct 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) {
static
int ctf_open_mmap_stream_read(struct ctf_trace *td,
struct mmap_stream *mmap_info,
- void (*packet_seek)(struct stream_pos *pos, size_t offset,
+ void (*packet_seek)(struct stream_pos *pos, size_t index,
int whence))
{
int ret;
int ctf_open_mmap_trace_read(struct ctf_trace *td,
struct mmap_stream_list *mmap_list,
- void (*packet_seek)(struct stream_pos *pos, size_t offset,
+ 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 (*packet_seek)(struct 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;