ltt/branches/poly/ltt-newlib/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
  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 gchar * ltt_trace_name(LttTrace *t);
  48
  49 void ltt_trace_close(LttTrace *t);
  50
  51
  52 LttSystemDescription *ltt_trace_system_description(LttTrace *t);
  53
  54
  55 /* Functions to discover the facilities in the trace. Once the number
  56    of facilities is known, they may be accessed by position. Multiple
  57    versions of a facility (same name, different checksum) have consecutive
  58    positions. */
  59
  60 unsigned ltt_trace_facility_number(LttTrace *t);
  61
  62 LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i);
  63
  64 LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id);
  65
  66 /* Look for a facility by name. It returns the number of facilities found
  67    and sets the position argument to the first found. Returning 0, the named
  68    facility is unknown, returning 1, the named facility is at the specified
  69    position, returning n, the facilities are from position to
  70    position + n - 1. */
  71
  72 unsigned ltt_trace_facility_find(LttTrace *t, gchar *name, unsigned *position);
  73
  74
  75 /* Functions to discover all the event types in the trace */
  76
  77 unsigned ltt_trace_eventtype_number(LttTrace *t);
  78
  79 LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i);
  80
  81
  82 /* There is one "per cpu" tracefile for each CPU, numbered from 0 to
  83    the maximum number of CPU in the system. When the number of CPU installed
  84    is less than the maximum, some positions are unused. There are also a
  85    number of "control" tracefiles (facilities, interrupts...). */
  86
  87 unsigned ltt_trace_control_tracefile_number(LttTrace *t);
  88
  89 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t);
  90
  91
  92 /* It is possible to search for the tracefiles by name or by CPU tracefile
  93  * name.
  94  * The index within the tracefiles of the same type is returned if found
  95  * and a negative value otherwise.
  96  */
  97
  98 int ltt_trace_control_tracefile_find(LttTrace *t, const gchar *name);
  99
 100 int ltt_trace_per_cpu_tracefile_find(LttTrace *t, const gchar *name);
 101
 102
 103 /* Get a specific tracefile */
 104
 105 LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i);
 106
 107 LttTracefile *ltt_trace_per_cpu_tracefile_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 char *ltt_tracefile_name(LttTracefile *tf);
 118
 119
 120 /* Get the number of blocks in the tracefile */
 121
 122 unsigned ltt_tracefile_block_number(LttTracefile *tf);
 123
 124
 125 /* Seek to the first event of the trace with time larger or equal to time */
 126
 127 int ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
 128
 129 /* Seek to the first event with position equal or larger to ep */
 130
 131 int ltt_tracefile_seek_position(LttTracefile *t,
 132     const LttEventPosition *ep);
 133
 134 /* Read the next event */
 135
 136 int ltt_tracefile_read(LttTracefile *t);
 137
 138 /* ltt_tracefile_read cut down in pieces */
 139 int ltt_tracefile_read_seek(LttTracefile *t);
 140 int ltt_tracefile_read_update_event(LttTracefile *t);
 141 int ltt_tracefile_read_op(LttTracefile *t);
 142
 143 /* open tracefile */
 144
 145 LttTracefile * ltt_tracefile_open(LttTrace *t, gchar * tracefile_name);
 146
 147 void ltt_tracefile_open_cpu(LttTrace *t, gchar * tracefile_name);
 148
 149 gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name);
 150
 151
 152 /* get the data type size and endian type of the local machine */
 153
 154 void getDataEndianType(LttArchSize * size, LttArchEndian * endian);
 155
 156 /* get an integer number */
 157 gint64 get_int(gboolean reverse_byte_order, gint size, void *data);
 158
 159 /* get the node name of the system */
 160
 161 gchar * ltt_trace_system_description_node_name (LttSystemDescription * s);
 162
 163
 164 /* get the domain name of the system */
 165
 166 gchar * ltt_trace_system_description_domain_name (LttSystemDescription * s);
 167
 168
 169 /* get the description of the system */
 170
 171 gchar * ltt_trace_system_description_description (LttSystemDescription * s);
 172
 173
 174 /* get the start time of the trace */
 175
 176 LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s);
 177
 178 /* copy tracefile info over another. Used for sync. */
 179 LttTracefile *ltt_tracefile_new();
 180 void ltt_tracefile_destroy(LttTracefile *tf);
 181 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src);
 182
 183 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname);
 184
 185
 186
 187 #endif // TRACE_H