X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=e7e213dc9d843b2dfd28d7f2ce9c57d30ee4d7a9;hb=f5d7967f8c41e4f380d3ea7c4304e68ab5bad8ec;hp=de046b165d7dd146df7d8d711fa766d1dbe99537;hpb=e939e5b28722833093a9ae3bede5314359e56080;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index de046b16..e7e213dc 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -106,7 +106,7 @@ static int ltt_seek_next_event(LttTracefile *tf); void ltt_update_event_size(LttTracefile *tf); -void precompute_offsets(LttTracefile *tf, LttEventType *event); +void precompute_offsets(LttFacility *fac, LttEventType *event); #if 0 /* Functions to parse system.xml file (using glib xml parser) */ @@ -250,36 +250,13 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) return 1; } break; - case 4: + case 6: { - struct ltt_trace_header_0_4 *vheader = - (struct ltt_trace_header_0_4 *)header; + struct ltt_trace_header_0_6 *vheader = + (struct ltt_trace_header_0_6 *)header; tf->buffer_header_size = sizeof(struct ltt_block_start_header) - + sizeof(struct ltt_trace_header_0_4); - 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 = ltt_get_time(LTT_GET_BO(tf), - &vheader->start_time); - 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; - case 5: - { - struct ltt_trace_header_0_5 *vheader = - (struct ltt_trace_header_0_5 *)header; - tf->buffer_header_size = - sizeof(struct ltt_block_start_header) - + sizeof(struct ltt_trace_header_0_5); + + sizeof(struct ltt_trace_header_0_6); if(t) { t->start_freq = ltt_get_uint64(LTT_GET_BO(tf), &vheader->start_freq); @@ -881,6 +858,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); @@ -894,9 +873,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); @@ -910,6 +901,39 @@ 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"; + case LTT_ARCH_TYPE_PPC64: + text = "_ppc64"; + 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; @@ -974,6 +998,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) { @@ -981,9 +1006,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, 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)); /* facility may already exist if trace is paused/unpaused */ @@ -1011,7 +1037,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; @@ -1036,9 +1062,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, 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)); /* facility may already exist if trace is paused/unpaused */ @@ -1066,7 +1093,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; @@ -1886,6 +1913,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: @@ -1894,6 +1922,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); @@ -1931,7 +1960,7 @@ void ltt_update_event_size(LttTracefile *tf) } /* Compute the dynamic offsets */ - compute_offsets(tf, event_type, &size, tf->event.data); + 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, @@ -2067,13 +2096,12 @@ 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) { LttType *type = &field->field_type; @@ -2104,7 +2132,7 @@ off_t get_alignment(LttTracefile *tf, LttField *field) 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: @@ -2113,10 +2141,10 @@ off_t get_alignment(LttTracefile *tf, LttField *field) off_t localign = 0; 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; } @@ -2129,7 +2157,7 @@ off_t get_alignment(LttTracefile *tf, LttField *field) 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; } @@ -2152,7 +2180,7 @@ 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) { LttType *type = &field->field_type; @@ -2182,7 +2210,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; @@ -2198,7 +2226,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) { @@ -2213,10 +2241,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 @@ -2240,7 +2268,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 * @@ -2249,7 +2277,7 @@ 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) { LttType *type = &field->field_type; @@ -2270,9 +2298,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; @@ -2290,8 +2319,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; @@ -2317,23 +2346,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); 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. */ @@ -2346,15 +2375,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); if(ret) break; } @@ -2367,8 +2396,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; @@ -2376,7 +2405,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); if(ret) break; } @@ -2402,7 +2431,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; @@ -2412,13 +2441,13 @@ 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); + ret = precompute_fields_offsets(fac, field, &offset); if(ret) break; } }