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 #include <ltt/ltt-private.h>
  25 #include <stdint.h>
  26 #include <glib.h>
  27
  28 struct LttTrace {
  29   GQuark pathname;                          //the pathname of the trace
  30   //LttSystemDescription * system_description;//system description
  31
  32   guint     num_cpu;
  33
  34   guint32   arch_type;
  35   guint32   arch_variant;
  36   guint8    arch_size;
  37   guint8    ltt_major_version;
  38   guint8    ltt_minor_version;
  39   guint8    flight_recorder;
  40   guint32   freq_scale;
  41   uint64_t  start_freq;
  42   uint64_t  start_tsc;
  43   uint64_t  start_monotonic;
  44   double    drift;
  45   double    offset;
  46   LttTime   start_time;
  47   LttTime   start_time_from_tsc;
  48         gboolean  is_live; /* Flag indicating that read trace is currently being recorded */
  49         LttTime live_safe_timestamp; /* In a live trace, timestamp were all data should be readable */
  50
  51         GData     *tracefiles;                    /*tracefiles groups*/
  52 };
  53
  54 static inline guint ltt_trace_get_num_cpu(LttTrace *t)
  55 {
  56   return t->num_cpu;
  57 }
  58
  59 /* A trace is specified as a pathname to the directory containing all the
  60    associated data (control tracefiles, per cpu tracefiles, event
  61    descriptions...).
  62
  63    When a trace is closed, all the associated facilities, types and fields
  64    are released as well.
  65
  66    return value is NULL if there is an error when opening the trace.
  67
  68    */
  69
  70 LttTrace *ltt_trace_open(const gchar *pathname);
  71
  72 /* Same as ltt_trace_open but open the trace in live mode */
  73 LttTrace *ltt_trace_open_live(const gchar *pathname);
  74
  75
  76 /* copy reopens a trace
  77  *
  78  * return value NULL if error while opening the trace
  79  */
  80 LttTrace *ltt_trace_copy(LttTrace *self);
  81
  82 static inline GQuark ltt_trace_name(const LttTrace *t)
  83 {
  84   return t->pathname;
  85 }
  86 /* Update the informations concerning a trace, normally a live one */
  87 int ltt_trace_update(LttTrace *trace);
  88
  89 void ltt_trace_close(LttTrace *t);
  90
  91 LttSystemDescription *ltt_trace_system_description(LttTrace *t);
  92
  93
  94 /* Get the start time and end time of the trace */
  95
  96 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);
  97
  98
  99 /* Get the name of a tracefile */
 100
 101 static inline GQuark ltt_tracefile_name(const LttTracefile *tf)
 102 {
 103   return tf->name;
 104 }
 105
 106 static inline GQuark ltt_tracefile_long_name(const LttTracefile *tf)
 107 {
 108   return tf->long_name;
 109 }
 110
 111 /* get the cpu number of the tracefile */
 112
 113 static inline guint ltt_tracefile_cpu(LttTracefile *tf)
 114 {
 115   return tf->cpu_num;
 116 }
 117
 118 /* For usertrace */
 119 static inline guint ltt_tracefile_tid(LttTracefile *tf)
 120 {
 121   return tf->tid;
 122 }
 123
 124 static inline guint ltt_tracefile_pgid(LttTracefile *tf)
 125 {
 126   return tf->pgid;
 127 }
 128
 129 static inline guint64 ltt_tracefile_creation(LttTracefile *tf)
 130 {
 131   return tf->creation;
 132 }
 133
 134 static inline LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
 135 {
 136   return tf->trace;
 137 }
 138
 139 /* Get the number of blocks in the tracefile */
 140
 141 static inline guint ltt_tracefile_block_number(LttTracefile *tf)
 142 {
 143   return tf->num_blocks;
 144 }
 145
 146
 147 /* Seek to the first event of the trace with time larger or equal to time */
 148
 149 int ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
 150
 151
 152 int ltt_tracefile_get_current_position(const LttTracefile *tf,  LttEventPosition *ep);
 153
 154 /* Seek to the first event with position equal or larger to ep */
 155
 156 int ltt_tracefile_seek_position(LttTracefile *t,
 157     const LttEventPosition *ep);
 158
 159 /* Read the next event */
 160
 161 int ltt_tracefile_read(LttTracefile *t);
 162
 163 /* ltt_tracefile_read cut down in pieces */
 164 int ltt_tracefile_read_seek(LttTracefile *t);
 165 int ltt_tracefile_read_update_event(LttTracefile *t);
 166 int ltt_tracefile_read_op(LttTracefile *t);
 167
 168 /* Get the current event of the tracefile : valid until the next read */
 169 LttEvent *ltt_tracefile_get_event(LttTracefile *tf);
 170
 171 /* get the data type size and endian type of the local machine */
 172
 173 void getDataEndianType(LttArchSize * size, LttArchEndian * endian);
 174
 175 /* get an integer number */
 176 gint64 get_int(gboolean reverse_byte_order, gint size, void *data);
 177
 178 /* get the node name of the system */
 179
 180 gchar * ltt_trace_system_description_node_name (LttSystemDescription * s);
 181
 182
 183 /* get the domain name of the system */
 184
 185 gchar * ltt_trace_system_description_domain_name (LttSystemDescription * s);
 186
 187
 188 /* get the description of the system */
 189
 190 gchar * ltt_trace_system_description_description (LttSystemDescription * s);
 191
 192
 193 /* get the NTP start time of the trace */
 194
 195 LttTime ltt_trace_start_time(LttTrace *t);
 196
 197 /* get the monotonic start time of the trace */
 198
 199 LttTime ltt_trace_start_time_monotonic(LttTrace *t);
 200
 201 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname);
 202
 203 /* May return a NULL tracefile group */
 204 GData **ltt_trace_get_tracefiles_groups(LttTrace *trace);
 205
 206 typedef void (*ForEachTraceFileFunc)(LttTracefile *tf, gpointer func_args);
 207
 208 struct compute_tracefile_group_args {
 209   ForEachTraceFileFunc func;
 210   gpointer func_args;
 211 };
 212
 213 void compute_tracefile_group(GQuark key_id,
 214                              GArray *group,
 215                              struct compute_tracefile_group_args *args);
 216
 217
 218 gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data);
 219
 220 guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data);
 221
 222 guint64 tsc_to_uint64(guint32 freq_scale, uint64_t start_freq, guint64 tsc);
 223
 224 LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc);
 225
 226 /* Set to enable event debugging output */
 227 void ltt_event_debug(int state);
 228
 229 /* A structure representing the version number of the trace */
 230 struct LttTraceVersion {
 231   guint8    ltt_major_version;
 232   guint8    ltt_minor_version;
 233 };
 234
 235 /* To get the version number of a trace */
 236 int ltt_get_trace_version(const gchar *pathname, struct LttTraceVersion * version_number);
 237
 238 #endif // TRACE_H