/* 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
#define TRACE_H
#include <ltt/ltt.h>
+#include <stdint.h>
+#include <glib.h>
-/* A trace is specified as a pathname to the directory containing all the
- associated data (control tracefiles, per cpu tracefiles, event
- descriptions...).
+struct LttTrace {
+ GQuark pathname; //the pathname of the trace
+ //LttSystemDescription * system_description;//system description
- When a trace is closed, all the associated facilities, types and fields
- are released as well. */
+ guint num_cpu;
-LttTrace *ltt_trace_open(const char *pathname);
+ guint32 arch_type;
+ guint32 arch_variant;
+ guint8 arch_size;
+ guint8 ltt_major_version;
+ guint8 ltt_minor_version;
+ guint8 flight_recorder;
+ guint32 freq_scale;
+ uint64_t start_freq;
+ uint64_t start_tsc;
+ uint64_t start_monotonic;
+ LttTime start_time;
+ LttTime start_time_from_tsc;
-/* copy reopens a trace */
-LttTrace *ltt_trace_copy(LttTrace *self);
+ GData *tracefiles; //tracefiles groups
+ /* Support for markers */
+ GArray *markers; //indexed by marker ID
+ GHashTable *markers_hash; //indexed by name hash
+ GHashTable *markers_format_hash; //indexed by name hash
+};
-char * ltt_trace_name(LttTrace *t);
-void ltt_trace_close(LttTrace *t);
+extern GQuark LTT_FACILITY_NAME_HEARTBEAT,
+ LTT_EVENT_NAME_HEARTBEAT,
+ LTT_EVENT_NAME_HEARTBEAT_FULL;
-LttSystemDescription *ltt_trace_system_description(LttTrace *t);
-
-
-/* Functions to discover the facilities in the trace. Once the number
- of facilities is known, they may be accessed by position. Multiple
- versions of a facility (same name, different checksum) have consecutive
- positions. */
-
-unsigned ltt_trace_facility_number(LttTrace *t);
-
-LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i);
+/* A trace is specified as a pathname to the directory containing all the
+ associated data (control tracefiles, per cpu tracefiles, event
+ descriptions...).
-LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id);
+ When a trace is closed, all the associated facilities, types and fields
+ are released as well.
+
+ return value is NULL if there is an error when opening the trace.
+
+ */
-/* 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. */
+LttTrace *ltt_trace_open(const gchar *pathname);
-unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position);
+/* copy reopens a trace
+ *
+ * return value NULL if error while opening the trace
+ */
+LttTrace *ltt_trace_copy(LttTrace *self);
+GQuark ltt_trace_name(const LttTrace *t);
-/* Functions to discover all the event types in the trace */
+void ltt_trace_close(LttTrace *t);
-unsigned ltt_trace_eventtype_number(LttTrace *t);
+guint ltt_trace_get_num_cpu(LttTrace *t);
-LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i);
+LttSystemDescription *ltt_trace_system_description(LttTrace *t);
-/* 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...). */
+/* Get the start time and end time of the trace */
-unsigned ltt_trace_control_tracefile_number(LttTrace *t);
+void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);
-unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t);
+/* Get the name of a tracefile */
-/* 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. */
+GQuark ltt_tracefile_name(const LttTracefile *tf);
+GQuark ltt_tracefile_long_name(const LttTracefile *tf);
-int ltt_trace_control_tracefile_find(LttTrace *t, char *name);
+/* get the cpu number of the tracefile */
-int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i);
+guint ltt_tracefile_cpu(LttTracefile *tf);
+/* For usertrace */
+guint ltt_tracefile_tid(LttTracefile *tf);
+guint ltt_tracefile_pgid(LttTracefile *tf);
+guint64 ltt_tracefile_creation(LttTracefile *tf);
-/* Get a specific tracefile */
-LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i);
+LttTrace *ltt_tracefile_get_trace(LttTracefile *tf);
-LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i);
+/* Get the number of blocks in the tracefile */
+unsigned ltt_tracefile_block_number(LttTracefile *tf);
-/* Get the start time and end time of the trace */
-void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);
+/* Seek to the first event of the trace with time larger or equal to time */
+int ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
-/* Get the name of a tracefile */
+/* Seek to the first event with position equal or larger to ep */
-char *ltt_tracefile_name(LttTracefile *tf);
+int ltt_tracefile_seek_position(LttTracefile *t,
+ const LttEventPosition *ep);
+/* Read the next event */
-/* Get the number of blocks in the tracefile */
+int ltt_tracefile_read(LttTracefile *t);
-unsigned ltt_tracefile_block_number(LttTracefile *tf);
+/* 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);
+/* Get the current event of the tracefile : valid until the next read */
+LttEvent *ltt_tracefile_get_event(LttTracefile *tf);
-/* Seek to the first event of the trace with time larger or equal to time */
+/* open tracefile */
-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 */
-char * ltt_trace_system_description_description (LttSystemDescription * s);
+gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data);
+guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data);
-/* get the start time of the trace */
+LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc);
-LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s);
+/* Set to enable event debugging output */
+void ltt_event_debug(int state);
#endif // TRACE_H
projects / lttv.git / blobdiff