[lttv.git] / lttv / lttv / state.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 STATE_H
#define STATE_H

#include <glib.h>
#include <lttv/tracecontext.h>
#include <stdio.h>

/* The operating system state, kept during the trace analysis,
   contains a subset of the real operating system state, 
   sufficient for the analysis, and possibly organized quite differently.

   The state information is added to LttvTracesetContext, LttvTraceContext 
   and LttvTracefileContext objects, used by process_traceset, through
   subtyping. The context objects already reflect the multiple tracefiles
   (one per cpu) per trace and multiple traces per trace set. The state
   objects defined here simply add fields to the relevant context objects. 

   There is no traceset specific state yet. It may eventually contains such
   things as clock differences over time.

   The trace state currently consists in a process table. 

   The tracefile level state relates to the associated cpu. It contains the
   position of the current event in the tracefile (since the state depends on
   which events have been processed) and a pointer to the current process,
   in the process table, being run on that cpu.

   For each process in the process table, various information such as exec 
   file name, pid, ppid and creation time are stored. Each process state also
   contains an execution mode stack (e.g. irq within system call, called
   from user mode). */

/* Priority of state hooks */
#define LTTV_PRIO_STATE 25

#define LTTV_STATE_SAVE_INTERVAL 50000

/* Channel Quarks */

extern GQuark
	LTT_CHANNEL_FD_STATE,
	LTT_CHANNEL_GLOBAL_STATE,
	LTT_CHANNEL_IRQ_STATE,
	LTT_CHANNEL_MODULE_STATE,
	LTT_CHANNEL_NETIF_STATE,
	LTT_CHANNEL_SOFTIRQ_STATE,
	LTT_CHANNEL_SWAP_STATE,
	LTT_CHANNEL_SYSCALL_STATE,
	LTT_CHANNEL_TASK_STATE,
	LTT_CHANNEL_VM_STATE,
	LTT_CHANNEL_KPROBE_STATE,
	LTT_CHANNEL_FS,
	LTT_CHANNEL_KERNEL,
	LTT_CHANNEL_MM,
	LTT_CHANNEL_USERSPACE,
	LTT_CHANNEL_BLOCK;

/* Events Quarks */

extern GQuark 
	LTT_EVENT_SYSCALL_ENTRY,
	LTT_EVENT_SYSCALL_EXIT,
	LTT_EVENT_TRAP_ENTRY,
	LTT_EVENT_TRAP_EXIT,
	LTT_EVENT_PAGE_FAULT_ENTRY,
	LTT_EVENT_PAGE_FAULT_EXIT,
	LTT_EVENT_PAGE_FAULT_NOSEM_ENTRY,
	LTT_EVENT_PAGE_FAULT_NOSEM_EXIT,
	LTT_EVENT_IRQ_ENTRY,
	LTT_EVENT_IRQ_EXIT,
	LTT_EVENT_SOFT_IRQ_RAISE,
	LTT_EVENT_SOFT_IRQ_ENTRY,
	LTT_EVENT_SOFT_IRQ_EXIT,
	LTT_EVENT_SCHED_SCHEDULE,
	LTT_EVENT_SCHED_TRY_WAKEUP,
	LTT_EVENT_PROCESS_FORK,
	LTT_EVENT_KTHREAD_CREATE,
	LTT_EVENT_PROCESS_EXIT,
	LTT_EVENT_PROCESS_FREE,
	LTT_EVENT_EXEC,
	LTT_EVENT_PROCESS_STATE,
	LTT_EVENT_STATEDUMP_END,
	LTT_EVENT_FUNCTION_ENTRY,
	LTT_EVENT_FUNCTION_EXIT,
	LTT_EVENT_THREAD_BRAND,
	LTT_EVENT_REQUEST_ISSUE,
	LTT_EVENT_REQUEST_COMPLETE,
	LTT_EVENT_LIST_INTERRUPT,
	LTT_EVENT_SYS_CALL_TABLE,
	LTT_EVENT_SOFTIRQ_VEC,
	LTT_EVENT_KPROBE_TABLE,
	LTT_EVENT_KPROBE,
	LTT_EVENT_OPEN,
	LTT_EVENT_READ,
	LTT_EVENT_POLL_EVENT;

/* Fields Quarks */

extern GQuark 
	LTT_FIELD_SYSCALL_ID,
	LTT_FIELD_TRAP_ID,
	LTT_FIELD_IRQ_ID,
	LTT_FIELD_SOFT_IRQ_ID,
	LTT_FIELD_PREV_PID,
	LTT_FIELD_NEXT_PID,
	LTT_FIELD_PREV_STATE,
	LTT_FIELD_PARENT_PID,
	LTT_FIELD_CHILD_PID,
	LTT_FIELD_PID,
	LTT_FIELD_TGID,
	LTT_FIELD_FILENAME,
	LTT_FIELD_NAME,
	LTT_FIELD_TYPE,
	LTT_FIELD_MODE,
	LTT_FIELD_SUBMODE,
	LTT_FIELD_STATUS,
	LTT_FIELD_THIS_FN,
	LTT_FIELD_CALL_SITE,
	LTT_FIELD_MINOR,
	LTT_FIELD_MAJOR,
	LTT_FIELD_OPERATION,
	LTT_FIELD_ACTION,
	LTT_FIELD_ID,
	LTT_FIELD_ADDRESS,
	LTT_FIELD_SYMBOL,
	LTT_FIELD_IP,
	LTT_FIELD_FD,
	LTT_FIELD_STATE,
	LTT_FIELD_CPU_ID;

typedef struct _LttvTracesetState LttvTracesetState;
typedef struct _LttvTracesetStateClass LttvTracesetStateClass;

typedef struct _LttvTraceState LttvTraceState;
typedef struct _LttvTraceStateClass LttvTraceStateClass;

typedef struct _LttvTracefileState LttvTracefileState;
typedef struct _LttvTracefileStateClass LttvTracefileStateClass;

gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data);
void lttv_state_add_event_hooks(LttvTracesetState *self);

gint lttv_state_hook_remove_event_hooks(void *hook_data, void *call_data);
void lttv_state_remove_event_hooks(LttvTracesetState *self);

void lttv_state_save_add_event_hooks(LttvTracesetState *self);
// Hook wrapper. call_data is a trace context.
gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data);

void lttv_state_save_remove_event_hooks(LttvTracesetState *self);
// Hook wrapper. call_data is a trace context.
gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data);

void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t);

/* The LttvProcessState structure defines the current state for each process.
   A process can make system calls (in some rare cases nested) and receive
   interrupts/faults. For instance, a process may issue a system call,
   generate a page fault while reading an argument from user space, and
   get caught by an interrupt. To represent these nested states, an
   execution mode stack is maintained. The stack bottom is normal user mode 
   and the top of stack is the current execution mode.

   The execution mode stack tells about the process status, execution mode and
   submode (interrupt, system call or IRQ number). All these could be 
   defined as enumerations but may need extensions (e.g. new process state). 
   GQuark are thus used. They are as easy to manipulate as integers but have
   a string associated, just like enumerations.

   The execution mode is one of "user mode", "kernel thread", "system call",
   "interrupt request", "fault". */

typedef GQuark LttvExecutionMode;

extern LttvExecutionMode
	LTTV_STATE_USER_MODE,
	LTTV_STATE_MAYBE_USER_MODE,
	LTTV_STATE_SYSCALL,
	LTTV_STATE_MAYBE_SYSCALL,
	LTTV_STATE_TRAP,
	LTTV_STATE_MAYBE_TRAP,	/* TODO */
	LTTV_STATE_IRQ,
	LTTV_STATE_SOFT_IRQ,
	LTTV_STATE_MODE_UNKNOWN;


/* The submode number depends on the execution mode. For user mode or kernel
   thread, which are the normal mode (execution mode stack bottom), 
   it is set to "none". For interrupt requests, faults and system calls, 
   it is set respectively to the interrupt name (e.g. "timer"), fault name 
   (e.g. "page fault"), and system call name (e.g. "select"). */
 
typedef GQuark LttvExecutionSubmode;

extern LttvExecutionSubmode
	LTTV_STATE_SUBMODE_NONE,
	LTTV_STATE_SUBMODE_UNKNOWN;

/* The process status is one of "running", "wait-cpu" (runnable), or "wait-*"
   where "*" describes the resource waited for (e.g. timer, process, 
   disk...). */

typedef GQuark LttvProcessStatus;

extern LttvProcessStatus
	LTTV_STATE_UNNAMED,
	LTTV_STATE_WAIT_FORK,
	LTTV_STATE_WAIT_CPU,
	LTTV_STATE_EXIT,
	LTTV_STATE_ZOMBIE,
	LTTV_STATE_WAIT,
	LTTV_STATE_RUN,
	LTTV_STATE_DEAD;

extern GQuark
	LTTV_STATE_UNBRANDED;

typedef GQuark LttvProcessType;

extern LttvProcessType
	LTTV_STATE_USER_THREAD,
	LTTV_STATE_KERNEL_THREAD;

typedef GQuark LttvCPUMode;
extern LttvCPUMode
	LTTV_CPU_UNKNOWN,
	LTTV_CPU_IDLE,
	LTTV_CPU_BUSY,
	LTTV_CPU_IRQ,
	LTTV_CPU_SOFT_IRQ,
	LTTV_CPU_TRAP;

typedef GQuark LttvIRQMode;
extern LttvIRQMode
	LTTV_IRQ_UNKNOWN,
	LTTV_IRQ_IDLE,
	LTTV_IRQ_BUSY;

typedef GQuark LttvBdevMode;
extern LttvBdevMode
	LTTV_BDEV_UNKNOWN,
	LTTV_BDEV_IDLE,
	LTTV_BDEV_BUSY_READING,
	LTTV_BDEV_BUSY_WRITING;

typedef struct _LttvExecutionState {
	LttvExecutionMode t;
	LttvExecutionSubmode n;
	LttTime entry;
	LttTime change;
	LttTime cum_cpu_time;
	LttvProcessStatus s;
} LttvExecutionState;

typedef struct _LttvProcessState {
	guint pid;
	guint tgid;
	guint ppid;
	LttTime creation_time;
	LttTime insertion_time;
	GQuark name;
	GQuark brand;
	GQuark pid_time;
	GArray *execution_stack;         /* Array of LttvExecutionState */
	LttvExecutionState *state;       /* Top of interrupt stack */
		/* WARNING : each time the execution_stack size is modified, the state
		 * must be reget : g_array_set_size can have to move the array.
		 * (Mathieu) */
	guint cpu;                /* CPU where process is scheduled (being either in
	                             the active or inactive runqueue)*/
//	guint last_tracefile_index;    /* index in the trace for cpu tracefile */
	LttvTracefileState *usertrace;    /* Associated usertrace */
	/* opened file descriptors, address map?... */
	GArray *user_stack;          /* User space function call stack */
	guint64 current_function;
	LttvProcessType type;        /* kernel thread or user space ? */
	guint target_pid; /* target PID of the current event. */
	guint free_events; /* 0 : none, 1 : free or exit dead, 2 : should delete */
	GHashTable *fds; /* hash table of int (file descriptor) -> GQuark (file name) */
} LttvProcessState;

#define ANY_CPU 0 /* For clarity sake : a call to lttv_state_find_process for
                     a PID != 0 will search on any cpu automatically. */

LttvProcessState *lttv_state_find_process(LttvTraceState *ts, guint cpu,
		guint pid);

LttvProcessState *lttv_state_find_process_or_create(LttvTraceState *ts,
		guint cpu, guint pid, const LttTime *timestamp);

LttvProcessState *lttv_state_create_process(LttvTraceState *tcs,
		LttvProcessState *parent, guint cpu, guint pid,
		guint tgid, GQuark name, const LttTime *timestamp);

void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp);
void lttv_state_write_raw(LttvTraceState *self, LttTime t, FILE *fp);

/* The LttvTracesetState, LttvTraceState and LttvTracefileState types
   inherit from the corresponding Context objects defined in processTrace. */

#define LTTV_TRACESET_STATE_TYPE  (lttv_traceset_state_get_type ())
#define LTTV_TRACESET_STATE(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_STATE_TYPE, LttvTracesetState))
#define LTTV_TRACESET_STATE_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_STATE_TYPE, LttvTracesetStateClass))
#define LTTV_IS_TRACESET_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_STATE_TYPE))
#define LTTV_IS_TRACESET_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_STATE_TYPE))
#define LTTV_TRACESET_STATE_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_STATE_TYPE, LttvTracesetStateClass))

struct _LttvTracesetState {
	LttvTracesetContext parent;
};

struct _LttvTracesetStateClass {
	LttvTracesetContextClass parent;
};

GType lttv_traceset_state_get_type (void);


#define LTTV_TRACE_STATE_TYPE  (lttv_trace_state_get_type ())
#define LTTV_TRACE_STATE(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_STATE_TYPE, LttvTraceState))
#define LTTV_TRACE_STATE_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_STATE_TYPE, LttvTraceStateClass))
#define LTTV_IS_TRACE_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_STATE_TYPE))
#define LTTV_IS_TRACE_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_STATE_TYPE))
#define LTTV_TRACE_STATE_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_STATE_TYPE, LttvTraceStateClass))

typedef struct _LttvCPUState {
	GArray *mode_stack;
	GArray *irq_stack;
	GArray *softirq_stack;
	GArray *trap_stack;
} LttvCPUState;

typedef struct _LttvIRQState {
	GArray *mode_stack;
} LttvIRQState;

typedef struct _LttvSoftIRQState {
	guint pending; /* number of times it is pending */
	guint running; /* number of times it is currently running (on different processors) */
} LttvSoftIRQState;

typedef struct _LttvTrapState {
	guint running; /* number of times it is currently running (on different processors) */
} LttvTrapState;

typedef struct _LttvBdevState {
	GArray *mode_stack;
} LttvBdevState;

typedef struct _LttvNameTables {
	GQuark *syscall_names;
	guint nb_syscalls;
	GQuark *trap_names;
	guint nb_traps;
	GQuark *irq_names;
	guint nb_irqs;
	GQuark *soft_irq_names;
	guint nb_soft_irqs;
	GHashTable *kprobe_hash;
} LttvNameTables;

struct _LttvTraceState {
	LttvTraceContext parent;

	GHashTable *processes;  /* LttvProcessState objects indexed by pid and
	                           last_cpu */
	GHashTable *usertraces;  /* GPtrArray objects indexed by pid, containing
	                           pointers to LttvTracefileState objects. */
	guint nb_event, save_interval;
	/* Block/char devices, locks, memory pages... */
	GQuark *eventtype_names;
	LttvNameTables *name_tables;
	LttTime *max_time_state_recomputed_in_seek;
	GHashTable *kprobe_hash;

	/* Array of per cpu running process */
	LttvProcessState **running_process;
	gboolean has_precomputed_states;
	LttvCPUState *cpu_states; /* state of each cpu */
	/* FIXME should be a g_array to deal with resize and copy. */
	LttvIRQState *irq_states; /* state of each irq handler */
	/* FIXME should be a g_array to deal with resize and copy. */
	LttvSoftIRQState *soft_irq_states; /* state of each softirq */
	/* FIXME should be a g_array to deal with resize and copy. */
	LttvTrapState *trap_states; /* state of each trap */
	GHashTable *bdev_states; /* state of the block devices */
};

struct _LttvTraceStateClass {
	LttvTraceContextClass parent;

	void (*state_save) (LttvTraceState *self, LttvAttribute *container);
	void (*state_restore) (LttvTraceState *self, LttvAttribute *container);
	void (*state_saved_free) (LttvTraceState *self, LttvAttribute *container);
};

GType lttv_trace_state_get_type (void);

void lttv_state_save(LttvTraceState *self, LttvAttribute *container);

void lttv_state_restore(LttvTraceState *self, LttvAttribute *container);

void lttv_state_state_saved_free(LttvTraceState *self, 
		LttvAttribute *container);

int lttv_state_pop_state_cleanup(LttvProcessState *process,
		LttvTracefileState *tfs);

#define LTTV_TRACEFILE_STATE_TYPE  (lttv_tracefile_state_get_type ())
#define LTTV_TRACEFILE_STATE(obj)  (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_STATE_TYPE, LttvTracefileState))
#define LTTV_TRACEFILE_STATE_CLASS(vtable)  (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_STATE_TYPE, LttvTracefileStateClass))
#define LTTV_IS_TRACEFILE_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_STATE_TYPE))
#define LTTV_IS_TRACEFILE_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_STATE_TYPE))
#define LTTV_TRACEFILE_STATE_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_STATE_TYPE, LttvTracefileStateClass))

struct _LttvTracefileState {
	LttvTracefileContext parent;

	GQuark tracefile_name;
	guint cpu;  /* Current cpu of the tracefile */ /* perhaps merge in cpu_state */
	LttvCPUState *cpu_state; /* cpu resource state */
};

struct _LttvTracefileStateClass {
	LttvTracefileContextClass parent;
};

GType lttv_tracefile_state_get_type (void);

static inline guint lttv_state_get_target_pid(LttvTracefileState *tfs)
{
	LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
	guint cpu = tfs->cpu;
	LttvProcessState *process = ts->running_process[cpu];

	if(tfs->parent.target_pid >= 0) return tfs->parent.target_pid;
	else return process->pid;
}


#define HDR_PROCESS 0
#define HDR_ES 1
#define HDR_USER_STACK 2
#define HDR_USERTRACE 3
#define HDR_PROCESS_STATE 4
#define HDR_CPU 5
#define HDR_TRACEFILE 6
#define HDR_TRACESET 7
#define HDR_TRACE 8
#define HDR_QUARKS 9
#define HDR_QUARK 10

/* Device number manipulation macros from kernel source */
#define MINORBITS	20
#define MINORMASK	((1U << MINORBITS) - 1)
#define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma, mi)	((((unsigned int) (ma)) << MINORBITS) | (unsigned int) (mi))

#endif // STATE_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 STATE_H
	20	#define STATE_H
	21
ffd54a90	22	#include <glib.h>
d8f124de	23	#include <lttv/tracecontext.h>
dbb7bb09	24	#include <stdio.h>
dc877563	25
dd025f91	26	/* The operating system state, kept during the trace analysis,
dc877563	27	contains a subset of the real operating system state,
	28	sufficient for the analysis, and possibly organized quite differently.
	29
ffd54a90	30	The state information is added to LttvTracesetContext, LttvTraceContext
d3e01c7a	31	and LttvTracefileContext objects, used by process_traceset, through
dc877563	32	subtyping. The context objects already reflect the multiple tracefiles
dc877563	33	(one per cpu) per trace and multiple traces per trace set. The state
308711e5	34	objects defined here simply add fields to the relevant context objects.
	35
	36	There is no traceset specific state yet. It may eventually contains such
	37	things as clock differences over time.
	38
	39	The trace state currently consists in a process table.
	40
	41	The tracefile level state relates to the associated cpu. It contains the
	42	position of the current event in the tracefile (since the state depends on
	43	which events have been processed) and a pointer to the current process,
	44	in the process table, being run on that cpu.
	45
1aeb0ff5	46	For each process in the process table, various information such as exec
308711e5	47	file name, pid, ppid and creation time are stored. Each process state also
	48	contains an execution mode stack (e.g. irq within system call, called
	49	from user mode). */
dc877563	50
a5ba1787	51	/* Priority of state hooks */
	52	#define LTTV_PRIO_STATE 25
	53
eed2ef37	54	#define LTTV_STATE_SAVE_INTERVAL 50000
eed2ef37	55
750eb11a	56	/* Channel Quarks */
eed2ef37	57
eed2ef37	58	extern GQuark
90e19f82 AM	59	LTT_CHANNEL_FD_STATE,
	60	LTT_CHANNEL_GLOBAL_STATE,
	61	LTT_CHANNEL_IRQ_STATE,
	62	LTT_CHANNEL_MODULE_STATE,
	63	LTT_CHANNEL_NETIF_STATE,
	64	LTT_CHANNEL_SOFTIRQ_STATE,
	65	LTT_CHANNEL_SWAP_STATE,
	66	LTT_CHANNEL_SYSCALL_STATE,
	67	LTT_CHANNEL_TASK_STATE,
	68	LTT_CHANNEL_VM_STATE,
	69	LTT_CHANNEL_KPROBE_STATE,
	70	LTT_CHANNEL_FS,
	71	LTT_CHANNEL_KERNEL,
	72	LTT_CHANNEL_MM,
	73	LTT_CHANNEL_USERSPACE,
	74	LTT_CHANNEL_BLOCK;
eed2ef37	75
	76	/* Events Quarks */
	77
	78	extern GQuark
90e19f82 AM	79	LTT_EVENT_SYSCALL_ENTRY,
	80	LTT_EVENT_SYSCALL_EXIT,
	81	LTT_EVENT_TRAP_ENTRY,
	82	LTT_EVENT_TRAP_EXIT,
	83	LTT_EVENT_PAGE_FAULT_ENTRY,
	84	LTT_EVENT_PAGE_FAULT_EXIT,
	85	LTT_EVENT_PAGE_FAULT_NOSEM_ENTRY,
	86	LTT_EVENT_PAGE_FAULT_NOSEM_EXIT,
	87	LTT_EVENT_IRQ_ENTRY,
	88	LTT_EVENT_IRQ_EXIT,
	89	LTT_EVENT_SOFT_IRQ_RAISE,
	90	LTT_EVENT_SOFT_IRQ_ENTRY,
	91	LTT_EVENT_SOFT_IRQ_EXIT,
	92	LTT_EVENT_SCHED_SCHEDULE,
	93	LTT_EVENT_SCHED_TRY_WAKEUP,
	94	LTT_EVENT_PROCESS_FORK,
	95	LTT_EVENT_KTHREAD_CREATE,
	96	LTT_EVENT_PROCESS_EXIT,
	97	LTT_EVENT_PROCESS_FREE,
	98	LTT_EVENT_EXEC,
	99	LTT_EVENT_PROCESS_STATE,
	100	LTT_EVENT_STATEDUMP_END,
	101	LTT_EVENT_FUNCTION_ENTRY,
	102	LTT_EVENT_FUNCTION_EXIT,
	103	LTT_EVENT_THREAD_BRAND,
	104	LTT_EVENT_REQUEST_ISSUE,
	105	LTT_EVENT_REQUEST_COMPLETE,
	106	LTT_EVENT_LIST_INTERRUPT,
	107	LTT_EVENT_SYS_CALL_TABLE,
	108	LTT_EVENT_SOFTIRQ_VEC,
	109	LTT_EVENT_KPROBE_TABLE,
	110	LTT_EVENT_KPROBE,
	111	LTT_EVENT_OPEN,
	112	LTT_EVENT_READ,
	113	LTT_EVENT_POLL_EVENT;
eed2ef37	114
	115	/* Fields Quarks */
	116
	117	extern GQuark
90e19f82 AM	118	LTT_FIELD_SYSCALL_ID,
	119	LTT_FIELD_TRAP_ID,
	120	LTT_FIELD_IRQ_ID,
	121	LTT_FIELD_SOFT_IRQ_ID,
	122	LTT_FIELD_PREV_PID,
	123	LTT_FIELD_NEXT_PID,
	124	LTT_FIELD_PREV_STATE,
	125	LTT_FIELD_PARENT_PID,
	126	LTT_FIELD_CHILD_PID,
	127	LTT_FIELD_PID,
	128	LTT_FIELD_TGID,
	129	LTT_FIELD_FILENAME,
	130	LTT_FIELD_NAME,
	131	LTT_FIELD_TYPE,
	132	LTT_FIELD_MODE,
	133	LTT_FIELD_SUBMODE,
	134	LTT_FIELD_STATUS,
	135	LTT_FIELD_THIS_FN,
	136	LTT_FIELD_CALL_SITE,
	137	LTT_FIELD_MINOR,
	138	LTT_FIELD_MAJOR,
	139	LTT_FIELD_OPERATION,
	140	LTT_FIELD_ACTION,
	141	LTT_FIELD_ID,
	142	LTT_FIELD_ADDRESS,
	143	LTT_FIELD_SYMBOL,
	144	LTT_FIELD_IP,
	145	LTT_FIELD_FD,
	146	LTT_FIELD_STATE,
	147	LTT_FIELD_CPU_ID;
eed2ef37	148
ffd54a90	149	typedef struct _LttvTracesetState LttvTracesetState;
	150	typedef struct _LttvTracesetStateClass LttvTracesetStateClass;
	151
	152	typedef struct _LttvTraceState LttvTraceState;
	153	typedef struct _LttvTraceStateClass LttvTraceStateClass;
	154
	155	typedef struct _LttvTracefileState LttvTracefileState;
	156	typedef struct _LttvTracefileStateClass LttvTracefileStateClass;
	157
58c88a41	158	gint lttv_state_hook_add_event_hooks(void hook_data, void call_data);
308711e5	159	void lttv_state_add_event_hooks(LttvTracesetState *self);
308711e5	160
58c88a41	161	gint lttv_state_hook_remove_event_hooks(void hook_data, void call_data);
308711e5	162	void lttv_state_remove_event_hooks(LttvTracesetState *self);
	163
	164	void lttv_state_save_add_event_hooks(LttvTracesetState *self);
b56b5fec	165	// Hook wrapper. call_data is a trace context.
b56b5fec	166	gint lttv_state_save_hook_add_event_hooks(void hook_data, void call_data);
dc877563	167
308711e5	168	void lttv_state_save_remove_event_hooks(LttvTracesetState *self);
b56b5fec	169	// Hook wrapper. call_data is a trace context.
b56b5fec	170	gint lttv_state_save_hook_remove_event_hooks(void hook_data, void call_data);
308711e5	171
dd025f91	172	void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t);
dc877563	173
b445142a	174	/* The LttvProcessState structure defines the current state for each process.
	175	A process can make system calls (in some rare cases nested) and receive
	176	interrupts/faults. For instance, a process may issue a system call,
	177	generate a page fault while reading an argument from user space, and
	178	get caught by an interrupt. To represent these nested states, an
	179	execution mode stack is maintained. The stack bottom is normal user mode
	180	and the top of stack is the current execution mode.
	181
	182	The execution mode stack tells about the process status, execution mode and
	183	submode (interrupt, system call or IRQ number). All these could be
	184	defined as enumerations but may need extensions (e.g. new process state).
	185	GQuark are thus used. They are as easy to manipulate as integers but have
	186	a string associated, just like enumerations.
dc877563	187
b445142a	188	The execution mode is one of "user mode", "kernel thread", "system call",
dc877563	189	"interrupt request", "fault". */
dc877563	190
b445142a	191	typedef GQuark LttvExecutionMode;
dc877563	192
b445142a	193	extern LttvExecutionMode
90e19f82	194	LTTV_STATE_USER_MODE,
f044974e	195	LTTV_STATE_MAYBE_USER_MODE,
90e19f82	196	LTTV_STATE_SYSCALL,
f044974e	197	LTTV_STATE_MAYBE_SYSCALL,
90e19f82	198	LTTV_STATE_TRAP,
f044974e	199	LTTV_STATE_MAYBE_TRAP, /* TODO */
90e19f82 AM	200	LTTV_STATE_IRQ,
	201	LTTV_STATE_SOFT_IRQ,
	202	LTTV_STATE_MODE_UNKNOWN;
ffd54a90	203
dc877563	204
b445142a	205	/* The submode number depends on the execution mode. For user mode or kernel
	206	thread, which are the normal mode (execution mode stack bottom),
	207	it is set to "none". For interrupt requests, faults and system calls,
	208	it is set respectively to the interrupt name (e.g. "timer"), fault name
996acd92	209	(e.g. "page fault"), and system call name (e.g. "select"). */
dc877563	210
b445142a	211	typedef GQuark LttvExecutionSubmode;
dc877563	212
b445142a	213	extern LttvExecutionSubmode
90e19f82 AM	214	LTTV_STATE_SUBMODE_NONE,
90e19f82 AM	215	LTTV_STATE_SUBMODE_UNKNOWN;
dc877563	216
	217	/* The process status is one of "running", "wait-cpu" (runnable), or "wait-*"
	218	where "*" describes the resource waited for (e.g. timer, process,
	219	disk...). */
	220
	221	typedef GQuark LttvProcessStatus;
	222
ffd54a90	223	extern LttvProcessStatus
90e19f82 AM	224	LTTV_STATE_UNNAMED,
	225	LTTV_STATE_WAIT_FORK,
	226	LTTV_STATE_WAIT_CPU,
	227	LTTV_STATE_EXIT,
	228	LTTV_STATE_ZOMBIE,
	229	LTTV_STATE_WAIT,
	230	LTTV_STATE_RUN,
	231	LTTV_STATE_DEAD;
dc877563	232
c4a72569	233	extern GQuark
90e19f82	234	LTTV_STATE_UNBRANDED;
c4a72569	235
e62e7f3a	236	typedef GQuark LttvProcessType;
	237
	238	extern LttvProcessType
90e19f82 AM	239	LTTV_STATE_USER_THREAD,
90e19f82 AM	240	LTTV_STATE_KERNEL_THREAD;
ffd54a90	241
44ffb95f	242	typedef GQuark LttvCPUMode;
44ffb95f	243	extern LttvCPUMode
90e19f82 AM	244	LTTV_CPU_UNKNOWN,
	245	LTTV_CPU_IDLE,
	246	LTTV_CPU_BUSY,
	247	LTTV_CPU_IRQ,
	248	LTTV_CPU_SOFT_IRQ,
	249	LTTV_CPU_TRAP;
44ffb95f	250
5e563da0	251	typedef GQuark LttvIRQMode;
5e563da0	252	extern LttvIRQMode
90e19f82 AM	253	LTTV_IRQ_UNKNOWN,
	254	LTTV_IRQ_IDLE,
	255	LTTV_IRQ_BUSY;
5e563da0	256
27811799	257	typedef GQuark LttvBdevMode;
27811799	258	extern LttvBdevMode
90e19f82 AM	259	LTTV_BDEV_UNKNOWN,
	260	LTTV_BDEV_IDLE,
	261	LTTV_BDEV_BUSY_READING,
	262	LTTV_BDEV_BUSY_WRITING;
27811799	263
b445142a	264	typedef struct _LttvExecutionState {
90e19f82 AM	265	LttvExecutionMode t;
	266	LttvExecutionSubmode n;
	267	LttTime entry;
	268	LttTime change;
	269	LttTime cum_cpu_time;
	270	LttvProcessStatus s;
b445142a	271	} LttvExecutionState;
dc877563	272
dc877563	273	typedef struct _LttvProcessState {
90e19f82 AM	274	guint pid;
	275	guint tgid;
	276	guint ppid;
	277	LttTime creation_time;
	278	LttTime insertion_time;
	279	GQuark name;
	280	GQuark brand;
	281	GQuark pid_time;
	282	GArray execution_stack; / Array of LttvExecutionState */
	283	LttvExecutionState state; / Top of interrupt stack */
	284	/* WARNING : each time the execution_stack size is modified, the state
	285	* must be reget : g_array_set_size can have to move the array.
	286	* (Mathieu) */
	287	guint cpu; /* CPU where process is scheduled (being either in
	288	the active or inactive runqueue)*/
	289	// guint last_tracefile_index; /* index in the trace for cpu tracefile */
	290	LttvTracefileState usertrace; / Associated usertrace */
	291	/* opened file descriptors, address map?... */
	292	GArray user_stack; / User space function call stack */
	293	guint64 current_function;
	294	LttvProcessType type; /* kernel thread or user space ? */
	295	guint target_pid; /* target PID of the current event. */
	296	guint free_events; /* 0 : none, 1 : free or exit dead, 2 : should delete */
	297	GHashTable fds; / hash table of int (file descriptor) -> GQuark (file name) */
dc877563	298	} LttvProcessState;
dc877563	299
348c6ba8	300	#define ANY_CPU 0 /* For clarity sake : a call to lttv_state_find_process for
	301	a PID != 0 will search on any cpu automatically. */
	302
90e19f82 AM	303	LttvProcessState lttv_state_find_process(LttvTraceState ts, guint cpu,
90e19f82 AM	304	guint pid);
2a2fa4f0	305
90e19f82 AM	306	LttvProcessState lttv_state_find_process_or_create(LttvTraceState ts,
90e19f82 AM	307	guint cpu, guint pid, const LttTime *timestamp);
2a2fa4f0	308
90e19f82 AM	309	LttvProcessState lttv_state_create_process(LttvTraceState tcs,
	310	LttvProcessState *parent, guint cpu, guint pid,
	311	guint tgid, GQuark name, const LttTime *timestamp);
b445142a	312
dbb7bb09	313	void lttv_state_write(LttvTraceState self, LttTime t, FILE fp);
6d0cdf22	314	void lttv_state_write_raw(LttvTraceState self, LttTime t, FILE fp);
b445142a	315
ffd54a90	316	/* The LttvTracesetState, LttvTraceState and LttvTracefileState types
dc877563	317	inherit from the corresponding Context objects defined in processTrace. */
	318
	319	#define LTTV_TRACESET_STATE_TYPE (lttv_traceset_state_get_type ())
ffd54a90	320	#define LTTV_TRACESET_STATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACESET_STATE_TYPE, LttvTracesetState))
ffd54a90	321	#define LTTV_TRACESET_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACESET_STATE_TYPE, LttvTracesetStateClass))
dc877563	322	#define LTTV_IS_TRACESET_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACESET_STATE_TYPE))
dc877563	323	#define LTTV_IS_TRACESET_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACESET_STATE_TYPE))
ffd54a90	324	#define LTTV_TRACESET_STATE_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACESET_STATE_TYPE, LttvTracesetStateClass))
dc877563	325
ffd54a90	326	struct _LttvTracesetState {
90e19f82	327	LttvTracesetContext parent;
dc877563	328	};
	329
	330	struct _LttvTracesetStateClass {
90e19f82	331	LttvTracesetContextClass parent;
dc877563	332	};
	333
	334	GType lttv_traceset_state_get_type (void);
	335
	336
	337	#define LTTV_TRACE_STATE_TYPE (lttv_trace_state_get_type ())
	338	#define LTTV_TRACE_STATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACE_STATE_TYPE, LttvTraceState))
	339	#define LTTV_TRACE_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACE_STATE_TYPE, LttvTraceStateClass))
	340	#define LTTV_IS_TRACE_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACE_STATE_TYPE))
	341	#define LTTV_IS_TRACE_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACE_STATE_TYPE))
	342	#define LTTV_TRACE_STATE_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACE_STATE_TYPE, LttvTraceStateClass))
	343
44ffb95f	344	typedef struct _LttvCPUState {
90e19f82 AM	345	GArray *mode_stack;
	346	GArray *irq_stack;
	347	GArray *softirq_stack;
	348	GArray *trap_stack;
44ffb95f	349	} LttvCPUState;
44ffb95f	350
5e563da0	351	typedef struct _LttvIRQState {
90e19f82	352	GArray *mode_stack;
5e563da0	353	} LttvIRQState;
5e563da0	354
0305fe77	355	typedef struct _LttvSoftIRQState {
90e19f82 AM	356	guint pending; /* number of times it is pending */
90e19f82 AM	357	guint running; /* number of times it is currently running (on different processors) */
0305fe77	358	} LttvSoftIRQState;
0305fe77	359
38726a78	360	typedef struct _LttvTrapState {
90e19f82	361	guint running; /* number of times it is currently running (on different processors) */
38726a78	362	} LttvTrapState;
38726a78	363
27811799	364	typedef struct _LttvBdevState {
90e19f82	365	GArray *mode_stack;
27811799	366	} LttvBdevState;
27811799	367
1cd9058f	368	typedef struct _LttvNameTables {
90e19f82 AM	369	GQuark *syscall_names;
	370	guint nb_syscalls;
	371	GQuark *trap_names;
	372	guint nb_traps;
	373	GQuark *irq_names;
	374	guint nb_irqs;
	375	GQuark *soft_irq_names;
	376	guint nb_soft_irqs;
	377	GHashTable *kprobe_hash;
1cd9058f MD	378	} LttvNameTables;
1cd9058f MD	379
dc877563	380	struct _LttvTraceState {
90e19f82 AM	381	LttvTraceContext parent;
	382
	383	GHashTable processes; / LttvProcessState objects indexed by pid and
	384	last_cpu */
	385	GHashTable usertraces; / GPtrArray objects indexed by pid, containing
	386	pointers to LttvTracefileState objects. */
	387	guint nb_event, save_interval;
	388	/* Block/char devices, locks, memory pages... */
	389	GQuark *eventtype_names;
	390	LttvNameTables *name_tables;
	391	LttTime *max_time_state_recomputed_in_seek;
	392	GHashTable *kprobe_hash;
	393
	394	/* Array of per cpu running process */
	395	LttvProcessState **running_process;
	396	gboolean has_precomputed_states;
	397	LttvCPUState cpu_states; / state of each cpu */
	398	/* FIXME should be a g_array to deal with resize and copy. */
	399	LttvIRQState irq_states; / state of each irq handler */
	400	/* FIXME should be a g_array to deal with resize and copy. */
	401	LttvSoftIRQState soft_irq_states; / state of each softirq */
	402	/* FIXME should be a g_array to deal with resize and copy. */
	403	LttvTrapState trap_states; / state of each trap */
	404	GHashTable bdev_states; / state of the block devices */
dc877563	405	};
	406
	407	struct _LttvTraceStateClass {
90e19f82	408	LttvTraceContextClass parent;
308711e5	409
90e19f82 AM	410	void (state_save) (LttvTraceState self, LttvAttribute *container);
	411	void (state_restore) (LttvTraceState self, LttvAttribute *container);
	412	void (state_saved_free) (LttvTraceState self, LttvAttribute *container);
dc877563	413	};
	414
	415	GType lttv_trace_state_get_type (void);
	416
308711e5	417	void lttv_state_save(LttvTraceState self, LttvAttribute container);
	418
	419	void lttv_state_restore(LttvTraceState self, LttvAttribute container);
	420
f95bc830	421	void lttv_state_state_saved_free(LttvTraceState *self,
90e19f82	422	LttvAttribute *container);
308711e5	423
b49e54b4	424	int lttv_state_pop_state_cleanup(LttvProcessState *process,
90e19f82	425	LttvTracefileState *tfs);
dc877563	426
	427	#define LTTV_TRACEFILE_STATE_TYPE (lttv_tracefile_state_get_type ())
	428	#define LTTV_TRACEFILE_STATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), LTTV_TRACEFILE_STATE_TYPE, LttvTracefileState))
	429	#define LTTV_TRACEFILE_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST ((vtable), LTTV_TRACEFILE_STATE_TYPE, LttvTracefileStateClass))
	430	#define LTTV_IS_TRACEFILE_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LTTV_TRACEFILE_STATE_TYPE))
	431	#define LTTV_IS_TRACEFILE_STATE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), LTTV_TRACEFILE_STATE_TYPE))
	432	#define LTTV_TRACEFILE_STATE_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst), LTTV_TRACEFILE_STATE_TYPE, LttvTracefileStateClass))
	433
dc877563	434	struct _LttvTracefileState {
90e19f82	435	LttvTracefileContext parent;
dc877563	436
90e19f82 AM	437	GQuark tracefile_name;
	438	guint cpu; /* Current cpu of the tracefile / / perhaps merge in cpu_state */
	439	LttvCPUState cpu_state; / cpu resource state */
dc877563	440	};
	441
	442	struct _LttvTracefileStateClass {
90e19f82	443	LttvTracefileContextClass parent;
dc877563	444	};
	445
	446	GType lttv_tracefile_state_get_type (void);
	447
33bdc8dd	448	static inline guint lttv_state_get_target_pid(LttvTracefileState *tfs)
33bdc8dd	449	{
90e19f82 AM	450	LttvTraceState ts = (LttvTraceState)tfs->parent.t_context;
	451	guint cpu = tfs->cpu;
	452	LttvProcessState *process = ts->running_process[cpu];
33bdc8dd	453
90e19f82 AM	454	if(tfs->parent.target_pid >= 0) return tfs->parent.target_pid;
90e19f82 AM	455	else return process->pid;
33bdc8dd	456	}
33bdc8dd	457
dc877563	458
6d0cdf22	459	#define HDR_PROCESS 0
	460	#define HDR_ES 1
	461	#define HDR_USER_STACK 2
	462	#define HDR_USERTRACE 3
	463	#define HDR_PROCESS_STATE 4
	464	#define HDR_CPU 5
	465	#define HDR_TRACEFILE 6
	466	#define HDR_TRACESET 7
	467	#define HDR_TRACE 8
	468	#define HDR_QUARKS 9
	469	#define HDR_QUARK 10
	470
67f72973	471	/* Device number manipulation macros from kernel source */
	472	#define MINORBITS 20
	473	#define MINORMASK ((1U << MINORBITS) - 1)
	474	#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
	475	#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
59dc1f2a	476	#define MKDEV(ma, mi) ((((unsigned int) (ma)) << MINORBITS) \| (unsigned int) (mi))
6d0cdf22	477
b445142a	478	#endif // STATE_H