#define g_close close
-/* obtain the time of an event */
-
-static inline LttTime getEventTime(LttTracefile * tf);
-
+/* Those macros must be called from within a function where page_size is a known
+ * variable */
+#define PAGE_MASK (~(page_size-1))
+#define PAGE_ALIGN(addr) (((addr)+page_size-1)&PAGE_MASK)
/* 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);
+//void set_fields_offsets(LttTracefile *tf, LttEventType *event_type);
//size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data);
/* get the size of the field type according to
* The facility size information. */
+#if 0
static inline void preset_field_type_size(LttTracefile *tf,
LttEventType *event_type,
off_t offset_root, off_t offset_parent,
enum field_status *fixed_root, enum field_status *fixed_parent,
LttField *field);
+#endif //0
/* map a fixed size or a block information from the file (fd) */
static gint map_block(LttTracefile * tf, guint block_num);
/* calculate nsec per cycles for current block */
-static double calc_nsecs_per_cycle(LttTracefile * t);
+#if 0
+static guint32 calc_nsecs_per_cycle(LttTracefile * t);
+static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles);
+#endif //0
/* go to the next event */
static int ltt_seek_next_event(LttTracefile *tf);
void ltt_update_event_size(LttTracefile *tf);
+
+void precompute_offsets(LttTracefile *tf, LttEventType *event);
+
#if 0
/* Functions to parse system.xml file (using glib xml parser) */
static void parser_start_element (GMarkupParseContext __UNUSED__ *context,
des->description = g_strdup(text);
}
#endif //0
+
+
LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
guint num)
{
}
+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)
+{
+ guint32 *magic_number = (guint32*)header;
+ struct ltt_trace_header_any *any = (struct ltt_trace_header_any *)header;
+
+ if(*magic_number == LTT_MAGIC_NUMBER)
+ tf->reverse_bo = 0;
+ else if(*magic_number == LTT_REV_MAGIC_NUMBER)
+ tf->reverse_bo = 1;
+ else /* invalid magic number, bad tracefile ! */
+ return 1;
+
+ /* 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;
+
+ if(t) {
+ t->arch_type = ltt_get_uint32(LTT_GET_BO(tf),
+ &any->arch_type);
+ t->arch_variant = ltt_get_uint32(LTT_GET_BO(tf),
+ &any->arch_variant);
+ t->arch_size = any->arch_size;
+ 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->has_tsc = any->has_tsc;
+ }
+
+
+ switch(any->major_version) {
+
+ case 0:
+ switch(any->minor_version) {
+ case 3:
+ {
+ tf->buffer_header_size =
+ sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_0_3);
+ g_warning("Unsupported trace version : %hhu.%hhu",
+ any->major_version, any->minor_version);
+ return 1;
+ }
+ break;
+ case 4:
+ {
+ struct ltt_trace_header_0_4 *vheader =
+ (struct ltt_trace_header_0_4 *)header;
+ tf->buffer_header_size =
+ sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_0_4);
+ if(t) {
+ t->start_freq = ltt_get_uint64(LTT_GET_BO(tf),
+ &vheader->start_freq);
+ t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf),
+ &vheader->start_tsc);
+ t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf),
+ &vheader->start_monotonic);
+ t->start_time = ltt_get_time(LTT_GET_BO(tf),
+ &vheader->start_time);
+ t->start_time.tv_nsec *= 1000; /* microsec to nanosec */
+
+ t->start_time_from_tsc = ltt_time_from_uint64(
+ (double)t->start_tsc * 1000000.0 / (double)t->start_freq);
+ }
+ }
+ break;
+ default:
+ g_warning("Unsupported trace version : %hhu.%hhu",
+ any->major_version, any->minor_version);
+ return 1;
+ }
+ break;
+
+ default:
+ g_warning("Unsupported trace version : %hhu.%hhu",
+ any->major_version, any->minor_version);
+ return 1;
+ }
+
+
+ return 0;
+}
+
+
/*****************************************************************************
*Function name
{
struct stat lTDFStat; /* Trace data file status */
struct ltt_block_start_header *header;
+ int page_size = getpagesize();
//open the file
- tf->name = g_quark_from_string(fileName);
+ tf->long_name = g_quark_from_string(fileName);
tf->trace = t;
tf->fd = open(fileName, O_RDONLY);
if(tf->fd < 0){
}
// Is the file large enough to contain a trace
- if(lTDFStat.st_size < (off_t)(sizeof(struct ltt_block_start_header))){
+ if(lTDFStat.st_size <
+ (off_t)(sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_any))){
g_print("The input data file %s does not contain a trace\n", fileName);
goto close_file;
}
/* Temporarily map the buffer start header to get trace information */
/* Multiple of pages aligned head */
- tf->buffer.head = mmap(0, sizeof(struct ltt_block_start_header), PROT_READ,
+ tf->buffer.head = mmap(0,
+ PAGE_ALIGN(sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_any)), PROT_READ,
MAP_PRIVATE, tf->fd, 0);
if(tf->buffer.head == MAP_FAILED) {
perror("Error in allocating memory for buffer of tracefile");
header = (struct ltt_block_start_header*)tf->buffer.head;
- if(header->trace.magic_number == LTT_MAGIC_NUMBER)
- tf->reverse_bo = 0;
- else if(header->trace.magic_number == LTT_REV_MAGIC_NUMBER)
- tf->reverse_bo = 1;
- else /* invalid magic number, bad tracefile ! */
+ if(parse_trace_header(header->trace, tf, NULL)) {
+ g_warning("parse_trace_header error");
goto unmap_file;
+ }
//store the size of the file
tf->file_size = lTDFStat.st_size;
- tf->block_size = header->buf_size;
- tf->num_blocks = tf->file_size / tf->block_size;
-
- munmap(tf->buffer.head, sizeof(struct ltt_block_start_header));
+ tf->buf_size = ltt_get_uint32(LTT_GET_BO(tf), &header->buf_size);
+ tf->num_blocks = tf->file_size / tf->buf_size;
+
+ if(munmap(tf->buffer.head,
+ PAGE_ALIGN(sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_any)))) {
+ g_warning("unmap size : %u\n",
+ PAGE_ALIGN(sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_any)));
+ perror("munmap error");
+ g_assert(0);
+ }
tf->buffer.head = NULL;
//read the first block
/* Error */
unmap_file:
- munmap(tf->buffer.head, sizeof(struct ltt_block_start_header));
+ if(munmap(tf->buffer.head,
+ PAGE_ALIGN(sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_any)))) {
+ g_warning("unmap size : %u\n",
+ PAGE_ALIGN(sizeof(struct ltt_block_start_header)
+ + sizeof(struct ltt_trace_header_any)));
+ perror("munmap error");
+ g_assert(0);
+ }
close_file:
close(tf->fd);
end:
return -1;
}
+LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
+{
+ return tf->trace;
+}
+
#if 0
/*****************************************************************************
*Open control and per cpu tracefiles
void ltt_tracefile_close(LttTracefile *t)
{
+ int page_size = getpagesize();
+
if(t->buffer.head != NULL)
- munmap(t->buffer.head, t->buf_size);
+ if(munmap(t->buffer.head, PAGE_ALIGN(t->buf_size))) {
+ g_warning("unmap size : %u\n",
+ PAGE_ALIGN(t->buf_size));
+ perror("munmap error");
+ g_assert(0);
+ }
+
close(t->fd);
}
{
guint raw_name_len = strlen(raw_name);
gchar char_name[PATH_MAX];
- gchar *digit_begin;
int i;
int underscore_pos;
long int cpu_num;
strncpy(char_name, raw_name, underscore_pos);
+ char_name[underscore_pos] = '\0';
+
*name = g_quark_from_string(char_name);
*num = cpu_num;
* A tracefile group is simply an array where all the per cpu tracefiles sits.
*/
-static int open_tracefiles(LttTrace *trace, char *root_path,
- char *relative_path)
+static int open_tracefiles(LttTrace *trace, gchar *root_path,
+ gchar *relative_path)
{
DIR *dir = opendir(root_path);
struct dirent *entry;
struct stat stat_buf;
int ret;
- char path[PATH_MAX];
+ gchar path[PATH_MAX];
int path_len;
- char *path_ptr;
+ gchar *path_ptr;
int rel_path_len;
- char rel_path[PATH_MAX];
- char *rel_path_ptr;
+ gchar rel_path[PATH_MAX];
+ gchar *rel_path_ptr;
+ LttTracefile tmp_tf;
if(dir == NULL) {
perror(root_path);
g_debug("Tracefile file or directory : %s\n", path);
+ if(strcmp(rel_path, "/eventdefs") == 0) continue;
+
if(S_ISDIR(stat_buf.st_mode)) {
g_debug("Entering subdirectory...\n");
ret = open_tracefiles(trace, path, rel_path);
if(ret < 0) continue;
} else if(S_ISREG(stat_buf.st_mode)) {
- g_debug("Opening file.\n");
-
GQuark name;
guint num;
GArray *group;
- LttTracefile *tf;
- guint len;
if(get_tracefile_name_number(rel_path, &name, &num))
continue; /* invalid name */
+ g_debug("Opening file.\n");
+ if(ltt_tracefile_open(trace, path, &tmp_tf)) {
+ g_info("Error opening tracefile %s", path);
+
+ continue; /* error opening the tracefile : bad magic number ? */
+ }
+
g_debug("Tracefile name is %s and number is %u",
g_quark_to_string(name), num);
+ tmp_tf.cpu_online = 1;
+ tmp_tf.cpu_num = num;
+ tmp_tf.name = name;
+
group = g_datalist_id_get_data(&trace->tracefiles, name);
if(group == NULL) {
/* Elements are automatically cleared when the array is allocated.
g_datalist_id_set_data_full(&trace->tracefiles, name,
group, ltt_tracefile_group_destroy);
}
+
/* Add the per cpu tracefile to the named group */
unsigned int old_len = group->len;
if(num+1 > old_len)
group = g_array_set_size(group, num+1);
- tf = &g_array_index (group, LttTracefile, num);
-
- if(ltt_tracefile_open(trace, path, tf)) {
- g_info("Error opening tracefile %s", path);
- g_array_set_size(group, old_len);
-
- if(!ltt_tracefile_group_has_cpu_online(group))
- g_datalist_id_remove_data(&trace->tracefiles, name);
+ g_array_index (group, LttTracefile, num) = tmp_tf;
- continue; /* error opening the tracefile : bad magic number ? */
- }
- tf->cpu_online = 1;
- tf->cpu_num = num;
}
}
/* ltt_get_facility_description
*
- * Opens the trace corresponding to the requested facility (identified by fac_id
+ * Opens the file corresponding to the requested facility (identified by fac_id
* and checksum).
*
* The name searched is : %trace root%/eventdefs/facname_checksum.xml
const gchar *text;
guint textlen;
gint err;
- int i, j;
- LttEventType *et;
text = g_quark_to_string(t->pathname);
textlen = strlen(text);
textlen+=strlen(text);
if(textlen >= PATH_MAX) goto name_error;
strcat(desc_file_name, text);
-
+#if 0
text = "_";
textlen+=strlen(text);
if(textlen >= PATH_MAX) goto name_error;
err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1,
"%u", f->checksum);
- if(err) goto name_error;
+ if(err < 0) goto name_error;
textlen=strlen(desc_file_name);
+#endif //0
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;
-
- for(i=0;i<t->facilities_by_num->len;i++){
- f = &g_array_index(t->facilities_by_num, LttFacility, i);
- if(f->exists) {
- for(j=0; j<f->events->len; j++){
- et = &g_array_index(f->events, LttEventType, j);
- set_fields_offsets(fac_tf, et);
- }
- }
- }
-
return 0;
static void ltt_fac_ids_destroy(gpointer data)
{
GArray *fac_ids = (GArray *)data;
- int i;
- LttFacility *fac;
-
- for(i=0; i<fac_ids->len; i++) {
- fac = &g_array_index (fac_ids, LttFacility, i);
- ltt_facility_close(fac);
- }
g_array_free(fac_ids, TRUE);
}
int err;
LttFacility *fac;
GArray *fac_ids;
+ guint i;
+ LttEventType *et;
while(1) {
err = ltt_tracefile_read_seek(tf);
* 0 : facility load
* 1 : facility unload
* 2 : state dump facility load
- * Facility 1 : (heartbeat)
- * 0 : heartbeat
+ * 3 : heartbeat
*/
- if(tf->event.facility_id > 1) { /* Should only contain core and heartbeat
- facilities */
+ if(tf->event.facility_id != LTT_FACILITY_CORE) {
+ /* Should only contain core facility */
g_warning("Error in processing facility file %s, "
"should not contain facility id %u.", g_quark_to_string(tf->name),
tf->event.facility_id);
err = EPERM;
goto fac_id_error;
- } else if(tf->event.facility_id == LTT_FACILITY_CORE) {
+ } else {
struct LttFacilityLoad *fac_load_data;
+ struct LttStateDumpFacilityLoad *fac_state_dump_load_data;
char *fac_name;
// FIXME align
switch((enum ltt_core_events)tf->event.event_id) {
case LTT_EVENT_FACILITY_LOAD:
+ fac_name = (char*)(tf->event.data);
+ g_debug("Doing LTT_EVENT_FACILITY_LOAD of facility %s",
+ fac_name);
fac_load_data =
- (struct LttFacilityLoad *)tf->event.data;
- fac_name =
- (char*)(tf->event.data + sizeof(struct LttFacilityLoad));
+ (struct LttFacilityLoad *)
+ (tf->event.data + strlen(fac_name) + 1);
fac = &g_array_index (tf->trace->facilities_by_num, LttFacility,
ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id));
- g_assert(fac->exists == 0);
+ /* facility may already exist if trace is paused/unpaused */
+ if(fac->exists) continue;
fac->name = g_quark_from_string(fac_name);
fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->checksum);
fac->id = ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id);
fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->pointer_size);
+ fac->int_size = ltt_get_uint32(LTT_GET_BO(tf),
+ &fac_load_data->int_size);
+ fac->long_size = ltt_get_uint32(LTT_GET_BO(tf),
+ &fac_load_data->long_size);
fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->size_t_size);
fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
- &fac_load_data->alignment);
+ &fac_load_data->has_alignment);
if(ltt_get_facility_description(fac, tf->trace, tf))
- goto facility_error;
+ continue; /* error opening description */
fac->trace = tf->trace;
+
+ /* Preset the field offsets */
+ for(i=0; i<fac->events->len; i++){
+ et = &g_array_index(fac->events, LttEventType, i);
+ precompute_offsets(tf, et);
+ }
+
fac->exists = 1;
fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
break;
case LTT_EVENT_FACILITY_UNLOAD:
+ g_debug("Doing LTT_EVENT_FACILITY_UNLOAD");
/* We don't care about unload : facilities ID are valid for the whole
* trace. They simply won't be used after the unload. */
break;
case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
- fac_load_data =
- (struct LttFacilityLoad *)tf->event.data;
- fac_name =
- (char*)(tf->event.data + sizeof(struct LttFacilityLoad));
+ fac_name = (char*)(tf->event.data);
+ g_debug("Doing LTT_EVENT_STATE_DUMP_FACILITY_LOAD of facility %s",
+ fac_name);
+ fac_state_dump_load_data =
+ (struct LttStateDumpFacilityLoad *)
+ (tf->event.data + strlen(fac_name) + 1);
fac = &g_array_index (tf->trace->facilities_by_num, LttFacility,
- ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id));
- g_assert(fac->exists == 0);
+ ltt_get_uint32(LTT_GET_BO(tf), &fac_state_dump_load_data->id));
+ /* facility may already exist if trace is paused/unpaused */
+ if(fac->exists) continue;
fac->name = g_quark_from_string(fac_name);
fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
- &fac_load_data->checksum);
- fac->id = fac_load_data->id;
+ &fac_state_dump_load_data->checksum);
+ fac->id = ltt_get_uint32(LTT_GET_BO(tf),
+ &fac_state_dump_load_data->id);
fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
- &fac_load_data->pointer_size);
+ &fac_state_dump_load_data->pointer_size);
+ fac->int_size = ltt_get_uint32(LTT_GET_BO(tf),
+ &fac_state_dump_load_data->int_size);
+ fac->long_size = ltt_get_uint32(LTT_GET_BO(tf),
+ &fac_state_dump_load_data->long_size);
fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
- &fac_load_data->size_t_size);
+ &fac_state_dump_load_data->size_t_size);
fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
- &fac_load_data->alignment);
+ &fac_state_dump_load_data->has_alignment);
if(ltt_get_facility_description(fac, tf->trace, tf))
- goto facility_error;
+ continue; /* error opening description */
fac->trace = tf->trace;
+ /* Preset the field offsets */
+ for(i=0; i<fac->events->len; i++){
+ et = &g_array_index(fac->events, LttEventType, i);
+ precompute_offsets(tf, et);
+ }
+
fac->exists = 1;
fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
return 0;
/* Error handling */
-facility_error:
event_id_error:
fac_id_error:
update_error:
seek_error:
+ g_warning("An error occured in facility tracefile parsing");
return err;
}
LttTrace * t;
LttTracefile *tf;
GArray *group;
- int i;
+ int i, ret;
+ struct ltt_block_start_header *header;
+ DIR *dir;
+ struct dirent *entry;
+ guint control_found = 0;
+ guint eventdefs_found = 0;
+ struct stat stat_buf;
+ gchar path[PATH_MAX];
t = g_new(LttTrace, 1);
if(!t) goto alloc_error;
get_absolute_pathname(pathname, abs_path);
t->pathname = g_quark_from_string(abs_path);
- /* Open all the tracefiles */
g_datalist_init(&t->tracefiles);
- if(open_tracefiles(t, abs_path, ""))
- goto open_error;
+
+ /* Test to see if it looks like a trace */
+ dir = opendir(abs_path);
+ if(dir == NULL) {
+ perror(abs_path);
+ goto open_error;
+ }
+ while((entry = readdir(dir)) != NULL) {
+ strcpy(path, abs_path);
+ strcat(path, "/");
+ strcat(path, entry->d_name);
+ ret = stat(path, &stat_buf);
+ if(ret == -1) {
+ perror(path);
+ continue;
+ }
+ if(S_ISDIR(stat_buf.st_mode)) {
+ 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;
+
+ /* Open all the tracefiles */
+ if(open_tracefiles(t, abs_path, "")) {
+ g_warning("Error opening tracefile %s", abs_path);
+ goto find_error;
+ }
/* Prepare the facilities containers : array and mapping */
/* Array is zeroed : the "exists" field is set to false by default */
goto facilities_error;
}
+ /* Get the trace information for the control/facility 0 tracefile */
+ g_assert(group->len > 0);
+ tf = &g_array_index (group, LttTracefile, 0);
+ header = (struct ltt_block_start_header*)tf->buffer.head;
+ g_assert(parse_trace_header(header->trace,
+ tf, t) == 0);
+
+ t->num_cpu = group->len;
+
for(i=0; i<group->len; i++) {
tf = &g_array_index (group, LttTracefile, i);
if(ltt_process_facility_tracefile(tf))
goto facilities_error;
}
-
-
return t;
facilities_error:
g_datalist_clear(&t->facilities_by_name);
g_array_free(t->facilities_by_num, TRUE);
-open_error:
+find_error:
g_datalist_clear(&t->tracefiles);
+open_error:
g_free(t);
alloc_error:
return NULL;
}
-GQuark ltt_trace_name(LttTrace *t)
+GQuark ltt_trace_name(const LttTrace *t)
{
return t->pathname;
}
void ltt_trace_close(LttTrace *t)
{
+ guint i;
+ LttFacility *fac;
+
+ for(i=0; i<t->facilities_by_num->len; i++) {
+ fac = &g_array_index (t->facilities_by_num, LttFacility, i);
+ if(fac->exists)
+ ltt_facility_close(fac);
+ }
+
g_datalist_clear(&t->facilities_by_name);
g_array_free(t->facilities_by_num, TRUE);
g_datalist_clear(&t->tracefiles);
static void ltt_tracefile_time_span_get(LttTracefile *tf,
LttTime *start, LttTime *end)
{
- struct ltt_block_start_header * header;
int err;
err = map_block(tf, 0);
*Get the name of a tracefile
****************************************************************************/
-GQuark ltt_tracefile_name(LttTracefile *tf)
+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_num(LttTracefile *tf)
+{
+ return tf->cpu_num;
+}
+
/*****************************************************************************
* Get the number of blocks in the tracefile
****************************************************************************/
* the time passed in parameter.
*
* If the time parameter is outside the tracefile time span, seek to the first
- * or the last event of the tracefile.
+ * event or if after, return ERANGE.
*
* If the time parameter is before the first event, we have to seek specially to
* there.
*
- * If the time is after the end of the trace, get the last event.
+ * If the time is after the end of the trace, return ERANGE.
*
* Do a binary search to find the right block, then a sequential search in the
* block to find the event.
* you will jump over an event if you do.
*
* Return value : 0 : no error, the tf->event can be used
+ * ERANGE : time if after the last event of the trace
* otherwise : this is an error.
*
* */
* go to the first event. */
if(ltt_time_compare(time, tf->buffer.begin.timestamp) <= 0) {
ret = ltt_tracefile_read(tf);
+ if(ret == ERANGE) goto range;
+ else if (ret) goto fail;
goto found; /* There is either no event in the trace or the event points
to the first event in the trace */
}
goto fail;
}
- /* If the time is after the end of the trace, get the last event. */
- if(ltt_time_compare(time, tf->buffer.end.timestamp) >= 0) {
- /* While the ltt_tracefile_read doesn't return ERANGE or EPERM,
- * continue reading.
- */
- while(1) {
- ret = ltt_tracefile_read(tf);
- if(ret == ERANGE) goto found; /* ERANGE or EPERM */
- else if(ret) goto fail;
- }
+ /* If the time is after the end of the trace, return ERANGE. */
+ if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
+ goto range;
}
/* Binary search the block */
* (or in the next buffer first event) */
while(1) {
ret = ltt_tracefile_read(tf);
- if(ret == ERANGE) goto found; /* ERANGE or EPERM */
+ if(ret == ERANGE) goto range; /* ERANGE or EPERM */
else if(ret) goto fail;
- if(ltt_time_compare(time, tf->event.event_time) >= 0)
- break;
+ if(ltt_time_compare(time, tf->event.event_time) <= 0)
+ goto found;
}
- } if(ltt_time_compare(time, tf->buffer.begin.timestamp) < 0) {
+ } else if(ltt_time_compare(time, tf->buffer.begin.timestamp) < 0) {
/* go to lower part */
- high = block_num;
+ high = block_num - 1;
} else if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
/* go to higher part */
- low = block_num;
+ low = block_num + 1;
} else {/* The event is right in the buffer!
(or in the next buffer first event) */
while(1) {
- ltt_tracefile_read(tf);
- if(ret == ERANGE) goto found; /* ERANGE or EPERM */
+ ret = ltt_tracefile_read(tf);
+ if(ret == ERANGE) goto range; /* ERANGE or EPERM */
else if(ret) goto fail;
- if(ltt_time_compare(time, tf->event.event_time) >= 0)
+ if(ltt_time_compare(time, tf->event.event_time) <= 0)
break;
}
goto found;
found:
return 0;
+range:
+ return ERANGE;
/* Error handling */
fail:
err = ltt_tracefile_read_op(tf);
if(err) goto fail;
- return;
+ return 0;
fail:
g_error("ltt_tracefile_seek_time failed on tracefile %s",
g_quark_to_string(tf->name));
+ return 1;
}
/* Calculate the real event time based on the buffer boundaries */
g_assert(tf->trace->has_tsc);
+// time = ltt_time_from_uint64(
+// cycles_2_ns(tf, (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count)));
time = ltt_time_from_uint64(
- (guint64)tf->buffer.tsc*tf->buffer.nsecs_per_cycle);
- time = ltt_time_add(tf->buffer.begin.timestamp, time);
+ (double)(tf->buffer.tsc - tf->trace->start_tsc) * 1000000.0
+ / (double)tf->trace->start_freq);
+ //time = ltt_time_add(tf->buffer.begin.timestamp, time);
+ time = ltt_time_add(tf->trace->start_time_from_tsc, time);
return time;
}
*Return value
*
* Returns 0 if an event can be used in tf->event.
- * Returns ERANGE on end of trace. The event in tf->event still can be used.
+ * Returns ERANGE on end of trace. The event in tf->event still can be used
+ * (if the last block was not empty).
* Returns EPERM on error.
*
* This function does make the tracefile event structure point to the event
/* do specific operation on events */
int ltt_tracefile_read_op(LttTracefile *tf)
{
- int err;
- LttFacility *f;
- void * pos;
LttEvent *event;
event = &tf->event;
* event specific operation. */
int ltt_tracefile_read_update_event(LttTracefile *tf)
{
- int err;
- LttFacility *f;
void * pos;
LttEvent *event;
/* Read event header */
- //TODO align
+ /* Align the head */
+ pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
if(tf->trace->has_tsc) {
- event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf),
- pos);
- /* 32 bits -> 64 bits tsc */
- /* note : still works for seek and non seek cases. */
- if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) {
- tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL)
- + 0x100000000ULL)
- | (guint64)event->time.timestamp;
- event->tsc = tf->buffer.tsc;
+ if(tf->trace->has_heartbeat) {
+ event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf),
+ pos);
+ /* 32 bits -> 64 bits tsc */
+ /* note : still works for seek and non seek cases. */
+ if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) {
+ tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL)
+ + 0x100000000ULL)
+ | (guint64)event->time.timestamp;
+ event->tsc = tf->buffer.tsc;
+ } else {
+ /* no overflow */
+ tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL)
+ | (guint64)event->time.timestamp;
+ event->tsc = tf->buffer.tsc;
+ }
+ pos += sizeof(guint32);
} else {
- /* no overflow */
- tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL)
- | (guint64)event->time.timestamp;
- event->tsc = tf->buffer.tsc;
+ event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos);
+ tf->buffer.tsc = event->tsc;
+ pos += sizeof(guint64);
}
-
+
event->event_time = ltt_interpolate_time(tf, event);
-
- pos += sizeof(guint32);
} else {
event->time.delta.tv_sec = 0;
event->time.delta.tv_nsec = ltt_get_uint32(LTT_GET_BO(tf),
event->event_id = *(guint8*)pos;
pos += sizeof(guint8);
+ event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos);
+ pos += sizeof(guint16);
+
+ /* Align the head */
+ pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment);
+
event->data = pos;
/* get the data size and update the event fields with the current
static gint map_block(LttTracefile * tf, guint block_num)
{
+ int page_size = getpagesize();
struct ltt_block_start_header *header;
g_assert(block_num < tf->num_blocks);
- if(tf->buffer.head != NULL)
- munmap(tf->buffer.head, tf->buf_size);
+ if(tf->buffer.head != NULL) {
+ if(munmap(tf->buffer.head, PAGE_ALIGN(tf->buf_size))) {
+ g_warning("unmap size : %u\n",
+ PAGE_ALIGN(tf->buf_size));
+ perror("munmap error");
+ g_assert(0);
+ }
+ }
+
/* Multiple of pages aligned head */
- tf->buffer.head = mmap(0, tf->block_size, PROT_READ, MAP_PRIVATE, tf->fd,
- (off_t)tf->block_size * (off_t)block_num);
+ tf->buffer.head = mmap(0,
+ PAGE_ALIGN(tf->buf_size),
+ PROT_READ, MAP_PRIVATE, tf->fd,
+ PAGE_ALIGN((off_t)tf->buf_size * (off_t)block_num));
if(tf->buffer.head == MAP_FAILED) {
perror("Error in allocating memory for buffer of tracefile");
header = (struct ltt_block_start_header*)tf->buffer.head;
- tf->buffer.begin.timestamp = ltt_get_time(LTT_GET_BO(tf),
- &header->begin.timestamp);
- tf->buffer.begin.timestamp.tv_nsec *= NSEC_PER_USEC;
+#if 0
+ tf->buffer.begin.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ ltt_get_uint64(LTT_GET_BO(tf),
+ &header->begin.timestamp)
+ - tf->trace->start_monotonic),
+ tf->trace->start_time);
+#endif //0
+ //g_debug("block %u begin : %lu.%lu", block_num,
+ // tf->buffer.begin.timestamp.tv_sec, tf->buffer.begin.timestamp.tv_nsec);
tf->buffer.begin.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
&header->begin.cycle_count);
- tf->buffer.end.timestamp = ltt_get_time(LTT_GET_BO(tf),
- &header->end.timestamp);
- tf->buffer.end.timestamp.tv_nsec *= NSEC_PER_USEC;
+ tf->buffer.begin.freq = ltt_get_uint64(LTT_GET_BO(tf),
+ &header->begin.freq);
+ tf->buffer.begin.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ (double)(tf->buffer.begin.cycle_count
+ - tf->trace->start_tsc) * 1000000.0
+ / (double)tf->trace->start_freq),
+ tf->trace->start_time_from_tsc);
+#if 0
+
+ tf->buffer.end.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ ltt_get_uint64(LTT_GET_BO(tf),
+ &header->end.timestamp)
+ - tf->trace->start_monotonic),
+ tf->trace->start_time);
+#endif //0
+ //g_debug("block %u end : %lu.%lu", block_num,
+ // tf->buffer.end.timestamp.tv_sec, tf->buffer.end.timestamp.tv_nsec);
tf->buffer.end.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
&header->end.cycle_count);
+ tf->buffer.end.freq = ltt_get_uint64(LTT_GET_BO(tf),
+ &header->end.freq);
tf->buffer.lost_size = ltt_get_uint32(LTT_GET_BO(tf),
- &header->lost_size);
-
+ &header->lost_size);
+ tf->buffer.end.timestamp = ltt_time_add(
+ ltt_time_from_uint64(
+ (double)(tf->buffer.end.cycle_count
+ - tf->trace->start_tsc) * 1000000.0
+ / (double)tf->trace->start_freq),
+ tf->trace->start_time_from_tsc);
+
tf->buffer.tsc = tf->buffer.begin.cycle_count;
tf->event.tsc = tf->buffer.tsc;
+ tf->buffer.freq = tf->buffer.begin.freq;
/* FIXME
* eventually support variable buffer size : will need a partial pre-read of
* the headers to create an index when we open the trace... eventually. */
- g_assert(tf->block_size == ltt_get_uint32(LTT_GET_BO(tf),
+ g_assert(tf->buf_size == ltt_get_uint32(LTT_GET_BO(tf),
&header->buf_size));
/* Now that the buffer is mapped, calculate the time interpolation for the
* block. */
- tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf);
+// tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf);
+ //tf->buffer.cyc2ns_scale = calc_nsecs_per_cycle(tf);
/* Make the current event point to the beginning of the buffer :
* it means that the event read must get the first event. */
/* It will update the fields offsets too */
void ltt_update_event_size(LttTracefile *tf)
{
- ssize_t size = 0;
+ off_t size = 0;
/* Specific handling of core events : necessary to read the facility control
* tracefile. */
if(likely(tf->event.facility_id == LTT_FACILITY_CORE)) {
switch((enum ltt_core_events)tf->event.event_id) {
case LTT_EVENT_FACILITY_LOAD:
- size = strlen((char*)tf->event.data);
+ size = strlen((char*)tf->event.data) + 1;
+ //g_debug("Update Event facility load of facility %s", (char*)tf->event.data);
size += sizeof(struct LttFacilityLoad);
break;
case LTT_EVENT_FACILITY_UNLOAD:
+ //g_debug("Update Event facility unload");
size = sizeof(struct LttFacilityUnload);
break;
case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
- size = strlen((char*)tf->event.data);
+ size = strlen((char*)tf->event.data) + 1;
+ //g_debug("Update Event facility load state dump of facility %s",
+ // (char*)tf->event.data);
size += sizeof(struct LttStateDumpFacilityLoad);
break;
case LTT_EVENT_HEARTBEAT:
+ //g_debug("Update Event heartbeat");
size = sizeof(TimeHeartbeat);
break;
default:
g_quark_to_string(tf->name));
goto event_type_error;
}
+
+ /* Compute the dynamic offsets */
+ compute_offsets(tf, event_type, &size, tf->event.data);
- size = get_field_type_size(tf, event_type,
- 0, 0, event_type->root_field, tf->event.data);
- g_debug("Event root field : f.e %hhu.%hhu size %lu", tf->event.facility_id,
- tf->event.event_id, size);
+ //g_debug("Event root field : f.e %hhu.%hhu size %zd",
+ // tf->event.facility_id,
+ // tf->event.event_id, size);
}
tf->event.data_size = size;
+ /* Check consistency between kernel and LTTV structure sizes */
+ g_assert(tf->event.data_size == tf->event.event_size);
+
return;
facility_error:
{
int ret = 0;
void *pos;
- ssize_t event_size;
/* seek over the buffer header if we are at the buffer start */
if(tf->event.offset == 0) {
- tf->event.offset += sizeof(struct ltt_block_start_header);
- goto found;
- }
+ tf->event.offset += tf->buffer_header_size;
-
- if(tf->event.offset == tf->buffer.lost_size) {
- ret = ERANGE;
+ if(tf->event.offset == tf->buf_size - tf->buffer.lost_size) {
+ ret = ERANGE;
+ }
goto found;
}
+
pos = tf->event.data;
if(tf->event.data_size < 0) goto error;
pos += (size_t)tf->event.data_size;
tf->event.offset = pos - tf->buffer.head;
+
+ if(tf->event.offset == tf->buf_size - tf->buffer.lost_size) {
+ ret = ERANGE;
+ goto found;
+ }
+ g_assert(tf->event.offset < tf->buf_size - tf->buffer.lost_size);
found:
return ret;
return ENOPROTOOPT;
}
-
+#if 0
/*****************************************************************************
*Function name
* calc_nsecs_per_cycle : calculate nsecs per cycle for current block
+ *
+ * 1.0 / (freq(khz) *1000) * 1000000000
*Input Params
* t : tracefile
****************************************************************************/
-
-static double calc_nsecs_per_cycle(LttTracefile * tf)
+/* from timer_tsc.c */
+#define CYC2NS_SCALE_FACTOR 10
+static guint32 calc_nsecs_per_cycle(LttTracefile * tf)
{
- LttTime lBufTotalTime; /* Total time for this buffer */
- double lBufTotalNSec; /* Total time for this buffer in nsecs */
- LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */
-
- /* Calculate the total time for this buffer */
- lBufTotalTime = ltt_time_sub(
- ltt_get_time(LTT_GET_BO(tf), &tf->buffer.end.timestamp),
- ltt_get_time(LTT_GET_BO(tf), &tf->buffer.begin.timestamp));
-
- /* Calculate the total cycles for this bufffer */
- lBufTotalCycle = ltt_get_uint64(LTT_GET_BO(tf), &tf->buffer.end.cycle_count);
- lBufTotalCycle -= ltt_get_uint64(LTT_GET_BO(tf),
- &tf->buffer.begin.cycle_count);
-
- /* Convert the total time to double */
- lBufTotalNSec = ltt_time_to_double(lBufTotalTime);
+ //return 1e6 / (double)tf->buffer.freq;
+ guint32 cpu_mhz = tf->buffer.freq / 1000;
+ guint32 cyc2ns_scale = (1000 << CYC2NS_SCALE_FACTOR)/cpu_mhz;
- return lBufTotalNSec / (double)lBufTotalCycle;
+ return cyc2ns_scale;
+ // return 1e6 / (double)tf->buffer.freq;
+}
+static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles)
+{
+ return (cycles * tf->buffer.cyc2ns_scale) >> CYC2NS_SCALE_FACTOR;
}
+#endif //0
+
#if 0
void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD)
{
evT, 0,0,rootFld, evD);
}
#endif //0
-
+#if 0
/*****************************************************************************
*Function name
* set_fields_offsets : set the precomputable offset of the fields
field);
}
+#endif //0
+
+
+/*****************************************************************************
+ *Function name
+ * get_alignment : Get the alignment needed for a field.
+ *Input params
+ * tf : tracefile
+ * field : field
+ *
+ * returns : The size on which it must be aligned.
+ *
+ ****************************************************************************/
+off_t get_alignment(LttTracefile *tf, LttField *field)
+{
+ LttType *type = &field->field_type;
+
+ switch(type->type_class) {
+ case LTT_INT_FIXED:
+ case LTT_UINT_FIXED:
+ case LTT_POINTER:
+ case LTT_CHAR:
+ case LTT_UCHAR:
+ case LTT_SHORT:
+ case LTT_USHORT:
+ case LTT_INT:
+ case LTT_UINT:
+ case LTT_LONG:
+ case LTT_ULONG:
+ case LTT_SIZE_T:
+ case LTT_SSIZE_T:
+ case LTT_OFF_T:
+ case LTT_FLOAT:
+ case LTT_ENUM:
+ /* Align offset on type size */
+ return field->field_size;
+ break;
+ case LTT_STRING:
+ return 0;
+ break;
+ case LTT_ARRAY:
+ g_assert(type->fields->len == 1);
+ {
+ LttField *child = &g_array_index(type->fields, LttField, 0);
+ return get_alignment(tf, child);
+ }
+ break;
+ case LTT_SEQUENCE:
+ g_assert(type->fields->len == 2);
+ {
+ off_t localign = 0;
+ LttField *child = &g_array_index(type->fields, LttField, 0);
+
+ localign = max(localign, get_alignment(tf, child));
+
+ child = &g_array_index(type->fields, LttField, 1);
+ localign = max(localign, get_alignment(tf, child));
+
+ return localign;
+ }
+ break;
+ case LTT_STRUCT:
+ case LTT_UNION:
+ {
+ guint i;
+ off_t localign = 0;
+
+ for(i=0; i<type->fields->len; i++) {
+ LttField *child = &g_array_index(type->fields, LttField, i);
+ localign = max(localign, get_alignment(tf, child));
+ }
+ return localign;
+ }
+ break;
+ case LTT_NONE:
+ default:
+ g_error("get_alignment : unknown type");
+ }
+
+}
+
+/*****************************************************************************
+ *Function name
+ * field_compute_static_size : Determine the size of fields known by their
+ * sole definition. Unions, arrays and struct sizes might be known, but
+ * the parser does not give that information.
+ *Input params
+ * tf : tracefile
+ * field : field
+ *
+ ****************************************************************************/
+
+void field_compute_static_size(LttTracefile *tf, LttField *field)
+{
+ LttType *type = &field->field_type;
+
+ switch(type->type_class) {
+ case LTT_INT_FIXED:
+ case LTT_UINT_FIXED:
+ case LTT_POINTER:
+ case LTT_CHAR:
+ case LTT_UCHAR:
+ case LTT_SHORT:
+ case LTT_USHORT:
+ case LTT_INT:
+ case LTT_UINT:
+ case LTT_LONG:
+ case LTT_ULONG:
+ case LTT_SIZE_T:
+ case LTT_SSIZE_T:
+ case LTT_OFF_T:
+ case LTT_FLOAT:
+ case LTT_ENUM:
+ case LTT_STRING:
+ /* nothing to do */
+ break;
+ case LTT_ARRAY:
+ /* note this : array type size is the number of elements in the array,
+ * while array field size of the length of the array in bytes */
+ g_assert(type->fields->len == 1);
+ {
+ LttField *child = &g_array_index(type->fields, LttField, 0);
+ field_compute_static_size(tf, child);
+
+ if(child->field_size != 0) {
+ field->field_size = type->size * child->field_size;
+ field->dynamic_offsets = g_array_sized_new(FALSE, TRUE,
+ sizeof(off_t), type->size);
+ } else {
+ field->field_size = 0;
+ }
+ }
+ break;
+ case LTT_SEQUENCE:
+ g_assert(type->fields->len == 2);
+ {
+ off_t local_offset = 0;
+ LttField *child = &g_array_index(type->fields, LttField, 1);
+ field_compute_static_size(tf, child);
+ field->field_size = 0;
+ type->size = 0;
+ if(child->field_size != 0) {
+ field->dynamic_offsets = g_array_sized_new(FALSE, TRUE,
+ sizeof(off_t), SEQUENCE_AVG_ELEMENTS);
+ }
+ }
+ break;
+ case LTT_STRUCT:
+ case LTT_UNION:
+ {
+ guint i;
+ for(i=0;i<type->fields->len;i++) {
+ LttField *child = &g_array_index(type->fields, LttField, i);
+ field_compute_static_size(tf, child);
+ if(child->field_size != 0) {
+ type->size += ltt_align(type->size, get_alignment(tf, child),
+ tf->has_alignment);
+ type->size += child->field_size;
+ } else {
+ /* As soon as we find a child with variable size, we have
+ * a variable size */
+ type->size = 0;
+ break;
+ }
+ }
+ field->field_size = type->size;
+ }
+ break;
+ default:
+ g_error("field_static_size : unknown type");
+ }
+
+}
+
+
+
+/*****************************************************************************
+ *Function name
+ * precompute_fields_offsets : set the precomputable offset of the fields
+ *Input params
+ * tf : tracefile
+ * field : the field
+ * offset : pointer to the current offset, must be incremented
+ *
+ * return : 1 : found a variable length field, stop the processing.
+ * 0 otherwise.
+ ****************************************************************************/
+
+
+gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset)
+{
+ LttType *type = &field->field_type;
+
+ switch(type->type_class) {
+ case LTT_INT_FIXED:
+ case LTT_UINT_FIXED:
+ case LTT_POINTER:
+ case LTT_CHAR:
+ case LTT_UCHAR:
+ case LTT_SHORT:
+ case LTT_USHORT:
+ case LTT_INT:
+ case LTT_UINT:
+ case LTT_LONG:
+ case LTT_ULONG:
+ case LTT_SIZE_T:
+ case LTT_SSIZE_T:
+ case LTT_OFF_T:
+ case LTT_FLOAT:
+ case LTT_ENUM:
+ /* Align offset on type size */
+ *offset += ltt_align(*offset, get_alignment(tf, field),
+ tf->has_alignment);
+ /* remember offset */
+ field->offset_root = *offset;
+ field->fixed_root = FIELD_FIXED;
+ /* Increment offset */
+ *offset += field->field_size;
+ return 0;
+ break;
+ case LTT_STRING:
+ field->offset_root = *offset;
+ field->fixed_root = FIELD_FIXED;
+ return 1;
+ break;
+ case LTT_ARRAY:
+ g_assert(type->fields->len == 1);
+ {
+ LttField *child = &g_array_index(type->fields, LttField, 0);
+
+ *offset += ltt_align(*offset, get_alignment(tf, field),
+ tf->has_alignment);
+
+ /* remember offset */
+ field->offset_root = *offset;
+ field->array_offset = *offset;
+ field->fixed_root = FIELD_FIXED;
+
+ /* Let the child be variable */
+ //precompute_fields_offsets(tf, child, offset);
+
+ if(field->field_size != 0) {
+ /* Increment offset */
+ /* field_size is the array size in bytes */
+ *offset += field->field_size;
+ return 0;
+ } else {
+ return 1;
+ }
+ }
+ break;
+ case LTT_SEQUENCE:
+ g_assert(type->fields->len == 2);
+ {
+ LttField *child;
+ guint ret;
+
+ *offset += ltt_align(*offset, get_alignment(tf, field),
+ tf->has_alignment);
+
+ /* remember offset */
+ field->offset_root = *offset;
+ field->fixed_root = FIELD_FIXED;
+
+ child = &g_array_index(type->fields, LttField, 0);
+ ret = precompute_fields_offsets(tf, child, offset);
+ g_assert(ret == 0); /* Seq len cannot have variable len */
+
+ child = &g_array_index(type->fields, LttField, 1);
+ *offset += ltt_align(*offset, get_alignment(tf, child),
+ tf->has_alignment);
+ field->array_offset = *offset;
+ /* Set the offset position at position 0 */
+ ret = precompute_fields_offsets(tf, child, offset);
+
+ /* Cannot precompute fields offsets of sequence members, and has
+ * variable length. */
+ return 1;
+ }
+ break;
+ case LTT_STRUCT:
+ {
+ LttField *child;
+ guint i;
+ gint ret=0;
+
+ *offset += ltt_align(*offset, get_alignment(tf, field),
+ tf->has_alignment);
+ /* remember offset */
+ field->offset_root = *offset;
+ field->fixed_root = FIELD_FIXED;
+
+ for(i=0; i< type->fields->len; i++) {
+ child = &g_array_index(type->fields, LttField, i);
+ ret = precompute_fields_offsets(tf, child, offset);
+
+ if(ret) break;
+ }
+ return ret;
+ }
+ break;
+ case LTT_UNION:
+ {
+ LttField *child;
+ guint i;
+ gint ret=0;
+
+ *offset += ltt_align(*offset, get_alignment(tf, field),
+ tf->has_alignment);
+ /* remember offset */
+ field->offset_root = *offset;
+ field->fixed_root = FIELD_FIXED;
+
+ for(i=0; i< type->fields->len; i++) {
+ *offset = field->offset_root;
+ child = &g_array_index(type->fields, LttField, i);
+ ret = precompute_fields_offsets(tf, child, offset);
+
+ if(ret) break;
+ }
+ *offset = field->offset_root + field->field_size;
+ return ret;
+ }
+
+ break;
+ case LTT_NONE:
+ default:
+ g_error("precompute_fields_offsets : unknown type");
+ return 1;
+ }
+
+}
+
+
+/*****************************************************************************
+ *Function name
+ * precompute_offsets : set the precomputable offset of an event type
+ *Input params
+ * tf : tracefile
+ * event : event type
+ *
+ ****************************************************************************/
+void precompute_offsets(LttTracefile *tf, LttEventType *event)
+{
+ guint i;
+ off_t offset = 0;
+ gint ret;
+
+ /* First, compute the size of fixed size fields. Will determine size for
+ * arrays, struct and unions, which is not done by the parser */
+ for(i=0; i<event->fields->len; i++) {
+ LttField *field = &g_array_index(event->fields, LttField, i);
+ field_compute_static_size(tf, field);
+ }
+
+ /* 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(tf, field, &offset);
+ if(ret) break;
+ }
+}
+
+
/*****************************************************************************
* fixed_parent : Do we know a fixed offset to the parent ?
* field : field
****************************************************************************/
+
+
+
+// preset the fixed size offsets. Calculate them just like genevent-new : an
+// increment of a *to value that represents the offset from the start of the
+// event data.
+// The preset information is : offsets up to (and including) the first element
+// of variable size. All subsequent fields must be flagged "VARIABLE OFFSET".
+#if 0
void preset_field_type_size(LttTracefile *tf, LttEventType *event_type,
off_t offset_root, off_t offset_parent,
enum field_status *fixed_root, enum field_status *fixed_parent,
break;
case LTT_LONG:
case LTT_ULONG:
- field->field_size = (off_t)event_type->facility->pointer_size;
+ field->field_size = (off_t)event_type->facility->long_size;
field->fixed_size = FIELD_FIXED;
break;
case LTT_SIZE_T:
field->child[0]);
field->fixed_size = FIELD_VARIABLE;
field->field_size = 0;
+ *fixed_root = FIELD_VARIABLE;
+ *fixed_parent = FIELD_VARIABLE;
break;
case LTT_STRING:
field->fixed_size = FIELD_VARIABLE;
field->field_size = 0;
+ *fixed_root = FIELD_VARIABLE;
+ *fixed_parent = FIELD_VARIABLE;
break;
case LTT_ARRAY:
local_fixed_root = FIELD_VARIABLE;
&local_fixed_root, &local_fixed_parent,
field->child[0]);
field->fixed_size = field->child[0]->fixed_size;
- if(field->fixed_size == FIELD_FIXED)
+ if(field->fixed_size == FIELD_FIXED) {
field->field_size = type->element_number * field->child[0]->field_size;
- else
+ } else {
field->field_size = 0;
+ *fixed_root = FIELD_VARIABLE;
+ *fixed_parent = FIELD_VARIABLE;
+ }
break;
case LTT_STRUCT:
current_root_offset = field->offset_root;
max_size = max(max_size, field->child[i]->field_size);
}
if(final_child_status != FIELD_FIXED) {
+ g_error("LTTV does not support variable size fields in unions.");
+ /* This will stop the application. */
*fixed_root = final_child_status;
*fixed_parent = final_child_status;
field->field_size = 0;
}
}
-
+#endif //0
/*****************************************************************************
*Function name
*Returns : 0 if identical
* 1 if not.
****************************************************************************/
+// this function checks for equality of field types. Therefore, it does not use
+// per se offsets. For instance, an aligned version of a structure is
+// compatible with an unaligned version of the same structure.
+gint check_fields_compatibility(LttEventType *event_type1,
+ LttEventType *event_type2,
+ LttField *field1, LttField *field2)
+{
+ guint different = 0;
+ LttType *type1;
+ LttType *type2;
+
+ if(field1 == NULL) {
+ if(field2 == NULL) goto end;
+ else {
+ different = 1;
+ goto end;
+ }
+ } else if(field2 == NULL) {
+ different = 1;
+ goto end;
+ }
+
+ type1 = &field1->field_type;
+ type2 = &field2->field_type;
+
+ if(type1->type_class != type2->type_class) {
+ different = 1;
+ goto end;
+ }
+
+ switch(type1->type_class) {
+ case LTT_INT_FIXED:
+ case LTT_UINT_FIXED:
+ case LTT_POINTER:
+ case LTT_CHAR:
+ case LTT_UCHAR:
+ case LTT_SHORT:
+ case LTT_USHORT:
+ case LTT_INT:
+ case LTT_UINT:
+ case LTT_LONG:
+ case LTT_ULONG:
+ case LTT_SIZE_T:
+ case LTT_SSIZE_T:
+ case LTT_OFF_T:
+ case LTT_FLOAT:
+ case LTT_ENUM:
+ if(field1->field_size != field2->field_size)
+ different = 1;
+ break;
+ case LTT_STRING:
+ break;
+ case LTT_ARRAY:
+ {
+ LttField *child1 = &g_array_index(type1->fields, LttField, 0);
+ LttField *child2 = &g_array_index(type2->fields, LttField, 0);
+
+ if(type1->size != type2->size)
+ different = 1;
+ if(check_fields_compatibility(event_type1, event_type2, child1, child2))
+ different = 1;
+ }
+ break;
+ case LTT_SEQUENCE:
+ {
+ LttField *child1 = &g_array_index(type1->fields, LttField, 1);
+ LttField *child2 = &g_array_index(type2->fields, LttField, 1);
+
+ if(check_fields_compatibility(event_type1, event_type2, child1, child2))
+ different = 1;
+ }
+ break;
+ case LTT_STRUCT:
+ case LTT_UNION:
+ {
+ LttField *child;
+ guint i;
+
+ if(type1->fields->len != type2->fields->len) {
+ different = 1;
+ goto end;
+ }
+
+ for(i=0; i< type1->fields->len; i++) {
+ LttField *child1;
+ LttField *child2;
+ child1 = &g_array_index(type1->fields, LttField, i);
+ child2 = &g_array_index(type2->fields, LttField, i);
+ different = check_fields_compatibility(event_type1,
+ event_type2, child1, child2);
+
+ if(different) break;
+ }
+ }
+ break;
+ case LTT_NONE:
+ default:
+ g_error("precompute_fields_offsets : unknown type");
+ }
+
+end:
+ return different;
+}
+
+
+#if 0
gint check_fields_compatibility(LttEventType *event_type1,
LttEventType *event_type2,
LttField *field1, LttField *field2)
{
guint different = 0;
- enum field_status local_fixed_root, local_fixed_parent;
guint i;
LttType *type1;
LttType *type2;
type1 = field1->field_type;
type2 = field2->field_type;
- size_t current_root_offset;
- size_t current_offset;
- enum field_status current_child_status, final_child_status;
- size_t max_size;
-
if(type1->type_class != type2->type_class) {
different = 1;
goto end;
end:
return different;
}
-
-
-
-
-#if 0
-/*****************************************************************************
- *Function name
- * getFieldtypeSize: get the size of the field type (primitive type)
- *Input params
- * evT : event type
- * offsetRoot : offset from the root
- * offsetParent : offset from the parrent
- * fld : field
- * evD : event data, it may be NULL
- *Return value
- * int : size of the field
- ****************************************************************************/
-
-static inline gint getFieldtypeSize(LttTracefile *tf,
- LttEventType * evT, gint offsetRoot,
- gint offsetParent, LttField * fld, void *evD)
-{
- gint size, size1, element_number, i, offset1, offset2;
- LttType * type = fld->field_type;
-
- /* This likely has been tested with gcov : half of them.. */
- if(unlikely(fld->field_fixed == 1)){
- /* tested : none */
- if(unlikely(fld == evT->root_field)) {
- size = fld->field_size;
- goto end_getFieldtypeSize;
- }
- }
-
- /* From gcov profiling : half string, half struct, can we gain something
- * from that ? (Mathieu) */
- switch(type->type_class) {
- case LTT_ARRAY:
- element_number = (int) type->element_number;
- if(fld->field_fixed == -1){
- size = getFieldtypeSize(tf, evT, offsetRoot,
- 0,fld->child[0], NULL);
- if(size == 0){ //has string or sequence
- fld->field_fixed = 0;
- }else{
- fld->field_fixed = 1;
- size *= element_number;
- }
- }else if(fld->field_fixed == 0){// has string or sequence
- size = 0;
- for(i=0;i<element_number;i++){
- size += getFieldtypeSize(tf, evT, offsetRoot+size,size,
- fld->child[0], evD+size);
- }
- }else size = fld->field_size;
- if(unlikely(!evD)){
- fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
- fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
- }
-
- break;
-
- case LTT_SEQUENCE:
- size1 = (int) ltt_type_size(fac, type);
- if(fld->field_fixed == -1){
- fld->sequ_number_size = size1;
- fld->field_fixed = 0;
- size = getFieldtypeSize(evT, offsetRoot,
- 0,fld->child[0], NULL);
- fld->element_size = size;
- }else{//0: sequence
- element_number = getIntNumber(tf,size1,evD);
- type->element_number = element_number;
- if(fld->element_size > 0){
- size = element_number * fld->element_size;
- }else{//sequence has string or sequence
- size = 0;
- for(i=0;i<element_number;i++){
- size += getFieldtypeSize(tf, evT,
- offsetRoot+size+size1,size+size1,
- fld->child[0], evD+size+size1);
- }
- }
- size += size1;
- }
- if(unlikely(!evD)){
- fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
- fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
- }
-
- break;
-
- case LTT_STRING:
- size = 0;
- if(fld->field_fixed == -1){
- fld->field_fixed = 0;
- }else{//0: string
- /* Hope my implementation is faster than strlen (Mathieu) */
- char *ptr=(char*)evD;
- size = 1;
- /* from gcov : many many strings are empty, make it the common case.*/
- while(unlikely(*ptr != '\0')) { size++; ptr++; }
- //size = ptr - (char*)evD + 1; //include end : '\0'
- }
- fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
- fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
-
- break;
-
- case LTT_STRUCT:
- element_number = (int) type->element_number;
- size = 0;
- /* tested with gcov */
- if(unlikely(fld->field_fixed == -1)){
- offset1 = offsetRoot;
- offset2 = 0;
- for(i=0;i<element_number;i++){
- size1=getFieldtypeSize(tf, evT,offset1,offset2,
- fld->child[i], NULL);
- if(likely(size1 > 0 && size >= 0)){
- size += size1;
- if(likely(offset1 >= 0)) offset1 += size1;
- offset2 += size1;
- }else{
- size = -1;
- offset1 = -1;
- offset2 = -1;
- }
- }
- if(unlikely(size == -1)){
- fld->field_fixed = 0;
- size = 0;
- }else fld->field_fixed = 1;
- }else if(likely(fld->field_fixed == 0)){
- offset1 = offsetRoot;
- offset2 = 0;
- for(i=0;unlikely(i<element_number);i++){
- size=getFieldtypeSize(tf, evT, offset1, offset2,
- fld->child[i], evD+offset2);
- offset1 += size;
- offset2 += size;
- }
- size = offset2;
- }else size = fld->field_size;
- fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
- fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
- break;
-
- default:
- if(unlikely(fld->field_fixed == -1)){
- size = (int) ltt_type_size(LTT_GET_BO(tf), type);
- fld->field_fixed = 1;
- }else size = fld->field_size;
- if(unlikely(!evD)){
- fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
- fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
- }
- break;
- }
-
- fld->offset_root = offsetRoot;
- fld->offset_parent = offsetParent;
- fld->field_size = size;
-
-end_getFieldtypeSize:
-
- return size;
-}
#endif //0
+
/*****************************************************************************
*Function name
* ltt_get_int : get an integer number
}
-/* get the start time of the trace */
-
-LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s)
+/* get the NTP corrected start time of the trace */
+LttTime ltt_trace_start_time(LttTrace *t)
{
- return s->trace_start;
+ return t->start_time;
}
+/* get the monotonic start time of the trace */
+LttTime ltt_trace_start_time_monotonic(LttTrace *t)
+{
+ return t->start_time_from_tsc;
+}
LttTracefile *ltt_tracefile_new()
{