ltt/branches/poly/ltt/event.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 EVENT_H
  20 #define EVENT_H
  21
  22 #include <glib.h>
  23 #include <ltt/ltt.h>
  24 #include <sys/types.h>
  25
  26 LttEvent *ltt_event_new();
  27
  28 void ltt_event_destroy(LttEvent *event);
  29
  30 /* Events and their content, including the raw data, are only valid
  31    until reading another event from the same tracefile.
  32    Indeed, since event reading is critical to the performance,
  33    the memory associated with an event may be reused at each read. */
  34
  35 /* Obtain the trace unique integer id associated with the type of
  36    this event */
  37
  38 unsigned ltt_event_eventtype_id(const LttEvent *e);
  39
  40 unsigned ltt_event_facility_id(const LttEvent *e);
  41
  42 /* Facility and type for the event */
  43
  44 LttFacility *ltt_event_facility(const LttEvent *e);
  45
  46 LttEventType *ltt_event_eventtype(const LttEvent *e);
  47
  48
  49 /* Root field for the event */
  50
  51 LttField *ltt_event_field(LttEvent *e);
  52
  53
  54 /* Time and cycle count for the event */
  55
  56 LttTime ltt_event_time(const LttEvent *e);
  57
  58 LttCycleCount ltt_event_cycle_count(const LttEvent *e);
  59
  60
  61 /* Obtain the position of the event within the tracefile. This
  62    is used to seek back to this position later or to seek to another
  63    position, computed relative to this position. The event position
  64    structure is opaque and contains several fields, only two
  65    of which are user accessible: block number and event index
  66    within the block. */
  67
  68 void ltt_event_position(LttEvent *e, LttEventPosition *ep);
  69
  70 LttEventPosition * ltt_event_position_new();
  71
  72 void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf,
  73         guint *block, guint *offset, guint64 *tsc);
  74
  75 gint ltt_event_position_compare(const LttEventPosition *ep1,
  76                                 const LttEventPosition *ep2);
  77
  78 void ltt_event_position_copy(LttEventPosition *dest,
  79                              const LttEventPosition *src);
  80
  81 LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep);
  82
  83 /* CPU id of the event */
  84
  85 unsigned ltt_event_cpu_id(LttEvent *e);
  86
  87
  88 /* Pointer to the raw data for the event. This should not be used directly
  89    unless prepared to do all the architecture specific conversions. */
  90
  91 void *ltt_event_data(LttEvent *e);
  92
  93
  94 /* The number of elements in a sequence field is specific to each event
  95    instance. This function returns the number of elements for an array or
  96    sequence field in an event. */
  97
  98 guint64 ltt_event_field_element_number(LttEvent *e, LttField *f);
  99
 100
 101 /* Set the currently selected element for a sequence or array field. */
 102
 103 void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i);
 104
 105
 106 /* A union is like a structure except that only a single member at a time
 107    is present depending on the specific event instance. This function tells
 108    the active member for a union field in an event. */
 109
 110 unsigned ltt_event_field_union_member(LttEvent *e, LttField *f);
 111
 112
 113 /* These functions extract data from an event after architecture specific
 114    conversions. */
 115
 116 guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f);
 117
 118 gint32 ltt_event_get_int(LttEvent *e, LttField *f);
 119
 120 guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f);
 121
 122 gint64 ltt_event_get_long_int(LttEvent *e, LttField *f);
 123
 124 float ltt_event_get_float(LttEvent *e, LttField *f);
 125
 126 double ltt_event_get_double(LttEvent *e, LttField *f);
 127
 128
 129 /* The string obtained is only valid until the next read from
 130    the same tracefile. */
 131
 132 gchar *ltt_event_get_string(LttEvent *e, LttField *f);
 133
 134 size_t get_field_type_size(LttTracefile *tf,
 135     LttEventType *event_type,
 136     off_t offset_root, off_t offset_parent,
 137     LttField *field, void *data);
 138
 139
 140
 141 #endif // EVENT_H