X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=995a907506b4a937efffe2f8a18a792c8de0d982;hb=ec7a5af61127aa50a1839eee5be99ce53494c57b;hp=df02f4be3b2860c1706d068af955b37dc63a5601;hpb=29af7cfdc9979121f09db4ba7c154f52d0fb518e;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index df02f4be..995a9075 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -41,14 +41,12 @@ #include -#include "parser.h" #include #include "ltt-private.h" #include #include -//#include #include -#include +#include /* Facility names used in this file */ @@ -77,6 +75,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); @@ -104,8 +104,6 @@ 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); - static int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path); static int ltt_process_facility_tracefile(LttTracefile *tf); @@ -113,110 +111,21 @@ 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); - -#if 0 -/* Functions to parse system.xml file (using glib xml parser) */ -static void parser_start_element (GMarkupParseContext __UNUSED__ *context, - const gchar *element_name, - const gchar **attribute_names, - const gchar **attribute_values, - gpointer user_data, - GError **error) -{ - int i=0; - LttSystemDescription* des = (LttSystemDescription* )user_data; - if(strcmp("system", element_name)){ - *error = g_error_new(G_MARKUP_ERROR, - G_LOG_LEVEL_WARNING, - "This is not system.xml file"); - return; - } - - while(attribute_names[i]){ - if(strcmp("node_name", attribute_names[i])==0){ - des->node_name = g_strdup(attribute_values[i]); - }else if(strcmp("domainname", attribute_names[i])==0){ - des->domain_name = g_strdup(attribute_values[i]); - }else if(strcmp("cpu", attribute_names[i])==0){ - des->nb_cpu = atoi(attribute_values[i]); - }else if(strcmp("arch_size", attribute_names[i])==0){ - if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32; - else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32; - else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64; - else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64; - else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN; - }else if(strcmp("endian", attribute_names[i])==0){ - if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0) - des->endian = LTT_LITTLE_ENDIAN; - else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0) - des->endian = LTT_BIG_ENDIAN; - }else if(strcmp("kernel_name", attribute_names[i])==0){ - des->kernel_name = g_strdup(attribute_values[i]); - }else if(strcmp("kernel_release", attribute_names[i])==0){ - des->kernel_release = g_strdup(attribute_values[i]); - }else if(strcmp("kernel_version", attribute_names[i])==0){ - des->kernel_version = g_strdup(attribute_values[i]); - }else if(strcmp("machine", attribute_names[i])==0){ - des->machine = g_strdup(attribute_values[i]); - }else if(strcmp("processor", attribute_names[i])==0){ - des->processor = g_strdup(attribute_values[i]); - }else if(strcmp("hardware_platform", attribute_names[i])==0){ - des->hardware_platform = g_strdup(attribute_values[i]); - }else if(strcmp("operating_system", attribute_names[i])==0){ - des->operating_system = g_strdup(attribute_values[i]); - }else if(strcmp("ltt_major_version", attribute_names[i])==0){ - des->ltt_major_version = atoi(attribute_values[i]); - }else if(strcmp("ltt_minor_version", attribute_names[i])==0){ - des->ltt_minor_version = atoi(attribute_values[i]); - }else if(strcmp("ltt_block_size", attribute_names[i])==0){ - des->ltt_block_size = atoi(attribute_values[i]); - }else{ - *error = g_error_new(G_MARKUP_ERROR, - G_LOG_LEVEL_WARNING, - "Not a valid attribute"); - return; - } - i++; - } -} - -static void parser_characters (GMarkupParseContext __UNUSED__ *context, - const gchar *text, - gsize __UNUSED__ text_len, - gpointer user_data, - GError __UNUSED__ **error) -{ - LttSystemDescription* des = (LttSystemDescription* )user_data; - des->description = g_strdup(text); -} -#endif //0 - -#if 0 -LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, - guint num) -{ - g_assert(num < t->facilities_by_num->len); - - return &g_array_index(t->facilities_by_num, LttFacility, num); -} -#endif //0 +/* Enable event debugging */ +static int a_event_debug = 0; -guint ltt_trace_get_num_cpu(LttTrace *t) +void ltt_event_debug(int state) { - return t->num_cpu; + a_event_debug = state; } - /* trace can be NULL * * Return value : 0 success, 1 bad tracefile */ -int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) +static 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; @@ -231,7 +140,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) { @@ -246,7 +155,6 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) // t->compact_facilities = NULL; } - switch(any->major_version) { case 0: @@ -266,6 +174,7 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) 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)); @@ -275,6 +184,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), @@ -289,7 +205,6 @@ 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; @@ -322,7 +237,7 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) * : 0 for success, -1 otherwise. ****************************************************************************/ -gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf) +static gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf) { struct stat lTDFStat; /* Trace data file status */ struct ltt_block_start_header *header; @@ -361,7 +276,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; @@ -411,11 +326,6 @@ end: return -1; } -LttTrace *ltt_tracefile_get_trace(LttTracefile *tf) -{ - return tf->trace; -} - #if 0 /***************************************************************************** *Open control and per cpu tracefiles @@ -491,7 +401,7 @@ gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name) * t : tracefile which will be closed ****************************************************************************/ -void ltt_tracefile_close(LttTracefile *t) +static void ltt_tracefile_close(LttTracefile *t) { int page_size = getpagesize(); @@ -659,11 +569,11 @@ void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname) * The left side is the name, the right side is the number. */ -int get_tracefile_name_number(gchar *raw_name, +static 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); @@ -777,7 +687,7 @@ void compute_tracefile_group(GQuark key_id, } -void ltt_tracefile_group_destroy(gpointer data) +static void ltt_tracefile_group_destroy(gpointer data) { GArray *group = (GArray *)data; int i; @@ -791,7 +701,7 @@ void ltt_tracefile_group_destroy(gpointer data) g_array_free(group, TRUE); } -gboolean ltt_tracefile_group_has_cpu_online(gpointer data) +static gboolean ltt_tracefile_group_has_cpu_online(gpointer data) { GArray *group = (GArray *)data; int i; @@ -817,7 +727,7 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data) * A tracefile group is simply an array where all the per cpu tracefiles sit. */ -int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path) +static int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path) { DIR *dir = opendir(root_path); struct dirent *entry; @@ -865,7 +775,7 @@ int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_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)) { @@ -874,10 +784,12 @@ int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_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 */ @@ -918,7 +830,8 @@ int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_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); } } @@ -927,134 +840,10 @@ int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path) return 0; } -/* ltt_get_facility_description - * - * Opens the file corresponding to the requested facility (identified by fac_id - * and checksum). - * - * The name searched is : %trace root%/eventdefs/facname_checksum.xml - * - * Returns 0 on success, or 1 on failure. - */ -#if 0 -static int ltt_get_facility_description(LttFacility *f, - LttTrace *t, - LttTracefile *fac_tf) -{ - char desc_file_name[PATH_MAX]; - const gchar *text; - guint textlen; - gint err; - gint arch_spec; - gint fac_name_len; - - text = g_quark_to_string(t->pathname); - textlen = strlen(text); - - if(textlen >= PATH_MAX) goto name_error; - strcpy(desc_file_name, text); - - text = "/eventdefs/"; - textlen+=strlen(text); - if(textlen >= PATH_MAX) goto name_error; - strcat(desc_file_name, text); - - text = g_quark_to_string(f->name); - fac_name_len = strlen(text); - textlen+=fac_name_len; - if(textlen >= PATH_MAX) goto name_error; - strcat(desc_file_name, text); - - /* arch specific facilities are named like this : name_arch */ - if(fac_name_len+1 < sizeof("_arch")) - arch_spec = 0; - else { - if(!strcmp(&text[fac_name_len+1-sizeof("_arch")], "_arch")) - arch_spec = 1; - else - arch_spec = 0; - } - -#if 0 - text = "_"; - textlen+=strlen(text); - if(textlen >= PATH_MAX) goto name_error; - strcat(desc_file_name, text); - - err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1, - "%u", f->checksum); - if(err < 0) goto name_error; - - textlen=strlen(desc_file_name); - -#endif //0 - - if(arch_spec) { - switch(t->arch_type) { - case LTT_ARCH_TYPE_I386: - text = "_i386"; - break; - case LTT_ARCH_TYPE_PPC: - text = "_ppc"; - break; - case LTT_ARCH_TYPE_SH: - text = "_sh"; - break; - case LTT_ARCH_TYPE_S390: - text = "_s390"; - break; - case LTT_ARCH_TYPE_MIPS: - text = "_mips"; - break; - case LTT_ARCH_TYPE_ARM: - text = "_arm"; - break; - case LTT_ARCH_TYPE_PPC64: - text = "_ppc64"; - break; - case LTT_ARCH_TYPE_X86_64: - text = "_x86_64"; - break; - case LTT_ARCH_TYPE_C2: - text = "_c2"; - break; - case LTT_ARCH_TYPE_POWERPC: - text = "_powerpc"; - break; - default: - g_error("Trace from unsupported architecture."); - } - textlen+=strlen(text); - if(textlen >= PATH_MAX) goto name_error; - strcat(desc_file_name, text); - } - - 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; - - return 0; - -facility_error: -name_error: - return 1; -} - -static void ltt_fac_ids_destroy(gpointer data) -{ - GArray *fac_ids = (GArray *)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 */ -int ltt_process_facility_tracefile(LttTracefile *tf) +static int ltt_process_facility_tracefile(LttTracefile *tf) { int err; //LttFacility *fac; @@ -1090,7 +879,7 @@ int ltt_process_facility_tracefile(LttTracefile *tf) goto event_id_error; } else { - void *pos; + char *pos; const char *marker_name, *format; uint16_t id; guint8 int_size, long_size, pointer_size, size_t_size, alignment; @@ -1098,12 +887,15 @@ int ltt_process_facility_tracefile(LttTracefile *tf) // FIXME align switch((enum marker_id)tf->event.event_id) { case MARKER_ID_SET_MARKER_ID: - marker_name = (char*)(tf->event.data); + marker_name = pos = tf->event.data; g_debug("Doing MARKER_ID_SET_MARKER_ID of marker %s", marker_name); - pos = (tf->event.data + strlen(marker_name) + 1); - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - pos += ltt_align((size_t)pos, sizeof(uint16_t), tf->has_alignment); + 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); @@ -1120,14 +912,16 @@ int ltt_process_facility_tracefile(LttTracefile *tf) pointer_size, size_t_size, alignment); break; case MARKER_ID_SET_MARKER_FORMAT: - marker_name = (char*)(tf->event.data); + marker_name = pos = tf->event.data; g_debug("Doing MARKER_ID_SET_MARKER_FORMAT of marker %s", marker_name); - pos = (tf->event.data + strlen(marker_name) + 1); - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - format = (const char*)pos; + 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; - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + //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 */ @@ -1155,6 +949,11 @@ seek_error: return err; } +/* + * Open a trace and return its LttTrace handle. + * + * pathname must be the directory of the trace + */ LttTrace *ltt_trace_open(const gchar *pathname) { @@ -1167,7 +966,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]; @@ -1198,14 +996,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, "")) { @@ -1230,18 +1025,22 @@ 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; + if (tf->cpu_online) + if(ltt_process_facility_tracefile(tf)) + goto facilities_error; } 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: @@ -1251,22 +1050,23 @@ alloc_error: } -GQuark ltt_trace_name(const LttTrace *t) -{ - return t->pathname; -} - - -/****************************************************************************** +/* Open another, completely independant, instance of a trace. + * + * A read on this new instance will read the first event of the trace. + * * When we copy a trace, we want all the opening actions to happen again : * the trace will be reopened and totally independant from the original. * That's why we call ltt_trace_open. - *****************************************************************************/ + */ LttTrace *ltt_trace_copy(LttTrace *self) { return ltt_trace_open(g_quark_to_string(self->pathname)); } +/* + * Close a trace + */ + void ltt_trace_close(LttTrace *t) { g_datalist_clear(&t->tracefiles); @@ -1274,80 +1074,6 @@ 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); - return &g_array_index(t->facilities_by_num, LttFacility, id); -} - -/* ltt_trace_facility_get_by_name - * - * Returns the GArray of facility indexes. All the fac_ids that matches the - * requested facility name. - * - * If name is not found, returns NULL. - */ -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 - ****************************************************************************/ - -#if 0 -unsigned ltt_trace_eventtype_number(LttTrace *t) -{ - unsigned int i; - unsigned count = 0; - unsigned int num = t->facility_number; - LttFacility * f; - - for(i=0;ifacilities, i); - count += f->event_number; - } - return count; -} -#endif //0 - -#if 0 -//use an iteration on all the trace facilities, and inside iteration on all the -//event types in each facilities instead. -LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId) -{ - LttEventType *event_type; - - LttFacility * f; - f = ltt_trace_facility_by_id(t,evId); - - if(unlikely(!f)) event_type = NULL; - else event_type = f->events[evId - f->base_id]; - - return event_type; -} -#endif //0 - -#if 0 -/***************************************************************************** - * ltt_trace_find_tracefile - * - * Find a tracefile by name and index in the group. - * - * Returns a pointer to the tracefiles, else NULL. - ****************************************************************************/ - -LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name) -{ -} -#endif //0 - /***************************************************************************** * Get the start time and end time of the trace ****************************************************************************/ @@ -1378,7 +1104,7 @@ struct tracefile_time_span_get_args { LttTime *end; }; -void group_time_span_get(GQuark name, gpointer data, gpointer user_data) +static 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; @@ -1399,6 +1125,8 @@ void group_time_span_get(GQuark name, gpointer data, gpointer user_data) } } +/* return the start and end time of a trace */ + void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) { LttTime min_start = ltt_time_infinite; @@ -1413,51 +1141,6 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) } -/***************************************************************************** - *Get the name of a tracefile - ****************************************************************************/ - -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_cpu(LttTracefile *tf) -{ - return tf->cpu_num; -} - -guint ltt_tracefile_tid(LttTracefile *tf) -{ - return tf->tid; -} - -guint ltt_tracefile_pgid(LttTracefile *tf) -{ - return tf->pgid; -} - -guint64 ltt_tracefile_creation(LttTracefile *tf) -{ - return tf->creation; -} -/***************************************************************************** - * Get the number of blocks in the tracefile - ****************************************************************************/ - -guint ltt_tracefile_block_number(LttTracefile *tf) -{ - return tf->num_blocks; -} - - /* Seek to the first event in a tracefile that has a time equal or greater than * the time passed in parameter. * @@ -1581,9 +1264,11 @@ fail: return EPERM; } +/* Seek to a position indicated by an LttEventPosition + */ -int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) { - +int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) +{ int err; if(ep->tracefile != tf) { @@ -1604,8 +1289,11 @@ int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) { err = ltt_tracefile_read_update_event(tf); if(err) goto fail; + + /* deactivate this, as it does nothing for now err = ltt_tracefile_read_op(tf); if(err) goto fail; + */ return 0; @@ -1615,6 +1303,10 @@ fail: return 1; } +/* Given a TSC value, return the LttTime (seconds,nanoseconds) it + * corresponds to. + */ + LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc) { LttTime time; @@ -1680,8 +1372,11 @@ int ltt_tracefile_read(LttTracefile *tf) if(err) return err; err = ltt_tracefile_read_update_event(tf); if(err) return err; + + /* deactivate this, as it does nothing for now err = ltt_tracefile_read_op(tf); if(err) return err; + */ return 0; } @@ -1715,23 +1410,55 @@ int ltt_tracefile_read_seek(LttTracefile *tf) return 0; } +/* do an operation when reading a new event */ -/* do specific operation on events */ +/* This function does nothing for now */ +#if 0 int ltt_tracefile_read_op(LttTracefile *tf) { LttEvent *event; event = &tf->event; - /* do event specific operation */ + /* do event specific operation */ + + /* nothing */ - /* do something if its an heartbeat event : increment the heartbeat count */ - //if(event->facility_id == LTT_FACILITY_CORE) - // if(event->event_id == LTT_EVENT_HEARTBEAT) - // tf->cur_heart_beat_number++; - return 0; } +#endif + +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 @@ -1740,6 +1467,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; @@ -1748,11 +1476,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), @@ -1777,9 +1506,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 */ @@ -1820,17 +1549,22 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) event->event_time = ltt_interpolate_time(tf, event); if(!tf->compact) { - event->event_id = *(guint16*)pos; + event->event_id = ltt_get_uint16(LTT_GET_BO(tf), 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; @@ -1854,7 +1588,7 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) * EIO : can not read from the file ****************************************************************************/ -gint map_block(LttTracefile * tf, guint block_num) +static gint map_block(LttTracefile * tf, guint block_num) { int page_size = getpagesize(); struct ltt_block_start_header *header; @@ -1882,7 +1616,7 @@ 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; @@ -1975,6 +1709,54 @@ 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) { @@ -1985,8 +1767,8 @@ void ltt_update_event_size(LttTracefile *tf) switch((enum marker_id)tf->event.event_id) { case MARKER_ID_SET_MARKER_ID: size = strlen((char*)tf->event.data) + 1; - //g_debug("marker %s id set", (char*)tf->event.data); - size += ltt_align(size, sizeof(guint16), tf->has_alignment); + 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); @@ -1995,33 +1777,38 @@ void ltt_update_event_size(LttTracefile *tf) size += sizeof(guint8); break; case MARKER_ID_SET_MARKER_FORMAT: - //g_debug("marker %s format set", (char*)tf->event.data); + g_debug("marker %s format set", (char*)tf->event.data); size = strlen((char*)tf->event.data) + 1; - size += strlen((char*)tf->event.data) + 1; + size += strlen((char*)tf->event.data + size) + 1; break; case MARKER_ID_HEARTBEAT_32: - //g_debug("Update Event heartbeat 32 bits"); - size = ltt_align(size, sizeof(guint32), tf->has_alignment); - size += sizeof(guint32); + g_debug("Update Event heartbeat 32 bits"); break; case MARKER_ID_HEARTBEAT_64: - //g_debug("Update Event heartbeat 64 bits"); + 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 = ltt_align(size, sizeof(guint64), tf->has_alignment); + size = ltt_align(size, sizeof(guint64), tf->alignment); size += sizeof(guint64); break; - default: - info = marker_get_info_from_id(tf->trace, tf->event.event_id); - g_assert(info != NULL); - 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); - } + } + + 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; @@ -2031,6 +1818,20 @@ void ltt_update_event_size(LttTracefile *tf) /* 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); @@ -2039,53 +1840,6 @@ void ltt_update_event_size(LttTracefile *tf) tf->event.event_size, tf->event.data_size); exit(-1); } - -#if 0 - LttEventType *event_type = - ltt_facility_eventtype_get(f, tf->event.event_id); - - if(!event_type) { - g_warning("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; - } - - /* Compute the dynamic offsets */ - compute_offsets(tf, f, event_type, &size, tf->event.data); - - //g_debug("Event root field : f.e %hhu.%hhu size %zd", - // tf->event.facility_id, - // tf->event.event_id, size); - -no_offset: - tf->event.data_size = size; - - /* 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 (tf->event.data_size != tf->event.event_size) { - g_error("Kernel/LTTV event size differs for event %s.%s: kernel %u, LTTV %u", - g_quark_to_string(f->name), g_quark_to_string(event_type->name), - tf->event.event_size, tf->event.data_size); - exit(-1); - } - //g_assert(tf->event.data_size == tf->event.event_size); - - return; - -event_type_error: -event_id_error: - if(tf->event.event_size == 0xFFFF) { - g_error("Cannot jump over an unknown event bigger than 0xFFFE bytes"); - } - /* 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 } @@ -2100,7 +1854,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. */ -int ltt_seek_next_event(LttTracefile *tf) +static int ltt_seek_next_event(LttTracefile *tf) { int ret = 0; void *pos; @@ -3103,24 +2857,27 @@ LttTime ltt_trace_start_time_monotonic(LttTrace *t) return t->start_time_from_tsc; } -LttTracefile *ltt_tracefile_new() +static 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) +static void ltt_tracefile_destroy(LttTracefile *tf) { g_free(tf); } -void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) +static void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) { *dest = *src; } /* Before library loading... */ -void init(void) +static __attribute__((constructor)) void init(void) { LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat");