#include <glib.h>
#include <malloc.h>
#include <sys/mman.h>
+#include <string.h>
// For realpath
#include <limits.h>
* (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->has_heartbeat = any->has_heartbeat;
if(t) {
t->arch_type = ltt_get_uint32(LTT_GET_BO(tf),
t->ltt_major_version = any->major_version;
t->ltt_minor_version = any->minor_version;
t->flight_recorder = any->flight_recorder;
- t->has_heartbeat = any->has_heartbeat;
t->compact_facilities = NULL;
}
(double)t->start_tsc
* (1000000000.0 / tf->trace->freq_scale)
/ (double)t->start_freq);
+ t->compact_event_bits = 0;
}
}
break;
tf->tsc_lsb_truncate = vheader->tsc_lsb_truncate;
tf->tscbits = vheader->tscbits;
tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits;
- tf->tsc_mask = ((1ULL << (tf->tscbits))-1);
- tf->tsc_mask = tf->tsc_mask << tf->tsc_lsb_truncate;
+ 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));
tf->tsc_mask_next_bit = tf->tsc_mask_next_bit << tf->tsc_lsb_truncate;
if(t) {
(double)t->start_tsc
* (1000000000.0 / tf->trace->freq_scale)
/ (double)t->start_freq);
+ t->compact_event_bits = 0;
}
}
break;
if(!t->compact_facilities)
t->compact_facilities = ltt_trace_facility_get_by_name(t,
g_quark_from_string("flight-compact"));
-
+ if (t->compact_facilities) {
+ /* FIXME : currently does not support unload/load of compact
+ * facility during tracing. Should check for the currently loaded
+ * version of the facility. */
+ g_assert(t->compact_facilities->len == 1);
+ g_assert(t->compact_facilities);
+ {
+ guint facility_id = g_array_index(t->compact_facilities, guint, 0);
+ LttFacility *fac = ltt_trace_facility_by_id(t, facility_id);
+ unsigned int num = ltt_facility_eventtype_number(fac);
+ /* Could be done much quicker, but not on much used code path */
+ if(num) {
+ t->compact_event_bits = 1;
+ while(num >>= 1)
+ t->compact_event_bits++;
+ } else
+ t->compact_event_bits = 0;
+ }
+ }
+
return t;
/* Error handling */
if(!tf->compact)
pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
else {
- g_assert(tf->trace->has_heartbeat);
+ g_assert(tf->has_heartbeat);
pos += ltt_align((size_t)pos, sizeof(uint32_t), tf->has_alignment);
}
- if(tf->trace->has_heartbeat) {
+ if(tf->has_heartbeat) {
event->timestamp = ltt_get_uint32(LTT_GET_BO(tf),
pos);
if(!tf->compact) {
tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL)
| (guint64)event->timestamp;
event->tsc = tf->buffer.tsc;
+ event->compact_data = 0;
}
} else {
/* Compact header */
/* 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->compact_data = event->timestamp >>
+ (tf->trace->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->compact_data = ltt_get_uint32(LTT_GET_BO(tf), &event->compact_data);
event->event_size = 0xFFFF;
- printf("Found compact event %d\n", event->event_id);
+ //printf("Found compact event %d\n", event->event_id);
+ //printf("Compact data %d\n", event->compact_data);
event->timestamp = event->timestamp << tf->tsc_lsb_truncate;
event->timestamp = event->timestamp & tf->tsc_mask;
- printf("timestamp 0x%lX\n", event->timestamp);
- printf("mask 0x%llX\n", tf->tsc_mask);
- printf("mask_next 0x%llX\n", tf->tsc_mask_next_bit);
- printf("previous tsc 0x%llX\n", tf->buffer.tsc);
- printf("previous tsc&mask 0x%llX\n", tf->tsc_mask&tf->buffer.tsc);
- printf("previous tsc&(~mask) 0x%llX\n", tf->buffer.tsc&(~tf->tsc_mask));
+ //printf("timestamp 0x%lX\n", event->timestamp);
+ //printf("mask 0x%llX\n", tf->tsc_mask);
+ //printf("mask_next 0x%llX\n", tf->tsc_mask_next_bit);
+ //printf("previous tsc 0x%llX\n", tf->buffer.tsc);
+ //printf("previous tsc&mask 0x%llX\n", tf->tsc_mask&tf->buffer.tsc);
+ //printf("previous tsc&(~mask) 0x%llX\n", tf->buffer.tsc&(~tf->tsc_mask));
if(event->timestamp < (tf->tsc_mask&tf->buffer.tsc)) {
- printf("wrap\n");
+ //printf("wrap\n");
tf->buffer.tsc = ((tf->buffer.tsc&(~tf->tsc_mask))
+ tf->tsc_mask_next_bit)
| (guint64)event->timestamp;
event->tsc = tf->buffer.tsc;
} else {
- printf("no wrap\n");
+ //printf("no wrap\n");
/* no overflow */
tf->buffer.tsc = (tf->buffer.tsc&(~tf->tsc_mask))
| (guint64)event->timestamp;
event->tsc = tf->buffer.tsc;
}
- printf("current tsc 0x%llX\n", tf->buffer.tsc);
- g_assert(tf->trace->compact_facilities);
- /* FIXME : currently does not support unload/load of compact
- * facility during tracing. Should check for the currently loaded
- * version of the facility. */
- g_assert(tf->trace->compact_facilities->len == 1);
+ //printf("current tsc 0x%llX\n", tf->buffer.tsc);
event->facility_id = g_array_index(tf->trace->compact_facilities, guint, 0);
}
pos += sizeof(guint32);
} else {
event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos);
tf->buffer.tsc = event->tsc;
+ event->compact_data = 0;
pos += sizeof(guint64);
}
event->event_time = ltt_interpolate_time(tf, event);
/* Event size too big to fit in the event size field */
tf->event.event_size = tf->event.data_size;
}
- g_assert(tf->event.data_size == tf->event.event_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;
****************************************************************************/
-gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset)
+gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, gint is_compact)
{
LttType *type = &field->field_type;
+
+ if(unlikely(is_compact)) {
+ g_assert(field->field_size != 0);
+ /* FIXME THIS IS A HUUUUUGE hack :
+ * offset is between the compact_data field in struct LttEvent
+ * and the address of the field root in the memory map.
+ * ark. Both will stay at the same addresses while the event
+ * is readable, so it's ok.
+ */
+ field->offset_root = 0;
+ field->fixed_root = FIELD_FIXED;
+ return 0;
+ }
switch(type->type_class) {
case LTT_INT_FIXED:
field->fixed_root = FIELD_FIXED;
child = &g_array_index(type->fields, LttField, 0);
- ret = precompute_fields_offsets(fac, child, offset);
+ ret = precompute_fields_offsets(fac, child, offset, is_compact);
g_assert(ret == 0); /* Seq len cannot have variable len */
child = &g_array_index(type->fields, LttField, 1);
for(i=0; i< type->fields->len; i++) {
child = &g_array_index(type->fields, LttField, i);
- ret = precompute_fields_offsets(fac, child, offset);
+ ret = precompute_fields_offsets(fac, child, offset, is_compact);
if(ret) break;
}
for(i=0; i< type->fields->len; i++) {
*offset = field->offset_root;
child = &g_array_index(type->fields, LttField, i);
- ret = precompute_fields_offsets(fac, child, offset);
+ ret = precompute_fields_offsets(fac, child, offset, is_compact);
if(ret) break;
}
/* Precompute all known offsets */
for(i=0; i<event->fields->len; i++) {
LttField *field = &g_array_index(event->fields, LttField, i);
- ret = precompute_fields_offsets(fac, field, &offset);
+ if(event->has_compact_data && i == 0)
+ ret = precompute_fields_offsets(fac, field, &offset, 1);
+ else
+ ret = precompute_fields_offsets(fac, field, &offset, 0);
if(ret) break;
}
}
break;
case LTT_NONE:
default:
- g_error("precompute_fields_offsets : unknown type");
+ g_error("check_fields_compatibility : unknown type");
}
end: