From 3c165eaf5aa1e60ce88c036cfb692ce3e1d81585 Mon Sep 17 00:00:00 2001 From: compudj Date: Wed, 29 Aug 2007 14:07:19 +0000 Subject: [PATCH] libltt compiles git-svn-id: http://ltt.polymtl.ca/svn@2595 04897980-b3bd-0310-b5e0-8ef037075253 --- ltt/branches/poly/ltt/Makefile.am | 4 +- ltt/branches/poly/ltt/event.c | 58 +-- ltt/branches/poly/ltt/event.h | 11 +- ltt/branches/poly/ltt/ltt-private.h | 56 +-- ltt/branches/poly/ltt/markers.c | 416 ++++++++++++++++++++- ltt/branches/poly/ltt/markers.h | 67 +++- ltt/branches/poly/ltt/tracefile.c | 353 ++++++----------- ltt/branches/poly/ltt/type.c | 16 - ltt/branches/poly/lttv/lttv/hook.h | 4 - ltt/branches/poly/lttv/lttv/tracecontext.c | 54 +-- ltt/branches/poly/lttv/lttv/tracecontext.h | 19 +- 11 files changed, 604 insertions(+), 454 deletions(-) diff --git a/ltt/branches/poly/ltt/Makefile.am b/ltt/branches/poly/ltt/Makefile.am index e6d6aa12..75574118 100644 --- a/ltt/branches/poly/ltt/Makefile.am +++ b/ltt/branches/poly/ltt/Makefile.am @@ -10,13 +10,13 @@ AM_CFLAGS = $(GLIB_CFLAGS) LIBS += $(GLIB_LIBS) lib_LTLIBRARIES = liblttvtraceread.la -liblttvtraceread_la_SOURCES = event.c facility.c parser.c tracefile.c type.c +liblttvtraceread_la_SOURCES = event.c parser.c tracefile.c type.c markers.c noinst_HEADERS = parser.h ltt-private.h lttinclude_HEADERS = \ compiler.h\ event.h\ - facility.h\ + markers.h\ ltt.h\ time.h\ trace.h\ diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c index 0c208c48..0e87646e 100644 --- a/ltt/branches/poly/ltt/event.c +++ b/ltt/branches/poly/ltt/event.c @@ -35,11 +35,12 @@ #include #include #include - +#include void compute_fields_offsets(LttTracefile *tf, - LttFacility *fac, LttField *field, off_t *offset, void *root, guint is_compact); + LttFacility *fac, LttField *field, off_t *offset, void *root, + guint is_compact); LttEvent *ltt_event_new() @@ -63,9 +64,9 @@ void ltt_event_destroy(LttEvent *event) * unsigned : event type id ****************************************************************************/ -unsigned ltt_event_eventtype_id(const LttEvent *e) +uint16_t ltt_event_eventtype_id(const LttEvent *e) { - return (unsigned) e->event_id; + return e->event_id; } /***************************************************************************** @@ -74,51 +75,14 @@ unsigned ltt_event_eventtype_id(const LttEvent *e) *Input params * e : an instance of an event type *Return value - * LttFacility * : the facility of the event - ****************************************************************************/ - -LttFacility *ltt_event_facility(const LttEvent *e) -{ - LttTrace * trace = e->tracefile->trace; - unsigned id = e->facility_id; - LttFacility *facility = ltt_trace_facility_by_id(trace,id); - - g_assert(facility->exists); - - return facility; -} - -/***************************************************************************** - *Function name - * ltt_event_facility_id : get the facility id of the event - *Input params - * e : an instance of an event type - *Return value - * unsigned : the facility of the event + * struct marker_info *: the marker associated with the event ****************************************************************************/ -unsigned ltt_event_facility_id(const LttEvent *e) +struct marker_info *ltt_event_marker(const LttEvent *e) { - return e->facility_id; + return marker_get_info_from_id(e->tracefile->trace, e->event_id); } -/***************************************************************************** - *Function name - * ltt_event_eventtype : get the event type of the event - *Input params - * e : an instance of an event type - *Return value - * LttEventType * : the event type of the event - ****************************************************************************/ - -LttEventType *ltt_event_eventtype(const LttEvent *e) -{ - LttFacility* facility = ltt_event_facility(e); - if(!facility) return NULL; - return &g_array_index(facility->events, LttEventType, e->event_id); -} - - /***************************************************************************** *Function name * ltt_event_time : get the time of the event @@ -147,8 +111,6 @@ LttCycleCount ltt_event_cycle_count(const LttEvent *e) return e->tsc; } - - /***************************************************************************** *Function name * ltt_event_position_get : get the event position data @@ -568,7 +530,7 @@ char *ltt_event_get_string(LttEvent *e, LttField *f) * offset : pointer to the current offset, must be incremented ****************************************************************************/ - +#if 0 void compute_fields_offsets(LttTracefile *tf, LttFacility *fac, LttField *field, off_t *offset, void *root, guint is_compact) { @@ -775,4 +737,4 @@ void compute_offsets(LttTracefile *tf, LttFacility *fac, } } - +#endif //0 diff --git a/ltt/branches/poly/ltt/event.h b/ltt/branches/poly/ltt/event.h index e91875e5..79ceed52 100644 --- a/ltt/branches/poly/ltt/event.h +++ b/ltt/branches/poly/ltt/event.h @@ -23,6 +23,7 @@ #include #include #include +#include LttEvent *ltt_event_new(); @@ -36,18 +37,12 @@ void ltt_event_destroy(LttEvent *event); /* Obtain the trace unique integer id associated with the type of this event */ -unsigned ltt_event_eventtype_id(const LttEvent *e); +uint16_t ltt_event_eventtype_id(const LttEvent *e); -unsigned ltt_event_facility_id(const LttEvent *e); - -/* Facility and type for the event */ - -LttFacility *ltt_event_facility(const LttEvent *e); +struct marker_info *ltt_event_marker(const LttEvent *e); LttEventType *ltt_event_eventtype(const LttEvent *e); - - /* Time and cycle count for the event */ LttTime ltt_event_time(const LttEvent *e); diff --git a/ltt/branches/poly/ltt/ltt-private.h b/ltt/branches/poly/ltt/ltt-private.h index b1e69c0d..8d862840 100644 --- a/ltt/branches/poly/ltt/ltt-private.h +++ b/ltt/branches/poly/ltt/ltt-private.h @@ -137,15 +137,13 @@ typedef struct _TimeHeartbeatFull { struct ltt_event_header_hb { uint32_t timestamp; - unsigned char facility_id; - unsigned char event_id; + uint16_t event_id; uint16_t event_size; } LTT_PACKED_STRUCT; struct ltt_event_header_nohb { uint64_t timestamp; - unsigned char facility_id; - unsigned char event_id; + uint16_t event_id; uint16_t event_size; } LTT_PACKED_STRUCT; @@ -166,47 +164,7 @@ struct ltt_trace_header_any { uint32_t freq_scale; } LTT_PACKED_STRUCT; - -/* For version 0.3 */ - -struct ltt_trace_header_0_3 { - uint32_t magic_number; - uint32_t arch_type; - uint32_t arch_variant; - uint32_t float_word_order; - uint8_t arch_size; - uint8_t major_version; - uint8_t minor_version; - uint8_t flight_recorder; - uint8_t has_heartbeat; - uint8_t has_alignment; /* Event header alignment */ - uint32_t freq_scale; -} LTT_PACKED_STRUCT; - -/* For version 0.7 */ - -struct ltt_trace_header_0_7 { - uint32_t magic_number; - uint32_t arch_type; - uint32_t arch_variant; - uint32_t float_word_order; - uint8_t arch_size; - uint8_t major_version; - uint8_t minor_version; - uint8_t flight_recorder; - uint8_t has_heartbeat; - uint8_t has_alignment; /* Event header alignment */ - uint32_t freq_scale; - uint64_t start_freq; - uint64_t start_tsc; - uint64_t start_monotonic; - uint64_t start_time_sec; - uint64_t start_time_usec; -} LTT_PACKED_STRUCT; - -/* For version 0.8 */ - -struct ltt_trace_header_0_8 { +struct ltt_trace_header_1_0 { uint32_t magic_number; uint32_t arch_type; uint32_t arch_variant; @@ -265,7 +223,7 @@ struct _LttEventType{ GQuark name; gchar * description; guint index; //id of the event type within the facility - LttFacility * facility; //the facility that contains the event type + struct marker_info *info; GArray * fields; //event's fields (LttField) GData *fields_by_name; int has_compact_data; //event header contains compact data (first field) @@ -287,8 +245,7 @@ struct _LttEvent{ guint32 timestamp; /* truncated timestamp */ - unsigned char facility_id; /* facility ID are never reused. */ - unsigned char event_id; + guint16 event_id; LttTime event_time; @@ -335,6 +292,7 @@ struct _LttField{ // contain variable length fields. }; +#if 0 struct _LttFacility{ LttTrace *trace; GQuark name; @@ -353,6 +311,7 @@ struct _LttFacility{ unsigned char exists; /* 0 does not exist, 1 exists */ }; +#endif //0 typedef struct _LttBuffer { void * head; @@ -446,7 +405,6 @@ struct _LttTrace{ uint64_t start_monotonic; LttTime start_time; LttTime start_time_from_tsc; - GArray *compact_facilities; uint8_t compact_event_bits; GData *tracefiles; //tracefiles groups diff --git a/ltt/branches/poly/ltt/markers.c b/ltt/branches/poly/ltt/markers.c index e760a256..ec9ad591 100644 --- a/ltt/branches/poly/ltt/markers.c +++ b/ltt/branches/poly/ltt/markers.c @@ -6,12 +6,376 @@ */ #include +#include +#include +#include #include #include +#include #define DEFAULT_MARKERS_NUM 100 +#define DEFAULT_FIELDS_NUM 1 +#define MAX_NAME_LEN 1024 -int marker_format_event(LttTrace *trace, const char *name, const char *format) +static inline const char *parse_trace_type(struct marker_info *info, + const char *fmt, + char *trace_size, enum ltt_type *trace_type, + unsigned long *attributes) +{ + int qualifier; /* 'h', 'l', or 'L' for integer fields */ + /* 'z' support added 23/7/1999 S.H. */ + /* 'z' changed to 'Z' --davidm 1/25/99 */ + /* 't' added for ptrdiff_t */ + + /* parse attributes. */ + repeat: + switch (*fmt) { + case 'b': + *attributes |= LTT_ATTRIBUTE_COMPACT; + ++fmt; + goto repeat; + case 'n': + *attributes |= LTT_ATTRIBUTE_NETWORK_BYTE_ORDER; + ++fmt; + goto repeat; + } + + /* get the conversion qualifier */ + qualifier = -1; + if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || + *fmt =='Z' || *fmt == 'z' || *fmt == 't' || + *fmt == 'S' || *fmt == '1' || *fmt == '2' || + *fmt == '4' || *fmt == 8) { + qualifier = *fmt; + ++fmt; + if (qualifier == 'l' && *fmt == 'l') { + qualifier = 'L'; + ++fmt; + } + } + + switch (*fmt) { + case 'c': + *trace_type = LTT_TYPE_UNSIGNED_INT; + *trace_size = sizeof(char); + goto parse_end; + case 's': + *trace_type = LTT_TYPE_STRING; + goto parse_end; + case 'p': + *trace_type = LTT_TYPE_UNSIGNED_INT; + *trace_size = info->pointer_size; + goto parse_end; + case 'd': + case 'i': + *trace_type = LTT_TYPE_SIGNED_INT; + break; + case 'o': + case 'u': + case 'x': + case 'X': + *trace_type = LTT_TYPE_UNSIGNED_INT; + break; + default: + if (!*fmt) + --fmt; + goto parse_end; + } + switch (qualifier) { + case 'L': + *trace_size = sizeof(long long); + break; + case 'l': + *trace_size = info->long_size; + break; + case 'Z': + case 'z': + *trace_size = info->size_t_size; + break; + case 't': + *trace_size = info->pointer_size; + break; + case 'h': + *trace_size = sizeof(short); + break; + case '1': + *trace_size = sizeof(uint8_t); + break; + case '2': + *trace_size = sizeof(guint16); + break; + case '4': + *trace_size = sizeof(uint32_t); + break; + case '8': + *trace_size = sizeof(uint64_t); + break; + default: + *trace_size = info->int_size; + } + +parse_end: + return fmt; +} + +/* + * Restrictions: + * Field width and precision are *not* supported. + * %n not supported. + */ +__attribute__((no_instrument_function)) +static inline const char *parse_c_type(struct marker_info *info, + const char *fmt, + char *c_size, enum ltt_type *c_type) +{ + int qualifier; /* 'h', 'l', or 'L' for integer fields */ + /* 'z' support added 23/7/1999 S.H. */ + /* 'z' changed to 'Z' --davidm 1/25/99 */ + /* 't' added for ptrdiff_t */ + + /* process flags : ignore standard print formats for now. */ + repeat: + switch (*fmt) { + case '-': + case '+': + case ' ': + case '#': + case '0': + ++fmt; + goto repeat; + } + + /* get the conversion qualifier */ + qualifier = -1; + if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || + *fmt =='Z' || *fmt == 'z' || *fmt == 't' || + *fmt == 'S') { + qualifier = *fmt; + ++fmt; + if (qualifier == 'l' && *fmt == 'l') { + qualifier = 'L'; + ++fmt; + } + } + + switch (*fmt) { + case 'c': + *c_type = LTT_TYPE_UNSIGNED_INT; + *c_size = sizeof(unsigned char); + goto parse_end; + case 's': + *c_type = LTT_TYPE_STRING; + goto parse_end; + case 'p': + *c_type = LTT_TYPE_UNSIGNED_INT; + *c_size = info->pointer_size; + goto parse_end; + case 'd': + case 'i': + *c_type = LTT_TYPE_SIGNED_INT; + break; + case 'o': + case 'u': + case 'x': + case 'X': + *c_type = LTT_TYPE_UNSIGNED_INT; + break; + default: + if (!*fmt) + --fmt; + goto parse_end; + } + switch (qualifier) { + case 'L': + *c_size = sizeof(long long); + break; + case 'l': + *c_size = info->long_size; + break; + case 'Z': + case 'z': + *c_size = info->size_t_size; + break; + case 't': + *c_size = info->pointer_size; + break; + case 'h': + *c_size = sizeof(short); + break; + default: + *c_size = info->int_size; + } + +parse_end: + return fmt; +} + +static inline long add_type(struct marker_info *info, + long offset, const char *name, + char trace_size, enum ltt_type trace_type, + char c_size, enum ltt_type c_type, unsigned long attributes, + unsigned int field_count) +{ + struct marker_field *field; + char tmpname[MAX_NAME_LEN]; + + info->fields = g_array_set_size(info->fields, info->fields->len+1); + field = &g_array_index(info->fields, struct marker_field, + info->fields->len-1); + if (name) + field->name = g_quark_from_string(name); + else { + snprintf(tmpname, MAX_NAME_LEN-1, "field %u", field_count); + field->name = g_quark_from_string(tmpname); + } + field->type = trace_type; + + switch (trace_type) { + case LTT_TYPE_SIGNED_INT: + case LTT_TYPE_UNSIGNED_INT: + field->size = trace_size; + field->alignment = trace_size; + field->attributes = attributes; + if (offset == -1) { + field->offset = -1; + field->static_offset = 0; + return -1; + } else { + field->offset = offset + ltt_align(offset, field->alignment, + info->alignment); + field->static_offset = 1; + return field->offset + trace_size; + } + case LTT_TYPE_STRING: + field->offset = offset; + field->size = 0; /* Variable length, size is 0 */ + field->alignment = 1; + if (offset == -1) + field->static_offset = 0; + else + field->static_offset = 1; + return -1; + default: + g_error("Unexpected type"); //FIXME: compact type + return 0; + } +} + +long marker_update_fields_offsets(struct marker_info *info, const char *data) +{ + struct marker_field *field; + unsigned int i; + long offset = 0; + + for (i = 0; i < info->fields->len; i++) { + field = &g_array_index(info->fields, struct marker_field, i); + + if (field->static_offset) + continue; + + switch (field->type) { + case LTT_TYPE_SIGNED_INT: + case LTT_TYPE_UNSIGNED_INT: + field->offset = offset + ltt_align(offset, field->alignment, + info->alignment); + offset = field->offset + field->size; + break; + case LTT_TYPE_STRING: + field->offset = offset; + offset = offset + strlen(&data[offset]) + 1; + // not aligning on pointer size, breaking genevent backward compatibility. + break; + default: + g_error("Unexpected type"); //FIXME: compact type + return -1; + } + } + return offset; +} + +static void format_parse(const char *fmt, struct marker_info *info) +{ + char trace_size = 0, c_size = 0; /* + * 0 (unset), 1, 2, 4, 8 bytes. + */ + enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE; + unsigned long attributes = 0; + long offset = 0; + const char *name_begin = NULL, *name_end = NULL; + char *name = NULL; + unsigned int field_count = 1; + + for (; *fmt ; ++fmt) { + switch (*fmt) { + case '#': + /* tracetypes (#) */ + ++fmt; /* skip first '#' */ + if (*fmt == '#') /* Escaped ## */ + break; + attributes = 0; + fmt = parse_trace_type(info, fmt, &trace_size, &trace_type, + &attributes); + break; + case '%': + /* c types (%) */ + ++fmt; /* skip first '%' */ + if (*fmt == '%') /* Escaped %% */ + break; + fmt = parse_c_type(info, fmt, &c_size, &c_type); + /* + * Output c types if no trace types has been + * specified. + */ + if (!trace_size) + trace_size = c_size; + if (trace_type == LTT_TYPE_NONE) + trace_type = c_type; + if (c_type == LTT_TYPE_STRING) + trace_type = LTT_TYPE_STRING; + /* perform trace write */ + offset = add_type(info, offset, name, trace_size, + trace_type, c_size, c_type, attributes, field_count++); + trace_size = c_size = 0; + trace_type = c_size = LTT_TYPE_NONE; + attributes = 0; + name_begin = NULL; + if (name) { + g_free(name); + name = NULL; + } + break; + case ' ': + if (!name_end) { + name_end = fmt; + if (name) + g_free(name); + name = g_new(char, name_end - name_begin + 1); + memcpy(name, name_begin, name_end - name_begin); + name[name_end - name_begin] = '\0'; + } + break; /* Skip white spaces */ + default: + if (!name) { + name_begin = fmt; + name_end = NULL; + } + } + } + info->size = offset; + if (name) + g_free(name); +} + +int marker_parse_format(const char *format, struct marker_info *info) +{ + if (info->fields) + g_array_free(info->fields, TRUE); + info->fields = g_array_sized_new(FALSE, TRUE, + sizeof(struct marker_field), DEFAULT_FIELDS_NUM); + format_parse(format, info); +} + +int marker_format_event(LttTrace *trace, GQuark name, const char *format) { struct marker_info *info; @@ -20,25 +384,38 @@ int marker_format_event(LttTrace *trace, const char *name, const char *format) g_error("Got marker format %s, but marker name %s has no ID yet. " "Kernel issue.", format, name); - if (info->format) - g_free(info->format); - info->format = g_new(char, strlen(format)+1); - strcpy(info->format, format); - /* TODO deal with format string */ + for (; info != NULL; info = info->next) { + if (info->format) + g_free(info->format); + info->format = g_new(char, strlen(format)+1); + strcpy(info->format, format); + if (marker_parse_format(format, info)) + g_error("Error parsing marker format %s for marker %s", format, + g_quark_to_string(name)); + } } -int marker_id_event(LttTrace *trace, const char *name, uint16_t id) +int marker_id_event(LttTrace *trace, GQuark name, guint16 id, + uint8_t int_size, uint8_t long_size, uint8_t pointer_size, + uint8_t size_t_size, uint8_t alignment) { - struct marker_info *info; + struct marker_info *info, *head; if (trace->markers->len < id) trace->markers = g_array_set_size(trace->markers, id+1); info = &g_array_index(trace->markers, struct marker_info, id); - if (info->name) - g_free(info->name); - info->name = g_new(char, strlen(name)+1); - strcpy(info->name, name); - g_hash_table_insert(trace->markers_hash, (gpointer)name, info); + info->name = name; + info->int_size = int_size; + info->long_size = long_size; + info->pointer_size = pointer_size; + info->size_t_size = size_t_size; + info->alignment = alignment; + info->next = NULL; + head = g_hash_table_lookup(trace->markers_hash, (gconstpointer)name); + if (!head) + g_hash_table_insert(trace->markers_hash, (gpointer)name, info); + else + head->next = info; } int allocate_marker_data(LttTrace *trace) @@ -46,20 +423,25 @@ int allocate_marker_data(LttTrace *trace) /* Init array to 0 */ trace->markers = g_array_sized_new(FALSE, TRUE, sizeof(struct marker_info), DEFAULT_MARKERS_NUM); - trace->markers_hash = g_hash_table_new(g_str_hash, g_str_equal); + if (!trace->markers) + return -ENOMEM; + trace->markers_hash = g_hash_table_new(g_direct_hash, g_direct_equal); + if (!trace->markers_hash) + return -ENOMEM; + return 0; } -int destroy_marker_data(LttTrace *trace) +void destroy_marker_data(LttTrace *trace) { unsigned int i; struct marker_info *info; for (i=0; imarkers->len; i++) { info = &g_array_index(trace->markers, struct marker_info, i); - if (info->name) - g_free(info->name); if (info->format) g_free(info->format); + if (info->fields) + g_array_free(info->fields, TRUE); } g_array_free(trace->markers, TRUE); g_hash_table_destroy(trace->markers_hash); diff --git a/ltt/branches/poly/ltt/markers.h b/ltt/branches/poly/ltt/markers.h index 32a9080e..b5aa3125 100644 --- a/ltt/branches/poly/ltt/markers.h +++ b/ltt/branches/poly/ltt/markers.h @@ -1,17 +1,53 @@ +#ifndef _LTT_MARKERS_H +#define _LTT_MARKERS_H + /* * Marker support header. * - * Mathieu Desnoyers, Auguest 2007 + * Mathieu Desnoyers, August 2007 * License: LGPL. */ +#include #include #include +#include + +enum ltt_type { + LTT_TYPE_SIGNED_INT, + LTT_TYPE_UNSIGNED_INT, + LTT_TYPE_STRING, + LTT_TYPE_COMPACT, + LTT_TYPE_NONE, +}; + +#define LTT_ATTRIBUTE_COMPACT (1<<0) +#define LTT_ATTRIBUTE_NETWORK_BYTE_ORDER (1<<1) + +/* static ids 0-7 reserved for internal use. */ +#define MARKER_CORE_IDS 8 +/* dynamic ids 8-127 reserved for compact events. */ +#define MARKER_COMPACT_IDS 128 + +struct marker_info; struct marker_info { - char *name; - char *format; - unsigned long size; /* size if known statically, else 0 */ + GQuark name; + char *format; + long size; /* size if known statically, else -1 */ + GArray *fields; /* Array of struct marker_field */ + guint8 int_size, long_size, pointer_size, size_t_size, alignment; + struct marker_info *next; /* Linked list of markers with the same name */ +}; + +struct marker_field { + GQuark name; + enum ltt_type type; + unsigned long offset; /* offset in the event data */ + unsigned long size; + unsigned long alignment; + unsigned long attributes; + int static_offset; }; enum marker_id { @@ -23,7 +59,7 @@ enum marker_id { MARKER_ID_DYNAMIC, /* Dynamic IDs (range: 128-65535) */ }; -static inline uint16_t marker_get_id_from_info(LttTrace *trace, +static inline guint16 marker_get_id_from_info(LttTrace *trace, struct marker_info *info) { return ((unsigned long)info - (unsigned long)trace->markers->data) @@ -31,14 +67,27 @@ static inline uint16_t marker_get_id_from_info(LttTrace *trace, } static inline struct marker_info *marker_get_info_from_id(LttTrace *trace, - uint16_t id) + guint16 id) { if (unlikely(trace->markers->len < id)) return NULL; return &g_array_index(trace->markers, struct marker_info, id); } -int marker_format_event(LttTrace *trace, const char *name, const char *format); -int marker_id_event(LttTrace *trace, const char *name, uint16_t id); +/* + * Returns the head of the marker info list for that name. + */ +static inline struct marker_info *marker_get_info_from_name(LttTrace *trace, + GQuark name) +{ + return g_hash_table_lookup(trace->markers_hash, (gconstpointer)name); +} + +int marker_format_event(LttTrace *trace, GQuark name, const char *format); +int marker_id_event(LttTrace *trace, GQuark name, guint16 id, + uint8_t int_size, uint8_t long_size, uint8_t pointer_size, + uint8_t size_t_size, uint8_t alignment); int allocate_marker_data(LttTrace *trace); -int destroy_marker_data(LttTrace *trace); +void destroy_marker_data(LttTrace *trace); + +#endif //_LTT_MARKERS_H diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 7e4c6469..d58ef3eb 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -105,10 +105,19 @@ static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles); /* go to the next event */ static int ltt_seek_next_event(LttTracefile *tf); -void ltt_update_event_size(LttTracefile *tf); +//void ltt_update_event_size(LttTracefile *tf); - -void precompute_offsets(LttFacility *fac, LttEventType *event); +static int open_tracefiles(LttTrace *trace, gchar *root_path, + gchar *relative_path); +static int ltt_process_facility_tracefile(LttTracefile *tf); +static void ltt_tracefile_time_span_get(LttTracefile *tf, + LttTime *start, LttTime *end); +static void group_time_span_get(GQuark name, gpointer data, gpointer user_data); +static gint map_block(LttTracefile * tf, guint block_num); +static int ltt_seek_next_event(LttTracefile *tf); +static void __attribute__((constructor)) init(void); +static void ltt_update_event_size(LttTracefile *tf); +//void precompute_offsets(LttFacility *fac, LttEventType *event); #if 0 /* Functions to parse system.xml file (using glib xml parser) */ @@ -187,7 +196,7 @@ static void parser_characters (GMarkupParseContext __UNUSED__ *context, } #endif //0 - +#if 0 LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, guint num) { @@ -196,6 +205,7 @@ LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, return &g_array_index(t->facilities_by_num, LttFacility, num); } +#endif //0 guint ltt_trace_get_num_cpu(LttTrace *t) { @@ -234,66 +244,26 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) t->ltt_major_version = any->major_version; t->ltt_minor_version = any->minor_version; t->flight_recorder = any->flight_recorder; - t->compact_facilities = NULL; + // t->compact_facilities = NULL; } switch(any->major_version) { case 0: + g_warning("Unsupported trace version : %hhu.%hhu", + any->major_version, any->minor_version); + return 1; + break; + case 1: switch(any->minor_version) { - case 3: + case 0: { + struct ltt_trace_header_1_0 *vheader = + (struct ltt_trace_header_1_0 *)header; tf->buffer_header_size = sizeof(struct ltt_block_start_header) - + sizeof(struct ltt_trace_header_0_3); - g_warning("Unsupported trace version : %hhu.%hhu", - any->major_version, any->minor_version); - return 1; - } - break; - case 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); - 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.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; - 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); + + sizeof(struct ltt_trace_header_1_0); tf->tsc_lsb_truncate = vheader->tsc_lsb_truncate; tf->tscbits = vheader->tscbits; tf->tsc_msb_cutoff = 32 - tf->tsc_lsb_truncate - tf->tscbits; @@ -326,11 +296,10 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t) break; default: g_warning("Unsupported trace version : %hhu.%hhu", - any->major_version, any->minor_version); + any->major_version, any->minor_version); return 1; } break; - default: g_warning("Unsupported trace version : %hhu.%hhu", any->major_version, any->minor_version); @@ -831,7 +800,8 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data) for(i=0; ilen; i++) { tf = &g_array_index (group, LttTracefile, i); - if(tf->cpu_online) return 1; + if(tf->cpu_online) + return 1; } return 0; } @@ -848,8 +818,7 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data) * A tracefile group is simply an array where all the per cpu tracefiles sit. */ -static int open_tracefiles(LttTrace *trace, gchar *root_path, - gchar *relative_path) +int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path) { DIR *dir = opendir(root_path); struct dirent *entry; @@ -968,7 +937,7 @@ static int open_tracefiles(LttTrace *trace, gchar *root_path, * * Returns 0 on success, or 1 on failure. */ - +#if 0 static int ltt_get_facility_description(LttFacility *f, LttTrace *t, LttTracefile *fac_tf) @@ -1082,11 +1051,11 @@ static void ltt_fac_ids_destroy(gpointer data) g_array_free(fac_ids, TRUE); } - +#endif //0 /* Presumes the tracefile is already seeked at the beginning. It makes sense, * because it must be done just after the opening */ -static int ltt_process_facility_tracefile(LttTracefile *tf) +int ltt_process_facility_tracefile(LttTracefile *tf) { int err; LttFacility *fac; @@ -1113,137 +1082,63 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) * 2 : state dump facility load * 3 : heartbeat */ - if(tf->event.facility_id != LTT_FACILITY_CORE) { + if(tf->event.event_id >= MARKER_CORE_IDS) { /* Should only contain core facility */ g_warning("Error in processing facility file %s, " - "should not contain facility id %u.", g_quark_to_string(tf->name), - tf->event.facility_id); + "should not contain event id %u.", g_quark_to_string(tf->name), + tf->event.event_id); err = EPERM; - goto fac_id_error; + goto event_id_error; } else { - struct LttFacilityLoad *fac_load_data; - struct LttStateDumpFacilityLoad *fac_state_dump_load_data; - char *fac_name; void *pos; + const char *marker_name, *format; + uint16_t id; + guint8 int_size, long_size, pointer_size, size_t_size, alignment; // FIXME align - switch((enum ltt_core_events)tf->event.event_id) { - case LTT_EVENT_FACILITY_LOAD: - fac_name = (char*)(tf->event.data); - g_debug("Doing LTT_EVENT_FACILITY_LOAD of facility %s", - fac_name); - pos = (tf->event.data + strlen(fac_name) + 1); + switch((enum marker_id)tf->event.event_id) { + case MARKER_ID_SET_MARKER_ID: + marker_name = (char*)(tf->event.data); + g_debug("Doing MARKER_ID_SET_MARKER_ID of marker %s", marker_name); + pos = (tf->event.data + strlen(marker_name) + 1); pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - 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 */ - if(fac->exists) continue; - fac->name = g_quark_from_string(fac_name); - fac->checksum = ltt_get_uint32(LTT_GET_BO(tf), - &fac_load_data->checksum); - fac->id = ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id); - fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_load_data->pointer_size); - fac->int_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_load_data->int_size); - fac->long_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_load_data->long_size); - fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_load_data->size_t_size); - fac->alignment = ltt_get_uint32(LTT_GET_BO(tf), - &fac_load_data->has_alignment); - - if(ltt_get_facility_description(fac, tf->trace, tf)) - continue; /* error opening description */ - - fac->trace = tf->trace; - - /* Preset the field offsets */ - for(i=0; ievents->len; i++){ - et = &g_array_index(fac->events, LttEventType, i); - precompute_offsets(fac, et); - } - - fac->exists = 1; - - fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name, - fac->name); - if(fac_ids == NULL) { - fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1); - g_datalist_id_set_data_full(&tf->trace->facilities_by_name, - fac->name, - fac_ids, ltt_fac_ids_destroy); - } - g_array_append_val(fac_ids, fac->id); - + pos += ltt_align((size_t)pos, sizeof(uint16_t), tf->has_alignment); + id = ltt_get_uint16(LTT_GET_BO(tf), pos); + pos += sizeof(guint16); + int_size = *(guint8*)pos; + pos += sizeof(guint8); + long_size = *(guint8*)pos; + pos += sizeof(guint8); + pointer_size = *(guint8*)pos; + pos += sizeof(guint8); + size_t_size = *(guint8*)pos; + pos += sizeof(guint8); + alignment = *(guint8*)pos; + pos += sizeof(guint8); + marker_id_event(tf->trace, g_quark_from_string(marker_name), + id, int_size, long_size, + pointer_size, size_t_size, alignment); break; - case LTT_EVENT_FACILITY_UNLOAD: - g_debug("Doing LTT_EVENT_FACILITY_UNLOAD"); - /* We don't care about unload : facilities ID are valid for the whole - * trace. They simply won't be used after the unload. */ - break; - case LTT_EVENT_STATE_DUMP_FACILITY_LOAD: - fac_name = (char*)(tf->event.data); - g_debug("Doing LTT_EVENT_STATE_DUMP_FACILITY_LOAD of facility %s", - fac_name); - pos = (tf->event.data + strlen(fac_name) + 1); + case MARKER_ID_SET_MARKER_FORMAT: + marker_name = (char*)(tf->event.data); + g_debug("Doing MARKER_ID_SET_MARKER_FORMAT of marker %s", + marker_name); + pos = (tf->event.data + strlen(marker_name) + 1); pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); - 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 */ - if(fac->exists) continue; - fac->name = g_quark_from_string(fac_name); - fac->checksum = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->checksum); - fac->id = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->id); - fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->pointer_size); - fac->int_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->int_size); - fac->long_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->long_size); - fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->size_t_size); - fac->alignment = ltt_get_uint32(LTT_GET_BO(tf), - &fac_state_dump_load_data->has_alignment); - if(ltt_get_facility_description(fac, tf->trace, tf)) - continue; /* error opening description */ - - fac->trace = tf->trace; - - /* Preset the field offsets */ - for(i=0; ievents->len; i++){ - et = &g_array_index(fac->events, LttEventType, i); - precompute_offsets(fac, et); - } - - fac->exists = 1; - - fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name, - fac->name); - if(fac_ids == NULL) { - fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1); - g_datalist_id_set_data_full(&tf->trace->facilities_by_name, - fac->name, - fac_ids, ltt_fac_ids_destroy); - } - g_array_append_val(fac_ids, fac->id); - g_debug("fac id : %u", fac->id); - - break; - case LTT_EVENT_HEARTBEAT: + format = (const char*)pos; + pos += strlen(format) + 1; + pos += ltt_align((size_t)pos, tf->trace->arch_size, tf->has_alignment); + marker_format_event(tf->trace, g_quark_from_string(marker_name), + format); + /* get information from dictionnary TODO */ break; - case LTT_EVENT_HEARTBEAT_FULL: + case MARKER_ID_HEARTBEAT_32: + case MARKER_ID_HEARTBEAT_64: break; default: g_warning("Error in processing facility file %s, " - "unknown event id %hhu in core facility.", + "unknown event id %hhu.", g_quark_to_string(tf->name), tf->event.event_id); err = EPERM; @@ -1255,7 +1150,6 @@ static int ltt_process_facility_tracefile(LttTracefile *tf) /* Error handling */ event_id_error: -fac_id_error: update_error: seek_error: g_warning("An error occured in facility tracefile parsing"); @@ -1320,15 +1214,6 @@ LttTrace *ltt_trace_open(const gchar *pathname) goto find_error; } - /* Prepare the facilities containers : array and mapping */ - /* Array is zeroed : the "exists" field is set to false by default */ - t->facilities_by_num = g_array_sized_new (FALSE, - TRUE, sizeof(LttFacility), - NUM_FACILITIES); - t->facilities_by_num = g_array_set_size(t->facilities_by_num, NUM_FACILITIES); - - g_datalist_init(&t->facilities_by_name); - /* Parse each trace control/facilitiesN files : get runtime fac. info */ group = g_datalist_id_get_data(&t->tracefiles, LTT_TRACEFILE_NAME_FACILITIES); if(group == NULL) { @@ -1351,30 +1236,6 @@ 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; @@ -1409,17 +1270,6 @@ LttTrace *ltt_trace_copy(LttTrace *self) void ltt_trace_close(LttTrace *t) { - guint i; - LttFacility *fac; - - for(i=0; ifacilities_by_num->len; i++) { - fac = &g_array_index (t->facilities_by_num, LttFacility, i); - if(fac->exists) - ltt_facility_close(fac); - } - - g_datalist_clear(&t->facilities_by_name); - g_array_free(t->facilities_by_num, TRUE); g_datalist_clear(&t->tracefiles); g_free(t); } @@ -1428,7 +1278,7 @@ void ltt_trace_close(LttTrace *t) /***************************************************************************** *Get the system description of the trace ****************************************************************************/ - +#if 0 LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id) { g_assert(id < t->facilities_by_num->len); @@ -1446,6 +1296,7 @@ GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name) { return g_datalist_id_get_data(&t->facilities_by_name, name); } +#endif //0 /***************************************************************************** * Functions to discover all the event types in the trace @@ -1502,7 +1353,7 @@ LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name) * Get the start time and end time of the trace ****************************************************************************/ -static void ltt_tracefile_time_span_get(LttTracefile *tf, +void ltt_tracefile_time_span_get(LttTracefile *tf, LttTime *start, LttTime *end) { int err; @@ -1528,7 +1379,7 @@ struct tracefile_time_span_get_args { LttTime *end; }; -static void group_time_span_get(GQuark name, gpointer data, gpointer user_data) +void group_time_span_get(GQuark name, gpointer data, gpointer user_data) { struct tracefile_time_span_get_args *args = (struct tracefile_time_span_get_args*)user_data; @@ -1959,7 +1810,6 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) 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); } pos += sizeof(guint32); } else { @@ -1971,11 +1821,8 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) event->event_time = ltt_interpolate_time(tf, event); if(!tf->compact) { - event->facility_id = *(guint8*)pos; - pos += sizeof(guint8); - - event->event_id = *(guint8*)pos; - pos += sizeof(guint8); + event->event_id = *(guint16*)pos; + pos += sizeof(guint16); event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos); pos += sizeof(guint16); @@ -2008,7 +1855,7 @@ int ltt_tracefile_read_update_event(LttTracefile *tf) * EIO : can not read from the file ****************************************************************************/ -static gint map_block(LttTracefile * tf, guint block_num) +gint map_block(LttTracefile * tf, guint block_num) { int page_size = getpagesize(); struct ltt_block_start_header *header; @@ -2142,6 +1989,11 @@ void ltt_update_event_size(LttTracefile *tf) //g_debug("marker %s id set", (char*)tf->event.data); size += ltt_align(size, sizeof(guint16), tf->has_alignment); size += sizeof(guint16); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); + size += sizeof(guint8); break; case MARKER_ID_SET_MARKER_FORMAT: //g_debug("marker %s format set", (char*)tf->event.data); @@ -2165,11 +2017,11 @@ void ltt_update_event_size(LttTracefile *tf) default: info = marker_get_info_from_id(tf->trace, tf->event.event_id); g_assert(info != NULL); - if (info->size) { + if (info->size != -1) { size = info->size; } else { - /* Must compute the event size dynamically TODO */ - + size = marker_update_fields_offsets(marker_get_info_from_id(tf->trace, + tf->event.event_id), tf->event.data); } } @@ -2181,9 +2033,11 @@ void ltt_update_event_size(LttTracefile *tf) 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); + struct marker_info *info = marker_get_info_from_id(tf->trace, + tf->event.event_id); + g_error("Kernel/LTTV event size differs for event %s: kernel %u, LTTV %u", + g_quark_to_string(info->name), + tf->event.event_size, tf->event.data_size); exit(-1); } @@ -2247,7 +2101,7 @@ event_id_error: * ERANGE if we are at the end of the buffer. * ENOPROTOOPT if an error occured when getting the current event size. */ -static int ltt_seek_next_event(LttTracefile *tf) +int ltt_seek_next_event(LttTracefile *tf) { int ret = 0; void *pos; @@ -2356,6 +2210,7 @@ void set_fields_offsets(LttTracefile *tf, LttEventType *event_type) * returns : The size on which it must be aligned. * ****************************************************************************/ +#if 0 off_t get_alignment(LttField *field) { LttType *type = &field->field_type; @@ -2425,6 +2280,8 @@ off_t get_alignment(LttField *field) } } +#endif //0 + /***************************************************************************** *Function name * field_compute_static_size : Determine the size of fields known by their @@ -2435,7 +2292,7 @@ off_t get_alignment(LttField *field) * field : field * ****************************************************************************/ - +#if 0 void field_compute_static_size(LttFacility *fac, LttField *field) { LttType *type = &field->field_type; @@ -2517,7 +2374,7 @@ void field_compute_static_size(LttFacility *fac, LttField *field) } } - +#endif //0 /***************************************************************************** @@ -2532,7 +2389,7 @@ void field_compute_static_size(LttFacility *fac, LttField *field) * 0 otherwise. ****************************************************************************/ - +#if 0 gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, gint is_compact) { LttType *type = &field->field_type; @@ -2691,7 +2548,9 @@ gint precompute_fields_offsets(LttFacility *fac, LttField *field, off_t *offset, } +#endif //0 +#if 0 /***************************************************************************** *Function name * precompute_offsets : set the precomputable offset of an event type @@ -2723,7 +2582,7 @@ void precompute_offsets(LttFacility *fac, LttEventType *event) if(ret) break; } } - +#endif //0 @@ -2921,6 +2780,7 @@ void preset_field_type_size(LttTracefile *tf, LttEventType *event_type, // this function checks for equality of field types. Therefore, it does not use // per se offsets. For instance, an aligned version of a structure is // compatible with an unaligned version of the same structure. +#if 0 gint check_fields_compatibility(LttEventType *event_type1, LttEventType *event_type2, LttField *field1, LttField *field2) @@ -3025,7 +2885,7 @@ gint check_fields_compatibility(LttEventType *event_type1, end: return different; } - +#endif //0 #if 0 gint check_fields_compatibility(LttEventType *event_type1, @@ -3261,7 +3121,7 @@ void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) /* Before library loading... */ -static void __attribute__((constructor)) init(void) +void init(void) { LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat"); @@ -3269,4 +3129,3 @@ static void __attribute__((constructor)) init(void) LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("/control/facilities"); } - diff --git a/ltt/branches/poly/ltt/type.c b/ltt/branches/poly/ltt/type.c index 086060a2..df1b8ea8 100644 --- a/ltt/branches/poly/ltt/type.c +++ b/ltt/branches/poly/ltt/type.c @@ -78,20 +78,6 @@ gchar *ltt_eventtype_description(LttEventType *et) return et->description; } -/***************************************************************************** - *Function name - * ltt_eventtype_facility : get the facility which contains the event type - *Input params - * et : an event type - *Return value - * LttFacility * : the facility - ****************************************************************************/ - -LttFacility *ltt_eventtype_facility(LttEventType *et) -{ - return et->facility; -} - /***************************************************************************** *Function name * ltt_eventtype_id : get the id of the event type @@ -134,8 +120,6 @@ GQuark ltt_field_name(LttField *f) return f->name; } - - /***************************************************************************** *Function name * ltt_type_class : get the type class of the type diff --git a/ltt/branches/poly/lttv/lttv/hook.h b/ltt/branches/poly/lttv/lttv/hook.h index 197184a6..325d2186 100644 --- a/ltt/branches/poly/lttv/lttv/hook.h +++ b/ltt/branches/poly/lttv/lttv/hook.h @@ -128,10 +128,6 @@ typedef struct _LttvHooksById { GArray *array; } LttvHooksById; -/* macro to calculate the hook ID of a facility/event pair. */ -#define GET_HOOK_ID(fac_id, ev_id) \ - ( (guint)fac_id | ((guint)ev_id << FACILITIES_BITS) ) - /* Create and destroy a hooks by id list */ LttvHooksById *lttv_hooks_by_id_new(); diff --git a/ltt/branches/poly/lttv/lttv/tracecontext.c b/ltt/branches/poly/lttv/lttv/tracecontext.c index 5ecdae22..085059b4 100644 --- a/ltt/branches/poly/lttv/lttv/tracecontext.c +++ b/ltt/branches/poly/lttv/lttv/tracecontext.c @@ -975,11 +975,7 @@ LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th, return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id); } -/* Get the first facility corresponding to the name. As the types must be - * compatible, it is relevant to use the field name and sizes of the first - * facility to create data structures and assume the data will be compatible - * thorough the trace */ -LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th) +struct marker_info *lttv_trace_hook_get_marker(LttvTraceHook *th) { g_assert(th->fac_list->len > 0); return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0); @@ -988,51 +984,29 @@ LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th) /* Returns 0 on success, -1 if fails. */ gint -lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event, +lttv_trace_find_hook(LttTrace *t, GQuark event, GQuark field1, GQuark field2, GQuark field3, LttvHook h, gpointer hook_data, LttvTraceHook *th) { - LttFacility *f; - LttEventType *et, *first_et; - GArray *facilities; - - guint i, fac_id, ev_id; - - LttvTraceHookByFacility *thf, *first_thf; - - facilities = ltt_trace_facility_get_by_name(t, facility); + struct marker_info *info; - if(unlikely(facilities == NULL)) goto facility_error; + guint i, ev_id; - th->fac_index = g_array_sized_new(FALSE, TRUE, - sizeof(LttvTraceHookByFacility), - NUM_FACILITIES); - th->fac_index = g_array_set_size(th->fac_index, NUM_FACILITIES); + head = marker_get_info_from_name(t, event); - th->fac_list = g_array_sized_new(FALSE, TRUE, - sizeof(LttvTraceHookByFacility*), - facilities->len); - th->fac_list = g_array_set_size(th->fac_list, facilities->len); - - fac_id = g_array_index(facilities, guint, 0); - f = ltt_trace_get_facility_by_num(t, fac_id); - - et = ltt_facility_eventtype_get_by_name(f, event); - if(unlikely(et == NULL)) goto event_error; - - thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id); - g_array_index(th->fac_list, LttvTraceHookByFacility*, 0) = thf; + if(unlikely(head == NULL)) + goto facility_error; - ev_id = ltt_eventtype_id(et); + ev_id = marker_get_id_from_info(t, info); - thf->h = h; - thf->id = GET_HOOK_ID(fac_id, ev_id); - thf->f1 = find_field(et, field1); - thf->f2 = find_field(et, field2); - thf->f3 = find_field(et, field3); - thf->hook_data = hook_data; + th->h = h; + th->id = ev_id; + th->f1 = find_field(et, field1); + th->f2 = find_field(et, field2); + th->f3 = find_field(et, field3); + th->hook_data = hook_data; first_thf = thf; first_et = et; diff --git a/ltt/branches/poly/lttv/lttv/tracecontext.h b/ltt/branches/poly/lttv/lttv/tracecontext.h index 1336160b..be9a9514 100644 --- a/ltt/branches/poly/lttv/lttv/tracecontext.h +++ b/ltt/branches/poly/lttv/lttv/tracecontext.h @@ -23,6 +23,7 @@ #include #include #include +#include /* This is the generic part of trace processing. All events within a certain time interval are accessed and processing hooks are called for @@ -274,11 +275,6 @@ void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *self, /* A LttvTraceHook has two arrays of LttvTraceHookByFacility, * indexed by facility ID and a simple array used to walk all the hooks */ typedef struct _LttvTraceHook { - GArray *fac_index; - GArray *fac_list; -} LttvTraceHook; - -typedef struct _LttvTraceHookByFacility { LttvHook h; guint id; LttField *f1; @@ -288,14 +284,9 @@ typedef struct _LttvTraceHookByFacility { } LttvTraceHookByFacility; -/* Get the first facility corresponding to the name. As the types must be - * compatible, it is relevant to use the field name and sizes of the first - * facility to create data structures and assume the data will be compatible - * thorough the trace */ -LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th); - -LttvTraceHookByFacility *lttv_trace_hook_get_fac( - LttvTraceHook *th, guint facility_id); +/* Get the head of marker list correcponding to the given trace hook. + */ +struct marker_info *lttv_trace_hook_get_marker(LttvTraceHook *th); void lttv_trace_hook_destroy(LttvTraceHook *th); @@ -306,7 +297,7 @@ void lttv_trace_hook_destroy(LttvTraceHook *th); registering a hook using this structure as event data; it already contains the (up to three) needed fields handles. */ -gint lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event_type, +gint lttv_trace_find_hook(LttTrace *t, GQuark event_type, GQuark field1, GQuark field2, GQuark field3, LttvHook h, gpointer hook_data, LttvTraceHook *th); -- 2.34.1