X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=00e3444400e56ca1262e139f59ffe5394a8f6dcc;hb=ae3d0f50f89e7b965795a9b9ad7e1f533f760598;hp=b9ab0b71f2f5d79defa33b0c0e36f08f96ddbc29;hpb=29e7c5b37d76ef85f8d0bebbe3d453c9a14e0d3f;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index b9ab0b71..00e34444 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 @@ -78,28 +78,36 @@ GQuark LTT_TRACEFILE_NAME_FACILITIES; /* 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); +//void set_fields_offsets(LttTracefile *tf, LttEventType *event_type); //size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data); /* get the size of the field type according to * The facility size information. */ +#if 0 static inline void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, off_t offset_root, off_t offset_parent, enum field_status *fixed_root, enum field_status *fixed_parent, LttField *field); +#endif //0 /* map a fixed size or a block information from the file (fd) */ static gint map_block(LttTracefile * tf, guint block_num); /* calculate nsec per cycles for current block */ -static double calc_nsecs_per_cycle(LttTracefile * t); +#if 0 +static guint32 calc_nsecs_per_cycle(LttTracefile * t); +static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles); +#endif //0 /* go to the next event */ static int ltt_seek_next_event(LttTracefile *tf); 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, @@ -176,6 +184,8 @@ static void parser_characters (GMarkupParseContext __UNUSED__ *context, des->description = g_strdup(text); } #endif //0 + + LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, guint num) { @@ -210,6 +220,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; if(t) { t->arch_type = ltt_get_uint32(LTT_GET_BO(tf), @@ -221,8 +232,7 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) t->ltt_minor_version = any->minor_version; t->flight_recorder = any->flight_recorder; t->has_heartbeat = any->has_heartbeat; - t->has_alignment = any->has_alignment; - t->has_tsc = any->has_tsc; + t->freq_scale = any->freq_scale; } @@ -235,10 +245,38 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) tf->buffer_header_size = sizeof(struct ltt_block_start_header) + sizeof(struct ltt_trace_header_0_3); + g_warning("Unsupported trace version : %hhu.%hhu", + any->major_version, any->minor_version); + return 1; + } + break; + case 7: + { + struct ltt_trace_header_0_7 *vheader = + (struct ltt_trace_header_0_7 *)header; + tf->buffer_header_size = + sizeof(struct ltt_block_start_header) + + sizeof(struct ltt_trace_header_0_7); + if(t) { + t->start_freq = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_freq); + t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_tsc); + t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_monotonic); + t->start_time.tv_sec = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_time_sec); + t->start_time.tv_nsec = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_time_usec); + t->start_time.tv_nsec *= 1000; /* microsec to nanosec */ + + t->start_time_from_tsc = ltt_time_from_uint64( + (double)t->start_tsc * 1000000.0 / (double)t->start_freq); + } } break; default: - g_warning("Unsupported trace version : %hhu.%hhu", + g_warning("Unsupported trace version : %hhu.%hhu", any->major_version, any->minor_version); return 1; } @@ -604,9 +642,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, +int get_tracefile_name_number(gchar *raw_name, GQuark *name, - guint *num) + guint *num, + guint *tid, + guint *pgid, + guint64 *creation) { guint raw_name_len = strlen(raw_name); gchar char_name[PATH_MAX]; @@ -614,27 +655,84 @@ 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; - - cpu_num = strtol(raw_name+underscore_pos+1, &endptr, 10); + if(i==-1) { /* Either not found or name length is 0 */ + /* This is a userspace tracefile */ + strncpy(char_name, raw_name, raw_name_len); + *name = g_quark_from_string(char_name); + *num = 0; /* unknown cpu */ + for(i=0;itracefiles, name); if(group == NULL) { @@ -820,6 +923,8 @@ static int ltt_get_facility_description(LttFacility *f, const gchar *text; guint textlen; gint err; + gint arch_spec; + gint fac_name_len; text = g_quark_to_string(t->pathname); textlen = strlen(text); @@ -833,9 +938,21 @@ static int ltt_get_facility_description(LttFacility *f, strcat(desc_file_name, text); text = g_quark_to_string(f->name); - textlen+=strlen(text); + 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); @@ -849,6 +966,41 @@ static int ltt_get_facility_description(LttFacility *f, 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; + 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; @@ -913,6 +1065,7 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) struct LttFacilityLoad *fac_load_data; struct LttStateDumpFacilityLoad *fac_state_dump_load_data; char *fac_name; + void *pos; // FIXME align switch((enum ltt_core_events)tf->event.event_id) { @@ -920,24 +1073,28 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) 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); + pos = (tf->event.data + strlen(fac_name) + 1); + pos += ltt_align((size_t)pos, sizeof(guint32), tf->has_alignment); + fac_load_data = (struct LttFacilityLoad *)pos; + fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id)); - g_assert(fac->exists == 0); + /* 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->alignment); + &fac_load_data->has_alignment); if(ltt_get_facility_description(fac, tf->trace, tf)) continue; /* error opening description */ @@ -947,7 +1104,7 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) /* Preset the field offsets */ for(i=0; ievents->len; i++){ et = &g_array_index(fac->events, LttEventType, i); - set_fields_offsets(tf, et); + precompute_offsets(fac, et); } fac->exists = 1; @@ -972,24 +1129,29 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) 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); + pos = (tf->event.data + strlen(fac_name) + 1); + pos += ltt_align((size_t)pos, sizeof(guint32), tf->has_alignment); + fac_state_dump_load_data = (struct LttStateDumpFacilityLoad *)pos; + fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, ltt_get_uint32(LTT_GET_BO(tf), &fac_state_dump_load_data->id)); - g_assert(fac->exists == 0); + /* 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 = fac_state_dump_load_data->id; + 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->alignment); + &fac_state_dump_load_data->has_alignment); if(ltt_get_facility_description(fac, tf->trace, tf)) continue; /* error opening description */ @@ -998,7 +1160,7 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) /* Preset the field offsets */ for(i=0; ievents->len; i++){ et = &g_array_index(fac->events, LttEventType, i); - set_fields_offsets(tf, et); + precompute_offsets(fac, et); } fac->exists = 1; @@ -1330,11 +1492,25 @@ GQuark ltt_tracefile_long_name(const LttTracefile *tf) -guint ltt_tracefile_num(LttTracefile *tf) +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 ****************************************************************************/ @@ -1485,6 +1661,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); @@ -1498,21 +1678,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( - (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count) * - tf->buffer.nsecs_per_cycle); - time = ltt_time_add(tf->buffer.begin.timestamp, 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) @@ -1618,45 +1809,32 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) /* Read event header */ - //TODO align + /* Align the head */ + pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - if(tf->trace->has_tsc) { - if(tf->trace->has_heartbeat) { - event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf), - pos); - /* 32 bits -> 64 bits tsc */ - /* note : still works for seek and non seek cases. */ - if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) { - tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL) - + 0x100000000ULL) - | (guint64)event->time.timestamp; - event->tsc = tf->buffer.tsc; - } else { - /* no overflow */ - tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL) - | (guint64)event->time.timestamp; - event->tsc = tf->buffer.tsc; - } - pos += sizeof(guint32); - } else { - event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos); - tf->buffer.tsc = event->tsc; - pos += sizeof(guint64); - } - - event->event_time = ltt_interpolate_time(tf, event); - } 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); - } - + if(tf->trace->has_heartbeat) { + event->timestamp = ltt_get_uint32(LTT_GET_BO(tf), + pos); + /* 32 bits -> 64 bits tsc */ + /* note : still works for seek and non seek cases. */ + if(event->timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) { + tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL) + + 0x100000000ULL) + | (guint64)event->timestamp; + event->tsc = tf->buffer.tsc; + } else { + /* no overflow */ + tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL) + | (guint64)event->timestamp; + event->tsc = tf->buffer.tsc; + } + pos += sizeof(guint32); + } else { + event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos); + tf->buffer.tsc = event->tsc; + pos += sizeof(guint64); + } + event->event_time = ltt_interpolate_time(tf, event); event->facility_id = *(guint8*)pos; pos += sizeof(guint8); @@ -1666,6 +1844,9 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) 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); + event->data = pos; /* get the data size and update the event fields with the current @@ -1723,25 +1904,66 @@ static gint map_block(LttTracefile * tf, guint block_num) header = (struct ltt_block_start_header*)tf->buffer.head; - tf->buffer.begin.timestamp = ltt_get_time(LTT_GET_BO(tf), - &header->begin.timestamp); - tf->buffer.begin.timestamp.tv_nsec *= NSEC_PER_USEC; +#if 0 + tf->buffer.begin.timestamp = ltt_time_add( + ltt_time_from_uint64( + ltt_get_uint64(LTT_GET_BO(tf), + &header->begin.timestamp) + - tf->trace->start_monotonic), + tf->trace->start_time); +#endif //0 //g_debug("block %u begin : %lu.%lu", block_num, // tf->buffer.begin.timestamp.tv_sec, tf->buffer.begin.timestamp.tv_nsec); tf->buffer.begin.cycle_count = ltt_get_uint64(LTT_GET_BO(tf), &header->begin.cycle_count); - tf->buffer.end.timestamp = ltt_get_time(LTT_GET_BO(tf), - &header->end.timestamp); - tf->buffer.end.timestamp.tv_nsec *= NSEC_PER_USEC; + tf->buffer.begin.freq = ltt_get_uint64(LTT_GET_BO(tf), + &header->begin.freq); + 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); +#endif //0 +#if 0 + + tf->buffer.end.timestamp = ltt_time_add( + ltt_time_from_uint64( + ltt_get_uint64(LTT_GET_BO(tf), + &header->end.timestamp) + - tf->trace->start_monotonic), + tf->trace->start_time); +#endif //0 //g_debug("block %u end : %lu.%lu", block_num, // tf->buffer.end.timestamp.tv_sec, tf->buffer.end.timestamp.tv_nsec); tf->buffer.end.cycle_count = ltt_get_uint64(LTT_GET_BO(tf), &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); - + &header->lost_size); + 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; /* FIXME * eventually support variable buffer size : will need a partial pre-read of @@ -1752,7 +1974,8 @@ static gint map_block(LttTracefile * tf, guint block_num) /* Now that the buffer is mapped, calculate the time interpolation for the * block. */ - tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf); +// tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf); + //tf->buffer.cyc2ns_scale = calc_nsecs_per_cycle(tf); /* Make the current event point to the beginning of the buffer : * it means that the event read must get the first event. */ @@ -1770,7 +1993,7 @@ map_error: /* It will update the fields offsets too */ void ltt_update_event_size(LttTracefile *tf) { - ssize_t size = 0; + off_t size = 0; /* Specific handling of core events : necessary to read the facility control * tracefile. */ @@ -1782,6 +2005,7 @@ void ltt_update_event_size(LttTracefile *tf) 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 += ltt_align(size, sizeof(guint32), tf->has_alignment); size += sizeof(struct LttFacilityLoad); break; case LTT_EVENT_FACILITY_UNLOAD: @@ -1790,6 +2014,7 @@ void ltt_update_event_size(LttTracefile *tf) break; case LTT_EVENT_STATE_DUMP_FACILITY_LOAD: size = strlen((char*)tf->event.data) + 1; + size += ltt_align(size, sizeof(guint32), tf->has_alignment); //g_debug("Update Event facility load state dump of facility %s", // (char*)tf->event.data); size += sizeof(struct LttStateDumpFacilityLoad); @@ -1808,7 +2033,7 @@ void ltt_update_event_size(LttTracefile *tf) } } else { if(!f->exists) { - g_error("Unknown facility %hhu (0x%hhx) in tracefile %s", + g_warning("Unknown facility %hhu (0x%hhx) in tracefile %s", tf->event.facility_id, tf->event.facility_id, g_quark_to_string(tf->name)); @@ -1819,18 +2044,15 @@ void ltt_update_event_size(LttTracefile *tf) ltt_facility_eventtype_get(f, tf->event.event_id); if(!event_type) { - g_error("Unknown event id %hhu in facility %s in tracefile %s", + 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; } - - if(event_type->root_field) - size = get_field_type_size(tf, event_type, - 0, 0, event_type->root_field, tf->event.data); - else - size = 0; + + /* 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, @@ -1840,6 +2062,10 @@ void ltt_update_event_size(LttTracefile *tf) 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; + } g_assert(tf->event.data_size == tf->event.event_size); return; @@ -1847,7 +2073,12 @@ void ltt_update_event_size(LttTracefile *tf) facility_error: event_type_error: event_id_error: - tf->event.data_size = 0; + 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; } @@ -1901,34 +2132,33 @@ error: return ENOPROTOOPT; } - +#if 0 /***************************************************************************** *Function name * calc_nsecs_per_cycle : calculate nsecs per cycle for current block + * + * 1.0 / (freq(khz) *1000) * 1000000000 *Input Params * t : tracefile ****************************************************************************/ - -static double calc_nsecs_per_cycle(LttTracefile * tf) +/* from timer_tsc.c */ +#define CYC2NS_SCALE_FACTOR 10 +static guint32 calc_nsecs_per_cycle(LttTracefile * tf) { - LttTime lBufTotalTime; /* Total time for this buffer */ - double lBufTotalNSec; /* Total time for this buffer in nsecs */ - LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */ - - /* Calculate the total time for this buffer */ - lBufTotalTime = ltt_time_sub(tf->buffer.end.timestamp, - tf->buffer.begin.timestamp); - - /* Calculate the total cycles for this bufffer */ - lBufTotalCycle = tf->buffer.end.cycle_count; - lBufTotalCycle -= tf->buffer.begin.cycle_count; - - /* Convert the total time to double */ - lBufTotalNSec = ltt_time_to_double(lBufTotalTime); + //return 1e6 / (double)tf->buffer.freq; + guint32 cpu_mhz = tf->buffer.freq / 1000; + guint32 cyc2ns_scale = (1000 << CYC2NS_SCALE_FACTOR)/cpu_mhz; - return lBufTotalNSec / (double)lBufTotalCycle; + return cyc2ns_scale; + // return 1e6 / (double)tf->buffer.freq; +} +static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles) +{ + return (cycles * tf->buffer.cyc2ns_scale) >> CYC2NS_SCALE_FACTOR; } +#endif //0 + #if 0 void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD) { @@ -1940,7 +2170,7 @@ void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD) evT, 0,0,rootFld, evD); } #endif //0 - +#if 0 /***************************************************************************** *Function name * set_fields_offsets : set the precomputable offset of the fields @@ -1960,6 +2190,370 @@ void set_fields_offsets(LttTracefile *tf, LttEventType *event_type) field); } +#endif //0 + + +/***************************************************************************** + *Function name + * get_alignment : Get the alignment needed for a field. + *Input params + * field : field + * + * returns : The size on which it must be aligned. + * + ****************************************************************************/ +off_t get_alignment(LttField *field) +{ + LttType *type = &field->field_type; + + switch(type->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_LONG: + case LTT_ULONG: + case LTT_SIZE_T: + case LTT_SSIZE_T: + case LTT_OFF_T: + case LTT_FLOAT: + case LTT_ENUM: + /* Align offset on type size */ + return field->field_size; + break; + case LTT_STRING: + return 0; + break; + case LTT_ARRAY: + g_assert(type->fields->len == 1); + { + LttField *child = &g_array_index(type->fields, LttField, 0); + return get_alignment(child); + } + break; + case LTT_SEQUENCE: + g_assert(type->fields->len == 2); + { + off_t localign = 0; + LttField *child = &g_array_index(type->fields, LttField, 0); + + localign = max(localign, get_alignment(child)); + + child = &g_array_index(type->fields, LttField, 1); + localign = max(localign, get_alignment(child)); + + return localign; + } + break; + case LTT_STRUCT: + case LTT_UNION: + { + guint i; + off_t localign = 0; + + for(i=0; ifields->len; i++) { + LttField *child = &g_array_index(type->fields, LttField, i); + localign = max(localign, get_alignment(child)); + } + return localign; + } + break; + case LTT_NONE: + default: + g_error("get_alignment : unknown type"); + } + +} + +/***************************************************************************** + *Function name + * field_compute_static_size : Determine the size of fields known by their + * sole definition. Unions, arrays and struct sizes might be known, but + * the parser does not give that information. + *Input params + * tf : tracefile + * field : field + * + ****************************************************************************/ + +void field_compute_static_size(LttFacility *fac, LttField *field) +{ + LttType *type = &field->field_type; + + switch(type->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_LONG: + case LTT_ULONG: + case LTT_SIZE_T: + case LTT_SSIZE_T: + case LTT_OFF_T: + case LTT_FLOAT: + case LTT_ENUM: + case LTT_STRING: + /* nothing to do */ + break; + case LTT_ARRAY: + /* note this : array type size is the number of elements in the array, + * while array field size of the length of the array in bytes */ + g_assert(type->fields->len == 1); + { + LttField *child = &g_array_index(type->fields, LttField, 0); + field_compute_static_size(fac, child); + + if(child->field_size != 0) { + field->field_size = type->size * child->field_size; + field->dynamic_offsets = g_array_sized_new(FALSE, TRUE, + sizeof(off_t), type->size); + } else { + field->field_size = 0; + } + } + break; + case LTT_SEQUENCE: + g_assert(type->fields->len == 2); + { + off_t local_offset = 0; + LttField *child = &g_array_index(type->fields, LttField, 1); + field_compute_static_size(fac, child); + field->field_size = 0; + type->size = 0; + if(child->field_size != 0) { + field->dynamic_offsets = g_array_sized_new(FALSE, TRUE, + sizeof(off_t), SEQUENCE_AVG_ELEMENTS); + } + } + break; + case LTT_STRUCT: + case LTT_UNION: + { + guint i; + for(i=0;ifields->len;i++) { + LttField *child = &g_array_index(type->fields, LttField, i); + field_compute_static_size(fac, child); + if(child->field_size != 0) { + 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 + * a variable size */ + type->size = 0; + break; + } + } + field->field_size = type->size; + } + break; + default: + g_error("field_static_size : unknown type"); + } + +} + + + +/***************************************************************************** + *Function name + * precompute_fields_offsets : set the precomputable offset of the fields + *Input params + * fac : facility + * field : the field + * offset : pointer to the current offset, must be incremented + * + * return : 1 : found a variable length field, stop the processing. + * 0 otherwise. + ****************************************************************************/ + + +gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset) +{ + LttType *type = &field->field_type; + + switch(type->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_LONG: + case LTT_ULONG: + case LTT_SIZE_T: + case LTT_SSIZE_T: + 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(field), + fac->alignment); + /* remember offset */ + field->offset_root = *offset; + field->fixed_root = FIELD_FIXED; + /* Increment offset */ + *offset += field->field_size; + return 0; + break; + case LTT_STRING: + field->offset_root = *offset; + field->fixed_root = FIELD_FIXED; + return 1; + break; + case LTT_ARRAY: + g_assert(type->fields->len == 1); + { + LttField *child = &g_array_index(type->fields, LttField, 0); + + *offset += ltt_align(*offset, get_alignment(field), + fac->alignment); + + /* remember offset */ + field->offset_root = *offset; + field->array_offset = *offset; + field->fixed_root = FIELD_FIXED; + + /* Let the child be variable */ + //precompute_fields_offsets(tf, child, offset); + + if(field->field_size != 0) { + /* Increment offset */ + /* field_size is the array size in bytes */ + *offset += field->field_size; + return 0; + } else { + return 1; + } + } + break; + case LTT_SEQUENCE: + g_assert(type->fields->len == 2); + { + LttField *child; + guint ret; + + *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(fac, child, offset); + g_assert(ret == 0); /* Seq len cannot have variable len */ + + child = &g_array_index(type->fields, LttField, 1); + *offset += ltt_align(*offset, get_alignment(child), + fac->alignment); + field->array_offset = *offset; + /* Let the child be variable. */ + //ret = precompute_fields_offsets(fac, child, offset); + + /* Cannot precompute fields offsets of sequence members, and has + * variable length. */ + return 1; + } + break; + case LTT_STRUCT: + { + LttField *child; + guint i; + gint ret=0; + + *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(fac, child, offset); + + if(ret) break; + } + return ret; + } + break; + case LTT_UNION: + { + LttField *child; + guint i; + gint ret=0; + + *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++) { + *offset = field->offset_root; + child = &g_array_index(type->fields, LttField, i); + ret = precompute_fields_offsets(fac, child, offset); + + if(ret) break; + } + *offset = field->offset_root + field->field_size; + return ret; + } + + break; + case LTT_NONE: + default: + g_error("precompute_fields_offsets : unknown type"); + return 1; + } + +} + + +/***************************************************************************** + *Function name + * precompute_offsets : set the precomputable offset of an event type + *Input params + * tf : tracefile + * event : event type + * + ****************************************************************************/ +void precompute_offsets(LttFacility *fac, LttEventType *event) +{ + guint i; + off_t offset = 0; + gint ret; + + /* First, compute the size of fixed size fields. Will determine size for + * 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(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(fac, field, &offset); + if(ret) break; + } +} + + /***************************************************************************** @@ -1974,6 +2568,15 @@ void set_fields_offsets(LttTracefile *tf, LttEventType *event_type) * fixed_parent : Do we know a fixed offset to the parent ? * field : field ****************************************************************************/ + + + +// preset the fixed size offsets. Calculate them just like genevent-new : an +// increment of a *to value that represents the offset from the start of the +// event data. +// The preset information is : offsets up to (and including) the first element +// of variable size. All subsequent fields must be flagged "VARIABLE OFFSET". +#if 0 void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, off_t offset_root, off_t offset_parent, enum field_status *fixed_root, enum field_status *fixed_parent, @@ -2107,6 +2710,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. */ *fixed_root = final_child_status; *fixed_parent = final_child_status; field->field_size = 0; @@ -2119,7 +2724,7 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, } } - +#endif //0 /***************************************************************************** *Function name @@ -2133,6 +2738,116 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, *Returns : 0 if identical * 1 if not. ****************************************************************************/ +// 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. +gint check_fields_compatibility(LttEventType *event_type1, + LttEventType *event_type2, + LttField *field1, LttField *field2) +{ + guint different = 0; + LttType *type1; + LttType *type2; + + if(field1 == NULL) { + if(field2 == NULL) goto end; + else { + different = 1; + goto end; + } + } else if(field2 == NULL) { + different = 1; + goto end; + } + + type1 = &field1->field_type; + type2 = &field2->field_type; + + if(type1->type_class != type2->type_class) { + different = 1; + goto end; + } + if(type1->network != type2->network) { + different = 1; + goto end; + } + + 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_LONG: + case LTT_ULONG: + case LTT_SIZE_T: + case LTT_SSIZE_T: + case LTT_OFF_T: + case LTT_FLOAT: + case LTT_ENUM: + if(field1->field_size != field2->field_size) + different = 1; + break; + case LTT_STRING: + break; + case LTT_ARRAY: + { + LttField *child1 = &g_array_index(type1->fields, LttField, 0); + LttField *child2 = &g_array_index(type2->fields, LttField, 0); + + if(type1->size != type2->size) + different = 1; + if(check_fields_compatibility(event_type1, event_type2, child1, child2)) + different = 1; + } + break; + case LTT_SEQUENCE: + { + LttField *child1 = &g_array_index(type1->fields, LttField, 1); + LttField *child2 = &g_array_index(type2->fields, LttField, 1); + + if(check_fields_compatibility(event_type1, event_type2, child1, child2)) + different = 1; + } + break; + case LTT_STRUCT: + case LTT_UNION: + { + LttField *child; + guint i; + + if(type1->fields->len != type2->fields->len) { + different = 1; + goto end; + } + + for(i=0; i< type1->fields->len; i++) { + LttField *child1; + LttField *child2; + child1 = &g_array_index(type1->fields, LttField, i); + child2 = &g_array_index(type2->fields, LttField, i); + different = check_fields_compatibility(event_type1, + event_type2, child1, child2); + + if(different) break; + } + } + break; + case LTT_NONE: + default: + g_error("precompute_fields_offsets : unknown type"); + } + +end: + return different; +} + + +#if 0 gint check_fields_compatibility(LttEventType *event_type1, LttEventType *event_type2, LttField *field1, LttField *field2) @@ -2245,176 +2960,9 @@ gint check_fields_compatibility(LttEventType *event_type1, end: return different; } - - - - -#if 0 -/***************************************************************************** - *Function name - * getFieldtypeSize: get the size of the field type (primitive type) - *Input params - * evT : event type - * offsetRoot : offset from the root - * offsetParent : offset from the parrent - * fld : field - * evD : event data, it may be NULL - *Return value - * int : size of the field - ****************************************************************************/ - -static inline gint getFieldtypeSize(LttTracefile *tf, - LttEventType * evT, gint offsetRoot, - gint offsetParent, LttField * fld, void *evD) -{ - gint size, size1, element_number, i, offset1, offset2; - LttType * type = fld->field_type; - - /* This likely has been tested with gcov : half of them.. */ - if(unlikely(fld->field_fixed == 1)){ - /* tested : none */ - if(unlikely(fld == evT->root_field)) { - size = fld->field_size; - goto end_getFieldtypeSize; - } - } - - /* From gcov profiling : half string, half struct, can we gain something - * from that ? (Mathieu) */ - switch(type->type_class) { - case LTT_ARRAY: - element_number = (int) type->element_number; - if(fld->field_fixed == -1){ - size = getFieldtypeSize(tf, evT, offsetRoot, - 0,fld->child[0], NULL); - if(size == 0){ //has string or sequence - fld->field_fixed = 0; - }else{ - fld->field_fixed = 1; - size *= element_number; - } - }else if(fld->field_fixed == 0){// has string or sequence - size = 0; - for(i=0;ichild[0], evD+size); - } - }else size = fld->field_size; - if(unlikely(!evD)){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - } - - break; - - case LTT_SEQUENCE: - size1 = (int) ltt_type_size(fac, type); - if(fld->field_fixed == -1){ - fld->sequ_number_size = size1; - fld->field_fixed = 0; - size = getFieldtypeSize(evT, offsetRoot, - 0,fld->child[0], NULL); - fld->element_size = size; - }else{//0: sequence - element_number = getIntNumber(tf,size1,evD); - type->element_number = element_number; - if(fld->element_size > 0){ - size = element_number * fld->element_size; - }else{//sequence has string or sequence - size = 0; - for(i=0;ichild[0], evD+size+size1); - } - } - size += size1; - } - if(unlikely(!evD)){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - } - - break; - - case LTT_STRING: - size = 0; - if(fld->field_fixed == -1){ - fld->field_fixed = 0; - }else{//0: string - /* Hope my implementation is faster than strlen (Mathieu) */ - char *ptr=(char*)evD; - size = 1; - /* from gcov : many many strings are empty, make it the common case.*/ - while(unlikely(*ptr != '\0')) { size++; ptr++; } - //size = ptr - (char*)evD + 1; //include end : '\0' - } - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - - break; - - case LTT_STRUCT: - element_number = (int) type->element_number; - size = 0; - /* tested with gcov */ - if(unlikely(fld->field_fixed == -1)){ - offset1 = offsetRoot; - offset2 = 0; - for(i=0;ichild[i], NULL); - if(likely(size1 > 0 && size >= 0)){ - size += size1; - if(likely(offset1 >= 0)) offset1 += size1; - offset2 += size1; - }else{ - size = -1; - offset1 = -1; - offset2 = -1; - } - } - if(unlikely(size == -1)){ - fld->field_fixed = 0; - size = 0; - }else fld->field_fixed = 1; - }else if(likely(fld->field_fixed == 0)){ - offset1 = offsetRoot; - offset2 = 0; - for(i=0;unlikely(ichild[i], evD+offset2); - offset1 += size; - offset2 += size; - } - size = offset2; - }else size = fld->field_size; - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - break; - - default: - if(unlikely(fld->field_fixed == -1)){ - size = (int) ltt_type_size(LTT_GET_BO(tf), type); - fld->field_fixed = 1; - }else size = fld->field_size; - if(unlikely(!evD)){ - fld->fixed_root = (offsetRoot==-1) ? 0 : 1; - fld->fixed_parent = (offsetParent==-1) ? 0 : 1; - } - break; - } - - fld->offset_root = offsetRoot; - fld->offset_parent = offsetParent; - fld->field_size = size; - -end_getFieldtypeSize: - - return size; -} #endif //0 + /***************************************************************************** *Function name * ltt_get_int : get an integer number @@ -2497,13 +3045,17 @@ char * ltt_trace_system_description_description (LttSystemDescription * s) } -/* get the start time of the trace */ - -LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s) +/* get the NTP corrected start time of the trace */ +LttTime ltt_trace_start_time(LttTrace *t) { - return s->trace_start; + return t->start_time; } +/* get the monotonic start time of the trace */ +LttTime ltt_trace_start_time_monotonic(LttTrace *t) +{ + return t->start_time_from_tsc; +} LttTracefile *ltt_tracefile_new() {