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
  28 #ifndef max
  29 #define max(a,b) ((a)>(b)?(a):(b))
  30 #endif
  31
  32 #ifndef min
  33 #define min(a,b) ((a)<(b)?(a):(b))
  34 #endif
  35
  36
  37
  38 #define LTT_MAGIC_NUMBER 0x00D6B7ED
  39 #define LTT_REV_MAGIC_NUMBER 0xEDB7D600
  40
  41 #define NSEC_PER_USEC 1000
  42
  43 #define LTT_PACKED_STRUCT __attribute__ ((packed))
  44
  45 /* Hardcoded facilities */
  46 #define LTT_FACILITY_CORE 0
  47
  48 /* Byte ordering */
  49 #define LTT_GET_BO(t) ((t)->reverse_bo)
  50
  51 #define LTT_HAS_FLOAT(t) ((t)->float_word_order!=0)
  52 #define LTT_GET_FLOAT_BO(t) \
  53   (((t)->float_word_order==__BYTE_ORDER)?0:1)
  54
  55 #define SEQUENCE_AVG_ELEMENTS 1000
  56
  57 /* Hardcoded core events */
  58 enum ltt_core_events {
  59     LTT_EVENT_FACILITY_LOAD,
  60     LTT_EVENT_FACILITY_UNLOAD,
  61     LTT_EVENT_HEARTBEAT,
  62     LTT_EVENT_HEARTBEAT_FULL,
  63     LTT_EVENT_STATE_DUMP_FACILITY_LOAD
  64 };
  65
  66
  67 #if 0
  68 /* enumeration definition */
  69
  70 typedef enum _BuildinEvent{
  71   TRACE_FACILITY_LOAD = 0,
  72   TRACE_BLOCK_START   = 17,
  73   TRACE_BLOCK_END     = 18,
  74   TRACE_TIME_HEARTBEAT= 19
  75 } BuildinEvent;
  76
  77
  78 /* structure definition */
  79
  80 typedef struct _FacilityLoad{
  81   gchar * name;
  82   LttChecksum checksum;
  83   guint32     base_code;
  84 } LTT_PACKED_STRUCT FacilityLoad;
  85
  86 typedef struct _BlockStart {
  87   LttTime       time;       //Time stamp of this block
  88   LttCycleCount cycle_count; //cycle count of the event
  89   guint32       block_id;    //block id
  90 } LTT_PACKED_STRUCT BlockStart;
  91
  92 typedef struct _BlockEnd {
  93   LttTime       time;       //Time stamp of this block
  94   LttCycleCount cycle_count; //cycle count of the event
  95   guint32       block_id;    //block id
  96 } LTT_PACKED_STRUCT BlockEnd;
  97 #endif //0
  98
  99
 100 typedef guint8 uint8_t;
 101 typedef guint16 uint16_t;
 102 typedef guint32 uint32_t;
 103 typedef guint64 uint64_t;
 104
 105 /* Hardcoded facility load event : this plus an preceding "name" string */
 106 struct LttFacilityLoad {
 107   guint32 checksum;
 108   guint32 id;
 109   guint32 int_size;
 110   guint32 long_size;
 111   guint32 pointer_size;
 112   guint32 size_t_size;
 113   guint32 has_alignment;
 114 } LTT_PACKED_STRUCT;
 115
 116 struct LttFacilityUnload {
 117   guint32 id;
 118 } LTT_PACKED_STRUCT;
 119
 120 struct LttStateDumpFacilityLoad {
 121   guint32 checksum;
 122   guint32 id;
 123   guint32 int_size;
 124   guint32 long_size;
 125   guint32 pointer_size;
 126   guint32 size_t_size;
 127   guint32  has_alignment;
 128 } LTT_PACKED_STRUCT;
 129
 130 /* Empty event */
 131 typedef struct _TimeHeartbeat {
 132 } LTT_PACKED_STRUCT TimeHeartbeat;
 133
 134 typedef struct _TimeHeartbeatFull {
 135   guint64 tsc;
 136 } LTT_PACKED_STRUCT TimeHeartbeatFull;
 137
 138 struct ltt_event_header_hb {
 139   uint32_t      timestamp;
 140   uint16_t      event_id;
 141   uint16_t      event_size;
 142 } LTT_PACKED_STRUCT;
 143
 144 struct ltt_event_header_nohb {
 145   uint64_t      timestamp;
 146   uint16_t      event_id;
 147   uint16_t      event_size;
 148 } LTT_PACKED_STRUCT;
 149
 150
 151 /* Block and trace headers */
 152
 153 struct ltt_trace_header_any {
 154   uint32_t        magic_number;
 155   uint32_t        arch_type;
 156   uint32_t        arch_variant;
 157   uint32_t        float_word_order;
 158   uint8_t         arch_size;
 159   uint8_t         major_version;
 160   uint8_t         minor_version;
 161   uint8_t         flight_recorder;
 162   uint8_t         has_heartbeat;
 163   uint8_t         has_alignment;  /* Event header alignment */
 164   uint32_t        freq_scale;
 165 } LTT_PACKED_STRUCT;
 166
 167 struct ltt_trace_header_1_0 {
 168   uint32_t        magic_number;
 169   uint32_t        arch_type;
 170   uint32_t        arch_variant;
 171   uint32_t        float_word_order;
 172   uint8_t         arch_size;
 173   uint8_t         major_version;
 174   uint8_t         minor_version;
 175   uint8_t         flight_recorder;
 176   uint8_t         has_heartbeat;
 177   uint8_t         has_alignment;  /* Event header alignment */
 178   uint8_t         tsc_lsb_truncate;
 179   uint8_t         tscbits;
 180   uint32_t        freq_scale;
 181   uint64_t        start_freq;
 182   uint64_t        start_tsc;
 183   uint64_t        start_monotonic;
 184   uint64_t        start_time_sec;
 185   uint64_t        start_time_usec;
 186 } LTT_PACKED_STRUCT;
 187
 188
 189 struct ltt_block_start_header {
 190   struct {
 191     uint64_t                cycle_count;
 192     uint64_t                freq;
 193   } begin;
 194   struct {
 195     uint64_t                cycle_count;
 196     uint64_t                freq;
 197   } end;
 198   uint32_t                lost_size;  /* Size unused at the end of the buffer */
 199   uint32_t                buf_size;   /* The size of this sub-buffer */
 200   struct ltt_trace_header_any trace[0];
 201 } LTT_PACKED_STRUCT;
 202
 203
 204 #if 0
 205 struct _LttType{
 206 // LTTV does not care about type names. Everything is a field.
 207 // GQuark type_name;                //type name if it is a named type
 208   gchar * fmt;
 209   guint size;
 210   LttTypeEnum type_class;          //which type
 211   GHashTable *enum_map;                 //maps enum labels to numbers.
 212   gint32 highest_value;                 //For enum
 213   gint32 lowest_value;                  //For enum
 214   GArray *fields;     // Array of LttFields, for array, sequence, union, struct.
 215   GData *fields_by_name;
 216   guint network;  // Is the type in network byte order ?
 217   //part added by gaby for fmt:
 218   char *header;
 219   char *separator;
 220   char *footer;
 221 };
 222 #endif //0
 223
 224 #if 0
 225 struct _LttEventType{
 226   GQuark name;
 227   gchar * description;
 228   guint index;            //id of the event type within the facility
 229   struct marker_info *info;
 230   GArray * fields;        //event's fields (LttField)
 231   GData *fields_by_name;
 232   int has_compact_data;       //event header contains compact data (first field)
 233 };
 234 #endif //0
 235
 236 /* Structure LttEvent and LttEventPosition must begin with the _exact_ same
 237  * fields in the exact same order. LttEventPosition is a parent of LttEvent. */
 238 struct _LttEvent{
 239
 240   /* Begin of LttEventPosition fields */
 241   LttTracefile  *tracefile;
 242   unsigned int  block;
 243   unsigned int  offset;
 244
 245   /* Timekeeping */
 246   uint64_t                tsc;       /* Current timestamp counter */
 247
 248   /* End of LttEventPosition fields */
 249
 250   guint32  timestamp;        /* truncated timestamp */
 251
 252   guint16 event_id;
 253
 254   LttTime event_time;
 255
 256   void * data;               //event data
 257   guint  data_size;
 258   guint  event_size;         //event_size field of the header :
 259                              //used to verify data_size from facility.
 260   uint32_t compact_data;
 261
 262   int      count;                    //the number of overflow of cycle count
 263   gint64 overflow_nsec;              //precalculated nsec for overflows
 264 };
 265
 266 struct _LttEventPosition{
 267   LttTracefile  *tracefile;
 268   unsigned int  block;
 269   unsigned int  offset;
 270
 271   /* Timekeeping */
 272   uint64_t                tsc;       /* Current timestamp counter */
 273 };
 274
 275
 276 enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };
 277
 278 #if 0
 279 struct _LttField{
 280   GQuark name;
 281   gchar *description;
 282   LttType field_type;      //field type
 283
 284   off_t offset_root;            //offset from the root
 285   enum field_status fixed_root; //offset fixed according to the root
 286
 287   guint field_size;       // size of the field
 288                           // Only if field type size is set to 0
 289                           // (it's variable), then the field_size should be
 290                           // dynamically calculated while reading the trace
 291                           // and put here. Otherwise, the field_size always
 292                           // equals the type size.
 293   off_t array_offset;     // offset of the beginning of the array (for array
 294                           // and sequences)
 295   GArray * dynamic_offsets; // array of offsets calculated dynamically at
 296                             // each event for sequences and arrays that
 297                             // contain variable length fields.
 298 };
 299 #endif //0
 300 #if 0
 301 struct _LttFacility{
 302   LttTrace  *trace;
 303   GQuark name;
 304   guint32 checksum;      //checksum of the facility
 305   guint32  id;          //id of the facility
 306
 307   guint32 int_size;
 308   guint32 long_size;
 309   guint32 pointer_size;
 310   guint32 size_t_size;
 311   guint32 alignment;
 312
 313   GArray *events;
 314   GData *events_by_name;
 315  // not necessary in LTTV GData *named_types;
 316
 317   unsigned char exists; /* 0 does not exist, 1 exists */
 318 };
 319 #endif //0
 320
 321 typedef struct _LttBuffer {
 322   void * head;
 323   unsigned int index;
 324
 325   struct {
 326     LttTime                 timestamp;
 327     uint64_t                cycle_count;
 328     uint64_t                freq; /* Frequency in khz */
 329   } begin;
 330   struct {
 331     LttTime                 timestamp;
 332     uint64_t                cycle_count;
 333     uint64_t                freq; /* Frequency in khz */
 334   } end;
 335   uint32_t                lost_size; /* Size unused at the end of the buffer */
 336
 337   /* Timekeeping */
 338   uint64_t                tsc;       /* Current timestamp counter */
 339   uint64_t                freq; /* Frequency in khz */
 340   //double                  nsecs_per_cycle;  /* Precalculated from freq */
 341   guint32                 cyc2ns_scale;
 342 } LttBuffer;
 343
 344 struct _LttTracefile{
 345   gboolean cpu_online;               //is the cpu online ?
 346   GQuark long_name;                  //tracefile complete filename
 347   GQuark name;                       //tracefile name
 348   guint cpu_num;                     //cpu number of the tracefile
 349   guint  tid;                         //Usertrace tid, else 0
 350   guint pgid;                         //Usertrace pgid, else 0
 351   guint64 creation;                   //Usertrace creation, else 0
 352   LttTrace * trace;                  //trace containing the tracefile
 353   int fd;                            //file descriptor
 354   off_t file_size;                   //file size
 355   //unsigned block_size;               //block_size
 356   guint num_blocks;           //number of blocks in the file
 357   gboolean  reverse_bo;              //must we reverse byte order ?
 358   gboolean  float_word_order;        //what is the byte order of floats ?
 359   size_t    has_alignment;           //alignment of events in the tracefile.
 360                                      // 0 or the architecture size in bytes.
 361
 362   guint8    has_heartbeat;
 363   size_t    buffer_header_size;
 364   int       compact;                 //compact tracefile ?
 365   uint8_t   tsc_lsb_truncate;
 366   uint8_t   tscbits;
 367   uint8_t   tsc_msb_cutoff;
 368   uint64_t  tsc_mask;
 369   uint64_t  tsc_mask_next_bit;       //next MSB after the mask
 370
 371   /* Current event */
 372   LttEvent event;                    //Event currently accessible in the trace
 373
 374   /* Current block */
 375   LttBuffer buffer;                  //current buffer
 376   guint32 buf_size;                  /* The size of blocks */
 377
 378   /* Time flow */
 379   //unsigned int      count;           //the number of overflow of cycle count
 380   //double nsec_per_cycle;             //Nsec per cycle
 381   //TimeHeartbeat * last_heartbeat;    //last heartbeat
 382
 383   //LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
 384   //void * last_event_pos;
 385
 386   //LttTime prev_block_end_time;       //the end time of previous block
 387   //LttTime prev_event_time;           //the time of the previous event
 388   //LttCycleCount pre_cycle_count;     //previous cycle count of the event
 389 };
 390
 391 struct _LttTrace{
 392   GQuark pathname;                          //the pathname of the trace
 393   //LttSystemDescription * system_description;//system description
 394
 395   GArray *facilities_by_num;            /* fac_id as index in array */
 396   GData *facilities_by_name;            /* fac name (GQuark) as index */
 397                                         /* Points to array of fac_id of all the
 398                                         * facilities that has this name. */
 399   guint     num_cpu;
 400
 401   guint32   arch_type;
 402   guint32   arch_variant;
 403   guint8    arch_size;
 404   guint8    ltt_major_version;
 405   guint8    ltt_minor_version;
 406   guint8    flight_recorder;
 407   guint32    freq_scale;
 408   uint64_t  start_freq;
 409   uint64_t  start_tsc;
 410   uint64_t  start_monotonic;
 411   LttTime   start_time;
 412   LttTime   start_time_from_tsc;
 413   uint8_t   compact_event_bits;
 414
 415   GData     *tracefiles;                    //tracefiles groups
 416   /* Support for markers */
 417   GArray    *markers;                       //indexed by marker ID
 418   GHashTable *markers_hash;                 //indexed by name hash
 419 };
 420
 421 /* The characteristics of the system on which the trace was obtained
 422    is described in a LttSystemDescription structure. */
 423
 424 struct _LttSystemDescription {
 425   gchar *description;
 426   gchar *node_name;
 427   gchar *domain_name;
 428   unsigned nb_cpu;
 429   LttArchSize size;
 430   LttArchEndian endian;
 431   gchar *kernel_name;
 432   gchar *kernel_release;
 433   gchar *kernel_version;
 434   gchar *machine;
 435   gchar *processor;
 436   gchar *hardware_platform;
 437   gchar *operating_system;
 438   LttTime trace_start;
 439   LttTime trace_end;
 440 };
 441
 442 /*****************************************************************************
 443  macro for size of some data types
 444  *****************************************************************************/
 445 // alignment -> dynamic!
 446
 447 //#define TIMESTAMP_SIZE    sizeof(guint32)
 448 //#define EVENT_ID_SIZE     sizeof(guint16)
 449 //#define EVENT_HEADER_SIZE (TIMESTAMP_SIZE + EVENT_ID_SIZE)
 450
 451
 452 off_t get_alignment(LttField *field);
 453
 454 /* Calculate the offset needed to align the type.
 455  * If has_alignment is 0, alignment is disactivated.
 456  * else, the function returns the offset needed to
 457  * align align_drift on the has_alignment value (should be
 458  * the size of the architecture). */
 459 static inline unsigned int ltt_align(size_t align_drift,
 460           size_t size_of_type,
 461           size_t has_alignment)
 462 {
 463   size_t alignment = min(has_alignment, size_of_type);
 464
 465   if(!has_alignment) return 0;
 466
 467   g_assert(size_of_type != 0);
 468   return ((alignment - align_drift) & (alignment-1));
 469 }
 470
 471
 472 #endif /* LTT_PRIVATE_H */