X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=bcdf3ef8a3dbc7aa573c04fe528c571aa53fabc7;hb=61ab5e97ee7296773f7e0b8630752471c3d84e3d;hp=9450d8bce16397c230dfbd2a7bfb797b0c1854e2;hpb=032ba5da50aa4bd57b14a1cc9123a3ff579a7702;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index 9450d8bc..bcdf3ef8 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -21,12 +21,14 @@ #include #endif +#include #include #include #include #include #include #include +#include #include #include @@ -104,8 +106,7 @@ GQuark LTT_FIELD_MINOR, LTT_FIELD_MAJOR, LTT_FIELD_OPERATION, - LTT_FIELD_ACTION, - LTT_FIELD_NUM; + LTT_FIELD_ACTION; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, @@ -141,6 +142,7 @@ LttvCPUMode LTTV_CPU_IDLE, LTTV_CPU_BUSY, LTTV_CPU_IRQ, + LTTV_CPU_SOFT_IRQ, LTTV_CPU_TRAP; LttvIRQMode @@ -167,7 +169,9 @@ static GQuark LTTV_STATE_NAME_TABLES, LTTV_STATE_TRACE_STATE_USE_COUNT, LTTV_STATE_RESOURCE_CPUS, + LTTV_STATE_RESOURCE_CPUS_COUNT, LTTV_STATE_RESOURCE_IRQS, + LTTV_STATE_RESOURCE_SOFT_IRQS, LTTV_STATE_RESOURCE_BLKDEVS; static void create_max_time(LttvTraceState *tcs); @@ -251,12 +255,15 @@ static void lttv_state_free_usertraces(GHashTable *usertraces) g_hash_table_destroy(usertraces); } - +gboolean rettrue(gpointer key, gpointer value, gpointer user_data) +{ + return TRUE; +} static void restore_init_state(LttvTraceState *self) { - guint i, nb_cpus, nb_irqs; + guint i, nb_cpus, nb_irqs, nb_soft_irqs; //LttvTracefileState *tfcs; @@ -282,6 +289,7 @@ restore_init_state(LttvTraceState *self) nb_cpus = ltt_trace_get_num_cpu(self->parent.t); nb_irqs = self->nb_irqs; + nb_soft_irqs = self->nb_soft_irqs; /* Put the per cpu running_process to beginning state : process 0. */ for(i=0; i< nb_cpus; i++) { @@ -312,9 +320,15 @@ restore_init_state(LttvTraceState *self) g_array_remove_range(self->irq_states[i].mode_stack, 0, self->irq_states[i].mode_stack->len); } + /* reset softirq states */ + for(i=0; isoft_irq_states[i].running = 0; + } + /* reset bdev states */ g_hash_table_foreach(self->bdev_states, bdevstate_free_cb, NULL); - g_hash_table_steal_all(self->bdev_states); + //g_hash_table_steal_all(self->bdev_states); + g_hash_table_foreach_steal(self->bdev_states, rettrue, NULL); #if 0 nb_tracefile = self->parent.tracefiles->len; @@ -480,6 +494,10 @@ init(LttvTracesetState *self, LttvTraceset *ts) g_assert(tcs->irq_states[j].mode_stack != NULL); } + /* init soft irq stuff */ + /* the kernel has a statically fixed max of 32 softirqs */ + tcs->soft_irq_states = g_new(LttvSoftIRQState, tcs->nb_soft_irqs); + /* init bdev resource stuff */ tcs->bdev_states = g_hash_table_new(g_int_hash, g_int_equal); @@ -1153,7 +1171,7 @@ static void lttv_state_free_cpu_states(LttvCPUState *states, guint n) guint i; for(i=0; imode_stack, FALSE); + g_array_free(bds->mode_stack, TRUE); g_free(bds); } @@ -1350,6 +1387,10 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) /* save the cpu state */ { + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_CPUS_COUNT, + LTTV_UINT); + *(value.v_uint) = nb_cpus; + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_CPUS, LTTV_POINTER); *(value.v_pointer) = lttv_state_copy_cpu_states(self->cpu_states, nb_cpus); @@ -1363,6 +1404,14 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) *(value.v_pointer) = lttv_state_copy_irq_states(self->irq_states, nb_irqs); } + /* save the soft irq state */ + nb_irqs = self->nb_irqs; + { + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_SOFT_IRQS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_soft_irq_states(self->soft_irq_states, nb_irqs); + } + /* save the blkdev states */ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_BLKDEVS, LTTV_POINTER); @@ -1372,7 +1421,7 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) static void state_restore(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, pid, nb_cpus, nb_irqs; + guint i, nb_tracefile, pid, nb_cpus, nb_irqs, nb_soft_irqs; LttvTracefileState *tfcs; @@ -1431,6 +1480,13 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) lttv_state_free_irq_states(self->irq_states, nb_irqs); self->irq_states = lttv_state_copy_irq_states(*(value.v_pointer), nb_irqs); + /* restore soft irq resource states */ + nb_soft_irqs = self->nb_soft_irqs; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_SOFT_IRQS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_soft_irq_states(self->soft_irq_states, nb_soft_irqs); + self->soft_irq_states = lttv_state_copy_soft_irq_states(*(value.v_pointer), nb_soft_irqs); + /* restore the blkdev states */ type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value); g_assert(type == LTTV_POINTER); @@ -1478,7 +1534,7 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) static void state_saved_free(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, nb_cpus; + guint i, nb_tracefile, nb_cpus, nb_irqs; LttvTracefileState *tfcs; @@ -1507,13 +1563,31 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container) lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES); /* Free 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); g_free(running_process); + /* free cpu resource states */ + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_CPUS_COUNT, &value); + g_assert(type == LTTV_UINT); + nb_cpus = *value.v_uint; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_CPUS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_cpu_states(*(value.v_pointer), nb_cpus); + + /* free irq resource states */ + nb_irqs = self->nb_irqs; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_IRQS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_irq_states(*(value.v_pointer), nb_irqs); + + /* free the blkdev states */ + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_blkdev_hashtable(*(value.v_pointer)); + nb_tracefile = self->parent.tracefiles->len; for(i = 0 ; i < nb_tracefile ; i++) { @@ -1632,13 +1706,14 @@ create_name_tables(LttvTraceState *tcs) hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 1); if(!lttv_trace_find_hook(tcs->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, FIELD_ARRAY(LTT_FIELD_SYSCALL_ID), NULL, NULL, &hooks)) { // th = lttv_trace_hook_get_first(&th); // -// t = ltt_field_type(th->f1); +// t = ltt_field_type(lttv_trace_get_hook_field(th, 0)); // nb = ltt_type_element_number(t); // // name_tables->syscall_names = g_new(GQuark, nb); @@ -1654,6 +1729,7 @@ create_name_tables(LttvTraceState *tcs) // } // } + name_tables->nb_syscalls = 256; name_tables->syscall_names = g_new(GQuark, 256); for(i = 0 ; i < 256 ; i++) { g_string_printf(fe_name, "syscall %d", i); @@ -1666,13 +1742,14 @@ create_name_tables(LttvTraceState *tcs) lttv_trace_hook_remove_all(&hooks); if(!lttv_trace_find_hook(tcs->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_TRAP_ENTRY, FIELD_ARRAY(LTT_FIELD_TRAP_ID), NULL, NULL, &hooks)) { // th = lttv_trace_hook_get_first(&th); // -// t = ltt_field_type(th->f1); +// t = ltt_field_type(lttv_trace_get_hook_field(th, 0)); // //nb = ltt_type_element_number(t); // // name_tables->trap_names = g_new(GQuark, nb); @@ -1694,6 +1771,7 @@ create_name_tables(LttvTraceState *tcs) lttv_trace_hook_remove_all(&hooks); if(!lttv_trace_find_hook(tcs->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY, FIELD_ARRAY(LTT_FIELD_IRQ_ID), NULL, NULL, &hooks)) { @@ -1723,9 +1801,10 @@ create_name_tables(LttvTraceState *tcs) } */ - name_tables->nb_softirqs = 256; - name_tables->soft_irq_names = g_new(GQuark, 256); - for(i = 0 ; i < 256 ; i++) { + /* the kernel is limited to 32 statically defined softirqs */ + name_tables->nb_softirqs = 32; + name_tables->soft_irq_names = g_new(GQuark, name_tables->nb_softirqs); + for(i = 0 ; i < name_tables->nb_softirqs ; i++) { g_string_printf(fe_name, "softirq %d", i); name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str); } @@ -1754,7 +1833,7 @@ get_name_tables(LttvTraceState *tcs) tcs->irq_names = name_tables->irq_names; tcs->soft_irq_names = name_tables->soft_irq_names; tcs->nb_irqs = name_tables->nb_irqs; - tcs->nb_softirqs = name_tables->nb_softirqs; + tcs->nb_soft_irqs = name_tables->nb_softirqs; } @@ -2111,7 +2190,7 @@ lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid, * the parent waits for its child terminaison, but may also happen in special * cases in the child's exit : when the parent ignores its children SIGCCHLD or * has the flag SA_NOCLDWAIT. It can also happen when the child is part - * of a killed thread ground, but isn't the leader. + * of a killed thread group, but isn't the leader. */ static void exit_process(LttvTracefileState *tfs, LttvProcessState *process) { @@ -2150,7 +2229,7 @@ static gboolean syscall_entry(void *hook_data, void *call_data) LttvProcessState *process = ts->running_process[cpu]; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHook *th = (LttvTraceHook *)hook_data; - struct marker_field *f = th->f1; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; @@ -2193,7 +2272,7 @@ static gboolean trap_entry(void *hook_data, void *call_data) LttvTracefileState *s = (LttvTracefileState *)call_data; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHook *th = (LttvTraceHook *)hook_data; - struct marker_field *f = th->f1; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; @@ -2237,8 +2316,7 @@ static gboolean irq_entry(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); //guint8 ev_id = ltt_event_eventtype_id(e); LttvTraceHook *th = (LttvTraceHook *)hook_data; - g_assert(th->f1 != NULL); - struct marker_field *f = th->f1; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; guint64 irq = ltt_event_get_long_unsigned(e, f); @@ -2270,12 +2348,20 @@ static gboolean irq_entry(void *hook_data, void *call_data) static gboolean soft_irq_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; + guint softirq = s->cpu_state->last_soft_irq; pop_state(s, LTTV_STATE_SOFT_IRQ); - return FALSE; -} + /* update softirq status */ + if(ts->soft_irq_states[softirq].running) + ts->soft_irq_states[softirq].running--; + + /* update cpu status */ + cpu_pop_mode(s->cpu_state); + return FALSE; +} static gboolean irq_exit(void *hook_data, void *call_data) { @@ -2296,15 +2382,15 @@ static gboolean irq_exit(void *hook_data, void *call_data) static gboolean soft_irq_entry(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); //guint8 ev_id = ltt_event_eventtype_id(e); LttvTraceHook *th = (LttvTraceHook *)hook_data; - g_assert(th->f1 != NULL); - struct marker_field *f = th->f1; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; guint64 softirq = ltt_event_get_long_unsigned(e, f); - guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_softirqs; + guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_soft_irqs; if(softirq < nb_softirqs) { submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq]; @@ -2318,6 +2404,14 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data) /* Do something with the info about being in user or system mode when int? */ push_state(s, LTTV_STATE_SOFT_IRQ, submode); + + /* update cpu status */ + cpu_push_mode(s->cpu_state, LTTV_CPU_SOFT_IRQ); + + /* update softirq status */ + s->cpu_state->last_soft_irq = softirq; + ts->soft_irq_states[softirq].running++; + return FALSE; } @@ -2329,8 +2423,9 @@ static gboolean enum_interrupt(void *hook_data, void *call_data) //guint8 ev_id = ltt_event_eventtype_id(e); LttvTraceHook *th = (LttvTraceHook *)hook_data; - GQuark action = g_quark_from_string(ltt_event_get_string(e, th->f1)); - guint irq = ltt_event_get_long_unsigned(e, th->f2); + GQuark action = g_quark_from_string(ltt_event_get_string(e, + lttv_trace_get_hook_field(th, 0))); + guint irq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1)); ts->irq_names[irq] = action; @@ -2346,9 +2441,12 @@ static gboolean bdev_request_issue(void *hook_data, void *call_data) //guint8 ev_id = ltt_event_eventtype_id(e); LttvTraceHook *th = (LttvTraceHook *)hook_data; - guint major = ltt_event_get_long_unsigned(e, th->f1); - guint minor = ltt_event_get_long_unsigned(e, th->f2); - guint oper = ltt_event_get_long_unsigned(e, th->f3); + guint major = ltt_event_get_long_unsigned(e, + lttv_trace_get_hook_field(th, 0)); + guint minor = ltt_event_get_long_unsigned(e, + lttv_trace_get_hook_field(th, 1)); + guint oper = ltt_event_get_long_unsigned(e, + lttv_trace_get_hook_field(th, 2)); guint16 devcode = MKDEV(major,minor); /* have we seen this block device before? */ @@ -2369,9 +2467,12 @@ static gboolean bdev_request_complete(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHook *th = (LttvTraceHook *)hook_data; - guint major = ltt_event_get_long_unsigned(e, th->f1); - guint minor = ltt_event_get_long_unsigned(e, th->f2); - //guint oper = ltt_event_get_long_unsigned(e, th->f3); + guint major = ltt_event_get_long_unsigned(e, + lttv_trace_get_hook_field(th, 0)); + guint minor = ltt_event_get_long_unsigned(e, + lttv_trace_get_hook_field(th, 1)); + //guint oper = ltt_event_get_long_unsigned(e, + // lttv_trace_get_hook_field(th, 2)); guint16 devcode = MKDEV(major,minor); /* have we seen this block device before? */ @@ -2393,7 +2494,7 @@ static void push_function(LttvTracefileState *tfs, guint64 funcptr) guint depth = process->user_stack->len; - process->user_stack = + process->user_stack = g_array_set_size(process->user_stack, depth + 1); new_func = &g_array_index(process->user_stack, guint64, depth); @@ -2441,8 +2542,7 @@ static gboolean function_entry(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); //guint8 ev_id = ltt_event_eventtype_id(e); LttvTraceHook *th = (LttvTraceHook *)hook_data; - g_assert(th->f1 != NULL); - struct marker_field *f = th->f1; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); guint64 funcptr = ltt_event_get_long_unsigned(e, f); push_function(s, funcptr); @@ -2455,8 +2555,7 @@ static gboolean function_exit(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); //guint8 ev_id = ltt_event_eventtype_id(e); LttvTraceHook *th = (LttvTraceHook *)hook_data; - g_assert(th->f1 != NULL); - struct marker_field *f = th->f1; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); guint64 funcptr = ltt_event_get_long_unsigned(e, f); pop_function(s, funcptr); @@ -2476,9 +2575,9 @@ static gboolean schedchange(void *hook_data, void *call_data) guint pid_in, pid_out; gint64 state_out; - pid_out = ltt_event_get_unsigned(e, th->f1); - pid_in = ltt_event_get_unsigned(e, th->f2); - state_out = ltt_event_get_long_int(e, th->f3); + pid_out = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); + pid_in = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 1)); + state_out = ltt_event_get_long_int(e, lttv_trace_get_hook_field(th, 2)); if(likely(process != NULL)) { @@ -2515,7 +2614,7 @@ static gboolean schedchange(void *hook_data, void *call_data) process->state->change = s->parent.timestamp; } - if(state_out == 32 || state_out == 128) + if(state_out == 32 || state_out == 64) exit_process(s, process); /* EXIT_DEAD || TASK_DEAD */ /* see sched.h for states */ } @@ -2534,9 +2633,18 @@ static gboolean schedchange(void *hook_data, void *call_data) /* update cpu status */ if(pid_in == 0) + /* going to idle task */ cpu_set_base_mode(s->cpu_state, LTTV_CPU_IDLE); - else + else { + /* scheduling a real task. + * we must be careful here: + * if we just schedule()'ed to a process that is + * in a trap, we must put the cpu in trap mode + */ cpu_set_base_mode(s->cpu_state, LTTV_CPU_BUSY); + if(process->state->t == LTTV_STATE_TRAP) + cpu_push_mode(s->cpu_state, LTTV_CPU_TRAP); + } return FALSE; } @@ -2554,17 +2662,21 @@ static gboolean process_fork(void *hook_data, void *call_data) LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; LttvProcessState *child_process; + struct marker_field *f; /* Parent PID */ - parent_pid = ltt_event_get_unsigned(e, th->f1); + parent_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); /* Child PID */ - child_pid = ltt_event_get_unsigned(e, th->f2); + child_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 1)); s->parent.target_pid = child_pid; /* Child TGID */ - if(th->f3) child_tgid = ltt_event_get_unsigned(e, th->f3); - else child_tgid = 0; + f = lttv_trace_get_hook_field(th, 2); + if (likely(f)) + child_tgid = ltt_event_get_unsigned(e, f); + else + child_tgid = 0; /* 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 @@ -2627,7 +2739,7 @@ static gboolean process_kernel_thread(void *hook_data, void *call_data) LttvExecutionState *es; /* PID */ - pid = (guint)ltt_event_get_long_unsigned(e, th->f1); + pid = (guint)ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0)); s->parent.target_pid = pid; process = lttv_state_find_process_or_create(ts, ANY_CPU, pid, @@ -2651,7 +2763,7 @@ static gboolean process_exit(void *hook_data, void *call_data) LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process; // = ts->running_process[cpu]; - pid = ltt_event_get_unsigned(e, th->f1); + pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); s->parent.target_pid = pid; // FIXME : Add this test in the "known state" section @@ -2674,7 +2786,7 @@ static gboolean process_free(void *hook_data, void *call_data) LttvProcessState *process; /* PID of the process to release */ - release_pid = ltt_event_get_unsigned(e, th->f1); + release_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); s->parent.target_pid = release_pid; g_assert(release_pid != 0); @@ -2723,9 +2835,11 @@ static gboolean process_exec(void *hook_data, void *call_data) #if 0//how to use a sequence that must be transformed in a string /* PID of the process to release */ - 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); + guint64 name_len = ltt_event_field_element_number(e, + lttv_trace_get_hook_field(th, 0)); + //name = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 0)); + LttField *child = ltt_event_field_element_select(e, + lttv_trace_get_hook_field(th, 0), 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); @@ -2734,7 +2848,8 @@ static gboolean process_exec(void *hook_data, void *call_data) process->name = g_quark_from_string(null_term_name); #endif //0 - process->name = g_quark_from_string(ltt_event_get_string(e, th->f1)); + process->name = g_quark_from_string(ltt_event_get_string(e, + lttv_trace_get_hook_field(th, 0))); process->brand = LTTV_STATE_UNBRANDED; //g_free(null_term_name); return FALSE; @@ -2750,7 +2865,7 @@ static gboolean thread_brand(void *hook_data, void *call_data) guint cpu = s->cpu; LttvProcessState *process = ts->running_process[cpu]; - name = ltt_event_get_string(e, th->f1); + name = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 0)); process->brand = g_quark_from_string(name); return FALSE; @@ -2839,53 +2954,45 @@ static gboolean enum_process_state(void *hook_data, void *call_data) LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; LttvProcessState *parent_process; - struct marker_field *f4, *f5, *f6, *f7, *f8; + struct marker_field *f; GQuark type, mode, submode, status; LttvExecutionState *es; guint i, nb_cpus; - struct marker_info *mi; /* PID */ - pid = ltt_event_get_unsigned(e, th->f1); + pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); s->parent.target_pid = pid; /* Parent PID */ - parent_pid = ltt_event_get_unsigned(e, th->f2); + parent_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 1)); /* Command name */ - command = ltt_event_get_string(e, th->f3); + command = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 2)); /* type */ - mi = marker_get_info_from_id(ts->parent.t, e->event_id); - f4 = marker_get_field(mi, 3); - g_assert(f4->name == LTT_FIELD_TYPE); - type = ltt_enum_string_get(ltt_field_type(f4), - ltt_event_get_unsigned(e, f4)); + f = lttv_trace_get_hook_field(th, 3); + type = ltt_enum_string_get(f, ltt_event_get_unsigned(e, f)); + + //FIXME: type is rarely used, enum must match possible types. /* mode */ - f5 = marker_get_field(mi, 4); - g_assert(f5->name == LTT_FIELD_MODE); - mode = ltt_enum_string_get(ltt_field_type(f5), - ltt_event_get_unsigned(e, f5)); + f = lttv_trace_get_hook_field(th, 4); + mode = ltt_enum_string_get(f,ltt_event_get_unsigned(e, f)); /* submode */ - f6 = marker_get_field(mi, 5); - g_assert(f6->name == LTT_FIELD_SUBMODE); - submode = ltt_enum_string_get(ltt_field_type(f6), - ltt_event_get_unsigned(e, f6)); + f = lttv_trace_get_hook_field(th, 5); + submode = ltt_enum_string_get(f, ltt_event_get_unsigned(e, f)); /* status */ - f7 = marker_get_field(mi, 6); - g_assert(f7->name == LTT_FIELD_STATUS); - status = ltt_enum_string_get(ltt_field_type(f7), - ltt_event_get_unsigned(e, f7)); + f = lttv_trace_get_hook_field(th, 6); + status = ltt_enum_string_get(f, ltt_event_get_unsigned(e, f)); /* TGID */ - f8 = marker_get_field(mi, 7); - g_assert(f8->name == LTT_FIELD_TGID); - if(f8) tgid = ltt_event_get_unsigned(e, f8); - else tgid = 0; - + f = lttv_trace_get_hook_field(th, 7); + if(f) + tgid = ltt_event_get_unsigned(e, f); + else + tgid = 0; if(pid == 0) { nb_cpus = ltt_trace_get_num_cpu(ts->parent.t); @@ -3021,9 +3128,6 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) LttvAttributeValue val; - gint ret; - gint hn; - nb_trace = lttv_traceset_number(traceset); for(i = 0 ; i < nb_trace ; i++) { ts = (LttvTraceState *)self->parent.traces[i]; @@ -3036,114 +3140,138 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) //hn = 0; lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, FIELD_ARRAY(LTT_FIELD_SYSCALL_ID), syscall_entry, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT, NULL, syscall_exit, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_TRAP_ENTRY, FIELD_ARRAY(LTT_FIELD_TRAP_ID), trap_entry, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_TRAP_EXIT, NULL, trap_exit, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY, FIELD_ARRAY(LTT_FIELD_IRQ_ID), irq_entry, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT, NULL, irq_exit, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY, FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID), soft_irq_entry, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT, NULL, soft_irq_exit, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_SCHED_SCHEDULE, FIELD_ARRAY(LTT_FIELD_PREV_PID, LTT_FIELD_NEXT_PID, LTT_FIELD_PREV_STATE), schedchange, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_PROCESS_FORK, FIELD_ARRAY(LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, LTT_FIELD_CHILD_TGID), process_fork, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_KTHREAD_CREATE, - FIELD_ARRAY(LTT_FIELD_PID) + FIELD_ARRAY(LTT_FIELD_PID), process_kernel_thread, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_PROCESS_EXIT, FIELD_ARRAY(LTT_FIELD_PID), process_exit, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_PROCESS_FREE, FIELD_ARRAY(LTT_FIELD_PID), process_free, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_FS, LTT_EVENT_EXEC, FIELD_ARRAY(LTT_FIELD_FILENAME), process_exec, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_USER_GENERIC, LTT_EVENT_THREAD_BRAND, FIELD_ARRAY(LTT_FIELD_NAME), thread_brand, NULL, &hooks); /* statedump-related hooks */ lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_LIST, LTT_EVENT_PROCESS_STATE, - FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME), + FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME, + LTT_FIELD_TYPE, LTT_FIELD_MODE, LTT_FIELD_SUBMODE, + LTT_FIELD_STATUS, LTT_FIELD_TGID), enum_process_state, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_LIST, LTT_EVENT_STATEDUMP_END, NULL, statedump_end, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_LIST, LTT_EVENT_LIST_INTERRUPT, - FIELD_ARRAY(LTT_FIELD_ACTION, LTT_FIELD_NUM), + FIELD_ARRAY(LTT_FIELD_ACTION, LTT_FIELD_IRQ_ID), enum_interrupt, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_BLOCK, LTT_EVENT_REQUEST_ISSUE, FIELD_ARRAY(LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION), bdev_request_issue, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_BLOCK, LTT_EVENT_REQUEST_COMPLETE, FIELD_ARRAY(LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION), bdev_request_complete, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY, FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), function_entry, NULL, &hooks); lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT, FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), function_exit, NULL, &hooks); @@ -3766,8 +3894,8 @@ lttv_tracefile_state_get_type(void) static void module_init() { - LTTV_STATE_UNNAMED = g_quark_from_string("UNNAMED"); - LTTV_STATE_UNBRANDED = g_quark_from_string("UNBRANDED"); + LTTV_STATE_UNNAMED = g_quark_from_string(""); + LTTV_STATE_UNBRANDED = g_quark_from_string(""); LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("MODE_UNKNOWN"); LTTV_STATE_USER_MODE = g_quark_from_string("USER_MODE"); LTTV_STATE_SYSCALL = g_quark_from_string("SYSCALL"); @@ -3798,7 +3926,9 @@ static void module_init() LTTV_STATE_TRACE_STATE_USE_COUNT = g_quark_from_string("trace_state_use_count"); LTTV_STATE_RESOURCE_CPUS = g_quark_from_string("cpu resource states"); + LTTV_STATE_RESOURCE_CPUS = g_quark_from_string("cpu count"); LTTV_STATE_RESOURCE_IRQS = g_quark_from_string("irq resource states"); + LTTV_STATE_RESOURCE_SOFT_IRQS = g_quark_from_string("soft irq resource states"); LTTV_STATE_RESOURCE_BLKDEVS = g_quark_from_string("blkdevs resource states"); @@ -3816,8 +3946,8 @@ static void module_init() 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_SOFT_IRQ_ENTRY = g_quark_from_string("soft_irq_entry"); - LTT_EVENT_SOFT_IRQ_EXIT = g_quark_from_string("soft_irq_exit"); + LTT_EVENT_SOFT_IRQ_ENTRY = g_quark_from_string("softirq_entry"); + LTT_EVENT_SOFT_IRQ_EXIT = g_quark_from_string("softirq_exit"); LTT_EVENT_SCHED_SCHEDULE = g_quark_from_string("sched_schedule"); LTT_EVENT_PROCESS_FORK = g_quark_from_string("process_fork"); LTT_EVENT_KTHREAD_CREATE = g_quark_from_string("kthread_create"); @@ -3858,12 +3988,12 @@ static void module_init() LTT_FIELD_MINOR = g_quark_from_string("minor"); LTT_FIELD_OPERATION = g_quark_from_string("direction"); LTT_FIELD_ACTION = g_quark_from_string("action"); - LTT_FIELD_NUM = g_quark_from_string("num"); LTTV_CPU_UNKNOWN = g_quark_from_string("unknown"); LTTV_CPU_IDLE = g_quark_from_string("idle"); LTTV_CPU_BUSY = g_quark_from_string("busy"); LTTV_CPU_IRQ = g_quark_from_string("irq"); + LTTV_CPU_SOFT_IRQ = g_quark_from_string("softirq"); LTTV_CPU_TRAP = g_quark_from_string("trap"); LTTV_IRQ_UNKNOWN = g_quark_from_string("unknown");