#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);
{
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->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;
- munmap(tf->buffer.head, sizeof(struct ltt_block_start_header));
+ 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;
}
{
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)
+GData **ltt_trace_get_tracefiles_groups(LttTrace *trace)
{
- return trace->tracefiles;
+ return &trace->tracefiles;
}
-void compute_tracefile_group(GArray *group,
- struct compute_tracefile_group_args args)
+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);
+ args->func(tf, args->func_args);
}
}
* 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;
+
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");
LttTracefile *tf;
guint len;
- if(get_tracefile_name_number(path, &name, &num))
+ if(get_tracefile_name_number(rel_path, &name, &num))
continue; /* invalid name */
-
- group = g_datalist_id_get_data(&tracefiles, name);
+
+ g_debug("Tracefile name is %s and number is %u",
+ g_quark_to_string(name), num);
+
+ 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 */
g_array_set_size(group, old_len);
if(!ltt_tracefile_group_has_cpu_online(group))
- g_datalist_id_remove_data(&tracefiles, name);
+ g_datalist_id_remove_data(&trace->tracefiles, name);
continue; /* error opening the tracefile : bad magic number ? */
}
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);
* 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);
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 = 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_state_dump_load_data->pointer_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->alignment);
if(ltt_get_facility_description(fac, tf->trace, tf))
goto facility_error;
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;
//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),
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
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;
LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
tf->event.facility_id);
- if(unlikely(f == NULL)) {
- 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);
- break;
- case LTT_EVENT_FACILITY_UNLOAD:
- size = sizeof(struct LttFacilityUnload);
- break;
- case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
- size = sizeof(struct LttStateDumpFacilityLoad);
- break;
- case LTT_EVENT_HEARTBEAT:
- size = sizeof(TimeHeartbeat);
- break;
- default:
- g_warning("Error in getting event size : tracefile %s, "
- "unknown event id %hhu in core facility.",
- g_quark_to_string(tf->name),
- tf->event.event_id);
- goto event_id_error;
+ 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) + 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) + 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_warning("Error in getting event size : tracefile %s, "
+ "unknown event id %hhu in core facility.",
+ g_quark_to_string(tf->name),
+ tf->event.event_id);
+ goto event_id_error;
- }
}
} else {
+ 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);
+
+ 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;
+ }
+
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);
}
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:
tf->event.data_size = 0;
}
/* 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);
+
+ if(tf->event.offset == tf->block_size - tf->buffer.lost_size) {
+ ret = ERANGE;
+ }
goto found;
}
- if(tf->event.offset == tf->buffer.lost_size) {
+ if(tf->event.offset == tf->block_size - tf->buffer.lost_size) {
ret = ERANGE;
goto found;
}
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