X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=5d757e035feb3206fb45bab515b74aac2a876780;hb=2312de30ce2be53f81c4eaaa772ffff21511b509;hp=dee43252eaf4ddd1eb6c3eb838cb07e71c7c9d58;hpb=d448fce24840c50fbd998d06a7daa595859df2ff;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index dee43252..5d757e03 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, @@ -775,7 +776,7 @@ create_name_tables(LttvTraceState *tcs) thf = lttv_trace_hook_get_first(&h); t = ltt_field_type(thf->f1); - nb = ltt_type_element_number(t); + //nb = ltt_type_element_number(t); lttv_trace_hook_destroy(&h); @@ -803,7 +804,7 @@ create_name_tables(LttvTraceState *tcs) thf = lttv_trace_hook_get_first(&h); t = ltt_field_type(thf->f1); - nb = ltt_type_element_number(t); + //nb = ltt_type_element_number(t); lttv_trace_hook_destroy(&h); @@ -830,7 +831,7 @@ create_name_tables(LttvTraceState *tcs) thf = lttv_trace_hook_get_first(&h); t = ltt_field_type(thf->f1); - nb = ltt_type_element_number(t); + //nb = ltt_type_element_number(t); lttv_trace_hook_destroy(&h); @@ -1017,7 +1018,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf); process->execution_stack = g_array_sized_new(FALSE, FALSE, sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK); - process->execution_stack = g_array_set_size(process->execution_stack, 1); + process->execution_stack = g_array_set_size(process->execution_stack, 2); es = process->state = &g_array_index(process->execution_stack, LttvExecutionState, 0); es->t = LTTV_STATE_USER_MODE; @@ -1025,6 +1026,15 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, es->entry = *timestamp; //g_assert(timestamp->tv_sec != 0); es->change = *timestamp; + es->s = LTTV_STATE_RUN; + + es = process->state = &g_array_index(process->execution_stack, + LttvExecutionState, 1); + es->t = LTTV_STATE_SYSCALL; + es->n = LTTV_STATE_SUBMODE_NONE; + es->entry = *timestamp; + //g_assert(timestamp->tv_sec != 0); + es->change = *timestamp; es->s = LTTV_STATE_WAIT_FORK; return process; @@ -1202,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( @@ -1251,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)) { @@ -1262,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); @@ -1277,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; } @@ -1329,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; @@ -1838,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 = @@ -1847,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); } } @@ -2104,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");