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 /* Byte ordering */
  45 #define LTT_GET_BO(t) ((t)->reverse_bo)
  46
  47 #define LTT_HAS_FLOAT(t) ((t)->float_word_order ! =0)
  48 #define LTT_GET_FLOAT_BO(t) \
  49   (((t)->float_word_order == __BYTE_ORDER) ? 0 : 1)
  50
  51 #define SEQUENCE_AVG_ELEMENTS 1000
  52
  53 /*
  54  * offsetof taken from Linux kernel.
  55  */
  56 #undef offsetof
  57 #ifdef __compiler_offsetof
  58 #define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
  59 #else
  60 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  61 #endif
  62
  63 typedef guint8 uint8_t;
  64 typedef guint16 uint16_t;
  65 typedef guint32 uint32_t;
  66 typedef guint64 uint64_t;
  67
  68 /* Subbuffer header */
  69 struct ltt_subbuffer_header_2_2 {
  70         uint64_t cycle_count_begin;     /* Cycle count at subbuffer start */
  71         uint64_t cycle_count_end;       /* Cycle count at subbuffer end */
  72         uint32_t magic_number;          /*
  73                                          * Trace magic number.
  74                                          * contains endianness information.
  75                                          */
  76         uint8_t major_version;
  77         uint8_t minor_version;
  78         uint8_t arch_size;              /* Architecture pointer size */
  79         uint8_t alignment;              /* LTT data alignment */
  80         uint64_t start_time_sec;        /* NTP-corrected start time */
  81         uint64_t start_time_usec;
  82         uint64_t start_freq;            /*
  83                                          * Frequency at trace start,
  84                                          * used all along the trace.
  85                                          */
  86         uint32_t freq_scale;            /* Frequency scaling */
  87         uint32_t lost_size;             /* Size unused at end of subbuffer */
  88         uint32_t buf_size;              /* Size of this subbuffer */
  89         uint32_t events_lost;           /*
  90                                          * Events lost in this subbuffer since
  91                                          * last subbuffer switch.
  92                                          */
  93         uint32_t subbuf_corrupt;        /*
  94                                          * Corrupted (lost) subbuffers since
  95                                          * the begginig of the trace.
  96                                          */
  97         char header_end[0];             /* End of header */
  98 };
  99
 100 typedef struct ltt_subbuffer_header_2_2 ltt_subbuffer_header_t;
 101
 102 /*
 103  * Return header size without padding after the structure. Don't use packed
 104  * structure because gcc generates inefficient code on some architectures
 105  * (powerpc, mips..)
 106  */
 107 static inline size_t ltt_subbuffer_header_size(void)
 108 {
 109         return offsetof(ltt_subbuffer_header_t, header_end);
 110 }
 111
 112 enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };
 113
 114 typedef struct _LttBuffer {
 115   void * head;
 116   unsigned int index;
 117
 118   struct {
 119     LttTime                 timestamp;
 120     uint64_t                cycle_count;
 121     uint64_t                freq; /* Frequency in khz */
 122   } begin;
 123   struct {
 124     LttTime                 timestamp;
 125     uint64_t                cycle_count;
 126     uint64_t                freq; /* Frequency in khz */
 127   } end;
 128   uint32_t                lost_size; /* Size unused at the end of the buffer */
 129
 130   /* Timekeeping */
 131   uint64_t                tsc;       /* Current timestamp counter */
 132   uint64_t                freq; /* Frequency in khz */
 133   guint32                 cyc2ns_scale;
 134 } LttBuffer;
 135
 136 struct LttTracefile {
 137   gboolean cpu_online;               //is the cpu online ?
 138   GQuark long_name;                  //tracefile complete filename
 139   GQuark name;                       //tracefile name
 140   guint cpu_num;                     //cpu number of the tracefile
 141   guint  tid;                         //Usertrace tid, else 0
 142   guint pgid;                         //Usertrace pgid, else 0
 143   guint64 creation;                   //Usertrace creation, else 0
 144   LttTrace * trace;                  //trace containing the tracefile
 145   int fd;                            //file descriptor
 146   off_t file_size;                   //file size
 147   //unsigned block_size;               //block_size
 148   guint num_blocks;           //number of blocks in the file
 149   gboolean  reverse_bo;              //must we reverse byte order ?
 150   gboolean  float_word_order;        //what is the byte order of floats ?
 151   size_t    alignment;               //alignment of events in the tracefile.
 152                                      // 0 or the architecture size in bytes.
 153
 154   size_t    buffer_header_size;
 155   uint8_t   tscbits;
 156   uint8_t   eventbits;
 157   uint64_t  tsc_mask;
 158   uint64_t  tsc_mask_next_bit;       //next MSB after the mask<
 159   uint32_t  events_lost;
 160   uint32_t  subbuf_corrupt;
 161
 162   /* Current event */
 163   LttEvent event;                    //Event currently accessible in the trace
 164
 165   /* Current block */
 166   LttBuffer buffer;                  //current buffer
 167   guint32 buf_size;                  /* The size of blocks */
 168 };
 169
 170 /* The characteristics of the system on which the trace was obtained
 171    is described in a LttSystemDescription structure. */
 172
 173 struct LttSystemDescription {
 174   gchar *description;
 175   gchar *node_name;
 176   gchar *domain_name;
 177   unsigned nb_cpu;
 178   LttArchSize size;
 179   LttArchEndian endian;
 180   gchar *kernel_name;
 181   gchar *kernel_release;
 182   gchar *kernel_version;
 183   gchar *machine;
 184   gchar *processor;
 185   gchar *hardware_platform;
 186   gchar *operating_system;
 187   LttTime trace_start;
 188   LttTime trace_end;
 189 };
 190
 191 /* Calculate the offset needed to align the type.
 192  * If alignment is 0, alignment is disactivated.
 193  * else, the function returns the offset needed to
 194  * align align_drift on the alignment value (should be
 195  * the size of the architecture). */
 196 static inline unsigned int ltt_align(size_t align_drift,
 197           size_t size_of_type,
 198           size_t alignment)
 199 {
 200   size_t align_offset = min(alignment, size_of_type);
 201
 202   if(!alignment)
 203     return 0;
 204
 205   g_assert(size_of_type != 0);
 206   return ((align_offset - align_drift) & (align_offset-1));
 207 }
 208
 209
 210 #endif /* LTT_PRIVATE_H */