+/* 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
and LttvTracefileContext objects, used by processTrace, 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. */
+ 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 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
- interrupt stack is maintained. The stack bottom is normal user mode and
- the top of stack is the current interrupt state.
+ The trace state currently consists in a process table.
- The interrupt state tells about the process status, interrupt type and
- interrupt number. All these could be defined as enumerations but may
- need extensions (e.g. new process state). GQuark are thus used being
- as easy to manipulate as integers but having a string associated, just
- like enumerations. */
+ 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). */
typedef struct _LttvTracesetState LttvTracesetState;
typedef struct _LttvTracesetStateClass LttvTracesetStateClass;
typedef struct _LttvTracefileState LttvTracefileState;
typedef struct _LttvTracefileStateClass LttvTracefileStateClass;
-gboolean lttv_state_add_event_hooks(LttvTracesetState *self);
+void lttv_state_add_event_hooks(LttvTracesetState *self);
-gboolean lttv_state_remove_event_hooks(LttvTracesetState *self);
+void lttv_state_remove_event_hooks(LttvTracesetState *self);
+void lttv_state_save_add_event_hooks(LttvTracesetState *self);
-/* The interrupt type is one of "user mode", "kernel thread", "system call",
+void lttv_state_save_remove_event_hooks(LttvTracesetState *self);
+
+void lttv_state_restore_closest_state(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 LttvInterruptType;
+typedef GQuark LttvExecutionMode;
-extern LttvInterruptType
+extern LttvExecutionMode
LTTV_STATE_USER_MODE,
LTTV_STATE_SYSCALL,
LTTV_STATE_TRAP,
- LTTV_STATE_IRQ;
+ LTTV_STATE_IRQ,
+ LTTV_STATE_MODE_UNKNOWN;
-/* The interrupt number depends on the interrupt type. For user mode or kernel
- thread, which are the normal mode (interrupt 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
+/* 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 LttvInterruptNumber;
+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,
LTTV_STATE_RUN;
-typedef struct _LttvInterruptState {
- LttvInterruptType t;
- LttvInterruptNumber n;
- LttvTime entry;
- LttvTime last_change;
+typedef struct _LttvExecutionState {
+ LttvExecutionMode t;
+ LttvExecutionSubmode n;
+ LttTime entry;
+ LttTime change;
LttvProcessStatus s;
-} LttvInterruptState;
+} LttvExecutionState;
typedef struct _LttvProcessState {
guint pid;
- LttvTime birth;
+ guint ppid;
+ LttTime creation_time;
GQuark name;
- GArray *interrupt_stack; /* Array of LttvInterruptState */
- LttvInterruptState *state; /* Top of interrupt stack */
- /* opened file descriptors, address map... */
+ GQuark pid_time;
+ GArray *execution_stack; /* Array of LttvExecutionState */
+ LttvExecutionState *state; /* Top of interrupt stack */
+ /* opened file descriptors, address map?... */
} LttvProcessState;
+LttvProcessState *lttv_state_find_process(LttvTracefileState *tfs, guint pid);
+
+
/* The LttvTracesetState, LttvTraceState and LttvTracefileState types
inherit from the corresponding Context objects defined in processTrace. */
LttvTraceContext parent;
GHashTable *processes; /* LttvProcessState objects indexed by pid */
+ guint nb_event, save_interval;
/* Block/char devices, locks, memory pages... */
+ GQuark *eventtype_names;
+ GQuark *syscall_names;
+ GQuark *trap_names;
+ GQuark *irq_names;
};
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_saved_state_free(LttvTraceState *self,
+ LttvAttribute *container);
+
#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))
LttvTracefileContext parent;
LttvProcessState *process;
+ GQuark cpu_name;
+ guint saved_position;
};
struct _LttvTracefileStateClass {
GType lttv_tracefile_state_get_type (void);
-#endif // PROCESSTRACE_H
+#endif // STATE_H
projects / lttv.git / blobdiff