* MA 02111-1307, USA.
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <lttv/lttv.h>
#include <lttv/module.h>
#define PREALLOCATED_EXECUTION_STACK 10
+/* Facilities Quarks */
+
+GQuark
+ LTT_FACILITY_KERNEL,
+ LTT_FACILITY_PROCESS;
+
+/* Events Quarks */
+
+GQuark
+ LTT_EVENT_SYSCALL_ENTRY,
+ LTT_EVENT_SYSCALL_EXIT,
+ LTT_EVENT_TRAP_ENTRY,
+ LTT_EVENT_TRAP_EXIT,
+ LTT_EVENT_IRQ_ENTRY,
+ LTT_EVENT_IRQ_EXIT,
+ LTT_EVENT_SCHEDCHANGE,
+ LTT_EVENT_FORK,
+ LTT_EVENT_EXIT,
+ LTT_EVENT_FREE;
+
+/* Fields Quarks */
+
+GQuark
+ LTT_FIELD_SYSCALL_ID,
+ LTT_FIELD_TRAP_ID,
+ LTT_FIELD_IRQ_ID,
+ LTT_FIELD_OUT,
+ LTT_FIELD_IN,
+ LTT_FIELD_OUT_STATE,
+ LTT_FIELD_PARENT_PID,
+ LTT_FIELD_CHILD_PID,
+ LTT_FIELD_PID;
+
LttvExecutionMode
LTTV_STATE_MODE_UNKNOWN,
LTTV_STATE_USER_MODE,
LTTV_STATE_TRACEFILES,
LTTV_STATE_PROCESSES,
LTTV_STATE_PROCESS,
+ LTTV_STATE_RUNNING_PROCESS,
LTTV_STATE_EVENT,
LTTV_STATE_SAVED_STATES,
LTTV_STATE_SAVED_STATES_TIME,
LTTV_STATE_NAME_TABLES,
LTTV_STATE_TRACE_STATE_USE_COUNT;
-
static void create_max_time(LttvTraceState *tcs);
static void get_max_time(LttvTraceState *tcs);
if(likely(process_a->pid != process_b->pid)) ret = FALSE;
else if(likely(process_a->pid == 0 &&
- process_a->last_cpu != process_b->last_cpu)) ret = FALSE;
+ process_a->cpu != process_b->cpu)) ret = FALSE;
return ret;
}
static void
restore_init_state(LttvTraceState *self)
{
- guint i, nb_tracefile;
+ guint i, nb_cpus;
LttvTracefileState *tfcs;
+ /* Free the process tables */
if(self->processes != NULL) lttv_state_free_process_table(self->processes);
self->processes = g_hash_table_new(process_hash, process_equal);
self->nb_event = 0;
- nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
- ltt_trace_per_cpu_tracefile_number(self->parent.t);
+ /* Seek time to beginning */
+ g_tree_destroy(self->parent.ts_context->pqueue);
+ self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
+
+ lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
+
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+
+ /* Put the per cpu running_process to beginning state : process 0. */
+ for(i=0; i< nb_cpus; i++) {
+ self->running_process[i] = lttv_state_create_process(self, NULL, i, 0,
+ <t_time_zero);
+ self->running_process[i]->state->s = LTTV_STATE_RUN;
+ self->running_process[i]->cpu = i;
+ }
+
+#if 0
+ nb_tracefile = self->parent.tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfcs = LTTV_TRACEFILE_STATE(self->parent.tracefiles[i]);
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
+ LttvTracefileContext*, i));
ltt_trace_time_span_get(self->parent.t, &tfcs->parent.timestamp, NULL);
- tfcs->saved_position = 0;
+// tfcs->saved_position = 0;
tfcs->process = lttv_state_create_process(tfcs, NULL,0);
tfcs->process->state->s = LTTV_STATE_RUN;
tfcs->process->last_cpu = tfcs->cpu_name;
- tfcs->process->last_cpu_index = ((LttvTracefileContext*)tfcs)->index;
+ tfcs->process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfcs)->tf);
}
+#endif //0
}
-static LttTime time_zero = {0,0};
+//static LttTime time_zero = {0,0};
static void
init(LttvTracesetState *self, LttvTraceset *ts)
nb_trace = lttv_traceset_number(ts);
for(i = 0 ; i < nb_trace ; i++) {
tc = self->parent.traces[i];
- tcs = (LttvTraceState *)tc;
- tcs->save_interval = 50000;
+ tcs = LTTV_TRACE_STATE(tc);
+ tcs->save_interval = LTTV_STATE_SAVE_INTERVAL;
lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
LTTV_UINT, &v);
(*v.v_uint)++;
get_name_tables(tcs);
get_max_time(tcs);
- nb_tracefile = ltt_trace_control_tracefile_number(tc->t) +
- ltt_trace_per_cpu_tracefile_number(tc->t);
-
+ nb_tracefile = tc->tracefiles->len;
+#if 0
for(j = 0 ; j < nb_tracefile ; j++) {
- tfcs = LTTV_TRACEFILE_STATE(tc->tracefiles[j]);
- tfcs->cpu_name= g_quark_from_string(ltt_tracefile_name(tfcs->parent.tf));
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles,
+ LttvTracefileContext*, j));
+ tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf);
}
+#endif //0
tcs->processes = NULL;
+ tcs->running_process = g_new(LttvProcessState*,
+ ltt_trace_get_num_cpu(tc->t));
restore_init_state(tcs);
}
}
free_max_time(tcs);
free_saved_state(tcs);
}
+ g_free(tcs->running_process);
+ tcs->running_process = NULL;
lttv_state_free_process_table(tcs->processes);
tcs->processes = NULL;
}
process = (LttvProcessState *)value;
fprintf(fp,
-" <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%s\">\n",
+" <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%u\">\n",
process, process->pid, process->ppid, process->creation_time.tv_sec,
process->creation_time.tv_nsec, g_quark_to_string(process->name),
- g_quark_to_string(process->last_cpu));
+ process->cpu);
for(i = 0 ; i < process->execution_stack->len; i++) {
es = &g_array_index(process->execution_stack, LttvExecutionState, i);
void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp)
{
- guint i, nb_tracefile, nb_block, nb_event;
+ guint i, nb_tracefile, nb_block, offset;
+ guint64 tsc;
LttvTracefileState *tfcs;
LttEventPosition *ep;
+ guint nb_cpus;
+
ep = ltt_event_position_new();
fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
g_hash_table_foreach(self->processes, write_process_state, fp);
+
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ for(i=0;i<nb_cpus;i++) {
+ fprintf(fp,"<CPU NUM=%u RUNNING_PROCESS=%u>\n",
+ i, self->running_process[i]->pid);
+ }
- nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
- ltt_trace_per_cpu_tracefile_number(self->parent.t);
+ nb_tracefile = self->parent.tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
- fprintf(fp, " <TRACEFILE PID=%u TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
- tfcs->process->pid, tfcs->parent.timestamp.tv_sec,
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
+ LttvTracefileContext*, i));
+ fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
+ tfcs->parent.timestamp.tv_sec,
tfcs->parent.timestamp.tv_nsec);
- if(tfcs->parent.e == NULL) fprintf(fp,"/>\n");
+ LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
+ if(e == NULL) fprintf(fp,"/>\n");
else {
- ltt_event_position(tfcs->parent.e, ep);
- ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
- fprintf(fp, " BLOCK=%u EVENT=%u/>\n", nb_block, nb_event);
+ ltt_event_position(e, ep);
+ ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
+ fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
+ tsc);
}
}
g_free(ep);
*new_process = *process;
new_process->execution_stack = g_array_sized_new(FALSE, FALSE,
sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
- g_array_set_size(new_process->execution_stack,process->execution_stack->len);
+ new_process->execution_stack =
+ g_array_set_size(new_process->execution_stack,
+ process->execution_stack->len);
for(i = 0 ; i < process->execution_stack->len; i++) {
g_array_index(new_process->execution_stack, LttvExecutionState, i) =
g_array_index(process->execution_stack, LttvExecutionState, i);
static void state_save(LttvTraceState *self, LttvAttribute *container)
{
- guint i, nb_tracefile;
+ guint i, nb_tracefile, nb_cpus;
LttvTracefileState *tfcs;
LttvAttribute *tracefiles_tree, *tracefile_tree;
+
+ guint *running_process;
LttvAttributeType type;
LTTV_POINTER);
*(value.v_pointer) = lttv_state_copy_process_table(self->processes);
- nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
- ltt_trace_per_cpu_tracefile_number(self->parent.t);
+ /* Add the currently running processes array */
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ running_process = g_new(guint, nb_cpus);
+ for(i=0;i<nb_cpus;i++) {
+ running_process[i] = self->running_process[i]->pid;
+ }
+ value = lttv_attribute_add(container, LTTV_STATE_RUNNING_PROCESS,
+ LTTV_POINTER);
+ *(value.v_pointer) = running_process;
+
+
+ nb_tracefile = self->parent.tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
+ LttvTracefileContext*, i));
tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
value = lttv_attribute_add(tracefiles_tree, i,
LTTV_GOBJECT);
*(value.v_gobject) = (GObject *)tracefile_tree;
+#if 0
value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
LTTV_UINT);
*(value.v_uint) = tfcs->process->pid;
+#endif //0
value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
LTTV_POINTER);
- if(tfcs->parent.e == NULL) *(value.v_pointer) = NULL;
- else {
+ /* Only save the position if the tfs has not infinite time. */
+ //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
+ // && current_tfcs != tfcs) {
+ if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) == 0) {
+ *(value.v_pointer) = NULL;
+ } else {
+ LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
ep = ltt_event_position_new();
- ltt_event_position(tfcs->parent.e, ep);
+ ltt_event_position(e, ep);
*(value.v_pointer) = ep;
- guint nb_block, nb_event;
+ guint nb_block, offset;
+ guint64 tsc;
LttTracefile *tf;
- ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
- g_debug("Block %u event %u time %lu.%lu", nb_block, nb_event,
+ ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
+ g_debug("Block %u offset %u tsc %llu time %lu.%lu", nb_block, offset,
+ tsc,
tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
}
}
static void state_restore(LttvTraceState *self, LttvAttribute *container)
{
- guint i, nb_tracefile, pid;
+ guint i, nb_tracefile, pid, nb_cpus;
LttvTracefileState *tfcs;
LttvAttribute *tracefiles_tree, *tracefile_tree;
+ guint *running_process;
+
LttvAttributeType type;
LttvAttributeValue value;
LttEventPosition *ep;
+ LttvTracesetContext *tsc = self->parent.ts_context;
+
tracefiles_tree = lttv_attribute_find_subdir(container,
LTTV_STATE_TRACEFILES);
lttv_state_free_process_table(self->processes);
self->processes = lttv_state_copy_process_table(*(value.v_pointer));
- nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
- ltt_trace_per_cpu_tracefile_number(self->parent.t);
+ /* Add the currently running processes array */
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
+ &value);
+ g_assert(type == LTTV_POINTER);
+ running_process = *(value.v_pointer);
+ for(i=0;i<nb_cpus;i++) {
+ pid = running_process[i];
+ self->running_process[i] = lttv_state_find_process(self, i, pid);
+ g_assert(self->running_process[i] != NULL);
+ }
+
+ nb_tracefile = self->parent.tracefiles->len;
+
+ g_tree_destroy(tsc->pqueue);
+ tsc->pqueue = g_tree_new(compare_tracefile);
+
for(i = 0 ; i < nb_tracefile ; i++) {
- tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
+ LttvTracefileContext*, i));
type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
g_assert(type == LTTV_GOBJECT);
tracefile_tree = *((LttvAttribute **)(value.v_gobject));
-
+#if 0
type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_PROCESS,
&value);
g_assert(type == LTTV_UINT);
pid = *(value.v_uint);
tfcs->process = lttv_state_find_process_or_create(tfcs, pid);
-
+#endif //0
type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
&value);
g_assert(type == LTTV_POINTER);
- if(*(value.v_pointer) == NULL) tfcs->parent.e = NULL;
- else {
- ep = *(value.v_pointer);
- g_assert(tfcs->parent.t_context != NULL);
- lttv_process_tracefile_seek_position(LTTV_TRACEFILE_CONTEXT(tfcs), ep);
+ //g_assert(*(value.v_pointer) != NULL);
+ ep = *(value.v_pointer);
+ g_assert(tfcs->parent.t_context != NULL);
+
+ LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs);
+
+ if(ep != NULL) {
+ g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
+ tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
+ g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
+ g_tree_insert(tsc->pqueue, tfc, tfc);
+ } else {
+ tfc->timestamp = ltt_time_infinite;
}
}
}
static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
{
- guint i, nb_tracefile;
+ guint i, nb_tracefile, nb_cpus;
LttvTracefileState *tfcs;
LttvAttribute *tracefiles_tree, *tracefile_tree;
+ guint *running_process;
+
LttvAttributeType type;
LttvAttributeValue value;
*(value.v_pointer) = NULL;
lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES);
- nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
- ltt_trace_per_cpu_tracefile_number(self->parent.t);
+ /* Free running processes array */
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_RUNNING_PROCESS,
+ &value);
+ g_assert(type == LTTV_POINTER);
+ running_process = *(value.v_pointer);
+ g_free(running_process);
+
+ nb_tracefile = self->parent.tracefiles->len;
for(i = 0 ; i < nb_tracefile ; i++) {
- tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
+ LttvTracefileContext*, i));
type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
g_assert(type == LTTV_GOBJECT);
tracefile_tree = *((LttvAttribute **)(value.v_gobject));
LTTV_POINTER, &v);
g_assert(*(v.v_pointer) == NULL);
*(v.v_pointer) = g_new(LttTime,1);
- *((LttTime *)*(v.v_pointer)) = time_zero;
+ *((LttTime *)*(v.v_pointer)) = ltt_time_zero;
}
typedef struct _LttvNameTables {
- GQuark *eventtype_names;
+ // FIXME GQuark *eventtype_names;
GQuark *syscall_names;
GQuark *trap_names;
GQuark *irq_names;
{
int i, nb;
- char *f_name, *e_name;
+ GQuark f_name, e_name;
LttvTraceHook h;
+ LttvTraceHookByFacility *thf;
+
LttEventType *et;
LttType *t;
LTTV_POINTER, &v);
g_assert(*(v.v_pointer) == NULL);
*(v.v_pointer) = name_tables;
-
+#if 0 // Use iteration over the facilities_by_name and then list all event
+ // types of each facility
nb = ltt_trace_eventtype_number(tcs->parent.t);
name_tables->eventtype_names = g_new(GQuark, nb);
for(i = 0 ; i < nb ; i++) {
g_string_printf(fe_name, "%s.%s", f_name, e_name);
name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
}
-
- lttv_trace_find_hook(tcs->parent.t, "core", "syscall_entry",
- "syscall_id", NULL, NULL, NULL, &h);
- t = ltt_field_type(h.f1);
+#endif //0
+ if(lttv_trace_find_hook(tcs->parent.t,
+ LTT_FACILITY_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);
+
+ lttv_trace_hook_destroy(&h);
- /* CHECK syscalls should be an emun but currently are not!
+ /* 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(fe_name->str);
}
- lttv_trace_find_hook(tcs->parent.t, "core", "trap_entry",
- "trap_id", NULL, NULL, NULL, &h);
- t = ltt_field_type(h.f1);
+ if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
+ LTT_EVENT_TRAP_ENTRY,
+ LTT_FIELD_TRAP_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);
+ lttv_trace_hook_destroy(&h);
+
/*
name_tables->trap_names = g_new(GQuark, nb);
for(i = 0 ; i < nb ; i++) {
name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
}
- lttv_trace_find_hook(tcs->parent.t, "core", "irq_entry",
- "irq_id", NULL, NULL, NULL, &h);
- t = ltt_field_type(h.f1);
+ if(lttv_trace_find_hook(tcs->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
+ LTT_FIELD_IRQ_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);
+ lttv_trace_hook_destroy(&h);
+
/*
name_tables->irq_names = g_new(GQuark, nb);
for(i = 0 ; i < nb ; i++) {
LTTV_POINTER, &v);
g_assert(*(v.v_pointer) != NULL);
name_tables = (LttvNameTables *)*(v.v_pointer);
- tcs->eventtype_names = name_tables->eventtype_names;
+ //tcs->eventtype_names = name_tables->eventtype_names;
tcs->syscall_names = name_tables->syscall_names;
tcs->trap_names = name_tables->trap_names;
tcs->irq_names = name_tables->irq_names;
name_tables = (LttvNameTables *)*(v.v_pointer);
*(v.v_pointer) = NULL;
- g_free(name_tables->eventtype_names);
+ // g_free(name_tables->eventtype_names);
g_free(name_tables->syscall_names);
g_free(name_tables->trap_names);
g_free(name_tables->irq_names);
g_free(name_tables);
}
-
static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
guint state_id)
{
LttvExecutionState *es;
-
- LttvProcessState *process = tfs->process;
+
+ guint cpu = ltt_tracefile_num(tfs->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
+ LttvProcessState *process = ts->running_process[cpu];
guint depth = process->execution_stack->len;
- g_array_set_size(process->execution_stack, depth + 1);
+ process->execution_stack =
+ g_array_set_size(process->execution_stack, depth + 1);
+ /* Keep in sync */
+ process->state =
+ &g_array_index(process->execution_stack, LttvExecutionState, depth - 1);
+
es = &g_array_index(process->execution_stack, LttvExecutionState, depth);
es->t = t;
es->n = state_id;
static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
{
- LttvProcessState *process = tfs->process;
+ guint cpu = ltt_tracefile_num(tfs->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
+ LttvProcessState *process = ts->running_process[cpu];
guint depth = process->execution_stack->len;
return;
}
- g_array_set_size(process->execution_stack, depth - 1);
+ process->execution_stack =
+ g_array_set_size(process->execution_stack, depth - 1);
process->state = &g_array_index(process->execution_stack, LttvExecutionState,
depth - 2);
process->state->change = tfs->parent.timestamp;
LttvProcessState *
-lttv_state_create_process(LttvTracefileState *tfs, LttvProcessState *parent,
- guint pid)
+lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
+ guint cpu, guint pid, const LttTime *timestamp)
{
LttvProcessState *process = g_new(LttvProcessState, 1);
LttvExecutionState *es;
- LttvTraceContext *tc;
-
- LttvTraceState *tcs;
+ LttvTraceContext *tc = (LttvTraceContext*)tcs;
char buffer[128];
- tc = tfs->parent.t_context;
- tcs = (LttvTraceState *)tc;
-
process->pid = pid;
- process->last_cpu = tfs->cpu_name;
- process->last_cpu_index = ((LttvTracefileContext*)tfs)->index;
- g_warning("Process %u, core %p", process->pid, process);
+ process->cpu = cpu;
+ //process->last_cpu = tfs->cpu_name;
+ //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
+ g_info("Process %u, core %p", process->pid, process);
g_hash_table_insert(tcs->processes, process, process);
if(parent) {
process->ppid = parent->pid;
process->name = parent->name;
- process->creation_time = tfs->parent.timestamp;
+ process->creation_time = *timestamp;
}
/* No parent. This process exists but we are missing all information about
process->creation_time = ltt_time_zero;
}
- process->insertion_time = tfs->parent.timestamp;
+ process->insertion_time = *timestamp;
sprintf(buffer,"%d-%lu.%lu",pid, process->creation_time.tv_sec,
process->creation_time.tv_nsec);
process->pid_time = g_quark_from_string(buffer);
- process->last_cpu = tfs->cpu_name;
- process->last_cpu_index = ((LttvTracefileContext*)tfs)->index;
+ process->cpu = cpu;
+ //process->last_cpu = tfs->cpu_name;
+ //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
process->execution_stack = g_array_sized_new(FALSE, FALSE,
sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
- g_array_set_size(process->execution_stack, 1);
+ process->execution_stack = g_array_set_size(process->execution_stack, 1);
es = process->state = &g_array_index(process->execution_stack,
LttvExecutionState, 0);
es->t = LTTV_STATE_USER_MODE;
es->n = LTTV_STATE_SUBMODE_NONE;
- es->entry = tfs->parent.timestamp;
- g_assert(tfs->parent.timestamp.tv_sec != 0);
- es->change = tfs->parent.timestamp;
+ es->entry = *timestamp;
+ //g_assert(timestamp->tv_sec != 0);
+ es->change = *timestamp;
es->s = LTTV_STATE_WAIT_FORK;
return process;
}
-LttvProcessState *lttv_state_find_process(LttvTracefileState *tfs,
+LttvProcessState *lttv_state_find_process(LttvTraceState *ts, guint cpu,
guint pid)
{
LttvProcessState key;
LttvProcessState *process;
- LttvTraceState* ts = (LttvTraceState*)tfs->parent.t_context;
-
key.pid = pid;
- key.last_cpu = tfs->cpu_name;
+ key.cpu = cpu;
process = g_hash_table_lookup(ts->processes, &key);
return process;
}
LttvProcessState *
-lttv_state_find_process_or_create(LttvTracefileState *tfs, guint pid)
+lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid,
+ LttTime *timestamp)
{
- LttvProcessState *process = lttv_state_find_process(tfs, pid);
-
- if(unlikely(process == NULL)) process = lttv_state_create_process(tfs, NULL, pid);
+ LttvProcessState *process = lttv_state_find_process(ts, cpu, pid);
+
+ /* Put ltt_time_zero creation time for unexisting processes */
+ if(unlikely(process == NULL)) process = lttv_state_create_process(ts,
+ NULL, cpu, pid, timestamp);
return process;
}
LttvProcessState key;
key.pid = process->pid;
- key.last_cpu = process->last_cpu;
+ key.cpu = process->cpu;
g_hash_table_remove(ts->processes, &key);
g_array_free(process->execution_stack, TRUE);
g_free(process);
static gboolean syscall_entry(void *hook_data, void *call_data)
{
- LttField *f = ((LttvTraceHook *)hook_data)->f1;
-
LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ LttField *f = thf->f1;
LttvExecutionSubmode submode;
submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
- ltt_event_get_unsigned(s->parent.e, f)];
+ ltt_event_get_unsigned(e, f)];
push_state(s, LTTV_STATE_SYSCALL, submode);
return FALSE;
}
static gboolean trap_entry(void *hook_data, void *call_data)
{
- LttField *f = ((LttvTraceHook *)hook_data)->f1;
-
LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ LttField *f = thf->f1;
LttvExecutionSubmode submode;
submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[
- ltt_event_get_unsigned(s->parent.e, f)];
+ ltt_event_get_unsigned(e, f)];
push_state(s, LTTV_STATE_TRAP, submode);
return FALSE;
}
static gboolean irq_entry(void *hook_data, void *call_data)
{
- LttField *f = ((LttvTraceHook *)hook_data)->f1;
-
LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ guint8 fac_id = ltt_event_facility_id(e);
+ guint8 ev_id = ltt_event_eventtype_id(e);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
+ g_assert(thf->f1 != NULL);
+ // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
+ LttField *f = thf->f1;
LttvExecutionSubmode submode;
submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[
- ltt_event_get_unsigned(s->parent.e, f)];
+ ltt_event_get_unsigned(e, f)];
/* Do something with the info about being in user or system mode when int? */
push_state(s, LTTV_STATE_IRQ, submode);
static gboolean schedchange(void *hook_data, void *call_data)
{
- LttvTraceHook *h = (LttvTraceHook *)hook_data;
-
LttvTracefileState *s = (LttvTracefileState *)call_data;
-
- guint pid_in, pid_out, state_out;
-
- pid_in = ltt_event_get_unsigned(s->parent.e, h->f1);
- pid_out = ltt_event_get_unsigned(s->parent.e, h->f2);
- state_out = ltt_event_get_unsigned(s->parent.e, h->f3);
-
- if(likely(s->process != NULL)) {
+ guint cpu = ltt_tracefile_num(s->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvProcessState *process = ts->running_process[cpu];
+
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ guint pid_in, pid_out;
+ gint state_out;
+
+ pid_out = ltt_event_get_unsigned(e, thf->f1);
+ pid_in = ltt_event_get_unsigned(e, thf->f2);
+ state_out = ltt_event_get_int(e, thf->f3);
+
+ if(likely(process != NULL)) {
/* We could not know but it was not the idle process executing.
This should only happen at the beginning, before the first schedule
is missing. It is not obvious how we could, after the fact, compensate
the wrongly attributed statistics. */
- if(unlikely(s->process->pid != pid_out)) {
- g_assert(s->process->pid == 0);
- }
+ //This test only makes sense once the state is known and if there is no
+ //missing events.
+ //if(unlikely(process->pid != pid_out)) {
+ // g_assert(process->pid == 0);
+ //}
- if(unlikely(s->process->state->s == LTTV_STATE_EXIT)) {
- s->process->state->s = LTTV_STATE_ZOMBIE;
+ if(unlikely(process->state->s == LTTV_STATE_EXIT)) {
+ process->state->s = LTTV_STATE_ZOMBIE;
} else {
- if(unlikely(state_out == 0)) s->process->state->s = LTTV_STATE_WAIT_CPU;
- else s->process->state->s = LTTV_STATE_WAIT;
+ 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, s->process);
+ // exit_process(s, process);
- s->process->state->change = s->parent.timestamp;
+ process->state->change = s->parent.timestamp;
}
- s->process = lttv_state_find_process_or_create(s, pid_in);
- s->process->state->s = LTTV_STATE_RUN;
- s->process->last_cpu = s->cpu_name;
- s->process->last_cpu_index = ((LttvTracefileContext*)s)->index;
- s->process->state->change = s->parent.timestamp;
+ process = ts->running_process[cpu] =
+ lttv_state_find_process_or_create(
+ (LttvTraceState*)s->parent.t_context,
+ cpu, pid_in,
+ &s->parent.timestamp);
+ process->state->s = LTTV_STATE_RUN;
+ process->cpu = cpu;
+ // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
+ process->state->change = s->parent.timestamp;
return FALSE;
}
-
-static gboolean process_fork(LttvTraceHook *trace_hook, LttvTracefileState *s)
+static gboolean process_fork(void *hook_data, void *call_data)
{
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
LttField *f;
+ guint parent_pid;
guint child_pid;
LttvProcessState *zombie_process;
+ guint cpu = ltt_tracefile_num(s->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvProcessState *process = ts->running_process[cpu];
+
+ /* Parent PID */
+ f = thf->f1;
+ parent_pid = ltt_event_get_unsigned(e, f);
/* Child PID */
- f = trace_hook->f2;
- child_pid = ltt_event_get_unsigned(s->parent.e, f);
+ f = thf->f2;
+ child_pid = ltt_event_get_unsigned(e, f);
- zombie_process = lttv_state_find_process(s, child_pid);
+ zombie_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
if(unlikely(zombie_process != NULL)) {
/* Reutilisation of PID. Only now we are sure that the old PID
- * has been released. FIXME : sould know when release_task happens instead.
+ * has been released. FIXME : should know when release_task happens instead.
*/
exit_process(s, zombie_process);
}
- g_assert(s->process->pid != child_pid);
- lttv_state_create_process(s, s->process, child_pid);
+ g_assert(process->pid != child_pid);
+ // FIXME : Add this test in the "known state" section
+ // g_assert(process->pid == parent_pid);
+ lttv_state_create_process(ts, process, cpu, child_pid, &s->parent.timestamp);
return FALSE;
}
-static gboolean process_exit(LttvTraceHook *trace_hook, LttvTracefileState *s)
+static gboolean process_exit(void *hook_data, void *call_data)
{
- if(likely(s->process != NULL)) {
- s->process->state->s = LTTV_STATE_EXIT;
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ LttField *f;
+ guint pid;
+ guint cpu = ltt_tracefile_num(s->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvProcessState *process = ts->running_process[cpu];
+
+ pid = ltt_event_get_unsigned(e, thf->f1);
+
+ // FIXME : Add this test in the "known state" section
+ // g_assert(process->pid == pid);
+
+ if(likely(process != NULL)) {
+ process->state->s = LTTV_STATE_EXIT;
}
return FALSE;
}
-gboolean process(void *hook_data, void *call_data)
+static gboolean process_free(void *hook_data, void *call_data)
{
- LttvTraceHook *trace_hook = (LttvTraceHook *)hook_data;
- LttField *f = trace_hook->f1;
-
LttvTracefileState *s = (LttvTracefileState *)call_data;
-
- guint sub_id = ltt_event_get_unsigned(s->parent.e, f);
+ LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ guint release_pid;
+ LttvProcessState *process;
- /* CHECK : do not hardcode the sub_id values here ? */
- if(sub_id == 2) {
- return process_fork(trace_hook, s);
- } else if(sub_id == 3) {
- return process_exit(trace_hook, s);
+ /* PID of the process to release */
+ release_pid = ltt_event_get_unsigned(e, thf->f1);
+
+ process = lttv_state_find_process(ts, ANY_CPU, release_pid);
+
+ if(likely(process != NULL)) {
+ /* release_task is happening at kernel level : we can now safely release
+ * the data structure of the process */
+ exit_process(s, process);
}
- return 0;
+
+ return FALSE;
}
gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
{
LttvTraceset *traceset = self->parent.ts;
- guint i, j, k, nb_trace, nb_tracefile;
+ guint i, j, k, l, nb_trace, nb_tracefile;
LttvTraceState *ts;
GArray *hooks;
- LttvTraceHook hook;
+ LttvTraceHookByFacility *thf;
+
+ LttvTraceHook *hook;
LttvAttributeValue val;
+ gint ret;
+
nb_trace = lttv_traceset_number(traceset);
for(i = 0 ; i < nb_trace ; i++) {
ts = (LttvTraceState *)self->parent.traces[i];
/* Find the eventtype id for the following events and register the
associated by id hooks. */
- hooks = g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
- g_array_set_size(hooks, 8);
-
- lttv_trace_find_hook(ts->parent.t, "core","syscall_entry","syscall_id",
- NULL, NULL, syscall_entry, &g_array_index(hooks, LttvTraceHook, 0));
-
- lttv_trace_find_hook(ts->parent.t, "core", "syscall_exit", NULL, NULL,
- NULL, syscall_exit, &g_array_index(hooks, LttvTraceHook, 1));
-
- lttv_trace_find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
- NULL, NULL, trap_entry, &g_array_index(hooks, LttvTraceHook, 2));
-
- lttv_trace_find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL, NULL,
- trap_exit, &g_array_index(hooks, LttvTraceHook, 3));
-
- lttv_trace_find_hook(ts->parent.t, "core", "irq_entry", "irq_id", NULL,
- NULL, irq_entry, &g_array_index(hooks, LttvTraceHook, 4));
+ hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 10);
+ hooks = g_array_set_size(hooks, 10);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_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,
+ 0, 0, 0,
+ syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
+ LTT_FIELD_TRAP_ID, 0, 0,
+ trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, 2));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
+ 0, 0, 0,
+ trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, 3));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
+ LTT_FIELD_IRQ_ID, 0, 0,
+ irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 4));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
+ 0, 0, 0,
+ irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 5));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
+ LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
+ schedchange, NULL, &g_array_index(hooks, LttvTraceHook, 6));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
+ LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0,
+ process_fork, NULL, &g_array_index(hooks, LttvTraceHook, 7));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
+ LTT_FIELD_PID, 0, 0,
+ process_exit, NULL, &g_array_index(hooks, LttvTraceHook, 8));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
+ LTT_FIELD_PID, 0, 0,
+ process_free, NULL, &g_array_index(hooks, LttvTraceHook, 9));
+ g_assert(!ret);
- lttv_trace_find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL, NULL,
- irq_exit, &g_array_index(hooks, LttvTraceHook, 5));
- lttv_trace_find_hook(ts->parent.t, "core", "schedchange", "in", "out",
- "out_state", schedchange, &g_array_index(hooks, LttvTraceHook, 6));
-
- lttv_trace_find_hook(ts->parent.t, "core", "process", "event_sub_id",
- "event_data1", "event_data2", process,
- &g_array_index(hooks, LttvTraceHook, 7));
-
-#if 0
- lttv_trace_find_hook(ts->parent.t, "core", "process_fork", "child_pid",
- NULL, NULL, process_fork, &g_array_index(hooks, LttvTraceHook, 7));
-
- lttv_trace_find_hook(ts->parent.t, "core", "process_exit", NULL, NULL,
- NULL, process_exit, &g_array_index(hooks, LttvTraceHook, 8));
-#endif //0
/* Add these hooks to each event_by_id hooks list */
- nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
- ltt_trace_per_cpu_tracefile_number(ts->parent.t);
+ nb_tracefile = ts->parent.tracefiles->len;
for(j = 0 ; j < nb_tracefile ; j++) {
- tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
+ tfs =
+ LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
+ LttvTracefileContext*, j));
for(k = 0 ; k < hooks->len ; k++) {
- hook = g_array_index(hooks, LttvTraceHook, k);
- lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
- hook.id), hook.h, &g_array_index(hooks, LttvTraceHook, k), LTTV_PRIO_STATE);
+ hook = &g_array_index(hooks, LttvTraceHook, k);
+ for(l=0;l<hook->fac_list->len;l++) {
+ thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
+ lttv_hooks_add(
+ lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
+ thf->h,
+ thf,
+ LTTV_PRIO_STATE);
+ }
}
}
lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
{
LttvTraceset *traceset = self->parent.ts;
- guint i, j, k, nb_trace, nb_tracefile;
+ guint i, j, k, l, nb_trace, nb_tracefile;
LttvTraceState *ts;
GArray *hooks;
- LttvTraceHook hook;
+ LttvTraceHook *hook;
+
+ LttvTraceHookByFacility *thf;
LttvAttributeValue val;
/* Remove these hooks from each event_by_id hooks list */
- nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
- ltt_trace_per_cpu_tracefile_number(ts->parent.t);
+ nb_tracefile = ts->parent.tracefiles->len;
for(j = 0 ; j < nb_tracefile ; j++) {
- tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
+ tfs =
+ LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
+ LttvTracefileContext*, j));
for(k = 0 ; k < hooks->len ; k++) {
- hook = g_array_index(hooks, LttvTraceHook, k);
- lttv_hooks_remove_data(
- lttv_hooks_by_id_find(tfs->parent.event_by_id,
- hook.id), hook.h, &g_array_index(hooks, LttvTraceHook, k));
+ hook = &g_array_index(hooks, LttvTraceHook, k);
+ for(l=0;l<hook->fac_list->len;l++) {
+ thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
+
+ lttv_hooks_remove_data(
+ lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
+ thf->h,
+ thf);
+ }
}
}
+ for(k = 0 ; k < hooks->len ; k++)
+ lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k));
g_array_free(hooks, TRUE);
}
}
+static guint test_event_count = 0;
+static gboolean state_save_event_hook(void *hook_data, void *call_data)
+{
+ guint *event_count = (guint*)hook_data;
+
+ test_event_count++;
+ /* Only save at LTTV_STATE_SAVE_INTERVAL */
+ if(likely((*event_count)++ < LTTV_STATE_SAVE_INTERVAL))
+ return FALSE;
+ else
+ *event_count = 0;
+
+ LttvTracefileState *self = (LttvTracefileState *)call_data;
+ LttvTracefileState *tfcs;
+
+ LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
+
+ LttEventPosition *ep;
+
+ guint i;
+
+ LttTracefile *tf;
+
+ LttvAttribute *saved_states_tree, *saved_state_tree;
+
+ LttvAttributeValue value;
+
+ saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
+ LTTV_STATE_SAVED_STATES);
+ saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
+ value = lttv_attribute_add(saved_states_tree,
+ lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
+ *(value.v_gobject) = (GObject *)saved_state_tree;
+ value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
+ *(value.v_time) = self->parent.timestamp;
+ lttv_state_save(tcs, saved_state_tree);
+ g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
+ self->parent.timestamp.tv_nsec);
+
+ *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
+
+ return FALSE;
+}
+
+#if 0
static gboolean block_start(void *hook_data, void *call_data)
{
LttvTracefileState *self = (LttvTracefileState *)call_data;
LttvAttributeValue value;
ep = ltt_event_position_new();
- nb_tracefile = ltt_trace_control_tracefile_number(tcs->parent.t) +
- ltt_trace_per_cpu_tracefile_number(tcs->parent.t);
+
+ nb_tracefile = tcs->parent.tracefiles->len;
/* Count the number of events added since the last block end in any
tracefile. */
for(i = 0 ; i < nb_tracefile ; i++) {
- tfcs = (LttvTracefileState *)tcs->parent.tracefiles[i];
+ tfcs =
+ LTTV_TRACEFILE_STATE(&g_array_index(tcs->parent.tracefiles,
+ LttvTracefileContext, i));
ltt_event_position(tfcs->parent.e, ep);
ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
tcs->nb_event += nb_event - tfcs->saved_position;
*(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
return FALSE;
}
+#endif //0
-
+#if 0
static gboolean block_end(void *hook_data, void *call_data)
{
LttvTracefileState *self = (LttvTracefileState *)call_data;
return FALSE;
}
-
-
+#endif //0
+#if 0
void lttv_state_save_add_event_hooks(LttvTracesetState *self)
{
LttvTraceset *traceset = self->parent.ts;
nb_trace = lttv_traceset_number(traceset);
for(i = 0 ; i < nb_trace ; i++) {
ts = (LttvTraceState *)self->parent.traces[i];
+
lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
NULL, NULL, block_start, &hook_start);
lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
NULL, NULL, block_end, &hook_end);
- nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
- ltt_trace_per_cpu_tracefile_number(ts->parent.t);
+ nb_tracefile = ts->parent.tracefiles->len;
for(j = 0 ; j < nb_tracefile ; j++) {
- tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
+ tfs =
+ LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
+ LttvTracefileContext, j));
lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
- hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
+ hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
- hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
+ hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
+ }
+ }
+}
+#endif //0
+
+void lttv_state_save_add_event_hooks(LttvTracesetState *self)
+{
+ LttvTraceset *traceset = self->parent.ts;
+
+ guint i, j, nb_trace, nb_tracefile;
+
+ LttvTraceState *ts;
+
+ LttvTracefileState *tfs;
+
+
+ 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 = g_new(guint, 1);
+ *event_count = 0;
+
+ for(j = 0 ; j < nb_tracefile ; j++) {
+ tfs =
+ LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
+ LttvTracefileContext*, j));
+ lttv_hooks_add(tfs->parent.event,
+ state_save_event_hook,
+ event_count,
+ LTTV_PRIO_STATE);
+
}
}
}
}
+#if 0
void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
{
LttvTraceset *traceset = self->parent.ts;
nb_trace = lttv_traceset_number(traceset);
for(i = 0 ; i < nb_trace ; i++) {
ts = LTTV_TRACE_STATE(self->parent.traces[i]);
+
lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
NULL, NULL, block_start, &hook_start);
lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
NULL, NULL, block_end, &hook_end);
- nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
- ltt_trace_per_cpu_tracefile_number(ts->parent.t);
+ nb_tracefile = ts->parent.tracefiles->len;
for(j = 0 ; j < nb_tracefile ; j++) {
- tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
+ tfs =
+ LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
+ LttvTracefileContext, j));
lttv_hooks_remove_data(lttv_hooks_by_id_find(
tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
lttv_hooks_remove_data(lttv_hooks_by_id_find(
}
}
}
+#endif //0
+
+void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
+{
+ LttvTraceset *traceset = self->parent.ts;
+
+ guint i, j, nb_trace, nb_tracefile;
+
+ LttvTraceState *ts;
+
+ LttvTracefileState *tfs;
+
+
+ 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;
+
+ for(j = 0 ; j < nb_tracefile ; j++) {
+ tfs =
+ LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
+ LttvTracefileContext*, j));
+ event_count = lttv_hooks_remove(tfs->parent.event,
+ state_save_event_hook);
+
+ }
+ g_free(event_count);
+ }
+ g_info("EVENT COUNT TEST : %u", test_event_count);
+}
gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data)
{
LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
+ g_tree_destroy(self->parent.pqueue);
+ self->parent.pqueue = g_tree_new(compare_tracefile);
+
nb_trace = lttv_traceset_number(traceset);
for(i = 0 ; i < nb_trace ; i++) {
tcs = (LttvTraceState *)self->parent.traces[i];
LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
LTTV_STATE_PROCESSES = g_quark_from_string("processes");
LTTV_STATE_PROCESS = g_quark_from_string("process");
+ LTTV_STATE_RUNNING_PROCESS = g_quark_from_string("running_process");
LTTV_STATE_EVENT = g_quark_from_string("event");
LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
LTTV_STATE_TRACE_STATE_USE_COUNT =
g_quark_from_string("trace_state_use_count");
+
+
+ LTT_FACILITY_KERNEL = g_quark_from_string("kernel");
+ LTT_FACILITY_PROCESS = g_quark_from_string("process");
+
+
+ LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
+ LTT_EVENT_SYSCALL_EXIT = g_quark_from_string("syscall_exit");
+ LTT_EVENT_TRAP_ENTRY = g_quark_from_string("trap_entry");
+ LTT_EVENT_TRAP_EXIT = g_quark_from_string("trap_exit");
+ LTT_EVENT_IRQ_ENTRY = g_quark_from_string("irq_entry");
+ LTT_EVENT_IRQ_EXIT = g_quark_from_string("irq_exit");
+ LTT_EVENT_SCHEDCHANGE = g_quark_from_string("schedchange");
+ LTT_EVENT_FORK = g_quark_from_string("fork");
+ LTT_EVENT_EXIT = g_quark_from_string("exit");
+ LTT_EVENT_FREE = g_quark_from_string("free");
+
+
+ LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id");
+ LTT_FIELD_TRAP_ID = g_quark_from_string("trap_id");
+ LTT_FIELD_IRQ_ID = g_quark_from_string("irq_id");
+ LTT_FIELD_OUT = g_quark_from_string("out");
+ LTT_FIELD_IN = g_quark_from_string("in");
+ LTT_FIELD_OUT_STATE = g_quark_from_string("out_state");
+ LTT_FIELD_PARENT_PID = g_quark_from_string("parent_pid");
+ LTT_FIELD_CHILD_PID = g_quark_from_string("child_pid");
+ LTT_FIELD_PID = g_quark_from_string("pid");
+
}
static void module_destroy()