X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=a3a3102a50039a3adbb2e7c58003bbd07c5f2046;hb=b2a893e7066e02c014f6262afeb209cdef8f0ef0;hp=6bd0b271beed2ab98bb05fb0645bc6055accc777;hpb=302efbadc93944574ea9955d8c72a56b0ac9a1dc;p=lttv.git

diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c
index 6bd0b271..a3a3102a 100644
--- a/ltt/branches/poly/lttv/lttv/state.c
+++ b/ltt/branches/poly/lttv/lttv/state.c
@@ -61,7 +61,8 @@ GQuark
     LTT_EVENT_EXEC,
     LTT_EVENT_ENUM_PROCESS_STATE,
 		LTT_EVENT_FUNCTION_ENTRY,
-		LTT_EVENT_FUNCTION_EXIT;
+		LTT_EVENT_FUNCTION_EXIT,
+		LTT_EVENT_THREAD_BRAND;
 
 /* Fields Quarks */
 
@@ -78,6 +79,7 @@ GQuark
     LTT_FIELD_PID,
     LTT_FIELD_FILENAME,
     LTT_FIELD_NAME,
+    LTT_FIELD_TYPE,
     LTT_FIELD_MODE,
     LTT_FIELD_SUBMODE,
     LTT_FIELD_STATUS,
@@ -98,6 +100,7 @@ LttvExecutionSubmode
 
 LttvProcessStatus
   LTTV_STATE_UNNAMED,
+  LTTV_STATE_UNBRANDED,
   LTTV_STATE_WAIT_FORK,
   LTTV_STATE_WAIT_CPU,
   LTTV_STATE_EXIT,
@@ -106,6 +109,10 @@ LttvProcessStatus
   LTTV_STATE_RUN,
   LTTV_STATE_DEAD;
 
+LttvProcessType
+  LTTV_STATE_USER_THREAD,
+	LTTV_STATE_KERNEL_THREAD;
+
 static GQuark
   LTTV_STATE_TRACEFILES,
   LTTV_STATE_PROCESSES,
@@ -198,6 +205,8 @@ restore_init_state(LttvTraceState *self)
   guint i, nb_cpus;
 
   LttvTracefileState *tfcs;
+
+  LttTime start_time, end_time;
   
   /* Free the process tables */
   if(self->processes != NULL) lttv_state_free_process_table(self->processes);
@@ -213,6 +222,7 @@ restore_init_state(LttvTraceState *self)
   //g_tree_destroy(self->parent.ts_context->pqueue);
   //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
   
+  ltt_trace_time_span_get(self->parent.t, &start_time, &end_time);
   
   //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
 
@@ -221,7 +231,7 @@ restore_init_state(LttvTraceState *self)
   /* Put the per cpu running_process to beginning state : process 0. */
   for(i=0; i< nb_cpus; i++) {
     self->running_process[i] = lttv_state_create_process(self, NULL, i, 0,
-        LTTV_STATE_UNNAMED, &ltt_time_zero);
+        LTTV_STATE_UNNAMED, &start_time);
     self->running_process[i]->state->s = LTTV_STATE_RUN;
     self->running_process[i]->cpu = i;
   }
@@ -412,9 +422,11 @@ static void write_process_state(gpointer key, gpointer value,
 
   process = (LttvProcessState *)value;
   fprintf(fp,
-"  <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%u\">\n",
-      process, process->pid, process->ppid, process->creation_time.tv_sec,
+"  <PROCESS CORE=%p PID=%u PPID=%u TYPE=\"%s\"CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\">\n",
+      process, process->pid, process->ppid, g_quark_to_string(process->type),
+			process->creation_time.tv_sec,
       process->creation_time.tv_nsec, g_quark_to_string(process->name),
+      g_quark_to_string(process->brand),
       process->cpu);
 
   for(i = 0 ; i < process->execution_stack->len; i++) {
@@ -510,8 +522,7 @@ static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
     g_array_index(new_process->user_stack, guint64, i) =
         g_array_index(process->user_stack, guint64, i);
   }
-  new_process->current_function = &g_array_index(new_process->user_stack, 
-      guint64, new_process->user_stack->len - 1);
+  new_process->current_function = process->current_function;
   g_hash_table_insert(new_processes, new_process, new_process);
 }
 
@@ -624,6 +635,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container)
 
   LttvAttributeName name;
 
+	gboolean is_named;
+
   LttEventPosition *ep;
 
   LttvTracesetContext *tsc = self->parent.ts_context;
@@ -659,7 +672,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
@@ -708,6 +721,8 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
 
   LttvAttributeName name;
 
+	gboolean is_named;
+
   LttEventPosition *ep;
 
   tracefiles_tree = lttv_attribute_find_subdir(container, 
@@ -736,7 +751,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));
 
@@ -759,6 +774,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,
@@ -766,7 +783,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));
   }
@@ -815,8 +832,9 @@ free_max_time(LttvTraceState *tcs)
 typedef struct _LttvNameTables {
  // FIXME  GQuark *eventtype_names;
   GQuark *syscall_names;
-	guint nb_syscalls;
+  guint nb_syscalls;
   GQuark *trap_names;
+  guint nb_traps;
   GQuark *irq_names;
   GQuark *soft_irq_names;
 } LttvNameTables;
@@ -859,85 +877,92 @@ create_name_tables(LttvTraceState *tcs)
     name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);    
   }
 #endif //0
-  if(lttv_trace_find_hook(tcs->parent.t,
+  if(!lttv_trace_find_hook(tcs->parent.t,
       LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
       LTT_FIELD_SYSCALL_ID, 0, 0,
-      NULL, NULL, &h))
-    return;
-  
-  thf = lttv_trace_hook_get_first(&h);
-  
-  t = ltt_field_type(thf->f1);
-  nb = ltt_type_element_number(t);
-  
-  lttv_trace_hook_destroy(&h);
+      NULL, NULL, &h)) {
+		
+		thf = lttv_trace_hook_get_first(&h);
+		
+		t = ltt_field_type(thf->f1);
+		nb = ltt_type_element_number(t);
+		
+		lttv_trace_hook_destroy(&h);
 
-  name_tables->syscall_names = g_new(GQuark, nb);
-  name_tables->nb_syscalls = nb;
+		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);
-  }
+		for(i = 0 ; i < nb ; i++) {
+			name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
+		}
 
-  //name_tables->syscall_names = g_new(GQuark, 256);
-  //for(i = 0 ; i < 256 ; i++) {
-  //  g_string_printf(fe_name, "syscall %d", i);
-  //  name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
-  //}
+		//name_tables->syscall_names = g_new(GQuark, 256);
+		//for(i = 0 ; i < 256 ; i++) {
+		//  g_string_printf(fe_name, "syscall %d", i);
+		//  name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
+		//}
+	} else {
+		name_tables->syscall_names = NULL;
+		name_tables->nb_syscalls = 0;
+	}
 
-  if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
+  if(!lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
         LTT_EVENT_TRAP_ENTRY,
         LTT_FIELD_TRAP_ID, 0, 0,
-        NULL, NULL, &h))
-    return;
+        NULL, NULL, &h)) {
 
-  thf = lttv_trace_hook_get_first(&h);
+		thf = lttv_trace_hook_get_first(&h);
 
-  t = ltt_field_type(thf->f1);
-  //nb = ltt_type_element_number(t);
+		t = ltt_field_type(thf->f1);
+		//nb = ltt_type_element_number(t);
 
-  lttv_trace_hook_destroy(&h);
+		lttv_trace_hook_destroy(&h);
 
-  /*
-  name_tables->trap_names = g_new(GQuark, nb);
-  for(i = 0 ; i < nb ; i++) {
-    name_tables->trap_names[i] = g_quark_from_string(
-        ltt_enum_string_get(t, i));
-  }
-  */
-
-  name_tables->trap_names = g_new(GQuark, 256);
-  for(i = 0 ; i < 256 ; i++) {
-    g_string_printf(fe_name, "trap %d", i);
-    name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
-  }
+		/*
+		name_tables->trap_names = g_new(GQuark, nb);
+		for(i = 0 ; i < nb ; i++) {
+			name_tables->trap_names[i] = g_quark_from_string(
+					ltt_enum_string_get(t, i));
+		}
+		*/
+		name_tables->nb_traps = 256;
+		name_tables->trap_names = g_new(GQuark, 256);
+		for(i = 0 ; i < 256 ; i++) {
+			g_string_printf(fe_name, "trap %d", i);
+			name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
+		}
+	} else {
+		name_tables->trap_names = NULL;
+		name_tables->nb_traps = 0;
+	}
 
-  if(lttv_trace_find_hook(tcs->parent.t,
+  if(!lttv_trace_find_hook(tcs->parent.t,
         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
         LTT_FIELD_IRQ_ID, 0, 0,
-        NULL, NULL, &h))
-    return;
-  
-  thf = lttv_trace_hook_get_first(&h);
-  
-  t = ltt_field_type(thf->f1);
-  //nb = ltt_type_element_number(t);
-
-  lttv_trace_hook_destroy(&h);
+        NULL, NULL, &h)) {
+		
+		thf = lttv_trace_hook_get_first(&h);
+		
+		t = ltt_field_type(thf->f1);
+		//nb = ltt_type_element_number(t);
 
-  /*
-  name_tables->irq_names = g_new(GQuark, nb);
-  for(i = 0 ; i < nb ; i++) {
-    name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
-  }
-  */
+		lttv_trace_hook_destroy(&h);
 
-  name_tables->irq_names = g_new(GQuark, 256);
-  for(i = 0 ; i < 256 ; i++) {
-    g_string_printf(fe_name, "irq %d", i);
-    name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
-  }
+		/*
+		name_tables->irq_names = g_new(GQuark, nb);
+		for(i = 0 ; i < nb ; i++) {
+			name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
+		}
+		*/
 
+		name_tables->irq_names = g_new(GQuark, 256);
+		for(i = 0 ; i < 256 ; i++) {
+			g_string_printf(fe_name, "irq %d", i);
+			name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
+		}
+	} else {
+		name_tables->irq_names = NULL;
+	}
   /*
   name_tables->soft_irq_names = g_new(GQuark, nb);
   for(i = 0 ; i < nb ; i++) {
@@ -971,6 +996,7 @@ get_name_tables(LttvTraceState *tcs)
   tcs->syscall_names = name_tables->syscall_names;
   tcs->nb_syscalls = name_tables->nb_syscalls;
   tcs->trap_names = name_tables->trap_names;
+  tcs->nb_traps = name_tables->nb_traps;
   tcs->irq_names = name_tables->irq_names;
   tcs->soft_irq_names = name_tables->soft_irq_names;
 }
@@ -989,11 +1015,11 @@ free_name_tables(LttvTraceState *tcs)
   *(v.v_pointer) = NULL;
 
  // g_free(name_tables->eventtype_names);
-  g_free(name_tables->syscall_names);
-  g_free(name_tables->trap_names);
-  g_free(name_tables->irq_names);
-  g_free(name_tables->soft_irq_names);
-  g_free(name_tables);
+  if(name_tables->syscall_names) g_free(name_tables->syscall_names);
+  if(name_tables->trap_names) g_free(name_tables->trap_names);
+  if(name_tables->irq_names) g_free(name_tables->irq_names);
+  if(name_tables->soft_irq_names) g_free(name_tables->soft_irq_names);
+  if(name_tables) g_free(name_tables);
 } 
 
 #ifdef HASH_TABLE_DEBUG
@@ -1040,10 +1066,33 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
   es->t = t;
   es->n = state_id;
   es->entry = es->change = tfs->parent.timestamp;
+	es->cum_cpu_time = ltt_time_zero;
   es->s = process->state->s;
   process->state = es;
 }
 
+/* pop state
+ * return 1 when empty, else 0 */
+int lttv_state_pop_state_cleanup(LttvProcessState *process, 
+		LttvTracefileState *tfs)
+{ 
+	guint cpu = tfs->cpu;
+  LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
+
+  guint depth = process->execution_stack->len;
+
+  if(depth == 1){
+    return 1;
+  }
+
+  process->execution_stack = 
+    g_array_set_size(process->execution_stack, depth - 1);
+  process->state = &g_array_index(process->execution_stack, LttvExecutionState,
+      depth - 2);
+  process->state->change = tfs->parent.timestamp;
+	
+	return 0;
+}
 
 static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
 {
@@ -1059,10 +1108,11 @@ static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
     g_info("process state has %s when pop_int is %s\n",
 		    g_quark_to_string(process->state->t),
 		    g_quark_to_string(t));
-    g_info("{ %u, %u, %s, %s }\n",
+    g_info("{ %u, %u, %s, %s, %s }\n",
 		    process->pid,
 		    process->ppid,
 		    g_quark_to_string(process->name),
+		    g_quark_to_string(process->brand),
 		    g_quark_to_string(process->state->s));
     return;
   }
@@ -1107,6 +1157,7 @@ static gint search_usertrace(gconstpointer a, gconstpointer b)
 		}
 		return -1;
 	}
+	return 0;
 }
 
 static LttvTracefileState *ltt_state_usertrace_find(LttvTraceState *tcs,
@@ -1146,9 +1197,10 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
   process->pid = pid;
   process->cpu = cpu;
   process->name = name;
+  process->brand = LTTV_STATE_UNBRANDED;
   //process->last_cpu = tfs->cpu_name;
   //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
-	process->kernel_thread = 0;
+	process->type = LTTV_STATE_USER_THREAD;
 	process->usertrace = ltt_state_usertrace_find(tcs, pid, timestamp);
 	process->current_function = 0; //function 0x0 by default.
 
@@ -1186,6 +1238,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
   es->entry = *timestamp;
   //g_assert(timestamp->tv_sec != 0);
   es->change = *timestamp;
+	es->cum_cpu_time = ltt_time_zero;
   es->s = LTTV_STATE_RUN;
 
   es = process->state = &g_array_index(process->execution_stack, 
@@ -1195,6 +1248,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
   es->entry = *timestamp;
   //g_assert(timestamp->tv_sec != 0);
   es->change = *timestamp;
+	es->cum_cpu_time = ltt_time_zero;
   es->s = LTTV_STATE_WAIT_FORK;
 	
 	/* Allocate an empty function call stack. If it's empty, use 0x0. */
@@ -1316,8 +1370,19 @@ static gboolean trap_entry(void *hook_data, void *call_data)
 
   LttvExecutionSubmode submode;
 
-  submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[
-      ltt_event_get_unsigned(e, f)];
+  guint64 nb_traps = ((LttvTraceState *)(s->parent.t_context))->nb_traps;
+  guint64 trap = ltt_event_get_long_unsigned(e, f);
+
+  if(trap < nb_traps) {
+    submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[trap];
+  } else {
+    /* Fixup an incomplete trap table */
+    GString *string = g_string_new("");
+    g_string_printf(string, "trap %u", trap);
+    submode = g_quark_from_string(string->str);
+    g_string_free(string, TRUE);
+  }
+
   push_state(s, LTTV_STATE_TRAP, submode);
   return FALSE;
 }
@@ -1387,7 +1452,7 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data)
   LttvExecutionSubmode submode;
 
   submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[
-      ltt_event_get_unsigned(e, f)];
+      ltt_event_get_long_unsigned(e, f)];
 
   /* Do something with the info about being in user or system mode when int? */
   push_state(s, LTTV_STATE_SOFT_IRQ, submode);
@@ -1409,8 +1474,7 @@ static void push_function(LttvTracefileState *tfs, guint64 funcptr)
     
   new_func = &g_array_index(process->user_stack, guint64, depth);
 	*new_func = funcptr;
-  process->current_function = 
-		g_array_index(process->user_stack, guint64, depth - 1);
+  process->current_function = funcptr;
 }
 
 static void pop_function(LttvTracefileState *tfs, guint64 funcptr)
@@ -1419,19 +1483,20 @@ static void pop_function(LttvTracefileState *tfs, guint64 funcptr)
   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
 
-  guint depth = process->user_stack->len;
   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",
+    g_info("{ %u, %u, %s, %s, %s }\n",
 		    process->pid,
 		    process->ppid,
 		    g_quark_to_string(process->name),
+		    g_quark_to_string(process->brand),
 		    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",
@@ -1619,7 +1684,7 @@ static gboolean process_kernel_thread(void *hook_data, void *call_data)
   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;
+	process->type = LTTV_STATE_KERNEL_THREAD;
 
 	return FALSE;
 }
@@ -1633,13 +1698,14 @@ static gboolean process_exit(void *hook_data, void *call_data)
   guint pid;
   guint cpu = s->cpu;
   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
-  LttvProcessState *process = ts->running_process[cpu];
+  LttvProcessState *process; // = ts->running_process[cpu];
 
   pid = ltt_event_get_unsigned(e, thf->f1);
 
   // FIXME : Add this test in the "known state" section
   // g_assert(process->pid == pid);
 
+  process = lttv_state_find_process(ts, ANY_CPU, pid);
   if(likely(process != NULL)) {
     process->state->s = LTTV_STATE_EXIT;
   }
@@ -1684,9 +1750,8 @@ static gboolean process_free(void *hook_data, void *call_data)
         break;
       }
     }
-    //if(i == num_cpus) /* process is not scheduled */
-      //exit_process(s, process);	// do nothing : wait for the schedchange to
-			//delete the process.
+    if(i == num_cpus) /* process is not scheduled */
+      exit_process(s, process);
   }
 
   return FALSE;
@@ -1718,6 +1783,22 @@ static gboolean process_exec(void *hook_data, void *call_data)
   return FALSE;
 }
 
+static gboolean thread_brand(void *hook_data, void *call_data)
+{
+  LttvTracefileState *s = (LttvTracefileState *)call_data;
+  LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+  LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+  LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+  gchar *name;
+  guint cpu = s->cpu;
+  LttvProcessState *process = ts->running_process[cpu];
+
+  name = ltt_event_get_string(e, thf->f1);
+  process->brand = g_quark_from_string(name);
+
+  return FALSE;
+}
+
 static gboolean enum_process_state(void *hook_data, void *call_data)
 {
   LttvTracefileState *s = (LttvTracefileState *)call_data;
@@ -1733,8 +1814,9 @@ static gboolean enum_process_state(void *hook_data, void *call_data)
   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
   LttvProcessState *process = ts->running_process[cpu];
   LttvProcessState *parent_process;
-	LttField *f4, *f5, *f6;
-	GQuark mode, submode, status;
+	LttField *f4, *f5, *f6, *f7;
+	GQuark type, mode, submode, status;
+	LttvExecutionState *es;
 
   /* PID */
   pid = ltt_event_get_unsigned(e, thf->f1);
@@ -1745,21 +1827,26 @@ static gboolean enum_process_state(void *hook_data, void *call_data)
   /* Command name */
   command = ltt_event_get_string(e, thf->f3);
 
-	/* mode */
-	f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE);
-	mode = ltt_enum_string_get(ltt_field_type(f4), 
+	/* type */
+	f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_TYPE);
+	type = ltt_enum_string_get(ltt_field_type(f4),
 			ltt_event_get_unsigned(e, f4));
 
-	/* submode */
-	f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE);
-	submode = ltt_enum_string_get(ltt_field_type(f5), 
+	/* mode */
+	f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE);
+	mode = ltt_enum_string_get(ltt_field_type(f5), 
 			ltt_event_get_unsigned(e, f5));
 
-	/* status */
-	f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS);
-	status = ltt_enum_string_get(ltt_field_type(f6), 
+	/* submode */
+	f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE);
+	submode = ltt_enum_string_get(ltt_field_type(f6), 
 			ltt_event_get_unsigned(e, f6));
 
+	/* status */
+	f7 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS);
+	status = ltt_enum_string_get(ltt_field_type(f7), 
+			ltt_event_get_unsigned(e, f7));
+
   /* The process might exist if a process was forked while performing the sate dump. */
   process = lttv_state_find_process(ts, ANY_CPU, pid);
   if(process == NULL) {
@@ -1769,38 +1856,44 @@ static gboolean enum_process_state(void *hook_data, void *call_data)
 															&s->parent.timestamp);
 	
 		/* Keep the stack bottom : a running user mode */
-#if 0
 		/* Disabled because of inconsistencies in the current statedump states. */
-		if(mode == LTTV_STATE_USER_MODE) {
+		if(type == LTTV_STATE_KERNEL_THREAD) {
 			/* Only keep the bottom */
 			process->execution_stack = g_array_set_size(process->execution_stack, 1);
+			es = process->state = &g_array_index(process->execution_stack, 
+					LttvExecutionState, 0);
+			es->t = LTTV_STATE_SYSCALL;
+			es->s = status;
+			es->n = submode;
 		} else {
 			/* On top of it : */
-			LttvExecutionState *es;
 			es = process->state = &g_array_index(process->execution_stack, 
 					LttvExecutionState, 1);
-			es->t = mode;
+			es->t = LTTV_STATE_USER_MODE;
 			es->s = status;
 			es->n = submode;
 		}
-#endif //0
-
+#if 0
 		/* UNKNOWN STATE */
 		{
-			LttvExecutionState *es;
 			es = process->state = &g_array_index(process->execution_stack, 
 					LttvExecutionState, 1);
 			es->t = LTTV_STATE_MODE_UNKNOWN;
 			es->s = LTTV_STATE_UNNAMED;
 			es->n = LTTV_STATE_SUBMODE_UNKNOWN;
 		}
+#endif //0
   } else {
     /* The process has already been created :
 		 * Probably was forked while dumping the process state or
 		 * was simply scheduled in prior to get the state dump event.
+		 * We know for sure if it is a user space thread.
      */
     process->ppid = parent_pid;
 		process->name = g_quark_from_string(command);
+		es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
+		if(type != LTTV_STATE_KERNEL_THREAD)
+			es->t = LTTV_STATE_USER_MODE;
 		/* Don't mess around with the stack, it will eventually become
 		 * ok after the end of state dump. */
   }
@@ -1845,8 +1938,8 @@ 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), 17);
-    hooks = g_array_set_size(hooks, 17); // Max possible number of hooks.
+    hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 18);
+    hooks = g_array_set_size(hooks, 18); // Max possible number of hooks.
 		hn = 0;
 
     ret = lttv_trace_find_hook(ts->parent.t,
@@ -1934,6 +2027,12 @@ void lttv_state_add_event_hooks(LttvTracesetState *self)
         process_exec, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
 		if(ret) hn--;
 
+    ret = lttv_trace_find_hook(ts->parent.t,
+        LTT_FACILITY_USER_GENERIC, LTT_EVENT_THREAD_BRAND,
+        LTT_FIELD_NAME, 0, 0,
+        thread_brand, 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,
@@ -2371,6 +2470,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);
@@ -2391,7 +2492,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, 
@@ -2583,7 +2685,8 @@ lttv_tracefile_state_get_type(void)
 
 static void module_init()
 {
-  LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
+  LTTV_STATE_UNNAMED = g_quark_from_string("UNNAMED");
+  LTTV_STATE_UNBRANDED = g_quark_from_string("UNBRANDED");
   LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("MODE_UNKNOWN");
   LTTV_STATE_USER_MODE = g_quark_from_string("USER_MODE");
   LTTV_STATE_SYSCALL = g_quark_from_string("SYSCALL");
@@ -2599,6 +2702,8 @@ static void module_init()
   LTTV_STATE_WAIT = g_quark_from_string("WAIT");
   LTTV_STATE_RUN = g_quark_from_string("RUN");
   LTTV_STATE_DEAD = g_quark_from_string("DEAD");
+	LTTV_STATE_USER_THREAD = g_quark_from_string("USER_THREAD");
+	LTTV_STATE_KERNEL_THREAD = g_quark_from_string("KERNEL_THREAD");
   LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
   LTTV_STATE_PROCESSES = g_quark_from_string("processes");
   LTTV_STATE_PROCESS = g_quark_from_string("process");
@@ -2638,6 +2743,7 @@ static void module_init()
   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_EVENT_THREAD_BRAND  = g_quark_from_string("thread_brand");
 
 
   LTT_FIELD_SYSCALL_ID    = g_quark_from_string("syscall_id");
@@ -2652,6 +2758,7 @@ static void module_init()
   LTT_FIELD_PID           = g_quark_from_string("pid");
   LTT_FIELD_FILENAME      = g_quark_from_string("filename");
   LTT_FIELD_NAME          = g_quark_from_string("name");
+  LTT_FIELD_TYPE          = g_quark_from_string("type");
   LTT_FIELD_MODE          = g_quark_from_string("mode");
   LTT_FIELD_SUBMODE       = g_quark_from_string("submode");
   LTT_FIELD_STATUS        = g_quark_from_string("status");