#define g_close close
+/* 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)
+
/* obtain the time of an event */
static inline LttTime getEventTime(LttTracefile * tf);
/* 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);
-size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data);
+//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. */
enum field_status *fixed_root, enum field_status *fixed_parent,
LttField *field);
-
-static inline size_t get_field_type_size(LttTracefile *tf,
- LttEventType *event_type,
- off_t offset_root, off_t offset_parent,
- LttField *field, void *data);
-
-
/* map a fixed size or a block information from the file (fd) */
static gint map_block(LttTracefile * tf, guint block_num);
/* go to the next event */
static int ltt_seek_next_event(LttTracefile *tf);
+void ltt_update_event_size(LttTracefile *tf);
+
#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
-static inline LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
+LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
guint num)
{
g_assert(num < t->facilities_by_num->len);
{
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 = g_open(fileName, O_RDONLY, 0);
+ tf->fd = open(fileName, O_RDONLY);
if(tf->fd < 0){
g_warning("Unable to open input data file %s\n", fileName);
goto end;
/* 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)), PROT_READ,
MAP_PRIVATE, tf->fd, 0);
- if(tf->buffer.head == NULL) {
+ if(tf->buffer.head == MAP_FAILED) {
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( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
header = (struct ltt_block_start_header*)tf->buffer.head;
//store the size of the file
tf->file_size = lTDFStat.st_size;
- tf->block_size = header->buf_size;
+ tf->block_size = ltt_get_uint32(LTT_GET_BO(tf), &header->buf_size);
tf->num_blocks = tf->file_size / tf->block_size;
- vfree(tf->buffer.head);
+ munmap(tf->buffer.head, PAGE_ALIGN(sizeof(struct ltt_block_start_header)));
tf->buffer.head = NULL;
//read the first block
/* Error */
unmap_file:
- munmap(tf->buffer.head, sizeof(struct ltt_block_start_header));
+ munmap(tf->buffer.head, PAGE_ALIGN(sizeof(struct ltt_block_start_header)));
close_file:
- g_close(tf->fd);
+ close(tf->fd);
end:
return -1;
}
+LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
+{
+ return tf->trace;
+}
+
#if 0
/*****************************************************************************
*Open control and per cpu tracefiles
{
if(t->buffer.head != NULL)
munmap(t->buffer.head, t->buf_size);
- g_close(t->fd);
+ close(t->fd);
}
}
+GData **ltt_trace_get_tracefiles_groups(LttTrace *trace)
+{
+ return &trace->tracefiles;
+}
+
+
+void compute_tracefile_group(GQuark key_id,
+ GArray *group,
+ struct compute_tracefile_group_args *args)
+{
+ int i;
+ LttTracefile *tf;
+
+ for(i=0; i<group->len; i++) {
+ tf = &g_array_index (group, LttTracefile, i);
+ if(tf->cpu_online)
+ args->func(tf, args->func_args);
+ }
+}
+
+
void ltt_tracefile_group_destroy(gpointer data)
{
GArray *group = (GArray *)data;
* GData : permits to access them using their tracefile group pathname.
* i.e. access control/modules tracefile group by index :
* "control/module".
+ *
+ * relative path is the path relative to the trace root
+ * root path is the full path
*
* A tracefile group is simply an array where all the per cpu tracefiles sits.
*/
-static int open_tracefiles(LttTrace *trace, char *root_path, GData *tracefiles)
+static int open_tracefiles(LttTrace *trace, char *root_path,
+ char *relative_path)
{
DIR *dir = opendir(root_path);
struct dirent *entry;
struct stat stat_buf;
int ret;
+
char path[PATH_MAX];
int path_len;
char *path_ptr;
+ int rel_path_len;
+ char rel_path[PATH_MAX];
+ char *rel_path_ptr;
+ LttTracefile tmp_tf;
+
if(dir == NULL) {
perror(root_path);
return ENOENT;
path_len++;
path_ptr = path + path_len;
+ strncpy(rel_path, relative_path, PATH_MAX-1);
+ rel_path_len = strlen(rel_path);
+ rel_path[rel_path_len] = '/';
+ rel_path_len++;
+ rel_path_ptr = rel_path + rel_path_len;
+
while((entry = readdir(dir)) != NULL) {
if(entry->d_name[0] == '.') continue;
strncpy(path_ptr, entry->d_name, PATH_MAX - path_len);
+ strncpy(rel_path_ptr, entry->d_name, PATH_MAX - rel_path_len);
ret = stat(path, &stat_buf);
if(ret == -1) {
if(S_ISDIR(stat_buf.st_mode)) {
g_debug("Entering subdirectory...\n");
- ret = open_tracefiles(trace, path, tracefiles);
+ 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(path, &name, &num))
+ 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(&tracefiles, name);
+ group = g_datalist_id_get_data(&trace->tracefiles, name);
if(group == NULL) {
/* Elements are automatically cleared when the array is allocated.
* It makes the cpu_online variable set to 0 : cpu offline, by default.
*/
group = g_array_sized_new (FALSE, TRUE, sizeof(LttTracefile), 10);
- g_datalist_id_set_data_full(&tracefiles, name,
+ 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);
+ g_array_index (group, LttTracefile, num) = tmp_tf;
- if(!ltt_tracefile_group_has_cpu_online(group))
- g_datalist_id_remove_data(&tracefiles, name);
-
- continue; /* error opening the tracefile : bad magic number ? */
- }
- tf->cpu_online = 1;
- tf->cpu_num = num;
}
}
const gchar *text;
guint textlen;
gint err;
- int i, j;
- LttEventType *et;
text = g_quark_to_string(t->pathname);
textlen = strlen(text);
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);
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);
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->size_t_size = ltt_get_uin32(LTT_GET_BO(tf),
+ 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);
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);
+ set_fields_offsets(tf, et);
+ }
+
fac->exists = 1;
- fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name, fac->name);
+ fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
+ fac->name);
if(fac_ids == NULL) {
fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1);
g_datalist_id_set_data_full(&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));
+ ltt_get_uint32(LTT_GET_BO(tf), &fac_state_dump_load_data->id));
g_assert(fac->exists == 0);
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_uint8(LTT_GET_BO(tf), &fac_load_data->id);
+ &fac_state_dump_load_data->checksum);
+ fac->id = fac_state_dump_load_data->id;
fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
- &fac_load_data->pointer_size);
- fac->size_t_size = ltt_get_uin32(LTT_GET_BO(tf),
- &fac_load_data->size_t_size);
+ &fac_state_dump_load_data->pointer_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_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->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);
+ set_fields_offsets(tf, et);
+ }
+
fac->exists = 1;
fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
fac_id_error:
update_error:
seek_error:
+ g_warning("An error occured in facility tracefile parsing");
return err;
}
LttTracefile *tf;
GArray *group;
int i;
+ struct ltt_block_start_header *header;
t = g_new(LttTrace, 1);
if(!t) goto alloc_error;
/* Open all the tracefiles */
g_datalist_init(&t->tracefiles);
- if(open_tracefiles(t, abs_path, t->tracefiles))
+ if(open_tracefiles(t, abs_path, ""))
goto open_error;
/* Prepare the facilities containers : array and mapping */
group = g_datalist_id_get_data(&t->tracefiles, LTT_TRACEFILE_NAME_FACILITIES);
if(group == NULL) {
g_error("Trace %s has no facility tracefile", abs_path);
+ g_assert(0);
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;
+ t->arch_type = ltt_get_uint32(LTT_GET_BO(tf), &header->trace.arch_type);
+ t->arch_variant = ltt_get_uint32(LTT_GET_BO(tf), &header->trace.arch_variant);
+ t->arch_size = header->trace.arch_size;
+ t->ltt_major_version = header->trace.major_version;
+ t->ltt_minor_version = header->trace.minor_version;
+ t->flight_recorder = header->trace.flight_recorder;
+ t->has_heartbeat = header->trace.has_heartbeat;
+ t->has_alignment = header->trace.has_alignment;
+ t->has_tsc = header->trace.has_tsc;
+
+
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;
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);
return tf->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->buffer.begin.timestamp) < 0) {
+ } else if(ltt_time_compare(time, tf->buffer.begin.timestamp) < 0) {
/* go to lower part */
high = block_num;
} else if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
} 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)
found:
return 0;
+range:
+ return ERANGE;
/* Error handling */
fail:
return time;
}
+
+/* Get the current event of the tracefile : valid until the next read */
+LttEvent *ltt_tracefile_get_event(LttTracefile *tf)
+{
+ return &tf->event;
+}
+
+
+
/*****************************************************************************
*Function name
* ltt_tracefile_read : Read the next event in the tracefile
LttEvent *event;
event = &tf->event;
- pos = event->offset;
+ pos = tf->buffer.head + event->offset;
/* Read event header */
//TODO align
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),
pos += sizeof(guint32);
}
- event->facility_id = ltt_get_uint8(LTT_GET_BO(tf),
- pos);
+ event->facility_id = *(guint8*)pos;
pos += sizeof(guint8);
- event->event_id = ltt_get_uint8(LTT_GET_BO(tf),
- pos);
+ event->event_id = *(guint8*)pos;
pos += sizeof(guint8);
+ event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos);
+ pos += sizeof(guint16);
+
event->data = pos;
+ /* get the data size and update the event fields with the current
+ * information */
+ ltt_update_event_size(tf);
+
return 0;
}
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);
+ munmap(tf->buffer.head, PAGE_ALIGN(tf->buf_size));
/* Multiple of pages aligned head */
- tf->buffer.head = mmap(0, tf->block_size, PROT_READ, tf->fd, MAP_PRIVATE,
- (off_t)tf->block_size * (off_t)block_num);
+ tf->buffer.head = mmap(0,
+ PAGE_ALIGN(tf->block_size),
+ PROT_READ, MAP_PRIVATE, tf->fd,
+ PAGE_ALIGN((off_t)tf->block_size * (off_t)block_num));
- if(tf->buffer.head == NULL) {
+ if(tf->buffer.head == MAP_FAILED) {
perror("Error in allocating memory for buffer of tracefile");
+ g_assert(0);
goto map_error;
}
- g_assert(((guint)tf->buffer.head) & (8-1) == 0); // make sure it's aligned.
+ g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
tf->buffer.index = block_num;
* it means that the event read must get the first event. */
tf->event.tracefile = tf;
tf->event.block = block_num;
- tf->event.offset = tf->buffer.head;
+ tf->event.offset = 0;
return 0;
}
-ssize_t ltt_get_event_size(LttTracefile *tf)
+/* It will update the fields offsets too */
+void ltt_update_event_size(LttTracefile *tf)
{
ssize_t size = 0;
/* Specific handling of core events : necessary to read the facility control
* tracefile. */
- if(unlikely(tf->event.facility_id == LTT_FACILITY_CORE)) {
+ LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
+ tf->event.facility_id);
+
+ if(likely(tf->event.facility_id == LTT_FACILITY_CORE)) {
switch((enum ltt_core_events)tf->event.event_id) {
case LTT_EVENT_FACILITY_LOAD:
- size = sizeof(struct LttFacilityLoad);
+ 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 = sizeof(struct LttStateDumpFacilityLoad);
+ 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:
goto event_id_error;
}
-
} else {
- LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
- tf->event.facility_id);
+ if(!f->exists) {
+ g_error("Unknown facility %hhu (0x%hhx) in tracefile %s",
+ tf->event.facility_id,
+ tf->event.facility_id,
+ g_quark_to_string(tf->name));
+ goto facility_error;
+ }
+
LttEventType *event_type =
ltt_facility_eventtype_get(f, tf->event.event_id);
- size = get_fields_offsets(tf, event_type, tf->event.data);
- }
- return size;
+ if(!event_type) {
+ g_error("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;
+ }
+
+ if(event_type->root_field)
+ size = get_field_type_size(tf, event_type,
+ 0, 0, event_type->root_field, tf->event.data);
+ else
+ size = 0;
+
+ g_debug("Event root field : f.e %hhu.%hhu size %lu", 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:
+event_type_error:
event_id_error:
- return -1;
+ tf->event.data_size = 0;
}
ssize_t event_size;
/* seek over the buffer header if we are at the buffer start */
- if(tf->event.offset == tf->buffer.head) {
+ if(tf->event.offset == 0) {
tf->event.offset += sizeof(struct ltt_block_start_header);
- goto found;
- }
-
- if(tf->event.offset == tf->buffer.head + tf->buffer.lost_size) {
- ret = ERANGE;
+ if(tf->event.offset == tf->block_size - tf->buffer.lost_size) {
+ ret = ERANGE;
+ }
goto found;
}
+
pos = tf->event.data;
- event_size = ltt_get_event_size(tf);
- if(event_size < 0) goto error;
+ if(tf->event.data_size < 0) goto error;
- pos += (size_t)event_size;
+ pos += (size_t)tf->event.data_size;
+
+ tf->event.offset = pos - tf->buffer.head;
- tf->event.offset = pos;
+ if(tf->event.offset == tf->block_size - tf->buffer.lost_size) {
+ ret = ERANGE;
+ goto found;
+ }
found:
return ret;
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;
/*****************************************************************************
*Function name
- * get_field_type_size : set the fixed and dynamic sizes of the field type
- * from the data read.
+ * check_fields_compatibility : Check for compatibility between two fields :
+ * do they use the same inner structure ?
*Input params
- * tf : tracefile
- * event_type : event type
- * offset_root : offset from the root
- * offset_parent : offset from the parent
- * field : field
- * data : a pointer to the event data.
- *Returns the field type size.
+ * event_type1 : event type
+ * event_type2 : event type
+ * field1 : field
+ * field2 : field
+ *Returns : 0 if identical
+ * 1 if not.
****************************************************************************/
-size_t get_field_type_size(LttTracefile *tf, LttEventType *event_type,
- off_t offset_root, off_t offset_parent,
- LttField *field, void *data)
+gint check_fields_compatibility(LttEventType *event_type1,
+ LttEventType *event_type2,
+ LttField *field1, LttField *field2)
{
- size_t size = 0;
+ guint different = 0;
+ enum field_status local_fixed_root, local_fixed_parent;
guint i;
- LttType *type;
+ LttType *type1;
+ LttType *type2;
- g_assert(field->fixed_root != FIELD_UNKNOWN);
- g_assert(field->fixed_parent != FIELD_UNKNOWN);
- g_assert(field->fixed_size != FIELD_UNKNOWN);
-
- field->offset_root = offset_root;
- field->offset_parent = offset_parent;
+ if(field1 == NULL) {
+ if(field2 == NULL) goto end;
+ else {
+ different = 1;
+ goto end;
+ }
+ } else if(field2 == NULL) {
+ different = 1;
+ goto end;
+ }
- type = field->field_type;
+ g_assert(field1->fixed_root != FIELD_UNKNOWN);
+ g_assert(field2->fixed_root != FIELD_UNKNOWN);
+ g_assert(field1->fixed_parent != FIELD_UNKNOWN);
+ g_assert(field2->fixed_parent != FIELD_UNKNOWN);
+ g_assert(field1->fixed_size != FIELD_UNKNOWN);
+ g_assert(field2->fixed_size != FIELD_UNKNOWN);
- switch(type->type_class) {
+ 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;
+ }
+ if(type1->element_name != type2->element_name) {
+ different = 1;
+ goto end;
+ }
+
+ switch(type1->type_class) {
case LTT_INT:
case LTT_UINT:
case LTT_FLOAT:
- case LTT_ENUM:
case LTT_POINTER:
case LTT_LONG:
case LTT_ULONG:
case LTT_SIZE_T:
case LTT_SSIZE_T:
case LTT_OFF_T:
- g_assert(field->fixed_size == FIELD_FIXED);
- size = field->field_size;
+ if(field1->field_size != field2->field_size) {
+ different = 1;
+ goto end;
+ }
+ break;
+ case LTT_ENUM:
+ if(type1->element_number != type2->element_number) {
+ different = 1;
+ goto end;
+ }
+ for(i=0;i<type1->element_number;i++) {
+ if(type1->enum_strings[i] != type2->enum_strings[i]) {
+ different = 1;
+ goto end;
+ }
+ }
break;
case LTT_SEQUENCE:
- {
- gint seqnum = ltt_get_uint(LTT_GET_BO(tf),
- field->sequ_number_size,
- data + offset_root);
-
- if(field->child[0]->fixed_size == FIELD_FIXED) {
- size = field->sequ_number_size +
- (seqnum * get_field_type_size(tf, event_type,
- offset_root, offset_parent,
- field->child[0], data));
- } else {
- size += field->sequ_number_size;
- for(i=0;i<seqnum;i++) {
- size_t child_size;
- child_size = get_field_type_size(tf, event_type,
- offset_root, offset_parent,
- field->child[0], data);
- offset_root += child_size;
- offset_parent += child_size;
- size += child_size;
- }
+ /* Two elements : size and child */
+ g_assert(type1->element_number != type2->element_number);
+ for(i=0;i<type1->element_number;i++) {
+ if(check_fields_compatibility(event_type1, event_type2,
+ field1->child[0], field2->child[0])) {
+ different = 1;
+ goto end;
}
- field->field_size = size;
}
break;
case LTT_STRING:
- size = strlen((char*)(data+offset_root)) + 1;// length + \0
- field->field_size = size;
break;
case LTT_ARRAY:
- if(field->fixed_size == FIELD_FIXED)
- size = field->field_size;
- else {
- for(i=0;i<field->field_type->element_number;i++) {
- size_t child_size;
- child_size = get_field_type_size(tf, event_type,
- offset_root, offset_parent,
- field->child[0], data);
- offset_root += child_size;
- offset_parent += child_size;
- size += child_size;
- }
- field->field_size = size;
+ if(field1->field_size != field2->field_size) {
+ different = 1;
+ goto end;
}
- break;
- case LTT_STRUCT:
- if(field->fixed_size == FIELD_FIXED)
- size = field->field_size;
- else {
- size_t current_root_offset = offset_root;
- size_t current_offset = 0;
- size_t child_size = 0;
- for(i=0;i<type->element_number;i++) {
- child_size = get_field_type_size(tf,
- event_type, current_root_offset, current_offset,
- field->child[i], data);
- current_offset += child_size;
- current_root_offset += child_size;
-
+ /* Two elements : size and child */
+ g_assert(type1->element_number != type2->element_number);
+ for(i=0;i<type1->element_number;i++) {
+ if(check_fields_compatibility(event_type1, event_type2,
+ field1->child[0], field2->child[0])) {
+ different = 1;
+ goto end;
}
- size = current_offset;
- field->field_size = size;
}
break;
+ case LTT_STRUCT:
case LTT_UNION:
- if(field->fixed_size == FIELD_FIXED)
- size = field->field_size;
- else {
- size_t current_root_offset = field->offset_root;
- size_t current_offset = 0;
- for(i=0;i<type->element_number;i++) {
- size = get_field_type_size(tf, event_type,
- current_root_offset, current_offset,
- field->child[i], data);
- size = max(size, field->child[i]->field_size);
+ if(type1->element_number != type2->element_number) {
+ different = 1;
+ break;
+ }
+ for(i=0;i<type1->element_number;i++) {
+ if(check_fields_compatibility(event_type1, event_type2,
+ field1->child[0], field2->child[0])) {
+ different = 1;
+ goto end;
}
- field->field_size = size;
}
break;
}
-
- return size;
+end:
+ return different;
}
+
#if 0
/*****************************************************************************
*Function name
/*****************************************************************************
*Function name
- * get_int : get an integer number
+ * ltt_get_int : get an integer number
*Input params
* reverse_byte_order: must we reverse the byte order ?
* size : the size of the integer
* gint64 : a 64 bits integer
****************************************************************************/
-gint64 get_int(gboolean reverse_byte_order, gint size, void *data)
+gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data)
{
gint64 val;
/*****************************************************************************
*Function name
- * get_uint : get an unsigned integer number
+ * ltt_get_uint : get an unsigned integer number
*Input params
* reverse_byte_order: must we reverse the byte order ?
* size : the size of the integer
* guint64 : a 64 bits unsigned integer
****************************************************************************/
-guint64 get_uint(gboolean reverse_byte_order, gint size, void *data)
+guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data)
{
guint64 val;
LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
- LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("control/facilities");
+ LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("/control/facilities");
}
projects / lttv.git / blobdiff