[lttv.git] / ltt / branches / poly / 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 informations 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

/* Facilities Quarks */

extern GQuark
    LTT_FACILITY_KERNEL,
    LTT_FACILITY_KERNEL_ARCH,
    LTT_FACILITY_FS,
    LTT_FACILITY_LIST,
    LTT_FACILITY_USER_GENERIC,
    LTT_FACILITY_BLOCK,
    LTT_FACILITY_STATEDUMP;

/* Events Quarks */

extern GQuark 
    LTT_EVENT_SYSCALL_ENTRY,
    LTT_EVENT_SYSCALL_EXIT,
    LTT_EVENT_TRAP_ENTRY,
    LTT_EVENT_TRAP_EXIT,
    LTT_EVENT_IRQ_ENTRY,
    LTT_EVENT_IRQ_EXIT,
    LTT_EVENT_SOFT_IRQ_ENTRY,
    LTT_EVENT_SOFT_IRQ_EXIT,
    LTT_EVENT_SCHED_SCHEDULE,
    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;

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

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_SYSCALL,
  LTTV_STATE_TRAP,
  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 */
} 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;
  guint last_irq;
  guint last_soft_irq;
  guint last_trap;
} LttvCPUState;

typedef struct _LttvIRQState {
  GArray *mode_stack;
} LttvIRQState;

typedef struct _LttvSoftIRQState {
  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;

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;
  GQuark *syscall_names;
  guint  nb_syscalls;
  GQuark *trap_names;
  guint  nb_traps;
  guint  nb_irqs;
  guint  nb_soft_irqs;
  GQuark *irq_names;
  GQuark *soft_irq_names;
  LttTime *max_time_state_recomputed_in_seek;

  /* Array of per cpu running process */
  LttvProcessState **running_process;
  gboolean has_precomputed_states;
  LttvCPUState *cpu_states; /* state of each cpu */
  LttvIRQState *irq_states; /* state of each irq handler */
  LttvSoftIRQState *soft_irq_states; /* state of each softirq */
  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)	(((ma) << MINORBITS) | (mi))

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