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 /* A trace is specified as a pathname to the directory containing all the
  25    associated data (control tracefiles, per cpu tracefiles, event
  26    descriptions...).
  27
  28    When a trace is closed, all the associated facilities, types and fields
  29    are released as well.
  30
  31    return value is NULL if there is an error when opening the trace.
  32
  33    */
  34
  35 LttTrace *ltt_trace_open(const char *pathname);
  36
  37 /* copy reopens a trace
  38  *
  39  * return value NULL if error while opening the trace
  40  */
  41 LttTrace *ltt_trace_copy(LttTrace *self);
  42
  43 char * ltt_trace_name(LttTrace *t);
  44
  45 void ltt_trace_close(LttTrace *t);
  46
  47
  48 LttSystemDescription *ltt_trace_system_description(LttTrace *t);
  49
  50
  51 /* Functions to discover the facilities in the trace. Once the number
  52    of facilities is known, they may be accessed by position. Multiple
  53    versions of a facility (same name, different checksum) have consecutive
  54    positions. */
  55
  56 unsigned ltt_trace_facility_number(LttTrace *t);
  57
  58 LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i);
  59
  60 LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id);
  61
  62 /* Look for a facility by name. It returns the number of facilities found
  63    and sets the position argument to the first found. Returning 0, the named
  64    facility is unknown, returning 1, the named facility is at the specified
  65    position, returning n, the facilities are from position to
  66    position + n - 1. */
  67
  68 unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position);
  69
  70
  71 /* Functions to discover all the event types in the trace */
  72
  73 unsigned ltt_trace_eventtype_number(LttTrace *t);
  74
  75 LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i);
  76
  77
  78 /* There is one "per cpu" tracefile for each CPU, numbered from 0 to
  79    the maximum number of CPU in the system. When the number of CPU installed
  80    is less than the maximum, some positions are unused. There are also a
  81    number of "control" tracefiles (facilities, interrupts...). */
  82
  83 unsigned ltt_trace_control_tracefile_number(LttTrace *t);
  84
  85 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t);
  86
  87
  88 /* It is possible to search for the tracefiles by name or by CPU position.
  89    The index within the tracefiles of the same type is returned if found
  90    and a negative value otherwise. */
  91
  92 int ltt_trace_control_tracefile_find(LttTrace *t, char *name);
  93
  94 int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i);
  95
  96
  97 /* Get a specific tracefile */
  98
  99 LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i);
 100
 101 LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i);
 102
 103
 104 /* Get the start time and end time of the trace */
 105
 106 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);
 107
 108
 109 /* Get the name of a tracefile */
 110
 111 char *ltt_tracefile_name(LttTracefile *tf);
 112
 113
 114 /* Get the number of blocks in the tracefile */
 115
 116 unsigned ltt_tracefile_block_number(LttTracefile *tf);
 117
 118
 119 /* Seek to the first event of the trace with time larger or equal to time */
 120
 121 void ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
 122
 123 /* Seek to the first event with position equal or larger to ep */
 124
 125 void ltt_tracefile_seek_position(LttTracefile *t,
 126     const LttEventPosition *ep);
 127
 128 /* Read the next event */
 129
 130 LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event);
 131
 132 /* open tracefile */
 133
 134 LttTracefile * ltt_tracefile_open(LttTrace *t, char * tracefile_name);
 135
 136 void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name);
 137
 138 gint ltt_tracefile_open_control(LttTrace *t, char * control_name);
 139
 140
 141 /* obtain the time of an event */
 142
 143 LttTime getEventTime(LttTracefile * tf);
 144
 145
 146 /* get the data type size and endian type of the local machine */
 147
 148 void getDataEndianType(LttArchSize * size, LttArchEndian * endian);
 149
 150 /* get an integer number */
 151
 152 int getIntNumber(int size1, void *evD);
 153
 154
 155 /* get the node name of the system */
 156
 157 char * ltt_trace_system_description_node_name (LttSystemDescription * s);
 158
 159
 160 /* get the domain name of the system */
 161
 162 char * ltt_trace_system_description_domain_name (LttSystemDescription * s);
 163
 164
 165 /* get the description of the system */
 166
 167 char * ltt_trace_system_description_description (LttSystemDescription * s);
 168
 169
 170 /* get the start time of the trace */
 171
 172 LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s);
 173
 174 /* copy tracefile info over another. Used for sync. */
 175 LttTracefile *ltt_tracefile_new();
 176 void ltt_tracefile_destroy(LttTracefile *tf);
 177 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src);
 178
 179
 180 #endif // TRACE_H