X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=05a6aa53683536d5669dbbb6072b190271f80258;hb=d88e4d7ce82657364025613b8f2ebe61192a0b03;hp=dee43252eaf4ddd1eb6c3eb838cb07e71c7c9d58;hpb=d448fce24840c50fbd998d06a7daa595859df2ff;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index dee43252..05a6aa53 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -28,6 +28,7 @@ #include #include #include +#include #define PREALLOCATED_EXECUTION_STACK 10 @@ -35,8 +36,10 @@ GQuark LTT_FACILITY_KERNEL, + LTT_FACILITY_KERNEL_ARCH, LTT_FACILITY_PROCESS, - LTT_FACILITY_FS; + LTT_FACILITY_FS, + LTT_FACILITY_STATEDUMP; /* Events Quarks */ @@ -47,11 +50,14 @@ GQuark LTT_EVENT_TRAP_EXIT, LTT_EVENT_IRQ_ENTRY, LTT_EVENT_IRQ_EXIT, + LTT_EVENT_SOFT_IRQ_ENTRY, + LTT_EVENT_SOFT_IRQ_EXIT, LTT_EVENT_SCHEDCHANGE, LTT_EVENT_FORK, LTT_EVENT_EXIT, LTT_EVENT_FREE, - LTT_EVENT_EXEC; + LTT_EVENT_EXEC, + LTT_EVENT_ENUM_PROCESS_STATE; /* Fields Quarks */ @@ -59,20 +65,26 @@ GQuark LTT_FIELD_SYSCALL_ID, LTT_FIELD_TRAP_ID, LTT_FIELD_IRQ_ID, + LTT_FIELD_SOFT_IRQ_ID, LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE, LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, LTT_FIELD_PID, - LTT_FIELD_FILENAME; + LTT_FIELD_FILENAME, + LTT_FIELD_NAME, + LTT_FIELD_MODE, + LTT_FIELD_SUBMODE, + LTT_FIELD_STATUS; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, LTTV_STATE_USER_MODE, LTTV_STATE_SYSCALL, LTTV_STATE_TRAP, - LTTV_STATE_IRQ; + LTTV_STATE_IRQ, + LTTV_STATE_SOFT_IRQ; LttvExecutionSubmode LTTV_STATE_SUBMODE_UNKNOWN, @@ -85,7 +97,8 @@ LttvProcessStatus LTTV_STATE_EXIT, LTTV_STATE_ZOMBIE, LTTV_STATE_WAIT, - LTTV_STATE_RUN; + LTTV_STATE_RUN, + LTTV_STATE_DEAD; static GQuark LTTV_STATE_TRACEFILES, @@ -188,7 +201,7 @@ restore_init_state(LttvTraceState *self) /* 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); + LTTV_STATE_UNNAMED, <t_time_zero); self->running_process[i]->state->s = LTTV_STATE_RUN; self->running_process[i]->cpu = i; } @@ -726,6 +739,7 @@ typedef struct _LttvNameTables { GQuark *syscall_names; GQuark *trap_names; GQuark *irq_names; + GQuark *soft_irq_names; } LttvNameTables; @@ -767,7 +781,7 @@ create_name_tables(LttvTraceState *tcs) } #endif //0 if(lttv_trace_find_hook(tcs->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, LTT_FIELD_SYSCALL_ID, 0, 0, NULL, NULL, &h)) return; @@ -779,20 +793,17 @@ create_name_tables(LttvTraceState *tcs) lttv_trace_hook_destroy(&h); - /* CHECK syscalls should be an enum but currently are not! name_tables->syscall_names = g_new(GQuark, nb); for(i = 0 ; i < nb ; i++) { - name_tables->syscall_names[i] = g_quark_from_string( - ltt_enum_string_get(t, i)); + name_tables->syscall_names[i] = ltt_enum_string_get(t, i); } - */ - name_tables->syscall_names = g_new(GQuark, 256); - for(i = 0 ; i < 256 ; i++) { - g_string_printf(fe_name, "syscall %d", i); - name_tables->syscall_names[i] = g_quark_from_string(fe_name->str); - } + //name_tables->syscall_names = g_new(GQuark, 256); + //for(i = 0 ; i < 256 ; i++) { + // g_string_printf(fe_name, "syscall %d", i); + // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str); + //} if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY, @@ -803,7 +814,7 @@ create_name_tables(LttvTraceState *tcs) thf = lttv_trace_hook_get_first(&h); t = ltt_field_type(thf->f1); - nb = ltt_type_element_number(t); + //nb = ltt_type_element_number(t); lttv_trace_hook_destroy(&h); @@ -830,7 +841,7 @@ create_name_tables(LttvTraceState *tcs) thf = lttv_trace_hook_get_first(&h); t = ltt_field_type(thf->f1); - nb = ltt_type_element_number(t); + //nb = ltt_type_element_number(t); lttv_trace_hook_destroy(&h); @@ -847,6 +858,20 @@ create_name_tables(LttvTraceState *tcs) name_tables->irq_names[i] = g_quark_from_string(fe_name->str); } + /* + name_tables->soft_irq_names = g_new(GQuark, nb); + for(i = 0 ; i < nb ; i++) { + name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i)); + } + */ + + name_tables->soft_irq_names = g_new(GQuark, 256); + for(i = 0 ; i < 256 ; i++) { + g_string_printf(fe_name, "softirq %d", i); + name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str); + } + + g_string_free(fe_name, TRUE); } @@ -866,6 +891,7 @@ get_name_tables(LttvTraceState *tcs) tcs->syscall_names = name_tables->syscall_names; tcs->trap_names = name_tables->trap_names; tcs->irq_names = name_tables->irq_names; + tcs->soft_irq_names = name_tables->soft_irq_names; } @@ -885,6 +911,7 @@ free_name_tables(LttvTraceState *tcs) g_free(name_tables->syscall_names); g_free(name_tables->trap_names); g_free(name_tables->irq_names); + g_free(name_tables->soft_irq_names); g_free(name_tables); } @@ -975,7 +1002,7 @@ static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t) LttvProcessState * lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, - guint cpu, guint pid, const LttTime *timestamp) + guint cpu, guint pid, GQuark name, const LttTime *timestamp) { LttvProcessState *process = g_new(LttvProcessState, 1); @@ -987,6 +1014,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, process->pid = pid; process->cpu = cpu; + process->name = name; //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); @@ -994,7 +1022,6 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, if(parent) { process->ppid = parent->pid; - process->name = parent->name; process->creation_time = *timestamp; } @@ -1004,7 +1031,6 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, else { process->ppid = 0; - process->name = LTTV_STATE_UNNAMED; process->creation_time = ltt_time_zero; } @@ -1017,7 +1043,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf); process->execution_stack = g_array_sized_new(FALSE, FALSE, sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK); - process->execution_stack = g_array_set_size(process->execution_stack, 1); + process->execution_stack = g_array_set_size(process->execution_stack, 2); es = process->state = &g_array_index(process->execution_stack, LttvExecutionState, 0); es->t = LTTV_STATE_USER_MODE; @@ -1025,6 +1051,15 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, es->entry = *timestamp; //g_assert(timestamp->tv_sec != 0); es->change = *timestamp; + es->s = LTTV_STATE_RUN; + + es = process->state = &g_array_index(process->execution_stack, + LttvExecutionState, 1); + es->t = LTTV_STATE_SYSCALL; + es->n = LTTV_STATE_SUBMODE_NONE; + es->entry = *timestamp; + //g_assert(timestamp->tv_sec != 0); + es->change = *timestamp; es->s = LTTV_STATE_WAIT_FORK; return process; @@ -1050,7 +1085,7 @@ lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid, /* Put ltt_time_zero creation time for unexisting processes */ if(unlikely(process == NULL)) process = lttv_state_create_process(ts, - NULL, cpu, pid, timestamp); + NULL, cpu, pid, LTTV_STATE_UNNAMED, timestamp); return process; } @@ -1169,6 +1204,37 @@ static gboolean irq_exit(void *hook_data, void *call_data) return FALSE; } +static gboolean soft_irq_entry(void *hook_data, void *call_data) +{ + 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))->soft_irq_names[ + 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_SOFT_IRQ, submode); + return FALSE; +} + + +static gboolean soft_irq_exit(void *hook_data, void *call_data) +{ + LttvTracefileState *s = (LttvTracefileState *)call_data; + + pop_state(s, LTTV_STATE_SOFT_IRQ); + return FALSE; +} + static gboolean schedchange(void *hook_data, void *call_data) { @@ -1202,18 +1268,16 @@ static gboolean schedchange(void *hook_data, void *call_data) if(unlikely(process->state->s == LTTV_STATE_EXIT)) { process->state->s = LTTV_STATE_ZOMBIE; + process->state->change = s->parent.timestamp; } else { if(unlikely(state_out == 0)) process->state->s = LTTV_STATE_WAIT_CPU; else process->state->s = LTTV_STATE_WAIT; - } /* FIXME : we do not remove process here, because the kernel - * still has them : they may be zombies. We need to know - * exactly when release_task is executed on the PID to - * know when the zombie is destroyed. - */ - //else - // exit_process(s, process); - - process->state->change = s->parent.timestamp; + process->state->change = s->parent.timestamp; + } + + if(state_out == 32) + exit_process(s, process); /* EXIT_DEAD */ + /* see sched.h for states */ } process = ts->running_process[cpu] = lttv_state_find_process_or_create( @@ -1232,7 +1296,6 @@ 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; @@ -1242,17 +1305,17 @@ static gboolean process_fork(void *hook_data, void *call_data) LttvProcessState *child_process; /* Parent PID */ - f = thf->f1; - parent_pid = ltt_event_get_unsigned(e, f); + parent_pid = ltt_event_get_unsigned(e, thf->f1); /* Child PID */ - f = thf->f2; - child_pid = ltt_event_get_unsigned(e, f); + child_pid = ltt_event_get_unsigned(e, thf->f2); /* Mathieu : it seems like the process might have been scheduled in before the * fork, and, in a rare case, might be the current process. This might happen - * in a SMP case where we don't have enough precision on the clocks */ -#if 0 + * in a SMP case where we don't have enough precision on the clocks. + * + * Test reenabled after precision fixes on time. (Mathieu) */ +#if 0 zombie_process = lttv_state_find_process(ts, ANY_CPU, child_pid); if(unlikely(zombie_process != NULL)) { @@ -1262,7 +1325,7 @@ static gboolean process_fork(void *hook_data, void *call_data) guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t); guint i; for(i=0; i< num_cpus; i++) { - g_assert(process != ts->running_process[i]); + g_assert(zombie_process != ts->running_process[i]); } exit_process(s, zombie_process); @@ -1273,16 +1336,21 @@ static gboolean process_fork(void *hook_data, void *call_data) // g_assert(process->pid == parent_pid); child_process = lttv_state_find_process(ts, ANY_CPU, child_pid); if(child_process == NULL) { - lttv_state_create_process(ts, process, cpu, - child_pid, &s->parent.timestamp); + child_process = lttv_state_create_process(ts, process, cpu, + child_pid, LTTV_STATE_UNNAMED, &s->parent.timestamp); } else { /* The process has already been created : due to time imprecision between - * multiple CPUs : it has been scheduled in before creation. + * multiple CPUs : it has been scheduled in before creation. Note that we + * shouldn't have this kind of imprecision. * * Simply put a correct parent. */ + g_assert(0); /* This is a problematic case : the process has been created + before the fork event */ child_process->ppid = process->pid; } + g_assert(child_process->name == LTTV_STATE_UNNAMED); + child_process->name = process->name; return FALSE; } @@ -1329,12 +1397,27 @@ static gboolean process_free(void *hook_data, void *call_data) if(likely(process != NULL)) { /* release_task is happening at kernel level : we can now safely release * the data structure of the process */ + //This test is fun, though, as it may happen that + //at time t : CPU 0 : process_free + //at time t+150ns : CPU 1 : schedule out + //Clearly due to time imprecision, we disable it. (Mathieu) + //If this weird case happen, we have no choice but to put the + //Currently running process on the cpu to 0. + //I re-enable it following time precision fixes. (Mathieu) + //Well, in the case where an process is freed by a process on another CPU + //and still scheduled, it happens that this is the schedchange that will + //drop the last reference count. Do not free it here! guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t); guint i; for(i=0; i< num_cpus; i++) { - g_assert(process != ts->running_process[i]); + //g_assert(process != ts->running_process[i]); + if(process == ts->running_process[i]) { + //ts->running_process[i] = lttv_state_find_process(ts, i, 0); + break; + } } - exit_process(s, process); + if(i == num_cpus) /* process is not scheduled */ + exit_process(s, process); } return FALSE; @@ -1347,20 +1430,114 @@ static gboolean process_exec(void *hook_data, void *call_data) LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; - gchar *name; + //gchar *name; guint cpu = ltt_tracefile_num(s->parent.tf); LttvProcessState *process = ts->running_process[cpu]; /* PID of the process to release */ - name = ltt_event_get_string(e, thf->f1); - - process->name = g_quark_from_string(name); - + guint64 name_len = ltt_event_field_element_number(e, thf->f1); + //name = ltt_event_get_string(e, thf->f1); + LttField *child = ltt_event_field_element_select(e, thf->f1, 0); + gchar *name_begin = + (gchar*)(ltt_event_data(e)+ltt_event_field_offset(e, child)); + gchar *null_term_name = g_new(gchar, name_len+1); + memcpy(null_term_name, name_begin, name_len); + null_term_name[name_len] = '\0'; + + process->name = g_quark_from_string(null_term_name); + g_free(null_term_name); return FALSE; } +static gboolean enum_process_state(void *hook_data, void *call_data) +{ + LttvTracefileState *s = (LttvTracefileState *)call_data; + LttEvent *e = ltt_tracefile_get_event(s->parent.tf); + //It's slow : optimise later by doing this before reading trace. + LttEventType *et = ltt_event_eventtype(e); + // + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + guint parent_pid; + guint pid; + gchar * command; + guint cpu = ltt_tracefile_num(s->parent.tf); + LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; + LttvProcessState *process = ts->running_process[cpu]; + LttvProcessState *parent_process; + LttField *f4, *f5, *f6; + GQuark mode, submode, status; + + /* PID */ + pid = ltt_event_get_unsigned(e, thf->f1); + /* Parent PID */ + parent_pid = ltt_event_get_unsigned(e, thf->f2); + + /* Command name */ + command = ltt_event_get_string(e, thf->f3); + + /* mode */ + f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE); + mode = ltt_enum_string_get(ltt_field_type(f4), + ltt_event_get_unsigned(e, f4)); + + /* submode */ + f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE); + submode = ltt_enum_string_get(ltt_field_type(f5), + ltt_event_get_unsigned(e, f5)); + + /* status */ + f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS); + status = ltt_enum_string_get(ltt_field_type(f6), + ltt_event_get_unsigned(e, f6)); + + /* The process might exist if a process was forked while performing the sate dump. */ + process = lttv_state_find_process(ts, ANY_CPU, pid); + if(process == NULL) { + parent_process = lttv_state_find_process(ts, ANY_CPU, parent_pid); + process = lttv_state_create_process(ts, parent_process, cpu, + pid, g_quark_from_string(command), + &s->parent.timestamp); + + /* Keep the stack bottom : a running user mode */ +#if 0 + /* Disabled because of inconsistencies in the current statedump states. */ + if(mode == LTTV_STATE_USER_MODE) { + /* Only keep the bottom */ + process->execution_stack = g_array_set_size(process->execution_stack, 1); + } else { + /* On top of it : */ + LttvExecutionState *es; + es = process->state = &g_array_index(process->execution_stack, + LttvExecutionState, 1); + es->t = mode; + es->s = status; + es->n = submode; + } +#endif //0 + /* UNKNOWN STATE */ + { + LttvExecutionState *es; + es = process->state = &g_array_index(process->execution_stack, + LttvExecutionState, 1); + es->t = LTTV_STATE_MODE_UNKNOWN; + es->s = LTTV_STATE_UNNAMED; + es->n = LTTV_STATE_SUBMODE_UNKNOWN; + } + } else { + /* The process has already been created : + * Probably was forked while dumping the process state or + * was simply scheduled in prior to get the state dump event. + */ + process->ppid = parent_pid; + process->name = g_quark_from_string(command); + /* Don't mess around with the stack, it will eventually become + * ok after the end of state dump. */ + } + + return FALSE; +} gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data) { @@ -1398,17 +1575,17 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) /* Find the eventtype id for the following events and register the associated by id hooks. */ - hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 11); - hooks = g_array_set_size(hooks, 11); + hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 14); + hooks = g_array_set_size(hooks, 14); ret = lttv_trace_find_hook(ts->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, LTT_FIELD_SYSCALL_ID, 0, 0, syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, 0)); g_assert(!ret); ret = lttv_trace_find_hook(ts->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_EXIT, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT, 0, 0, 0, syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1)); g_assert(!ret); @@ -1437,38 +1614,56 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 5)); g_assert(!ret); + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY, + LTT_FIELD_SOFT_IRQ_ID, 0, 0, + soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 6)); + g_assert(!ret); + + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT, + 0, 0, 0, + soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 7)); + 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)); + schedchange, NULL, &g_array_index(hooks, LttvTraceHook, 8)); 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)); + process_fork, NULL, &g_array_index(hooks, LttvTraceHook, 9)); 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)); + process_exit, NULL, &g_array_index(hooks, LttvTraceHook, 10)); 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)); + process_free, NULL, &g_array_index(hooks, LttvTraceHook, 11)); g_assert(!ret); ret = lttv_trace_find_hook(ts->parent.t, LTT_FACILITY_FS, LTT_EVENT_EXEC, LTT_FIELD_FILENAME, 0, 0, - process_exec, NULL, &g_array_index(hooks, LttvTraceHook, 10)); + process_exec, NULL, &g_array_index(hooks, LttvTraceHook, 12)); g_assert(!ret); + /* statedump-related hooks */ + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_STATEDUMP, LTT_EVENT_ENUM_PROCESS_STATE, + LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME, + enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, 13)); + g_assert(!ret); - + /* Add these hooks to each event_by_id hooks list */ nb_tracefile = ts->parent.tracefiles->len; @@ -1490,7 +1685,7 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) } } } - lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); + lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); *(val.v_pointer) = hooks; } } @@ -1525,7 +1720,7 @@ void lttv_state_remove_event_hooks(LttvTracesetState *self) nb_trace = lttv_traceset_number(traceset); for(i = 0 ; i < nb_trace ; i++) { ts = LTTV_TRACE_STATE(self->parent.traces[i]); - lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); + lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); hooks = *(val.v_pointer); /* Remove these hooks from each event_by_id hooks list */ @@ -1838,7 +2033,7 @@ void lttv_state_save_remove_event_hooks(LttvTracesetState *self) ts = (LttvTraceState *)self->parent.traces[i]; nb_tracefile = ts->parent.tracefiles->len; - guint *event_count; + guint *event_count = NULL; for(j = 0 ; j < nb_tracefile ; j++) { tfs = @@ -1847,7 +2042,7 @@ void lttv_state_save_remove_event_hooks(LttvTracesetState *self) event_count = lttv_hooks_remove(tfs->parent.event, state_save_event_hook); } - g_free(event_count); + if(event_count) g_free(event_count); } } @@ -2091,19 +2286,21 @@ lttv_tracefile_state_get_type(void) static void module_init() { LTTV_STATE_UNNAMED = g_quark_from_string("unnamed"); - LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("unknown execution mode"); - 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_SUBMODE_UNKNOWN = g_quark_from_string("unknown submode"); - LTTV_STATE_SUBMODE_NONE = g_quark_from_string("(no submode)"); - LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu"); - LTTV_STATE_EXIT = g_quark_from_string("exiting"); - LTTV_STATE_ZOMBIE = g_quark_from_string("zombie"); - LTTV_STATE_WAIT = g_quark_from_string("wait for I/O"); - LTTV_STATE_RUN = g_quark_from_string("running"); + LTTV_STATE_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"); + LTTV_STATE_TRAP = g_quark_from_string("TRAP"); + LTTV_STATE_IRQ = g_quark_from_string("IRQ"); + LTTV_STATE_SOFT_IRQ = g_quark_from_string("SOFTIRQ"); + LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("UNKNOWN"); + LTTV_STATE_SUBMODE_NONE = g_quark_from_string("NONE"); + LTTV_STATE_WAIT_FORK = g_quark_from_string("WAIT_FORK"); + LTTV_STATE_WAIT_CPU = g_quark_from_string("WAIT_CPU"); + LTTV_STATE_EXIT = g_quark_from_string("EXIT"); + LTTV_STATE_ZOMBIE = g_quark_from_string("ZOMBIE"); + LTTV_STATE_WAIT = g_quark_from_string("WAIT"); + LTTV_STATE_RUN = g_quark_from_string("RUN"); + LTTV_STATE_DEAD = g_quark_from_string("DEAD"); LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles"); LTTV_STATE_PROCESSES = g_quark_from_string("processes"); LTTV_STATE_PROCESS = g_quark_from_string("process"); @@ -2119,8 +2316,10 @@ static void module_init() LTT_FACILITY_KERNEL = g_quark_from_string("kernel"); + LTT_FACILITY_KERNEL_ARCH = g_quark_from_string("kernel_arch"); LTT_FACILITY_PROCESS = g_quark_from_string("process"); LTT_FACILITY_FS = g_quark_from_string("fs"); + LTT_FACILITY_STATEDUMP = g_quark_from_string("statedump"); LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry"); @@ -2129,16 +2328,20 @@ 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_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_EVENT_EXEC = g_quark_from_string("exec"); + LTT_EVENT_ENUM_PROCESS_STATE = g_quark_from_string("enumerate_process_state"); 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_SOFT_IRQ_ID = g_quark_from_string("softirq_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"); @@ -2146,6 +2349,10 @@ static void module_init() LTT_FIELD_CHILD_PID = g_quark_from_string("child_pid"); LTT_FIELD_PID = g_quark_from_string("pid"); LTT_FIELD_FILENAME = g_quark_from_string("filename"); + LTT_FIELD_NAME = g_quark_from_string("name"); + LTT_FIELD_MODE = g_quark_from_string("mode"); + LTT_FIELD_SUBMODE = g_quark_from_string("submode"); + LTT_FIELD_STATUS = g_quark_from_string("status"); }