X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=728e589928657b44f29408c59f1680cb3019ed3c;hb=743e50fd0105daeea4804d68989965399bf3a4d3;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..728e5899 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; @@ -1347,14 +1375,19 @@ static gboolean process_exec(void *hook_data, void *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; + //gchar *name; guint cpu = ltt_tracefile_num(s->parent.tf); LttvProcessState *process = ts->running_process[cpu]; /* PID of the process to release */ - name = ltt_event_get_string(e, thf->f1); + guint64 name_len = ltt_event_field_element_number(e, thf->f1); + //name = ltt_event_get_string(e, thf->f1); + gchar *name_begin = ltt_event_field_element_select(e, thf->f1, 0); + gchar *null_term_name = g_new(gchar, name_len+1); + memcpy(null_term_name, name_begin, name_len); + null_term_name[name_len] = '\0'; - process->name = g_quark_from_string(name); + process->name = g_quark_from_string(null_term_name); return FALSE; } @@ -1838,7 +1871,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 +1880,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 +2137,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");