X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=6bd0b271beed2ab98bb05fb0645bc6055accc777;hb=302efbadc93944574ea9955d8c72a56b0ac9a1dc;hp=18518e87f557fcb5636df6c17fdf9c6c65a3051d;hpb=faf074a30c5aaf8c12214c5bd3446f85248acc04;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index 18518e87..6bd0b271 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 @@ -37,7 +38,9 @@ GQuark LTT_FACILITY_KERNEL, LTT_FACILITY_KERNEL_ARCH, LTT_FACILITY_PROCESS, - LTT_FACILITY_FS; + LTT_FACILITY_FS, + LTT_FACILITY_STATEDUMP, + LTT_FACILITY_USER_GENERIC; /* Events Quarks */ @@ -52,9 +55,13 @@ GQuark LTT_EVENT_SOFT_IRQ_EXIT, LTT_EVENT_SCHEDCHANGE, LTT_EVENT_FORK, + LTT_EVENT_KERNEL_THREAD, LTT_EVENT_EXIT, LTT_EVENT_FREE, - LTT_EVENT_EXEC; + LTT_EVENT_EXEC, + LTT_EVENT_ENUM_PROCESS_STATE, + LTT_EVENT_FUNCTION_ENTRY, + LTT_EVENT_FUNCTION_EXIT; /* Fields Quarks */ @@ -69,7 +76,13 @@ GQuark 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, + LTT_FIELD_THIS_FN, + LTT_FIELD_CALL_SITE; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, @@ -166,6 +179,18 @@ gboolean process_equal(gconstpointer a, gconstpointer b) return ret; } +static void delete_usertrace(gpointer key, gpointer value, gpointer user_data) +{ + g_tree_destroy((GTree*)value); +} + +static void lttv_state_free_usertraces(GHashTable *usertraces) +{ + g_hash_table_foreach(usertraces, delete_usertrace, NULL); + g_hash_table_destroy(usertraces); +} + + static void restore_init_state(LttvTraceState *self) @@ -176,7 +201,9 @@ restore_init_state(LttvTraceState *self) /* Free the process tables */ if(self->processes != NULL) lttv_state_free_process_table(self->processes); + if(self->usertraces != NULL) lttv_state_free_usertraces(self->usertraces); self->processes = g_hash_table_new(process_hash, process_equal); + self->usertraces = g_hash_table_new(g_direct_hash, g_direct_equal); self->nb_event = 0; /* Seek time to beginning */ @@ -194,7 +221,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; } @@ -218,6 +245,20 @@ restore_init_state(LttvTraceState *self) //static LttTime time_zero = {0,0}; +static gint compare_usertraces(gconstpointer a, gconstpointer b, + gpointer user_data) +{ + const LttTime *t1 = (const LttTime *)a; + const LttTime *t2 = (const LttTime *)b; + + return ltt_time_compare(*t1, *t2); +} + +static void free_usertrace_key(gpointer data) +{ + g_free(data); +} + static void init(LttvTracesetState *self, LttvTraceset *ts) { @@ -251,22 +292,53 @@ init(LttvTracesetState *self, LttvTraceset *ts) get_max_time(tcs); nb_tracefile = tc->tracefiles->len; -#if 0 + tcs->processes = NULL; + tcs->usertraces = NULL; + tcs->running_process = g_new(LttvProcessState*, + ltt_trace_get_num_cpu(tc->t)); + restore_init_state(tcs); for(j = 0 ; j < nb_tracefile ; j++) { tfcs = LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles, LttvTracefileContext*, j)); tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf); + tfcs->cpu = ltt_tracefile_cpu(tfcs->parent.tf); +#if 0 + if(ltt_tracefile_tid(tfcs->parent.tf) != 0) { + /* It's a Usertrace */ + LttvProcessState *process; + LttTime timestamp = + ltt_interpolate_time_from_tsc(tfcs->parent.tf, + ltt_tracefile_creation(tfcs->parent.tf)); + process = lttv_state_find_process_or_create( + tcs, + 0, ltt_tracefile_tid(tfcs->parent.tf), + ×tamp); + process->usertrace = tfcs; + } } #endif //0 - tcs->processes = NULL; - tcs->running_process = g_new(LttvProcessState*, - ltt_trace_get_num_cpu(tc->t)); - restore_init_state(tcs); + if(ltt_tracefile_tid(tfcs->parent.tf) != 0) { + /* It's a Usertrace */ + guint tid = ltt_tracefile_tid(tfcs->parent.tf); + GTree *usertrace_tree = (GTree*)g_hash_table_lookup(tcs->usertraces, + (gconstpointer)tid); + if(!usertrace_tree) { + usertrace_tree = g_tree_new_full(compare_usertraces, + NULL, free_usertrace_key, NULL); + g_hash_table_insert(tcs->usertraces, + (gpointer)tid, usertrace_tree); + } + LttTime *timestamp = g_new(LttTime, 1); + *timestamp = ltt_interpolate_time_from_tsc(tfcs->parent.tf, + ltt_tracefile_creation(tfcs->parent.tf)); + g_tree_insert(usertrace_tree, timestamp, tfcs); + } + } + } } - static void fini(LttvTracesetState *self) { @@ -295,7 +367,9 @@ fini(LttvTracesetState *self) g_free(tcs->running_process); tcs->running_process = NULL; lttv_state_free_process_table(tcs->processes); + lttv_state_free_usertraces(tcs->usertraces); tcs->processes = NULL; + tcs->usertraces = NULL; } LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))-> fini((LttvTracesetContext *)self); @@ -427,6 +501,17 @@ 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 = &g_array_index(new_process->user_stack, + guint64, new_process->user_stack->len - 1); g_hash_table_insert(new_processes, new_process, new_process); } @@ -730,6 +815,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; @@ -787,6 +873,7 @@ create_name_tables(LttvTraceState *tcs) lttv_trace_hook_destroy(&h); 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); @@ -882,6 +969,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; @@ -932,8 +1020,8 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t, { LttvExecutionState *es; - guint cpu = ltt_tracefile_num(tfs->parent.tf); LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context; + guint cpu = tfs->cpu; #ifdef HASH_TABLE_DEBUG hash_table_check(ts->processes); @@ -959,7 +1047,7 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t, static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t) { - guint cpu = ltt_tracefile_num(tfs->parent.tf); + guint cpu = tfs->cpu; LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; @@ -992,10 +1080,60 @@ static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t) process->state->change = tfs->parent.timestamp; } +struct search_result { + const LttTime *time; /* Requested time */ + LttTime *best; /* Best result */ +}; + +static gint search_usertrace(gconstpointer a, gconstpointer b) +{ + const LttTime *elem_time = (const LttTime*)a; + /* Explicit non const cast */ + struct search_result *res = (struct search_result *)b; + + if(ltt_time_compare(*elem_time, *(res->time)) < 0) { + /* The usertrace was created before the schedchange */ + /* Get larger keys */ + return 1; + } else if(ltt_time_compare(*elem_time, *(res->time)) >= 0) { + /* The usertrace was created after the schedchange time */ + /* Get smaller keys */ + if(res->best) { + if(ltt_time_compare(*elem_time, *res->best) < 0) { + res->best = elem_time; + } + } else { + res->best = elem_time; + } + return -1; + } +} + +static LttvTracefileState *ltt_state_usertrace_find(LttvTraceState *tcs, + guint pid, const LttTime *timestamp) +{ + LttvTracefileState *tfs = NULL; + struct search_result res; + /* Find the usertrace associated with a pid and time interval. + * Search in the usertraces by PID (within a hash) and then, for each + * corresponding element of the array, find the first one with creation + * timestamp the lowest, but higher or equal to "timestamp". */ + res.time = timestamp; + res.best = NULL; + GTree *usertrace_tree = g_hash_table_lookup(tcs->usertraces, (gpointer)pid); + if(usertrace_tree) { + g_tree_search(usertrace_tree, search_usertrace, &res); + if(res.best) + tfs = g_tree_lookup(usertrace_tree, res.best); + } + + return tfs; +} + 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); @@ -1007,14 +1145,18 @@ 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); + process->kernel_thread = 0; + 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); if(parent) { process->ppid = parent->pid; - process->name = parent->name; process->creation_time = *timestamp; } @@ -1024,7 +1166,6 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, else { process->ppid = 0; - process->name = LTTV_STATE_UNNAMED; process->creation_time = ltt_time_zero; } @@ -1055,7 +1196,11 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, //g_assert(timestamp->tv_sec != 0); es->change = *timestamp; 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; } @@ -1076,10 +1221,17 @@ lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid, LttTime *timestamp) { LttvProcessState *process = lttv_state_find_process(ts, cpu, pid); + LttvExecutionState *es; /* Put ltt_time_zero creation time for unexisting processes */ - if(unlikely(process == NULL)) process = lttv_state_create_process(ts, - NULL, cpu, pid, timestamp); + if(unlikely(process == NULL)) { + process = lttv_state_create_process(ts, + NULL, cpu, pid, LTTV_STATE_UNNAMED, timestamp); + /* We are not sure is it's a kernel thread or normal thread, put the + * bottom stack state to unknown */ + es = &g_array_index(process->execution_stack, LttvExecutionState, 0); + es->t = LTTV_STATE_MODE_UNKNOWN; + } return process; } @@ -1099,6 +1251,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); } @@ -1106,6 +1259,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); } @@ -1126,8 +1280,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; } @@ -1189,6 +1354,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) { @@ -1220,22 +1394,97 @@ 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]; -static gboolean soft_irq_exit(void *hook_data, void *call_data) + 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 = + g_array_index(process->user_stack, guint64, depth - 1); +} + +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]; + + guint depth = process->user_stack->len; + 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; + } + + 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) { LttvTracefileState *s = (LttvTracefileState *)call_data; - guint cpu = ltt_tracefile_num(s->parent.tf); + guint cpu = s->cpu; LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; + LttvProcessState *old_process = ts->running_process[cpu]; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; @@ -1255,7 +1504,8 @@ static gboolean schedchange(void *hook_data, void *call_data) the wrongly attributed statistics. */ //This test only makes sense once the state is known and if there is no - //missing events. + //missing events. We need to silently ignore schedchange coming after a + //process_free, or it causes glitches. (FIXME) //if(unlikely(process->pid != pid_out)) { // g_assert(process->pid == 0); //} @@ -1268,8 +1518,8 @@ static gboolean schedchange(void *hook_data, void *call_data) else process->state->s = LTTV_STATE_WAIT; process->state->change = s->parent.timestamp; } - - if(state_out == 32) + + if(state_out == 32) exit_process(s, process); /* EXIT_DEAD */ /* see sched.h for states */ } @@ -1280,6 +1530,8 @@ static gboolean schedchange(void *hook_data, void *call_data) &s->parent.timestamp); process->state->s = LTTV_STATE_RUN; process->cpu = cpu; + if(process->usertrace) + process->usertrace->cpu = cpu; // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf); process->state->change = s->parent.timestamp; return FALSE; @@ -1290,22 +1542,19 @@ static gboolean process_fork(void *hook_data, void *call_data) LttvTracefileState *s = (LttvTracefileState *)call_data; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; - LttField *f; guint parent_pid; guint child_pid; LttvProcessState *zombie_process; - guint cpu = ltt_tracefile_num(s->parent.tf); + guint cpu = s->cpu; LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; 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 @@ -1333,8 +1582,8 @@ 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. Note that we @@ -1346,10 +1595,34 @@ static gboolean process_fork(void *hook_data, void *call_data) before the fork event */ child_process->ppid = process->pid; } + g_assert(child_process->name == LTTV_STATE_UNNAMED); + child_process->name = process->name; return FALSE; } +/* We stamp a newly created process as kernel_thread */ +static gboolean process_kernel_thread(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; + guint pid; + guint cpu = s->cpu; + LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; + LttvProcessState *process; + LttvExecutionState *es; + + /* PID */ + pid = ltt_event_get_unsigned(e, thf->f1); + + 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; + + return FALSE; +} static gboolean process_exit(void *hook_data, void *call_data) { @@ -1358,7 +1631,7 @@ static gboolean process_exit(void *hook_data, void *call_data) LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; LttField *f; guint pid; - guint cpu = ltt_tracefile_num(s->parent.tf); + guint cpu = s->cpu; LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; @@ -1411,8 +1684,9 @@ static gboolean process_free(void *hook_data, void *call_data) break; } } - if(i == num_cpus) /* process is not scheduled */ - exit_process(s, process); + //if(i == num_cpus) /* process is not scheduled */ + //exit_process(s, process); // do nothing : wait for the schedchange to + //delete the process. } return FALSE; @@ -1426,7 +1700,7 @@ static gboolean process_exec(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; //gchar *name; - guint cpu = ltt_tracefile_num(s->parent.tf); + guint cpu = s->cpu; LttvProcessState *process = ts->running_process[cpu]; /* PID of the process to release */ @@ -1444,8 +1718,95 @@ static gboolean process_exec(void *hook_data, void *call_data) 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 = s->cpu; + 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) { @@ -1475,6 +1836,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++) { @@ -1483,89 +1845,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), 13); - hooks = g_array_set_size(hooks, 13); + 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, + 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, 10)); - 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, 11)); - 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, 12)); - 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, 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; @@ -1587,7 +1976,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; } } @@ -1622,7 +2011,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 */ @@ -1704,6 +2093,13 @@ static gboolean state_save_after_trace_hook(void *hook_data, void *call_data) return FALSE; } +guint lttv_state_current_cpu(LttvTracefileState *tfs) +{ + return tfs->cpu; +} + + + #if 0 static gboolean block_start(void *hook_data, void *call_data) { @@ -2188,21 +2584,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_SOFT_IRQ = g_quark_from_string("softirq"); - 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_DEAD = g_quark_from_string("dead"); + 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"); @@ -2221,6 +2617,8 @@ static void module_init() 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_FACILITY_USER_GENERIC = g_quark_from_string("user_generic"); LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry"); @@ -2233,9 +2631,13 @@ static void module_init() 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_KERNEL_THREAD = g_quark_from_string("kernel_thread"); 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_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"); @@ -2249,6 +2651,12 @@ 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"); + LTT_FIELD_THIS_FN = g_quark_from_string("this_fn"); + LTT_FIELD_CALL_SITE = g_quark_from_string("call_site"); }