[lttv.git] / ltt / branches / poly / ltt / ltt-private.h

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Xiangxiu Yang
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; 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>


#ifndef max
#define max(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

/* Hardcoded core events */
enum ltt_core_events {
    LTT_EVENT_FACILITY_LOAD,
    LTT_EVENT_FACILITY_UNLOAD,
    LTT_EVENT_HEARTBEAT,
    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;

/* Hardcoded facility load event : this plus an preceding "name" string */
struct LttFacilityLoad {
  guint32 checksum;
  guint32 id;
  guint32 long_size;
  guint32 pointer_size;
  guint32 size_t_size;
  guint32 alignment;
} LTT_PACKED_STRUCT;

struct LttFacilityUnload {
  guint32 id;
} LTT_PACKED_STRUCT;

struct LttStateDumpFacilityLoad {
  guint32 checksum;
  guint32 id;
  guint32 long_size;
  guint32 pointer_size;
  guint32 size_t_size;
  guint32 alignment;
} LTT_PACKED_STRUCT;

typedef struct _TimeHeartbeat {
  LttTime       time;       //Time stamp of this block
  uint64_t cycle_count; //cycle count of the event
} LTT_PACKED_STRUCT TimeHeartbeat;

struct ltt_event_header_hb {
  uint32_t      timestamp;
  unsigned char  facility_id;
  unsigned char event_id;
  uint16_t      event_size;
} LTT_PACKED_STRUCT;

struct ltt_event_header_nohb {
  uint64_t      timestamp;
  unsigned char  facility_id;
  unsigned char event_id;
  uint16_t      event_size;
} LTT_PACKED_STRUCT;

struct ltt_trace_header {
  uint32_t        magic_number;
  uint32_t        arch_type;
  uint32_t        arch_variant;
  uint8_t         arch_size;
  //uint32_t        system_type;
  uint8_t          major_version;
  uint8_t          minor_version;
  uint8_t          flight_recorder;
  uint8_t          has_heartbeat;
  uint8_t          has_alignment;  /* Event header alignment */
	uint8_t					 has_tsc;
} LTT_PACKED_STRUCT;


struct ltt_block_start_header {
  struct { 
    struct timeval          timestamp;
    uint64_t                cycle_count;
  } begin;
  struct {
    struct timeval          timestamp;
    uint64_t                cycle_count;
  } 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 trace;
} LTT_PACKED_STRUCT;


struct _LttType{
  GQuark type_name;                //type name if it is a named type
  GQuark element_name;             //elements name of the struct
  gchar * fmt;
  unsigned int size;
  LttTypeEnum type_class;          //which type
  GQuark * enum_strings;            //for enum labels
  struct _LttType ** element_type; //for array, sequence and struct
  unsigned element_number;         //the number of elements 
                                   //for enum, array, sequence and structure
};

struct _LttEventType{
  GQuark name;
  gchar * description;
  guint index;              //id of the event type within the facility
  LttFacility * facility; //the facility that contains the event type
  LttField * root_field;  //root field
};

/* Structure LttEvent and LttEventPosition must begin with the _exact_ same
 * fields in the exact same order. LttEventPosition is a parent of LttEvent. */
struct _LttEvent{
  
  /* Begin of LttEventPosition fields */
  LttTracefile  *tracefile;
  unsigned int  block;
  unsigned int  offset;

  /* Timekeeping */
  uint64_t                tsc;       /* Current timestamp counter */
  
  /* End of LttEventPosition fields */

	union {											/* choice by trace has_tsc */
	  guint32  timestamp;				/* truncated timestamp */
  	LttTime  delta;
	} time;

  unsigned char facility_id;	/* facility ID are never reused. */
  unsigned char event_id;

  LttTime event_time;

  void * data;               //event data
  guint  data_size;
  guint  event_size;         //event_size field of the header : 
                             //used to verify data_size from facility.

  int      count;                    //the number of overflow of cycle count
  gint64 overflow_nsec;              //precalculated nsec for overflows
};

struct _LttEventPosition{
  LttTracefile  *tracefile;
  unsigned int  block;
  unsigned int  offset;
  
  /* Timekeeping */
  uint64_t                tsc;       /* Current timestamp counter */
};


enum field_status { FIELD_UNKNOWN, FIELD_VARIABLE, FIELD_FIXED };

struct _LttField{
  //guint field_pos;           //field position within its parent
  LttType * field_type;      //field type, if it is root field
                             //then it must be struct type

  off_t offset_root;         //offset from the root, -1:uninitialized 
  enum field_status fixed_root;          //offset fixed according to the root
                             //-1:uninitialized, 0:unfixed, 1:fixed
  off_t offset_parent;       //offset from the parent,-1:uninitialized
  enum field_status fixed_parent;        //offset fixed according to its parent
                             //-1:uninitialized, 0:unfixed, 1:fixed
  //  void * base_address;       //base address of the field  ????
  
  guint field_size;     //      //>0: size of the field, 
                          //   //0 : uncertain
                           //  //-1: uninitialize
  enum field_status fixed_size;

  /* for sequence */
  gint sequ_number_size;      //the size of unsigned used to save the
                             //number of elements in the sequence

  gint element_size;          //the element size of the sequence
  //int field_fixed;           //0: field has string or sequence
                             //1: field has no string or sequenc
                             //-1: uninitialize

  struct _LttField * parent;
  struct _LttField ** child; //for array, sequence, struct and union: 
                             //list of fields, it may have only one
                             //field if the element is not a struct or
                             //union
  unsigned current_element;  //which element is currently processed
                             // Used for sequences and arrays.
};


struct _LttFacility{
  LttTrace  *trace;
  //gchar * name;               //facility name 
  GQuark name;
  guint32 checksum;      //checksum of the facility 
  guint32  id;          //id of the facility
 
  guint32 pointer_size;
  guint32 long_size;
  guint32 size_t_size;
  guint32 alignment;


  //LttEventType ** events;    //array of event types 
  //unsigned int event_number;          //number of events in the facility 
  //LttType ** named_types;
  //unsigned int named_types_number;

  GArray *events;
  GData *events_by_name;
 // GArray *named_types;
  //GData *named_types_by_name;
  GData *named_types;
  
  unsigned char exists; /* 0 does not exist, 1 exists */
};

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

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

  /* Timekeeping */
  uint64_t                tsc;       /* Current timestamp counter */
  double                  nsecs_per_cycle;
} 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
  LttTrace * trace;                  //trace containing the tracefile
  int fd;                            //file descriptor 
  off_t file_size;                   //file size
  unsigned block_size;               //block_size
  unsigned int num_blocks;           //number of blocks in the file
  gboolean  reverse_bo;              //must we reverse byte order ?

	/* 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
};

struct _LttTrace{
  GQuark pathname;                          //the pathname of the trace
  //LttSystemDescription * system_description;//system description 

  GArray *facilities_by_num;            /* fac_id as index in array */
  GData *facilities_by_name;            /* fac name (GQuark) as index */
                                        /* Points to array of fac_id of all the
                                         * facilities that has this name. */

  guint32   arch_type;
  guint32   arch_variant;
  guint8    arch_size;
  guint8    ltt_major_version;
  guint8    ltt_minor_version;
  guint8    flight_recorder;
  guint8    has_heartbeat;
  guint8    has_alignment;
	guint8		has_tsc;

  GData     *tracefiles;                    //tracefiles groups
};

/* 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)

#define LTT_GET_BO(t) ((t)->reverse_bo)


#endif /* LTT_PRIVATE_H */
Commit	Line	Data
	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 */