X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=6fb3b2afd2d6450a9b8019e65e2ea5506f1737b8;hb=ec7a5af61127aa50a1839eee5be99ce53494c57b;hp=b15c616847d77276471919f5f1808a1eab055ac7;hpb=f61bce48a06a0a3516941ba31b73982d45da0f9e;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c index b15c6168..6fb3b2af 100644 --- a/ltt/branches/poly/lttv/lttv/state.c +++ b/ltt/branches/poly/lttv/lttv/state.c @@ -31,6 +31,7 @@ #include #include #include +#include /* Comment : * Mathieu Desnoyers @@ -52,7 +53,8 @@ GQuark LTT_FACILITY_LIST, LTT_FACILITY_FS, LTT_FACILITY_USER_GENERIC, - LTT_FACILITY_BLOCK; + LTT_FACILITY_BLOCK, + LTT_FACILITY_STATEDUMP; /* Events Quarks */ @@ -63,6 +65,7 @@ GQuark LTT_EVENT_TRAP_EXIT, LTT_EVENT_IRQ_ENTRY, LTT_EVENT_IRQ_EXIT, + LTT_EVENT_SOFT_IRQ_RAISE, LTT_EVENT_SOFT_IRQ_ENTRY, LTT_EVENT_SOFT_IRQ_EXIT, LTT_EVENT_SCHED_SCHEDULE, @@ -78,7 +81,9 @@ GQuark LTT_EVENT_THREAD_BRAND, LTT_EVENT_REQUEST_ISSUE, LTT_EVENT_REQUEST_COMPLETE, - LTT_EVENT_LIST_INTERRUPT; + LTT_EVENT_LIST_INTERRUPT, + LTT_EVENT_SYS_CALL_TABLE, + LTT_EVENT_SOFTIRQ_VEC; /* Fields Quarks */ @@ -106,7 +111,10 @@ GQuark LTT_FIELD_MINOR, LTT_FIELD_MAJOR, LTT_FIELD_OPERATION, - LTT_FIELD_ACTION; + LTT_FIELD_ACTION, + LTT_FIELD_ID, + LTT_FIELD_ADDRESS, + LTT_FIELD_SYMBOL; LttvExecutionMode LTTV_STATE_MODE_UNKNOWN, @@ -142,6 +150,7 @@ LttvCPUMode LTTV_CPU_IDLE, LTTV_CPU_BUSY, LTTV_CPU_IRQ, + LTTV_CPU_SOFT_IRQ, LTTV_CPU_TRAP; LttvIRQMode @@ -170,6 +179,8 @@ static GQuark LTTV_STATE_RESOURCE_CPUS, LTTV_STATE_RESOURCE_CPUS_COUNT, LTTV_STATE_RESOURCE_IRQS, + LTTV_STATE_RESOURCE_SOFT_IRQS, + LTTV_STATE_RESOURCE_TRAPS, LTTV_STATE_RESOURCE_BLKDEVS; static void create_max_time(LttvTraceState *tcs); @@ -253,12 +264,114 @@ 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 guint check_expand(nb, id) +{ + if(likely(nb > id)) + return nb; + else + return max(id + 1, nb * 2); +} + +static void expand_name_table(LttvTraceState *ts, GQuark **table, + guint nb, guint new_nb) +{ + /* Expand an incomplete table */ + GQuark *old_table = *table; + *table = g_new(GQuark, new_nb); + memcpy(*table, old_table, nb * sizeof(GQuark)); +} + +static void fill_name_table(LttvTraceState *ts, GQuark *table, guint nb, + guint new_nb, const char *def_string) +{ + guint i; + GString *fe_name = g_string_new(""); + for(i = nb; i < new_nb; i++) { + g_string_printf(fe_name, "%s %d", def_string, i); + table[i] = g_quark_from_string(fe_name->str); + } + g_string_free(fe_name, TRUE); +} + +static void expand_syscall_table(LttvTraceState *ts, int id) +{ + guint new_nb = check_expand(ts->nb_syscalls, id); + if(likely(new_nb == ts->nb_syscalls)) + return; + expand_name_table(ts, &ts->syscall_names, ts->nb_syscalls, new_nb); + fill_name_table(ts, ts->syscall_names, ts->nb_syscalls, new_nb, "syscall"); + /* Update the table size */ + ts->nb_syscalls = new_nb; +} + +static void expand_trap_table(LttvTraceState *ts, int id) +{ + guint new_nb = check_expand(ts->nb_traps, id); + guint i; + if(likely(new_nb == ts->nb_traps)) + return; + expand_name_table(ts, &ts->trap_names, ts->nb_traps, new_nb); + fill_name_table(ts, ts->trap_names, ts->nb_traps, new_nb, "trap"); + /* Update the table size */ + ts->nb_traps = new_nb; + + LttvTrapState *old_table = ts->trap_states; + ts->trap_states = g_new(LttvTrapState, new_nb); + memcpy(ts->trap_states, old_table, + ts->nb_traps * sizeof(LttvTrapState)); + for(i = ts->nb_traps; i < new_nb; i++) + ts->trap_states[i].running = 0; +} + +static void expand_irq_table(LttvTraceState *ts, int id) +{ + guint new_nb = check_expand(ts->nb_irqs, id); + guint i; + if(likely(new_nb == ts->nb_irqs)) + return; + expand_name_table(ts, &ts->irq_names, ts->nb_irqs, new_nb); + fill_name_table(ts, ts->irq_names, ts->nb_irqs, new_nb, "irq"); + + LttvIRQState *old_table = ts->irq_states; + ts->irq_states = g_new(LttvIRQState, new_nb); + memcpy(ts->irq_states, old_table, ts->nb_irqs * sizeof(LttvIRQState)); + for(i = ts->nb_irqs; i < new_nb; i++) { + ts->irq_states[i].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvIRQMode)); + } + /* Update the table size */ + ts->nb_irqs = new_nb; +} + +static void expand_soft_irq_table(LttvTraceState *ts, int id) +{ + guint new_nb = check_expand(ts->nb_soft_irqs, id); + guint i; + if(likely(new_nb == ts->nb_soft_irqs)) + return; + expand_name_table(ts, &ts->soft_irq_names, ts->nb_soft_irqs, new_nb); + fill_name_table(ts, ts->soft_irq_names, ts->nb_soft_irqs, new_nb, "softirq"); + + LttvSoftIRQState *old_table = ts->soft_irq_states; + ts->soft_irq_states = g_new(LttvSoftIRQState, new_nb); + memcpy(ts->soft_irq_states, old_table, + ts->nb_soft_irqs * sizeof(LttvSoftIRQState)); + for(i = ts->nb_soft_irqs; i < new_nb; i++) + ts->soft_irq_states[i].running = 0; + + /* Update the table size */ + ts->nb_soft_irqs = new_nb; +} static void restore_init_state(LttvTraceState *self) { - guint i, nb_cpus, nb_irqs; + guint i, nb_cpus, nb_irqs, nb_soft_irqs, nb_traps; //LttvTracefileState *tfcs; @@ -284,6 +397,8 @@ restore_init_state(LttvTraceState *self) nb_cpus = ltt_trace_get_num_cpu(self->parent.t); nb_irqs = self->nb_irqs; + nb_soft_irqs = self->nb_soft_irqs; + nb_traps = self->nb_traps; /* Put the per cpu running_process to beginning state : process 0. */ for(i=0; i< nb_cpus; i++) { @@ -314,9 +429,21 @@ restore_init_state(LttvTraceState *self) g_array_remove_range(self->irq_states[i].mode_stack, 0, self->irq_states[i].mode_stack->len); } + /* reset softirq states */ + for(i=0; isoft_irq_states[i].pending = 0; + self->soft_irq_states[i].running = 0; + } + + /* reset trap states */ + for(i=0; itrap_states[i].running = 0; + } + /* reset bdev states */ g_hash_table_foreach(self->bdev_states, bdevstate_free_cb, NULL); - g_hash_table_steal_all(self->bdev_states); + //g_hash_table_steal_all(self->bdev_states); + g_hash_table_foreach_steal(self->bdev_states, rettrue, NULL); #if 0 nb_tracefile = self->parent.tracefiles->len; @@ -482,6 +609,13 @@ init(LttvTracesetState *self, LttvTraceset *ts) g_assert(tcs->irq_states[j].mode_stack != NULL); } + /* init soft irq stuff */ + /* the kernel has a statically fixed max of 32 softirqs */ + tcs->soft_irq_states = g_new(LttvSoftIRQState, tcs->nb_soft_irqs); + + /* init trap stuff */ + tcs->trap_states = g_new(LttvTrapState, tcs->nb_traps); + /* init bdev resource stuff */ tcs->bdev_states = g_hash_table_new(g_int_hash, g_int_equal); @@ -590,7 +724,7 @@ static void write_process_state(gpointer key, gpointer value, process = (LttvProcessState *)value; fprintf(fp, -" \n", +" \n", process, process->pid, process->tgid, process->ppid, g_quark_to_string(process->type), process->creation_time.tv_sec, @@ -599,7 +733,7 @@ static void write_process_state(gpointer key, gpointer value, process->insertion_time.tv_nsec, g_quark_to_string(process->name), g_quark_to_string(process->brand), - process->cpu); + process->cpu, process->free_events); for(i = 0 ; i < process->execution_stack->len; i++) { es = &g_array_index(process->execution_stack, LttvExecutionState, i); @@ -700,6 +834,7 @@ static void write_process_state_raw(gpointer key, gpointer value, //fputc('\0', fp); fwrite(&process->brand, sizeof(process->brand), 1, fp); fwrite(&process->pid, sizeof(process->pid), 1, fp); + fwrite(&process->free_events, sizeof(process->free_events), 1, fp); fwrite(&process->tgid, sizeof(process->tgid), 1, fp); fwrite(&process->ppid, sizeof(process->ppid), 1, fp); fwrite(&process->cpu, sizeof(process->cpu), 1, fp); @@ -849,6 +984,7 @@ static void read_process_state_raw(LttvTraceState *self, FILE *fp, fread(&tmp.name, sizeof(tmp.name), 1, fp); fread(&tmp.brand, sizeof(tmp.brand), 1, fp); fread(&tmp.pid, sizeof(tmp.pid), 1, fp); + fread(&tmp.free_events, sizeof(tmp.free_events), 1, fp); fread(&tmp.tgid, sizeof(tmp.tgid), 1, fp); fread(&tmp.ppid, sizeof(tmp.ppid), 1, fp); fread(&tmp.cpu, sizeof(tmp.cpu), 1, fp); @@ -879,7 +1015,7 @@ static void read_process_state_raw(LttvTraceState *self, FILE *fp, (gchar*)g_ptr_array_index(quarktable, tmp.brand)); process->name = g_quark_from_string((gchar*)g_ptr_array_index(quarktable, tmp.name)); - + process->free_events = tmp.free_events; do { if(feof(fp) || ferror(fp)) goto end_loop; @@ -1136,7 +1272,7 @@ static LttvCPUState *lttv_state_copy_cpu_states(LttvCPUState *states, guint n) guint i,j; LttvCPUState *retval; - retval = g_malloc(n*sizeof(LttvCPUState)); + retval = g_new(LttvCPUState, n); for(i=0; ibdev_states, &devcode_gint); if(bdev == NULL) { - LttvBdevState *bdevstate = g_malloc(sizeof(LttvBdevState)); + LttvBdevState *bdevstate = g_new(LttvBdevState, 1); bdevstate->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark)); - gint * key = g_malloc(sizeof(gint)); + gint * key = g_new(gint, 1); *key = devcode; g_hash_table_insert(ts->bdev_states, key, bdevstate); @@ -1213,7 +1388,7 @@ static LttvBdevState *get_hashed_bdevstate(LttvTraceState *ts, guint16 devcode) static LttvBdevState *bdevstate_new(void) { LttvBdevState *retval; - retval = g_malloc(sizeof(LttvBdevState)); + retval = g_new(LttvBdevState, 1); retval->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark)); return retval; @@ -1221,7 +1396,7 @@ static LttvBdevState *bdevstate_new(void) static void bdevstate_free(LttvBdevState *bds) { - g_array_free(bds->mode_stack, FALSE); + g_array_free(bds->mode_stack, TRUE); g_free(bds); } @@ -1281,7 +1456,7 @@ static void lttv_state_free_blkdev_hashtable(GHashTable *ht) static void state_save(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, nb_cpus, nb_irqs; + guint i, nb_tracefile, nb_cpus, nb_irqs, nb_soft_irqs, nb_traps; LttvTracefileState *tfcs; @@ -1369,6 +1544,22 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) *(value.v_pointer) = lttv_state_copy_irq_states(self->irq_states, nb_irqs); } + /* save the soft irq state */ + nb_soft_irqs = self->nb_soft_irqs; + { + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_SOFT_IRQS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_soft_irq_states(self->soft_irq_states, nb_soft_irqs); + } + + /* save the trap state */ + nb_traps = self->nb_traps; + { + value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_TRAPS, + LTTV_POINTER); + *(value.v_pointer) = lttv_state_copy_trap_states(self->trap_states, nb_traps); + } + /* save the blkdev states */ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_BLKDEVS, LTTV_POINTER); @@ -1378,7 +1569,7 @@ static void state_save(LttvTraceState *self, LttvAttribute *container) static void state_restore(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, pid, nb_cpus, nb_irqs; + guint i, nb_tracefile, pid, nb_cpus, nb_irqs, nb_soft_irqs, nb_traps; LttvTracefileState *tfcs; @@ -1437,6 +1628,20 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) lttv_state_free_irq_states(self->irq_states, nb_irqs); self->irq_states = lttv_state_copy_irq_states(*(value.v_pointer), nb_irqs); + /* restore soft irq resource states */ + nb_soft_irqs = self->nb_soft_irqs; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_SOFT_IRQS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_soft_irq_states(self->soft_irq_states, nb_soft_irqs); + self->soft_irq_states = lttv_state_copy_soft_irq_states(*(value.v_pointer), nb_soft_irqs); + + /* restore trap resource states */ + nb_traps = self->nb_traps; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_TRAPS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_trap_states(self->trap_states, nb_traps); + self->trap_states = lttv_state_copy_trap_states(*(value.v_pointer), nb_traps); + /* restore the blkdev states */ type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value); g_assert(type == LTTV_POINTER); @@ -1484,7 +1689,7 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container) static void state_saved_free(LttvTraceState *self, LttvAttribute *container) { - guint i, nb_tracefile, nb_cpus, nb_irqs; + guint i, nb_tracefile, nb_cpus, nb_irqs, nb_softirqs; LttvTracefileState *tfcs; @@ -1533,6 +1738,12 @@ static void state_saved_free(LttvTraceState *self, LttvAttribute *container) g_assert(type == LTTV_POINTER); lttv_state_free_irq_states(*(value.v_pointer), nb_irqs); + /* free softirq resource states */ + nb_softirqs = self->nb_irqs; + type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_SOFT_IRQS, &value); + g_assert(type == LTTV_POINTER); + lttv_state_free_soft_irq_states(*(value.v_pointer), nb_softirqs); + /* free the blkdev states */ type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value); g_assert(type == LTTV_POINTER); @@ -1751,9 +1962,10 @@ create_name_tables(LttvTraceState *tcs) } */ - name_tables->nb_softirqs = 256; - name_tables->soft_irq_names = g_new(GQuark, 256); - for(i = 0 ; i < 256 ; i++) { + /* the kernel is limited to 32 statically defined softirqs */ + name_tables->nb_softirqs = 32; + name_tables->soft_irq_names = g_new(GQuark, name_tables->nb_softirqs); + for(i = 0 ; i < name_tables->nb_softirqs ; i++) { g_string_printf(fe_name, "softirq %d", i); name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str); } @@ -1782,7 +1994,7 @@ get_name_tables(LttvTraceState *tcs) tcs->irq_names = name_tables->irq_names; tcs->soft_irq_names = name_tables->soft_irq_names; tcs->nb_irqs = name_tables->nb_irqs; - tcs->nb_softirqs = name_tables->nb_softirqs; + tcs->nb_soft_irqs = name_tables->nb_softirqs; } @@ -2067,6 +2279,7 @@ lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent, process->creation_time.tv_nsec); process->pid_time = g_quark_from_string(buffer); process->cpu = cpu; + process->free_events = 0; //process->last_cpu = tfs->cpu_name; //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf); process->execution_stack = g_array_sized_new(FALSE, FALSE, @@ -2139,19 +2352,25 @@ 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) +static int exit_process(LttvTracefileState *tfs, LttvProcessState *process) { LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context); LttvProcessState key; + /* Wait for both schedule with exit dead and process free to happen. + * They can happen in any order. */ + if (++(process->free_events) < 2) + return 0; + key.pid = process->pid; 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); + return 1; } @@ -2179,22 +2398,11 @@ static gboolean syscall_entry(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(s->parent.tf); LttvTraceHook *th = (LttvTraceHook *)hook_data; struct marker_field *f = lttv_trace_get_hook_field(th, 0); - LttvExecutionSubmode submode; - 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); - } + expand_syscall_table(ts, syscall); + submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[syscall]; /* There can be no system call from PID 0 : unknown state */ if(process->pid != 0) push_state(s, LTTV_STATE_SYSCALL, submode); @@ -2219,42 +2427,46 @@ static gboolean syscall_exit(void *hook_data, void *call_data) static gboolean trap_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); LttvTraceHook *th = (LttvTraceHook *)hook_data; struct marker_field *f = lttv_trace_get_hook_field(th, 0); LttvExecutionSubmode submode; - guint64 nb_traps = ((LttvTraceState *)(s->parent.t_context))->nb_traps; guint64 trap = ltt_event_get_long_unsigned(e, f); - if(trap < nb_traps) { - submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[trap]; - } else { - /* Fixup an incomplete trap table */ - GString *string = g_string_new(""); - g_string_printf(string, "trap %llu", trap); - submode = g_quark_from_string(string->str); - g_string_free(string, TRUE); - } + expand_trap_table(ts, trap); + + submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[trap]; push_state(s, LTTV_STATE_TRAP, submode); /* update cpu status */ cpu_push_mode(s->cpu_state, LTTV_CPU_TRAP); + /* update trap status */ + s->cpu_state->last_trap = trap; + ts->trap_states[trap].running++; + return FALSE; } static gboolean trap_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; + guint trap = s->cpu_state->last_trap; pop_state(s, LTTV_STATE_TRAP); /* update cpu status */ cpu_pop_mode(s->cpu_state); + /* update trap status */ + if(ts->trap_states[trap].running) + ts->trap_states[trap].running--; + return FALSE; } @@ -2269,17 +2481,10 @@ static gboolean irq_entry(void *hook_data, void *call_data) LttvExecutionSubmode submode; guint64 irq = ltt_event_get_long_unsigned(e, f); - guint64 nb_irqs = ((LttvTraceState *)(s->parent.t_context))->nb_irqs; - 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); - } + expand_irq_table(ts, irq); + + submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[irq]; /* Do something with the info about being in user or system mode when int? */ push_state(s, LTTV_STATE_IRQ, submode); @@ -2297,12 +2502,20 @@ static gboolean irq_entry(void *hook_data, void *call_data) static gboolean soft_irq_exit(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; + guint softirq = s->cpu_state->last_soft_irq; pop_state(s, LTTV_STATE_SOFT_IRQ); - return FALSE; -} + /* update softirq status */ + if(ts->soft_irq_states[softirq].running) + ts->soft_irq_states[softirq].running--; + + /* update cpu status */ + cpu_pop_mode(s->cpu_state); + return FALSE; +} static gboolean irq_exit(void *hook_data, void *call_data) { @@ -2320,9 +2533,10 @@ static gboolean irq_exit(void *hook_data, void *call_data) return FALSE; } -static gboolean soft_irq_entry(void *hook_data, void *call_data) +static gboolean soft_irq_raise(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; @@ -2330,7 +2544,7 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data) LttvExecutionSubmode submode; guint64 softirq = ltt_event_get_long_unsigned(e, f); - guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_softirqs; + guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_soft_irqs; if(softirq < nb_softirqs) { submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq]; @@ -2342,8 +2556,38 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data) g_string_free(string, TRUE); } + /* update softirq status */ + /* a soft irq raises are not cumulative */ + ts->soft_irq_states[softirq].pending=1; + + return FALSE; +} + +static gboolean soft_irq_entry(void *hook_data, void *call_data) +{ + LttvTracefileState *s = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)s->parent.t_context; + LttEvent *e = ltt_tracefile_get_event(s->parent.tf); + //guint8 ev_id = ltt_event_eventtype_id(e); + LttvTraceHook *th = (LttvTraceHook *)hook_data; + struct marker_field *f = lttv_trace_get_hook_field(th, 0); + LttvExecutionSubmode submode; + guint64 softirq = ltt_event_get_long_unsigned(e, f); + expand_soft_irq_table(ts, softirq); + submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq]; + /* Do something with the info about being in user or system mode when int? */ push_state(s, LTTV_STATE_SOFT_IRQ, submode); + + /* update cpu status */ + cpu_push_mode(s->cpu_state, LTTV_CPU_SOFT_IRQ); + + /* update softirq status */ + s->cpu_state->last_soft_irq = softirq; + if(ts->soft_irq_states[softirq].pending) + ts->soft_irq_states[softirq].pending--; + ts->soft_irq_states[softirq].running++; + return FALSE; } @@ -2359,6 +2603,7 @@ static gboolean enum_interrupt(void *hook_data, void *call_data) lttv_trace_get_hook_field(th, 0))); guint irq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1)); + expand_irq_table(ts, irq); ts->irq_names[irq] = action; return FALSE; @@ -2494,6 +2739,46 @@ static gboolean function_exit(void *hook_data, void *call_data) return FALSE; } +static gboolean dump_syscall(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 id; + guint64 address; + char *symbol; + + id = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); + address = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1)); + symbol = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 2)); + + expand_syscall_table(ts, id); + ts->syscall_names[id] = g_quark_from_string(symbol); + + return FALSE; +} + +static gboolean dump_softirq(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 id; + guint64 address; + char *symbol; + + id = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 0)); + address = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1)); + symbol = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 2)); + + expand_soft_irq_table(ts, id); + ts->soft_irq_names[id] = g_quark_from_string(symbol); + + return FALSE; +} + static gboolean schedchange(void *hook_data, void *call_data) { LttvTracefileState *s = (LttvTracefileState *)call_data; @@ -2546,9 +2831,13 @@ static gboolean schedchange(void *hook_data, void *call_data) process->state->change = s->parent.timestamp; } - if(state_out == 32 || state_out == 128) - exit_process(s, process); /* EXIT_DEAD || TASK_DEAD */ - /* see sched.h for states */ + if(state_out == 32 || state_out == 64) { /* EXIT_DEAD || TASK_DEAD */ + /* see sched.h for states */ + if (!exit_process(s, process)) { + process->state->s = LTTV_STATE_DEAD; + process->state->change = s->parent.timestamp; + } + } } } process = ts->running_process[cpu] = @@ -2565,9 +2854,18 @@ static gboolean schedchange(void *hook_data, void *call_data) /* update cpu status */ if(pid_in == 0) + /* going to idle task */ cpu_set_base_mode(s->cpu_state, LTTV_CPU_IDLE); - else + else { + /* scheduling a real task. + * we must be careful here: + * if we just schedule()'ed to a process that is + * in a trap, we must put the cpu in trap mode + */ cpu_set_base_mode(s->cpu_state, LTTV_CPU_BUSY); + if(process->state->t == LTTV_STATE_TRAP) + cpu_push_mode(s->cpu_state, LTTV_CPU_TRAP); + } return FALSE; } @@ -2637,8 +2935,9 @@ static gboolean process_fork(void *hook_data, void *call_data) * * Simply put a correct parent. */ - g_assert(0); /* This is a problematic case : the process has been created - before the fork event */ + g_error("Process %u has been created before fork on cpu %u. Probably an unsynchronized TSC problem on the traced machine.", child_pid, cpu); + //g_assert(0); /* This is a problematic case : the process has been created + // before the fork event */ child_process->ppid = process->pid; child_process->tgid = child_tgid; } @@ -2667,11 +2966,13 @@ static gboolean process_kernel_thread(void *hook_data, void *call_data) 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; + if (process->state->s != LTTV_STATE_DEAD) { + 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; return FALSE; @@ -2715,7 +3016,10 @@ static gboolean process_free(void *hook_data, void *call_data) g_assert(release_pid != 0); process = lttv_state_find_process(ts, ANY_CPU, release_pid); - + if(likely(process != NULL)) + exit_process(s, process); + return FALSE; +//DISABLED if(likely(process != NULL)) { /* release_task is happening at kernel level : we can now safely release * the data structure of the process */ @@ -3098,6 +3402,12 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) NULL, irq_exit, NULL, &hooks); + lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SOFT_IRQ_RAISE, + FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID), + soft_irq_raise, NULL, &hooks); + lttv_trace_find_hook(ts->parent.t, LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY, @@ -3199,6 +3509,18 @@ void lttv_state_add_event_hooks(LttvTracesetState *self) FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), function_exit, NULL, &hooks); + lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_STATEDUMP, + LTT_EVENT_SYS_CALL_TABLE, + FIELD_ARRAY(LTT_FIELD_ID, LTT_FIELD_ADDRESS, LTT_FIELD_SYMBOL), + dump_syscall, NULL, &hooks); + + lttv_trace_find_hook(ts->parent.t, + LTT_FACILITY_STATEDUMP, + LTT_EVENT_SOFTIRQ_VEC, + FIELD_ARRAY(LTT_FIELD_ID, LTT_FIELD_ADDRESS, LTT_FIELD_SYMBOL), + dump_softirq, NULL, &hooks); + /* Add these hooks to each event_by_id hooks list */ nb_tracefile = ts->parent.tracefiles->len; @@ -3851,6 +4173,8 @@ static void module_init() LTTV_STATE_RESOURCE_CPUS = g_quark_from_string("cpu resource states"); LTTV_STATE_RESOURCE_CPUS = g_quark_from_string("cpu count"); LTTV_STATE_RESOURCE_IRQS = g_quark_from_string("irq resource states"); + LTTV_STATE_RESOURCE_SOFT_IRQS = g_quark_from_string("soft irq resource states"); + LTTV_STATE_RESOURCE_TRAPS = g_quark_from_string("trap resource states"); LTTV_STATE_RESOURCE_BLKDEVS = g_quark_from_string("blkdevs resource states"); @@ -3860,14 +4184,15 @@ static void module_init() 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_FACILITY_STATEDUMP = g_quark_from_string("statedump"); + LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry"); LTT_EVENT_SYSCALL_EXIT = g_quark_from_string("syscall_exit"); LTT_EVENT_TRAP_ENTRY = g_quark_from_string("trap_entry"); 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_RAISE = g_quark_from_string("softirq_raise"); 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"); @@ -3883,8 +4208,9 @@ static void module_init() 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_EVENT_LIST_INTERRUPT = g_quark_from_string("interrupt"); + LTT_EVENT_SYS_CALL_TABLE = g_quark_from_string("sys_call_table"); + LTT_EVENT_SOFTIRQ_VEC = g_quark_from_string("softirq_vec"); LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id"); LTT_FIELD_TRAP_ID = g_quark_from_string("trap_id"); @@ -3910,11 +4236,15 @@ static void module_init() LTT_FIELD_MINOR = g_quark_from_string("minor"); LTT_FIELD_OPERATION = g_quark_from_string("direction"); LTT_FIELD_ACTION = g_quark_from_string("action"); + LTT_FIELD_ID = g_quark_from_string("id"); + LTT_FIELD_ADDRESS = g_quark_from_string("address"); + LTT_FIELD_SYMBOL = g_quark_from_string("symbol"); LTTV_CPU_UNKNOWN = g_quark_from_string("unknown"); LTTV_CPU_IDLE = g_quark_from_string("idle"); LTTV_CPU_BUSY = g_quark_from_string("busy"); LTTV_CPU_IRQ = g_quark_from_string("irq"); + LTTV_CPU_SOFT_IRQ = g_quark_from_string("softirq"); LTTV_CPU_TRAP = g_quark_from_string("trap"); LTTV_IRQ_UNKNOWN = g_quark_from_string("unknown");