X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=2bb0162969c042bf562f4f54e7622ca9eaabf827;hb=9c731a505cf0d0ded02f8e90a823fa90084c7740;hp=a2cf1822f850b55213eda1f178613e0120466163;hpb=62e4e7bff5bceb4b07145fc667dc93225618a918;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index a2cf1822..2bb01629 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -41,15 +41,13 @@ #include -#include "parser.h" #include #include "ltt-private.h" #include -#include #include -#include +//#include #include - +#include /* Facility names used in this file */ @@ -78,6 +76,8 @@ GQuark LTT_TRACEFILE_NAME_FACILITIES; #define PAGE_MASK (~(page_size-1)) #define PAGE_ALIGN(addr) (((addr)+page_size-1)&PAGE_MASK) +LttTrace *father_trace = NULL; + /* set the offset of the fields belonging to the event, need the information of the archecture */ //void set_fields_offsets(LttTracefile *tf, LttEventType *event_type); @@ -105,10 +105,28 @@ static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles); /* go to the next event */ static int ltt_seek_next_event(LttTracefile *tf); -void ltt_update_event_size(LttTracefile *tf); +//void ltt_update_event_size(LttTracefile *tf); +static int open_tracefiles(LttTrace *trace, gchar *root_path, + gchar *relative_path); +static int ltt_process_facility_tracefile(LttTracefile *tf); +static void ltt_tracefile_time_span_get(LttTracefile *tf, + LttTime *start, LttTime *end); +static void group_time_span_get(GQuark name, gpointer data, gpointer user_data); +static gint map_block(LttTracefile * tf, guint block_num); +static int ltt_seek_next_event(LttTracefile *tf); +static void __attribute__((constructor)) init(void); +static void ltt_update_event_size(LttTracefile *tf); -void precompute_offsets(LttFacility *fac, LttEventType *event); +/* Enable event debugging */ +static int a_event_debug = 0; + +void ltt_event_debug(int state) +{ + a_event_debug = state; +} + +//void precompute_offsets(LttFacility *fac, LttEventType *event); #if 0 /* Functions to parse system.xml file (using glib xml parser) */ @@ -187,7 +205,7 @@ static void parser_characters (GMarkupParseContext __UNUSED__ *context, } #endif //0 - +#if 0 LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, guint num) { @@ -196,6 +214,7 @@ LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, return &g_array_index(t->facilities_by_num, LttFacility, num); } +#endif //0 guint ltt_trace_get_num_cpu(LttTrace *t) { @@ -222,7 +241,7 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) /* Get float byte order : might be different from int byte order * (or is set to 0 if the trace has no float (kernel trace)) */ tf->float_word_order = any->float_word_order; - tf->has_alignment = any->has_alignment; + tf->alignment = any->alignment; tf->has_heartbeat = any->has_heartbeat; if(t) { @@ -234,69 +253,29 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) t->ltt_major_version = any->major_version; t->ltt_minor_version = any->minor_version; t->flight_recorder = any->flight_recorder; - t->compact_facilities = NULL; + // t->compact_facilities = NULL; } - switch(any->major_version) { case 0: + g_warning("Unsupported trace version : %hhu.%hhu", + any->major_version, any->minor_version); + return 1; + break; + case 1: 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 7: + case 0: { - struct ltt_trace_header_0_7 *vheader = - (struct ltt_trace_header_0_7 *)header; + struct ltt_trace_header_1_0 *vheader = + (struct ltt_trace_header_1_0 *)header; tf->buffer_header_size = sizeof(struct ltt_block_start_header) - + sizeof(struct ltt_trace_header_0_7); - tf->tsc_lsb_truncate = 0; - tf->tscbits = 32; - tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits; - tf->tsc_mask = (1ULL<<32)-1; - tf->tsc_mask_next_bit = (1ULL<<32); - if(t) { - t->start_freq = ltt_get_uint64(LTT_GET_BO(tf), - &vheader->start_freq); - t->freq_scale = ltt_get_uint32(LTT_GET_BO(tf), - &vheader->freq_scale); - 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.tv_sec = ltt_get_uint64(LTT_GET_BO(tf), - &vheader->start_time_sec); - t->start_time.tv_nsec = ltt_get_uint64(LTT_GET_BO(tf), - &vheader->start_time_usec); - t->start_time.tv_nsec *= 1000; /* microsec to nanosec */ - - t->start_time_from_tsc = ltt_time_from_uint64( - (double)t->start_tsc - * (1000000000.0 / tf->trace->freq_scale) - / (double)t->start_freq); - t->compact_event_bits = 0; - } - } - break; - case 8: - { - struct ltt_trace_header_0_8 *vheader = - (struct ltt_trace_header_0_8 *)header; - tf->buffer_header_size = - sizeof(struct ltt_block_start_header) - + sizeof(struct ltt_trace_header_0_8); + + sizeof(struct ltt_trace_header_1_0); tf->tsc_lsb_truncate = vheader->tsc_lsb_truncate; tf->tscbits = vheader->tscbits; tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits; + tf->compact_event_bits = 32 - vheader->compact_data_shift; tf->tsc_mask = ((1ULL << (tf->tscbits))-1); tf->tsc_mask = tf->tsc_mask << tf->tsc_lsb_truncate; tf->tsc_mask_next_bit = (1ULL<<(tf->tscbits)); @@ -306,6 +285,13 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) &vheader->start_freq); t->freq_scale = ltt_get_uint32(LTT_GET_BO(tf), &vheader->freq_scale); + if(father_trace) { + t->start_freq = father_trace->start_freq; + t->freq_scale = father_trace->freq_scale; + } + else { + father_trace = t; + } t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf), &vheader->start_tsc); t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf), @@ -320,17 +306,15 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) (double)t->start_tsc * (1000000000.0 / tf->trace->freq_scale) / (double)t->start_freq); - t->compact_event_bits = 0; } } break; default: g_warning("Unsupported trace version : %hhu.%hhu", - any->major_version, any->minor_version); + any->major_version, any->minor_version); return 1; } break; - default: g_warning("Unsupported trace version : %hhu.%hhu", any->major_version, any->minor_version); @@ -393,7 +377,7 @@ gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf) perror("Error in allocating memory for buffer of tracefile"); goto close_file; } - g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned. + g_assert( ( (gulong)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned. header = (struct ltt_block_start_header*)tf->buffer.head; @@ -694,8 +678,8 @@ void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname) int get_tracefile_name_number(gchar *raw_name, GQuark *name, guint *num, - guint *tid, - guint *pgid, + gulong *tid, + gulong *pgid, guint64 *creation) { guint raw_name_len = strlen(raw_name); @@ -831,7 +815,8 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data) for(i=0; ilen; i++) { tf = &g_array_index (group, LttTracefile, i); - if(tf->cpu_online) return 1; + if(tf->cpu_online) + return 1; } return 0; } @@ -848,8 +833,7 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data) * A tracefile group is simply an array where all the per cpu tracefiles sit. */ -static int open_tracefiles(LttTrace *trace, gchar *root_path, - gchar *relative_path) +int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path) { DIR *dir = opendir(root_path); struct dirent *entry; @@ -897,7 +881,7 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, g_debug("Tracefile file or directory : %s\n", path); - if(strcmp(rel_path, "/eventdefs") == 0) continue; + // if(strcmp(rel_path, "/eventdefs") == 0) continue; if(S_ISDIR(stat_buf.st_mode)) { @@ -906,10 +890,12 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, if(ret < 0) continue; } else if(S_ISREG(stat_buf.st_mode)) { GQuark name; - guint num, tid, pgid; + guint num; + gulong tid, pgid; guint64 creation; GArray *group; - num = tid = pgid = 0; + num = 0; + tid = pgid = 0; creation = 0; if(get_tracefile_name_number(rel_path, &name, &num, &tid, &pgid, &creation)) continue; /* invalid name */ @@ -950,7 +936,8 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, if(num+1 > old_len) group = g_array_set_size(group, num+1); g_array_index (group, LttTracefile, num) = tmp_tf; - + g_array_index (group, LttTracefile, num).event.tracefile = + &g_array_index (group, LttTracefile, num); } } @@ -968,7 +955,7 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, * * Returns 0 on success, or 1 on failure. */ - +#if 0 static int ltt_get_facility_description(LttFacility *f, LttTrace *t, LttTracefile *fac_tf) @@ -1082,17 +1069,17 @@ static void ltt_fac_ids_destroy(gpointer data) g_array_free(fac_ids, TRUE); } - +#endif //0 /* Presumes the tracefile is already seeked at the beginning. It makes sense, * because it must be done just after the opening */ -static int ltt_process_facility_tracefile(LttTracefile *tf) +int ltt_process_facility_tracefile(LttTracefile *tf) { int err; - LttFacility *fac; - GArray *fac_ids; + //LttFacility *fac; + //GArray *fac_ids; guint i; - LttEventType *et; + //LttEventType *et; while(1) { err = ltt_tracefile_read_seek(tf); @@ -1113,137 +1100,68 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) * 2 : state dump facility load * 3 : heartbeat */ - if(tf->event.facility_id != LTT_FACILITY_CORE) { + if(tf->event.event_id >= MARKER_CORE_IDS) { /* 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); + "should not contain event id %u.", g_quark_to_string(tf->name), + tf->event.event_id); err = EPERM; - goto fac_id_error; + goto event_id_error; } else { - struct LttFacilityLoad *fac_load_data; - struct LttStateDumpFacilityLoad *fac_state_dump_load_data; - char *fac_name; - void *pos; + char *pos; + const char *marker_name, *format; + uint16_t id; + guint8 int_size, long_size, pointer_size, size_t_size, alignment; // 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); - pos = (tf->event.data + strlen(fac_name) + 1); - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - fac_load_data = (struct LttFacilityLoad *)pos; - - fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, - ltt_get_uint32(LTT_GET_BO(tf), &fac_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 = 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->has_alignment); - - if(ltt_get_facility_description(fac, tf->trace, tf)) - continue; /* error opening description */ - - fac->trace = tf->trace; - - /* Preset the field offsets */ - for(i=0; ievents->len; i++){ - et = &g_array_index(fac->events, LttEventType, i); - precompute_offsets(fac, et); - } - - fac->exists = 1; - - 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, - fac->name, - fac_ids, ltt_fac_ids_destroy); - } - g_array_append_val(fac_ids, fac->id); - - 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_name = (char*)(tf->event.data); - g_debug("Doing LTT_EVENT_STATE_DUMP_FACILITY_LOAD of facility %s", - fac_name); - pos = (tf->event.data + strlen(fac_name) + 1); - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - fac_state_dump_load_data = (struct LttStateDumpFacilityLoad *)pos; - - fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, - 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_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_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_state_dump_load_data->size_t_size); - fac->alignment = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->has_alignment); - if(ltt_get_facility_description(fac, tf->trace, tf)) - continue; /* error opening description */ - - fac->trace = tf->trace; - - /* Preset the field offsets */ - for(i=0; ievents->len; i++){ - et = &g_array_index(fac->events, LttEventType, i); - precompute_offsets(fac, et); - } - - fac->exists = 1; - - 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, - fac->name, - fac_ids, ltt_fac_ids_destroy); - } - g_array_append_val(fac_ids, fac->id); - g_debug("fac id : %u", fac->id); - + switch((enum marker_id)tf->event.event_id) { + case MARKER_ID_SET_MARKER_ID: + marker_name = pos = tf->event.data; + g_debug("Doing MARKER_ID_SET_MARKER_ID of marker %s", marker_name); + pos += strlen(marker_name) + 1; + //remove genevent compatibility + //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment); + pos += ltt_align((size_t)pos, sizeof(uint16_t), tf->alignment); + id = ltt_get_uint16(LTT_GET_BO(tf), pos); + g_debug("In MARKER_ID_SET_MARKER_ID of marker %s id %hu", + marker_name, id); + pos += sizeof(guint16); + int_size = *(guint8*)pos; + pos += sizeof(guint8); + long_size = *(guint8*)pos; + pos += sizeof(guint8); + pointer_size = *(guint8*)pos; + pos += sizeof(guint8); + size_t_size = *(guint8*)pos; + pos += sizeof(guint8); + alignment = *(guint8*)pos; + pos += sizeof(guint8); + marker_id_event(tf->trace, g_quark_from_string(marker_name), + id, int_size, long_size, + pointer_size, size_t_size, alignment); break; - case LTT_EVENT_HEARTBEAT: + case MARKER_ID_SET_MARKER_FORMAT: + marker_name = pos = tf->event.data; + g_debug("Doing MARKER_ID_SET_MARKER_FORMAT of marker %s", + marker_name); + pos += strlen(marker_name) + 1; + //break genevent. + //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment); + format = pos; + pos += strlen(format) + 1; + //break genevent + //pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment); + marker_format_event(tf->trace, g_quark_from_string(marker_name), + format); + /* get information from dictionnary TODO */ break; - case LTT_EVENT_HEARTBEAT_FULL: + case MARKER_ID_HEARTBEAT_32: + case MARKER_ID_HEARTBEAT_64: break; default: g_warning("Error in processing facility file %s, " - "unknown event id %hhu in core facility.", + "unknown event id %hhu.", g_quark_to_string(tf->name), tf->event.event_id); err = EPERM; @@ -1255,7 +1173,6 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) /* Error handling */ event_id_error: -fac_id_error: update_error: seek_error: g_warning("An error occured in facility tracefile parsing"); @@ -1274,7 +1191,6 @@ LttTrace *ltt_trace_open(const gchar *pathname) DIR *dir; struct dirent *entry; guint control_found = 0; - guint eventdefs_found = 0; struct stat stat_buf; gchar path[PATH_MAX]; @@ -1305,14 +1221,11 @@ LttTrace *ltt_trace_open(const gchar *pathname) if(strcmp(entry->d_name, "control") == 0) { control_found = 1; } - if(strcmp(entry->d_name, "eventdefs") == 0) { - eventdefs_found = 1; - } } } closedir(dir); - if(!control_found || !eventdefs_found) goto find_error; + if(!control_found) goto find_error; /* Open all the tracefiles */ if(open_tracefiles(t, abs_path, "")) { @@ -1320,15 +1233,6 @@ LttTrace *ltt_trace_open(const gchar *pathname) goto find_error; } - /* Prepare the facilities containers : array and mapping */ - /* Array is zeroed : the "exists" field is set to false by default */ - t->facilities_by_num = g_array_sized_new (FALSE, - TRUE, sizeof(LttFacility), - NUM_FACILITIES); - t->facilities_by_num = g_array_set_size(t->facilities_by_num, NUM_FACILITIES); - - g_datalist_init(&t->facilities_by_name); - /* Parse each trace control/facilitiesN files : get runtime fac. info */ group = g_datalist_id_get_data(&t->tracefiles, LTT_TRACEFILE_NAME_FACILITIES); if(group == NULL) { @@ -1346,42 +1250,21 @@ LttTrace *ltt_trace_open(const gchar *pathname) t->num_cpu = group->len; + ret = allocate_marker_data(t); + if (ret) + g_error("Error in allocating marker data"); + for(i=0; ilen; i++) { tf = &g_array_index (group, LttTracefile, i); if(ltt_process_facility_tracefile(tf)) goto facilities_error; } - t->compact_facilities = ltt_trace_facility_get_by_name(t, - g_quark_from_string("compact")); - if(!t->compact_facilities) - t->compact_facilities = ltt_trace_facility_get_by_name(t, - g_quark_from_string("flight-compact")); - if (t->compact_facilities) { - /* FIXME : currently does not support unload/load of compact - * facility during tracing. Should check for the currently loaded - * version of the facility. */ - g_assert(t->compact_facilities->len == 1); - g_assert(t->compact_facilities); - { - guint facility_id = g_array_index(t->compact_facilities, guint, 0); - LttFacility *fac = ltt_trace_facility_by_id(t, facility_id); - unsigned int num = ltt_facility_eventtype_number(fac); - /* Could be done much quicker, but not on much used code path */ - if(num) { - t->compact_event_bits = 1; - while(num >>= 1) - t->compact_event_bits++; - } else - t->compact_event_bits = 0; - } - } return t; /* Error handling */ facilities_error: - g_datalist_clear(&t->facilities_by_name); - g_array_free(t->facilities_by_num, TRUE); + destroy_marker_data(t); find_error: g_datalist_clear(&t->tracefiles); open_error: @@ -1409,17 +1292,6 @@ LttTrace *ltt_trace_copy(LttTrace *self) void ltt_trace_close(LttTrace *t) { - guint i; - LttFacility *fac; - - for(i=0; ifacilities_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); g_free(t); } @@ -1428,7 +1300,7 @@ void ltt_trace_close(LttTrace *t) /***************************************************************************** *Get the system description of the trace ****************************************************************************/ - +#if 0 LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id) { g_assert(id < t->facilities_by_num->len); @@ -1446,6 +1318,7 @@ GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name) { return g_datalist_id_get_data(&t->facilities_by_name, name); } +#endif //0 /***************************************************************************** * Functions to discover all the event types in the trace @@ -1502,7 +1375,7 @@ LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name) * Get the start time and end time of the trace ****************************************************************************/ -static void ltt_tracefile_time_span_get(LttTracefile *tf, +void ltt_tracefile_time_span_get(LttTracefile *tf, LttTime *start, LttTime *end) { int err; @@ -1528,7 +1401,7 @@ struct tracefile_time_span_get_args { LttTime *end; }; -static void group_time_span_get(GQuark name, gpointer data, gpointer user_data) +void group_time_span_get(GQuark name, gpointer data, gpointer user_data) { struct tracefile_time_span_get_args *args = (struct tracefile_time_span_get_args*)user_data; @@ -1883,6 +1756,38 @@ int ltt_tracefile_read_op(LttTracefile *tf) return 0; } +static void print_debug_event_header(LttEvent *ev, void *start_pos, void *end_pos) +{ + unsigned int offset = 0; + int i, j; + + g_printf("Event header (tracefile %s offset %llx):\n", + g_quark_to_string(ev->tracefile->long_name), + ((uint64_t)ev->tracefile->buffer.index * ev->tracefile->buf_size) + + (long)start_pos - (long)ev->tracefile->buffer.head); + + while (offset < (long)end_pos - (long)start_pos) { + g_printf("%8lx", (long)start_pos - (long)ev->tracefile->buffer.head + offset); + g_printf(" "); + + for (i = 0; i < 4 ; i++) { + for (j = 0; j < 4; j++) { + if (offset + ((i * 4) + j) < + (long)end_pos - (long)start_pos) + g_printf("%02hhX", + ((char*)start_pos)[offset + ((i * 4) + j)]); + else + g_printf(" "); + g_printf(" "); + } + if (i < 4) + g_printf(" "); + } + offset+=16; + g_printf("\n"); + } +} + /* same as ltt_tracefile_read, but does not seek to the next event nor call * event specific operation. */ @@ -1890,6 +1795,7 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) { void * pos; LttEvent *event; + void *pos_aligned; event = &tf->event; pos = tf->buffer.head + event->offset; @@ -1898,11 +1804,12 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) /* Align the head */ if(!tf->compact) - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment); else { g_assert(tf->has_heartbeat); - pos += ltt_align((size_t)pos, sizeof(uint32_t), tf->has_alignment); + pos += ltt_align((size_t)pos, sizeof(uint32_t), tf->alignment); } + pos_aligned = pos; if(tf->has_heartbeat) { event->timestamp = ltt_get_uint32(LTT_GET_BO(tf), @@ -1927,9 +1834,9 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) /* We keep the LSB of the previous timestamp, to make sure * we never go back */ event->event_id = event->timestamp >> tf->tscbits; - event->event_id = event->event_id & ((1 << tf->trace->compact_event_bits) - 1); + event->event_id = event->event_id & ((1 << tf->compact_event_bits) - 1); event->compact_data = event->timestamp >> - (tf->trace->compact_event_bits + tf->tscbits); + (tf->compact_event_bits + tf->tscbits); //printf("tsc bits %u, ev bits %u init data %u\n", // tf->tscbits, tf->trace->compact_event_bits, event->compact_data); /* Put the compact data back in original endianness */ @@ -1959,7 +1866,6 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) event->tsc = tf->buffer.tsc; } //printf("current tsc 0x%llX\n", tf->buffer.tsc); - event->facility_id = g_array_index(tf->trace->compact_facilities, guint, 0); } pos += sizeof(guint32); } else { @@ -1971,20 +1877,22 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) event->event_time = ltt_interpolate_time(tf, event); if(!tf->compact) { - event->facility_id = *(guint8*)pos; - pos += sizeof(guint8); - - event->event_id = *(guint8*)pos; - pos += sizeof(guint8); + event->event_id = *(guint16*)pos; + pos += sizeof(guint16); event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos); pos += sizeof(guint16); } else { /* Compact event */ + event->event_size = 0xFFFF; } + + if (a_event_debug) + print_debug_event_header(event, pos_aligned, pos); + /* Align the head */ if(!tf->compact) - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->alignment); event->data = pos; @@ -2008,7 +1916,7 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) * EIO : can not read from the file ****************************************************************************/ -static gint map_block(LttTracefile * tf, guint block_num) +gint map_block(LttTracefile * tf, guint block_num) { int page_size = getpagesize(); struct ltt_block_start_header *header; @@ -2036,7 +1944,7 @@ static gint map_block(LttTracefile * tf, guint block_num) g_assert(0); goto map_error; } - g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned. + g_assert( ( (gulong)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned. tf->buffer.index = block_num; @@ -2129,68 +2037,139 @@ map_error: } +static void print_debug_event_data(LttEvent *ev) +{ + unsigned int offset = 0; + int i, j; + + if (!max(ev->event_size, ev->data_size)) + return; + + g_printf("Event data (tracefile %s offset %llx):\n", + g_quark_to_string(ev->tracefile->long_name), + ((uint64_t)ev->tracefile->buffer.index * ev->tracefile->buf_size) + + (long)ev->data - (long)ev->tracefile->buffer.head); + + while (offset < max(ev->event_size, ev->data_size)) { + g_printf("%8lx", (long)ev->data + offset + - (long)ev->tracefile->buffer.head); + g_printf(" "); + + for (i = 0; i < 4 ; i++) { + for (j = 0; j < 4; j++) { + if (offset + ((i * 4) + j) < max(ev->event_size, ev->data_size)) + g_printf("%02hhX", ((char*)ev->data)[offset + ((i * 4) + j)]); + else + g_printf(" "); + g_printf(" "); + } + if (i < 4) + g_printf(" "); + } + + g_printf(" "); + + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + if (offset + ((i * 4) + j) < max(ev->event_size, ev->data_size)) { + if (isprint(((char*)ev->data)[offset + ((i * 4) + j)])) + g_printf("%c", ((char*)ev->data)[offset + ((i * 4) + j)]); + else + g_printf("."); + } else + g_printf(" "); + } + } + offset+=16; + g_printf("\n"); + } +} + /* It will update the fields offsets too */ void ltt_update_event_size(LttTracefile *tf) { off_t size = 0; - LttFacility *f = ltt_trace_get_facility_by_num(tf->trace, - tf->event.facility_id); char *tscdata; + struct marker_info *info; - if(!f->exists) { - /* 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: + switch((enum marker_id)tf->event.event_id) { + case MARKER_ID_SET_MARKER_ID: size = strlen((char*)tf->event.data) + 1; - //g_debug("Update Event facility load of facility %s", (char*)tf->event.data); - size += ltt_align(size, sizeof(guint32), tf->has_alignment); - size += sizeof(struct LttFacilityLoad); + g_debug("marker %s id set", (char*)tf->event.data); + size += ltt_align(size, sizeof(guint16), tf->alignment); + size += sizeof(guint16); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); break; - case LTT_EVENT_FACILITY_UNLOAD: - //g_debug("Update Event facility unload"); - size = sizeof(struct LttFacilityUnload); - break; - case LTT_EVENT_STATE_DUMP_FACILITY_LOAD: + case MARKER_ID_SET_MARKER_FORMAT: + g_debug("marker %s format set", (char*)tf->event.data); size = strlen((char*)tf->event.data) + 1; - size += ltt_align(size, sizeof(guint32), tf->has_alignment); - //g_debug("Update Event facility load state dump of facility %s", - // (char*)tf->event.data); - size += sizeof(struct LttStateDumpFacilityLoad); + size += strlen((char*)tf->event.data + size) + 1; break; - case LTT_EVENT_HEARTBEAT: - //g_debug("Update Event heartbeat"); - size = sizeof(TimeHeartbeat); + case MARKER_ID_HEARTBEAT_32: + g_debug("Update Event heartbeat 32 bits"); break; - case LTT_EVENT_HEARTBEAT_FULL: - //g_debug("Update Event heartbeat full"); + case MARKER_ID_HEARTBEAT_64: + g_debug("Update Event heartbeat 64 bits"); tscdata = (char*)(tf->event.data); tf->event.tsc = ltt_get_uint64(LTT_GET_BO(tf), tscdata); tf->buffer.tsc = tf->event.tsc; tf->event.event_time = ltt_interpolate_time(tf, &tf->event); - size = sizeof(TimeHeartbeatFull); - size += ltt_align(size, sizeof(guint64), tf->has_alignment); + size = ltt_align(size, sizeof(guint64), tf->alignment); + size += sizeof(guint64); 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; + } + + info = marker_get_info_from_id(tf->trace, tf->event.event_id); + + if (tf->event.event_id >= MARKER_CORE_IDS) + g_assert(info != NULL); + + /* Do not update field offsets of core markers when initially reading the + * facility tracefile when the infos about these markers do not exist yet. + */ + if (likely(info && info->fields)) { + if (info->size != -1) + size = info->size; + else + size = marker_update_fields_offsets(marker_get_info_from_id(tf->trace, + tf->event.event_id), tf->event.data); + } + + tf->event.data_size = size; - } - goto no_offset; /* Skip the field computation */ - } else { - g_warning("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; - } + /* Check consistency between kernel and LTTV structure sizes */ + if(tf->event.event_size == 0xFFFF) { + /* Event size too big to fit in the event size field */ + tf->event.event_size = tf->event.data_size; + } + + if (a_event_debug) + print_debug_event_data(&tf->event); + + /* Having a marker load or marker format event out of the facilities + * tracefiles is a serious bug. */ + switch((enum marker_id)tf->event.event_id) { + case MARKER_ID_SET_MARKER_ID: + case MARKER_ID_SET_MARKER_FORMAT: + if (tf->name != g_quark_from_string("/control/facilities")) + g_error("Trace inconsistency : metadata event found in data " + "tracefile %s", g_quark_to_string(tf->long_name)); + } + + if (tf->event.data_size != tf->event.event_size) { + struct marker_info *info = marker_get_info_from_id(tf->trace, + tf->event.event_id); + g_error("Kernel/LTTV event size differs for event %s: kernel %u, LTTV %u", + g_quark_to_string(info->name), + tf->event.event_size, tf->event.data_size); + exit(-1); } +#if 0 LttEventType *event_type = ltt_facility_eventtype_get(f, tf->event.event_id); @@ -2227,7 +2206,6 @@ no_offset: return; -facility_error: event_type_error: event_id_error: if(tf->event.event_size == 0xFFFF) { @@ -2236,6 +2214,7 @@ event_id_error: /* The facility is unknown : use the kernel information about this event * to jump over it. */ tf->event.data_size = tf->event.event_size; +#endif //0 } @@ -2250,7 +2229,7 @@ event_id_error: * ERANGE if we are at the end of the buffer. * ENOPROTOOPT if an error occured when getting the current event size. */ -static int ltt_seek_next_event(LttTracefile *tf) +int ltt_seek_next_event(LttTracefile *tf) { int ret = 0; void *pos; @@ -2359,6 +2338,7 @@ void set_fields_offsets(LttTracefile *tf, LttEventType *event_type) * returns : The size on which it must be aligned. * ****************************************************************************/ +#if 0 off_t get_alignment(LttField *field) { LttType *type = &field->field_type; @@ -2428,6 +2408,8 @@ off_t get_alignment(LttField *field) } } +#endif //0 + /***************************************************************************** *Function name * field_compute_static_size : Determine the size of fields known by their @@ -2438,7 +2420,7 @@ off_t get_alignment(LttField *field) * field : field * ****************************************************************************/ - +#if 0 void field_compute_static_size(LttFacility *fac, LttField *field) { LttType *type = &field->field_type; @@ -2520,7 +2502,7 @@ void field_compute_static_size(LttFacility *fac, LttField *field) } } - +#endif //0 /***************************************************************************** @@ -2535,7 +2517,7 @@ void field_compute_static_size(LttFacility *fac, LttField *field) * 0 otherwise. ****************************************************************************/ - +#if 0 gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, gint is_compact) { LttType *type = &field->field_type; @@ -2694,7 +2676,9 @@ gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, } +#endif //0 +#if 0 /***************************************************************************** *Function name * precompute_offsets : set the precomputable offset of an event type @@ -2726,7 +2710,7 @@ void precompute_offsets(LttFacility *fac, LttEventType *event) if(ret) break; } } - +#endif //0 @@ -2924,6 +2908,7 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, // 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. +#if 0 gint check_fields_compatibility(LttEventType *event_type1, LttEventType *event_type2, LttField *field1, LttField *field2) @@ -3028,7 +3013,7 @@ gint check_fields_compatibility(LttEventType *event_type1, end: return different; } - +#endif //0 #if 0 gint check_fields_compatibility(LttEventType *event_type1, @@ -3249,7 +3234,10 @@ LttTime ltt_trace_start_time_monotonic(LttTrace *t) LttTracefile *ltt_tracefile_new() { - return g_new(LttTracefile, 1); + LttTracefile *tf; + tf = g_new(LttTracefile, 1); + tf->event.tracefile = tf; + return tf; } void ltt_tracefile_destroy(LttTracefile *tf) @@ -3264,7 +3252,7 @@ void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) /* Before library loading... */ -static void __attribute__((constructor)) init(void) +void init(void) { LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); @@ -3272,4 +3260,3 @@ static void __attribute__((constructor)) init(void) LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("/control/facilities"); } -