[lttv.git] / tags / LinuxTraceToolkitViewer-0.10.0-pre-115102007 / ltt / ltt-private.h

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Xiangxiu Yang
 *               2006 Mathieu Desnoyers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License Version 2.1 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef LTT_PRIVATE_H
#define LTT_PRIVATE_H

#include <glib.h>
#include <sys/types.h>
#include <ltt/ltt.h>
#include <endian.h>
#include <ltt/event.h>
#include <ltt/marker.h>
#include <ltt/trace.h>

#ifndef max
#define max(a,b) ((a)>(b)?(a):(b))
#endif

#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#endif


#define LTT_MAGIC_NUMBER 0x00D6B7ED
#define LTT_REV_MAGIC_NUMBER 0xEDB7D600

#define NSEC_PER_USEC 1000

#define LTT_PACKED_STRUCT __attribute__ ((packed))

/* Hardcoded facilities */
#define LTT_FACILITY_CORE 0
 
/* Byte ordering */
#define LTT_GET_BO(t) ((t)->reverse_bo)

#define LTT_HAS_FLOAT(t) ((t)->float_word_order!=0)
#define LTT_GET_FLOAT_BO(t) \
  (((t)->float_word_order==__BYTE_ORDER)?0:1)

#define SEQUENCE_AVG_ELEMENTS 1000
                               
/* Hardcoded core events */
enum ltt_core_events {
    LTT_EVENT_FACILITY_LOAD,
    LTT_EVENT_FACILITY_UNLOAD,
    LTT_EVENT_HEARTBEAT,
    LTT_EVENT_HEARTBEAT_FULL,
    LTT_EVENT_STATE_DUMP_FACILITY_LOAD
};


#if 0
/* enumeration definition */

typedef enum _BuildinEvent{
  TRACE_FACILITY_LOAD = 0,
  TRACE_BLOCK_START   = 17,
  TRACE_BLOCK_END     = 18,
  TRACE_TIME_HEARTBEAT= 19
} BuildinEvent;


/* structure definition */

typedef struct _FacilityLoad{
  gchar * name;
  LttChecksum checksum;
  guint32     base_code;
} LTT_PACKED_STRUCT FacilityLoad;

typedef struct _BlockStart {
  LttTime       time;       //Time stamp of this block
  LttCycleCount cycle_count; //cycle count of the event
  guint32       block_id;    //block id 
} LTT_PACKED_STRUCT BlockStart;

typedef struct _BlockEnd {
  LttTime       time;       //Time stamp of this block
  LttCycleCount cycle_count; //cycle count of the event
  guint32       block_id;    //block id 
} LTT_PACKED_STRUCT BlockEnd;
#endif //0


typedef guint8 uint8_t;
typedef guint16 uint16_t;
typedef guint32 uint32_t;
typedef guint64 uint64_t;

struct ltt_event_header_hb {
  uint32_t      timestamp;
  uint16_t      event_id;
  uint16_t      event_size;
} LTT_PACKED_STRUCT;

struct ltt_event_header_nohb {
  uint64_t      timestamp;
  uint16_t      event_id;
  uint16_t      event_size;
} LTT_PACKED_STRUCT;


/* Block and trace headers */

struct ltt_trace_header_any {
  uint32_t        magic_number;
  uint32_t        arch_type;
  uint32_t        arch_variant;
  uint32_t        float_word_order;
  uint8_t         arch_size;
  uint8_t         major_version;
  uint8_t         minor_version;
  uint8_t         flight_recorder;
  uint8_t         has_heartbeat;
  uint8_t         alignment;  /* Event header alignment */
  uint32_t        freq_scale;
} LTT_PACKED_STRUCT;

struct ltt_trace_header_1_0 {
  uint32_t        magic_number;
  uint32_t        arch_type;
  uint32_t        arch_variant;
  uint32_t        float_word_order;
  uint8_t         arch_size;
  uint8_t         major_version;
  uint8_t         minor_version;
  uint8_t         flight_recorder;
  uint8_t         has_heartbeat;
  uint8_t         alignment;  /* Event header alignment */
  uint8_t         tsc_lsb_truncate;
  uint8_t         tscbits;
  uint8_t         compact_data_shift;
  uint32_t        freq_scale;
  uint64_t        start_freq;
  uint64_t        start_tsc;
  uint64_t        start_monotonic;
  uint64_t        start_time_sec;
  uint64_t        start_time_usec;
} LTT_PACKED_STRUCT;


struct ltt_block_start_header {
  struct { 
    uint64_t                cycle_count;
    uint64_t                freq;
  } begin;
  struct {
    uint64_t                cycle_count;
    uint64_t                freq;
  } end;
  uint32_t                lost_size;  /* Size unused at the end of the buffer */
  uint32_t                buf_size;   /* The size of this sub-buffer */
  struct ltt_trace_header_any trace[0];
} LTT_PACKED_STRUCT;


#if 0
struct _LttType{
// LTTV does not care about type names. Everything is a field.
// GQuark type_name;                //type name if it is a named type
  gchar * fmt;
  guint size;
  LttTypeEnum type_class;          //which type
  GHashTable *enum_map;                 //maps enum labels to numbers.
  gint32 highest_value;			//For enum
  gint32 lowest_value;			//For enum
  GArray *fields;     // Array of LttFields, for array, sequence, union, struct.
  GData *fields_by_name;
  guint network;  // Is the type in network byte order ?
  //part added by gaby for fmt:
  char *header;
  char *separator;
  char *footer;
};
#endif //0

#if 0
struct _LttEventType{
  GQuark name;
  gchar * description;
  guint index;            //id of the event type within the facility
  struct marker_info *info;
  GArray * fields;        //event's fields (LttField)
  GData *fields_by_name;
  int has_compact_data;       //event header contains compact data (first field)
};
#endif //0

enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };

#if 0
struct _LttField{
  GQuark name;
  gchar *description;
  LttType field_type;      //field type

  off_t offset_root;            //offset from the root
  enum field_status fixed_root; //offset fixed according to the root

  guint field_size;       // size of the field
                          // Only if field type size is set to 0
                          // (it's variable), then the field_size should be
                          // dynamically calculated while reading the trace
                          // and put here. Otherwise, the field_size always
                          // equals the type size.
  off_t array_offset;     // offset of the beginning of the array (for array
                          // and sequences)
  GArray * dynamic_offsets; // array of offsets calculated dynamically at
                            // each event for sequences and arrays that
                            // contain variable length fields.
};
#endif //0
#if 0
struct _LttFacility{
  LttTrace  *trace;
  GQuark name;
  guint32 checksum;      //checksum of the facility 
  guint32  id;          //id of the facility
 
  guint32 int_size;
  guint32 long_size;
  guint32 pointer_size;
  guint32 size_t_size;
  guint32 alignment;

  GArray *events;
  GData *events_by_name;
 // not necessary in LTTV GData *named_types;
  
  unsigned char exists; /* 0 does not exist, 1 exists */
};
#endif //0

typedef struct _LttBuffer {
  void * head;
  unsigned int index;

  struct {
    LttTime                 timestamp;
    uint64_t                cycle_count;
    uint64_t                freq; /* Frequency in khz */
  } begin;
  struct {
    LttTime                 timestamp;
    uint64_t                cycle_count;
    uint64_t                freq; /* Frequency in khz */
  } end;
  uint32_t                lost_size; /* Size unused at the end of the buffer */

  /* Timekeeping */
  uint64_t                tsc;       /* Current timestamp counter */
  uint64_t                freq; /* Frequency in khz */
  //double                  nsecs_per_cycle;  /* Precalculated from freq */
  guint32                 cyc2ns_scale;
} LttBuffer;

struct LttTracefile {
  gboolean cpu_online;               //is the cpu online ?
  GQuark long_name;                  //tracefile complete filename
  GQuark name;                       //tracefile name
  guint cpu_num;                     //cpu number of the tracefile
  guint  tid;                         //Usertrace tid, else 0
  guint pgid;                         //Usertrace pgid, else 0
  guint64 creation;                   //Usertrace creation, else 0
  LttTrace * trace;                  //trace containing the tracefile
  int fd;                            //file descriptor 
  off_t file_size;                   //file size
  //unsigned block_size;               //block_size
  guint num_blocks;           //number of blocks in the file
  gboolean  reverse_bo;              //must we reverse byte order ?
  gboolean  float_word_order;        //what is the byte order of floats ?
  size_t    alignment;               //alignment of events in the tracefile.
                                     // 0 or the architecture size in bytes.

  guint8    has_heartbeat;
  size_t    buffer_header_size;
  int       compact;                 //compact tracefile ?
  uint8_t   tsc_lsb_truncate;
  uint8_t   tscbits;
  uint8_t   tsc_msb_cutoff;
  uint8_t   compact_event_bits;
  uint64_t  tsc_mask;
  uint64_t  tsc_mask_next_bit;       //next MSB after the mask

  /* Current event */
  LttEvent event;                    //Event currently accessible in the trace

  /* Current block */
  LttBuffer buffer;                  //current buffer
  guint32 buf_size;                  /* The size of blocks */

  /* Time flow */
  //unsigned int      count;           //the number of overflow of cycle count
  //double nsec_per_cycle;             //Nsec per cycle
  //TimeHeartbeat * last_heartbeat;    //last heartbeat

  //LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
  //void * last_event_pos;

  //LttTime prev_block_end_time;       //the end time of previous block
  //LttTime prev_event_time;           //the time of the previous event
  //LttCycleCount pre_cycle_count;     //previous cycle count of the event
};

/* The characteristics of the system on which the trace was obtained
   is described in a LttSystemDescription structure. */

struct LttSystemDescription {
  gchar *description;
  gchar *node_name;
  gchar *domain_name;
  unsigned nb_cpu;
  LttArchSize size;
  LttArchEndian endian;
  gchar *kernel_name;
  gchar *kernel_release;
  gchar *kernel_version;
  gchar *machine;
  gchar *processor;
  gchar *hardware_platform;
  gchar *operating_system;
  LttTime trace_start;
  LttTime trace_end;
};

/*****************************************************************************
 macro for size of some data types
 *****************************************************************************/
// alignment -> dynamic!

//#define TIMESTAMP_SIZE    sizeof(guint32)
//#define EVENT_ID_SIZE     sizeof(guint16)
//#define EVENT_HEADER_SIZE (TIMESTAMP_SIZE + EVENT_ID_SIZE)


//off_t get_alignment(LttField *field);

/* Calculate the offset needed to align the type.
 * If alignment is 0, alignment is disactivated.
 * else, the function returns the offset needed to
 * align align_drift on the alignment value (should be
 * the size of the architecture). */
static inline unsigned int ltt_align(size_t align_drift,
          size_t size_of_type,
          size_t alignment)
{
  size_t align_offset = min(alignment, size_of_type);
  
  if(!alignment)
    return 0;
  
  g_assert(size_of_type != 0);
  return ((align_offset - align_drift) & (align_offset-1));
}


#endif /* LTT_PRIVATE_H */
Commit	Line	Data
0bc7c2cd	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	#if 0
71	/* enumeration definition */
72
73	typedef enum _BuildinEvent{
74	TRACE_FACILITY_LOAD = 0,
75	TRACE_BLOCK_START = 17,
76	TRACE_BLOCK_END = 18,
77	TRACE_TIME_HEARTBEAT= 19
78	} BuildinEvent;
79
80
81	/* structure definition */
82
83	typedef struct _FacilityLoad{
84	gchar * name;
85	LttChecksum checksum;
86	guint32 base_code;
87	} LTT_PACKED_STRUCT FacilityLoad;
88
89	typedef struct _BlockStart {
90	LttTime time; //Time stamp of this block
91	LttCycleCount cycle_count; //cycle count of the event
92	guint32 block_id; //block id
93	} LTT_PACKED_STRUCT BlockStart;
94
95	typedef struct _BlockEnd {
96	LttTime time; //Time stamp of this block
97	LttCycleCount cycle_count; //cycle count of the event
98	guint32 block_id; //block id
99	} LTT_PACKED_STRUCT BlockEnd;
100	#endif //0
101
102
103	typedef guint8 uint8_t;
104	typedef guint16 uint16_t;
105	typedef guint32 uint32_t;
106	typedef guint64 uint64_t;
107
108	struct ltt_event_header_hb {
109	uint32_t timestamp;
110	uint16_t event_id;
111	uint16_t event_size;
112	} LTT_PACKED_STRUCT;
113
114	struct ltt_event_header_nohb {
115	uint64_t timestamp;
116	uint16_t event_id;
117	uint16_t event_size;
118	} LTT_PACKED_STRUCT;
119
120
121	/* Block and trace headers */
122
123	struct ltt_trace_header_any {
124	uint32_t magic_number;
125	uint32_t arch_type;
126	uint32_t arch_variant;
127	uint32_t float_word_order;
128	uint8_t arch_size;
129	uint8_t major_version;
130	uint8_t minor_version;
131	uint8_t flight_recorder;
132	uint8_t has_heartbeat;
133	uint8_t alignment; /* Event header alignment */
134	uint32_t freq_scale;
135	} LTT_PACKED_STRUCT;
136
137	struct ltt_trace_header_1_0 {
138	uint32_t magic_number;
139	uint32_t arch_type;
140	uint32_t arch_variant;
141	uint32_t float_word_order;
142	uint8_t arch_size;
143	uint8_t major_version;
144	uint8_t minor_version;
145	uint8_t flight_recorder;
146	uint8_t has_heartbeat;
147	uint8_t alignment; /* Event header alignment */
148	uint8_t tsc_lsb_truncate;
149	uint8_t tscbits;
150	uint8_t compact_data_shift;
151	uint32_t freq_scale;
152	uint64_t start_freq;
153	uint64_t start_tsc;
154	uint64_t start_monotonic;
155	uint64_t start_time_sec;
156	uint64_t start_time_usec;
157	} LTT_PACKED_STRUCT;
158
159
160	struct ltt_block_start_header {
161	struct {
162	uint64_t cycle_count;
163	uint64_t freq;
164	} begin;
165	struct {
166	uint64_t cycle_count;
167	uint64_t freq;
168	} end;
169	uint32_t lost_size; /* Size unused at the end of the buffer */
170	uint32_t buf_size; /* The size of this sub-buffer */
171	struct ltt_trace_header_any trace[0];
172	} LTT_PACKED_STRUCT;
173
174
175	#if 0
176	struct _LttType{
177	// LTTV does not care about type names. Everything is a field.
178	// GQuark type_name; //type name if it is a named type
179	gchar * fmt;
180	guint size;
181	LttTypeEnum type_class; //which type
182	GHashTable *enum_map; //maps enum labels to numbers.
183	gint32 highest_value; //For enum
184	gint32 lowest_value; //For enum
185	GArray *fields; // Array of LttFields, for array, sequence, union, struct.
186	GData *fields_by_name;
187	guint network; // Is the type in network byte order ?
188	//part added by gaby for fmt:
189	char *header;
190	char *separator;
191	char *footer;
192	};
193	#endif //0
194
195	#if 0
196	struct _LttEventType{
197	GQuark name;
198	gchar * description;
199	guint index; //id of the event type within the facility
200	struct marker_info *info;
201	GArray * fields; //event's fields (LttField)
202	GData *fields_by_name;
203	int has_compact_data; //event header contains compact data (first field)
204	};
205	#endif //0
206
207	enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };
208
209	#if 0
210	struct _LttField{
211	GQuark name;
212	gchar *description;
213	LttType field_type; //field type
214
215	off_t offset_root; //offset from the root
216	enum field_status fixed_root; //offset fixed according to the root
217
218	guint field_size; // size of the field
219	// Only if field type size is set to 0
220	// (it's variable), then the field_size should be
221	// dynamically calculated while reading the trace
222	// and put here. Otherwise, the field_size always
223	// equals the type size.
224	off_t array_offset; // offset of the beginning of the array (for array
225	// and sequences)
226	GArray * dynamic_offsets; // array of offsets calculated dynamically at
227	// each event for sequences and arrays that
228	// contain variable length fields.
229	};
230	#endif //0
231	#if 0
232	struct _LttFacility{
233	LttTrace *trace;
234	GQuark name;
235	guint32 checksum; //checksum of the facility
236	guint32 id; //id of the facility
237
238	guint32 int_size;
239	guint32 long_size;
240	guint32 pointer_size;
241	guint32 size_t_size;
242	guint32 alignment;
243
244	GArray *events;
245	GData *events_by_name;
246	// not necessary in LTTV GData *named_types;
247
248	unsigned char exists; /* 0 does not exist, 1 exists */
249	};
250	#endif //0
251
252	typedef struct _LttBuffer {
253	void * head;
254	unsigned int index;
255
256	struct {
257	LttTime timestamp;
258	uint64_t cycle_count;
259	uint64_t freq; /* Frequency in khz */
260	} begin;
261	struct {
262	LttTime timestamp;
263	uint64_t cycle_count;
264	uint64_t freq; /* Frequency in khz */
265	} end;
266	uint32_t lost_size; /* Size unused at the end of the buffer */
267
268	/* Timekeeping */
269	uint64_t tsc; /* Current timestamp counter */
270	uint64_t freq; /* Frequency in khz */
271	//double nsecs_per_cycle; /* Precalculated from freq */
272	guint32 cyc2ns_scale;
273	} LttBuffer;
274
275	struct LttTracefile {
276	gboolean cpu_online; //is the cpu online ?
277	GQuark long_name; //tracefile complete filename
278	GQuark name; //tracefile name
279	guint cpu_num; //cpu number of the tracefile
280	guint tid; //Usertrace tid, else 0
281	guint pgid; //Usertrace pgid, else 0
282	guint64 creation; //Usertrace creation, else 0
283	LttTrace * trace; //trace containing the tracefile
284	int fd; //file descriptor
285	off_t file_size; //file size
286	//unsigned block_size; //block_size
287	guint num_blocks; //number of blocks in the file
288	gboolean reverse_bo; //must we reverse byte order ?
289	gboolean float_word_order; //what is the byte order of floats ?
290	size_t alignment; //alignment of events in the tracefile.
291	// 0 or the architecture size in bytes.
292
293	guint8 has_heartbeat;
294	size_t buffer_header_size;
295	int compact; //compact tracefile ?
296	uint8_t tsc_lsb_truncate;
297	uint8_t tscbits;
298	uint8_t tsc_msb_cutoff;
299	uint8_t compact_event_bits;
300	uint64_t tsc_mask;
301	uint64_t tsc_mask_next_bit; //next MSB after the mask
302
303	/* Current event */
304	LttEvent event; //Event currently accessible in the trace
305
306	/* Current block */
307	LttBuffer buffer; //current buffer
308	guint32 buf_size; /* The size of blocks */
309
310	/* Time flow */
311	//unsigned int count; //the number of overflow of cycle count
312	//double nsec_per_cycle; //Nsec per cycle
313	//TimeHeartbeat * last_heartbeat; //last heartbeat
314
315	//LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
316	//void * last_event_pos;
317
318	//LttTime prev_block_end_time; //the end time of previous block
319	//LttTime prev_event_time; //the time of the previous event
320	//LttCycleCount pre_cycle_count; //previous cycle count of the event
321	};
322
323	/* The characteristics of the system on which the trace was obtained
324	is described in a LttSystemDescription structure. */
325
326	struct LttSystemDescription {
327	gchar *description;
328	gchar *node_name;
329	gchar *domain_name;
330	unsigned nb_cpu;
331	LttArchSize size;
332	LttArchEndian endian;
333	gchar *kernel_name;
334	gchar *kernel_release;
335	gchar *kernel_version;
336	gchar *machine;
337	gchar *processor;
338	gchar *hardware_platform;
339	gchar *operating_system;
340	LttTime trace_start;
341	LttTime trace_end;
342	};
343
344	/*****************************************************************************
345	macro for size of some data types
346	*****************************************************************************/
347	// alignment -> dynamic!
348
349	//#define TIMESTAMP_SIZE sizeof(guint32)
350	//#define EVENT_ID_SIZE sizeof(guint16)
351	//#define EVENT_HEADER_SIZE (TIMESTAMP_SIZE + EVENT_ID_SIZE)
352
353
354	//off_t get_alignment(LttField *field);
355
356	/* Calculate the offset needed to align the type.
357	* If alignment is 0, alignment is disactivated.
358	* else, the function returns the offset needed to
359	* align align_drift on the alignment value (should be
360	* the size of the architecture). */
361	static inline unsigned int ltt_align(size_t align_drift,
362	size_t size_of_type,
363	size_t alignment)
364	{
365	size_t align_offset = min(alignment, size_of_type);
366
367	if(!alignment)
368	return 0;
369
370	g_assert(size_of_type != 0);
371	return ((align_offset - align_drift) & (align_offset-1));
372	}
373
374
375	#endif /* LTT_PRIVATE_H */