X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Finclude%2Flttv%2Fstate.h;h=b8f4be00db3276e7518eaf8310696242337b933b;hb=49bf71b500f112cc90b790eb3975cceac351d021;hp=bf9fa1ae4b2d532f97240b5d1766508350274fd7;hpb=3e5610273f292ff00d78f85020483d6a1abbfc02;p=lttv.git

diff --git a/ltt/branches/poly/include/lttv/state.h b/ltt/branches/poly/include/lttv/state.h
index bf9fa1ae..b8f4be00 100644
--- a/ltt/branches/poly/include/lttv/state.h
+++ b/ltt/branches/poly/include/lttv/state.h
@@ -12,23 +12,22 @@
    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;
@@ -39,31 +38,54 @@ typedef struct _LttvTraceStateClass LttvTraceStateClass;
 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);
+
+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 interrupt type is one of "user mode", "kernel thread", "system call",
+   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, 
@@ -80,26 +102,30 @@ extern LttvProcessStatus
   LTTV_STATE_RUN;
 
 
-typedef struct _LttvInterruptState {
-  LttvInterruptType t;
-  LttvInterruptNumber n;
+typedef struct _LttvExecutionState {
+  LttvExecutionMode t;
+  LttvExecutionSubmode n;
   LttTime entry;
-  LttTime last_change;
+  LttTime change;
   LttvProcessStatus s;
-} LttvInterruptState;
+} LttvExecutionState;
 
 
 typedef struct _LttvProcessState {
   guint pid;
   guint ppid;
-  LttTime birth;
+  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. */
 
@@ -132,15 +158,31 @@ struct _LttvTraceState {
   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))
@@ -153,6 +195,8 @@ struct _LttvTracefileState {
   LttvTracefileContext parent;
 
   LttvProcessState *process;
+  GQuark cpu_name;
+  guint saved_position;
 };
 
 struct _LttvTracefileStateClass {
@@ -162,4 +206,4 @@ struct _LttvTracefileStateClass {
 GType lttv_tracefile_state_get_type (void);
 
 
-#endif // PROCESSTRACE_H
+#endif // STATE_H