ltt/branches/poly/ltt/ltt-private.h

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Xiangxiu Yang
   3  *               2006 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 LTT_PRIVATE_H
  21 #define LTT_PRIVATE_H
  22
  23 #include <glib.h>
  24 #include <sys/types.h>
  25 #include <ltt/ltt.h>
  26 #include <endian.h>
  27 #include <ltt/event.h>
  28 #include <ltt/marker.h>
  29 #include <ltt/trace.h>
  30
  31 #ifndef max
  32 #define max(a,b) ((a)>(b)?(a):(b))
  33 #endif
  34
  35 #ifndef min
  36 #define min(a,b) ((a)<(b)?(a):(b))
  37 #endif
  38
  39
  40
  41 #define LTT_MAGIC_NUMBER 0x00D6B7ED
  42 #define LTT_REV_MAGIC_NUMBER 0xEDB7D600
  43
  44 #define NSEC_PER_USEC 1000
  45
  46 #define LTT_PACKED_STRUCT __attribute__ ((packed))
  47
  48 /* Hardcoded facilities */
  49 #define LTT_FACILITY_CORE 0
  50
  51 /* Byte ordering */
  52 #define LTT_GET_BO(t) ((t)->reverse_bo)
  53
  54 #define LTT_HAS_FLOAT(t) ((t)->float_word_order!=0)
  55 #define LTT_GET_FLOAT_BO(t) \
  56   (((t)->float_word_order==__BYTE_ORDER)?0:1)
  57
  58 #define SEQUENCE_AVG_ELEMENTS 1000
  59
  60 /* Hardcoded core events */
  61 enum ltt_core_events {
  62     LTT_EVENT_FACILITY_LOAD,
  63     LTT_EVENT_FACILITY_UNLOAD,
  64     LTT_EVENT_HEARTBEAT,
  65     LTT_EVENT_HEARTBEAT_FULL,
  66     LTT_EVENT_STATE_DUMP_FACILITY_LOAD
  67 };
  68
  69
  70 typedef guint8 uint8_t;
  71 typedef guint16 uint16_t;
  72 typedef guint32 uint32_t;
  73 typedef guint64 uint64_t;
  74
  75 struct ltt_event_header_hb {
  76   uint32_t      timestamp;
  77   uint16_t      event_id;
  78   uint16_t      event_size;
  79 } LTT_PACKED_STRUCT;
  80
  81 struct ltt_event_header_nohb {
  82   uint64_t      timestamp;
  83   uint16_t      event_id;
  84   uint16_t      event_size;
  85 } LTT_PACKED_STRUCT;
  86
  87
  88 /* Block and trace headers */
  89
  90 struct ltt_trace_header_any {
  91   uint32_t        magic_number;
  92   uint32_t        arch_type;
  93   uint32_t        arch_variant;
  94   uint32_t        float_word_order;
  95   uint8_t         arch_size;
  96   uint8_t         major_version;
  97   uint8_t         minor_version;
  98   uint8_t         flight_recorder;
  99   uint8_t         has_heartbeat;
 100   uint8_t         alignment;  /* Event header alignment */
 101   uint32_t        freq_scale;
 102 } LTT_PACKED_STRUCT;
 103
 104 struct ltt_trace_header_1_0 {
 105   uint32_t        magic_number;
 106   uint32_t        arch_type;
 107   uint32_t        arch_variant;
 108   uint32_t        float_word_order;
 109   uint8_t         arch_size;
 110   uint8_t         major_version;
 111   uint8_t         minor_version;
 112   uint8_t         flight_recorder;
 113   uint8_t         has_heartbeat;
 114   uint8_t         alignment;  /* Event header alignment */
 115   uint8_t         tsc_lsb_truncate;
 116   uint8_t         tscbits;
 117   uint8_t         compact_data_shift;
 118   uint32_t        freq_scale;
 119   uint64_t        start_freq;
 120   uint64_t        start_tsc;
 121   uint64_t        start_monotonic;
 122   uint64_t        start_time_sec;
 123   uint64_t        start_time_usec;
 124 } LTT_PACKED_STRUCT;
 125
 126
 127 struct ltt_block_start_header {
 128   struct {
 129     uint64_t                cycle_count;
 130     uint64_t                freq;
 131   } begin;
 132   struct {
 133     uint64_t                cycle_count;
 134     uint64_t                freq;
 135   } end;
 136   uint32_t                lost_size;  /* Size unused at the end of the buffer */
 137   uint32_t                buf_size;   /* The size of this sub-buffer */
 138   struct ltt_trace_header_any trace[0];
 139 } LTT_PACKED_STRUCT;
 140
 141
 142 enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };
 143
 144 typedef struct _LttBuffer {
 145   void * head;
 146   unsigned int index;
 147
 148   struct {
 149     LttTime                 timestamp;
 150     uint64_t                cycle_count;
 151     uint64_t                freq; /* Frequency in khz */
 152   } begin;
 153   struct {
 154     LttTime                 timestamp;
 155     uint64_t                cycle_count;
 156     uint64_t                freq; /* Frequency in khz */
 157   } end;
 158   uint32_t                lost_size; /* Size unused at the end of the buffer */
 159
 160   /* Timekeeping */
 161   uint64_t                tsc;       /* Current timestamp counter */
 162   uint64_t                freq; /* Frequency in khz */
 163   //double                  nsecs_per_cycle;  /* Precalculated from freq */
 164   guint32                 cyc2ns_scale;
 165 } LttBuffer;
 166
 167 struct LttTracefile {
 168   gboolean cpu_online;               //is the cpu online ?
 169   GQuark long_name;                  //tracefile complete filename
 170   GQuark name;                       //tracefile name
 171   guint cpu_num;                     //cpu number of the tracefile
 172   guint  tid;                         //Usertrace tid, else 0
 173   guint pgid;                         //Usertrace pgid, else 0
 174   guint64 creation;                   //Usertrace creation, else 0
 175   LttTrace * trace;                  //trace containing the tracefile
 176   int fd;                            //file descriptor
 177   off_t file_size;                   //file size
 178   //unsigned block_size;               //block_size
 179   guint num_blocks;           //number of blocks in the file
 180   gboolean  reverse_bo;              //must we reverse byte order ?
 181   gboolean  float_word_order;        //what is the byte order of floats ?
 182   size_t    alignment;               //alignment of events in the tracefile.
 183                                      // 0 or the architecture size in bytes.
 184
 185   guint8    has_heartbeat;
 186   size_t    buffer_header_size;
 187   int       compact;                 //compact tracefile ?
 188   uint8_t   tsc_lsb_truncate;
 189   uint8_t   tscbits;
 190   uint8_t   tsc_msb_cutoff;
 191   uint8_t   compact_event_bits;
 192   uint64_t  tsc_mask;
 193   uint64_t  tsc_mask_next_bit;       //next MSB after the mask
 194
 195   /* Current event */
 196   LttEvent event;                    //Event currently accessible in the trace
 197
 198   /* Current block */
 199   LttBuffer buffer;                  //current buffer
 200   guint32 buf_size;                  /* The size of blocks */
 201
 202   /* Time flow */
 203   //unsigned int      count;           //the number of overflow of cycle count
 204   //double nsec_per_cycle;             //Nsec per cycle
 205   //TimeHeartbeat * last_heartbeat;    //last heartbeat
 206
 207   //LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
 208   //void * last_event_pos;
 209
 210   //LttTime prev_block_end_time;       //the end time of previous block
 211   //LttTime prev_event_time;           //the time of the previous event
 212   //LttCycleCount pre_cycle_count;     //previous cycle count of the event
 213 };
 214
 215 /* The characteristics of the system on which the trace was obtained
 216    is described in a LttSystemDescription structure. */
 217
 218 struct LttSystemDescription {
 219   gchar *description;
 220   gchar *node_name;
 221   gchar *domain_name;
 222   unsigned nb_cpu;
 223   LttArchSize size;
 224   LttArchEndian endian;
 225   gchar *kernel_name;
 226   gchar *kernel_release;
 227   gchar *kernel_version;
 228   gchar *machine;
 229   gchar *processor;
 230   gchar *hardware_platform;
 231   gchar *operating_system;
 232   LttTime trace_start;
 233   LttTime trace_end;
 234 };
 235
 236 /*****************************************************************************
 237  macro for size of some data types
 238  *****************************************************************************/
 239 // alignment -> dynamic!
 240
 241 //#define TIMESTAMP_SIZE    sizeof(guint32)
 242 //#define EVENT_ID_SIZE     sizeof(guint16)
 243 //#define EVENT_HEADER_SIZE (TIMESTAMP_SIZE + EVENT_ID_SIZE)
 244
 245
 246 //off_t get_alignment(LttField *field);
 247
 248 /* Calculate the offset needed to align the type.
 249  * If alignment is 0, alignment is disactivated.
 250  * else, the function returns the offset needed to
 251  * align align_drift on the alignment value (should be
 252  * the size of the architecture). */
 253 static inline unsigned int ltt_align(size_t align_drift,
 254           size_t size_of_type,
 255           size_t alignment)
 256 {
 257   size_t align_offset = min(alignment, size_of_type);
 258
 259   if(!alignment)
 260     return 0;
 261
 262   g_assert(size_of_type != 0);
 263   return ((align_offset - align_drift) & (align_offset-1));
 264 }
 265
 266
 267 #endif /* LTT_PRIVATE_H */