[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


#define PREALLOC_NB_SYSCALLS	256
/*
 * As of 2.6.38, IRQ 239 has been seen (and we have seen higher than
 * 256 too.
 */
#define PREALLOC_NB_IRQS	512
/* As of 2.6.38, 255 softirqs are used. */
#define PREALLOC_NB_SOFT_IRQS	512
#define PREALLOC_NB_TRAPS	256

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