X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=d5d540316f7dc901f8229ffd5ea1c05b700ac704;hb=f0ca53e9f04bad0dfc7aac9978fdf11d760f399b;hp=aef86ae5c667b5a7ffa23c8b18d89eaaecc041c6;hpb=c607371be079c36e281398a753221002c1c4c851;p=lttv.git

diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c
index aef86ae5..d5d54031 100644
--- a/ltt/branches/poly/lttv/lttv/state.c
+++ b/ltt/branches/poly/lttv/lttv/state.c
@@ -85,7 +85,8 @@ LttvProcessStatus
   LTTV_STATE_EXIT,
   LTTV_STATE_ZOMBIE,
   LTTV_STATE_WAIT,
-  LTTV_STATE_RUN;
+  LTTV_STATE_RUN,
+  LTTV_STATE_DEAD;
 
 static GQuark
   LTTV_STATE_TRACEFILES,
@@ -1211,18 +1212,16 @@ static gboolean schedchange(void *hook_data, void *call_data)
 
     if(unlikely(process->state->s == LTTV_STATE_EXIT)) {
       process->state->s = LTTV_STATE_ZOMBIE;
+      process->state->change = s->parent.timestamp;
     } else {
       if(unlikely(state_out == 0)) process->state->s = LTTV_STATE_WAIT_CPU;
       else process->state->s = LTTV_STATE_WAIT;
-    } /* FIXME : we do not remove process here, because the kernel
-       * still has them : they may be zombies. We need to know
-       * exactly when release_task is executed on the PID to 
-       * know when the zombie is destroyed.
-       */
-    //else
-    //  exit_process(s, process);
-
-    process->state->change = s->parent.timestamp;
+      process->state->change = s->parent.timestamp;
+    }
+
+    if(state_out == 32)
+       exit_process(s, process); /* EXIT_DEAD */
+          /* see sched.h for states */
   }
   process = ts->running_process[cpu] =
               lttv_state_find_process_or_create(
@@ -1260,8 +1259,10 @@ static gboolean process_fork(void *hook_data, void *call_data)
 
   /* Mathieu : it seems like the process might have been scheduled in before the
    * fork, and, in a rare case, might be the current process. This might happen
-   * in a SMP case where we don't have enough precision on the clocks */
-#if 0
+   * in a SMP case where we don't have enough precision on the clocks.
+   *
+   * Test reenabled after precision fixes on time. (Mathieu) */
+#if 0 
   zombie_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
 
   if(unlikely(zombie_process != NULL)) {
@@ -1271,7 +1272,7 @@ static gboolean process_fork(void *hook_data, void *call_data)
     guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
     guint i;
     for(i=0; i< num_cpus; i++) {
-      g_assert(process != ts->running_process[i]);
+      g_assert(zombie_process != ts->running_process[i]);
     }
 
     exit_process(s, zombie_process);
@@ -1286,10 +1287,13 @@ static gboolean process_fork(void *hook_data, void *call_data)
                               child_pid, &s->parent.timestamp);
   } else {
     /* The process has already been created :  due to time imprecision between
-     * multiple CPUs : it has been scheduled in before creation.
+     * multiple CPUs : it has been scheduled in before creation. Note that we
+     * shouldn't have this kind of imprecision.
      *
      * Simply put a correct parent.
      */
+    g_assert(0); /* This is a problematic case : the process has been created
+                    before the fork event */
     child_process->ppid = process->pid;
   }
 
@@ -1338,12 +1342,27 @@ static gboolean process_free(void *hook_data, void *call_data)
   if(likely(process != NULL)) {
     /* release_task is happening at kernel level : we can now safely release
      * the data structure of the process */
+    //This test is fun, though, as it may happen that 
+    //at time t : CPU 0 : process_free
+    //at time t+150ns : CPU 1 : schedule out
+    //Clearly due to time imprecision, we disable it. (Mathieu)
+    //If this weird case happen, we have no choice but to put the 
+    //Currently running process on the cpu to 0.
+    //I re-enable it following time precision fixes. (Mathieu)
+    //Well, in the case where an process is freed by a process on another CPU
+    //and still scheduled, it happens that this is the schedchange that will
+    //drop the last reference count. Do not free it here!
     guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
     guint i;
     for(i=0; i< num_cpus; i++) {
-      g_assert(process != ts->running_process[i]);
+      //g_assert(process != ts->running_process[i]);
+      if(process == ts->running_process[i]) {
+        //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
+        break;
+      }
     }
-    exit_process(s, process);
+    if(i == num_cpus) /* process is not scheduled */
+      exit_process(s, process);
   }
 
   return FALSE;
@@ -1847,7 +1866,7 @@ void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
     ts = (LttvTraceState *)self->parent.traces[i];
     nb_tracefile = ts->parent.tracefiles->len;
 
-    guint *event_count;
+    guint *event_count = NULL;
 
     for(j = 0 ; j < nb_tracefile ; j++) {
       tfs = 
@@ -1856,7 +1875,7 @@ void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
       event_count = lttv_hooks_remove(tfs->parent.event,
                         state_save_event_hook);
     }
-    g_free(event_count);
+    if(event_count) g_free(event_count);
   }
 }
 
@@ -2113,6 +2132,7 @@ static void module_init()
   LTTV_STATE_ZOMBIE = g_quark_from_string("zombie");
   LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
   LTTV_STATE_RUN = g_quark_from_string("running");
+  LTTV_STATE_DEAD = g_quark_from_string("dead");
   LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
   LTTV_STATE_PROCESSES = g_quark_from_string("processes");
   LTTV_STATE_PROCESS = g_quark_from_string("process");