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