[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>

#define LTT_PACKED_STRUCT __attribute__ ((packed))

/* 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{
  char * 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;

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


struct _LttType{
  char * type_name;                //type name if it is a named type
  char * element_name;             //elements name of the struct
  char * fmt;
  unsigned int size;
  LttTypeEnum type_class;          //which type
  char ** 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{
  char * name;
  char * description;
  int index;              //id of the event type within the facility
  LttFacility * facility; //the facility that contains the event type
  LttField * root_field;  //root field
  unsigned int latest_block;       //the latest block using the event type
  unsigned int latest_event;       //the latest event using the event type
};

struct _LttEvent{
  guint16  event_id;
  guint32  time_delta;
  LttTime event_time;
  LttCycleCount event_cycle_count;
  LttTracefile * tracefile;
  void * data;               //event data
  unsigned int which_block;           //the current block of the event
  unsigned int which_event;           //the position of the event
  /* This is a workaround for fast position seek */
  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
  int      count;                    //the number of overflow of cycle count
  gint64 overflow_nsec;              //precalculated nsec for overflows
  TimeHeartbeat * last_heartbeat;    //last heartbeat

  /* end of workaround */
};


struct _LttField{
  unsigned 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 
  short fixed_root;          //offset fixed according to the root
                             //-1:uninitialized, 0:unfixed, 1:fixed
  off_t offset_parent;       //offset from the parent,-1:uninitialized
  short fixed_parent;        //offset fixed according to its parent
                             //-1:uninitialized, 0:unfixed, 1:fixed
  //  void * base_address;       //base address of the field  ????
  
  int  field_size;           //>0: size of the field, 
                             //0 : uncertain
                             //-1: uninitialize
  int sequ_number_size;      //the size of unsigned used to save the
                             //number of elements in the sequence

  int 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 and struct: 
                             //list of fields, it may have only one
                             //field if the element is not a struct 
  unsigned current_element;  //which element is currently processed
};


struct _LttFacility{
  char * name;               //facility name 
  unsigned int event_number;          //number of events in the facility 
  LttChecksum checksum;      //checksum of the facility 
  guint32  base_id;          //base id of the facility
  LttEventType ** events;    //array of event types 
  LttType ** named_types;
  unsigned int named_types_number;
};

struct _LttTracefile{
  char * name;                       //tracefile name
  LttTrace * trace;                  //trace containing the tracefile
  int fd;                            //file descriptor 
  off_t file_size;                   //file size
  unsigned block_size;               //block_size
  unsigned int block_number;         //number of blocks in the file
  unsigned int which_block;          //which block the current block is
  unsigned int which_event;          //which event of the current block 
                                     //is currently processed 
  LttTime current_event_time;        //time of the current event
  BlockStart * a_block_start;        //block start of the block- trace endian
  BlockEnd   * a_block_end;          //block end of the block - trace endian
  TimeHeartbeat * last_heartbeat;    //last heartbeat
  void * cur_event_pos;              //the position of the current event
  void * buffer;                     //the buffer containing the block
  double nsec_per_cycle;             //Nsec per cycle
  guint64 one_overflow_nsec;         //nsec for one overflow
  gint64 overflow_nsec;              //precalculated nsec for overflows
                                     //can be negative to include value
                                     //of block start cycle count.
                                     //incremented at each overflow while
                                     //reading.
  //LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
  unsigned cur_heart_beat_number;    //current number of heart beat in the buf
  LttCycleCount cur_cycle_count;     //current cycle count of the event
  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
  unsigned int      count;           //the number of overflow of cycle count
};

struct _LttTrace{
  char * pathname;                          //the pathname of the trace
  guint facility_number;                    //the number of facilities 
  guint control_tracefile_number;           //the number of control files 
  guint per_cpu_tracefile_number;           //the number of per cpu files 
  LttSystemDescription * system_description;//system description 

  GPtrArray *control_tracefiles;            //array of control tracefiles 
  GPtrArray *per_cpu_tracefiles;            //array of per cpu tracefiles 
  GPtrArray *facilities;                    //array of facilities 
  gboolean reverse_byte_order;              //must we reverse BO ?
};

struct _LttEventPosition{
  unsigned      block_num;          //block which contains the event 
  unsigned      event_num;          //event index in the block
  unsigned      event_offset;       //event position in the block
  LttTime       event_time;         //the time of the event
  LttCycleCount event_cycle_count;  //the cycle count of the event
  unsigned      heart_beat_number;  //current number of heart beats  
  LttTracefile *tf;                 //tracefile containing the event
  gboolean      old_position;       //flag to show if it is the position
                                    //being remembered
  /* This is a workaround for fast position seek */
  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
  int      count;                    //the number of overflow of cycle count
  gint64 overflow_nsec;              //precalculated nsec for overflows
  TimeHeartbeat * last_heartbeat;    //last heartbeat
  /* end of workaround */
};

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

struct _LttSystemDescription {
  char *description;
  char *node_name;
  char *domain_name;
  unsigned nb_cpu;
  LttArchSize size;
  LttArchEndian endian;
  char *kernel_name;
  char *kernel_release;
  char *kernel_version;
  char *machine;
  char *processor;
  char *hardware_platform;
  char *operating_system;
  unsigned ltt_major_version;
  unsigned ltt_minor_version;
  unsigned ltt_block_size;
  LttTime trace_start;
  LttTime trace_end;
};

/*****************************************************************************
 macro for size of some data types
 *****************************************************************************/
#define EVENT_ID_SIZE     sizeof(guint16)
#define TIME_DELTA_SIZE   sizeof(guint32)
#define EVENT_HEADER_SIZE (EVENT_ID_SIZE + TIME_DELTA_SIZE)


#endif /* LTT_PRIVATE_H */
Commit	Line	Data
449cb9d7	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
fcdf0ec2	19	#ifndef LTT_PRIVATE_H
	20	#define LTT_PRIVATE_H
	21
858bd80a	22	#include <glib.h>
cbd41522	23	#include <sys/types.h>
fcdf0ec2	24	#include <ltt/ltt.h>
e3247aa5	25
cbd41522	26	#define LTT_PACKED_STRUCT __attribute__ ((packed))
cbd41522	27
e3247aa5	28	/* enumeration definition */
	29
	30	typedef enum _BuildinEvent{
	31	TRACE_FACILITY_LOAD = 0,
	32	TRACE_BLOCK_START = 17,
	33	TRACE_BLOCK_END = 18,
0d7aac52	34	TRACE_TIME_HEARTBEAT= 19
e3247aa5	35	} BuildinEvent;
fcdf0ec2	36
7c6b3cd7	37
	38	/* structure definition */
	39
e3247aa5	40	typedef struct _FacilityLoad{
	41	char * name;
	42	LttChecksum checksum;
cbd41522	43	guint32 base_code;
e3247aa5	44	} LTT_PACKED_STRUCT FacilityLoad;
	45
	46	typedef struct _BlockStart {
	47	LttTime time; //Time stamp of this block
	48	LttCycleCount cycle_count; //cycle count of the event
cbd41522	49	guint32 block_id; //block id
e3247aa5	50	} LTT_PACKED_STRUCT BlockStart;
	51
	52	typedef struct _BlockEnd {
	53	LttTime time; //Time stamp of this block
	54	LttCycleCount cycle_count; //cycle count of the event
cbd41522	55	guint32 block_id; //block id
e3247aa5	56	} LTT_PACKED_STRUCT BlockEnd;
	57
	58	typedef struct _TimeHeartbeat {
	59	LttTime time; //Time stamp of this block
	60	LttCycleCount cycle_count; //cycle count of the event
	61	} LTT_PACKED_STRUCT TimeHeartbeat;
	62
	63
	64	struct _LttType{
0d7aac52	65	char * type_name; //type name if it is a named type
0d7aac52	66	char * element_name; //elements name of the struct
7c6b3cd7	67	char * fmt;
8d1e6362	68	unsigned int size;
e3247aa5	69	LttTypeEnum type_class; //which type
	70	char ** enum_strings; //for enum labels
	71	struct _LttType ** element_type; //for array, sequence and struct
	72	unsigned element_number; //the number of elements
	73	//for enum, array, sequence and structure
7c6b3cd7	74	};
7c6b3cd7	75
e3247aa5	76	struct _LttEventType{
7c6b3cd7	77	char * name;
7c6b3cd7	78	char * description;
e3247aa5	79	int index; //id of the event type within the facility
	80	LttFacility * facility; //the facility that contains the event type
	81	LttField * root_field; //root field
8d1e6362	82	unsigned int latest_block; //the latest block using the event type
8d1e6362	83	unsigned int latest_event; //the latest event using the event type
7c6b3cd7	84	};
7c6b3cd7	85
c02ea99f	86	struct _LttEvent{
	87	guint16 event_id;
	88	guint32 time_delta;
	89	LttTime event_time;
	90	LttCycleCount event_cycle_count;
	91	LttTracefile * tracefile;
	92	void * data; //event data
8d1e6362	93	unsigned int which_block; //the current block of the event
8d1e6362	94	unsigned int which_event; //the position of the event
c02ea99f	95	/* This is a workaround for fast position seek */
	96	void * last_event_pos;
	97
	98	LttTime prev_block_end_time; //the end time of previous block
	99	LttTime prev_event_time; //the time of the previous event
	100	LttCycleCount pre_cycle_count; //previous cycle count of the event
	101	int count; //the number of overflow of cycle count
2dee981d	102	gint64 overflow_nsec; //precalculated nsec for overflows
dfb73233	103	TimeHeartbeat * last_heartbeat; //last heartbeat
dfb73233	104
c02ea99f	105	/* end of workaround */
	106	};
	107
	108
e3247aa5	109	struct _LttField{
7c6b3cd7	110	unsigned field_pos; //field position within its parent
e3247aa5	111	LttType * field_type; //field type, if it is root field
7c6b3cd7	112	//then it must be struct type
	113
	114	off_t offset_root; //offset from the root, -1:uninitialized
	115	short fixed_root; //offset fixed according to the root
	116	//-1:uninitialized, 0:unfixed, 1:fixed
	117	off_t offset_parent; //offset from the parent,-1:uninitialized
	118	short fixed_parent; //offset fixed according to its parent
	119	//-1:uninitialized, 0:unfixed, 1:fixed
	120	// void * base_address; //base address of the field ????
	121
	122	int field_size; //>0: size of the field,
	123	//0 : uncertain
	124	//-1: uninitialize
0d7aac52	125	int sequ_number_size; //the size of unsigned used to save the
	126	//number of elements in the sequence
	127
7c6b3cd7	128	int element_size; //the element size of the sequence
	129	int field_fixed; //0: field has string or sequence
	130	//1: field has no string or sequenc
	131	//-1: uninitialize
	132
e3247aa5	133	struct _LttField * parent;
e3247aa5	134	struct _LttField ** child; //for array, sequence and struct:
7c6b3cd7	135	//list of fields, it may have only one
	136	//field if the element is not a struct
	137	unsigned current_element; //which element is currently processed
	138	};
	139
7c6b3cd7	140
e3247aa5	141	struct _LttFacility{
7c6b3cd7	142	char * name; //facility name
8d1e6362	143	unsigned int event_number; //number of events in the facility
e3247aa5	144	LttChecksum checksum; //checksum of the facility
cbd41522	145	guint32 base_id; //base id of the facility
e3247aa5	146	LttEventType ** events; //array of event types
36921b4e	147	LttType ** named_types;
8d1e6362	148	unsigned int named_types_number;
7c6b3cd7	149	};
7c6b3cd7	150
e3247aa5	151	struct _LttTracefile{
	152	char * name; //tracefile name
	153	LttTrace * trace; //trace containing the tracefile
	154	int fd; //file descriptor
	155	off_t file_size; //file size
	156	unsigned block_size; //block_size
8d1e6362	157	unsigned int block_number; //number of blocks in the file
	158	unsigned int which_block; //which block the current block is
	159	unsigned int which_event; //which event of the current block
e3247aa5	160	//is currently processed
e3247aa5	161	LttTime current_event_time; //time of the current event
1a2ceb63	162	BlockStart * a_block_start; //block start of the block- trace endian
1a2ceb63	163	BlockEnd * a_block_end; //block end of the block - trace endian
dfb73233	164	TimeHeartbeat * last_heartbeat; //last heartbeat
e3247aa5	165	void * cur_event_pos; //the position of the current event
e3247aa5	166	void * buffer; //the buffer containing the block
887208b7	167	double nsec_per_cycle; //Nsec per cycle
2dee981d	168	guint64 one_overflow_nsec; //nsec for one overflow
	169	gint64 overflow_nsec; //precalculated nsec for overflows
	170	//can be negative to include value
	171	//of block start cycle count.
	172	//incremented at each overflow while
	173	//reading.
887208b7	174	//LttCycleCount cycles_per_nsec_reciprocal; // Optimisation for speed
e3247aa5	175	unsigned cur_heart_beat_number; //current number of heart beat in the buf
fb1a869e	176	LttCycleCount cur_cycle_count; //current cycle count of the event
e37c1372	177	void * last_event_pos;
e3247aa5	178
	179	LttTime prev_block_end_time; //the end time of previous block
	180	LttTime prev_event_time; //the time of the previous event
dd691a2e	181	LttCycleCount pre_cycle_count; //previous cycle count of the event
8d1e6362	182	unsigned int count; //the number of overflow of cycle count
7c6b3cd7	183	};
7c6b3cd7	184
e3247aa5	185	struct _LttTrace{
	186	char * pathname; //the pathname of the trace
	187	guint facility_number; //the number of facilities
	188	guint control_tracefile_number; //the number of control files
	189	guint per_cpu_tracefile_number; //the number of per cpu files
	190	LttSystemDescription * system_description;//system description
80da81ad	191
e3247aa5	192	GPtrArray *control_tracefiles; //array of control tracefiles
	193	GPtrArray *per_cpu_tracefiles; //array of per cpu tracefiles
	194	GPtrArray *facilities; //array of facilities
1a2ceb63	195	gboolean reverse_byte_order; //must we reverse BO ?
e3247aa5	196	};
7c6b3cd7	197
80da81ad	198	struct _LttEventPosition{
	199	unsigned block_num; //block which contains the event
	200	unsigned event_num; //event index in the block
	201	unsigned event_offset; //event position in the block
	202	LttTime event_time; //the time of the event
	203	LttCycleCount event_cycle_count; //the cycle count of the event
	204	unsigned heart_beat_number; //current number of heart beats
fb1a869e	205	LttTracefile *tf; //tracefile containing the event
80da81ad	206	gboolean old_position; //flag to show if it is the position
80da81ad	207	//being remembered
18206708	208	/* This is a workaround for fast position seek */
	209	void * last_event_pos;
	210
	211	LttTime prev_block_end_time; //the end time of previous block
	212	LttTime prev_event_time; //the time of the previous event
18206708	213	LttCycleCount pre_cycle_count; //previous cycle count of the event
18206708	214	int count; //the number of overflow of cycle count
2dee981d	215	gint64 overflow_nsec; //precalculated nsec for overflows
dfb73233	216	TimeHeartbeat * last_heartbeat; //last heartbeat
18206708	217	/* end of workaround */
80da81ad	218	};
7c6b3cd7	219
a5dcde2f	220	/* The characteristics of the system on which the trace was obtained
	221	is described in a LttSystemDescription structure. */
	222
	223	struct _LttSystemDescription {
	224	char *description;
	225	char *node_name;
	226	char *domain_name;
	227	unsigned nb_cpu;
	228	LttArchSize size;
	229	LttArchEndian endian;
	230	char *kernel_name;
	231	char *kernel_release;
	232	char *kernel_version;
	233	char *machine;
	234	char *processor;
	235	char *hardware_platform;
	236	char *operating_system;
	237	unsigned ltt_major_version;
	238	unsigned ltt_minor_version;
	239	unsigned ltt_block_size;
	240	LttTime trace_start;
	241	LttTime trace_end;
	242	};
	243
7c6b3cd7	244	/*****************************************************************************
	245	macro for size of some data types
	246	*****************************************************************************/
cbd41522	247	#define EVENT_ID_SIZE sizeof(guint16)
cbd41522	248	#define TIME_DELTA_SIZE sizeof(guint32)
e3247aa5	249	#define EVENT_HEADER_SIZE (EVENT_ID_SIZE + TIME_DELTA_SIZE)
7c6b3cd7	250
7c6b3cd7	251
fcdf0ec2	252	#endif /* LTT_PRIVATE_H */