X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=1369be5e68576d37a91e266814d2bfcfb80f03a7;hb=e62e7f3a20cc94539fab3595f8aec3b6f4fce304;hp=efbd2ed6c52f353a47b6ff3232cef8c42797876f;hpb=6806b3c6cc33682d2f19967411b38fbdb400fed8;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index efbd2ed6..1369be5e 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -39,7 +39,8 @@ GQuark LTT_FACILITY_KERNEL_ARCH, LTT_FACILITY_PROCESS, LTT_FACILITY_FS, - LTT_FACILITY_STATEDUMP; + LTT_FACILITY_STATEDUMP, + LTT_FACILITY_USER_GENERIC; /* Events Quarks */ @@ -58,7 +59,9 @@ GQuark LTT_EVENT_EXIT, LTT_EVENT_FREE, LTT_EVENT_EXEC, - LTT_EVENT_ENUM_PROCESS_STATE; + LTT_EVENT_ENUM_PROCESS_STATE, + LTT_EVENT_FUNCTION_ENTRY, + LTT_EVENT_FUNCTION_EXIT; /* Fields Quarks */ @@ -75,9 +78,12 @@ GQuark LTT_FIELD_PID, LTT_FIELD_FILENAME, LTT_FIELD_NAME, + LTT_FIELD_TYPE, LTT_FIELD_MODE, LTT_FIELD_SUBMODE, - LTT_FIELD_STATUS; + LTT_FIELD_STATUS, + LTT_FIELD_THIS_FN, + LTT_FIELD_CALL_SITE; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, @@ -101,6 +107,10 @@ LttvProcessStatus LTTV_STATE_RUN, LTTV_STATE_DEAD; +LttvProcessType + LTTV_STATE_USER_THREAD, + LTTV_STATE_KERNEL_THREAD; + static GQuark LTTV_STATE_TRACEFILES, LTTV_STATE_PROCESSES, @@ -407,8 +417,9 @@ static void write_process_state(gpointer key, gpointer value, process = (LttvProcessState *)value; fprintf(fp, -" \n", - process, process->pid, process->ppid, process->creation_time.tv_sec, +" \n", + process, process->pid, process->ppid, g_quark_to_string(process->type), + process->creation_time.tv_sec, process->creation_time.tv_nsec, g_quark_to_string(process->name), process->cpu); @@ -496,6 +507,16 @@ static void copy_process_state(gpointer key, gpointer value,gpointer user_data) } new_process->state = &g_array_index(new_process->execution_stack, LttvExecutionState, new_process->execution_stack->len - 1); + new_process->user_stack = g_array_sized_new(FALSE, FALSE, + sizeof(guint64), 0); + new_process->user_stack = + g_array_set_size(new_process->user_stack, + process->user_stack->len); + for(i = 0 ; i < process->user_stack->len; i++) { + g_array_index(new_process->user_stack, guint64, i) = + g_array_index(process->user_stack, guint64, i); + } + new_process->current_function = process->current_function; g_hash_table_insert(new_processes, new_process, new_process); } @@ -608,6 +629,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) LttvAttributeName name; + gboolean is_named; + LttEventPosition *ep; LttvTracesetContext *tsc = self->parent.ts_context; @@ -643,7 +666,7 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) tfcs = LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles, LttvTracefileContext*, i)); - type = lttv_attribute_get(tracefiles_tree, i, &name, &value); + type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named); g_assert(type == LTTV_GOBJECT); tracefile_tree = *((LttvAttribute **)(value.v_gobject)); #if 0 @@ -692,6 +715,8 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container) LttvAttributeName name; + gboolean is_named; + LttEventPosition *ep; tracefiles_tree = lttv_attribute_find_subdir(container, @@ -720,7 +745,7 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container) tfcs = LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles, LttvTracefileContext*, i)); - type = lttv_attribute_get(tracefiles_tree, i, &name, &value); + type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named); g_assert(type == LTTV_GOBJECT); tracefile_tree = *((LttvAttribute **)(value.v_gobject)); @@ -743,6 +768,8 @@ static void free_saved_state(LttvTraceState *self) LttvAttributeName name; + gboolean is_named; + LttvAttribute *saved_states; saved_states = lttv_attribute_find_subdir(self->parent.t_a, @@ -750,7 +777,7 @@ static void free_saved_state(LttvTraceState *self) nb = lttv_attribute_get_number(saved_states); for(i = 0 ; i < nb ; i++) { - type = lttv_attribute_get(saved_states, i, &name, &value); + type = lttv_attribute_get(saved_states, i, &name, &value, &is_named); g_assert(type == LTTV_GOBJECT); state_saved_free(self, *((LttvAttribute **)value.v_gobject)); } @@ -799,6 +826,7 @@ free_max_time(LttvTraceState *tcs) typedef struct _LttvNameTables { // FIXME GQuark *eventtype_names; GQuark *syscall_names; + guint nb_syscalls; GQuark *trap_names; GQuark *irq_names; GQuark *soft_irq_names; @@ -842,84 +870,91 @@ create_name_tables(LttvTraceState *tcs) name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str); } #endif //0 - if(lttv_trace_find_hook(tcs->parent.t, + if(!lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL_ARCH, 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); + NULL, NULL, &h)) { + + 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->syscall_names = g_new(GQuark, nb); + name_tables->syscall_names = g_new(GQuark, nb); + name_tables->nb_syscalls = nb; - for(i = 0 ; i < nb ; i++) { - name_tables->syscall_names[i] = ltt_enum_string_get(t, i); - } + for(i = 0 ; i < nb ; 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); + //} + } else { + name_tables->syscall_names = NULL; + name_tables->nb_syscalls = 0; + } - if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL, + 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; + NULL, NULL, &h)) { - thf = lttv_trace_hook_get_first(&h); + thf = lttv_trace_hook_get_first(&h); - t = ltt_field_type(thf->f1); - //nb = ltt_type_element_number(t); + t = ltt_field_type(thf->f1); + //nb = ltt_type_element_number(t); - lttv_trace_hook_destroy(&h); + 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( - ltt_enum_string_get(t, i)); - } - */ + /* + name_tables->trap_names = g_new(GQuark, nb); + for(i = 0 ; i < nb ; i++) { + name_tables->trap_names[i] = g_quark_from_string( + ltt_enum_string_get(t, i)); + } + */ - name_tables->trap_names = g_new(GQuark, 256); - for(i = 0 ; i < 256 ; i++) { - g_string_printf(fe_name, "trap %d", i); - name_tables->trap_names[i] = g_quark_from_string(fe_name->str); - } + name_tables->trap_names = g_new(GQuark, 256); + for(i = 0 ; i < 256 ; i++) { + g_string_printf(fe_name, "trap %d", i); + name_tables->trap_names[i] = g_quark_from_string(fe_name->str); + } + } else { + name_tables->trap_names = NULL; + } - if(lttv_trace_find_hook(tcs->parent.t, + 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); + NULL, NULL, &h)) { + + thf = lttv_trace_hook_get_first(&h); + + t = ltt_field_type(thf->f1); + //nb = ltt_type_element_number(t); - /* - name_tables->irq_names = g_new(GQuark, nb); - for(i = 0 ; i < nb ; i++) { - name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i)); - } - */ + lttv_trace_hook_destroy(&h); - name_tables->irq_names = g_new(GQuark, 256); - for(i = 0 ; i < 256 ; i++) { - g_string_printf(fe_name, "irq %d", i); - name_tables->irq_names[i] = g_quark_from_string(fe_name->str); - } + /* + name_tables->irq_names = g_new(GQuark, nb); + for(i = 0 ; i < nb ; i++) { + name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i)); + } + */ + name_tables->irq_names = g_new(GQuark, 256); + for(i = 0 ; i < 256 ; i++) { + g_string_printf(fe_name, "irq %d", i); + name_tables->irq_names[i] = g_quark_from_string(fe_name->str); + } + } else { + name_tables->irq_names = NULL; + } /* name_tables->soft_irq_names = g_new(GQuark, nb); for(i = 0 ; i < nb ; i++) { @@ -951,6 +986,7 @@ get_name_tables(LttvTraceState *tcs) name_tables = (LttvNameTables *)*(v.v_pointer); //tcs->eventtype_names = name_tables->eventtype_names; tcs->syscall_names = name_tables->syscall_names; + tcs->nb_syscalls = name_tables->nb_syscalls; tcs->trap_names = name_tables->trap_names; tcs->irq_names = name_tables->irq_names; tcs->soft_irq_names = name_tables->soft_irq_names; @@ -970,11 +1006,11 @@ free_name_tables(LttvTraceState *tcs) *(v.v_pointer) = NULL; // 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->soft_irq_names); - g_free(name_tables); + if(name_tables->syscall_names) g_free(name_tables->syscall_names); + if(name_tables->trap_names) g_free(name_tables->trap_names); + if(name_tables->irq_names) g_free(name_tables->irq_names); + if(name_tables->soft_irq_names) g_free(name_tables->soft_irq_names); + if(name_tables) g_free(name_tables); } #ifdef HASH_TABLE_DEBUG @@ -1021,10 +1057,33 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t, es->t = t; es->n = state_id; es->entry = es->change = tfs->parent.timestamp; + es->cum_cpu_time = ltt_time_zero; es->s = process->state->s; process->state = es; } +/* pop state + * return 1 when empty, else 0 */ +int lttv_state_pop_state_cleanup(LttvProcessState *process, + LttvTracefileState *tfs) +{ + guint cpu = tfs->cpu; + LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context; + + guint depth = process->execution_stack->len; + + if(depth == 1){ + return 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; + + return 0; +} static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t) { @@ -1088,6 +1147,7 @@ static gint search_usertrace(gconstpointer a, gconstpointer b) } return -1; } + return 0; } static LttvTracefileState *ltt_state_usertrace_find(LttvTraceState *tcs, @@ -1129,8 +1189,9 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, process->name = name; //process->last_cpu = tfs->cpu_name; //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf); - process->kernel_thread = 0; + process->type = LTTV_STATE_USER_THREAD; process->usertrace = ltt_state_usertrace_find(tcs, pid, timestamp); + process->current_function = 0; //function 0x0 by default. g_info("Process %u, core %p", process->pid, process); g_hash_table_insert(tcs->processes, process, process); @@ -1166,6 +1227,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, es->entry = *timestamp; //g_assert(timestamp->tv_sec != 0); es->change = *timestamp; + es->cum_cpu_time = ltt_time_zero; es->s = LTTV_STATE_RUN; es = process->state = &g_array_index(process->execution_stack, @@ -1175,8 +1237,13 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, es->entry = *timestamp; //g_assert(timestamp->tv_sec != 0); es->change = *timestamp; + es->cum_cpu_time = ltt_time_zero; es->s = LTTV_STATE_WAIT_FORK; - + + /* Allocate an empty function call stack. If it's empty, use 0x0. */ + process->user_stack = g_array_sized_new(FALSE, FALSE, + sizeof(guint64), 0); + return process; } @@ -1227,6 +1294,7 @@ static void exit_process(LttvTracefileState *tfs, LttvProcessState *process) key.cpu = process->cpu; g_hash_table_remove(ts->processes, &key); g_array_free(process->execution_stack, TRUE); + g_array_free(process->user_stack, TRUE); g_free(process); } @@ -1234,6 +1302,7 @@ static void exit_process(LttvTracefileState *tfs, LttvProcessState *process) static void free_process_state(gpointer key, gpointer value,gpointer user_data) { g_array_free(((LttvProcessState *)value)->execution_stack, TRUE); + g_array_free(((LttvProcessState *)value)->user_stack, TRUE); g_free(value); } @@ -1254,8 +1323,19 @@ static gboolean syscall_entry(void *hook_data, void *call_data) LttvExecutionSubmode submode; - submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[ - ltt_event_get_unsigned(e, f)]; + guint nb_syscalls = ((LttvTraceState *)(s->parent.t_context))->nb_syscalls; + guint syscall = ltt_event_get_unsigned(e, f); + + if(syscall < nb_syscalls) { + submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[ + syscall]; + } else { + /* Fixup an incomplete syscall table */ + GString *string = g_string_new(""); + g_string_printf(string, "syscall %u", syscall); + submode = g_quark_from_string(string->str); + g_string_free(string, TRUE); + } push_state(s, LTTV_STATE_SYSCALL, submode); return FALSE; } @@ -1317,6 +1397,15 @@ static gboolean irq_entry(void *hook_data, void *call_data) 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 irq_exit(void *hook_data, void *call_data) { @@ -1348,15 +1437,88 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data) return FALSE; } +static void push_function(LttvTracefileState *tfs, guint64 funcptr) +{ + guint64 *new_func; + + LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context; + guint cpu = tfs->cpu; + LttvProcessState *process = ts->running_process[cpu]; + + guint depth = process->user_stack->len; + + process->user_stack = + g_array_set_size(process->user_stack, depth + 1); + + new_func = &g_array_index(process->user_stack, guint64, depth); + *new_func = funcptr; + process->current_function = funcptr; +} + +static void pop_function(LttvTracefileState *tfs, guint64 funcptr) +{ + guint cpu = tfs->cpu; + LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context; + LttvProcessState *process = ts->running_process[cpu]; -static gboolean soft_irq_exit(void *hook_data, void *call_data) + if(process->current_function != funcptr){ + g_info("Different functions (%lu.%09lu): ignore it\n", + tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec); + g_info("process state has %llu when pop_function is %llu\n", + process->current_function, funcptr); + g_info("{ %u, %u, %s, %s }\n", + process->pid, + process->ppid, + g_quark_to_string(process->name), + g_quark_to_string(process->state->s)); + return; + } + guint depth = process->user_stack->len; + + if(depth == 0){ + g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n", + tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec); + return; + } + + process->user_stack = + g_array_set_size(process->user_stack, depth - 1); + process->current_function = + g_array_index(process->user_stack, guint64, depth - 2); +} + + +static gboolean function_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(thf->f1 != NULL); + LttField *f = thf->f1; + guint64 funcptr = ltt_event_get_long_unsigned(e, f); - pop_state(s, LTTV_STATE_SOFT_IRQ); + push_function(s, funcptr); return FALSE; } +static gboolean function_exit(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(thf->f1 != NULL); + LttField *f = thf->f1; + guint64 funcptr = ltt_event_get_long_unsigned(e, f); + + LttvExecutionSubmode submode; + + pop_function(s, funcptr); + return FALSE; +} static gboolean schedchange(void *hook_data, void *call_data) { @@ -1499,7 +1661,7 @@ static gboolean process_kernel_thread(void *hook_data, void *call_data) process = lttv_state_find_process(ts, ANY_CPU, pid); es = &g_array_index(process->execution_stack, LttvExecutionState, 0); es->t = LTTV_STATE_SYSCALL; - process->kernel_thread = 1; + process->type = LTTV_STATE_KERNEL_THREAD; return FALSE; } @@ -1613,8 +1775,9 @@ 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; - LttField *f4, *f5, *f6; - GQuark mode, submode, status; + LttField *f4, *f5, *f6, *f7; + GQuark type, mode, submode, status; + LttvExecutionState *es; /* PID */ pid = ltt_event_get_unsigned(e, thf->f1); @@ -1625,21 +1788,26 @@ static gboolean enum_process_state(void *hook_data, void *call_data) /* 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), + /* type */ + f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_TYPE); + type = 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), + /* mode */ + f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE); + mode = 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), + /* submode */ + f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE); + submode = ltt_enum_string_get(ltt_field_type(f6), ltt_event_get_unsigned(e, f6)); + /* status */ + f7 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS); + status = ltt_enum_string_get(ltt_field_type(f7), + ltt_event_get_unsigned(e, f7)); + /* 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) { @@ -1649,38 +1817,44 @@ static gboolean enum_process_state(void *hook_data, void *call_data) &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) { + if(type == LTTV_STATE_KERNEL_THREAD) { /* Only keep the bottom */ 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_SYSCALL; + es->s = status; + es->n = submode; } else { /* On top of it : */ - LttvExecutionState *es; es = process->state = &g_array_index(process->execution_stack, LttvExecutionState, 1); - es->t = mode; + es->t = LTTV_STATE_USER_MODE; es->s = status; es->n = submode; } -#endif //0 - +#if 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; } +#endif //0 } 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. + * We know for sure if it is a user space thread. */ process->ppid = parent_pid; process->name = g_quark_from_string(command); + es = &g_array_index(process->execution_stack, LttvExecutionState, 0); + if(type != LTTV_STATE_KERNEL_THREAD) + es->t = LTTV_STATE_USER_MODE; /* Don't mess around with the stack, it will eventually become * ok after the end of state dump. */ } @@ -1716,6 +1890,7 @@ 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++) { @@ -1724,101 +1899,116 @@ 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), 15); - hooks = g_array_set_size(hooks, 15); + hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 17); + hooks = g_array_set_size(hooks, 17); // Max possible number of hooks. + hn = 0; ret = lttv_trace_find_hook(ts->parent.t, 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); + syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; ret = lttv_trace_find_hook(ts->parent.t, LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT, 0, 0, 0, - syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1)); - g_assert(!ret); + syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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); + trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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); + trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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); + irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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); + irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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); + soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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); + soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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, 8)); - g_assert(!ret); + schedchange, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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, 9)); - g_assert(!ret); + process_fork, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; ret = lttv_trace_find_hook(ts->parent.t, LTT_FACILITY_PROCESS, LTT_EVENT_KERNEL_THREAD, LTT_FIELD_PID, 0, 0, - process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook, 10)); - g_assert(!ret); + process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook, + hn++)); + if(ret) hn--; 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, 11)); - g_assert(!ret); + process_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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, 12)); - g_assert(!ret); + process_free, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; 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, 13)); - g_assert(!ret); + process_exec, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; /* 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, 14)); - g_assert(!ret); + enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; - + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY, + LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, + function_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; + + ret = lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT, + LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, + function_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); + if(ret) hn--; + + hooks = g_array_set_size(hooks, hn); + /* Add these hooks to each event_by_id hooks list */ nb_tracefile = ts->parent.tracefiles->len; @@ -2235,6 +2425,8 @@ void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t) LttvAttributeName name; + gboolean is_named; + LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree; //g_tree_destroy(self->parent.pqueue); @@ -2255,7 +2447,8 @@ void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t) max_pos = lttv_attribute_get_number(saved_states_tree) - 1; mid_pos = max_pos / 2; while(min_pos < max_pos) { - type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value); + type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value, + &is_named); g_assert(type == LTTV_GOBJECT); saved_state_tree = *((LttvAttribute **)(value.v_gobject)); type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME, @@ -2463,6 +2656,8 @@ static void module_init() 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_USER_THREAD = g_quark_from_string("USER_THREAD"); + LTTV_STATE_KERNEL_THREAD = g_quark_from_string("KERNEL_THREAD"); LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles"); LTTV_STATE_PROCESSES = g_quark_from_string("processes"); LTTV_STATE_PROCESS = g_quark_from_string("process"); @@ -2482,6 +2677,7 @@ static void module_init() 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_FACILITY_USER_GENERIC = g_quark_from_string("user_generic"); LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry"); @@ -2499,6 +2695,8 @@ static void module_init() 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_EVENT_FUNCTION_ENTRY = g_quark_from_string("function_entry"); + LTT_EVENT_FUNCTION_EXIT = g_quark_from_string("function_exit"); LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id"); @@ -2513,9 +2711,12 @@ static void module_init() 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_TYPE = g_quark_from_string("type"); LTT_FIELD_MODE = g_quark_from_string("mode"); LTT_FIELD_SUBMODE = g_quark_from_string("submode"); LTT_FIELD_STATUS = g_quark_from_string("status"); + LTT_FIELD_THIS_FN = g_quark_from_string("this_fn"); + LTT_FIELD_CALL_SITE = g_quark_from_string("call_site"); }