X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=31100215d80f9340cefee0bd52a664435d23ba1e;hb=8655430bd9f02ea37f252ed65885320aedd75ff3;hp=2a12480d8532f49ce0b4a457b8e9483cb7b19d3c;hpb=2312de30ce2be53f81c4eaaa772ffff21511b509;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 2a12480d..31100215 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -3,19 +3,19 @@ * * Complete rewrite from the original version made by XangXiu Yang. * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License Version 2 as - * published by the Free Software Foundation; + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License Version 2.1 as published by the Free Software Foundation. * - * This program is distributed in the hope that it will be useful, + * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H @@ -34,26 +34,25 @@ #include #include #include +#include // For realpath #include #include -#include "parser.h" #include #include "ltt-private.h" #include -#include #include -#include #include - +#include /* Facility names used in this file */ GQuark LTT_FACILITY_NAME_HEARTBEAT, - LTT_EVENT_NAME_HEARTBEAT; + LTT_EVENT_NAME_HEARTBEAT, + LTT_EVENT_NAME_HEARTBEAT_FULL; GQuark LTT_TRACEFILE_NAME_FACILITIES; #ifndef g_open @@ -76,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); @@ -103,109 +104,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 precompute_offsets(LttTracefile *tf, LttEventType *event); - -#if 0 -/* Functions to parse system.xml file (using glib xml parser) */ -static void parser_start_element (GMarkupParseContext __UNUSED__ *context, - 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 - - -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); +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 void ltt_update_event_size(LttTracefile *tf); -} +/* 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; @@ -220,7 +140,8 @@ 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) { t->arch_type = ltt_get_uint32(LTT_GET_BO(tf), @@ -231,55 +152,68 @@ 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->has_heartbeat = any->has_heartbeat; - t->has_tsc = any->has_tsc; + // 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: + case 0: { + 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_3); - g_warning("Unsupported trace version : %hhu.%hhu", - any->major_version, any->minor_version); - return 1; - } - break; - case 4: - { - struct ltt_trace_header_0_4 *vheader = - (struct ltt_trace_header_0_4 *)header; - tf->buffer_header_size = - sizeof(struct ltt_block_start_header) - + sizeof(struct ltt_trace_header_0_4); + + 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)); + tf->tsc_mask_next_bit = tf->tsc_mask_next_bit << tf->tsc_lsb_truncate; 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); + 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), &vheader->start_monotonic); - t->start_time = ltt_get_time(LTT_GET_BO(tf), - &vheader->start_time); + 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 * 1000000.0 / (double)t->start_freq); + (double)t->start_tsc + * (1000000000.0 / tf->trace->freq_scale) + / (double)t->start_freq); } } 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); @@ -303,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; @@ -342,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; @@ -392,11 +326,6 @@ end: return -1; } -LttTrace *ltt_tracefile_get_trace(LttTracefile *tf) -{ - return tf->trace; -} - #if 0 /***************************************************************************** *Open control and per cpu tracefiles @@ -472,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(); @@ -640,9 +569,12 @@ 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(const gchar *raw_name, +static int get_tracefile_name_number(gchar *raw_name, GQuark *name, - guint *num) + guint *num, + gulong *tid, + gulong *pgid, + guint64 *creation) { guint raw_name_len = strlen(raw_name); gchar char_name[PATH_MAX]; @@ -650,27 +582,85 @@ int get_tracefile_name_number(const gchar *raw_name, int underscore_pos; long int cpu_num; gchar *endptr; + gchar *tmpptr; for(i=raw_name_len-1;i>=0;i--) { if(raw_name[i] == '_') break; } - if(i==0) /* Either not found or name length is 0 */ - return -1; - underscore_pos = i; + if(i==-1) { /* Either not found or name length is 0 */ + /* This is a userspace tracefile */ + strncpy(char_name, raw_name, raw_name_len); + char_name[raw_name_len] = '\0'; + *name = g_quark_from_string(char_name); + *num = 0; /* unknown cpu */ + 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; } @@ -733,36 +724,35 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data) * 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. + * 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) +static int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path) { - DIR *dir = opendir(root_path); - struct dirent *entry; - struct stat stat_buf; - int ret; + DIR *dir = opendir(root_path); + struct dirent *entry; + struct stat stat_buf; + int ret; - gchar path[PATH_MAX]; - int path_len; - gchar *path_ptr; + gchar path[PATH_MAX]; + int path_len; + gchar *path_ptr; int rel_path_len; gchar rel_path[PATH_MAX]; gchar *rel_path_ptr; LttTracefile tmp_tf; - if(dir == NULL) { - perror(root_path); - return ENOENT; - } + if(dir == NULL) { + perror(root_path); + return ENOENT; + } - strncpy(path, root_path, PATH_MAX-1); - path_len = strlen(path); - path[path_len] = '/'; - path_len++; - path_ptr = path + path_len; + strncpy(path, root_path, PATH_MAX-1); + path_len = strlen(path); + path[path_len] = '/'; + path_len++; + path_ptr = path + path_len; strncpy(rel_path, relative_path, PATH_MAX-1); rel_path_len = strlen(rel_path); @@ -770,37 +760,41 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, 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) { - perror(path); - continue; - } - - g_debug("Tracefile file or directory : %s\n", path); - - if(strcmp(rel_path, "/eventdefs") == 0) continue; + 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) { + perror(path); + continue; + } + + g_debug("Tracefile file or directory : %s\n", path); + + // if(strcmp(rel_path, "/eventdefs") == 0) continue; - if(S_ISDIR(stat_buf.st_mode)) { + if(S_ISDIR(stat_buf.st_mode)) { - g_debug("Entering subdirectory...\n"); - ret = open_tracefiles(trace, path, rel_path); - if(ret < 0) continue; - } else if(S_ISREG(stat_buf.st_mode)) { - GQuark name; + g_debug("Entering subdirectory...\n"); + ret = open_tracefiles(trace, path, rel_path); + if(ret < 0) continue; + } else if(S_ISREG(stat_buf.st_mode)) { + GQuark name; guint num; + gulong tid, pgid; + guint64 creation; GArray *group; - - if(get_tracefile_name_number(rel_path, &name, &num)) + num = 0; + tid = pgid = 0; + creation = 0; + if(get_tracefile_name_number(rel_path, &name, &num, &tid, &pgid, &creation)) continue; /* invalid name */ - g_debug("Opening file.\n"); + g_debug("Opening file.\n"); if(ltt_tracefile_open(trace, path, &tmp_tf)) { g_info("Error opening tracefile %s", path); @@ -813,7 +807,14 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, tmp_tf.cpu_online = 1; tmp_tf.cpu_num = num; tmp_tf.name = name; - + tmp_tf.tid = tid; + tmp_tf.pgid = pgid; + tmp_tf.creation = creation; + if(tmp_tf.name == g_quark_from_string("/compact") + || tmp_tf.name == g_quark_from_string("/flight-compact")) + tmp_tf.compact = 1; + else + tmp_tf.compact = 0; group = g_datalist_id_get_data(&trace->tracefiles, name); if(group == NULL) { /* Elements are automatically cleared when the array is allocated. @@ -829,82 +830,14 @@ 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; - - } - } - - closedir(dir); - - 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. - */ - -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; - - 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); - textlen+=strlen(text); - if(textlen >= PATH_MAX) goto name_error; - strcat(desc_file_name, text); -#if 0 - text = "_"; - textlen+=strlen(text); - if(textlen >= PATH_MAX) goto name_error; - 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); + g_array_index (group, LttTracefile, num).event.tracefile = + &g_array_index (group, LttTracefile, num); + } + } -#endif //0 - text = ".xml"; - textlen+=strlen(text); - if(textlen >= PATH_MAX) goto name_error; - strcat(desc_file_name, text); - - err = ltt_facility_open(f, t, desc_file_name); - if(err) goto facility_error; + closedir(dir); 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); } @@ -913,10 +846,10 @@ static void ltt_fac_ids_destroy(gpointer data) static 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); @@ -937,131 +870,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; + 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); - fac_load_data = - (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)); - /* 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(tf, 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); - + 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_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); - 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_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(tf, 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); - + 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: + 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; @@ -1073,7 +943,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"); @@ -1089,11 +958,10 @@ LttTrace *ltt_trace_open(const gchar *pathname) GArray *group; int i, ret; struct ltt_block_start_header *header; - DIR *dir; - struct dirent *entry; + DIR *dir; + struct dirent *entry; guint control_found = 0; - guint eventdefs_found = 0; - struct stat stat_buf; + struct stat stat_buf; gchar path[PATH_MAX]; t = g_new(LttTrace, 1); @@ -1105,32 +973,29 @@ LttTrace *ltt_trace_open(const gchar *pathname) g_datalist_init(&t->tracefiles); /* Test to see if it looks like a trace */ - dir = opendir(abs_path); - if(dir == NULL) { - perror(abs_path); - goto open_error; - } - while((entry = readdir(dir)) != NULL) { + dir = opendir(abs_path); + if(dir == NULL) { + perror(abs_path); + goto open_error; + } + while((entry = readdir(dir)) != NULL) { strcpy(path, abs_path); strcat(path, "/"); strcat(path, entry->d_name); - ret = stat(path, &stat_buf); - if(ret == -1) { - perror(path); - continue; - } - if(S_ISDIR(stat_buf.st_mode)) { + ret = stat(path, &stat_buf); + if(ret == -1) { + perror(path); + continue; + } + if(S_ISDIR(stat_buf.st_mode)) { if(strcmp(entry->d_name, "control") == 0) { control_found = 1; } - if(strcmp(entry->d_name, "eventdefs") == 0) { - eventdefs_found = 1; - } } } closedir(dir); - if(!control_found || !eventdefs_found) goto find_error; + if(!control_found) goto find_error; /* Open all the tracefiles */ if(open_tracefiles(t, abs_path, "")) { @@ -1138,15 +1003,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) { @@ -1164,18 +1020,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; } - + 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: @@ -1185,12 +1044,6 @@ alloc_error: } -GQuark ltt_trace_name(const LttTrace *t) -{ - return t->pathname; -} - - /****************************************************************************** * 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. @@ -1203,100 +1056,16 @@ 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); } -/***************************************************************************** - *Get the system description of the trace - ****************************************************************************/ - -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); -} - -/***************************************************************************** - * 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 ****************************************************************************/ -static void ltt_tracefile_time_span_get(LttTracefile *tf, +void ltt_tracefile_time_span_get(LttTracefile *tf, LttTime *start, LttTime *end) { int err; @@ -1343,6 +1112,8 @@ static 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; @@ -1357,37 +1128,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_num(LttTracefile *tf) -{ - return tf->cpu_num; -} - -/***************************************************************************** - * 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. * @@ -1512,8 +1252,8 @@ fail: } -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) { @@ -1528,6 +1268,10 @@ int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) { tf->event.offset = ep->offset; + /* Put back the event real tsc */ + tf->event.tsc = ep->tsc; + tf->buffer.tsc = ep->tsc; + err = ltt_tracefile_read_update_event(tf); if(err) goto fail; err = ltt_tracefile_read_op(tf); @@ -1541,24 +1285,32 @@ fail: return 1; } -/* Calculate the real event time based on the buffer boundaries */ -LttTime ltt_interpolate_time(LttTracefile *tf, LttEvent *event) +LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc) { LttTime time; - - g_assert(tf->trace->has_tsc); - -// time = ltt_time_from_uint64( -// cycles_2_ns(tf, (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count))); - time = ltt_time_from_uint64( - (double)(tf->buffer.tsc - tf->trace->start_tsc) * 1000000.0 - / (double)tf->trace->start_freq); - //time = ltt_time_add(tf->buffer.begin.timestamp, time); - time = ltt_time_add(tf->trace->start_time_from_tsc, time); - + + if(tsc > tf->trace->start_tsc) { + time = ltt_time_from_uint64( + (double)(tsc - tf->trace->start_tsc) + * (1000000000.0 / tf->trace->freq_scale) + / (double)tf->trace->start_freq); + time = ltt_time_add(tf->trace->start_time_from_tsc, time); + } else { + time = ltt_time_from_uint64( + (double)(tf->trace->start_tsc - tsc) + * (1000000000.0 / tf->trace->freq_scale) + / (double)tf->trace->start_freq); + time = ltt_time_sub(tf->trace->start_time_from_tsc, time); + } return time; } +/* Calculate the real event time based on the buffer boundaries */ +LttTime ltt_interpolate_time(LttTracefile *tf, LttEvent *event) +{ + return ltt_interpolate_time_from_tsc(tf, tf->buffer.tsc); +} + /* Get the current event of the tracefile : valid until the next read */ LttEvent *ltt_tracefile_get_event(LttTracefile *tf) @@ -1651,6 +1403,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. */ @@ -1658,68 +1442,109 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) { void * pos; LttEvent *event; + void *pos_aligned; event = &tf->event; pos = tf->buffer.head + event->offset; /* Read event header */ - /* Align the head */ - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + /* Align the head */ + if(!tf->compact) + 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->alignment); + } + pos_aligned = pos; - if(tf->trace->has_tsc) { - if(tf->trace->has_heartbeat) { - event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf), - pos); + if(tf->has_heartbeat) { + event->timestamp = ltt_get_uint32(LTT_GET_BO(tf), + pos); + if(!tf->compact) { /* 32 bits -> 64 bits tsc */ /* note : still works for seek and non seek cases. */ - if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) { + if(event->timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) { tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL) + 0x100000000ULL) - | (guint64)event->time.timestamp; + | (guint64)event->timestamp; event->tsc = tf->buffer.tsc; } else { /* no overflow */ tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL) - | (guint64)event->time.timestamp; + | (guint64)event->timestamp; event->tsc = tf->buffer.tsc; + event->compact_data = 0; } - pos += sizeof(guint32); } else { - event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos); - tf->buffer.tsc = event->tsc; - pos += sizeof(guint64); + /* Compact header */ + /* 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->compact_event_bits) - 1); + event->compact_data = event->timestamp >> + (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 */ + event->compact_data = ltt_get_uint32(LTT_GET_BO(tf), &event->compact_data); + event->event_size = 0xFFFF; + //printf("Found compact event %d\n", event->event_id); + //printf("Compact data %d\n", event->compact_data); + event->timestamp = event->timestamp << tf->tsc_lsb_truncate; + event->timestamp = event->timestamp & tf->tsc_mask; + //printf("timestamp 0x%lX\n", event->timestamp); + //printf("mask 0x%llX\n", tf->tsc_mask); + //printf("mask_next 0x%llX\n", tf->tsc_mask_next_bit); + //printf("previous tsc 0x%llX\n", tf->buffer.tsc); + //printf("previous tsc&mask 0x%llX\n", tf->tsc_mask&tf->buffer.tsc); + //printf("previous tsc&(~mask) 0x%llX\n", tf->buffer.tsc&(~tf->tsc_mask)); + if(event->timestamp < (tf->tsc_mask&tf->buffer.tsc)) { + //printf("wrap\n"); + tf->buffer.tsc = ((tf->buffer.tsc&(~tf->tsc_mask)) + + tf->tsc_mask_next_bit) + | (guint64)event->timestamp; + event->tsc = tf->buffer.tsc; + } else { + //printf("no wrap\n"); + /* no overflow */ + tf->buffer.tsc = (tf->buffer.tsc&(~tf->tsc_mask)) + | (guint64)event->timestamp; + event->tsc = tf->buffer.tsc; + } + //printf("current tsc 0x%llX\n", tf->buffer.tsc); } - - event->event_time = ltt_interpolate_time(tf, event); - } else { - event->time.delta.tv_sec = 0; - event->time.delta.tv_nsec = ltt_get_uint32(LTT_GET_BO(tf), - pos) * NSEC_PER_USEC; - tf->buffer.tsc = 0; - event->tsc = tf->buffer.tsc; - - event->event_time = ltt_time_add(tf->buffer.begin.timestamp, - event->time.delta); pos += sizeof(guint32); + } else { + event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos); + tf->buffer.tsc = event->tsc; + event->compact_data = 0; + pos += sizeof(guint64); } + event->event_time = ltt_interpolate_time(tf, event); - event->facility_id = *(guint8*)pos; - pos += sizeof(guint8); + if(!tf->compact) { + event->event_id = ltt_get_uint16(LTT_GET_BO(tf), pos); + pos += sizeof(guint16); - event->event_id = *(guint8*)pos; - pos += sizeof(guint8); + event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos); + pos += sizeof(guint16); + } else { + /* Compact event */ + event->event_size = 0xFFFF; + } - event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos); - pos += sizeof(guint16); - - /* Align the head */ - pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + 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->alignment); event->data = pos; /* get the data size and update the event fields with the current - * information */ + * information. Also update the time if a heartbeat_full event is found. */ ltt_update_event_size(tf); return 0; @@ -1766,7 +1591,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; @@ -1787,12 +1612,19 @@ static gint map_block(LttTracefile * tf, guint block_num) &header->begin.cycle_count); tf->buffer.begin.freq = ltt_get_uint64(LTT_GET_BO(tf), &header->begin.freq); - tf->buffer.begin.timestamp = ltt_time_add( + if(tf->buffer.begin.freq == 0) + tf->buffer.begin.freq = tf->trace->start_freq; + + tf->buffer.begin.timestamp = ltt_interpolate_time_from_tsc(tf, + tf->buffer.begin.cycle_count); +#if 0 + ltt_time_add( ltt_time_from_uint64( (double)(tf->buffer.begin.cycle_count - tf->trace->start_tsc) * 1000000.0 / (double)tf->trace->start_freq), - tf->trace->start_time_from_tsc); + tf->trace->start_time_from_tsc); +#endif //0 #if 0 tf->buffer.end.timestamp = ltt_time_add( @@ -1808,15 +1640,21 @@ static gint map_block(LttTracefile * tf, guint block_num) &header->end.cycle_count); tf->buffer.end.freq = ltt_get_uint64(LTT_GET_BO(tf), &header->end.freq); + if(tf->buffer.end.freq == 0) + tf->buffer.end.freq = tf->trace->start_freq; + tf->buffer.lost_size = ltt_get_uint32(LTT_GET_BO(tf), &header->lost_size); - tf->buffer.end.timestamp = ltt_time_add( + tf->buffer.end.timestamp = ltt_interpolate_time_from_tsc(tf, + tf->buffer.end.cycle_count); +#if 0 + ltt_time_add( ltt_time_from_uint64( (double)(tf->buffer.end.cycle_count - tf->trace->start_tsc) * 1000000.0 / (double)tf->trace->start_freq), tf->trace->start_time_from_tsc); - +#endif //0 tf->buffer.tsc = tf->buffer.begin.cycle_count; tf->event.tsc = tf->buffer.tsc; tf->buffer.freq = tf->buffer.begin.freq; @@ -1846,84 +1684,137 @@ map_error: } -/* It will update the fields offsets too */ -void ltt_update_event_size(LttTracefile *tf) +static void print_debug_event_data(LttEvent *ev) { - off_t size = 0; + unsigned int offset = 0; + int i, j; - /* Specific handling of core events : necessary to read the facility control - * tracefile. */ - 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 = 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; + 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(" "); } - } 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; + + 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"); + } +} - LttEventType *event_type = - ltt_facility_eventtype_get(f, tf->event.event_id); +/* It will update the fields offsets too */ +void ltt_update_event_size(LttTracefile *tf) +{ + off_t size = 0; + char *tscdata; + struct marker_info *info; + + 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->alignment); + size += sizeof(guint16); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + break; + case MARKER_ID_SET_MARKER_FORMAT: + g_debug("marker %s format set", (char*)tf->event.data); + 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"); + break; + 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 = ltt_align(size, sizeof(guint64), tf->alignment); + size += sizeof(guint64); + break; + } - 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; - } - - /* Compute the dynamic offsets */ - compute_offsets(tf, event_type, &size, tf->event.data); + info = marker_get_info_from_id(tf->trace, tf->event.event_id); - //g_debug("Event root field : f.e %hhu.%hhu size %zd", - // tf->event.facility_id, - // tf->event.event_id, size); + 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; /* Check consistency between kernel and LTTV structure sizes */ - g_assert(tf->event.data_size == tf->event.event_size); + 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; + } - return; + if (a_event_debug) + print_debug_event_data(&tf->event); -facility_error: -event_type_error: -event_id_error: - tf->event.data_size = 0; + /* 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); + } } @@ -2042,13 +1933,13 @@ void set_fields_offsets(LttTracefile *tf, LttEventType *event_type) *Function name * get_alignment : Get the alignment needed for a field. *Input params - * tf : tracefile * field : field * * returns : The size on which it must be aligned. * ****************************************************************************/ -off_t get_alignment(LttTracefile *tf, LttField *field) +#if 0 +off_t get_alignment(LttField *field) { LttType *type = &field->field_type; @@ -2070,28 +1961,29 @@ off_t get_alignment(LttTracefile *tf, LttField *field) case LTT_FLOAT: case LTT_ENUM: /* Align offset on type size */ + g_assert(field->field_size != 0); return field->field_size; break; case LTT_STRING: - return 0; + return 1; break; case LTT_ARRAY: g_assert(type->fields->len == 1); { LttField *child = &g_array_index(type->fields, LttField, 0); - return get_alignment(tf, child); + return get_alignment(child); } break; case LTT_SEQUENCE: g_assert(type->fields->len == 2); { - off_t localign = 0; + off_t localign = 1; LttField *child = &g_array_index(type->fields, LttField, 0); - localign = max(localign, get_alignment(tf, child)); + localign = max(localign, get_alignment(child)); child = &g_array_index(type->fields, LttField, 1); - localign = max(localign, get_alignment(tf, child)); + localign = max(localign, get_alignment(child)); return localign; } @@ -2100,11 +1992,11 @@ off_t get_alignment(LttTracefile *tf, LttField *field) case LTT_UNION: { guint i; - off_t localign = 0; + off_t localign = 1; for(i=0; ifields->len; i++) { LttField *child = &g_array_index(type->fields, LttField, i); - localign = max(localign, get_alignment(tf, child)); + localign = max(localign, get_alignment(child)); } return localign; } @@ -2112,10 +2004,12 @@ off_t get_alignment(LttTracefile *tf, LttField *field) case LTT_NONE: default: g_error("get_alignment : unknown type"); + return -1; } - } +#endif //0 + /***************************************************************************** *Function name * field_compute_static_size : Determine the size of fields known by their @@ -2126,8 +2020,8 @@ off_t get_alignment(LttTracefile *tf, LttField *field) * field : field * ****************************************************************************/ - -void field_compute_static_size(LttTracefile *tf, LttField *field) +#if 0 +void field_compute_static_size(LttFacility *fac, LttField *field) { LttType *type = &field->field_type; @@ -2157,7 +2051,7 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) g_assert(type->fields->len == 1); { LttField *child = &g_array_index(type->fields, LttField, 0); - field_compute_static_size(tf, child); + field_compute_static_size(fac, child); if(child->field_size != 0) { field->field_size = type->size * child->field_size; @@ -2173,7 +2067,7 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) { off_t local_offset = 0; LttField *child = &g_array_index(type->fields, LttField, 1); - field_compute_static_size(tf, child); + field_compute_static_size(fac, child); field->field_size = 0; type->size = 0; if(child->field_size != 0) { @@ -2188,10 +2082,10 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) guint i; for(i=0;ifields->len;i++) { LttField *child = &g_array_index(type->fields, LttField, i); - field_compute_static_size(tf, child); + field_compute_static_size(fac, child); if(child->field_size != 0) { - type->size += ltt_align(type->size, get_alignment(tf, child), - tf->has_alignment); + type->size += ltt_align(type->size, get_alignment(child), + fac->alignment); type->size += child->field_size; } else { /* As soon as we find a child with variable size, we have @@ -2208,14 +2102,14 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) } } - +#endif //0 /***************************************************************************** *Function name * precompute_fields_offsets : set the precomputable offset of the fields *Input params - * tf : tracefile + * fac : facility * field : the field * offset : pointer to the current offset, must be incremented * @@ -2223,10 +2117,23 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) * 0 otherwise. ****************************************************************************/ - -gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) +#if 0 +gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, gint is_compact) { LttType *type = &field->field_type; + + if(unlikely(is_compact)) { + g_assert(field->field_size != 0); + /* FIXME THIS IS A HUUUUUGE hack : + * offset is between the compact_data field in struct LttEvent + * and the address of the field root in the memory map. + * ark. Both will stay at the same addresses while the event + * is readable, so it's ok. + */ + field->offset_root = 0; + field->fixed_root = FIELD_FIXED; + return 0; + } switch(type->type_class) { case LTT_INT_FIXED: @@ -2245,9 +2152,10 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) case LTT_OFF_T: case LTT_FLOAT: case LTT_ENUM: + g_assert(field->field_size != 0); /* Align offset on type size */ - *offset += ltt_align(*offset, get_alignment(tf, field), - tf->has_alignment); + *offset += ltt_align(*offset, get_alignment(field), + fac->alignment); /* remember offset */ field->offset_root = *offset; field->fixed_root = FIELD_FIXED; @@ -2265,8 +2173,8 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) { LttField *child = &g_array_index(type->fields, LttField, 0); - *offset += ltt_align(*offset, get_alignment(tf, field), - tf->has_alignment); + *offset += ltt_align(*offset, get_alignment(field), + fac->alignment); /* remember offset */ field->offset_root = *offset; @@ -2292,23 +2200,23 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) LttField *child; guint ret; - *offset += ltt_align(*offset, get_alignment(tf, field), - tf->has_alignment); + *offset += ltt_align(*offset, get_alignment(field), + fac->alignment); /* remember offset */ field->offset_root = *offset; field->fixed_root = FIELD_FIXED; child = &g_array_index(type->fields, LttField, 0); - ret = precompute_fields_offsets(tf, child, offset); + ret = precompute_fields_offsets(fac, child, offset, is_compact); g_assert(ret == 0); /* Seq len cannot have variable len */ child = &g_array_index(type->fields, LttField, 1); - *offset += ltt_align(*offset, get_alignment(tf, child), - tf->has_alignment); + *offset += ltt_align(*offset, get_alignment(child), + fac->alignment); field->array_offset = *offset; - /* Set the offset position at position 0 */ - ret = precompute_fields_offsets(tf, child, offset); + /* Let the child be variable. */ + //ret = precompute_fields_offsets(fac, child, offset); /* Cannot precompute fields offsets of sequence members, and has * variable length. */ @@ -2321,15 +2229,15 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) guint i; gint ret=0; - *offset += ltt_align(*offset, get_alignment(tf, field), - tf->has_alignment); + *offset += ltt_align(*offset, get_alignment(field), + fac->alignment); /* remember offset */ field->offset_root = *offset; field->fixed_root = FIELD_FIXED; for(i=0; i< type->fields->len; i++) { child = &g_array_index(type->fields, LttField, i); - ret = precompute_fields_offsets(tf, child, offset); + ret = precompute_fields_offsets(fac, child, offset, is_compact); if(ret) break; } @@ -2342,8 +2250,8 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) guint i; gint ret=0; - *offset += ltt_align(*offset, get_alignment(tf, field), - tf->has_alignment); + *offset += ltt_align(*offset, get_alignment(field), + fac->alignment); /* remember offset */ field->offset_root = *offset; field->fixed_root = FIELD_FIXED; @@ -2351,7 +2259,7 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) for(i=0; i< type->fields->len; i++) { *offset = field->offset_root; child = &g_array_index(type->fields, LttField, i); - ret = precompute_fields_offsets(tf, child, offset); + ret = precompute_fields_offsets(fac, child, offset, is_compact); if(ret) break; } @@ -2368,7 +2276,9 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) } +#endif //0 +#if 0 /***************************************************************************** *Function name * precompute_offsets : set the precomputable offset of an event type @@ -2377,7 +2287,7 @@ gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) * event : event type * ****************************************************************************/ -void precompute_offsets(LttTracefile *tf, LttEventType *event) +void precompute_offsets(LttFacility *fac, LttEventType *event) { guint i; off_t offset = 0; @@ -2387,17 +2297,20 @@ void precompute_offsets(LttTracefile *tf, LttEventType *event) * arrays, struct and unions, which is not done by the parser */ for(i=0; ifields->len; i++) { LttField *field = &g_array_index(event->fields, LttField, i); - field_compute_static_size(tf, field); + field_compute_static_size(fac, field); } /* Precompute all known offsets */ for(i=0; ifields->len; i++) { LttField *field = &g_array_index(event->fields, LttField, i); - ret = precompute_fields_offsets(tf, field, &offset); + if(event->has_compact_data && i == 0) + ret = precompute_fields_offsets(fac, field, &offset, 1); + else + ret = precompute_fields_offsets(fac, field, &offset, 0); if(ret) break; } } - +#endif //0 @@ -2455,6 +2368,12 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, size_t max_size; switch(type->type_class) { + case LTT_INT_FIXED: + case LTT_UINT_FIXED: + case LTT_CHAR: + case LTT_UCHAR: + case LTT_SHORT: + case LTT_USHORT: case LTT_INT: case LTT_UINT: case LTT_FLOAT: @@ -2555,8 +2474,8 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, max_size = max(max_size, field->child[i]->field_size); } if(final_child_status != FIELD_FIXED) { - g_error("LTTV does not support variable size fields in unions."); - /* This will stop the application. */ + g_error("LTTV does not support variable size fields in unions."); + /* This will stop the application. */ *fixed_root = final_child_status; *fixed_parent = final_child_status; field->field_size = 0; @@ -2566,6 +2485,9 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, field->fixed_size = FIELD_FIXED; } break; + case LTT_NONE: + g_error("unexpected type NONE"); + break; } } @@ -2586,6 +2508,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) @@ -2612,6 +2535,10 @@ gint check_fields_compatibility(LttEventType *event_type1, different = 1; goto end; } + if(type1->network != type2->network) { + different = 1; + goto end; + } switch(type1->type_class) { case LTT_INT_FIXED: @@ -2680,13 +2607,13 @@ gint check_fields_compatibility(LttEventType *event_type1, break; case LTT_NONE: default: - g_error("precompute_fields_offsets : unknown type"); + g_error("check_fields_compatibility : unknown type"); } end: return different; } - +#endif //0 #if 0 gint check_fields_compatibility(LttEventType *event_type1, @@ -2729,6 +2656,13 @@ gint check_fields_compatibility(LttEventType *event_type1, } switch(type1->type_class) { + case LTT_INT_FIXED: + case LTT_UINT_FIXED: + case LTT_POINTER: + case LTT_CHAR: + case LTT_UCHAR: + case LTT_SHORT: + case LTT_USHORT: case LTT_INT: case LTT_UINT: case LTT_FLOAT: @@ -2898,28 +2832,31 @@ 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... */ -static void __attribute__((constructor)) 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"); + LTT_EVENT_NAME_HEARTBEAT_FULL = g_quark_from_string("heartbeat_full"); LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("/control/facilities"); } -