X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=7835b708d2a33a097b9d037634f368bb0047281e;hb=37b0f1ed7982a8995d29da17a5b1b6b8127eb162;hp=0a48ada6009521504374b004898a34ae433d330c;hpb=cab321cf1e9fd164618942560cfb27f5561d21be;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index 0a48ada6..7835b708 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -16,17 +16,19 @@ * MA 02111-1307, USA. */ +#define _GNU_SOURCE #ifdef HAVE_CONFIG_H #include #endif +#include #include #include #include -#include #include #include -#include +#include +#include #include #include @@ -47,10 +49,10 @@ GQuark LTT_FACILITY_KERNEL, LTT_FACILITY_KERNEL_ARCH, - LTT_FACILITY_PROCESS, + LTT_FACILITY_LIST, LTT_FACILITY_FS, - LTT_FACILITY_STATEDUMP, - LTT_FACILITY_USER_GENERIC; + LTT_FACILITY_USER_GENERIC, + LTT_FACILITY_BLOCK; /* Events Quarks */ @@ -63,16 +65,20 @@ GQuark LTT_EVENT_IRQ_EXIT, LTT_EVENT_SOFT_IRQ_ENTRY, LTT_EVENT_SOFT_IRQ_EXIT, - LTT_EVENT_SCHEDCHANGE, - LTT_EVENT_FORK, - LTT_EVENT_KERNEL_THREAD, - LTT_EVENT_EXIT, - LTT_EVENT_FREE, + LTT_EVENT_SCHED_SCHEDULE, + LTT_EVENT_PROCESS_FORK, + LTT_EVENT_KTHREAD_CREATE, + LTT_EVENT_PROCESS_EXIT, + LTT_EVENT_PROCESS_FREE, LTT_EVENT_EXEC, - LTT_EVENT_ENUM_PROCESS_STATE, + LTT_EVENT_PROCESS_STATE, + LTT_EVENT_STATEDUMP_END, LTT_EVENT_FUNCTION_ENTRY, LTT_EVENT_FUNCTION_EXIT, - LTT_EVENT_THREAD_BRAND; + LTT_EVENT_THREAD_BRAND, + LTT_EVENT_REQUEST_ISSUE, + LTT_EVENT_REQUEST_COMPLETE, + LTT_EVENT_LIST_INTERRUPT; /* Fields Quarks */ @@ -81,13 +87,14 @@ GQuark 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_PREV_PID, + LTT_FIELD_NEXT_PID, + LTT_FIELD_PREV_STATE, LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, LTT_FIELD_PID, LTT_FIELD_TGID, + LTT_FIELD_CHILD_TGID, LTT_FIELD_FILENAME, LTT_FIELD_NAME, LTT_FIELD_TYPE, @@ -95,7 +102,11 @@ GQuark LTT_FIELD_SUBMODE, LTT_FIELD_STATUS, LTT_FIELD_THIS_FN, - LTT_FIELD_CALL_SITE; + LTT_FIELD_CALL_SITE, + LTT_FIELD_MINOR, + LTT_FIELD_MAJOR, + LTT_FIELD_OPERATION, + LTT_FIELD_ACTION; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, @@ -111,7 +122,6 @@ LttvExecutionSubmode LttvProcessStatus LTTV_STATE_UNNAMED, - LTTV_STATE_UNBRANDED, LTTV_STATE_WAIT_FORK, LTTV_STATE_WAIT_CPU, LTTV_STATE_EXIT, @@ -120,10 +130,31 @@ LttvProcessStatus LTTV_STATE_RUN, LTTV_STATE_DEAD; +GQuark + LTTV_STATE_UNBRANDED; + LttvProcessType LTTV_STATE_USER_THREAD, LTTV_STATE_KERNEL_THREAD; +LttvCPUMode + LTTV_CPU_UNKNOWN, + LTTV_CPU_IDLE, + LTTV_CPU_BUSY, + LTTV_CPU_IRQ, + LTTV_CPU_TRAP; + +LttvIRQMode + LTTV_IRQ_UNKNOWN, + LTTV_IRQ_IDLE, + LTTV_IRQ_BUSY; + +LttvBdevMode + LTTV_BDEV_UNKNOWN, + LTTV_BDEV_IDLE, + LTTV_BDEV_BUSY_READING, + LTTV_BDEV_BUSY_WRITING; + static GQuark LTTV_STATE_TRACEFILES, LTTV_STATE_PROCESSES, @@ -135,7 +166,11 @@ static GQuark LTTV_STATE_TIME, LTTV_STATE_HOOKS, LTTV_STATE_NAME_TABLES, - LTTV_STATE_TRACE_STATE_USE_COUNT; + LTTV_STATE_TRACE_STATE_USE_COUNT, + LTTV_STATE_RESOURCE_CPUS, + LTTV_STATE_RESOURCE_CPUS_COUNT, + LTTV_STATE_RESOURCE_IRQS, + LTTV_STATE_RESOURCE_BLKDEVS; static void create_max_time(LttvTraceState *tcs); @@ -156,6 +191,14 @@ static void lttv_state_free_process_table(GHashTable *processes); static void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp, GPtrArray *quarktable); +/* Resource function prototypes */ +static LttvBdevState *get_hashed_bdevstate(LttvTraceState *ts, guint16 devcode); +static LttvBdevState *bdevstate_new(void); +static void bdevstate_free(LttvBdevState *); +static void bdevstate_free_cb(gpointer key, gpointer value, gpointer user_data); +static LttvBdevState *bdevstate_copy(LttvBdevState *bds); + + void lttv_state_save(LttvTraceState *self, LttvAttribute *container) { LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container); @@ -210,14 +253,17 @@ 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; + guint i, nb_cpus, nb_irqs; - LttvTracefileState *tfcs; + //LttvTracefileState *tfcs; LttTime start_time, end_time; @@ -240,6 +286,7 @@ restore_init_state(LttvTraceState *self) //lttv_process_trace_seek_time(&self->parent, ltt_time_zero); nb_cpus = ltt_trace_get_num_cpu(self->parent.t); + nb_irqs = self->nb_irqs; /* Put the per cpu running_process to beginning state : process 0. */ for(i=0; i< nb_cpus; i++) { @@ -254,10 +301,26 @@ restore_init_state(LttvTraceState *self) &g_array_index(self->running_process[i]->execution_stack, LttvExecutionState, 0); es->t = LTTV_STATE_MODE_UNKNOWN; + es->s = LTTV_STATE_UNNAMED; - self->running_process[i]->state->s = LTTV_STATE_RUN; + //self->running_process[i]->state->s = LTTV_STATE_RUN; self->running_process[i]->cpu = i; + + /* reset cpu states */ + if(self->cpu_states[i].mode_stack->len > 0) + g_array_remove_range(self->cpu_states[i].mode_stack, 0, self->cpu_states[i].mode_stack->len); + } + + /* reset irq states */ + for(i=0; iirq_states[i].mode_stack->len > 0) + g_array_remove_range(self->irq_states[i].mode_stack, 0, self->irq_states[i].mode_stack->len); } + + /* 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_foreach_steal(self->bdev_states, rettrue, NULL); #if 0 nb_tracefile = self->parent.tracefiles->len; @@ -299,7 +362,7 @@ state_load_saved_states(LttvTraceState *tcs) { FILE *fp; GPtrArray *quarktable; - char *trace_path; + const char *trace_path; char path[PATH_MAX]; guint count; guint i; @@ -372,7 +435,8 @@ end: static void init(LttvTracesetState *self, LttvTraceset *ts) { - guint i, j, nb_trace, nb_tracefile; + guint i, j, nb_trace, nb_tracefile, nb_cpu; + guint64 nb_irq; LttvTraceContext *tc; @@ -402,10 +466,29 @@ init(LttvTracesetState *self, LttvTraceset *ts) get_max_time(tcs); nb_tracefile = tc->tracefiles->len; + nb_cpu = ltt_trace_get_num_cpu(tc->t); + nb_irq = tcs->nb_irqs; tcs->processes = NULL; tcs->usertraces = NULL; - tcs->running_process = g_new(LttvProcessState*, - ltt_trace_get_num_cpu(tc->t)); + tcs->running_process = g_new(LttvProcessState*, nb_cpu); + + /* init cpu resource stuff */ + tcs->cpu_states = g_new(LttvCPUState, nb_cpu); + for(j = 0; jcpu_states[j].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvCPUMode)); + g_assert(tcs->cpu_states[j].mode_stack != NULL); + } + + /* init irq resource stuff */ + tcs->irq_states = g_new(LttvIRQState, nb_irq); + for(j = 0; jirq_states[j].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvIRQMode)); + g_assert(tcs->irq_states[j].mode_stack != NULL); + } + + /* init bdev resource stuff */ + tcs->bdev_states = g_hash_table_new(g_int_hash, g_int_equal); + restore_init_state(tcs); for(j = 0 ; j < nb_tracefile ; j++) { tfcs = @@ -413,6 +496,7 @@ init(LttvTracesetState *self, LttvTraceset *ts) LttvTracefileContext*, j)); tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf); tfcs->cpu = ltt_tracefile_cpu(tfcs->parent.tf); + tfcs->cpu_state = &(tcs->cpu_states[tfcs->cpu]); if(ltt_tracefile_tid(tfcs->parent.tf) != 0) { /* It's a Usertrace */ guint tid = ltt_tracefile_tid(tfcs->parent.tf); @@ -443,7 +527,7 @@ fini(LttvTracesetState *self) LttvTraceState *tcs; - LttvTracefileState *tfcs; + //LttvTracefileState *tfcs; LttvAttributeValue v; @@ -531,7 +615,7 @@ static void write_process_state(gpointer key, gpointer value, } for(i = 0 ; i < process->user_stack->len; i++) { - address = &g_array_index(process->user_stack, guint64, i); + address = g_array_index(process->user_stack, guint64, i); fprintf(fp, " \n", address); } @@ -666,7 +750,7 @@ static void write_process_state_raw(gpointer key, gpointer value, } for(i = 0 ; i < process->user_stack->len; i++) { - address = &g_array_index(process->user_stack, guint64, i); + address = g_array_index(process->user_stack, guint64, i); fputc(HDR_USER_STACK, fp); fwrite(&address, sizeof(address), 1, fp); #if 0 @@ -762,9 +846,7 @@ static void read_process_state_raw(LttvTraceState *self, FILE *fp, LttvProcessState tmp; GQuark tmpq; - guint i; guint64 *address; - guint cpu; /* TODO : check return value */ fread(&tmp.type, sizeof(tmp.type), 1, fp); @@ -1001,7 +1083,7 @@ void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp, end_loop: *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time; restore_init_state(tcs); - lttv_process_trace_seek_time(tcs, ltt_time_zero); + lttv_process_trace_seek_time(&tcs->parent, ltt_time_zero); return; } @@ -1053,6 +1135,147 @@ static GHashTable *lttv_state_copy_process_table(GHashTable *processes) return new_processes; } +static LttvCPUState *lttv_state_copy_cpu_states(LttvCPUState *states, guint n) +{ + guint i,j; + LttvCPUState *retval; + + retval = g_malloc(n*sizeof(LttvCPUState)); + + for(i=0; ilen); + for(j=0; jlen; j++) { + g_array_index(retval[i].mode_stack, GQuark, j) = g_array_index(states[i].mode_stack, GQuark, j); + } + } + + return retval; +} + +static void lttv_state_free_cpu_states(LttvCPUState *states, guint n) +{ + guint i; + + for(i=0; ilen); + for(j=0; jlen; j++) { + g_array_index(retval[i].mode_stack, GQuark, j) = g_array_index(states[i].mode_stack, GQuark, j); + } + } + + return retval; +} + +static void lttv_state_free_irq_states(LttvIRQState *states, guint n) +{ + guint i; + + for(i=0; ibdev_states, &devcode_gint); + if(bdev == NULL) { + LttvBdevState *bdevstate = g_malloc(sizeof(LttvBdevState)); + bdevstate->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark)); + + gint * key = g_malloc(sizeof(gint)); + *key = devcode; + g_hash_table_insert(ts->bdev_states, key, bdevstate); + + bdev = bdevstate; + } + + return bdev; +} + +static LttvBdevState *bdevstate_new(void) +{ + LttvBdevState *retval; + retval = g_malloc(sizeof(LttvBdevState)); + retval->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark)); + + return retval; +} + +static void bdevstate_free(LttvBdevState *bds) +{ + g_array_free(bds->mode_stack, TRUE); + g_free(bds); +} + +static void bdevstate_free_cb(gpointer key, gpointer value, gpointer user_data) +{ + LttvBdevState *bds = (LttvBdevState *) value; + + bdevstate_free(bds); +} + +static LttvBdevState *bdevstate_copy(LttvBdevState *bds) +{ + LttvBdevState *retval; + + retval = bdevstate_new(); + g_array_insert_vals(retval->mode_stack, 0, bds->mode_stack->data, bds->mode_stack->len); + + return retval; +} + +static void insert_and_copy_bdev_state(gpointer k, gpointer v, gpointer u) +{ + //GHashTable *ht = (GHashTable *)u; + LttvBdevState *bds = (LttvBdevState *)v; + LttvBdevState *newbds; + + newbds = bdevstate_copy(bds); + + g_hash_table_insert(u, k, newbds); +} + +static GHashTable *lttv_state_copy_blkdev_hashtable(GHashTable *ht) +{ + GHashTable *retval; + + retval = g_hash_table_new(g_int_hash, g_int_equal); + + g_hash_table_foreach(ht, insert_and_copy_bdev_state, retval); + + return retval; +} + +/* Free a hashtable and the LttvBdevState structures its values + * point to. */ + +static void lttv_state_free_blkdev_hashtable(GHashTable *ht) +{ + g_hash_table_foreach(ht, bdevstate_free_cb, NULL); + g_hash_table_destroy(ht); +} /* The saved state for each trace contains a member "processes", which stores a copy of the process table, and a member "tracefiles" with @@ -1062,7 +1285,7 @@ static GHashTable *lttv_state_copy_process_table(GHashTable *processes) static void state_save(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, nb_cpus; + guint i, nb_tracefile, nb_cpus, nb_irqs; LttvTracefileState *tfcs; @@ -1070,12 +1293,8 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) guint *running_process; - LttvAttributeType type; - LttvAttributeValue value; - LttvAttributeName name; - LttEventPosition *ep; tracefiles_tree = lttv_attribute_find_subdir(container, @@ -1134,12 +1353,36 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec); } } + + /* 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); + } + + /* save the irq state */ + nb_irqs = self->nb_irqs; + { + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_IRQS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_irq_states(self->irq_states, nb_irqs); + } + + /* save the blkdev states */ + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_BLKDEVS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_blkdev_hashtable(self->bdev_states); } static void state_restore(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, pid, nb_cpus; + guint i, nb_tracefile, pid, nb_cpus, nb_irqs; LttvTracefileState *tfcs; @@ -1180,12 +1423,30 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) g_assert(self->running_process[i] != NULL); } - nb_tracefile = self->parent.tracefiles->len; //g_tree_destroy(tsc->pqueue); //tsc->pqueue = g_tree_new(compare_tracefile); + + /* restore cpu resource states */ + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_CPUS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_cpu_states(self->cpu_states, nb_cpus); + self->cpu_states = lttv_state_copy_cpu_states(*(value.v_pointer), nb_cpus); + + /* restore 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(self->irq_states, nb_irqs); + self->irq_states = lttv_state_copy_irq_states(*(value.v_pointer), nb_irqs); + /* restore 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(self->bdev_states); + self->bdev_states = lttv_state_copy_blkdev_hashtable(*(value.v_pointer)); + for(i = 0 ; i < nb_tracefile ; i++) { tfcs = LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles, @@ -1206,6 +1467,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) //g_assert(*(value.v_pointer) != NULL); ep = *(value.v_pointer); g_assert(tfcs->parent.t_context != NULL); + + tfcs->cpu_state = &self->cpu_states[tfcs->cpu]; LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs); g_tree_remove(tsc->pqueue, tfc); @@ -1225,7 +1488,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; @@ -1241,8 +1504,6 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container) gboolean is_named; - LttEventPosition *ep; - tracefiles_tree = lttv_attribute_find_subdir(container, LTTV_STATE_TRACEFILES); g_object_ref(G_OBJECT(tracefiles_tree)); @@ -1256,13 +1517,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++) { @@ -1354,24 +1633,16 @@ typedef struct _LttvNameTables { GQuark *trap_names; guint nb_traps; GQuark *irq_names; + guint nb_irqs; GQuark *soft_irq_names; + guint nb_softirqs; } LttvNameTables; static void create_name_tables(LttvTraceState *tcs) { - int i, nb; - - GQuark f_name, e_name; - - LttvTraceHook h; - - LttvTraceHookByFacility *thf; - - LttEventType *et; - - LttType *t; + int i; GString *fe_name = g_string_new(""); @@ -1379,70 +1650,68 @@ create_name_tables(LttvTraceState *tcs) LttvAttributeValue v; + GArray *hooks; + lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES, LTTV_POINTER, &v); g_assert(*(v.v_pointer) == NULL); *(v.v_pointer) = name_tables; -#if 0 // Use iteration over the facilities_by_name and then list all event - // types of each facility - nb = ltt_trace_eventtype_number(tcs->parent.t); - name_tables->eventtype_names = g_new(GQuark, nb); - for(i = 0 ; i < nb ; i++) { - et = ltt_trace_eventtype_get(tcs->parent.t, i); - e_name = ltt_eventtype_name(et); - f_name = ltt_facility_name(ltt_eventtype_facility(et)); - g_string_printf(fe_name, "%s.%s", f_name, e_name); - name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str); - } -#endif //0 - 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)) { - - 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->nb_syscalls = nb; + hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 1); - for(i = 0 ; i < nb ; i++) { - name_tables->syscall_names[i] = ltt_enum_string_get(t, i); + 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(lttv_trace_get_hook_field(th, 0)); +// nb = ltt_type_element_number(t); +// +// 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); +// if(!name_tables->syscall_names[i]) { +// GString *string = g_string_new(""); +// g_string_printf(string, "syscall %u", i); +// name_tables->syscall_names[i] = g_quark_from_string(string->str); +// g_string_free(string, TRUE); +// } +// } + + 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); + 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; } + lttv_trace_hook_remove_all(&hooks); - if(!lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL, + if(!lttv_trace_find_hook(tcs->parent.t, + LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_TRAP_ENTRY, - LTT_FIELD_TRAP_ID, 0, 0, - NULL, NULL, &h)) { + FIELD_ARRAY(LTT_FIELD_TRAP_ID), + NULL, NULL, &hooks)) { + +// th = lttv_trace_hook_get_first(&th); +// +// 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); +// for(i = 0 ; i < nb ; i++) { +// name_tables->trap_names[i] = g_quark_from_string( +// ltt_enum_string_get(t, i)); +// } - 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->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->nb_traps = 256; name_tables->trap_names = g_new(GQuark, 256); for(i = 0 ; i < 256 ; i++) { @@ -1453,19 +1722,14 @@ create_name_tables(LttvTraceState *tcs) name_tables->trap_names = NULL; name_tables->nb_traps = 0; } + lttv_trace_hook_remove_all(&hooks); if(!lttv_trace_find_hook(tcs->parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY, - LTT_FIELD_IRQ_ID, 0, 0, - NULL, NULL, &h)) { - - thf = lttv_trace_hook_get_first(&h); + LTT_FACILITY_KERNEL, + LTT_EVENT_IRQ_ENTRY, + FIELD_ARRAY(LTT_FIELD_IRQ_ID), + NULL, NULL, &hooks)) { - t = ltt_field_type(thf->f1); - //nb = ltt_type_element_number(t); - - lttv_trace_hook_destroy(&h); - /* name_tables->irq_names = g_new(GQuark, nb); for(i = 0 ; i < nb ; i++) { @@ -1473,14 +1737,17 @@ create_name_tables(LttvTraceState *tcs) } */ + name_tables->nb_irqs = 256; 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->nb_irqs = 0; name_tables->irq_names = NULL; } + lttv_trace_hook_remove_all(&hooks); /* name_tables->soft_irq_names = g_new(GQuark, nb); for(i = 0 ; i < nb ; i++) { @@ -1488,12 +1755,13 @@ 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++) { g_string_printf(fe_name, "softirq %d", i); name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str); } - + g_array_free(hooks, TRUE); g_string_free(fe_name, TRUE); } @@ -1517,6 +1785,8 @@ get_name_tables(LttvTraceState *tcs) tcs->nb_traps = name_tables->nb_traps; 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; } @@ -1558,6 +1828,67 @@ static void hash_table_check(GHashTable *table) #endif +/* clears the stack and sets the state passed as argument */ +static void cpu_set_base_mode(LttvCPUState *cpust, LttvCPUMode state) +{ + g_array_set_size(cpust->mode_stack, 1); + ((GQuark *)cpust->mode_stack->data)[0] = state; +} + +static void cpu_push_mode(LttvCPUState *cpust, LttvCPUMode state) +{ + g_array_set_size(cpust->mode_stack, cpust->mode_stack->len + 1); + ((GQuark *)cpust->mode_stack->data)[cpust->mode_stack->len - 1] = state; +} + +static void cpu_pop_mode(LttvCPUState *cpust) +{ + if(cpust->mode_stack->len <= 1) + cpu_set_base_mode(cpust, LTTV_CPU_UNKNOWN); + else + g_array_set_size(cpust->mode_stack, cpust->mode_stack->len - 1); +} + +/* clears the stack and sets the state passed as argument */ +static void bdev_set_base_mode(LttvBdevState *bdevst, LttvBdevMode state) +{ + g_array_set_size(bdevst->mode_stack, 1); + ((GQuark *)bdevst->mode_stack->data)[0] = state; +} + +static void bdev_push_mode(LttvBdevState *bdevst, LttvBdevMode state) +{ + g_array_set_size(bdevst->mode_stack, bdevst->mode_stack->len + 1); + ((GQuark *)bdevst->mode_stack->data)[bdevst->mode_stack->len - 1] = state; +} + +static void bdev_pop_mode(LttvBdevState *bdevst) +{ + if(bdevst->mode_stack->len <= 1) + bdev_set_base_mode(bdevst, LTTV_BDEV_UNKNOWN); + else + g_array_set_size(bdevst->mode_stack, bdevst->mode_stack->len - 1); +} + +static void irq_set_base_mode(LttvIRQState *irqst, LttvIRQMode state) +{ + g_array_set_size(irqst->mode_stack, 1); + ((GQuark *)irqst->mode_stack->data)[0] = state; +} + +static void irq_push_mode(LttvIRQState *irqst, LttvIRQMode state) +{ + g_array_set_size(irqst->mode_stack, irqst->mode_stack->len + 1); + ((GQuark *)irqst->mode_stack->data)[irqst->mode_stack->len - 1] = state; +} + +static void irq_pop_mode(LttvIRQState *irqst) +{ + if(irqst->mode_stack->len <= 1) + irq_set_base_mode(irqst, LTTV_IRQ_UNKNOWN); + else + g_array_set_size(irqst->mode_stack, irqst->mode_stack->len - 1); +} static void push_state(LttvTracefileState *tfs, LttvExecutionMode t, guint state_id) @@ -1594,9 +1925,6 @@ static void push_state(LttvTracefileState *tfs, LttvExecutionMode t, 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){ @@ -1632,26 +1960,12 @@ static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t) g_quark_to_string(process->name), g_quark_to_string(process->brand), g_quark_to_string(process->state->s)); - g_printf("MATD1 Different execution mode type (%lu.%09lu): ignore it\n", - tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec); - g_printf("MATD1 process state has %s when pop_int is %s\n", - g_quark_to_string(process->state->t), - g_quark_to_string(t)); - g_printf("MATD1 { %u, %u, %s, %s, %s }\n", - process->pid, - process->ppid, - g_quark_to_string(process->name), - g_quark_to_string(process->brand), - g_quark_to_string(process->state->s)); - return; } if(depth == 1){ g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n", tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec); - g_printf("MATD1 Trying to pop last state on stack (%lu.%09lu): ignore it\n", - tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec); return; } @@ -1682,10 +1996,10 @@ static gint search_usertrace(gconstpointer a, gconstpointer b) /* Get smaller keys */ if(res->best) { if(ltt_time_compare(*elem_time, *res->best) < 0) { - res->best = elem_time; + res->best = (LttTime *)elem_time; } } else { - res->best = elem_time; + res->best = (LttTime *)elem_time; } return -1; } @@ -1722,8 +2036,6 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, LttvExecutionState *es; - LttvTraceContext *tc = (LttvTraceContext*)tcs; - char buffer[128]; process->pid = pid; @@ -1816,8 +2128,12 @@ lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid, NULL, cpu, pid, 0, 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); + process->execution_stack = + g_array_set_size(process->execution_stack, 1); + process->state = es = + &g_array_index(process->execution_stack, LttvExecutionState, 0); es->t = LTTV_STATE_MODE_UNKNOWN; + es->s = LTTV_STATE_UNNAMED; } return process; } @@ -1827,7 +2143,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) { @@ -1865,8 +2181,8 @@ static gboolean syscall_entry(void *hook_data, void *call_data) LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; LttEvent *e = ltt_tracefile_get_event(s->parent.tf); - LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; - LttField *f = thf->f1; + LttvTraceHook *th = (LttvTraceHook *)hook_data; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; @@ -1908,8 +2224,8 @@ static gboolean trap_entry(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 = thf->f1; + LttvTraceHook *th = (LttvTraceHook *)hook_data; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; @@ -1927,38 +2243,58 @@ static gboolean trap_entry(void *hook_data, void *call_data) } push_state(s, LTTV_STATE_TRAP, submode); + + /* update cpu status */ + cpu_push_mode(s->cpu_state, LTTV_CPU_TRAP); + return FALSE; } - static gboolean trap_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; pop_state(s, LTTV_STATE_TRAP); + + /* update cpu status */ + cpu_pop_mode(s->cpu_state); + return FALSE; } - static gboolean 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 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; + //guint8 ev_id = ltt_event_eventtype_id(e); + LttvTraceHook *th = (LttvTraceHook *)hook_data; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; + guint64 irq = ltt_event_get_long_unsigned(e, f); + guint64 nb_irqs = ((LttvTraceState *)(s->parent.t_context))->nb_irqs; - submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[ - ltt_event_get_unsigned(e, f)]; + if(irq < nb_irqs) { + submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[irq]; + } else { + /* Fixup an incomplete irq table */ + GString *string = g_string_new(""); + g_string_printf(string, "irq %llu", irq); + submode = g_quark_from_string(string->str); + g_string_free(string, TRUE); + } /* Do something with the info about being in user or system mode when int? */ push_state(s, LTTV_STATE_IRQ, submode); + + /* update cpu status */ + cpu_push_mode(s->cpu_state, LTTV_CPU_IRQ); + + /* update irq status */ + s->cpu_state->last_irq = irq; + irq_push_mode(&ts->irq_states[irq], LTTV_IRQ_BUSY); + return FALSE; } @@ -1975,8 +2311,16 @@ static gboolean soft_irq_exit(void *hook_data, void *call_data) static gboolean irq_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; pop_state(s, LTTV_STATE_IRQ); + + /* update cpu status */ + cpu_pop_mode(s->cpu_state); + + /* update irq status */ + irq_pop_mode(&ts->irq_states[s->cpu_state->last_irq]); + return FALSE; } @@ -1984,24 +2328,98 @@ 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; + //guint8 ev_id = ltt_event_eventtype_id(e); + LttvTraceHook *th = (LttvTraceHook *)hook_data; + 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; - submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[ - ltt_event_get_long_unsigned(e, f)]; + if(softirq < nb_softirqs) { + submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq]; + } else { + /* Fixup an incomplete irq table */ + GString *string = g_string_new(""); + g_string_printf(string, "softirq %llu", softirq); + submode = g_quark_from_string(string->str); + g_string_free(string, TRUE); + } /* 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 enum_interrupt(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; + + 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; + + return FALSE; +} + + +static gboolean bdev_request_issue(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; + + 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? */ + gpointer bdev = get_hashed_bdevstate(ts, devcode); + + if(oper == 0) + bdev_push_mode(bdev, LTTV_BDEV_BUSY_READING); + else + bdev_push_mode(bdev, LTTV_BDEV_BUSY_WRITING); + + return FALSE; +} + +static gboolean bdev_request_complete(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); + LttvTraceHook *th = (LttvTraceHook *)hook_data; + + 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? */ + gpointer bdev = get_hashed_bdevstate(ts, devcode); + + /* update block device */ + bdev_pop_mode(bdev); + + return FALSE; +} + static void push_function(LttvTracefileState *tfs, guint64 funcptr) { guint64 *new_func; @@ -2012,7 +2430,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); @@ -2058,11 +2476,9 @@ 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; + //guint8 ev_id = ltt_event_eventtype_id(e); + LttvTraceHook *th = (LttvTraceHook *)hook_data; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); guint64 funcptr = ltt_event_get_long_unsigned(e, f); push_function(s, funcptr); @@ -2073,15 +2489,11 @@ 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; + //guint8 ev_id = ltt_event_eventtype_id(e); + LttvTraceHook *th = (LttvTraceHook *)hook_data; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); guint64 funcptr = ltt_event_get_long_unsigned(e, f); - LttvExecutionSubmode submode; - pop_function(s, funcptr); return FALSE; } @@ -2092,16 +2504,16 @@ static gboolean schedchange(void *hook_data, void *call_data) guint cpu = s->cpu; LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process = ts->running_process[cpu]; - LttvProcessState *old_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; + LttvTraceHook *th = (LttvTraceHook *)hook_data; guint pid_in, pid_out; - gint state_out; + gint64 state_out; - pid_out = ltt_event_get_unsigned(e, thf->f1); - pid_in = ltt_event_get_unsigned(e, thf->f2); - state_out = ltt_event_get_int(e, thf->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)) { @@ -2117,24 +2529,31 @@ static gboolean schedchange(void *hook_data, void *call_data) //if(unlikely(process->pid != pid_out)) { // g_assert(process->pid == 0); //} - if(process->pid == 0 && process->state->t == LTTV_STATE_MODE_UNKNOWN) { - /* Scheduling out of pid 0 at beginning of the trace : - * we know for sure it is in syscall mode at this point. */ - g_assert(process->execution_stack->len == 1); - process->state->t = LTTV_STATE_SYSCALL; - } - if(unlikely(process->state->s == LTTV_STATE_EXIT)) { - process->state->s = LTTV_STATE_ZOMBIE; - process->state->change = s->parent.timestamp; + if(process->pid == 0 + && process->state->t == LTTV_STATE_MODE_UNKNOWN) { + if(pid_out == 0) { + /* Scheduling out of pid 0 at beginning of the trace : + * we know for sure it is in syscall mode at this point. */ + g_assert(process->execution_stack->len == 1); + process->state->t = LTTV_STATE_SYSCALL; + process->state->s = LTTV_STATE_WAIT; + process->state->change = s->parent.timestamp; + process->state->entry = s->parent.timestamp; + } } else { - if(unlikely(state_out == 0)) process->state->s = LTTV_STATE_WAIT_CPU; - else process->state->s = LTTV_STATE_WAIT; - process->state->change = s->parent.timestamp; + 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; + process->state->change = s->parent.timestamp; + } + + if(state_out == 32 || state_out == 64) + exit_process(s, process); /* EXIT_DEAD || TASK_DEAD */ + /* see sched.h for states */ } - - 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( @@ -2147,6 +2566,22 @@ static gboolean schedchange(void *hook_data, void *call_data) process->usertrace->cpu = cpu; // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf); process->state->change = s->parent.timestamp; + + /* update cpu status */ + if(pid_in == 0) + /* going to idle task */ + cpu_set_base_mode(s->cpu_state, LTTV_CPU_IDLE); + 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; } @@ -2154,26 +2589,30 @@ 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; + LttvTraceHook *th = (LttvTraceHook *)hook_data; guint parent_pid; guint child_pid; /* In the Linux Kernel, there is one PID per thread. */ guint child_tgid; /* tgid in the Linux kernel is the "real" POSIX PID. */ - LttvProcessState *zombie_process; + //LttvProcessState *zombie_process; guint cpu = s->cpu; 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, thf->f1); + parent_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); /* Child PID */ - child_pid = ltt_event_get_unsigned(e, thf->f2); + child_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 1)); s->parent.target_pid = child_pid; /* Child TGID */ - if(thf->f3) child_tgid = ltt_event_get_unsigned(e, thf->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 @@ -2223,24 +2662,28 @@ static gboolean process_fork(void *hook_data, void *call_data) return FALSE; } -/* We stamp a newly created process as kernel_thread */ +/* We stamp a newly created process as kernel_thread. + * The thread should not be running yet. */ 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; + LttvTraceHook *th = (LttvTraceHook *)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); + 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(ts, ANY_CPU, pid); - es = &g_array_index(process->execution_stack, LttvExecutionState, 0); + process = lttv_state_find_process_or_create(ts, ANY_CPU, pid, + <t_time_zero); + 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; process->type = LTTV_STATE_KERNEL_THREAD; @@ -2251,14 +2694,12 @@ static gboolean process_exit(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; + LttvTraceHook *th = (LttvTraceHook *)hook_data; guint pid; - guint cpu = s->cpu; LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; LttvProcessState *process; // = ts->running_process[cpu]; - pid = ltt_event_get_unsigned(e, thf->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 @@ -2276,12 +2717,12 @@ static gboolean process_free(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); - LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + LttvTraceHook *th = (LttvTraceHook *)hook_data; guint release_pid; LttvProcessState *process; /* PID of the process to release */ - release_pid = ltt_event_get_unsigned(e, thf->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); @@ -2323,24 +2764,30 @@ static gboolean process_exec(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); - LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + LttvTraceHook *th = (LttvTraceHook *)hook_data; //gchar *name; guint cpu = s->cpu; LttvProcessState *process = ts->running_process[cpu]; +#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); memcpy(null_term_name, name_begin, name_len); null_term_name[name_len] = '\0'; - process->name = g_quark_from_string(null_term_name); +#endif //0 + + 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); + //g_free(null_term_name); return FALSE; } @@ -2349,25 +2796,92 @@ static gboolean thread_brand(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); - LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + LttvTraceHook *th = (LttvTraceHook *)hook_data; gchar *name; guint cpu = s->cpu; LttvProcessState *process = ts->running_process[cpu]; - name = ltt_event_get_string(e, thf->f1); + name = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 0)); process->brand = g_quark_from_string(name); return FALSE; } +static void fix_process(gpointer key, gpointer value, + gpointer user_data) +{ + LttvProcessState *process; + LttvExecutionState *es; + process = (LttvProcessState *)value; + LttTime *timestamp = (LttTime*)user_data; + + if(process->type == LTTV_STATE_KERNEL_THREAD) { + es = &g_array_index(process->execution_stack, LttvExecutionState, 0); + if(es->t == LTTV_STATE_MODE_UNKNOWN) { + es->t = LTTV_STATE_SYSCALL; + es->n = LTTV_STATE_SUBMODE_NONE; + es->entry = *timestamp; + es->change = *timestamp; + es->cum_cpu_time = ltt_time_zero; + if(es->s == LTTV_STATE_UNNAMED) + es->s = LTTV_STATE_WAIT; + } + } else { + es = &g_array_index(process->execution_stack, LttvExecutionState, 0); + if(es->t == LTTV_STATE_MODE_UNKNOWN) { + es->t = LTTV_STATE_USER_MODE; + es->n = LTTV_STATE_SUBMODE_NONE; + es->entry = *timestamp; + //g_assert(timestamp->tv_sec != 0); + es->change = *timestamp; + es->cum_cpu_time = ltt_time_zero; + if(es->s == LTTV_STATE_UNNAMED) + es->s = LTTV_STATE_RUN; + + if(process->execution_stack->len == 1) { + /* Still in bottom unknown mode, means never did a system call + * May be either in user mode, syscall mode, running or waiting.*/ + /* FIXME : we may be tagging syscall mode when being user mode */ + process->execution_stack = + g_array_set_size(process->execution_stack, 2); + 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->cum_cpu_time = ltt_time_zero; + if(es->s == LTTV_STATE_WAIT_FORK) + es->s = LTTV_STATE_WAIT; + } + } + } +} + +static gboolean statedump_end(void *hook_data, void *call_data) +{ + LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState*)s->parent.t_context; + LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + //LttEvent *e = ltt_tracefile_get_event(s->parent.tf); + //LttvTraceHook *th = (LttvTraceHook *)hook_data; + + /* For all processes */ + /* if kernel thread, if stack[0] is unknown, set to syscall mode, wait */ + /* else, if stack[0] is unknown, set to user mode, running */ + + g_hash_table_foreach(ts->processes, fix_process, &tfc->timestamp); + + 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; + LttvTraceHook *th = (LttvTraceHook *)hook_data; guint parent_pid; guint pid; guint tgid; @@ -2376,117 +2890,150 @@ 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, *f7, *f8; + struct marker_field *f; GQuark type, mode, submode, status; LttvExecutionState *es; + guint i, nb_cpus; /* PID */ - pid = ltt_event_get_unsigned(e, thf->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, thf->f2); + parent_pid = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 1)); /* Command name */ - command = ltt_event_get_string(e, thf->f3); + command = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 2)); /* 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)); + 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 = ltt_eventtype_field_by_name(et, 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 = ltt_eventtype_field_by_name(et, 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 = ltt_eventtype_field_by_name(et, 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 = ltt_eventtype_field_by_name(et, 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); + for(i=0; ippid = parent_pid; + process->tgid = tgid; + process->name = g_quark_from_string(command); + es = + &g_array_index(process->execution_stack, LttvExecutionState, 0); + process->type = LTTV_STATE_KERNEL_THREAD; + } - /* The process might exist if a process was forked while performing the state - * 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, tgid, g_quark_from_string(command), - &s->parent.timestamp); - - /* Keep the stack bottom : a running user mode */ - /* Disabled because of inconsistencies in the current statedump states. */ - if(type == LTTV_STATE_KERNEL_THREAD) { - /* Only keep the bottom - * FIXME Kernel thread : can be in syscall or interrupt or trap. */ - /* Will cause expected trap when in fact being syscall (even after end of - * statedump event) - * Will cause expected interrupt when being syscall. (only before end of - * statedump event) */ - // This will cause a "popping last state on stack, ignoring it." - 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 { + /* The process might exist if a process was forked while performing the + * state 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, tgid, g_quark_from_string(command), + &s->parent.timestamp); + + /* Keep the stack bottom : a running user mode */ + /* Disabled because of inconsistencies in the current statedump states. */ + if(type == LTTV_STATE_KERNEL_THREAD) { + /* Only keep the bottom + * FIXME Kernel thread : can be in syscall or interrupt or trap. */ + /* Will cause expected trap when in fact being syscall (even after end of + * statedump event) + * Will cause expected interrupt when being syscall. (only before end of + * statedump event) */ + // This will cause a "popping last state on stack, ignoring it." + process->execution_stack = g_array_set_size(process->execution_stack, 1); + es = process->state = &g_array_index(process->execution_stack, + LttvExecutionState, 0); + process->type = LTTV_STATE_KERNEL_THREAD; + es->t = LTTV_STATE_MODE_UNKNOWN; + es->s = LTTV_STATE_UNNAMED; + es->n = LTTV_STATE_SUBMODE_UNKNOWN; + #if 0 + es->t = LTTV_STATE_SYSCALL; + es->s = status; + es->n = submode; + #endif //0 + } else { + /* User space process : + * bottom : user mode + * either currently running or scheduled out. + * can be scheduled out because interrupted in (user mode or in syscall) + * or because of an explicit call to the scheduler in syscall. Note that + * the scheduler call comes after the irq_exit, so never in interrupt + * context. */ + // temp workaround : set size to 1 : only have user mode bottom of stack. + // will cause g_info message of expected syscall mode when in fact being + // in user mode. Can also cause expected trap when in fact being user + // mode in the event of a page fault reenabling interrupts in the handler. + // Expected syscall and trap can also happen after the end of statedump + // This will cause a "popping last state on stack, ignoring it." + 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_MODE_UNKNOWN; + es->s = LTTV_STATE_UNNAMED; + es->n = LTTV_STATE_SUBMODE_UNKNOWN; + #if 0 + es->t = LTTV_STATE_USER_MODE; + es->s = status; + es->n = submode; + #endif //0 + } + #if 0 + /* UNKNOWN STATE */ + { + 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 { - /* User space process : - * bottom : user mode - * either currently running or scheduled out. - * can be scheduled out because interrupted in (user mode or in syscall) - * or because of an explicit call to the scheduler in syscall. Note that - * the scheduler call comes after the irq_exit, so never in interrupt - * context. */ - // temp workaround : set size to 1 : only have user mode bottom of stack. - // will cause g_info message of expected syscall mode when in fact being - // in user mode. Can also cause expected trap when in fact being user - // mode in the event of a page fault reenabling interrupts in the handler. - // Expected syscall and trap can also happen after the end of statedump - // This will cause a "popping last state on stack, ignoring it." - process->execution_stack = g_array_set_size(process->execution_stack, 1); + /* 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->tgid = tgid; + process->name = g_quark_from_string(command); + process->type = type; + es = + &g_array_index(process->execution_stack, LttvExecutionState, 0); #if 0 - es = process->state = &g_array_index(process->execution_stack, - LttvExecutionState, 1); - es->t = LTTV_STATE_USER_MODE; - es->s = status; - es->n = submode; + if(es->t == LTTV_STATE_MODE_UNKNOWN) { + if(type == LTTV_STATE_KERNEL_THREAD) + es->t = LTTV_STATE_SYSCALL; + else + es->t = LTTV_STATE_USER_MODE; + } #endif //0 + /* Don't mess around with the stack, it will eventually become + * ok after the end of state dump. */ } -#if 0 - /* UNKNOWN STATE */ - { - 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->tgid = tgid; - 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. */ } return FALSE; @@ -2505,7 +3052,7 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) { LttvTraceset *traceset = self->parent.ts; - guint i, j, k, l, nb_trace, nb_tracefile; + guint i, j, k, nb_trace, nb_tracefile; LttvTraceState *ts; @@ -2513,15 +3060,10 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) GArray *hooks; - LttvTraceHookByFacility *thf; + LttvTraceHook *th; - LttvTraceHook *hook; - 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]; @@ -2529,122 +3071,147 @@ 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), 18); - hooks = g_array_set_size(hooks, 18); // 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, LTT_FIELD_TGID, - 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, hn++)); - if(ret) hn--; + hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 19); + //hooks = g_array_set_size(hooks, 19); // Max possible number of hooks. + //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), + 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); - 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, 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, hn++)); - if(ret) hn--; - - ret = lttv_trace_find_hook(ts->parent.t, - LTT_FACILITY_USER_GENERIC, LTT_EVENT_THREAD_BRAND, - LTT_FIELD_NAME, 0, 0, - thread_brand, NULL, &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + 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 */ - 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); - + 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, + 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_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); + /* Add these hooks to each event_by_id hooks list */ nb_tracefile = ts->parent.tracefiles->len; @@ -2655,15 +3222,12 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) LttvTracefileContext*, j)); for(k = 0 ; k < hooks->len ; k++) { - hook = &g_array_index(hooks, LttvTraceHook, k); - for(l=0;lfac_list->len;l++) { - thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); + th = &g_array_index(hooks, LttvTraceHook, k); lttv_hooks_add( - lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id), - thf->h, - thf, + lttv_hooks_by_id_find(tfs->parent.event_by_id, th->id), + th->h, + th, LTTV_PRIO_STATE); - } } } lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val); @@ -2684,7 +3248,7 @@ void lttv_state_remove_event_hooks(LttvTracesetState *self) { LttvTraceset *traceset = self->parent.ts; - guint i, j, k, l, nb_trace, nb_tracefile; + guint i, j, k, nb_trace, nb_tracefile; LttvTraceState *ts; @@ -2692,9 +3256,7 @@ void lttv_state_remove_event_hooks(LttvTracesetState *self) GArray *hooks; - LttvTraceHook *hook; - - LttvTraceHookByFacility *thf; + LttvTraceHook *th; LttvAttributeValue val; @@ -2715,19 +3277,14 @@ void lttv_state_remove_event_hooks(LttvTracesetState *self) LttvTracefileContext*, j)); for(k = 0 ; k < hooks->len ; k++) { - hook = &g_array_index(hooks, LttvTraceHook, k); - for(l=0;lfac_list->len;l++) { - thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); - + th = &g_array_index(hooks, LttvTraceHook, k); lttv_hooks_remove_data( - lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id), - thf->h, - thf); - } + lttv_hooks_by_id_find(tfs->parent.event_by_id, th->id), + th->h, + th); } } - for(k = 0 ; k < hooks->len ; k++) - lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k)); + lttv_trace_hook_remove_all(&hooks); g_array_free(hooks, TRUE); } } @@ -2744,16 +3301,8 @@ static gboolean state_save_event_hook(void *hook_data, void *call_data) LttvTracefileState *self = (LttvTracefileState *)call_data; - LttvTracefileState *tfcs; - LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context); - LttEventPosition *ep; - - guint i; - - LttTracefile *tf; - LttvAttribute *saved_states_tree, *saved_state_tree; LttvAttributeValue value; @@ -3281,8 +3830,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"); @@ -3312,14 +3861,18 @@ static void module_init() LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables"); 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_BLKDEVS = g_quark_from_string("blkdevs resource states"); 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_FACILITY_LIST = g_quark_from_string("list"); LTT_FACILITY_USER_GENERIC = g_quark_from_string("user_generic"); + LTT_FACILITY_BLOCK = g_quark_from_string("block"); LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry"); @@ -3328,31 +3881,36 @@ 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_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_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"); + LTT_EVENT_PROCESS_EXIT = g_quark_from_string("process_exit"); + LTT_EVENT_PROCESS_FREE = g_quark_from_string("process_free"); LTT_EVENT_EXEC = g_quark_from_string("exec"); - LTT_EVENT_ENUM_PROCESS_STATE = g_quark_from_string("enumerate_process_state"); + LTT_EVENT_PROCESS_STATE = g_quark_from_string("process_state"); + LTT_EVENT_STATEDUMP_END = g_quark_from_string("statedump_end"); LTT_EVENT_FUNCTION_ENTRY = g_quark_from_string("function_entry"); LTT_EVENT_FUNCTION_EXIT = g_quark_from_string("function_exit"); LTT_EVENT_THREAD_BRAND = g_quark_from_string("thread_brand"); + LTT_EVENT_REQUEST_ISSUE = g_quark_from_string("_blk_request_issue"); + LTT_EVENT_REQUEST_COMPLETE = g_quark_from_string("_blk_request_complete"); + LTT_EVENT_LIST_INTERRUPT = g_quark_from_string("interrupt");; 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"); + LTT_FIELD_PREV_PID = g_quark_from_string("prev_pid"); + LTT_FIELD_NEXT_PID = g_quark_from_string("next_pid"); + LTT_FIELD_PREV_STATE = g_quark_from_string("prev_state"); LTT_FIELD_PARENT_PID = g_quark_from_string("parent_pid"); LTT_FIELD_CHILD_PID = g_quark_from_string("child_pid"); LTT_FIELD_PID = g_quark_from_string("pid"); LTT_FIELD_TGID = g_quark_from_string("tgid"); + LTT_FIELD_CHILD_TGID = g_quark_from_string("child_tgid"); LTT_FIELD_FILENAME = g_quark_from_string("filename"); LTT_FIELD_NAME = g_quark_from_string("name"); LTT_FIELD_TYPE = g_quark_from_string("type"); @@ -3361,7 +3919,25 @@ static void module_init() 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"); + LTT_FIELD_MAJOR = g_quark_from_string("major"); + LTT_FIELD_MINOR = g_quark_from_string("minor"); + LTT_FIELD_OPERATION = g_quark_from_string("direction"); + LTT_FIELD_ACTION = g_quark_from_string("action"); + 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_TRAP = g_quark_from_string("trap"); + + LTTV_IRQ_UNKNOWN = g_quark_from_string("unknown"); + LTTV_IRQ_IDLE = g_quark_from_string("idle"); + LTTV_IRQ_BUSY = g_quark_from_string("busy"); + + LTTV_BDEV_UNKNOWN = g_quark_from_string("unknown"); + LTTV_BDEV_IDLE = g_quark_from_string("idle"); + LTTV_BDEV_BUSY_READING = g_quark_from_string("busy_reading"); + LTTV_BDEV_BUSY_WRITING = g_quark_from_string("busy_writing"); } static void module_destroy()