trunk/lttng-xenomai/LinuxTraceToolkitViewer-0.8.61-xenoltt/ltt/trace.h

   1 /* This file is part of the Linux Trace Toolkit trace reading library
   2  * Copyright (C) 2003-2004 Michel Dagenais
   3  *               2005 Mathieu Desnoyers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License Version 2.1 as published by the Free Software Foundation.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifndef TRACE_H
  21 #define TRACE_H
  22
  23 #include <ltt/ltt.h>
  24
  25 extern GQuark LTT_FACILITY_NAME_HEARTBEAT,
  26               LTT_EVENT_NAME_HEARTBEAT;
  27
  28 /* A trace is specified as a pathname to the directory containing all the
  29    associated data (control tracefiles, per cpu tracefiles, event
  30    descriptions...).
  31
  32    When a trace is closed, all the associated facilities, types and fields
  33    are released as well.
  34
  35    return value is NULL if there is an error when opening the trace.
  36
  37    */
  38
  39 LttTrace *ltt_trace_open(const gchar *pathname);
  40
  41 /* copy reopens a trace
  42  *
  43  * return value NULL if error while opening the trace
  44  */
  45 LttTrace *ltt_trace_copy(LttTrace *self);
  46
  47 GQuark ltt_trace_name(const LttTrace *t);
  48
  49 void ltt_trace_close(LttTrace *t);
  50
  51 guint ltt_trace_get_num_cpu(LttTrace *t);
  52
  53 LttSystemDescription *ltt_trace_system_description(LttTrace *t);
  54
  55
  56 /* Functions to discover the facilities in the trace. Once the number
  57    of facilities is known, they may be accessed by position. Multiple
  58    versions of a facility (same name, different checksum) have consecutive
  59    positions. */
  60
  61 unsigned ltt_trace_facility_number(LttTrace *t);
  62
  63 LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i);
  64
  65 LttFacility * ltt_trace_facility_by_id(LttTrace * trace, guint8 id);
  66
  67 /* Returns an array of indexes (guint) that matches the facility name */
  68 GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name);
  69
  70 /* Functions to discover all the event types in the trace */
  71
  72 unsigned ltt_trace_eventtype_number(LttTrace *t);
  73
  74 LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i);
  75
  76
  77 /* Get the start time and end time of the trace */
  78
  79 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);
  80
  81
  82 /* Get the name of a tracefile */
  83
  84 GQuark ltt_tracefile_name(const LttTracefile *tf);
  85 GQuark ltt_tracefile_long_name(const LttTracefile *tf);
  86
  87 /* get the cpu number of the tracefile */
  88
  89 guint ltt_tracefile_cpu(LttTracefile *tf);
  90
  91 /* For usertrace */
  92 guint ltt_tracefile_tid(LttTracefile *tf);
  93 guint ltt_tracefile_pgid(LttTracefile *tf);
  94 guint64 ltt_tracefile_creation(LttTracefile *tf);
  95
  96
  97 LttTrace *ltt_tracefile_get_trace(LttTracefile *tf);
  98
  99 /* Get the number of blocks in the tracefile */
 100
 101 unsigned ltt_tracefile_block_number(LttTracefile *tf);
 102
 103
 104 /* Seek to the first event of the trace with time larger or equal to time */
 105
 106 int ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
 107
 108 /* Seek to the first event with position equal or larger to ep */
 109
 110 int ltt_tracefile_seek_position(LttTracefile *t,
 111     const LttEventPosition *ep);
 112
 113 /* Read the next event */
 114
 115 int ltt_tracefile_read(LttTracefile *t);
 116
 117 /* ltt_tracefile_read cut down in pieces */
 118 int ltt_tracefile_read_seek(LttTracefile *t);
 119 int ltt_tracefile_read_update_event(LttTracefile *t);
 120 int ltt_tracefile_read_op(LttTracefile *t);
 121
 122 /* Get the current event of the tracefile : valid until the next read */
 123 LttEvent *ltt_tracefile_get_event(LttTracefile *tf);
 124
 125 /* open tracefile */
 126
 127 gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf);
 128
 129 /* get the data type size and endian type of the local machine */
 130
 131 void getDataEndianType(LttArchSize * size, LttArchEndian * endian);
 132
 133 /* get an integer number */
 134 gint64 get_int(gboolean reverse_byte_order, gint size, void *data);
 135
 136 /* get the node name of the system */
 137
 138 gchar * ltt_trace_system_description_node_name (LttSystemDescription * s);
 139
 140
 141 /* get the domain name of the system */
 142
 143 gchar * ltt_trace_system_description_domain_name (LttSystemDescription * s);
 144
 145
 146 /* get the description of the system */
 147
 148 gchar * ltt_trace_system_description_description (LttSystemDescription * s);
 149
 150
 151 /* get the NTP start time of the trace */
 152
 153 LttTime ltt_trace_start_time(LttTrace *t);
 154
 155 /* get the monotonic start time of the trace */
 156
 157 LttTime ltt_trace_start_time_monotonic(LttTrace *t);
 158
 159 /* copy tracefile info over another. Used for sync. */
 160 LttTracefile *ltt_tracefile_new();
 161 void ltt_tracefile_destroy(LttTracefile *tf);
 162 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src);
 163
 164 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname);
 165
 166 /* May return a NULL tracefile group */
 167 GData **ltt_trace_get_tracefiles_groups(LttTrace *trace);
 168
 169 typedef void (*ForEachTraceFileFunc)(LttTracefile *tf, gpointer func_args);
 170
 171 struct compute_tracefile_group_args {
 172   ForEachTraceFileFunc func;
 173   gpointer func_args;
 174 };
 175
 176
 177 void compute_tracefile_group(GQuark key_id,
 178                              GArray *group,
 179                              struct compute_tracefile_group_args *args);
 180
 181 LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, guint num);
 182
 183
 184 gint check_fields_compatibility(LttEventType *event_type1,
 185     LttEventType *event_type2,
 186     LttField *field1, LttField *field2);
 187
 188 gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data);
 189
 190 guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data);
 191
 192 LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc);
 193
 194 #endif // TRACE_H