X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=18d21fde159688115236bc06360ee53a645a2ff4;hb=fadb18a9c4eed454c8a8f9595222e0360e6edb07;hp=c06ba340e25fa77d7bfc97002f3e2de001f8c070;hpb=26275aa2f3a7de1a352f4dcbf7f6e8bebd6951bf;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index c06ba340..18d21fde 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -35,6 +35,7 @@ GQuark LTT_FACILITY_KERNEL, + LTT_FACILITY_KERNEL_ARCH, LTT_FACILITY_PROCESS, LTT_FACILITY_FS; @@ -85,7 +86,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, @@ -561,8 +563,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) nb_tracefile = self->parent.tracefiles->len; - g_tree_destroy(tsc->pqueue); - tsc->pqueue = g_tree_new(compare_tracefile); + //g_tree_destroy(tsc->pqueue); + //tsc->pqueue = g_tree_new(compare_tracefile); for(i = 0 ; i < nb_tracefile ; i++) { tfcs = @@ -586,6 +588,7 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) g_assert(tfcs->parent.t_context != NULL); LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs); + g_tree_remove(tsc->pqueue, tfc); if(ep != NULL) { g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0); @@ -766,7 +769,7 @@ create_name_tables(LttvTraceState *tcs) } #endif //0 if(lttv_trace_find_hook(tcs->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, LTT_FIELD_SYSCALL_ID, 0, 0, NULL, NULL, &h)) return; @@ -778,20 +781,17 @@ create_name_tables(LttvTraceState *tcs) lttv_trace_hook_destroy(&h); - /* CHECK syscalls should be an enum but currently are not! name_tables->syscall_names = g_new(GQuark, nb); for(i = 0 ; i < nb ; i++) { - name_tables->syscall_names[i] = g_quark_from_string( - ltt_enum_string_get(t, 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); + //} if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY, @@ -802,7 +802,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); @@ -829,7 +829,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); @@ -1016,7 +1016,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; @@ -1024,6 +1024,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; @@ -1201,18 +1210,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( @@ -1250,8 +1257,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)) { @@ -1261,7 +1270,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); @@ -1276,10 +1285,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; } @@ -1328,12 +1340,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; @@ -1346,15 +1373,22 @@ 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); - - process->name = g_quark_from_string(name); - + guint64 name_len = ltt_event_field_element_number(e, thf->f1); + //name = ltt_event_get_string(e, thf->f1); + LttField *child = ltt_event_field_element_select(e, thf->f1, 0); + gchar *name_begin = + (gchar*)(ltt_event_data(e)+ltt_event_field_offset(e, child)); + 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(null_term_name); + g_free(null_term_name); return FALSE; } @@ -1401,13 +1435,13 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) hooks = g_array_set_size(hooks, 11); ret = lttv_trace_find_hook(ts->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY, + 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); ret = lttv_trace_find_hook(ts->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_EXIT, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT, 0, 0, 0, syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1)); g_assert(!ret); @@ -1597,6 +1631,15 @@ static gboolean state_save_event_hook(void *hook_data, void *call_data) return FALSE; } +static gboolean state_save_after_trace_hook(void *hook_data, void *call_data) +{ + LttvTraceState *tcs = (LttvTraceState *)(call_data); + + *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time; + + return FALSE; +} + #if 0 static gboolean block_start(void *hook_data, void *call_data) { @@ -1745,6 +1788,10 @@ void lttv_state_save_add_event_hooks(LttvTracesetState *self) } } + + lttv_process_traceset_begin(&self->parent, + NULL, NULL, NULL, NULL, NULL); + } gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data) @@ -1805,14 +1852,26 @@ void lttv_state_save_remove_event_hooks(LttvTracesetState *self) LttvTracefileState *tfs; + LttvHooks *after_trace = lttv_hooks_new(); + + lttv_hooks_add(after_trace, + state_save_after_trace_hook, + NULL, + LTTV_PRIO_STATE); + + + lttv_process_traceset_end(&self->parent, + NULL, after_trace, NULL, NULL, NULL); + lttv_hooks_destroy(after_trace); + nb_trace = lttv_traceset_number(traceset); for(i = 0 ; i < nb_trace ; i++) { 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 = @@ -1820,9 +1879,8 @@ void lttv_state_save_remove_event_hooks(LttvTracesetState *self) LttvTracefileContext*, j)); event_count = lttv_hooks_remove(tfs->parent.event, state_save_event_hook); - } - g_free(event_count); + if(event_count) g_free(event_count); } } @@ -1855,8 +1913,8 @@ void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t) LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree; - g_tree_destroy(self->parent.pqueue); - self->parent.pqueue = g_tree_new(compare_tracefile); + //g_tree_destroy(self->parent.pqueue); + //self->parent.pqueue = g_tree_new(compare_tracefile); g_info("Entering seek_time_closest for time %lu.%lu", t.tv_sec, t.tv_nsec); @@ -2079,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"); @@ -2094,6 +2153,7 @@ static void module_init() LTT_FACILITY_KERNEL = g_quark_from_string("kernel"); + LTT_FACILITY_KERNEL_ARCH = g_quark_from_string("kernel_arch"); LTT_FACILITY_PROCESS = g_quark_from_string("process"); LTT_FACILITY_FS = g_quark_from_string("fs");