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

#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;
};

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;
  LttvAttribute *a;
  LttvAttribute *t_a;
};

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

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);

/* Save the complete tracefile information in the context */
//void lttv_process_traceset_get_sync_data(LttvTracesetContext *self);

/* Put all the tracefiles at the tracefile context position */
void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *self);

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

typedef struct _LttvTraceHook {
  LttvHook h;
  guint id;
  LttField *f1;
  LttField *f2;
  LttField *f3;
} LttvTraceHook;


/* 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. */
 
void lttv_trace_find_hook(LttTrace *t, char *facility, char *event_type,
    char *field1, char *field2, char *field3, LttvHook h, LttvTraceHook *th);

LttvTracefileContext *lttv_traceset_context_get_current_tfc(
                             LttvTracesetContext *self);


LttvTracesetContextPosition *lttv_traceset_context_position_new();

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);

gboolean lttv_process_tracefile_seek_position(LttvTracefileContext *self, 
                                              const LttEventPosition *pos);


#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
dc877563	80	#define LTTV_TRACESET_CONTEXT_TYPE (lttv_traceset_context_get_type ())
	81	#define LTTV_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContext))
	82	#define LTTV_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
	83	#define LTTV_IS_TRACESET_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_CONTEXT_TYPE))
	84	#define LTTV_IS_TRACESET_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_CONTEXT_TYPE))
	85	#define LTTV_TRACESET_CONTEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_CONTEXT_TYPE, LttvTracesetContextClass))
	86
dc877563	87	struct _LttvTracesetContext {
	88	GObject parent;
	89
	90	LttvTraceset *ts;
dc877563	91	LttvTraceContext **traces;
dc877563	92	LttvAttribute *a;
308711e5	93	LttvAttribute *ts_a;
8697a616	94	TimeInterval time_span;
2a2fa4f0	95	GTree *pqueue;
dc877563	96	};
	97
	98	struct _LttvTracesetContextClass {
	99	GObjectClass parent;
	100
	101	void (init) (LttvTracesetContext self, LttvTraceset *ts);
	102	void (fini) (LttvTracesetContext self);
	103	LttvTracesetContext* (new_traceset_context) (LttvTracesetContext self);
	104	LttvTraceContext* (new_trace_context) (LttvTracesetContext self);
	105	LttvTracefileContext* (new_tracefile_context) (LttvTracesetContext self);
	106	};
	107
	108	GType lttv_traceset_context_get_type (void);
	109
	110	void lttv_context_init(LttvTracesetContext self, LttvTraceset ts);
	111
	112	void lttv_context_fini(LttvTracesetContext *self);
	113
	114	LttvTracesetContext *
	115	lttv_context_new_traceset_context(LttvTracesetContext *self);
	116
	117	LttvTraceContext *
	118	lttv_context_new_trace_context(LttvTracesetContext *self);
	119
	120	LttvTracefileContext *
	121	lttv_context_new_tracefile_context(LttvTracesetContext *self);
	122
	123
	124	#define LTTV_TRACE_CONTEXT_TYPE (lttv_trace_context_get_type ())
	125	#define LTTV_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContext))
	126	#define LTTV_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
	127	#define LTTV_IS_TRACE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_CONTEXT_TYPE))
	128	#define LTTV_IS_TRACE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_CONTEXT_TYPE))
	129	#define LTTV_TRACE_CONTEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_CONTEXT_TYPE, LttvTraceContextClass))
	130
dc877563	131	struct _LttvTraceContext {
	132	GObject parent;
	133
	134	LttvTracesetContext *ts_context;
	135	guint index; /* in ts_context->traces */
ffd54a90	136	LttTrace *t;
308711e5	137	LttvTrace *vt;
dbb7bb09	138	LttvTracefileContext **tracefiles;
dc877563	139	LttvAttribute *a;
308711e5	140	LttvAttribute *t_a;
dc877563	141	};
	142
	143	struct _LttvTraceContextClass {
	144	GObjectClass parent;
	145	};
	146
	147	GType lttv_trace_context_get_type (void);
	148
	149	#define LTTV_TRACEFILE_CONTEXT_TYPE (lttv_tracefile_context_get_type ())
	150	#define LTTV_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContext))
	151	#define LTTV_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
	152	#define LTTV_IS_TRACEFILE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_CONTEXT_TYPE))
	153	#define LTTV_IS_TRACEFILE_CONTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_CONTEXT_TYPE))
	154	#define LTTV_TRACEFILE_CONTEXT_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_CONTEXT_TYPE, LttvTracefileContextClass))
	155
dc877563	156	struct _LttvTracefileContext {
	157	GObject parent;
	158
	159	LttvTraceContext *t_context;
	160	gboolean control;
dbb7bb09	161	guint index; /* in ts_context->tracefiles */
ffd54a90	162	LttTracefile *tf;
ffd54a90	163	LttEvent *e;
8697a616	164	LttvHooks *event;
8697a616	165	LttvHooksById *event_by_id;
ffd54a90	166	LttTime timestamp;
dc877563	167	LttvAttribute *a;
	168	};
	169
	170	struct _LttvTracefileContextClass {
	171	GObjectClass parent;
	172	};
	173
	174	GType lttv_tracefile_context_get_type (void);
	175
2a2fa4f0	176	/* Run through the events in a traceset in sorted order calling all the
	177	hooks appropriately. It starts at the current time and runs until end or
	178	nb_events are processed. */
	179
308711e5	180	void lttv_process_traceset(LttvTracesetContext *self, LttTime end,
2a2fa4f0	181	unsigned nb_events);
2a2fa4f0	182
8b0bbe19	183	/* Save the complete tracefile information in the context */
	184	//void lttv_process_traceset_get_sync_data(LttvTracesetContext *self);
	185
	186	/* Put all the tracefiles at the tracefile context position */
	187	void lttv_process_traceset_synchronize_tracefiles(LttvTracesetContext *self);
	188
8697a616	189	/* Process traceset can also be done in smaller pieces calling begin,
	190	* then seek and middle repeatedly, and end. The middle function return the
	191	* number of events processed. It will be smaller than nb_events if the end time
	192	* or end position is reached. */
2a2fa4f0	193
2a2fa4f0	194
8697a616	195	void lttv_process_traceset_begin(LttvTracesetContext *self,
	196	LttvHooks *before_traceset,
	197	LttvHooks *before_trace,
	198	LttvHooks *before_tracefile,
	199	LttvHooks *event,
	200	LttvHooksById *event_by_id);
	201
2a2fa4f0	202
8697a616	203	guint lttv_process_traceset_middle(LttvTracesetContext *self,
8697a616	204	LttTime end,
b8eccacd	205	guint nb_events,
8697a616	206	const LttvTracesetContextPosition *end_position);
	207
	208	void lttv_process_traceset_end(LttvTracesetContext *self,
	209	LttvHooks *after_traceset,
	210	LttvHooks *after_trace,
	211	LttvHooks *after_tracefile,
	212	LttvHooks *event,
	213	LttvHooksById *event_by_id);
2a2fa4f0	214
308711e5	215
	216	void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);
	217
8697a616	218	gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
	219	const LttvTracesetContextPosition *pos);
	220
308711e5	221	void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start);
dc877563	222
dc877563	223	void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
8697a616	224	LttvHooks *before_traceset,
dc877563	225	LttvHooks *before_trace,
ffd54a90	226	LttvHooks *before_tracefile,
8697a616	227	LttvHooks *event,
8697a616	228	LttvHooksById *event_by_id);
dc877563	229
dc877563	230	void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
dc877563	231	LttvHooks *after_traceset,
dc877563	232	LttvHooks *after_trace,
ffd54a90	233	LttvHooks *after_tracefile,
8697a616	234	LttvHooks *event,
8697a616	235	LttvHooksById *event_by_id);
dc877563	236
a8c0f09d	237	void lttv_trace_context_add_hooks(LttvTraceContext *self,
8697a616	238	LttvHooks *before_trace,
	239	LttvHooks *before_tracefile,
	240	LttvHooks *event,
	241	LttvHooksById *event_by_id);
a8c0f09d	242
a8c0f09d	243	void lttv_trace_context_remove_hooks(LttvTraceContext *self,
8697a616	244	LttvHooks *after_trace,
	245	LttvHooks *after_tracefile,
	246	LttvHooks *event,
	247	LttvHooksById *event_by_id);
a8c0f09d	248
a8c0f09d	249	void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
8697a616	250	LttvHooks *before_tracefile,
	251	LttvHooks *event,
	252	LttvHooksById *event_by_id);
	253
a8c0f09d	254
a8c0f09d	255	void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
8697a616	256	LttvHooks *after_tracefile,
	257	LttvHooks *event,
	258	LttvHooksById *event_by_id);
	259
a8c0f09d	260
	261	void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *self,
	262	unsigned i,
8697a616	263	LttvHooks *event_by_id);
a8c0f09d	264
	265	void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *self,
	266	unsigned i);
	267
b445142a	268	typedef struct _LttvTraceHook {
	269	LttvHook h;
	270	guint id;
	271	LttField *f1;
	272	LttField *f2;
	273	LttField *f3;
	274	} LttvTraceHook;
	275
	276
	277	/* Search in the trace for the id of the named event type within the named
	278	facility. Then, find the three (if non null) named fields. All that
	279	information is then used to fill the LttvTraceHook structure. This
	280	is useful to find the specific id for an event within a trace, for
	281	registering a hook using this structure as event data;
	282	it already contains the (up to three) needed fields handles. */
	283
	284	void lttv_trace_find_hook(LttTrace t, char facility, char *event_type,
	285	char field1, char field2, char field3, LttvHook h, LttvTraceHook th);
	286
2d262115	287	LttvTracefileContext *lttv_traceset_context_get_current_tfc(
	288	LttvTracesetContext *self);
	289
8b0bbe19	290
8b0bbe19	291	LttvTracesetContextPosition *lttv_traceset_context_position_new();
5e2c04a2	292
8697a616	293	void lttv_traceset_context_position_save(const LttvTracesetContext *self,
	294	LttvTracesetContextPosition *pos);
	295
	296	void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos);
	297
5e2c04a2	298	void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
	299	const LttvTracesetContextPosition *src);
	300
8697a616	301	gint lttv_traceset_context_pos_pos_compare(
8b0bbe19	302	const LttvTracesetContextPosition *pos1,
8b0bbe19	303	const LttvTracesetContextPosition *pos2);
8697a616	304
8697a616	305	gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
8b0bbe19	306	const LttvTracesetContextPosition *pos2);
8697a616	307
2d262115	308	LttTime lttv_traceset_context_position_get_time(
8b0bbe19	309	const LttvTracesetContextPosition *pos);
8b0bbe19	310
00e74b69	311	gboolean lttv_process_tracefile_seek_position(LttvTracefileContext *self,
	312	const LttEventPosition *pos);
	313
8b0bbe19	314
dc877563	315	#endif // PROCESSTRACE_H