ltt/branches/poly/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 <stdint.h>
  25 #include <glib.h>
  26
  27 struct LttTrace {
  28   GQuark pathname;                          //the pathname of the trace
  29   //LttSystemDescription * system_description;//system description
  30
  31   GArray *facilities_by_num;            /* fac_id as index in array */
  32   GData *facilities_by_name;            /* fac name (GQuark) as index */
  33                                         /* Points to array of fac_id of all the
  34                                         * facilities that has this name. */
  35   guint     num_cpu;
  36
  37   guint32   arch_type;
  38   guint32   arch_variant;
  39   guint8    arch_size;
  40   guint8    ltt_major_version;
  41   guint8    ltt_minor_version;
  42   guint8    flight_recorder;
  43   guint32   freq_scale;
  44   uint64_t  start_freq;
  45   uint64_t  start_tsc;
  46   uint64_t  start_monotonic;
  47   LttTime   start_time;
  48   LttTime   start_time_from_tsc;
  49   uint8_t   compact_event_bits;
  50
  51   GData     *tracefiles;                    //tracefiles groups
  52   /* Support for markers */
  53   GArray    *markers;                       //indexed by marker ID
  54   GHashTable *markers_hash;                 //indexed by name hash
  55 };
  56
  57
  58
  59 extern GQuark LTT_FACILITY_NAME_HEARTBEAT,
  60               LTT_EVENT_NAME_HEARTBEAT,
  61               LTT_EVENT_NAME_HEARTBEAT_FULL;
  62
  63 /* A trace is specified as a pathname to the directory containing all the
  64    associated data (control tracefiles, per cpu tracefiles, event
  65    descriptions...).
  66
  67    When a trace is closed, all the associated facilities, types and fields
  68    are released as well.
  69
  70    return value is NULL if there is an error when opening the trace.
  71
  72    */
  73
  74 LttTrace *ltt_trace_open(const gchar *pathname);
  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 GQuark ltt_trace_name(const LttTrace *t);
  83
  84 void ltt_trace_close(LttTrace *t);
  85
  86 guint ltt_trace_get_num_cpu(LttTrace *t);
  87
  88 LttSystemDescription *ltt_trace_system_description(LttTrace *t);
  89
  90
  91 /* Functions to discover the facilities in the trace. Once the number
  92    of facilities is known, they may be accessed by position. Multiple
  93    versions of a facility (same name, different checksum) have consecutive
  94    positions. */
  95
  96 //unsigned ltt_trace_facility_number(LttTrace *t);
  97
  98 //LttFacility * ltt_trace_facility_by_id(LttTrace * trace, guint8 id);
  99
 100 /* Returns an array of indexes (guint) that matches the facility name */
 101 //GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name);
 102
 103 /* Functions to discover all the event types in the trace */
 104
 105 //unsigned ltt_trace_eventtype_number(LttTrace *t);
 106
 107 //LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i);
 108
 109
 110 /* Get the start time and end time of the trace */
 111
 112 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);
 113
 114
 115 /* Get the name of a tracefile */
 116
 117 GQuark ltt_tracefile_name(const LttTracefile *tf);
 118 GQuark ltt_tracefile_long_name(const LttTracefile *tf);
 119
 120 /* get the cpu number of the tracefile */
 121
 122 guint ltt_tracefile_cpu(LttTracefile *tf);
 123
 124 /* For usertrace */
 125 guint ltt_tracefile_tid(LttTracefile *tf);
 126 guint ltt_tracefile_pgid(LttTracefile *tf);
 127 guint64 ltt_tracefile_creation(LttTracefile *tf);
 128
 129
 130 LttTrace *ltt_tracefile_get_trace(LttTracefile *tf);
 131
 132 /* Get the number of blocks in the tracefile */
 133
 134 unsigned ltt_tracefile_block_number(LttTracefile *tf);
 135
 136
 137 /* Seek to the first event of the trace with time larger or equal to time */
 138
 139 int ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
 140
 141 /* Seek to the first event with position equal or larger to ep */
 142
 143 int ltt_tracefile_seek_position(LttTracefile *t,
 144     const LttEventPosition *ep);
 145
 146 /* Read the next event */
 147
 148 int ltt_tracefile_read(LttTracefile *t);
 149
 150 /* ltt_tracefile_read cut down in pieces */
 151 int ltt_tracefile_read_seek(LttTracefile *t);
 152 int ltt_tracefile_read_update_event(LttTracefile *t);
 153 int ltt_tracefile_read_op(LttTracefile *t);
 154
 155 /* Get the current event of the tracefile : valid until the next read */
 156 LttEvent *ltt_tracefile_get_event(LttTracefile *tf);
 157
 158 /* open tracefile */
 159
 160 gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf);
 161
 162 /* get the data type size and endian type of the local machine */
 163
 164 void getDataEndianType(LttArchSize * size, LttArchEndian * endian);
 165
 166 /* get an integer number */
 167 gint64 get_int(gboolean reverse_byte_order, gint size, void *data);
 168
 169 /* get the node name of the system */
 170
 171 gchar * ltt_trace_system_description_node_name (LttSystemDescription * s);
 172
 173
 174 /* get the domain name of the system */
 175
 176 gchar * ltt_trace_system_description_domain_name (LttSystemDescription * s);
 177
 178
 179 /* get the description of the system */
 180
 181 gchar * ltt_trace_system_description_description (LttSystemDescription * s);
 182
 183
 184 /* get the NTP start time of the trace */
 185
 186 LttTime ltt_trace_start_time(LttTrace *t);
 187
 188 /* get the monotonic start time of the trace */
 189
 190 LttTime ltt_trace_start_time_monotonic(LttTrace *t);
 191
 192 /* copy tracefile info over another. Used for sync. */
 193 LttTracefile *ltt_tracefile_new();
 194 void ltt_tracefile_destroy(LttTracefile *tf);
 195 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src);
 196
 197 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname);
 198
 199 /* May return a NULL tracefile group */
 200 GData **ltt_trace_get_tracefiles_groups(LttTrace *trace);
 201
 202 typedef void (*ForEachTraceFileFunc)(LttTracefile *tf, gpointer func_args);
 203
 204 struct compute_tracefile_group_args {
 205   ForEachTraceFileFunc func;
 206   gpointer func_args;
 207 };
 208
 209
 210 void compute_tracefile_group(GQuark key_id,
 211                              GArray *group,
 212                              struct compute_tracefile_group_args *args);
 213
 214 //LttFacility *ltt_trace_get_facility_by_num(LttTrace *t, guint num);
 215
 216
 217 //gint check_fields_compatibility(LttEventType *event_type1,
 218 //    LttEventType *event_type2,
 219 //    LttField *field1, LttField *field2);
 220
 221 gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data);
 222
 223 guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data);
 224
 225 LttTime ltt_interpolate_time_from_tsc(LttTracefile *tf, guint64 tsc);
 226
 227 #endif // TRACE_H