X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=8ac4b5061de96a70269dfedc3a539642d55c11cd;hb=f63ebe5196f36fcf40385d29cfc37288c4d70817;hp=ec5152f3b7174bf0d65e46e835970177e6fe10d5;hpb=f104d082727461632e7a5cc1d2a854f0ad66db07;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index ec5152f3..8ac4b506 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,6 +34,7 @@ #include #include #include +#include // For realpath #include @@ -53,7 +54,8 @@ /* 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 @@ -105,6 +107,9 @@ 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, @@ -229,7 +234,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_tsc = any->has_tsc; + t->compact_facilities = NULL; } @@ -247,26 +252,75 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) return 1; } break; - case 4: + case 7: { - struct ltt_trace_header_0_4 *vheader = - (struct ltt_trace_header_0_4 *)header; + 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_4); + + sizeof(struct ltt_trace_header_0_7); + tf->tsc_lsb_truncate = 0; + tf->tscbits = 32; + tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits; + tf->tsc_mask = (1ULL<<32)-1; + tf->tsc_mask_next_bit = (1ULL<<32); if(t) { t->start_freq = ltt_get_uint64(LTT_GET_BO(tf), &vheader->start_freq); + t->freq_scale = ltt_get_uint32(LTT_GET_BO(tf), + &vheader->freq_scale); t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf), &vheader->start_tsc); t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf), &vheader->start_monotonic); - t->start_time = 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); + t->compact_event_bits = 0; + } + } + break; + case 8: + { + struct ltt_trace_header_0_8 *vheader = + (struct ltt_trace_header_0_8 *)header; + tf->buffer_header_size = + sizeof(struct ltt_block_start_header) + + sizeof(struct ltt_trace_header_0_8); + tf->tsc_lsb_truncate = vheader->tsc_lsb_truncate; + tf->tscbits = vheader->tscbits; + tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits; + 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); + t->start_tsc = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_tsc); + t->start_monotonic = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_monotonic); + t->start_time.tv_sec = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_time_sec); + t->start_time.tv_nsec = ltt_get_uint64(LTT_GET_BO(tf), + &vheader->start_time_usec); + t->start_time.tv_nsec *= 1000; /* microsec to nanosec */ + + t->start_time_from_tsc = ltt_time_from_uint64( + (double)t->start_tsc + * (1000000000.0 / tf->trace->freq_scale) + / (double)t->start_freq); + t->compact_event_bits = 0; } } break; @@ -637,9 +691,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]; @@ -647,27 +704,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; - - 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); + char_name[raw_name_len] = '\0'; + *name = g_quark_from_string(char_name); + *num = 0; /* unknown cpu */ + for(i=0;itracefiles, name); if(group == NULL) { /* Elements are automatically cleared when the array is allocated. @@ -853,6 +977,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); @@ -866,9 +992,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); @@ -882,6 +1020,47 @@ 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; + case LTT_ARCH_TYPE_C2: + text = "_c2"; + break; + case LTT_ARCH_TYPE_POWERPC: + text = "_powerpc"; + break; + default: + g_error("Trace from unsupported architecture."); + } + textlen+=strlen(text); + if(textlen >= PATH_MAX) goto name_error; + strcat(desc_file_name, text); + } + text = ".xml"; textlen+=strlen(text); if(textlen >= PATH_MAX) goto name_error; @@ -946,6 +1125,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) { @@ -953,9 +1133,10 @@ 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, tf->trace->arch_size, tf->has_alignment); + fac_load_data = (struct LttFacilityLoad *)pos; + fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id)); /* facility may already exist if trace is paused/unpaused */ @@ -966,14 +1147,14 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) 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->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 */ @@ -983,7 +1164,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); - precompute_offsets(tf, et); + precompute_offsets(fac, et); } fac->exists = 1; @@ -1008,9 +1189,10 @@ 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, tf->trace->arch_size, tf->has_alignment); + fac_state_dump_load_data = (struct LttStateDumpFacilityLoad *)pos; + fac = &g_array_index (tf->trace->facilities_by_num, LttFacility, ltt_get_uint32(LTT_GET_BO(tf), &fac_state_dump_load_data->id)); /* facility may already exist if trace is paused/unpaused */ @@ -1022,14 +1204,14 @@ static int ltt_process_facility_tracefile(LttTracefile *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->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 */ @@ -1038,7 +1220,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); - precompute_offsets(tf, et); + precompute_offsets(fac, et); } fac->exists = 1; @@ -1052,10 +1234,13 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) fac_ids, ltt_fac_ids_destroy); } g_array_append_val(fac_ids, fac->id); + g_debug("fac id : %u", fac->id); break; case LTT_EVENT_HEARTBEAT: break; + case LTT_EVENT_HEARTBEAT_FULL: + break; default: g_warning("Error in processing facility file %s, " "unknown event id %hhu in core facility.", @@ -1166,7 +1351,31 @@ LttTrace *ltt_trace_open(const gchar *pathname) if(ltt_process_facility_tracefile(tf)) goto facilities_error; } - + t->compact_facilities = ltt_trace_facility_get_by_name(t, + g_quark_from_string("compact")); + if(!t->compact_facilities) + t->compact_facilities = ltt_trace_facility_get_by_name(t, + g_quark_from_string("flight-compact")); + if (t->compact_facilities) { + /* FIXME : currently does not support unload/load of compact + * facility during tracing. Should check for the currently loaded + * version of the facility. */ + g_assert(t->compact_facilities->len == 1); + g_assert(t->compact_facilities); + { + guint facility_id = g_array_index(t->compact_facilities, guint, 0); + LttFacility *fac = ltt_trace_facility_by_id(t, facility_id); + unsigned int num = ltt_facility_eventtype_number(fac); + /* Could be done much quicker, but not on much used code path */ + if(num) { + t->compact_event_bits = 1; + while(num >>= 1) + t->compact_event_bits++; + } else + t->compact_event_bits = 0; + } + } + return t; /* Error handling */ @@ -1370,11 +1579,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 ****************************************************************************/ @@ -1525,6 +1748,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); @@ -1538,24 +1765,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) @@ -1662,61 +1897,99 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) /* Read event header */ /* Align the head */ - pos += ltt_align(pos, tf->trace->arch_size, tf->has_alignment); + if(!tf->compact) + pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + else { + g_assert(tf->trace->has_heartbeat); + pos += ltt_align((size_t)pos, sizeof(uint32_t), tf->has_alignment); + } - if(tf->trace->has_tsc) { - if(tf->trace->has_heartbeat) { - event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf), - pos); + if(tf->trace->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->trace->compact_event_bits) - 1); + event->compact_data = event->timestamp >> + (tf->trace->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->facility_id = g_array_index(tf->trace->compact_facilities, guint, 0); } - - 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); - } + 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->facility_id = *(guint8*)pos; + pos += sizeof(guint8); - event->event_id = *(guint8*)pos; - pos += sizeof(guint8); + event->event_id = *(guint8*)pos; + pos += sizeof(guint8); - event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos); - pos += sizeof(guint16); - + event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos); + pos += sizeof(guint16); + } else { + /* Compact event */ + } /* Align the head */ - pos += ltt_align(pos, tf->trace->arch_size, tf->has_alignment); + if(!tf->compact) + 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 - * information */ + * information. Also update the time if a heartbeat_full event is found. */ ltt_update_event_size(tf); return 0; @@ -1784,12 +2057,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( @@ -1805,15 +2085,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,81 +2132,110 @@ map_error: /* It will update the fields offsets too */ void ltt_update_event_size(LttTracefile *tf) { - size_t size = 0; - - /* Specific handling of core events : necessary to read the facility control - * tracefile. */ + off_t size = 0; 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; - - } - } else { - if(!f->exists) { - g_error("Unknown facility %hhu (0x%hhx) in tracefile %s", + char *tscdata; + + if(!f->exists) { + /* Specific handling of core events : necessary to read the facility control + * tracefile. */ + + if(likely(tf->event.facility_id == LTT_FACILITY_CORE)) { + switch((enum ltt_core_events)tf->event.event_id) { + case LTT_EVENT_FACILITY_LOAD: + 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: + //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; + 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); + break; + case LTT_EVENT_HEARTBEAT: + //g_debug("Update Event heartbeat"); + size = sizeof(TimeHeartbeat); + break; + case LTT_EVENT_HEARTBEAT_FULL: + //g_debug("Update Event heartbeat full"); + tscdata = (char*)(tf->event.data); + tf->event.tsc = ltt_get_uint64(LTT_GET_BO(tf), tscdata); + tf->buffer.tsc = tf->event.tsc; + tf->event.event_time = ltt_interpolate_time(tf, &tf->event); + size = sizeof(TimeHeartbeatFull); + size += ltt_align(size, sizeof(guint64), tf->has_alignment); + 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; + + } + goto no_offset; /* Skip the field computation */ + } else { + g_warning("Unknown facility %hhu (0x%hhx) in tracefile %s", tf->event.facility_id, tf->event.facility_id, g_quark_to_string(tf->name)); goto facility_error; } + } - LttEventType *event_type = - ltt_facility_eventtype_get(f, tf->event.event_id); - - if(!event_type) { - g_error("Unknown event id %hhu in facility %s in tracefile %s", - tf->event.event_id, - g_quark_to_string(f->name), - g_quark_to_string(tf->name)); - goto event_type_error; - } - - /* Compute the dynamic offsets */ - compute_offsets(tf, event_type, &size, tf->event.data); + LttEventType *event_type = + ltt_facility_eventtype_get(f, 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(!event_type) { + g_warning("Unknown event id %hhu in facility %s in tracefile %s", + tf->event.event_id, + g_quark_to_string(f->name), + g_quark_to_string(tf->name)); + goto event_type_error; } + /* Compute the dynamic offsets */ + compute_offsets(tf, f, event_type, &size, tf->event.data); + + //g_debug("Event root field : f.e %hhu.%hhu size %zd", + // tf->event.facility_id, + // tf->event.event_id, size); + +no_offset: tf->event.data_size = size; /* Check consistency between kernel and LTTV structure sizes */ - 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; + } + if (tf->event.data_size != tf->event.event_size) { + g_error("Kernel/LTTV event size differs for event %s.%s: kernel %u, LTTV %u", + g_quark_to_string(f->name), g_quark_to_string(event_type->name), + tf->event.event_size, tf->event.data_size); + exit(-1); + } + //g_assert(tf->event.data_size == tf->event.event_size); return; 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; } @@ -2039,15 +2354,14 @@ 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) +off_t get_alignment(LttField *field) { - type = &field->field_type; + LttType *type = &field->field_type; switch(type->type_class) { case LTT_INT_FIXED: @@ -2067,28 +2381,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; } @@ -2097,11 +2412,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; } @@ -2109,8 +2424,8 @@ off_t get_alignment(LttTracefile *tf, LttField *field) case LTT_NONE: default: g_error("get_alignment : unknown type"); + return -1; } - } /***************************************************************************** @@ -2124,9 +2439,9 @@ off_t get_alignment(LttTracefile *tf, LttField *field) * ****************************************************************************/ -void field_compute_static_size(LttTracefile *tf, LttField *field) +void field_compute_static_size(LttFacility *fac, LttField *field) { - type = &field->field_type; + LttType *type = &field->field_type; switch(type->type_class) { case LTT_INT_FIXED: @@ -2154,7 +2469,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; @@ -2168,9 +2483,9 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) case LTT_SEQUENCE: g_assert(type->fields->len == 2); { - local_offset = 0; + 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) { @@ -2185,10 +2500,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 @@ -2202,6 +2517,7 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) break; default: g_error("field_static_size : unknown type"); + } } @@ -2211,7 +2527,7 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) *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 * @@ -2220,9 +2536,22 @@ void field_compute_static_size(LttTracefile *tf, LttField *field) ****************************************************************************/ -gint precompute_fields_offsets(LttTracefile *tf, LttField *field, off_t *offset) +gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, gint is_compact) { - type = &field->field_type; + 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: @@ -2241,9 +2570,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; @@ -2261,8 +2591,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; @@ -2288,23 +2618,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. */ @@ -2317,15 +2647,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; } @@ -2338,8 +2668,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; @@ -2347,7 +2677,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; } @@ -2373,7 +2703,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; @@ -2383,13 +2713,16 @@ 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; } } @@ -2451,6 +2784,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: @@ -2562,6 +2901,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; } } @@ -2587,6 +2929,8 @@ gint check_fields_compatibility(LttEventType *event_type1, LttField *field1, LttField *field2) { guint different = 0; + LttType *type1; + LttType *type2; if(field1 == NULL) { if(field2 == NULL) goto end; @@ -2599,17 +2943,17 @@ gint check_fields_compatibility(LttEventType *event_type1, goto end; } - type1 = field1->field_type; - type2 = field2->field_type; + type1 = &field1->field_type; + type2 = &field2->field_type; if(type1->type_class != type2->type_class) { different = 1; goto end; } - if(type1->element_name != type2->element_name) { - different = 1; - goto end; - } + if(type1->network != type2->network) { + different = 1; + goto end; + } switch(type1->type_class) { case LTT_INT_FIXED: @@ -2665,6 +3009,8 @@ gint check_fields_compatibility(LttEventType *event_type1, } 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, @@ -2676,7 +3022,7 @@ 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: @@ -2725,6 +3071,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: @@ -2915,6 +3268,7 @@ static void __attribute__((constructor)) 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"); }