X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftrace.h;h=cd6bf7b7183a24ce1d05f716730ccb21e21d4438;hb=f0b795e0b579719a95fee5f84d4dcb893044d926;hp=2b3f8533ba6488494f7ae3fd88ec2aa0ed67975c;hpb=f95bc8309fe113855266f4445874248b6a285062;p=lttv.git diff --git a/ltt/branches/poly/ltt/trace.h b/ltt/branches/poly/ltt/trace.h index 2b3f8533..cd6bf7b7 100644 --- a/ltt/branches/poly/ltt/trace.h +++ b/ltt/branches/poly/ltt/trace.h @@ -1,5 +1,6 @@ /* This file is part of the Linux Trace Toolkit trace reading library * Copyright (C) 2003-2004 Michel Dagenais + * 2005 Mathieu Desnoyers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -21,22 +22,33 @@ #include +extern GQuark LTT_FACILITY_NAME_HEARTBEAT, + LTT_EVENT_NAME_HEARTBEAT; + /* A trace is specified as a pathname to the directory containing all the associated data (control tracefiles, per cpu tracefiles, event descriptions...). When a trace is closed, all the associated facilities, types and fields - are released as well. */ + are released as well. + + return value is NULL if there is an error when opening the trace. + + */ -LttTrace *ltt_trace_open(const char *pathname); +LttTrace *ltt_trace_open(const gchar *pathname); -/* copy reopens a trace */ +/* copy reopens a trace + * + * return value NULL if error while opening the trace + */ LttTrace *ltt_trace_copy(LttTrace *self); -char * ltt_trace_name(LttTrace *t); +GQuark ltt_trace_name(const LttTrace *t); void ltt_trace_close(LttTrace *t); +guint ltt_trace_get_num_cpu(LttTrace *t); LttSystemDescription *ltt_trace_system_description(LttTrace *t); @@ -50,16 +62,10 @@ unsigned ltt_trace_facility_number(LttTrace *t); LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i); -LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id); - -/* Look for a facility by name. It returns the number of facilities found - and sets the position argument to the first found. Returning 0, the named - facility is unknown, returning 1, the named facility is at the specified - position, returning n, the facilities are from position to - position + n - 1. */ - -unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position); +LttFacility * ltt_trace_facility_by_id(LttTrace * trace, guint8 id); +/* Returns an array of indexes (guint) that matches the facility name */ +GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name); /* Functions to discover all the event types in the trace */ @@ -68,100 +74,113 @@ unsigned ltt_trace_eventtype_number(LttTrace *t); LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i); -/* There is one "per cpu" tracefile for each CPU, numbered from 0 to - the maximum number of CPU in the system. When the number of CPU installed - is less than the maximum, some positions are unused. There are also a - number of "control" tracefiles (facilities, interrupts...). */ - -unsigned ltt_trace_control_tracefile_number(LttTrace *t); +/* Get the start time and end time of the trace */ -unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t); +void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end); -/* It is possible to search for the tracefiles by name or by CPU position. - The index within the tracefiles of the same type is returned if found - and a negative value otherwise. */ +/* Get the name of a tracefile */ -int ltt_trace_control_tracefile_find(LttTrace *t, char *name); +GQuark ltt_tracefile_name(const LttTracefile *tf); +GQuark ltt_tracefile_long_name(const LttTracefile *tf); -int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i); +/* get the cpu number of the tracefile */ +guint ltt_tracefile_num(LttTracefile *tf); -/* Get a specific tracefile */ +LttTrace *ltt_tracefile_get_trace(LttTracefile *tf); -LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i); +/* Get the number of blocks in the tracefile */ -LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i); +unsigned ltt_tracefile_block_number(LttTracefile *tf); -/* Get the start time and end time of the trace */ +/* Seek to the first event of the trace with time larger or equal to time */ -void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end); +int ltt_tracefile_seek_time(LttTracefile *t, LttTime time); +/* Seek to the first event with position equal or larger to ep */ -/* Get the name of a tracefile */ +int ltt_tracefile_seek_position(LttTracefile *t, + const LttEventPosition *ep); -char *ltt_tracefile_name(LttTracefile *tf); +/* Read the next event */ +int ltt_tracefile_read(LttTracefile *t); -/* Get the number of blocks in the tracefile */ +/* ltt_tracefile_read cut down in pieces */ +int ltt_tracefile_read_seek(LttTracefile *t); +int ltt_tracefile_read_update_event(LttTracefile *t); +int ltt_tracefile_read_op(LttTracefile *t); -unsigned ltt_tracefile_block_number(LttTracefile *tf); +/* Get the current event of the tracefile : valid until the next read */ +LttEvent *ltt_tracefile_get_event(LttTracefile *tf); +/* open tracefile */ -/* Seek to the first event of the trace with time larger or equal to time */ - -void ltt_tracefile_seek_time(LttTracefile *t, LttTime time); +gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf); -/* Seek to the first event with position equal or larger to ep */ +/* get the data type size and endian type of the local machine */ -void ltt_tracefile_seek_position(LttTracefile *t, - LttEventPosition *ep); +void getDataEndianType(LttArchSize * size, LttArchEndian * endian); -/* Read the next event */ +/* get an integer number */ +gint64 get_int(gboolean reverse_byte_order, gint size, void *data); -LttEvent *ltt_tracefile_read(LttTracefile *t); +/* get the node name of the system */ -/* open tracefile */ +gchar * ltt_trace_system_description_node_name (LttSystemDescription * s); -LttTracefile * ltt_tracefile_open(LttTrace *t, char * tracefile_name); -void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name); +/* get the domain name of the system */ -void ltt_tracefile_open_control(LttTrace *t, char * control_name); +gchar * ltt_trace_system_description_domain_name (LttSystemDescription * s); -/* obtain the time of an event */ +/* get the description of the system */ -LttTime getEventTime(LttTracefile * tf); +gchar * ltt_trace_system_description_description (LttSystemDescription * s); -/* get the data type size and endian type of the local machine */ +/* get the NTP start time of the trace */ -void getDataEndianType(LttArchSize * size, LttArchEndian * endian); +LttTime ltt_trace_start_time(LttTrace *t); -/* get an integer number */ +/* get the monotonic start time of the trace */ -int getIntNumber(int size1, void *evD); +LttTime ltt_trace_start_time_monotonic(LttTrace *t); +/* copy tracefile info over another. Used for sync. */ +LttTracefile *ltt_tracefile_new(); +void ltt_tracefile_destroy(LttTracefile *tf); +void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src); -/* get the node name of the system */ +void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname); -char * ltt_trace_system_description_node_name (LttSystemDescription * s); +/* May return a NULL tracefile group */ +GData **ltt_trace_get_tracefiles_groups(LttTrace *trace); +typedef void (*ForEachTraceFileFunc)(LttTracefile *tf, gpointer func_args); -/* get the domain name of the system */ +struct compute_tracefile_group_args { + ForEachTraceFileFunc func; + gpointer func_args; +}; -char * ltt_trace_system_description_domain_name (LttSystemDescription * s); +void compute_tracefile_group(GQuark key_id, + GArray *group, + struct compute_tracefile_group_args *args); -/* get the description of the system */ +LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, guint num); -char * ltt_trace_system_description_description (LttSystemDescription * s); +gint check_fields_compatibility(LttEventType *event_type1, + LttEventType *event_type2, + LttField *field1, LttField *field2); -/* get the start time of the trace */ +gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data); -LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s); +guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data); #endif // TRACE_H