[lttv.git] / ltt / branches / poly / lttv / lttv / tracecontext.h

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Michel Dagenais
 *
 * 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 PROCESSTRACE_H
#define PROCESSTRACE_H

#include <lttv/traceset.h>
#include <lttv/attribute.h>
#include <lttv/hook.h>
#include <ltt/ltt.h>

/* This is the generic part of trace processing. All events within a
   certain time interval are accessed and processing hooks are called for
   each. The events are examined in monotonically increasing time to more
   closely follow the traced system behavior. 

   Hooks are called at several different places during the processing:
   before traceset, after traceset, check trace, before trace, after trace, 
   check tracefile, before tracefile, after tracefile, 
   check_event, before_event, before_event_by_id, 
   after_event, after_event_by_id.

   In each case the "check" hooks are called first to determine if further
   processing of the trace, tracefile or event is wanted. Then, the before
   hooks and the after hooks are called. The before hooks for a traceset
   are called before those for the contained traces, which are called before
   those for the contained tracefiles. The after hooks are called in reverse
   order. The event hooks are called after all the before_tracefile hooks
   and before all the after_tracefile hooks.

   The hooks receive two arguments, the hook_data and call_data. The hook_data
   is specified when the hook is registered and typically links to the
   object registering the hook (e.g. a graphical events viewer). The call_data
   must contain all the context related to the call. The traceset hooks receive
   the LttvTracesetContext provided by the caller. The trace hooks receive
   the LttvTraceContext from the traces array in the LttvTracesetContext.
   The tracefile and event hooks receive the LttvTracefileContext from
   the tracefiles array in the LttvTraceContext. The LttEvent and LttTime
   fields in the tracefile context are set to the current event and current
   event time before calling the event hooks. No other context field is 
   modified.

   The contexts in the traces and tracefiles arrays must be allocated by 
   the caller, either before the call or during the before hooks of the 
   enclosing traceset or trace. The order in the traces array must
   correspond to the lttv_traceset_get function. The order in the tracefiles
   arrays must correspond to the ltt_trace_control_tracefile_get and
   ltt_trace_per_cpu_tracefile_get functions. The traceset, trace and
   tracefile contexts may be subtyped as needed. Indeed, both the contexts
   and the hooks are defined by the caller. */


typedef struct _LttvTracesetContext LttvTracesetContext;
typedef struct _LttvTracesetContextClass LttvTracesetContextClass;

typedef struct _LttvTraceContext LttvTraceContext;
typedef struct _LttvTraceContextClass LttvTraceContextClass;

typedef struct _LttvTracefileContext LttvTracefileContext;
typedef struct _LttvTracefileContextClass LttvTracefileContextClass;

typedef struct _LttvTracesetContextPosition LttvTracesetContextPosition;
typedef struct _LttvTraceContextPosition LttvTraceContextPosition;

#ifndef LTTVFILTER_TYPE_DEFINED
typedef struct _LttvFilter LttvFilter;
#define LTTVFILTER_TYPE_DEFINED
#endif

#define LTTV_TRACESET_CONTEXT_TYPE  (lttv_traceset_context_get_type ())
#define LTTV_TRACESET_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
#define LTTV_TRACESET_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
#define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
#define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
#define LTTV_TRACESET_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))

struct _LttvTracesetContext {
  GObject parent;

  LttvTraceset *ts;
  LttvTraceContext **traces;
  LttvAttribute *a;
  LttvAttribute *ts_a;
  TimeInterval time_span;
  GTree *pqueue;

  LttvTracesetContextPosition *sync_position;   /* position at which to sync the
                                                   trace context */
};

struct _LttvTracesetContextClass {
  GObjectClass parent;

  void (*init) (LttvTracesetContext *self, LttvTraceset *ts);
  void (*fini) (LttvTracesetContext *self);
  LttvTracesetContext* (*new_traceset_context) (LttvTracesetContext *self);
  LttvTraceContext* (*new_trace_context) (LttvTracesetContext *self);
  LttvTracefileContext* (*new_tracefile_context) (LttvTracesetContext *self);
};

GType lttv_traceset_context_get_type (void);

void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts);

void lttv_context_fini(LttvTracesetContext *self);

LttvTracesetContext *
lttv_context_new_traceset_context(LttvTracesetContext *self);

LttvTraceContext * 
lttv_context_new_trace_context(LttvTracesetContext *self);

LttvTracefileContext *
lttv_context_new_tracefile_context(LttvTracesetContext *self);


#define LTTV_TRACE_CONTEXT_TYPE  (lttv_trace_context_get_type ())
#define LTTV_TRACE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
#define LTTV_TRACE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
#define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
#define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
#define LTTV_TRACE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))

struct _LttvTraceContext {
  GObject parent;

  LttvTracesetContext *ts_context;
  guint index;                /* in ts_context->traces */
  LttTrace *t;
  LttvTrace *vt;
  //LttvTracefileContext **tracefiles;
  GArray *tracefiles;
  LttvAttribute *a;
  LttvAttribute *t_a;
  TimeInterval time_span;
};

struct _LttvTraceContextClass {
  GObjectClass parent;
};

GType lttv_trace_context_get_type (void);

#define LTTV_TRACEFILE_CONTEXT_TYPE  (lttv_tracefile_context_get_type ())
#define LTTV_TRACEFILE_CONTEXT(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
#define LTTV_TRACEFILE_CONTEXT_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
#define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
#define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
#define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))

struct _LttvTracefileContext {
  GObject parent;

  LttvTraceContext *t_context;
 // gboolean control;
  guint index;                /* in ts_context->tracefiles */
  LttTracefile *tf;
 // LttEvent *e;
  LttvHooks *event;
  LttvHooksById *event_by_id;
  LttTime timestamp;
  LttvAttribute *a;
  gint target_pid;          /* Target PID of the event.
				Updated by state.c. -1 means unset. */
};

struct _LttvTracefileContextClass {
  GObjectClass parent;
};

GType lttv_tracefile_context_get_type (void);

/* Run through the events in a traceset in sorted order calling all the
   hooks appropriately. It starts at the current time and runs until end or
   nb_events are processed. */

void lttv_process_traceset(LttvTracesetContext *self, LttTime end, 
    unsigned nb_events);

/* Process traceset can also be done in smaller pieces calling begin,
 * then seek and middle repeatedly, and end. The middle function return the
 * number of events processed. It will be smaller than nb_events if the end time
 * or end position is reached. */


void lttv_process_traceset_begin(LttvTracesetContext *self,
                                 LttvHooks       *before_traceset,
                                 LttvHooks       *before_trace,
                                 LttvHooks       *before_tracefile,
                                 LttvHooks       *event,
                                 LttvHooksById   *event_by_id);


guint lttv_process_traceset_middle(LttvTracesetContext *self,
                              LttTime end, 
                              guint nb_events,
                              const LttvTracesetContextPosition *end_position);

void lttv_process_traceset_end(LttvTracesetContext *self,
                               LttvHooks           *after_traceset,
                               LttvHooks           *after_trace,
                               LttvHooks           *after_tracefile,
                               LttvHooks           *event,
                               LttvHooksById       *event_by_id);


void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);

gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self, 
                                        const LttvTracesetContextPosition *pos);

void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);

void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
    LttvHooks *before_traceset,
    LttvHooks *before_trace, 
    LttvHooks *before_tracefile,
    LttvHooks *event,
    LttvHooksById *event_by_id);

void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
    LttvHooks *after_traceset,
    LttvHooks *after_trace, 
    LttvHooks *after_tracefile,
    LttvHooks *event, 
    LttvHooksById *event_by_id);

void lttv_trace_context_add_hooks(LttvTraceContext *self,
    LttvHooks *before_trace, 
    LttvHooks *before_tracefile,
    LttvHooks *event, 
    LttvHooksById *event_by_id);

void lttv_trace_context_remove_hooks(LttvTraceContext *self,
    LttvHooks *after_trace, 
    LttvHooks *after_tracefile,
    LttvHooks *event, 
    LttvHooksById *event_by_id);

void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
          LttvHooks *before_tracefile,
          LttvHooks *event, 
          LttvHooksById *event_by_id);


void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
           LttvHooks *after_tracefile,
           LttvHooks *event, 
           LttvHooksById *event_by_id);


void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *self,
					    unsigned i,
					    LttvHooks *event_by_id);

void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *self,
					       unsigned i);

/* A LttvTraceHook has two arrays of LttvTraceHookByFacility,
 * indexed by facility ID and a simple array used to walk all the hooks */
typedef struct _LttvTraceHook {
  GArray *fac_index;
  GArray *fac_list;
} LttvTraceHook;

typedef struct _LttvTraceHookByFacility {
  LttvHook h;
  guint id;
  LttField *f1;
  LttField *f2;
  LttField *f3;
  gpointer hook_data;
} LttvTraceHookByFacility;


/* Get the first facility corresponding to the name. As the types must be
 * compatible, it is relevant to use the field name and sizes of the first
 * facility to create data structures and assume the data will be compatible
 * thorough the trace */
LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th);

LttvTraceHookByFacility *lttv_trace_hook_get_fac(
    LttvTraceHook *th, guint facility_id);

void lttv_trace_hook_destroy(LttvTraceHook *th);

/* Search in the trace for the id of the named event type within the named
   facility. Then, find the three (if non null) named fields. All that
   information is then used to fill the LttvTraceHook structure. This
   is useful to find the specific id for an event within a trace, for
   registering a hook using this structure as event data;
   it already contains the (up to three) needed fields handles. */
 
gint lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event_type,
    GQuark field1, GQuark field2, GQuark field3, LttvHook h,
    gpointer hook_data, LttvTraceHook *th);

LttvTracefileContext *lttv_traceset_context_get_current_tfc(
                             LttvTracesetContext *self);


LttvTracesetContextPosition *lttv_traceset_context_position_new(
    const LttvTracesetContext *self);

void lttv_traceset_context_position_save(const LttvTracesetContext *self,
                                    LttvTracesetContextPosition *pos);

void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos);

void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
                                   const LttvTracesetContextPosition *src);

gint lttv_traceset_context_pos_pos_compare(
                          const LttvTracesetContextPosition *pos1,
                          const LttvTracesetContextPosition *pos2);

gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
                                    const LttvTracesetContextPosition *pos2);

LttTime lttv_traceset_context_position_get_time(
                                      const LttvTracesetContextPosition *pos);

gint compare_tracefile(gconstpointer a, gconstpointer b);


/* Synchronisation helpers : save/restore synchronization between ltt traces and
 * a traceset context. */
void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc);

void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc);

/* Seek n events forward and backward (without filtering) : only use these where
 * necessary : the seek backward is costy. */

#define BACKWARD_SEEK_MUL 2 /* Multiplication factor of time_offset between
                               backward seek iterations */

static const LttTime seek_back_default_offset = { 1, 0 };

typedef gboolean check_handler(guint count, gboolean *stop_flag, gpointer data);

guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self,
                                           guint n,
					   check_handler *check,
					   gboolean *stop_flag,
					   LttvFilter *filter1,
					   LttvFilter *filter2,
					   LttvFilter *filter3,
					   gpointer data);
typedef void (*seek_time_fct)(LttvTracesetContext *self, LttTime start);

/* If first_offset is ltt_time_zero, it will choose a default value */
guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
                                            guint n,
                                            LttTime first_offset,
                                            seek_time_fct,
	 				    check_handler *check,
					    gboolean *stop_flag,
					    LttvFilter *filter1,
					    LttvFilter *filter2,
					    LttvFilter *filter3,
					    gpointer data);


#endif // PROCESSTRACE_H
Commit	Line	Data
9c312311	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2003-2004 Michel Dagenais
	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
dc877563	19	#ifndef PROCESSTRACE_H
	20	#define PROCESSTRACE_H
	21
ffd54a90	22	#include <lttv/traceset.h>
dc877563	23	#include <lttv/attribute.h>
	24	#include <lttv/hook.h>
	25	#include <ltt/ltt.h>
	26
	27	/* This is the generic part of trace processing. All events within a
	28	certain time interval are accessed and processing hooks are called for
	29	each. The events are examined in monotonically increasing time to more
	30	closely follow the traced system behavior.
	31
	32	Hooks are called at several different places during the processing:
	33	before traceset, after traceset, check trace, before trace, after trace,
	34	check tracefile, before tracefile, after tracefile,
	35	check_event, before_event, before_event_by_id,
	36	after_event, after_event_by_id.
	37
	38	In each case the "check" hooks are called first to determine if further
	39	processing of the trace, tracefile or event is wanted. Then, the before
	40	hooks and the after hooks are called. The before hooks for a traceset
	41	are called before those for the contained traces, which are called before
	42	those for the contained tracefiles. The after hooks are called in reverse
	43	order. The event hooks are called after all the before_tracefile hooks
	44	and before all the after_tracefile hooks.
	45
	46	The hooks receive two arguments, the hook_data and call_data. The hook_data
	47	is specified when the hook is registered and typically links to the
	48	object registering the hook (e.g. a graphical events viewer). The call_data
	49	must contain all the context related to the call. The traceset hooks receive
	50	the LttvTracesetContext provided by the caller. The trace hooks receive
	51	the LttvTraceContext from the traces array in the LttvTracesetContext.
	52	The tracefile and event hooks receive the LttvTracefileContext from
	53	the tracefiles array in the LttvTraceContext. The LttEvent and LttTime
	54	fields in the tracefile context are set to the current event and current
	55	event time before calling the event hooks. No other context field is
	56	modified.
	57
	58	The contexts in the traces and tracefiles arrays must be allocated by
	59	the caller, either before the call or during the before hooks of the
	60	enclosing traceset or trace. The order in the traces array must
	61	correspond to the lttv_traceset_get function. The order in the tracefiles
	62	arrays must correspond to the ltt_trace_control_tracefile_get and
	63	ltt_trace_per_cpu_tracefile_get functions. The traceset, trace and
	64	tracefile contexts may be subtyped as needed. Indeed, both the contexts
	65	and the hooks are defined by the caller. */
	66
ffd54a90	67
	68	typedef struct _LttvTracesetContext LttvTracesetContext;
	69	typedef struct _LttvTracesetContextClass LttvTracesetContextClass;
	70
	71	typedef struct _LttvTraceContext LttvTraceContext;
	72	typedef struct _LttvTraceContextClass LttvTraceContextClass;
	73
	74	typedef struct _LttvTracefileContext LttvTracefileContext;
	75	typedef struct _LttvTracefileContextClass LttvTracefileContextClass;
	76
8697a616	77	typedef struct _LttvTracesetContextPosition LttvTracesetContextPosition;
	78	typedef struct _LttvTraceContextPosition LttvTraceContextPosition;
	79
33e44b82	80	#ifndef LTTVFILTER_TYPE_DEFINED
	81	typedef struct _LttvFilter LttvFilter;
	82	#define LTTVFILTER_TYPE_DEFINED
	83	#endif
	84
dc877563	85	#define LTTV_TRACESET_CONTEXT_TYPE (lttv_traceset_context_get_type ())
	86	#define LTTV_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
	87	#define LTTV_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
	88	#define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
	89	#define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
	90	#define LTTV_TRACESET_CONTEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
	91
dc877563	92	struct _LttvTracesetContext {
	93	GObject parent;
	94
	95	LttvTraceset *ts;
dc877563	96	LttvTraceContext **traces;
dc877563	97	LttvAttribute *a;
308711e5	98	LttvAttribute *ts_a;
8697a616	99	TimeInterval time_span;
2a2fa4f0	100	GTree *pqueue;
2c82c4dc	101
18c87975	102	LttvTracesetContextPosition sync_position; / position at which to sync the
18c87975	103	trace context */
dc877563	104	};
	105
	106	struct _LttvTracesetContextClass {
	107	GObjectClass parent;
	108
	109	void (init) (LttvTracesetContext self, LttvTraceset *ts);
	110	void (fini) (LttvTracesetContext self);
	111	LttvTracesetContext* (new_traceset_context) (LttvTracesetContext self);
	112	LttvTraceContext* (new_trace_context) (LttvTracesetContext self);
	113	LttvTracefileContext* (new_tracefile_context) (LttvTracesetContext self);
	114	};
	115
	116	GType lttv_traceset_context_get_type (void);
	117
	118	void lttv_context_init(LttvTracesetContext self, LttvTraceset ts);
	119
	120	void lttv_context_fini(LttvTracesetContext *self);
	121
	122	LttvTracesetContext *
	123	lttv_context_new_traceset_context(LttvTracesetContext *self);
	124
	125	LttvTraceContext *
	126	lttv_context_new_trace_context(LttvTracesetContext *self);
	127
	128	LttvTracefileContext *
	129	lttv_context_new_tracefile_context(LttvTracesetContext *self);
	130
	131
	132	#define LTTV_TRACE_CONTEXT_TYPE (lttv_trace_context_get_type ())
	133	#define LTTV_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
	134	#define LTTV_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
	135	#define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
	136	#define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
	137	#define LTTV_TRACE_CONTEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
	138
dc877563	139	struct _LttvTraceContext {
	140	GObject parent;
	141
	142	LttvTracesetContext *ts_context;
	143	guint index; /* in ts_context->traces */
ffd54a90	144	LttTrace *t;
308711e5	145	LttvTrace *vt;
eed2ef37	146	//LttvTracefileContext **tracefiles;
eed2ef37	147	GArray *tracefiles;
dc877563	148	LttvAttribute *a;
308711e5	149	LttvAttribute *t_a;
14aecf75	150	TimeInterval time_span;
dc877563	151	};
	152
	153	struct _LttvTraceContextClass {
	154	GObjectClass parent;
	155	};
	156
	157	GType lttv_trace_context_get_type (void);
	158
	159	#define LTTV_TRACEFILE_CONTEXT_TYPE (lttv_tracefile_context_get_type ())
	160	#define LTTV_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
	161	#define LTTV_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
	162	#define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
	163	#define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
	164	#define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
	165
dc877563	166	struct _LttvTracefileContext {
	167	GObject parent;
	168
	169	LttvTraceContext *t_context;
eed2ef37	170	// gboolean control;
dbb7bb09	171	guint index; /* in ts_context->tracefiles */
ffd54a90	172	LttTracefile *tf;
eed2ef37	173	// LttEvent *e;
8697a616	174	LttvHooks *event;
8697a616	175	LttvHooksById *event_by_id;
ffd54a90	176	LttTime timestamp;
dc877563	177	LttvAttribute *a;
e38d9ea0	178	gint target_pid; /* Target PID of the event.
e38d9ea0	179	Updated by state.c. -1 means unset. */
dc877563	180	};
	181
	182	struct _LttvTracefileContextClass {
	183	GObjectClass parent;
	184	};
	185
	186	GType lttv_tracefile_context_get_type (void);
	187
2a2fa4f0	188	/* Run through the events in a traceset in sorted order calling all the
	189	hooks appropriately. It starts at the current time and runs until end or
	190	nb_events are processed. */
	191
308711e5	192	void lttv_process_traceset(LttvTracesetContext *self, LttTime end,
2a2fa4f0	193	unsigned nb_events);
2a2fa4f0	194
8697a616	195	/* Process traceset can also be done in smaller pieces calling begin,
	196	* then seek and middle repeatedly, and end. The middle function return the
	197	* number of events processed. It will be smaller than nb_events if the end time
	198	* or end position is reached. */
2a2fa4f0	199
2a2fa4f0	200
8697a616	201	void lttv_process_traceset_begin(LttvTracesetContext *self,
	202	LttvHooks *before_traceset,
	203	LttvHooks *before_trace,
	204	LttvHooks *before_tracefile,
	205	LttvHooks *event,
	206	LttvHooksById *event_by_id);
	207
2a2fa4f0	208
8697a616	209	guint lttv_process_traceset_middle(LttvTracesetContext *self,
8697a616	210	LttTime end,
b8eccacd	211	guint nb_events,
8697a616	212	const LttvTracesetContextPosition *end_position);
	213
	214	void lttv_process_traceset_end(LttvTracesetContext *self,
	215	LttvHooks *after_traceset,
	216	LttvHooks *after_trace,
	217	LttvHooks *after_tracefile,
	218	LttvHooks *event,
	219	LttvHooksById *event_by_id);
2a2fa4f0	220
308711e5	221
	222	void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);
	223
8697a616	224	gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
	225	const LttvTracesetContextPosition *pos);
	226
308711e5	227	void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);
dc877563	228
dc877563	229	void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
8697a616	230	LttvHooks *before_traceset,
dc877563	231	LttvHooks *before_trace,
ffd54a90	232	LttvHooks *before_tracefile,
8697a616	233	LttvHooks *event,
8697a616	234	LttvHooksById *event_by_id);
dc877563	235
dc877563	236	void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
dc877563	237	LttvHooks *after_traceset,
dc877563	238	LttvHooks *after_trace,
ffd54a90	239	LttvHooks *after_tracefile,
8697a616	240	LttvHooks *event,
8697a616	241	LttvHooksById *event_by_id);
dc877563	242
a8c0f09d	243	void lttv_trace_context_add_hooks(LttvTraceContext *self,
8697a616	244	LttvHooks *before_trace,
	245	LttvHooks *before_tracefile,
	246	LttvHooks *event,
	247	LttvHooksById *event_by_id);
a8c0f09d	248
a8c0f09d	249	void lttv_trace_context_remove_hooks(LttvTraceContext *self,
8697a616	250	LttvHooks *after_trace,
	251	LttvHooks *after_tracefile,
	252	LttvHooks *event,
	253	LttvHooksById *event_by_id);
a8c0f09d	254
a8c0f09d	255	void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
8697a616	256	LttvHooks *before_tracefile,
	257	LttvHooks *event,
	258	LttvHooksById *event_by_id);
	259
a8c0f09d	260
a8c0f09d	261	void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
8697a616	262	LttvHooks *after_tracefile,
	263	LttvHooks *event,
	264	LttvHooksById *event_by_id);
	265
a8c0f09d	266
	267	void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *self,
	268	unsigned i,
8697a616	269	LttvHooks *event_by_id);
a8c0f09d	270
	271	void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *self,
	272	unsigned i);
	273
eed2ef37	274	/* A LttvTraceHook has two arrays of LttvTraceHookByFacility,
eed2ef37	275	* indexed by facility ID and a simple array used to walk all the hooks */
b445142a	276	typedef struct _LttvTraceHook {
eed2ef37	277	GArray *fac_index;
	278	GArray *fac_list;
	279	} LttvTraceHook;
	280
	281	typedef struct _LttvTraceHookByFacility {
b445142a	282	LttvHook h;
	283	guint id;
	284	LttField *f1;
	285	LttField *f2;
	286	LttField *f3;
2c82c4dc	287	gpointer hook_data;
eed2ef37	288	} LttvTraceHookByFacility;
	289
	290
	291	/* Get the first facility corresponding to the name. As the types must be
	292	* compatible, it is relevant to use the field name and sizes of the first
	293	* facility to create data structures and assume the data will be compatible
	294	* thorough the trace */
	295	LttvTraceHookByFacility lttv_trace_hook_get_first(LttvTraceHook th);
	296
	297	LttvTraceHookByFacility *lttv_trace_hook_get_fac(
	298	LttvTraceHook *th, guint facility_id);
b445142a	299
eed2ef37	300	void lttv_trace_hook_destroy(LttvTraceHook *th);
b445142a	301
	302	/* Search in the trace for the id of the named event type within the named
	303	facility. Then, find the three (if non null) named fields. All that
	304	information is then used to fill the LttvTraceHook structure. This
	305	is useful to find the specific id for an event within a trace, for
	306	registering a hook using this structure as event data;
	307	it already contains the (up to three) needed fields handles. */
	308
eed2ef37	309	gint lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event_type,
2c82c4dc	310	GQuark field1, GQuark field2, GQuark field3, LttvHook h,
2c82c4dc	311	gpointer hook_data, LttvTraceHook *th);
b445142a	312
2d262115	313	LttvTracefileContext *lttv_traceset_context_get_current_tfc(
	314	LttvTracesetContext *self);
	315
8b0bbe19	316
9ba3aaaf	317	LttvTracesetContextPosition *lttv_traceset_context_position_new(
9ba3aaaf	318	const LttvTracesetContext *self);
5e2c04a2	319
8697a616	320	void lttv_traceset_context_position_save(const LttvTracesetContext *self,
	321	LttvTracesetContextPosition *pos);
	322
	323	void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos);
	324
5e2c04a2	325	void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
	326	const LttvTracesetContextPosition *src);
	327
8697a616	328	gint lttv_traceset_context_pos_pos_compare(
8b0bbe19	329	const LttvTracesetContextPosition *pos1,
8b0bbe19	330	const LttvTracesetContextPosition *pos2);
8697a616	331
8697a616	332	gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
8b0bbe19	333	const LttvTracesetContextPosition *pos2);
8697a616	334
2d262115	335	LttTime lttv_traceset_context_position_get_time(
8b0bbe19	336	const LttvTracesetContextPosition *pos);
8b0bbe19	337
27304273	338	gint compare_tracefile(gconstpointer a, gconstpointer b);
8b0bbe19	339
2c82c4dc	340
	341	/* Synchronisation helpers : save/restore synchronization between ltt traces and
	342	* a traceset context. */
18c87975	343	void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *tsc);
2c82c4dc	344
18c87975	345	void lttv_process_traceset_get_sync_data(LttvTracesetContext *tsc);
2c82c4dc	346
0bd2f89c	347	/* Seek n events forward and backward (without filtering) : only use these where
	348	* necessary : the seek backward is costy. */
	349
	350	#define BACKWARD_SEEK_MUL 2 /* Multiplication factor of time_offset between
	351	backward seek iterations */
	352
9d227699	353	static const LttTime seek_back_default_offset = { 1, 0 };
33e44b82	354
fb3d6047	355	typedef gboolean check_handler(guint count, gboolean *stop_flag, gpointer data);
04f2543e	356
0bd2f89c	357	guint lttv_process_traceset_seek_n_forward(LttvTracesetContext *self,
33e44b82	358	guint n,
04f2543e	359	check_handler *check,
b139ad2a	360	gboolean *stop_flag,
	361	LttvFilter *filter1,
	362	LttvFilter *filter2,
fb3d6047	363	LttvFilter *filter3,
fb3d6047	364	gpointer data);
33e44b82	365	typedef void (seek_time_fct)(LttvTracesetContext self, LttTime start);
0bd2f89c	366
33e44b82	367	/* If first_offset is ltt_time_zero, it will choose a default value */
0bd2f89c	368	guint lttv_process_traceset_seek_n_backward(LttvTracesetContext *self,
33e44b82	369	guint n,
	370	LttTime first_offset,
	371	seek_time_fct,
04f2543e	372	check_handler *check,
b139ad2a	373	gboolean *stop_flag,
	374	LttvFilter *filter1,
	375	LttvFilter *filter2,
fb3d6047	376	LttvFilter *filter3,
fb3d6047	377	gpointer data);
33e44b82	378
0bd2f89c	379
dc877563	380	#endif // PROCESSTRACE_H