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