[lttv.git] / 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 <string.h>
#include <lttv/traceset.h>
#include <lttv/attribute.h>
#include <lttv/hook.h>
#include <ltt/ltt.h>
#include <ltt/marker.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,
		LttvHooksByIdChannelArray *event_by_id_channel);


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

void lttv_process_traceset_end(LttvTracesetContext *self,
		LttvHooks *after_traceset,
		LttvHooks *after_trace,
		LttvHooks *after_tracefile,
		LttvHooks *event,
		LttvHooksByIdChannelArray *event_by_id_channel);

guint lttv_process_traceset_update(LttvTracesetContext *self);


void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start);

void lttv_traceset_context_compute_time_span(LttvTracesetContext *self,
		TimeInterval *time_span);

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,
		LttvHooksByIdChannelArray *event_by_id_channel);

void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
		LttvHooks *after_traceset,
		LttvHooks *after_trace,
		LttvHooks *after_tracefile,
		LttvHooks *event,
		LttvHooksByIdChannelArray *event_by_id_channel);

void lttv_trace_context_add_hooks(LttvTraceContext *self,
		LttvHooks *before_trace,
		LttvHooks *before_tracefile,
		LttvHooks *event,
		LttvHooksByIdChannelArray *event_by_id_channel);

void lttv_trace_context_remove_hooks(LttvTraceContext *self,
		LttvHooks *after_trace,
		LttvHooks *after_tracefile,
		LttvHooks *event,
		LttvHooksByIdChannelArray *event_by_id_channel);

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

typedef struct _LttvTraceHook {
	LttvHook h;
	struct marker_data *mdata;
	GQuark channel;
	guint16 id;  /* id of the marker associated with this hook */
	GPtrArray *fields;  /* struct marker_fields pointers */
	gpointer hook_data;
} LttvTraceHook;

/* Get the head of marker list corresponding to the given trace hook.
 */
struct marker_info *lttv_trace_hook_get_marker(LttTrace *t, LttvTraceHook *th);

/* Remove the hooks from the array. Does not free the array itself. */
void lttv_trace_hook_remove_all(GArray **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.
   Returns the modified LttvTraceHook array.
   Prints warnings if events or markers are not found. returns 1 on error,
   0 on success.
   Adds the hooks to the trace_hooks array.
 */

int lttv_trace_find_hook(LttTrace *t, GQuark facility_name, GQuark event_name,
		GQuark fields[], LttvHook h, gpointer hook_data,
		GArray **trace_hooks);

static inline struct marker_field *
lttv_trace_get_hook_field(LttvTraceHook *hook, unsigned int index)
{
	return g_ptr_array_index(hook->fields, index);
}

#if 0
static inline GQuark lttv_merge_facility_event_name(GQuark fac, GQuark ev)
{
	char *tmp;
	const char *sfac, *sev;
	GQuark ret;

	sfac = g_quark_to_string(fac);
	sev = g_quark_to_string(ev);
	tmp = g_new(char, strlen(sfac) + strlen(sev) + 3); /* 3: _ \0 \0 */
	strcpy(tmp, sfac);
	strcat(tmp, "_");
	strcat(tmp, sev);
	ret = g_quark_from_string(tmp);
	g_free(tmp);
	return ret;
}
#endif //0

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

#define FIELD_ARRAY(val...) ((GQuark[]){ val, 0 })

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