X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=43b4d7ea9fdfc94fda1256913815d7dfee14e771;hb=052a984f0716f0cba2c59620a2575685b6b81099;hp=05a6aa53683536d5669dbbb6072b190271f80258;hpb=f0b795e0b579719a95fee5f84d4dcb893044d926;p=lttv.git

diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c
index 05a6aa53..43b4d7ea 100644
--- a/ltt/branches/poly/lttv/lttv/state.c
+++ b/ltt/branches/poly/lttv/lttv/state.c
@@ -39,7 +39,8 @@ GQuark
     LTT_FACILITY_KERNEL_ARCH,
     LTT_FACILITY_PROCESS,
     LTT_FACILITY_FS,
-    LTT_FACILITY_STATEDUMP;
+    LTT_FACILITY_STATEDUMP,
+		LTT_FACILITY_USER_GENERIC;
 
 /* Events Quarks */
 
@@ -54,10 +55,13 @@ GQuark
     LTT_EVENT_SOFT_IRQ_EXIT,
     LTT_EVENT_SCHEDCHANGE,
     LTT_EVENT_FORK,
+    LTT_EVENT_KERNEL_THREAD,
     LTT_EVENT_EXIT,
     LTT_EVENT_FREE,
     LTT_EVENT_EXEC,
-    LTT_EVENT_ENUM_PROCESS_STATE;
+    LTT_EVENT_ENUM_PROCESS_STATE,
+		LTT_EVENT_FUNCTION_ENTRY,
+		LTT_EVENT_FUNCTION_EXIT;
 
 /* Fields Quarks */
 
@@ -76,7 +80,9 @@ GQuark
     LTT_FIELD_NAME,
     LTT_FIELD_MODE,
     LTT_FIELD_SUBMODE,
-    LTT_FIELD_STATUS;
+    LTT_FIELD_STATUS,
+		LTT_FIELD_THIS_FN,
+		LTT_FIELD_CALL_SITE;
 
 LttvExecutionMode
   LTTV_STATE_MODE_UNKNOWN,
@@ -173,6 +179,18 @@ gboolean process_equal(gconstpointer a, gconstpointer b)
   return ret;
 }
 
+static void delete_usertrace(gpointer key, gpointer value, gpointer user_data)
+{
+	g_tree_destroy((GTree*)value);
+}
+
+static void lttv_state_free_usertraces(GHashTable *usertraces)
+{
+	g_hash_table_foreach(usertraces, delete_usertrace, NULL);
+	g_hash_table_destroy(usertraces);
+}
+
+
 
 static void
 restore_init_state(LttvTraceState *self)
@@ -183,7 +201,9 @@ restore_init_state(LttvTraceState *self)
   
   /* Free the process tables */
   if(self->processes != NULL) lttv_state_free_process_table(self->processes);
+	if(self->usertraces != NULL) lttv_state_free_usertraces(self->usertraces);
   self->processes = g_hash_table_new(process_hash, process_equal);
+	self->usertraces = g_hash_table_new(g_direct_hash, g_direct_equal);
   self->nb_event = 0;
 
   /* Seek time to beginning */
@@ -225,6 +245,20 @@ restore_init_state(LttvTraceState *self)
 
 //static LttTime time_zero = {0,0};
 
+static gint compare_usertraces(gconstpointer a, gconstpointer b, 
+		gpointer user_data)
+{
+	const LttTime *t1 = (const LttTime *)a;
+	const LttTime *t2 = (const LttTime *)b;
+
+	return ltt_time_compare(*t1, *t2);
+}
+
+static void free_usertrace_key(gpointer data)
+{
+	g_free(data);
+}
+
 static void
 init(LttvTracesetState *self, LttvTraceset *ts)
 {
@@ -258,22 +292,53 @@ init(LttvTracesetState *self, LttvTraceset *ts)
     get_max_time(tcs);
 
     nb_tracefile = tc->tracefiles->len;
-#if 0
+    tcs->processes = NULL;
+    tcs->usertraces = NULL;
+    tcs->running_process = g_new(LttvProcessState*, 
+                                 ltt_trace_get_num_cpu(tc->t));
+    restore_init_state(tcs);
     for(j = 0 ; j < nb_tracefile ; j++) {
       tfcs = 
           LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles,
                                           LttvTracefileContext*, j));
       tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf);
+			tfcs->cpu = ltt_tracefile_cpu(tfcs->parent.tf);
+#if 0		
+			if(ltt_tracefile_tid(tfcs->parent.tf) != 0) {
+				/* It's a Usertrace */
+				LttvProcessState *process;
+				LttTime timestamp = 
+					ltt_interpolate_time_from_tsc(tfcs->parent.tf,
+							ltt_tracefile_creation(tfcs->parent.tf));
+				process = lttv_state_find_process_or_create(
+												tcs,
+												0, ltt_tracefile_tid(tfcs->parent.tf),
+												&timestamp);
+				process->usertrace = tfcs;
+			}
     }
 #endif //0
-    tcs->processes = NULL;
-    tcs->running_process = g_new(LttvProcessState*, 
-                                 ltt_trace_get_num_cpu(tc->t));
-    restore_init_state(tcs);
+			if(ltt_tracefile_tid(tfcs->parent.tf) != 0) {
+				/* It's a Usertrace */
+				guint tid = ltt_tracefile_tid(tfcs->parent.tf);
+				GTree *usertrace_tree = (GTree*)g_hash_table_lookup(tcs->usertraces,
+						(gconstpointer)tid);
+				if(!usertrace_tree) {
+					usertrace_tree = g_tree_new_full(compare_usertraces,
+							NULL, free_usertrace_key, NULL);
+					g_hash_table_insert(tcs->usertraces,
+							(gpointer)tid, usertrace_tree);
+				}
+				LttTime *timestamp = g_new(LttTime, 1);
+				*timestamp = ltt_interpolate_time_from_tsc(tfcs->parent.tf,
+							ltt_tracefile_creation(tfcs->parent.tf));
+				g_tree_insert(usertrace_tree, timestamp, tfcs);
+			}
+    }
+
   }
 }
 
-
 static void
 fini(LttvTracesetState *self)
 {
@@ -302,7 +367,9 @@ fini(LttvTracesetState *self)
     g_free(tcs->running_process);
     tcs->running_process = NULL;
     lttv_state_free_process_table(tcs->processes);
+		lttv_state_free_usertraces(tcs->usertraces);
     tcs->processes = NULL;
+    tcs->usertraces = NULL;
   }
   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
       fini((LttvTracesetContext *)self);
@@ -434,6 +501,16 @@ static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
   }
   new_process->state = &g_array_index(new_process->execution_stack, 
       LttvExecutionState, new_process->execution_stack->len - 1);
+  new_process->user_stack = g_array_sized_new(FALSE, FALSE, 
+      sizeof(guint64), 0);
+  new_process->user_stack = 
+              g_array_set_size(new_process->user_stack,
+                  process->user_stack->len);
+  for(i = 0 ; i < process->user_stack->len; i++) {
+    g_array_index(new_process->user_stack, guint64, i) =
+        g_array_index(process->user_stack, guint64, i);
+  }
+  new_process->current_function = process->current_function;
   g_hash_table_insert(new_processes, new_process, new_process);
 }
 
@@ -546,6 +623,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container)
 
   LttvAttributeName name;
 
+	gboolean is_named;
+
   LttEventPosition *ep;
 
   LttvTracesetContext *tsc = self->parent.ts_context;
@@ -581,7 +660,7 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container)
     tfcs = 
           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
                                           LttvTracefileContext*, i));
-    type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
+    type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named);
     g_assert(type == LTTV_GOBJECT);
     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
 #if 0
@@ -630,6 +709,8 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
 
   LttvAttributeName name;
 
+	gboolean is_named;
+
   LttEventPosition *ep;
 
   tracefiles_tree = lttv_attribute_find_subdir(container, 
@@ -658,7 +739,7 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
     tfcs = 
           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
                                           LttvTracefileContext*, i));
-    type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
+    type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named);
     g_assert(type == LTTV_GOBJECT);
     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
 
@@ -681,6 +762,8 @@ static void free_saved_state(LttvTraceState *self)
 
   LttvAttributeName name;
 
+	gboolean is_named;
+
   LttvAttribute *saved_states;
 
   saved_states = lttv_attribute_find_subdir(self->parent.t_a,
@@ -688,7 +771,7 @@ static void free_saved_state(LttvTraceState *self)
 
   nb = lttv_attribute_get_number(saved_states);
   for(i = 0 ; i < nb ; i++) {
-    type = lttv_attribute_get(saved_states, i, &name, &value);
+    type = lttv_attribute_get(saved_states, i, &name, &value, &is_named);
     g_assert(type == LTTV_GOBJECT);
     state_saved_free(self, *((LttvAttribute **)value.v_gobject));
   }
@@ -737,6 +820,7 @@ free_max_time(LttvTraceState *tcs)
 typedef struct _LttvNameTables {
  // FIXME  GQuark *eventtype_names;
   GQuark *syscall_names;
+	guint nb_syscalls;
   GQuark *trap_names;
   GQuark *irq_names;
   GQuark *soft_irq_names;
@@ -794,6 +878,7 @@ create_name_tables(LttvTraceState *tcs)
   lttv_trace_hook_destroy(&h);
 
   name_tables->syscall_names = g_new(GQuark, nb);
+  name_tables->nb_syscalls = nb;
 
   for(i = 0 ; i < nb ; i++) {
     name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
@@ -889,6 +974,7 @@ get_name_tables(LttvTraceState *tcs)
   name_tables = (LttvNameTables *)*(v.v_pointer);
   //tcs->eventtype_names = name_tables->eventtype_names;
   tcs->syscall_names = name_tables->syscall_names;
+  tcs->nb_syscalls = name_tables->nb_syscalls;
   tcs->trap_names = name_tables->trap_names;
   tcs->irq_names = name_tables->irq_names;
   tcs->soft_irq_names = name_tables->soft_irq_names;
@@ -939,8 +1025,8 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
 {
   LttvExecutionState *es;
   
-  guint cpu = ltt_tracefile_num(tfs->parent.tf);
   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
+  guint cpu = tfs->cpu;
 
 #ifdef HASH_TABLE_DEBUG
   hash_table_check(ts->processes);
@@ -966,7 +1052,7 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
 
 static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
 {
-  guint cpu = ltt_tracefile_num(tfs->parent.tf);
+  guint cpu = tfs->cpu;
   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
 
@@ -999,6 +1085,57 @@ static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
   process->state->change = tfs->parent.timestamp;
 }
 
+struct search_result {
+	const LttTime *time;	/* Requested time */
+	LttTime *best;	/* Best result */
+};
+
+static gint search_usertrace(gconstpointer a, gconstpointer b)
+{
+	const LttTime *elem_time = (const LttTime*)a;
+	/* Explicit non const cast */
+	struct search_result *res = (struct search_result *)b;
+
+	if(ltt_time_compare(*elem_time, *(res->time)) < 0) {
+		/* The usertrace was created before the schedchange */
+		/* Get larger keys */
+		return 1;
+	} else if(ltt_time_compare(*elem_time, *(res->time)) >= 0) {
+		/* The usertrace was created after the schedchange time */
+		/* Get smaller keys */
+		if(res->best) {
+			if(ltt_time_compare(*elem_time, *res->best) < 0) {
+				res->best = elem_time;
+			}
+		} else {
+			res->best = elem_time;
+		}
+		return -1;
+	}
+	return 0;
+}
+
+static LttvTracefileState *ltt_state_usertrace_find(LttvTraceState *tcs,
+		guint pid, const LttTime *timestamp)
+{
+	LttvTracefileState *tfs = NULL;
+	struct search_result res;
+	/* Find the usertrace associated with a pid and time interval.
+	 * Search in the usertraces by PID (within a hash) and then, for each
+	 * corresponding element of the array, find the first one with creation
+	 * timestamp the lowest, but higher or equal to "timestamp". */
+	res.time = timestamp;
+	res.best = NULL;
+	GTree *usertrace_tree = g_hash_table_lookup(tcs->usertraces, (gpointer)pid);
+	if(usertrace_tree) {
+		g_tree_search(usertrace_tree, search_usertrace, &res);
+		if(res.best)
+			tfs = g_tree_lookup(usertrace_tree, res.best);
+	}
+
+	return tfs;
+}
+
 
 LttvProcessState *
 lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, 
@@ -1017,6 +1154,10 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
   process->name = name;
   //process->last_cpu = tfs->cpu_name;
   //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
+	process->kernel_thread = 0;
+	process->usertrace = ltt_state_usertrace_find(tcs, pid, timestamp);
+	process->current_function = 0; //function 0x0 by default.
+
   g_info("Process %u, core %p", process->pid, process);
   g_hash_table_insert(tcs->processes, process, process);
 
@@ -1061,7 +1202,11 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
   //g_assert(timestamp->tv_sec != 0);
   es->change = *timestamp;
   es->s = LTTV_STATE_WAIT_FORK;
-
+	
+	/* Allocate an empty function call stack. If it's empty, use 0x0. */
+	process->user_stack = g_array_sized_new(FALSE, FALSE,
+			sizeof(guint64), 0);
+	
   return process;
 }
 
@@ -1082,10 +1227,17 @@ lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid,
     LttTime *timestamp)
 {
   LttvProcessState *process = lttv_state_find_process(ts, cpu, pid);
+  LttvExecutionState *es;
   
   /* Put ltt_time_zero creation time for unexisting processes */
-  if(unlikely(process == NULL)) process = lttv_state_create_process(ts,
+  if(unlikely(process == NULL)) {
+		process = lttv_state_create_process(ts,
                 NULL, cpu, pid, LTTV_STATE_UNNAMED, timestamp);
+		/* We are not sure is it's a kernel thread or normal thread, put the
+	 	 * bottom stack state to unknown */
+		es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
+		es->t = LTTV_STATE_MODE_UNKNOWN;
+	}
   return process;
 }
 
@@ -1105,6 +1257,7 @@ static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
   key.cpu = process->cpu;
   g_hash_table_remove(ts->processes, &key);
   g_array_free(process->execution_stack, TRUE);
+  g_array_free(process->user_stack, TRUE);
   g_free(process);
 }
 
@@ -1112,6 +1265,7 @@ static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
 static void free_process_state(gpointer key, gpointer value,gpointer user_data)
 {
   g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
+  g_array_free(((LttvProcessState *)value)->user_stack, TRUE);
   g_free(value);
 }
 
@@ -1132,8 +1286,19 @@ static gboolean syscall_entry(void *hook_data, void *call_data)
 
   LttvExecutionSubmode submode;
 
-  submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
-      ltt_event_get_unsigned(e, f)];
+	guint nb_syscalls = ((LttvTraceState *)(s->parent.t_context))->nb_syscalls;
+	guint syscall = ltt_event_get_unsigned(e, f);
+	
+	if(syscall < nb_syscalls) {
+	  submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
+  	    syscall];
+	} else {
+		/* Fixup an incomplete syscall table */
+		GString *string = g_string_new("");
+    g_string_printf(string, "syscall %u", syscall);
+		submode = g_quark_from_string(string->str);
+		g_string_free(string, TRUE);
+	}
   push_state(s, LTTV_STATE_SYSCALL, submode);
   return FALSE;
 }
@@ -1195,6 +1360,15 @@ static gboolean irq_entry(void *hook_data, void *call_data)
   return FALSE;
 }
 
+static gboolean soft_irq_exit(void *hook_data, void *call_data)
+{
+  LttvTracefileState *s = (LttvTracefileState *)call_data;
+
+  pop_state(s, LTTV_STATE_SOFT_IRQ);
+  return FALSE;
+}
+
+
 
 static gboolean irq_exit(void *hook_data, void *call_data)
 {
@@ -1226,22 +1400,96 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data)
   return FALSE;
 }
 
+static void push_function(LttvTracefileState *tfs, guint64 funcptr)
+{
+  guint64 *new_func;
+  
+  LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
+  guint cpu = tfs->cpu;
+  LttvProcessState *process = ts->running_process[cpu];
 
-static gboolean soft_irq_exit(void *hook_data, void *call_data)
+  guint depth = process->user_stack->len;
+
+  process->user_stack = 
+    g_array_set_size(process->user_stack, depth + 1);
+    
+  new_func = &g_array_index(process->user_stack, guint64, depth);
+	*new_func = funcptr;
+  process->current_function = funcptr;
+}
+
+static void pop_function(LttvTracefileState *tfs, guint64 funcptr)
+{
+  guint cpu = tfs->cpu;
+  LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
+  LttvProcessState *process = ts->running_process[cpu];
+
+  if(process->current_function != funcptr){
+    g_info("Different functions (%lu.%09lu): ignore it\n",
+        tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
+    g_info("process state has %llu when pop_function is %llu\n",
+		    process->current_function, funcptr);
+    g_info("{ %u, %u, %s, %s }\n",
+		    process->pid,
+		    process->ppid,
+		    g_quark_to_string(process->name),
+		    g_quark_to_string(process->state->s));
+    return;
+  }
+  guint depth = process->user_stack->len;
+
+  if(depth == 0){
+    g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
+        tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
+    return;
+  }
+
+  process->user_stack = 
+    g_array_set_size(process->user_stack, depth - 1);
+  process->current_function =
+		g_array_index(process->user_stack, guint64, depth - 2);
+}
+
+
+static gboolean function_entry(void *hook_data, void *call_data)
 {
   LttvTracefileState *s = (LttvTracefileState *)call_data;
+  LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+  guint8 fac_id = ltt_event_facility_id(e);
+  guint8 ev_id = ltt_event_eventtype_id(e);
+  LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+  g_assert(thf->f1 != NULL);
+  LttField *f = thf->f1;
+	guint64 funcptr = ltt_event_get_long_unsigned(e, f);
 
-  pop_state(s, LTTV_STATE_SOFT_IRQ);
+  push_function(s, funcptr);
   return FALSE;
 }
 
+static gboolean function_exit(void *hook_data, void *call_data)
+{
+  LttvTracefileState *s = (LttvTracefileState *)call_data;
+  LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+  guint8 fac_id = ltt_event_facility_id(e);
+  guint8 ev_id = ltt_event_eventtype_id(e);
+  LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+  g_assert(thf->f1 != NULL);
+  LttField *f = thf->f1;
+	guint64 funcptr = ltt_event_get_long_unsigned(e, f);
+
+  LttvExecutionSubmode submode;
+
+  pop_function(s, funcptr);
+  return FALSE;
+}
 
 static gboolean schedchange(void *hook_data, void *call_data)
 {
   LttvTracefileState *s = (LttvTracefileState *)call_data;
-  guint cpu = ltt_tracefile_num(s->parent.tf);
+  guint cpu = s->cpu;
   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
+  LttvProcessState *old_process = ts->running_process[cpu];
   
   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
@@ -1261,7 +1509,8 @@ static gboolean schedchange(void *hook_data, void *call_data)
        the wrongly attributed statistics. */
 
     //This test only makes sense once the state is known and if there is no
-    //missing events.
+    //missing events. We need to silently ignore schedchange coming after a
+		//process_free, or it causes glitches. (FIXME)
     //if(unlikely(process->pid != pid_out)) {
     //  g_assert(process->pid == 0);
     //}
@@ -1274,8 +1523,8 @@ static gboolean schedchange(void *hook_data, void *call_data)
       else process->state->s = LTTV_STATE_WAIT;
       process->state->change = s->parent.timestamp;
     }
-
-    if(state_out == 32)
+		
+		if(state_out == 32)
        exit_process(s, process); /* EXIT_DEAD */
           /* see sched.h for states */
   }
@@ -1286,6 +1535,8 @@ static gboolean schedchange(void *hook_data, void *call_data)
                   &s->parent.timestamp);
   process->state->s = LTTV_STATE_RUN;
   process->cpu = cpu;
+	if(process->usertrace)
+		process->usertrace->cpu = cpu;
  // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
   process->state->change = s->parent.timestamp;
   return FALSE;
@@ -1299,7 +1550,7 @@ static gboolean process_fork(void *hook_data, void *call_data)
   guint parent_pid;
   guint child_pid;
   LttvProcessState *zombie_process;
-  guint cpu = ltt_tracefile_num(s->parent.tf);
+  guint cpu = s->cpu;
   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
   LttvProcessState *child_process;
@@ -1355,6 +1606,28 @@ static gboolean process_fork(void *hook_data, void *call_data)
   return FALSE;
 }
 
+/* We stamp a newly created process as kernel_thread */
+static gboolean process_kernel_thread(void *hook_data, void *call_data)
+{
+  LttvTracefileState *s = (LttvTracefileState *)call_data;
+  LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+  LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+  guint pid;
+  guint cpu = s->cpu;
+  LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+  LttvProcessState *process;
+  LttvExecutionState *es;
+
+  /* PID */
+  pid = ltt_event_get_unsigned(e, thf->f1);
+
+  process = lttv_state_find_process(ts, ANY_CPU, pid);
+	es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
+	es->t = LTTV_STATE_SYSCALL;
+	process->kernel_thread = 1;
+
+	return FALSE;
+}
 
 static gboolean process_exit(void *hook_data, void *call_data)
 {
@@ -1363,7 +1636,7 @@ static gboolean process_exit(void *hook_data, void *call_data)
   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
   LttField *f;
   guint pid;
-  guint cpu = ltt_tracefile_num(s->parent.tf);
+  guint cpu = s->cpu;
   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
 
@@ -1416,8 +1689,9 @@ static gboolean process_free(void *hook_data, void *call_data)
         break;
       }
     }
-    if(i == num_cpus) /* process is not scheduled */
-      exit_process(s, process);
+    //if(i == num_cpus) /* process is not scheduled */
+      //exit_process(s, process);	// do nothing : wait for the schedchange to
+			//delete the process.
   }
 
   return FALSE;
@@ -1431,7 +1705,7 @@ static gboolean process_exec(void *hook_data, void *call_data)
   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
   //gchar *name;
-  guint cpu = ltt_tracefile_num(s->parent.tf);
+  guint cpu = s->cpu;
   LttvProcessState *process = ts->running_process[cpu];
 
   /* PID of the process to release */
@@ -1460,7 +1734,7 @@ static gboolean enum_process_state(void *hook_data, void *call_data)
   guint parent_pid;
   guint pid;
   gchar * command;
-  guint cpu = ltt_tracefile_num(s->parent.tf);
+  guint cpu = s->cpu;
   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
   LttvProcessState *parent_process;
@@ -1567,6 +1841,7 @@ void lttv_state_add_event_hooks(LttvTracesetState *self)
   LttvAttributeValue val;
 
   gint ret;
+	gint hn;
 
   nb_trace = lttv_traceset_number(traceset);
   for(i = 0 ; i < nb_trace ; i++) {
@@ -1575,95 +1850,116 @@ void lttv_state_add_event_hooks(LttvTracesetState *self)
     /* Find the eventtype id for the following events and register the
        associated by id hooks. */
 
-    hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 14);
-    hooks = g_array_set_size(hooks, 14);
+    hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 17);
+    hooks = g_array_set_size(hooks, 17); // Max possible number of hooks.
+		hn = 0;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
         LTT_FIELD_SYSCALL_ID, 0, 0,
-        syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, 0));
-    g_assert(!ret);
+        syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT,
         0, 0, 0,
-        syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1));
-    g_assert(!ret);
+        syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
         LTT_FIELD_TRAP_ID, 0, 0,
-        trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, 2));
-    g_assert(!ret);
+        trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
         0, 0, 0, 
-        trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, 3));
-    g_assert(!ret);
+        trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
         LTT_FIELD_IRQ_ID, 0, 0,
-        irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 4));
-    g_assert(!ret);
+        irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
         0, 0, 0, 
-        irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 5));
-    g_assert(!ret);
+        irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY,
         LTT_FIELD_SOFT_IRQ_ID, 0, 0,
-        soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 6));
-    g_assert(!ret);
+        soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT,
         0, 0, 0, 
-        soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 7));
-    g_assert(!ret);
+        soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
         LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
-        schedchange, NULL, &g_array_index(hooks, LttvTraceHook, 8));
-    g_assert(!ret);
+        schedchange, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
         LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0,
-        process_fork, NULL, &g_array_index(hooks, LttvTraceHook, 9));
-    g_assert(!ret);
+        process_fork, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
+
+    ret = lttv_trace_find_hook(ts->parent.t,
+        LTT_FACILITY_PROCESS, LTT_EVENT_KERNEL_THREAD,
+        LTT_FIELD_PID, 0, 0,
+        process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook,
+					hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
         LTT_FIELD_PID, 0, 0,
-        process_exit, NULL, &g_array_index(hooks, LttvTraceHook, 10));
-    g_assert(!ret);
+        process_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
     
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
         LTT_FIELD_PID, 0, 0,
-        process_free, NULL, &g_array_index(hooks, LttvTraceHook, 11));
-    g_assert(!ret);
+        process_free, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_FS, LTT_EVENT_EXEC,
         LTT_FIELD_FILENAME, 0, 0,
-        process_exec, NULL, &g_array_index(hooks, LttvTraceHook, 12));
-    g_assert(!ret);
+        process_exec, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
      /* statedump-related hooks */
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_STATEDUMP, LTT_EVENT_ENUM_PROCESS_STATE,
         LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME,
-        enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, 13));
-    g_assert(!ret);
+        enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
 
-    
+    ret = lttv_trace_find_hook(ts->parent.t,
+        LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY,
+        LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
+        function_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
+
+    ret = lttv_trace_find_hook(ts->parent.t,
+        LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT,
+        LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
+        function_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+		if(ret) hn--;
+
+    hooks = g_array_set_size(hooks, hn);
+  
     /* Add these hooks to each event_by_id hooks list */
 
     nb_tracefile = ts->parent.tracefiles->len;
@@ -1802,6 +2098,13 @@ static gboolean state_save_after_trace_hook(void *hook_data, void *call_data)
   return FALSE;
 }
 
+guint lttv_state_current_cpu(LttvTracefileState *tfs)
+{
+	return tfs->cpu;
+}
+
+
+
 #if 0
 static gboolean block_start(void *hook_data, void *call_data)
 {
@@ -2073,6 +2376,8 @@ void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
 
   LttvAttributeName name;
 
+	gboolean is_named;
+
   LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
 
   //g_tree_destroy(self->parent.pqueue);
@@ -2093,7 +2398,8 @@ void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
         max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
         mid_pos = max_pos / 2;
         while(min_pos < max_pos) {
-          type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value);
+          type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value,
+							&is_named);
           g_assert(type == LTTV_GOBJECT);
           saved_state_tree = *((LttvAttribute **)(value.v_gobject));
           type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME, 
@@ -2320,6 +2626,7 @@ static void module_init()
   LTT_FACILITY_PROCESS    = g_quark_from_string("process");
   LTT_FACILITY_FS    = g_quark_from_string("fs");
   LTT_FACILITY_STATEDUMP    = g_quark_from_string("statedump");
+  LTT_FACILITY_USER_GENERIC    = g_quark_from_string("user_generic");
 
   
   LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
@@ -2332,10 +2639,13 @@ static void module_init()
   LTT_EVENT_SOFT_IRQ_EXIT      = g_quark_from_string("soft_irq_exit");
   LTT_EVENT_SCHEDCHANGE   = g_quark_from_string("schedchange");
   LTT_EVENT_FORK          = g_quark_from_string("fork");
+  LTT_EVENT_KERNEL_THREAD = g_quark_from_string("kernel_thread");
   LTT_EVENT_EXIT          = g_quark_from_string("exit");
   LTT_EVENT_FREE          = g_quark_from_string("free");
   LTT_EVENT_EXEC          = g_quark_from_string("exec");
   LTT_EVENT_ENUM_PROCESS_STATE  = g_quark_from_string("enumerate_process_state");
+  LTT_EVENT_FUNCTION_ENTRY  = g_quark_from_string("function_entry");
+  LTT_EVENT_FUNCTION_EXIT  = g_quark_from_string("function_exit");
 
 
   LTT_FIELD_SYSCALL_ID    = g_quark_from_string("syscall_id");
@@ -2353,6 +2663,8 @@ static void module_init()
   LTT_FIELD_MODE          = g_quark_from_string("mode");
   LTT_FIELD_SUBMODE       = g_quark_from_string("submode");
   LTT_FIELD_STATUS        = g_quark_from_string("status");
+  LTT_FIELD_THIS_FN       = g_quark_from_string("this_fn");
+  LTT_FIELD_CALL_SITE     = g_quark_from_string("call_site");
   
 }