GQuark
LTT_FACILITY_KERNEL,
+ LTT_FACILITY_ASM_I386_KERNEL,
LTT_FACILITY_PROCESS,
LTT_FACILITY_FS;
LTTV_STATE_EXIT,
LTTV_STATE_ZOMBIE,
LTTV_STATE_WAIT,
- LTTV_STATE_RUN;
+ LTTV_STATE_RUN,
+ LTTV_STATE_DEAD;
static GQuark
LTTV_STATE_TRACEFILES,
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 =
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);
}
#endif //0
if(lttv_trace_find_hook(tcs->parent.t,
- LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
+ LTT_FACILITY_ASM_I386_KERNEL, 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);
+ //nb = ltt_type_element_number(t);
lttv_trace_hook_destroy(&h);
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);
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);
//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;
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;
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(
/* 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)) {
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);
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;
}
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;
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;
}
hooks = g_array_set_size(hooks, 11);
ret = lttv_trace_find_hook(ts->parent.t,
- LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
+ LTT_FACILITY_ASM_I386_KERNEL, 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_ASM_I386_KERNEL, LTT_EVENT_SYSCALL_EXIT,
0, 0, 0,
syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1));
g_assert(!ret);
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)
{
}
}
+
+ 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)
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 =
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);
}
}
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);
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");
LTT_FACILITY_KERNEL = g_quark_from_string("kernel");
+ LTT_FACILITY_ASM_I386_KERNEL = g_quark_from_string("asm_i386_kernel");
LTT_FACILITY_PROCESS = g_quark_from_string("process");
LTT_FACILITY_FS = g_quark_from_string("fs");