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