X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fstate.c;h=1a79246ee04df9ba7ec8b0a98b218cec7a79401b;hb=3e5610273f292ff00d78f85020483d6a1abbfc02;hp=808bced78ffde8ef3b37a3171e052bd0a524a97b;hpb=dc87756342c051418eccb2b7d932ffa5453c6788;p=lttv.git diff --git a/ltt/branches/poly/lttv/state.c b/ltt/branches/poly/lttv/state.c index 808bced7..1a79246e 100644 --- a/ltt/branches/poly/lttv/state.c +++ b/ltt/branches/poly/lttv/state.c @@ -1,33 +1,65 @@ #include +#include +#include +LttvInterruptType + LTTV_STATE_USER_MODE, + LTTV_STATE_SYSCALL, + LTTV_STATE_TRAP, + LTTV_STATE_IRQ; + + +LttvProcessStatus + LTTV_STATE_UNNAMED, + LTTV_STATE_WAIT_FORK, + LTTV_STATE_WAIT_CPU, + LTTV_STATE_EXIT, + LTTV_STATE_WAIT, + LTTV_STATE_RUN; + +static GQuark + LTTV_STATE_HOOKS; + +void remove_all_processes(GHashTable *processes); + +LttvProcessState *create_process(LttvTracefileState *tfs, + LttvProcessState *parent, guint pid); static void init(LttvTracesetState *self, LttvTraceset *ts) { guint i, j, nb_trace, nb_tracefile; - LttvTraceState *tc; + LttvTraceContext *tc; + + LttvTraceState *tcs; - LttvTracefileState *tfc; + LttvTracefileContext *tfc; - LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_TYPE))->init(self, ts); + LttvTracefileState *tfcs; + + LttTime timestamp = {0,0}; + + LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->init((LttvTracesetContext *)self, ts); nb_trace = lttv_traceset_number(ts); for(i = 0 ; i < nb_trace ; i++) { - tc = (LttvTraceState *)self->traces[i]; - tc->processes = g_hash_table_new(g_direct_hash, g_direct_equal); + tcs = (LttvTraceState *)tc = (LTTV_TRACESET_CONTEXT(self)->traces[i]); + tcs->processes = g_hash_table_new(g_direct_hash, g_direct_equal); nb_tracefile = ltt_trace_control_tracefile_number(tc->t); for(j = 0 ; j < nb_tracefile ; j++) { - tfc = tc->control_tracefiles[j]; - tfc->process = NULL; + tfcs = (LttvTracefileState *)tfc = tc->control_tracefiles[j]; + tfc->timestamp = timestamp; + tfcs->process = create_process(tfcs, NULL,0); } nb_tracefile = ltt_trace_per_cpu_tracefile_number(tc->t); for(j = 0 ; j < nb_tracefile ; j++) { - tfc = tc->per_cpu_tracefiles[j]; - tfc->process = NULL; + tfcs = (LttvTracefileState *)tfc = tc->per_cpu_tracefiles[j]; + tfc->timestamp = timestamp; + tfcs->process = create_process(tfcs, NULL,0); } } } @@ -38,38 +70,65 @@ fini(LttvTracesetState *self) { guint i, j, nb_trace, nb_tracefile; - LttvTraceState *tc; + LttvTraceState *tcs; - LttvTracefileState *tfc; + LttvTracefileState *tfcs; - nb_trace = lttv_traceset_number(ts); + nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts); for(i = 0 ; i < nb_trace ; i++) { - tc = (LttvTraceState *)self->traces[i]; - remove_all_processes(tc->processes); - g_hash_table_destroy(tc->processes); + tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]); + remove_all_processes(tcs->processes); + g_hash_table_destroy(tcs->processes); } - LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_TYPE))->fini(self); + LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->fini((LttvTracesetContext *)self); } -LttvTracesetContext * +static LttvTracesetContext * new_traceset_context(LttvTracesetContext *self) { - return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE)); + return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL)); } -LttvTraceContext * +static LttvTraceContext * new_trace_context(LttvTracesetContext *self) { - return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE)); + return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL)); } -LttvTracefileContext * +static LttvTracefileContext * new_tracefile_context(LttvTracesetContext *self) { - return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE)); + return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL)); +} + + +static void +traceset_state_instance_init (GTypeInstance *instance, gpointer g_class) +{ +} + + +static void +traceset_state_finalize (LttvTracesetState *self) +{ + G_OBJECT_CLASS(g_type_class_peek_parent(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self))))->finalize(G_OBJECT(self)); +} + + +static void +traceset_state_class_init (LttvTracesetContextClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS(klass); + + gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize; + klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init; + klass->fini = (void (*)(LttvTracesetContext *self))fini; + klass->new_traceset_context = new_traceset_context; + klass->new_trace_context = new_trace_context; + klass->new_tracefile_context = new_tracefile_context; } @@ -82,12 +141,12 @@ lttv_traceset_state_get_type(void) sizeof (LttvTracesetStateClass), NULL, /* base_init */ NULL, /* base_finalize */ - traceset_state_class_init, /* class_init */ + (GClassInitFunc) traceset_state_class_init, /* class_init */ NULL, /* class_finalize */ NULL, /* class_data */ sizeof (LttvTracesetContext), 0, /* n_preallocs */ - traceset_state_instance_init /* instance_init */ + (GInstanceInitFunc) traceset_state_instance_init /* instance_init */ }; type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType", @@ -98,29 +157,24 @@ lttv_traceset_state_get_type(void) static void -traceset_state_instance_init (GTypeInstance *instance, gpointer g_class) +trace_state_instance_init (GTypeInstance *instance, gpointer g_class) { } static void -traceset_context_finalize (LttvTracesetContext *self) +trace_state_finalize (LttvTraceState *self) { - G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_TYPE))->finalize(self); + G_OBJECT_CLASS(g_type_class_peek_parent(g_type_class_peek_parent(LTTV_TRACE_STATE_GET_CLASS(self))))->finalize(G_OBJECT(self)); } static void -traceset_state_class_init (LttvTracesetContextClass *klass) +trace_state_class_init (LttvTraceContextClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS(klass); - gobject_class->finalize = traceset_state_finalize; - klass->init = init; - klass->fini = fini; - klass->new_traceset_context = new_traceset_context; - klass->new_trace_context = new_trace_context; - klass->new_tracefile_context = new_tracefile_context; + gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize; } @@ -133,12 +187,12 @@ lttv_trace_state_get_type(void) sizeof (LttvTraceStateClass), NULL, /* base_init */ NULL, /* base_finalize */ - trace_state_class_init, /* class_init */ + (GClassInitFunc) trace_state_class_init, /* class_init */ NULL, /* class_finalize */ NULL, /* class_data */ - sizeof (LttvTracesetState), + sizeof (LttvTraceState), 0, /* n_preallocs */ - trace_state_instance_init /* instance_init */ + (GInstanceInitFunc) trace_state_instance_init /* instance_init */ }; type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE, @@ -149,24 +203,24 @@ lttv_trace_state_get_type(void) static void -trace_state_instance_init (GTypeInstance *instance, gpointer g_class) +tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class) { } static void -trace_state_finalize (LttvTraceContext *self) +tracefile_state_finalize (LttvTracefileState *self) { - G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACE_STATE_TYPE))->finalize(self); + G_OBJECT_CLASS(g_type_class_peek_parent(g_type_class_peek_parent(LTTV_TRACEFILE_STATE_GET_CLASS(self))))->finalize(G_OBJECT(self)); } static void -trace_state_class_init (LttvTraceContextClass *klass) +tracefile_state_class_init (LttvTracefileStateClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS(klass); - gobject_class->finalize = trace_state_finalize; + gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize; } @@ -179,12 +233,12 @@ lttv_tracefile_state_get_type(void) sizeof (LttvTracefileStateClass), NULL, /* base_init */ NULL, /* base_finalize */ - tracefile_state_class_init, /* class_init */ + (GClassInitFunc) tracefile_state_class_init, /* class_init */ NULL, /* class_finalize */ NULL, /* class_data */ sizeof (LttvTracefileState), 0, /* n_preallocs */ - tracefile_state_instance_init /* instance_init */ + (GInstanceInitFunc) tracefile_state_instance_init /* instance_init */ }; type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE, @@ -194,33 +248,11 @@ lttv_tracefile_state_get_type(void) } -static void -tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class) -{ -} - - -static void -tracefile_state_finalize (LttvTracefileState *self) -{ - G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACEFILE_STATE_TYPE))->finalize(self); -} - - -static void -tracefile_state_class_init (LttvTracefileStateClass *klass) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS(klass); - - gobject_class->finalize = tracefile_state_finalize; -} - - struct HookData { LttField *f1; LttField *f2; LttField *f3; -} +}; struct HookId { @@ -228,12 +260,13 @@ struct HookId { guint id; void *hook_data; gboolean free_hook_data; -} +}; -void push_state(LttvTracefileState *tfs, LttvInterruptType t, guint state_id) +static void push_state(LttvTracefileState *tfs, LttvInterruptType t, + guint state_id) { - LttvInterruptState intr; + LttvInterruptState *intr; LttvProcessState *process = tfs->process; @@ -243,19 +276,23 @@ void push_state(LttvTracefileState *tfs, LttvInterruptType t, guint state_id) intr = &g_array_index(process->interrupt_stack, LttvInterruptState, depth); intr->t = t; intr->n = state_id; - intr->entry = tfs->time; - intr->last_change = tfs->time; + intr->entry = intr->last_change = LTTV_TRACEFILE_CONTEXT(tfs)->timestamp; intr->s = process->state->s; + process->state = intr; } -void pop_state(LttvTracefileState *tfs, LttvInterruptType t) +static void pop_state(LttvTracefileState *tfs, LttvInterruptType t) { LttvProcessState *process = tfs->process; guint depth = process->interrupt_stack->len - 1; - g_assert(process->state->t == t); + // g_assert(process->state->t == t); + if(process->state->t != t){ + g_warning("Different interrupt type: ignore it\n"); + return; + } g_array_remove_index(process->interrupt_stack, depth); depth--; process->state = &g_array_index(process->interrupt_stack, LttvInterruptState, @@ -263,40 +300,55 @@ void pop_state(LttvTracefileState *tfs, LttvInterruptType t) } -LttvProcessState *create_process(LttvTraceState *tfs, LttvProcessState *parent, - guint pid) +LttvProcessState *create_process(LttvTracefileState *tfs, + LttvProcessState *parent, guint pid) { LttvProcessState *process = g_new(LttvProcessState, 1); LttvInterruptState *intr; - g_hash_table_insert(tfs->ts->processes, pid, process); + LttvTraceContext *tc; + + LttvTraceState *tcs; + + LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfs); + + tcs = (LttvTraceState *)tc = tfc->t_context; + + g_hash_table_insert(tcs->processes, GUINT_TO_POINTER(pid), process); process->pid = pid; - process->birth = tfs->time; + process->birth = tfc->timestamp; process->name = LTTV_STATE_UNNAMED; process->interrupt_stack = g_array_new(FALSE, FALSE, sizeof(LttvInterruptState)); g_array_set_size(process->interrupt_stack, 1); - intr = process->state = process->interrupt_stack->data; - intr->t = LTTV_STATE_USER_MODE + intr = process->state = &g_array_index(process->interrupt_stack, + LttvInterruptState, 0); + intr->t = LTTV_STATE_USER_MODE; intr->n = 0; - intr->entry = tfs->time; - intr->last_change = tfs->time; + intr->entry = tfc->timestamp; + intr->last_change = tfc->timestamp; intr->s = LTTV_STATE_WAIT_FORK; + + return process; } -LttvProcessState *find_process(LttvTraceState *tfs, guint pid) +LttvProcessState *find_process(LttvTracefileState *tfs, guint pid) { - LttvProcessState *process = g_hash_table_lookup(tfs->processes, pid); + LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context; + LttvProcessState *process = g_hash_table_lookup(ts->processes, + GUINT_TO_POINTER(pid)); if(process == NULL) process = create_process(tfs, NULL, pid); return process; } -void exit_process(LttvTraceState *ts, LttvProcessState *process) +void exit_process(LttvTracefileState *tfs, LttvProcessState *process) { - g_hash_table_remove(tfs-ts->processes, process->pid); + LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context); + + g_hash_table_remove(ts->processes, GUINT_TO_POINTER(process->pid)); g_array_free(process->interrupt_stack, TRUE); g_free(process); } @@ -319,18 +371,19 @@ gboolean syscall_entry(void *hook_data, void *call_data) { LttField *f = (LttField *)hook_data; - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; - push_state(s, STATE_SYSCALL, ltt_event_get_unsigned(s->e, f)); + push_state(s, LTTV_STATE_SYSCALL, ltt_event_get_unsigned( + LTTV_TRACEFILE_CONTEXT(s)->e, f)); return FALSE; } gboolean syscall_exit(void *hook_data, void *call_data) { - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; - pop_state(s, STATE_SYSCALL); + pop_state(s, LTTV_STATE_SYSCALL); return FALSE; } @@ -339,18 +392,18 @@ gboolean trap_entry(void *hook_data, void *call_data) { LttField *f = (LttField *)hook_data; - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; - push_state(s, STATE_TRAP, ltt_event_get_unsigned(s->e, f)); + push_state(s, LTTV_STATE_TRAP, ltt_event_get_unsigned(s->parent.e, f)); return FALSE; } gboolean trap_exit(void *hook_data, void *call_data) { - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; - pop_state(s, STATE_TRAP); + pop_state(s, LTTV_STATE_TRAP); return FALSE; } @@ -359,19 +412,19 @@ gboolean irq_entry(void *hook_data, void *call_data) { LttField *f = (LttField *)hook_data; - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; /* Do something with the info about being in user or system mode when int? */ - push_state(s, STATE_IRQ, ltt_event_get_unsigned(s->e, f)); + push_state(s, LTTV_STATE_IRQ, ltt_event_get_unsigned(s->parent.e, f)); return FALSE; } gboolean irq_exit(void *hook_data, void *call_data) { - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; - pop_state(s, STATE_IRQ); + pop_state(s, LTTV_STATE_IRQ); return FALSE; } @@ -380,21 +433,24 @@ gboolean schedchange(void *hook_data, void *call_data) { struct HookData *h = (struct HookData *)hook_data; - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; guint pid_in, pid_out, state_out; - pid_in = ltt_event_get_int(s->e, h->f1); - pid_out = ltt_event_get_int(s->e, h->f2); - state_out = ltt_event_get_int(s->e, h->f3); + 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(s->process != NULL) { - if(state_out == 0) s->process->state->s = STATE_WAIT_CPU; - else if(s->process->state->s == STATE_EXIT) - exit_process(s->tc, s->process); - else s->process->state->s = STATE_WAIT; + if(state_out == 0) s->process->state->s = LTTV_STATE_WAIT_CPU; + else if(s->process->state->s == LTTV_STATE_EXIT) + exit_process(s, s->process); + else s->process->state->s = LTTV_STATE_WAIT; + + if(s->process->pid == 0) + s->process->pid == pid_out; } - s->process = find_process(s->tc, pid_in); - s->process->state->s = STATE_RUN; + s->process = find_process(s, pid_in); + s->process->state->s = LTTV_STATE_RUN; return FALSE; } @@ -403,22 +459,22 @@ gboolean process_fork(void *hook_data, void *call_data) { LttField *f = (LttField *)hook_data; - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; guint child_pid; - child_pid = ltt_event_get_int(s->e, f); - create_process(s->tc, s->process, child_pid); + child_pid = ltt_event_get_unsigned(s->parent.e, f); + create_process(s, s->process, child_pid); return FALSE; } gboolean process_exit(void *hook_data, void *call_data) { - struct LttvTracefileState *s = (LttvTraceFileState *)call_data; + LttvTracefileState *s = (LttvTracefileState *)call_data; if(s->process != NULL) { - s->process->state->s = STATE_EXIT; + s->process->state->s = LTTV_STATE_EXIT; } return FALSE; } @@ -450,9 +506,9 @@ find_field(LttEventType *et, const char *field) } -static HookId -find_hook(LttTrace *t, const char *facility, const char *event, - const char *field1, *field2, *field3, LttHook h) +static struct HookId +find_hook(LttTrace *t, char *facility, char *event, + char *field1, char *field2, char *field3, LttvHook h) { LttFacility *f; @@ -468,8 +524,8 @@ find_hook(LttTrace *t, const char *facility, const char *event, nb = ltt_trace_facility_find(t, facility, &pos); if(nb < 1) g_error("No %s facility", facility); - f = ltt_facility_get(t, pos); - et = ltt_facility_get_by_name(f, event); + f = ltt_trace_facility_get(t, pos); + et = ltt_facility_eventtype_get_by_name(f, event); if(et == NULL) g_error("Event %s does not exist", event); hook_id.id = ltt_eventtype_id(et); @@ -478,8 +534,8 @@ find_hook(LttTrace *t, const char *facility, const char *event, hook_data.f1 = find_field(et, field1); hook_data.f2 = find_field(et, field2); hook_data.f3 = find_field(et, field3); - if(hook_data->f1 == NULL) hook_id->hook_data = NULL; - else if(hook_data->f2 == NULL) hook_id->hook_data = hook_data->f1; + if(hook_data.f1 == NULL) hook_id.hook_data = NULL; + else if(hook_data.f2 == NULL) hook_id.hook_data = hook_data.f1; else { phook_data = g_new(struct HookData, 1); *phook_data = hook_data; @@ -492,17 +548,17 @@ find_hook(LttTrace *t, const char *facility, const char *event, lttv_state_add_event_hooks(LttvTracesetState *self) { - LttvTraceset *ts = self->ts; + LttvTraceset *traceset = self->parent.ts; - guint i, j, nb_trace, nb_control, nb_per_cpu, nb_tracefile; + guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile; LttFacility *f; LttEventType *et; - LttvTraceState *tc; + LttvTraceState *ts; - LttvTracefileState *tfc; + LttvTracefileState *tfs; void *hook_data; @@ -512,66 +568,84 @@ lttv_state_add_event_hooks(LttvTracesetState *self) LttvAttributeValue val; - nb_trace = lttv_traceset_number(ts); + nb_trace = lttv_traceset_number(traceset); for(i = 0 ; i < nb_trace ; i++) { - tc = (LttvTraceState *)self->traces[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, struct HookId); - g_array_add(hooks, find_hook(tc->t, "core","syscall_entry", "syscall_id", - NULL, NULL, syscall_entry)); - g_array_add(hooks, find_hook(tc->t, "core", "syscall_exit", NULL, NULL, - NULL, syscall_exit)); - g_array_add(hooks, find_hook(tc->t, "core", "trap_entry", "trap_id", - NULL, trap_entry)); - g_array_add(hooks, find_hook(tc->t, "core", "trap_exit", NULL, NULL, - NULL, trap_exit)); - g_array_add(hooks, find_hook(tc->t, "core", "irq_entry", "irq_id", - NULL, irq_entry)); - g_array_add(hooks, find_hook(tc->t, "core", "irq_exit", NULL, NULL, - NULL, irq_exit)); - g_array_add(hooks, find_hook(tc->t, "core", "schedchange", "in", "out", - "out_state", schedchange)); - g_array_add(hooks, find_hook(tc->t, "core", "process_fork", "child_pid", - NULL, NULL, process_fork)); - g_array_add(hooks, find_hook(tc->t, "core", "process_exit", NULL, NULL, - NULL, process_exit)); + hooks = g_array_new(FALSE, FALSE, sizeof(struct HookId)); + hook_id = find_hook(ts->parent.t, "core","syscall_entry","syscall_id", + NULL, NULL, syscall_entry); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "syscall_exit", + NULL, NULL, NULL, syscall_exit); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "trap_entry", "trap_id", + NULL, NULL, trap_entry); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL, + NULL, trap_exit); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "irq_entry", "irq_id", + NULL, NULL, irq_entry); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL, + NULL, irq_exit); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "schedchange", + "in", "out", "out_state", schedchange); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "process_fork", + "child_pid", NULL, NULL, process_fork); + g_array_append_val(hooks, hook_id); + + hook_id = find_hook(ts->parent.t, "core", "process_exit", + NULL, NULL, NULL, process_exit); + g_array_append_val(hooks, hook_id); /* Add these hooks to each before_event_by_id hooks list */ - nb_control = ltt_trace_control_tracefile_number(tc->t); - nb_per_cpu = ltt_trace_control_tracefile_number(tc->t); + nb_control = ltt_trace_control_tracefile_number(ts->parent.t); + nb_per_cpu = ltt_trace_per_cpu_tracefile_number(ts->parent.t); nb_tracefile = nb_control + nb_per_cpu; for(j = 0 ; j < nb_tracefile ; j++) { if(j < nb_control) { - tfc = tc->control_tracefiles[j]; + tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]); } else { - tfc = tc->per_cpu_tracefiles[j]; + tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j-nb_control]); } for(k = 0 ; k < hooks->len ; k++) { hook_id = g_array_index(hooks, struct HookId, k); - lttv_hooks_add(lttv_hooks_by_id_find(tfc->before_event_by_id, - hook_id->id), hook_id->h, hook_id->hook_data); + lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.before_event_by_id, + hook_id.id), hook_id.h, hook_id.hook_data); + } } - lttv_attribute_find(self->a, STATE_HOOKS, LTTV_POINTER, val); - val->v_pointer = hooks; + lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); + *(val.v_pointer) = hooks; } } lttv_state_remove_event_hooks(LttvTracesetState *self) { - LttvTraceset *ts = self->ts; + LttvTraceset *traceset = self->parent.ts; - guint i, j, nb_trace, nb_control, nb_per_cpu, nb_tracefile; + guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile; - LttvTraceState *tc; + LttvTraceState *ts; - LttvTracefileState *tfc; + LttvTracefileState *tfs; void *hook_data; @@ -581,43 +655,60 @@ lttv_state_remove_event_hooks(LttvTracesetState *self) LttvAttributeValue val; - nb_trace = lttv_traceset_number(ts); + nb_trace = lttv_traceset_number(traceset); for(i = 0 ; i < nb_trace ; i++) { - tc = (LttvTraceState *)self->traces[i]; - lttv_attribute_find(self->a, STATE_HOOKS, LTTV_POINTER, val); - hooks = val->v_pointer; + ts = LTTV_TRACE_STATE(self->parent.traces[i]); + lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); + hooks = *(val.v_pointer); /* Add these hooks to each before_event_by_id hooks list */ - nb_control = ltt_trace_control_tracefile_number(tc->t); - nb_per_cpu = ltt_trace_control_tracefile_number(tc->t); + nb_control = ltt_trace_control_tracefile_number(ts->parent.t); + nb_per_cpu = ltt_trace_per_cpu_tracefile_number(ts->parent.t); nb_tracefile = nb_control + nb_per_cpu; for(j = 0 ; j < nb_tracefile ; j++) { if(j < nb_control) { - tfc = tc->control_tracefiles[j]; + tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]); } else { - tfc = tc->per_cpu_tracefiles[j]; + tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j-nb_control]); } for(k = 0 ; k < hooks->len ; k++) { hook_id = g_array_index(hooks, struct HookId, k); - lttv_hooks_remove_data(lttv_hooks_by_id_find(tfc->before_event_by_id, - hook_id->id), hook_id->h, hook_id->hook_data); - } - for(k = 0 ; k < hooks->len ; k++) { - hook_id = g_array_index(hooks, struct HookId, k); - if(hook_id->free_hook_data) g_free(hook_id->hook_data); + lttv_hooks_remove_data( + lttv_hooks_by_id_find(tfs->parent.before_event_by_id, + hook_id.id), hook_id.h, hook_id.hook_data); + if(hook_id.free_hook_data) g_free(hook_id.hook_data); + } + // for(k = 0 ; k < hooks->len ; k++) { + // hook_id = g_array_index(hooks, struct HookId, k); + // if(hook_id.free_hook_data) g_free(hook_id.hook_data); + // } } g_array_free(hooks, TRUE); } } +void lttv_state_init(int argc, char **argv) +{ + LTTV_STATE_UNNAMED = g_quark_from_string("unnamed"); + LTTV_STATE_USER_MODE = g_quark_from_string("user mode"); + LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork"); + LTTV_STATE_SYSCALL = g_quark_from_string("system call"); + LTTV_STATE_TRAP = g_quark_from_string("trap"); + LTTV_STATE_IRQ = g_quark_from_string("irq"); + LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu"); + LTTV_STATE_EXIT = g_quark_from_string("exiting"); + LTTV_STATE_WAIT = g_quark_from_string("wait for I/O"); + LTTV_STATE_RUN = g_quark_from_string("running"); + LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks"); +} - - - +void lttv_state_destroy() +{ +}