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  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program 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
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #ifndef LTT_PRIVATE_H
  20 #define LTT_PRIVATE_H
  21
  22 #include <glib.h>
  23 #include <sys/types.h>
  24 #include <ltt/ltt.h>
  25
  26
  27 #ifndef max
  28 #define max(a,b) ((a)>(b)?(a):(b))
  29 #endif
  30
  31
  32 #define LTT_MAGIC_NUMBER 0x00D6B7ED
  33 #define LTT_REV_MAGIC_NUMBER 0xEDB7D600
  34
  35 #define NSEC_PER_USEC 1000
  36
  37 #define LTT_PACKED_STRUCT __attribute__ ((packed))
  38
  39 /* Hardcoded facilities */
  40 #define LTT_FACILITY_CORE 0
  41
  42 /* Hardcoded core events */
  43 enum ltt_core_events {
  44     LTT_EVENT_FACILITY_LOAD,
  45     LTT_EVENT_FACILITY_UNLOAD,
  46     LTT_EVENT_HEARTBEAT,
  47     LTT_EVENT_STATE_DUMP_FACILITY_LOAD
  48 };
  49
  50
  51 #if 0
  52 /* enumeration definition */
  53
  54 typedef enum _BuildinEvent{
  55   TRACE_FACILITY_LOAD = 0,
  56   TRACE_BLOCK_START   = 17,
  57   TRACE_BLOCK_END     = 18,
  58   TRACE_TIME_HEARTBEAT= 19
  59 } BuildinEvent;
  60
  61
  62 /* structure definition */
  63
  64 typedef struct _FacilityLoad{
  65   gchar * name;
  66   LttChecksum checksum;
  67   guint32     base_code;
  68 } LTT_PACKED_STRUCT FacilityLoad;
  69
  70 typedef struct _BlockStart {
  71   LttTime       time;       //Time stamp of this block
  72   LttCycleCount cycle_count; //cycle count of the event
  73   guint32       block_id;    //block id
  74 } LTT_PACKED_STRUCT BlockStart;
  75
  76 typedef struct _BlockEnd {
  77   LttTime       time;       //Time stamp of this block
  78   LttCycleCount cycle_count; //cycle count of the event
  79   guint32       block_id;    //block id
  80 } LTT_PACKED_STRUCT BlockEnd;
  81 #endif //0
  82
  83
  84 typedef guint8 uint8_t;
  85 typedef guint16 uint16_t;
  86 typedef guint32 uint32_t;
  87 typedef guint64 uint64_t;
  88
  89 /* Hardcoded facility load event : this plus an preceding "name" string */
  90 struct LttFacilityLoad {
  91   guint32 checksum;
  92   guint32 id;
  93   guint32 long_size;
  94   guint32 pointer_size;
  95   guint32 size_t_size;
  96   guint32 alignment;
  97 } LTT_PACKED_STRUCT;
  98
  99 struct LttFacilityUnload {
 100   guint32 id;
 101 } LTT_PACKED_STRUCT;
 102
 103 struct LttStateDumpFacilityLoad {
 104   guint32 checksum;
 105   guint32 id;
 106   guint32 long_size;
 107   guint32 pointer_size;
 108   guint32 size_t_size;
 109   guint32 alignment;
 110 } LTT_PACKED_STRUCT;
 111
 112 typedef struct _TimeHeartbeat {
 113   LttTime       time;       //Time stamp of this block
 114   uint64_t cycle_count; //cycle count of the event
 115 } LTT_PACKED_STRUCT TimeHeartbeat;
 116
 117 struct ltt_event_header_hb {
 118   uint32_t      timestamp;
 119   unsigned char  facility_id;
 120   unsigned char event_id;
 121   uint16_t      event_size;
 122 } LTT_PACKED_STRUCT;
 123
 124 struct ltt_event_header_nohb {
 125   uint64_t      timestamp;
 126   unsigned char  facility_id;
 127   unsigned char event_id;
 128   uint16_t      event_size;
 129 } LTT_PACKED_STRUCT;
 130
 131 struct ltt_trace_header {
 132   uint32_t        magic_number;
 133   uint32_t        arch_type;
 134   uint32_t        arch_variant;
 135   uint8_t         arch_size;
 136   //uint32_t        system_type;
 137   uint8_t          major_version;
 138   uint8_t          minor_version;
 139   uint8_t          flight_recorder;
 140   uint8_t          has_heartbeat;
 141   uint8_t          has_alignment;  /* Event header alignment */
 142         uint8_t                                  has_tsc;
 143 } LTT_PACKED_STRUCT;
 144
 145
 146 struct ltt_block_start_header {
 147   struct {
 148     struct timeval          timestamp;
 149     uint64_t                cycle_count;
 150   } begin;
 151   struct {
 152     struct timeval          timestamp;
 153     uint64_t                cycle_count;
 154   } end;
 155   uint32_t                lost_size;  /* Size unused at the end of the buffer */
 156   uint32_t                buf_size;   /* The size of this sub-buffer */
 157   struct ltt_trace_header trace;
 158 } LTT_PACKED_STRUCT;
 159
 160
 161 struct _LttType{
 162   GQuark type_name;                //type name if it is a named type
 163   GQuark element_name;             //elements name of the struct
 164   gchar * fmt;
 165   unsigned int size;
 166   LttTypeEnum type_class;          //which type
 167   GQuark * enum_strings;            //for enum labels
 168   struct _LttType ** element_type; //for array, sequence and struct
 169   unsigned element_number;         //the number of elements
 170                                    //for enum, array, sequence and structure
 171 };
 172
 173 struct _LttEventType{
 174   GQuark name;
 175   gchar * description;
 176   guint index;              //id of the event type within the facility
 177   LttFacility * facility; //the facility that contains the event type
 178   LttField * root_field;  //root field
 179 };
 180
 181 /* Structure LttEvent and LttEventPosition must begin with the _exact_ same
 182  * fields in the exact same order. LttEventPosition is a parent of LttEvent. */
 183 struct _LttEvent{
 184
 185   /* Begin of LttEventPosition fields */
 186   LttTracefile  *tracefile;
 187   unsigned int  block;
 188   unsigned int  offset;
 189
 190   /* Timekeeping */
 191   uint64_t                tsc;       /* Current timestamp counter */
 192
 193   /* End of LttEventPosition fields */
 194
 195         union {                                                                                 /* choice by trace has_tsc */
 196           guint32  timestamp;                           /* truncated timestamp */
 197         LttTime  delta;
 198         } time;
 199
 200   unsigned char facility_id;    /* facility ID are never reused. */
 201   unsigned char event_id;
 202
 203   LttTime event_time;
 204
 205   void * data;               //event data
 206   guint  data_size;
 207   guint  event_size;         //event_size field of the header :
 208                              //used to verify data_size from facility.
 209
 210   int      count;                    //the number of overflow of cycle count
 211   gint64 overflow_nsec;              //precalculated nsec for overflows
 212 };
 213
 214 struct _LttEventPosition{
 215   LttTracefile  *tracefile;
 216   unsigned int  block;
 217   unsigned int  offset;
 218
 219   /* Timekeeping */
 220   uint64_t                tsc;       /* Current timestamp counter */
 221 };
 222
 223
 224 enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };
 225
 226 struct _LttField{
 227   //guint field_pos;           //field position within its parent
 228   LttType * field_type;      //field type, if it is root field
 229                              //then it must be struct type
 230
 231   off_t offset_root;         //offset from the root, -1:uninitialized
 232   enum field_status fixed_root;          //offset fixed according to the root
 233                              //-1:uninitialized, 0:unfixed, 1:fixed
 234   off_t offset_parent;       //offset from the parent,-1:uninitialized
 235   enum field_status fixed_parent;        //offset fixed according to its parent
 236                              //-1:uninitialized, 0:unfixed, 1:fixed
 237   //  void * base_address;       //base address of the field  ????
 238
 239   guint field_size;     //      //>0: size of the field,
 240                           //   //0 : uncertain
 241                            //  //-1: uninitialize
 242   enum field_status fixed_size;
 243
 244   /* for sequence */
 245   gint sequ_number_size;      //the size of unsigned used to save the
 246                              //number of elements in the sequence
 247
 248   gint element_size;          //the element size of the sequence
 249   //int field_fixed;           //0: field has string or sequence
 250                              //1: field has no string or sequenc
 251                              //-1: uninitialize
 252
 253   struct _LttField * parent;
 254   struct _LttField ** child; //for array, sequence, struct and union:
 255                              //list of fields, it may have only one
 256                              //field if the element is not a struct or
 257                              //union
 258   unsigned current_element;  //which element is currently processed
 259                              // Used for sequences and arrays.
 260 };
 261
 262
 263 struct _LttFacility{
 264   LttTrace  *trace;
 265   //gchar * name;               //facility name
 266   GQuark name;
 267   guint32 checksum;      //checksum of the facility
 268   guint32  id;          //id of the facility
 269
 270   guint32 pointer_size;
 271   guint32 long_size;
 272   guint32 size_t_size;
 273   guint32 alignment;
 274
 275
 276   //LttEventType ** events;    //array of event types
 277   //unsigned int event_number;          //number of events in the facility
 278   //LttType ** named_types;
 279   //unsigned int named_types_number;
 280
 281   GArray *events;
 282   GData *events_by_name;
 283  // GArray *named_types;
 284   //GData *named_types_by_name;
 285   GData *named_types;
 286
 287   unsigned char exists; /* 0 does not exist, 1 exists */
 288 };
 289
 290 typedef struct _LttBuffer {
 291   void * head;
 292   unsigned int index;
 293
 294   struct {
 295     LttTime                 timestamp;
 296     uint64_t                cycle_count;
 297   } begin;
 298   struct {
 299     LttTime                 timestamp;
 300     uint64_t                cycle_count;
 301   } end;
 302   uint32_t                lost_size; /* Size unused at the end of the buffer */
 303
 304   /* Timekeeping */
 305   uint64_t                tsc;       /* Current timestamp counter */
 306   double                  nsecs_per_cycle;
 307 } LttBuffer;
 308
 309 struct _LttTracefile{
 310   gboolean cpu_online;               //is the cpu online ?
 311   GQuark long_name;                  //tracefile complete filename
 312   GQuark name;                       //tracefile name
 313   guint cpu_num;                     //cpu number of the tracefile
 314   LttTrace * trace;                  //trace containing the tracefile
 315   int fd;                            //file descriptor
 316   off_t file_size;                   //file size
 317   //unsigned block_size;               //block_size
 318   unsigned int num_blocks;           //number of blocks in the file
 319   gboolean  reverse_bo;              //must we reverse byte order ?
 320
 321         /* Current event */
 322   LttEvent event;                    //Event currently accessible in the trace
 323
 324         /* Current block */
 325   LttBuffer buffer;                  //current buffer
 326   guint32 buf_size;                  /* The size of blocks */
 327
 328         /* Time flow */
 329   //unsigned int      count;           //the number of overflow of cycle count
 330   //double nsec_per_cycle;             //Nsec per cycle
 331   //TimeHeartbeat * last_heartbeat;    //last heartbeat
 332
 333   //LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
 334   //void * last_event_pos;
 335
 336   //LttTime prev_block_end_time;       //the end time of previous block
 337   //LttTime prev_event_time;           //the time of the previous event
 338   //LttCycleCount pre_cycle_count;     //previous cycle count of the event
 339 };
 340
 341 struct _LttTrace{
 342   GQuark pathname;                          //the pathname of the trace
 343   //LttSystemDescription * system_description;//system description
 344
 345   GArray *facilities_by_num;            /* fac_id as index in array */
 346   GData *facilities_by_name;            /* fac name (GQuark) as index */
 347                                         /* Points to array of fac_id of all the
 348                                          * facilities that has this name. */
 349
 350   guint32   arch_type;
 351   guint32   arch_variant;
 352   guint8    arch_size;
 353   guint8    ltt_major_version;
 354   guint8    ltt_minor_version;
 355   guint8    flight_recorder;
 356   guint8    has_heartbeat;
 357   guint8    has_alignment;
 358         guint8          has_tsc;
 359
 360   GData     *tracefiles;                    //tracefiles groups
 361 };
 362
 363 /* The characteristics of the system on which the trace was obtained
 364    is described in a LttSystemDescription structure. */
 365
 366 struct _LttSystemDescription {
 367   gchar *description;
 368   gchar *node_name;
 369   gchar *domain_name;
 370   unsigned nb_cpu;
 371   LttArchSize size;
 372   LttArchEndian endian;
 373   gchar *kernel_name;
 374   gchar *kernel_release;
 375   gchar *kernel_version;
 376   gchar *machine;
 377   gchar *processor;
 378   gchar *hardware_platform;
 379   gchar *operating_system;
 380   LttTime trace_start;
 381   LttTime trace_end;
 382 };
 383
 384 /*****************************************************************************
 385  macro for size of some data types
 386  *****************************************************************************/
 387 // alignment -> dynamic!
 388
 389 //#define TIMESTAMP_SIZE    sizeof(guint32)
 390 //#define EVENT_ID_SIZE     sizeof(guint16)
 391 //#define EVENT_HEADER_SIZE (TIMESTAMP_SIZE + EVENT_ID_SIZE)
 392
 393 #define LTT_GET_BO(t) ((t)->reverse_bo)
 394
 395
 396 #endif /* LTT_PRIVATE_H */