#include <stdlib.h>
-#include "parser.h"
#include <ltt/ltt.h>
#include "ltt-private.h"
#include <ltt/trace.h>
#include <ltt/event.h>
-//#include <ltt/type.h>
#include <ltt/ltt-types.h>
#include <ltt/marker.h>
#define PAGE_MASK (~(page_size-1))
#define PAGE_ALIGN(addr) (((addr)+page_size-1)&PAGE_MASK)
+LttTrace *father_trace = NULL;
+
/* set the offset of the fields belonging to the event,
need the information of the archecture */
//void set_fields_offsets(LttTracefile *tf, LttEventType *event_type);
/* go to the next event */
static int ltt_seek_next_event(LttTracefile *tf);
-//void ltt_update_event_size(LttTracefile *tf);
-
static int open_tracefiles(LttTrace *trace, gchar *root_path,
gchar *relative_path);
static int ltt_process_facility_tracefile(LttTracefile *tf);
LttTime *start, LttTime *end);
static void group_time_span_get(GQuark name, gpointer data, gpointer user_data);
static gint map_block(LttTracefile * tf, guint block_num);
-static int ltt_seek_next_event(LttTracefile *tf);
-static void __attribute__((constructor)) init(void);
static void ltt_update_event_size(LttTracefile *tf);
-//void precompute_offsets(LttFacility *fac, LttEventType *event);
-#if 0
-/* Functions to parse system.xml file (using glib xml parser) */
-static void parser_start_element (GMarkupParseContext __UNUSED__ *context,
- const gchar *element_name,
- const gchar **attribute_names,
- const gchar **attribute_values,
- gpointer user_data,
- GError **error)
-{
- int i=0;
- LttSystemDescription* des = (LttSystemDescription* )user_data;
- if(strcmp("system", element_name)){
- *error = g_error_new(G_MARKUP_ERROR,
- G_LOG_LEVEL_WARNING,
- "This is not system.xml file");
- return;
- }
-
- while(attribute_names[i]){
- if(strcmp("node_name", attribute_names[i])==0){
- des->node_name = g_strdup(attribute_values[i]);
- }else if(strcmp("domainname", attribute_names[i])==0){
- des->domain_name = g_strdup(attribute_values[i]);
- }else if(strcmp("cpu", attribute_names[i])==0){
- des->nb_cpu = atoi(attribute_values[i]);
- }else if(strcmp("arch_size", attribute_names[i])==0){
- if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32;
- else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32;
- else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64;
- else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64;
- else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN;
- }else if(strcmp("endian", attribute_names[i])==0){
- if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0)
- des->endian = LTT_LITTLE_ENDIAN;
- else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0)
- des->endian = LTT_BIG_ENDIAN;
- }else if(strcmp("kernel_name", attribute_names[i])==0){
- des->kernel_name = g_strdup(attribute_values[i]);
- }else if(strcmp("kernel_release", attribute_names[i])==0){
- des->kernel_release = g_strdup(attribute_values[i]);
- }else if(strcmp("kernel_version", attribute_names[i])==0){
- des->kernel_version = g_strdup(attribute_values[i]);
- }else if(strcmp("machine", attribute_names[i])==0){
- des->machine = g_strdup(attribute_values[i]);
- }else if(strcmp("processor", attribute_names[i])==0){
- des->processor = g_strdup(attribute_values[i]);
- }else if(strcmp("hardware_platform", attribute_names[i])==0){
- des->hardware_platform = g_strdup(attribute_values[i]);
- }else if(strcmp("operating_system", attribute_names[i])==0){
- des->operating_system = g_strdup(attribute_values[i]);
- }else if(strcmp("ltt_major_version", attribute_names[i])==0){
- des->ltt_major_version = atoi(attribute_values[i]);
- }else if(strcmp("ltt_minor_version", attribute_names[i])==0){
- des->ltt_minor_version = atoi(attribute_values[i]);
- }else if(strcmp("ltt_block_size", attribute_names[i])==0){
- des->ltt_block_size = atoi(attribute_values[i]);
- }else{
- *error = g_error_new(G_MARKUP_ERROR,
- G_LOG_LEVEL_WARNING,
- "Not a valid attribute");
- return;
- }
- i++;
- }
-}
+/* Enable event debugging */
+static int a_event_debug = 0;
-static void parser_characters (GMarkupParseContext __UNUSED__ *context,
- const gchar *text,
- gsize __UNUSED__ text_len,
- gpointer user_data,
- GError __UNUSED__ **error)
+void ltt_event_debug(int state)
{
- LttSystemDescription* des = (LttSystemDescription* )user_data;
- des->description = g_strdup(text);
+ a_event_debug = state;
}
-#endif //0
-
-#if 0
-LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
- guint num)
-{
- g_assert(num < t->facilities_by_num->len);
-
- return &g_array_index(t->facilities_by_num, LttFacility, num);
-
-}
-#endif //0
-
-guint ltt_trace_get_num_cpu(LttTrace *t)
-{
- return t->num_cpu;
-}
-
/* trace can be NULL
*
* Return value : 0 success, 1 bad tracefile
*/
-int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t)
+static int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t)
{
guint32 *magic_number = (guint32*)header;
struct ltt_trace_header_any *any = (struct ltt_trace_header_any *)header;
/* Get float byte order : might be different from int byte order
* (or is set to 0 if the trace has no float (kernel trace)) */
tf->float_word_order = any->float_word_order;
- tf->has_alignment = any->has_alignment;
+ tf->alignment = any->alignment;
tf->has_heartbeat = any->has_heartbeat;
if(t) {
// t->compact_facilities = NULL;
}
-
switch(any->major_version) {
case 0:
tf->tsc_lsb_truncate = vheader->tsc_lsb_truncate;
tf->tscbits = vheader->tscbits;
tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits;
+ tf->compact_event_bits = 32 - vheader->compact_data_shift;
tf->tsc_mask = ((1ULL << (tf->tscbits))-1);
tf->tsc_mask = tf->tsc_mask << tf->tsc_lsb_truncate;
tf->tsc_mask_next_bit = (1ULL<<(tf->tscbits));
&vheader->start_freq);
t->freq_scale = ltt_get_uint32(LTT_GET_BO(tf),
&vheader->freq_scale);
+ if(father_trace) {
+ t->start_freq = father_trace->start_freq;
+ t->freq_scale = father_trace->freq_scale;
+ }
+ else {
+ father_trace = t;
+ }
t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf),
&vheader->start_tsc);
t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf),
(double)t->start_tsc
* (1000000000.0 / tf->trace->freq_scale)
/ (double)t->start_freq);
- t->compact_event_bits = 0;
}
}
break;
* : 0 for success, -1 otherwise.
****************************************************************************/
-gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf)
+static gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf)
{
struct stat lTDFStat; /* Trace data file status */
struct ltt_block_start_header *header;
perror("Error in allocating memory for buffer of tracefile");
goto close_file;
}
- g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
+ g_assert( ( (gulong)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
header = (struct ltt_block_start_header*)tf->buffer.head;
return -1;
}
-LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
-{
- return tf->trace;
-}
-
#if 0
/*****************************************************************************
*Open control and per cpu tracefiles
* t : tracefile which will be closed
****************************************************************************/
-void ltt_tracefile_close(LttTracefile *t)
+static void ltt_tracefile_close(LttTracefile *t)
{
int page_size = getpagesize();
* The left side is the name, the right side is the number.
*/
-int get_tracefile_name_number(gchar *raw_name,
+static int get_tracefile_name_number(gchar *raw_name,
GQuark *name,
guint *num,
- guint *tid,
- guint *pgid,
+ gulong *tid,
+ gulong *pgid,
guint64 *creation)
{
guint raw_name_len = strlen(raw_name);
}
-void ltt_tracefile_group_destroy(gpointer data)
+static void ltt_tracefile_group_destroy(gpointer data)
{
GArray *group = (GArray *)data;
int i;
g_array_free(group, TRUE);
}
-gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
+static gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
{
GArray *group = (GArray *)data;
int i;
* A tracefile group is simply an array where all the per cpu tracefiles sit.
*/
-int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path)
+static int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path)
{
DIR *dir = opendir(root_path);
struct dirent *entry;
g_debug("Tracefile file or directory : %s\n", path);
- if(strcmp(rel_path, "/eventdefs") == 0) continue;
+ // if(strcmp(rel_path, "/eventdefs") == 0) continue;
if(S_ISDIR(stat_buf.st_mode)) {
if(ret < 0) continue;
} else if(S_ISREG(stat_buf.st_mode)) {
GQuark name;
- guint num, tid, pgid;
+ guint num;
+ gulong tid, pgid;
guint64 creation;
GArray *group;
- num = tid = pgid = 0;
+ num = 0;
+ tid = pgid = 0;
creation = 0;
if(get_tracefile_name_number(rel_path, &name, &num, &tid, &pgid, &creation))
continue; /* invalid name */
if(num+1 > old_len)
group = g_array_set_size(group, num+1);
g_array_index (group, LttTracefile, num) = tmp_tf;
-
+ g_array_index (group, LttTracefile, num).event.tracefile =
+ &g_array_index (group, LttTracefile, num);
}
}
return 0;
}
-/* ltt_get_facility_description
- *
- * Opens the file corresponding to the requested facility (identified by fac_id
- * and checksum).
- *
- * The name searched is : %trace root%/eventdefs/facname_checksum.xml
- *
- * Returns 0 on success, or 1 on failure.
- */
-#if 0
-static int ltt_get_facility_description(LttFacility *f,
- LttTrace *t,
- LttTracefile *fac_tf)
-{
- char desc_file_name[PATH_MAX];
- const gchar *text;
- guint textlen;
- gint err;
- gint arch_spec;
- gint fac_name_len;
-
- text = g_quark_to_string(t->pathname);
- textlen = strlen(text);
-
- if(textlen >= PATH_MAX) goto name_error;
- strcpy(desc_file_name, text);
-
- text = "/eventdefs/";
- textlen+=strlen(text);
- if(textlen >= PATH_MAX) goto name_error;
- strcat(desc_file_name, text);
-
- text = g_quark_to_string(f->name);
- fac_name_len = strlen(text);
- textlen+=fac_name_len;
- if(textlen >= PATH_MAX) goto name_error;
- strcat(desc_file_name, text);
-
- /* arch specific facilities are named like this : name_arch */
- if(fac_name_len+1 < sizeof("_arch"))
- arch_spec = 0;
- else {
- if(!strcmp(&text[fac_name_len+1-sizeof("_arch")], "_arch"))
- arch_spec = 1;
- else
- arch_spec = 0;
- }
-
-#if 0
- text = "_";
- textlen+=strlen(text);
- if(textlen >= PATH_MAX) goto name_error;
- strcat(desc_file_name, text);
-
- err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1,
- "%u", f->checksum);
- if(err < 0) goto name_error;
-
- textlen=strlen(desc_file_name);
-
-#endif //0
-
- if(arch_spec) {
- switch(t->arch_type) {
- case LTT_ARCH_TYPE_I386:
- text = "_i386";
- break;
- case LTT_ARCH_TYPE_PPC:
- text = "_ppc";
- break;
- case LTT_ARCH_TYPE_SH:
- text = "_sh";
- break;
- case LTT_ARCH_TYPE_S390:
- text = "_s390";
- break;
- case LTT_ARCH_TYPE_MIPS:
- text = "_mips";
- break;
- case LTT_ARCH_TYPE_ARM:
- text = "_arm";
- break;
- case LTT_ARCH_TYPE_PPC64:
- text = "_ppc64";
- break;
- case LTT_ARCH_TYPE_X86_64:
- text = "_x86_64";
- break;
- case LTT_ARCH_TYPE_C2:
- text = "_c2";
- break;
- case LTT_ARCH_TYPE_POWERPC:
- text = "_powerpc";
- break;
- default:
- g_error("Trace from unsupported architecture.");
- }
- textlen+=strlen(text);
- if(textlen >= PATH_MAX) goto name_error;
- strcat(desc_file_name, text);
- }
-
- text = ".xml";
- textlen+=strlen(text);
- if(textlen >= PATH_MAX) goto name_error;
- strcat(desc_file_name, text);
-
- err = ltt_facility_open(f, t, desc_file_name);
- if(err) goto facility_error;
-
- return 0;
-
-facility_error:
-name_error:
- return 1;
-}
-
-static void ltt_fac_ids_destroy(gpointer data)
-{
- GArray *fac_ids = (GArray *)data;
-
- g_array_free(fac_ids, TRUE);
-}
-#endif //0
/* Presumes the tracefile is already seeked at the beginning. It makes sense,
* because it must be done just after the opening */
-int ltt_process_facility_tracefile(LttTracefile *tf)
+static int ltt_process_facility_tracefile(LttTracefile *tf)
{
int err;
//LttFacility *fac;
g_debug("Doing MARKER_ID_SET_MARKER_ID of marker %s", marker_name);
pos += strlen(marker_name) + 1;
//remove genevent compatibility
- //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
- pos += ltt_align((size_t)pos, sizeof(uint16_t), tf->has_alignment);
+ //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment);
+ pos += ltt_align((size_t)pos, sizeof(uint16_t), tf->alignment);
id = ltt_get_uint16(LTT_GET_BO(tf), pos);
+ g_debug("In MARKER_ID_SET_MARKER_ID of marker %s id %hu",
+ marker_name, id);
pos += sizeof(guint16);
int_size = *(guint8*)pos;
pos += sizeof(guint8);
marker_name);
pos += strlen(marker_name) + 1;
//break genevent.
- //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
+ //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment);
format = pos;
pos += strlen(format) + 1;
//break genevent
- //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
+ //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment);
marker_format_event(tf->trace, g_quark_from_string(marker_name),
format);
/* get information from dictionnary TODO */
return err;
}
+/*
+ * Open a trace and return its LttTrace handle.
+ *
+ * pathname must be the directory of the trace
+ */
LttTrace *ltt_trace_open(const gchar *pathname)
{
DIR *dir;
struct dirent *entry;
guint control_found = 0;
- guint eventdefs_found = 0;
struct stat stat_buf;
gchar path[PATH_MAX];
if(strcmp(entry->d_name, "control") == 0) {
control_found = 1;
}
- if(strcmp(entry->d_name, "eventdefs") == 0) {
- eventdefs_found = 1;
- }
}
}
closedir(dir);
- if(!control_found || !eventdefs_found) goto find_error;
+ if(!control_found) goto find_error;
/* Open all the tracefiles */
if(open_tracefiles(t, abs_path, "")) {
}
-GQuark ltt_trace_name(const LttTrace *t)
-{
- return t->pathname;
-}
-
-
-/******************************************************************************
+/* Open another, completely independant, instance of a trace.
+ *
+ * A read on this new instance will read the first event of the trace.
+ *
* When we copy a trace, we want all the opening actions to happen again :
* the trace will be reopened and totally independant from the original.
* That's why we call ltt_trace_open.
- *****************************************************************************/
+ */
LttTrace *ltt_trace_copy(LttTrace *self)
{
return ltt_trace_open(g_quark_to_string(self->pathname));
}
+/*
+ * Close a trace
+ */
+
void ltt_trace_close(LttTrace *t)
{
g_datalist_clear(&t->tracefiles);
}
-/*****************************************************************************
- *Get the system description of the trace
- ****************************************************************************/
-#if 0
-LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id)
-{
- g_assert(id < t->facilities_by_num->len);
- return &g_array_index(t->facilities_by_num, LttFacility, id);
-}
-
-/* ltt_trace_facility_get_by_name
- *
- * Returns the GArray of facility indexes. All the fac_ids that matches the
- * requested facility name.
- *
- * If name is not found, returns NULL.
- */
-GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name)
-{
- return g_datalist_id_get_data(&t->facilities_by_name, name);
-}
-#endif //0
-
-/*****************************************************************************
- * Functions to discover all the event types in the trace
- ****************************************************************************/
-
-#if 0
-unsigned ltt_trace_eventtype_number(LttTrace *t)
-{
- unsigned int i;
- unsigned count = 0;
- unsigned int num = t->facility_number;
- LttFacility * f;
-
- for(i=0;i<num;i++){
- f = (LttFacility*)g_ptr_array_index(t->facilities, i);
- count += f->event_number;
- }
- return count;
-}
-#endif //0
-
-#if 0
-//use an iteration on all the trace facilities, and inside iteration on all the
-//event types in each facilities instead.
-LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
-{
- LttEventType *event_type;
-
- LttFacility * f;
- f = ltt_trace_facility_by_id(t,evId);
-
- if(unlikely(!f)) event_type = NULL;
- else event_type = f->events[evId - f->base_id];
-
- return event_type;
-}
-#endif //0
-
-#if 0
-/*****************************************************************************
- * ltt_trace_find_tracefile
- *
- * Find a tracefile by name and index in the group.
- *
- * Returns a pointer to the tracefiles, else NULL.
- ****************************************************************************/
-
-LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name)
-{
-}
-#endif //0
-
/*****************************************************************************
* Get the start time and end time of the trace
****************************************************************************/
LttTime *end;
};
-void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
+static void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
{
struct tracefile_time_span_get_args *args =
(struct tracefile_time_span_get_args*)user_data;
}
}
+/* return the start and end time of a trace */
+
void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
{
LttTime min_start = ltt_time_infinite;
}
-/*****************************************************************************
- *Get the name of a tracefile
- ****************************************************************************/
-
-GQuark ltt_tracefile_name(const LttTracefile *tf)
-{
- return tf->name;
-}
-
-GQuark ltt_tracefile_long_name(const LttTracefile *tf)
-{
- return tf->long_name;
-}
-
-
-
-guint ltt_tracefile_cpu(LttTracefile *tf)
-{
- return tf->cpu_num;
-}
-
-guint ltt_tracefile_tid(LttTracefile *tf)
-{
- return tf->tid;
-}
-
-guint ltt_tracefile_pgid(LttTracefile *tf)
-{
- return tf->pgid;
-}
-
-guint64 ltt_tracefile_creation(LttTracefile *tf)
-{
- return tf->creation;
-}
-/*****************************************************************************
- * Get the number of blocks in the tracefile
- ****************************************************************************/
-
-guint ltt_tracefile_block_number(LttTracefile *tf)
-{
- return tf->num_blocks;
-}
-
-
/* Seek to the first event in a tracefile that has a time equal or greater than
* the time passed in parameter.
*
return EPERM;
}
+/* Seek to a position indicated by an LttEventPosition
+ */
-int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) {
-
+int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep)
+{
int err;
if(ep->tracefile != tf) {
return 1;
}
+/* Given a TSC value, return the LttTime (seconds,nanoseconds) it
+ * corresponds to.
+ */
+
LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc)
{
LttTime time;
return 0;
}
+/* do an operation when reading a new event */
/* do specific operation on events */
int ltt_tracefile_read_op(LttTracefile *tf)
return 0;
}
+static void print_debug_event_header(LttEvent *ev, void *start_pos, void *end_pos)
+{
+ unsigned int offset = 0;
+ int i, j;
+
+ g_printf("Event header (tracefile %s offset %llx):\n",
+ g_quark_to_string(ev->tracefile->long_name),
+ ((uint64_t)ev->tracefile->buffer.index * ev->tracefile->buf_size)
+ + (long)start_pos - (long)ev->tracefile->buffer.head);
+
+ while (offset < (long)end_pos - (long)start_pos) {
+ g_printf("%8lx", (long)start_pos - (long)ev->tracefile->buffer.head + offset);
+ g_printf(" ");
+
+ for (i = 0; i < 4 ; i++) {
+ for (j = 0; j < 4; j++) {
+ if (offset + ((i * 4) + j) <
+ (long)end_pos - (long)start_pos)
+ g_printf("%02hhX",
+ ((char*)start_pos)[offset + ((i * 4) + j)]);
+ else
+ g_printf(" ");
+ g_printf(" ");
+ }
+ if (i < 4)
+ g_printf(" ");
+ }
+ offset+=16;
+ g_printf("\n");
+ }
+}
+
/* same as ltt_tracefile_read, but does not seek to the next event nor call
* event specific operation. */
{
void * pos;
LttEvent *event;
+ void *pos_aligned;
event = &tf->event;
pos = tf->buffer.head + event->offset;
/* Align the head */
if(!tf->compact)
- pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
+ pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment);
else {
g_assert(tf->has_heartbeat);
- pos += ltt_align((size_t)pos, sizeof(uint32_t), tf->has_alignment);
+ pos += ltt_align((size_t)pos, sizeof(uint32_t), tf->alignment);
}
+ pos_aligned = pos;
if(tf->has_heartbeat) {
event->timestamp = ltt_get_uint32(LTT_GET_BO(tf),
/* We keep the LSB of the previous timestamp, to make sure
* we never go back */
event->event_id = event->timestamp >> tf->tscbits;
- event->event_id = event->event_id & ((1 << tf->trace->compact_event_bits) - 1);
+ event->event_id = event->event_id & ((1 << tf->compact_event_bits) - 1);
event->compact_data = event->timestamp >>
- (tf->trace->compact_event_bits + tf->tscbits);
+ (tf->compact_event_bits + tf->tscbits);
//printf("tsc bits %u, ev bits %u init data %u\n",
// tf->tscbits, tf->trace->compact_event_bits, event->compact_data);
/* Put the compact data back in original endianness */
event->event_time = ltt_interpolate_time(tf, event);
if(!tf->compact) {
- event->event_id = *(guint16*)pos;
+ event->event_id = ltt_get_uint16(LTT_GET_BO(tf), pos);
pos += sizeof(guint16);
event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos);
pos += sizeof(guint16);
} else {
/* Compact event */
+ event->event_size = 0xFFFF;
}
+
+ if (a_event_debug)
+ print_debug_event_header(event, pos_aligned, pos);
+
/* Align the head */
if(!tf->compact)
- pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
+ pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment);
event->data = pos;
* EIO : can not read from the file
****************************************************************************/
-gint map_block(LttTracefile * tf, guint block_num)
+static gint map_block(LttTracefile * tf, guint block_num)
{
int page_size = getpagesize();
struct ltt_block_start_header *header;
g_assert(0);
goto map_error;
}
- g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
+ g_assert( ( (gulong)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
tf->buffer.index = block_num;
}
+static void print_debug_event_data(LttEvent *ev)
+{
+ unsigned int offset = 0;
+ int i, j;
+
+ if (!max(ev->event_size, ev->data_size))
+ return;
+
+ g_printf("Event data (tracefile %s offset %llx):\n",
+ g_quark_to_string(ev->tracefile->long_name),
+ ((uint64_t)ev->tracefile->buffer.index * ev->tracefile->buf_size)
+ + (long)ev->data - (long)ev->tracefile->buffer.head);
+
+ while (offset < max(ev->event_size, ev->data_size)) {
+ g_printf("%8lx", (long)ev->data + offset
+ - (long)ev->tracefile->buffer.head);
+ g_printf(" ");
+
+ for (i = 0; i < 4 ; i++) {
+ for (j = 0; j < 4; j++) {
+ if (offset + ((i * 4) + j) < max(ev->event_size, ev->data_size))
+ g_printf("%02hhX", ((char*)ev->data)[offset + ((i * 4) + j)]);
+ else
+ g_printf(" ");
+ g_printf(" ");
+ }
+ if (i < 4)
+ g_printf(" ");
+ }
+
+ g_printf(" ");
+
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 4; j++) {
+ if (offset + ((i * 4) + j) < max(ev->event_size, ev->data_size)) {
+ if (isprint(((char*)ev->data)[offset + ((i * 4) + j)]))
+ g_printf("%c", ((char*)ev->data)[offset + ((i * 4) + j)]);
+ else
+ g_printf(".");
+ } else
+ g_printf(" ");
+ }
+ }
+ offset+=16;
+ g_printf("\n");
+ }
+}
+
/* It will update the fields offsets too */
void ltt_update_event_size(LttTracefile *tf)
{
switch((enum marker_id)tf->event.event_id) {
case MARKER_ID_SET_MARKER_ID:
size = strlen((char*)tf->event.data) + 1;
- //g_debug("marker %s id set", (char*)tf->event.data);
- size += ltt_align(size, sizeof(guint16), tf->has_alignment);
+ g_debug("marker %s id set", (char*)tf->event.data);
+ size += ltt_align(size, sizeof(guint16), tf->alignment);
size += sizeof(guint16);
size += sizeof(guint8);
size += sizeof(guint8);
size += sizeof(guint8);
break;
case MARKER_ID_SET_MARKER_FORMAT:
- //g_debug("marker %s format set", (char*)tf->event.data);
+ g_debug("marker %s format set", (char*)tf->event.data);
size = strlen((char*)tf->event.data) + 1;
size += strlen((char*)tf->event.data + size) + 1;
break;
case MARKER_ID_HEARTBEAT_32:
- //g_debug("Update Event heartbeat 32 bits");
+ g_debug("Update Event heartbeat 32 bits");
break;
case MARKER_ID_HEARTBEAT_64:
- //g_debug("Update Event heartbeat 64 bits");
+ g_debug("Update Event heartbeat 64 bits");
tscdata = (char*)(tf->event.data);
tf->event.tsc = ltt_get_uint64(LTT_GET_BO(tf), tscdata);
tf->buffer.tsc = tf->event.tsc;
tf->event.event_time = ltt_interpolate_time(tf, &tf->event);
- size = ltt_align(size, sizeof(guint64), tf->has_alignment);
+ size = ltt_align(size, sizeof(guint64), tf->alignment);
size += sizeof(guint64);
break;
- default:
- info = marker_get_info_from_id(tf->trace, tf->event.event_id);
- g_assert(info != NULL);
- if (info->size != -1) {
- size = info->size;
- } else {
- size = marker_update_fields_offsets(marker_get_info_from_id(tf->trace,
- tf->event.event_id), tf->event.data);
- }
+ }
+
+ info = marker_get_info_from_id(tf->trace, tf->event.event_id);
+
+ if (tf->event.event_id >= MARKER_CORE_IDS)
+ g_assert(info != NULL);
+
+ /* Do not update field offsets of core markers when initially reading the
+ * facility tracefile when the infos about these markers do not exist yet.
+ */
+ if (likely(info && info->fields)) {
+ if (info->size != -1)
+ size = info->size;
+ else
+ size = marker_update_fields_offsets(marker_get_info_from_id(tf->trace,
+ tf->event.event_id), tf->event.data);
}
tf->event.data_size = size;
/* Event size too big to fit in the event size field */
tf->event.event_size = tf->event.data_size;
}
+
+ if (a_event_debug)
+ print_debug_event_data(&tf->event);
+
+ /* Having a marker load or marker format event out of the facilities
+ * tracefiles is a serious bug. */
+ switch((enum marker_id)tf->event.event_id) {
+ case MARKER_ID_SET_MARKER_ID:
+ case MARKER_ID_SET_MARKER_FORMAT:
+ if (tf->name != g_quark_from_string("/control/facilities"))
+ g_error("Trace inconsistency : metadata event found in data "
+ "tracefile %s", g_quark_to_string(tf->long_name));
+ }
+
if (tf->event.data_size != tf->event.event_size) {
struct marker_info *info = marker_get_info_from_id(tf->trace,
tf->event.event_id);
tf->event.event_size, tf->event.data_size);
exit(-1);
}
-
-#if 0
- LttEventType *event_type =
- ltt_facility_eventtype_get(f, tf->event.event_id);
-
- if(!event_type) {
- g_warning("Unknown event id %hhu in facility %s in tracefile %s",
- tf->event.event_id,
- g_quark_to_string(f->name),
- g_quark_to_string(tf->name));
- goto event_type_error;
- }
-
- /* Compute the dynamic offsets */
- compute_offsets(tf, f, event_type, &size, tf->event.data);
-
- //g_debug("Event root field : f.e %hhu.%hhu size %zd",
- // tf->event.facility_id,
- // tf->event.event_id, size);
-
-no_offset:
- tf->event.data_size = size;
-
- /* Check consistency between kernel and LTTV structure sizes */
- if(tf->event.event_size == 0xFFFF) {
- /* Event size too big to fit in the event size field */
- tf->event.event_size = tf->event.data_size;
- }
- if (tf->event.data_size != tf->event.event_size) {
- g_error("Kernel/LTTV event size differs for event %s.%s: kernel %u, LTTV %u",
- g_quark_to_string(f->name), g_quark_to_string(event_type->name),
- tf->event.event_size, tf->event.data_size);
- exit(-1);
- }
- //g_assert(tf->event.data_size == tf->event.event_size);
-
- return;
-
-event_type_error:
-event_id_error:
- if(tf->event.event_size == 0xFFFF) {
- g_error("Cannot jump over an unknown event bigger than 0xFFFE bytes");
- }
- /* The facility is unknown : use the kernel information about this event
- * to jump over it. */
- tf->event.data_size = tf->event.event_size;
-#endif //0
}
* ERANGE if we are at the end of the buffer.
* ENOPROTOOPT if an error occured when getting the current event size.
*/
-int ltt_seek_next_event(LttTracefile *tf)
+static int ltt_seek_next_event(LttTracefile *tf)
{
int ret = 0;
void *pos;
return t->start_time_from_tsc;
}
-LttTracefile *ltt_tracefile_new()
+static LttTracefile *ltt_tracefile_new()
{
- return g_new(LttTracefile, 1);
+ LttTracefile *tf;
+ tf = g_new(LttTracefile, 1);
+ tf->event.tracefile = tf;
+ return tf;
}
-void ltt_tracefile_destroy(LttTracefile *tf)
+static void ltt_tracefile_destroy(LttTracefile *tf)
{
g_free(tf);
}
-void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
+static void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
{
*dest = *src;
}
/* Before library loading... */
-void init(void)
+static __attribute__((constructor)) void init(void)
{
LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
projects / lttv.git / blobdiff