X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstats.c;h=0bfb45462d9d6eee7fa5207b795afb36a3f2acb5;hb=c7146c5c1e676a169708c76bc29534067b951fb5;hp=6370720aa81867361181afacf37bbc338015f5e9;hpb=a5845ab3269869d508937a3b3c8c752c48832d42;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/stats.c b/ltt/branches/poly/lttv/lttv/stats.c index 6370720a..0bfb4546 100644 --- a/ltt/branches/poly/lttv/lttv/stats.c +++ b/ltt/branches/poly/lttv/lttv/stats.c @@ -25,10 +25,8 @@ #include #include #include -#include #include #include -#include #define BUF_SIZE 256 #define MAX_64_HEX_STRING_LEN 19 @@ -40,7 +38,7 @@ GQuark LTTV_STATS_MODE_TYPES, LTTV_STATS_MODES, LTTV_STATS_SUBMODES, - LTTV_STATS_FUNCTIONS, + LTTV_STATS_FUNCTIONS, LTTV_STATS_EVENT_TYPES, LTTV_STATS_CPU_TIME, LTTV_STATS_CUMULATIVE_CPU_TIME, @@ -56,7 +54,7 @@ GQuark static void find_event_tree(LttvTracefileStats *tfcs, GQuark pid_time, guint cpu, - guint64 function, + guint64 function, GQuark mode, GQuark sub_mode, LttvAttribute **events_tree, LttvAttribute **event_types_tree); @@ -69,18 +67,12 @@ static void lttv_stats_init(LttvTracesetStats *self) LttvTraceStats *tcs; - LttvTracefileContext *tfc; - LttvTracefileContext **tfs; LttvTracefileStats *tfcs; - LttTime timestamp = {0,0}; - LttvAttributeValue v; - LttvAttribute - *stats_tree, - *tracefiles_stats; + LttvAttribute *tracefiles_stats; LttvTraceset *ts = self->parent.parent.ts; @@ -121,10 +113,10 @@ static void lttv_stats_init(LttvTracesetStats *self) tfcs = LTTV_TRACEFILE_STATS(*tfs); tfcs->stats = lttv_attribute_find_subdir(tracefiles_stats, ltt_tracefile_long_name(tfcs->parent.parent.tf)); - guint cpu = tfcs->parent.cpu; + guint cpu = tfcs->parent.cpu; find_event_tree(tfcs, LTTV_STATS_PROCESS_UNKNOWN, - cpu, - 0x0ULL, + cpu, + 0x0ULL, LTTV_STATE_MODE_UNKNOWN, LTTV_STATE_SUBMODE_UNKNOWN, &tfcs->current_events_tree, &tfcs->current_event_types_tree); @@ -147,8 +139,6 @@ static void lttv_stats_fini(LttvTracesetStats *self) LttvTracefileStats *tfcs; - LttTime timestamp = {0,0}; - LttvAttributeValue v; LttvAttribute *tracefiles_stats; @@ -393,25 +383,24 @@ lttv_tracefile_stats_get_type(void) return type; } - static void find_event_tree(LttvTracefileStats *tfcs, GQuark pid_time, guint cpu, - guint64 function, + guint64 function, GQuark mode, GQuark sub_mode, LttvAttribute **events_tree, LttvAttribute **event_types_tree) { - LttvAttribute *a, *prev_a; - gchar fstring[MAX_64_HEX_STRING_LEN]; - gint ret; + LttvAttribute *a; + gchar fstring[MAX_64_HEX_STRING_LEN]; + gint ret; - ret = snprintf(fstring, MAX_64_HEX_STRING_LEN-1, - "0x%llX", function) > 0; - g_assert(ret > 0); - fstring[MAX_64_HEX_STRING_LEN-1] = '\0'; + ret = snprintf(fstring, MAX_64_HEX_STRING_LEN-1, + "0x%llX", function) > 0; + g_assert(ret > 0); + fstring[MAX_64_HEX_STRING_LEN-1] = '\0'; LttvTraceStats *tcs = (LttvTraceStats*)tfcs->parent.parent.t_context; a = lttv_attribute_find_subdir(tcs->stats, LTTV_STATS_PROCESSES); @@ -429,44 +418,63 @@ find_event_tree(LttvTracefileStats *tfcs, *event_types_tree = a; } - -static void update_event_tree(LttvTracefileStats *tfcs) +static void update_event_tree(LttvTracefileStats *tfcs) { - LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context; guint cpu = tfcs->parent.cpu; + LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context; LttvProcessState *process = ts->running_process[cpu]; LttvExecutionState *es = process->state; find_event_tree(tfcs, process->pid_time, cpu, - process->current_function, + process->current_function, es->t, es->n, &(tfcs->current_events_tree), &(tfcs->current_event_types_tree)); } +/* Update the trace event tree for the specified cpu */ +static void update_trace_event_tree(LttvTraceStats *tcs) +{ + LttvTracefileStats *tfcs; + LttvTraceContext *tc = (LttvTraceContext*)tcs; + guint j, nb_tracefile; + + /* For each tracefile, update the event tree */ + nb_tracefile = tc->tracefiles->len; + for(j = 0; j < nb_tracefile; j++) { + tfcs = LTTV_TRACEFILE_STATS(g_array_index(tc->tracefiles, + LttvTracefileContext*, j)); + update_event_tree(tfcs); + } +} + static void mode_change(LttvTracefileStats *tfcs) { LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context; guint cpu = tfcs->parent.cpu; LttvProcessState *process = ts->running_process[cpu]; - LttvAttributeValue cpu_time, cum_cpu_time; + LttvAttributeValue cpu_time; LttTime delta; - delta = ltt_time_sub(tfcs->parent.parent.timestamp, - process->state->change); + if(process->state->s == LTTV_STATE_RUN && + process->state->t != LTTV_STATE_MODE_UNKNOWN) + delta = ltt_time_sub(tfcs->parent.parent.timestamp, + process->state->change); + else + delta = ltt_time_zero; lttv_attribute_find(tfcs->current_events_tree, LTTV_STATS_CPU_TIME, LTTV_TIME, &cpu_time); *(cpu_time.v_time) = ltt_time_add(*(cpu_time.v_time), delta); process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time, - delta); + delta); } /* Note : every mode_end must come with a cumulative cpu time update in the - * after hook */ + * after hook. */ static void mode_end(LttvTracefileStats *tfcs) { LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context; @@ -476,24 +484,40 @@ static void mode_end(LttvTracefileStats *tfcs) LttTime delta; + /* FIXME put there in case of a missing update after a state modification */ + //void *lasttree = tfcs->current_events_tree; + //update_event_tree(tfcs); + //g_assert (lasttree == tfcs->current_events_tree); lttv_attribute_find(tfcs->current_events_tree, LTTV_STATS_ELAPSED_TIME, LTTV_TIME, &elapsed_time); - delta = ltt_time_sub(tfcs->parent.parent.timestamp, - process->state->entry); + + if(process->state->t != LTTV_STATE_MODE_UNKNOWN) { + delta = ltt_time_sub(tfcs->parent.parent.timestamp, + process->state->entry); + } else + delta = ltt_time_zero; + *(elapsed_time.v_time) = ltt_time_add(*(elapsed_time.v_time), delta); lttv_attribute_find(tfcs->current_events_tree, LTTV_STATS_CPU_TIME, LTTV_TIME, &cpu_time); - delta = ltt_time_sub(tfcs->parent.parent.timestamp, - process->state->change); + + /* if it is a running mode, we must count its cpu time */ + if(process->state->s == LTTV_STATE_RUN && + process->state->t != LTTV_STATE_MODE_UNKNOWN) + delta = ltt_time_sub(tfcs->parent.parent.timestamp, + process->state->change); + else + delta = ltt_time_zero; + *(cpu_time.v_time) = ltt_time_add(*(cpu_time.v_time), delta); process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time, - delta); + delta); lttv_attribute_find(tfcs->current_events_tree, LTTV_STATS_CUMULATIVE_CPU_TIME, LTTV_TIME, &cum_cpu_time); *(cum_cpu_time.v_time) = ltt_time_add(*(cum_cpu_time.v_time), - process->state->cum_cpu_time); + process->state->cum_cpu_time); } @@ -502,17 +526,16 @@ static void after_mode_end(LttvTracefileStats *tfcs) LttvTraceState *ts = (LttvTraceState *)tfcs->parent.parent.t_context; guint cpu = tfcs->parent.cpu; LttvProcessState *process = ts->running_process[cpu]; - LttvAttributeValue cum_cpu_time; LttTime nested_delta; nested_delta = process->state->cum_cpu_time; - process->state->cum_cpu_time = ltt_time_zero; /* For after traceset hook */ + process->state->cum_cpu_time = ltt_time_zero; /* For after traceset hook */ update_event_tree(tfcs); process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time, - nested_delta); + nested_delta); } static gboolean before_syscall_entry(void *hook_data, void *call_data) @@ -529,7 +552,7 @@ static gboolean after_syscall_entry(void *hook_data, void *call_data) } -gboolean before_syscall_exit(void *hook_data, void *call_data) +static gboolean before_syscall_exit(void *hook_data, void *call_data) { mode_end((LttvTracefileStats *)call_data); return FALSE; @@ -543,7 +566,7 @@ static gboolean after_syscall_exit(void *hook_data, void *call_data) } -gboolean before_trap_entry(void *hook_data, void *call_data) +static gboolean before_trap_entry(void *hook_data, void *call_data) { mode_change((LttvTracefileStats *)call_data); return FALSE; @@ -557,124 +580,120 @@ static gboolean after_trap_entry(void *hook_data, void *call_data) } -gboolean before_trap_exit(void *hook_data, void *call_data) +static gboolean before_trap_exit(void *hook_data, void *call_data) { mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_trap_exit(void *hook_data, void *call_data) +static gboolean after_trap_exit(void *hook_data, void *call_data) { after_mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean before_irq_entry(void *hook_data, void *call_data) +static gboolean before_irq_entry(void *hook_data, void *call_data) { mode_change((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_irq_entry(void *hook_data, void *call_data) +static gboolean after_irq_entry(void *hook_data, void *call_data) { update_event_tree((LttvTracefileStats *)call_data); return FALSE; } -gboolean before_irq_exit(void *hook_data, void *call_data) +static gboolean before_irq_exit(void *hook_data, void *call_data) { mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_irq_exit(void *hook_data, void *call_data) +static gboolean after_irq_exit(void *hook_data, void *call_data) { after_mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean before_soft_irq_entry(void *hook_data, void *call_data) +static gboolean before_soft_irq_entry(void *hook_data, void *call_data) { mode_change((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_soft_irq_entry(void *hook_data, void *call_data) +static gboolean after_soft_irq_entry(void *hook_data, void *call_data) { update_event_tree((LttvTracefileStats *)call_data); return FALSE; } - -gboolean before_soft_irq_exit(void *hook_data, void *call_data) +static gboolean before_soft_irq_exit(void *hook_data, void *call_data) { mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_soft_irq_exit(void *hook_data, void *call_data) +static gboolean after_soft_irq_exit(void *hook_data, void *call_data) { after_mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean before_function_entry(void *hook_data, void *call_data) +static gboolean before_function_entry(void *hook_data, void *call_data) { mode_change((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_function_entry(void *hook_data, void *call_data) +static gboolean after_function_entry(void *hook_data, void *call_data) { update_event_tree((LttvTracefileStats *)call_data); return FALSE; } -gboolean before_function_exit(void *hook_data, void *call_data) +static gboolean before_function_exit(void *hook_data, void *call_data) { mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean after_function_exit(void *hook_data, void *call_data) +static gboolean after_function_exit(void *hook_data, void *call_data) { after_mode_end((LttvTracefileStats *)call_data); return FALSE; } -gboolean before_schedchange(void *hook_data, void *call_data) +static gboolean before_schedchange(void *hook_data, void *call_data) { LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data; - LttvTraceState *ts = (LttvTraceState*)tfcs->parent.parent.t_context; - LttEvent *e = ltt_tracefile_get_event(tfcs->parent.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)); /* compute the time for the process to schedule out */ - mode_change(tfcs); return FALSE; } -gboolean after_schedchange(void *hook_data, void *call_data) +static gboolean after_schedchange(void *hook_data, void *call_data) { LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data; @@ -682,17 +701,17 @@ gboolean after_schedchange(void *hook_data, void *call_data) LttEvent *e = ltt_tracefile_get_event(tfcs->parent.parent.tf); - LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data; + LttvTraceHook *th = (LttvTraceHook *)hook_data; guint pid_in, pid_out; - gint state_out; + gint64 state_out; LttvProcessState *process; - 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)); /* get the information for the process scheduled in */ guint cpu = tfcs->parent.cpu; @@ -700,36 +719,61 @@ gboolean after_schedchange(void *hook_data, void *call_data) find_event_tree(tfcs, process->pid_time, cpu, - process->current_function, + process->current_function, process->state->t, process->state->n, &(tfcs->current_events_tree), &(tfcs->current_event_types_tree)); /* compute the time waiting for the process to schedule in */ mode_change(tfcs); - return FALSE; + return FALSE; +} + +static gboolean process_fork(void *hook_data, void *call_data) +{ + return FALSE; } -gboolean process_fork(void *hook_data, void *call_data) +static gboolean process_exit(void *hook_data, void *call_data) { - /* nothing to do for now */ + update_event_tree((LttvTracefileStats *)call_data); return FALSE; } +static gboolean before_enum_process_state(void *hook_data, void *call_data) +{ +#if 0 + /* Broken : adds up time in the current process doing the dump */ + LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data; + mode_end(tfcs); + after_mode_end(tfcs); + mode_change(tfcs); +#endif //0 + return FALSE; +} -gboolean process_exit(void *hook_data, void *call_data) +static gboolean after_enum_process_state(void *hook_data, void *call_data) { - /* We should probably exit all modes here or we could do that at - schedule out. */ + LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + LttvTraceStats *tcs = (LttvTraceStats*)tfc->t_context; + update_trace_event_tree(tcs); return FALSE; } -gboolean process_free(void *hook_data, void *call_data) +static gboolean after_statedump_end(void *hook_data, void *call_data) { + LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + LttvTraceStats *tcs = (LttvTraceStats*)tfc->t_context; + update_trace_event_tree(tcs); return FALSE; } -gboolean every_event(void *hook_data, void *call_data) +static gboolean process_free(void *hook_data, void *call_data) +{ + return FALSE; +} + +static gboolean every_event(void *hook_data, void *call_data) { LttvTracefileStats *tfcs = (LttvTracefileStats *)call_data; @@ -737,66 +781,96 @@ gboolean every_event(void *hook_data, void *call_data) LttvAttributeValue v; + LttTrace *trace = ((LttvTracefileContext *)tfcs)->t_context->t; + + struct marker_info *info; + /* The current branch corresponds to the tracefile/process/interrupt state. Statistics are added within it, to count the number of events of this type occuring in this context. A quark has been pre-allocated for each event type and is used as name. */ + info = marker_get_info_from_id(trace, e->event_id); + lttv_attribute_find(tfcs->current_event_types_tree, - ltt_eventtype_name(ltt_event_eventtype(e)), - LTTV_UINT, &v); + info->name, LTTV_UINT, &v); (*(v.v_uint))++; return FALSE; } +struct cleanup_state_struct { + LttvTraceState *ts; + LttTime current_time; +}; + +//static void lttv_stats_cleanup_process_state(LttvTraceState *ts, +// LttvProcessState *process, LttTime current_time) static void lttv_stats_cleanup_process_state(gpointer key, gpointer value, - gpointer user_data) -{ - LttvTraceStats *tcs = (LttvTraceStats *)user_data; - LttvTraceState *ts = (LttvTraceState *)user_data; - LttvTracesetContext *tsc = ts->parent.ts_context; - LttvProcessState *process = (LttvProcessState *)value; - int i; - LttvTracefileStats **tfs = (LttvTracefileStats **) - &g_array_index(ts->parent.tracefiles, LttvTracefileContext*, - process->cpu); - int cleanup_empty = 0; - - do { - if(ltt_time_compare(process->state->cum_cpu_time, ltt_time_zero) != 0) { - find_event_tree(*tfs, process->pid_time, - process->cpu, - process->current_function, - process->state->t, process->state->n, &((*tfs)->current_events_tree), - &((*tfs)->current_event_types_tree)); - /* FIXME : ok, this is a hack. The time is infinite here :( */ - LttTime save_time = (*tfs)->parent.parent.timestamp; - LttTime start, end; - ltt_trace_time_span_get(ts->parent.t, &start, &end); - (*tfs)->parent.parent.timestamp = end; - mode_end(*tfs); - (*tfs)->parent.parent.timestamp = save_time; - } - cleanup_empty = lttv_state_pop_state_cleanup(process, - (LttvTracefileState *)*tfs); - } while(cleanup_empty != 1); -} - -/* For each process in the state, for each of their stacked states, + gpointer user_data) +{ + struct cleanup_state_struct *cleanup_closure = + (struct cleanup_state_struct *)user_data; + LttvTraceState *ts = cleanup_closure->ts; + LttvProcessState *process = (LttvProcessState *)value; + LttTime current_time = cleanup_closure->current_time; + LttvTracefileStats **tfs = (LttvTracefileStats **) + &g_array_index(ts->parent.tracefiles, LttvTracefileContext*, + process->cpu); + int cleanup_empty = 0; + LttTime nested_delta = ltt_time_zero; + + /* FIXME : ok, this is a hack. The time is infinite here :( */ + //LttTime save_time = (*tfs)->parent.parent.timestamp; + //LttTime start, end; + //ltt_trace_time_span_get(ts->parent.t, &start, &end); + //(*tfs)->parent.parent.timestamp = end; + + do { + if(ltt_time_compare(process->state->cum_cpu_time, ltt_time_zero) != 0) { + find_event_tree(*tfs, process->pid_time, + process->cpu, + process->current_function, + process->state->t, process->state->n, &((*tfs)->current_events_tree), + &((*tfs)->current_event_types_tree)); + /* Call mode_end only if not at end of trace */ + if(ltt_time_compare(current_time, ltt_time_infinite) != 0) + mode_end(*tfs); + nested_delta = process->state->cum_cpu_time; + } + cleanup_empty = lttv_state_pop_state_cleanup(process, + (LttvTracefileState *)*tfs); + process->state->cum_cpu_time = ltt_time_add(process->state->cum_cpu_time, + nested_delta); + + } while(cleanup_empty != 1); + + //(*tfs)->parent.parent.timestamp = save_time; +} + +/* For each cpu, for each of their stacked states, * perform sum of needed values. */ -static void lttv_stats_cleanup_state(LttvTraceStats *tcs) +static void lttv_stats_cleanup_state(LttvTraceStats *tcs, LttTime current_time) { LttvTraceState *ts = (LttvTraceState *)tcs; - + struct cleanup_state_struct cleanup_closure; #if 0 - /* Does not work correctly FIXME. */ - g_hash_table_foreach(ts->processes, lttv_stats_cleanup_process_state, - tcs); + guint nb_cpus, i; + + nb_cpus = ltt_trace_get_num_cpu(ts->parent.t); + + for(i=0; irunning_process[i], current_time); + } #endif //0 + cleanup_closure.ts = ts; + cleanup_closure.current_time = current_time; + g_hash_table_foreach(ts->processes, lttv_stats_cleanup_process_state, + &cleanup_closure); } void -lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats) +lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats, + LttTime current_time) { LttvAttribute *sum_container = self->stats; @@ -806,11 +880,11 @@ lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats) LttvAttributeName name; - gboolean is_named; + gboolean is_named; unsigned sum; - int trace_is_summed; + int trace_is_summed; int i, j, k, l, m, nb_process, nb_cpu, nb_mode_type, nb_submode, nb_event_type, nf, nb_functions; @@ -819,9 +893,9 @@ lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats) *cpu_tree, *mode_tree, *mode_types_tree, *submodes_tree, *submode_tree, *event_types_tree, *mode_events_tree, *cpu_functions_tree, - *function_tree, - *function_mode_types_tree, - *trace_cpu_tree; + *function_tree, + *function_mode_types_tree, + *trace_cpu_tree; main_tree = sum_container; @@ -829,14 +903,14 @@ lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats) lttv_attribute_find(sum_container, LTTV_STATS_SUMMED, LTTV_UINT, &value); - trace_is_summed = *(value.v_uint); + trace_is_summed = *(value.v_uint); *(value.v_uint) = 1; - /* First cleanup the state : sum all stalled information (never ending - * states). */ - if(!trace_is_summed) - lttv_stats_cleanup_state(self); - + /* First cleanup the state : sum all stalled information (never ending + * states). */ + if(!trace_is_summed) + lttv_stats_cleanup_state(self, current_time); + processes_tree = lttv_attribute_find_subdir(main_tree, LTTV_STATS_PROCESSES); nb_process = lttv_attribute_get_number(processes_tree); @@ -854,70 +928,70 @@ lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats) trace_cpu_tree = lttv_attribute_find_subdir(main_tree, LTTV_STATS_CPU); trace_cpu_tree = lttv_attribute_find_subdir_unnamed(trace_cpu_tree, name); - cpu_functions_tree = lttv_attribute_find_subdir(cpu_tree, - LTTV_STATS_FUNCTIONS); - nb_functions = lttv_attribute_get_number(cpu_functions_tree); - - for(nf=0; nf < nb_functions; nf++) { - type = lttv_attribute_get(cpu_functions_tree, nf, &name, &value, - &is_named); - function_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); - function_mode_types_tree = lttv_attribute_find_subdir(function_tree, - LTTV_STATS_MODE_TYPES); - nb_mode_type = lttv_attribute_get_number(function_mode_types_tree); - for(k = 0 ; k < nb_mode_type ; k++) { - type = lttv_attribute_get(function_mode_types_tree, k, &name, &value, - &is_named); - mode_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); - - submodes_tree = lttv_attribute_find_subdir(mode_tree, - LTTV_STATS_SUBMODES); - mode_events_tree = lttv_attribute_find_subdir(mode_tree, - LTTV_STATS_EVENTS); - mode_types_tree = lttv_attribute_find_subdir(mode_tree, - LTTV_STATS_MODE_TYPES); - - nb_submode = lttv_attribute_get_number(submodes_tree); - - for(l = 0 ; l < nb_submode ; l++) { - type = lttv_attribute_get(submodes_tree, l, &name, &value, - &is_named); - submode_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); - - event_types_tree = lttv_attribute_find_subdir(submode_tree, - LTTV_STATS_EVENT_TYPES); - nb_event_type = lttv_attribute_get_number(event_types_tree); - - sum = 0; - for(m = 0 ; m < nb_event_type ; m++) { - type = lttv_attribute_get(event_types_tree, m, &name, &value, - &is_named); - sum += *(value.v_uint); - } - lttv_attribute_find(submode_tree, LTTV_STATS_EVENTS_COUNT, - LTTV_UINT, &value); - *(value.v_uint) = sum; - - type = lttv_attribute_get(submodes_tree, l, &name, &value, - &is_named); - submode_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); - if(!trace_is_summed) { - lttv_attribute_recursive_add(mode_events_tree, event_types_tree); - lttv_attribute_recursive_add(mode_types_tree, submode_tree); - } - } - if(!trace_is_summed) { - lttv_attribute_recursive_add(function_tree, mode_types_tree); - } - } - if(!trace_is_summed) { - lttv_attribute_recursive_add(cpu_tree, function_tree); - lttv_attribute_recursive_add(process_tree, function_tree); - lttv_attribute_recursive_add(trace_cpu_tree, function_tree); - lttv_attribute_recursive_add(main_tree, function_tree); - } - lttv_attribute_recursive_add(ts_stats, function_tree); - } + cpu_functions_tree = lttv_attribute_find_subdir(cpu_tree, + LTTV_STATS_FUNCTIONS); + nb_functions = lttv_attribute_get_number(cpu_functions_tree); + + for(nf=0; nf < nb_functions; nf++) { + type = lttv_attribute_get(cpu_functions_tree, nf, &name, &value, + &is_named); + function_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); + function_mode_types_tree = lttv_attribute_find_subdir(function_tree, + LTTV_STATS_MODE_TYPES); + nb_mode_type = lttv_attribute_get_number(function_mode_types_tree); + for(k = 0 ; k < nb_mode_type ; k++) { + type = lttv_attribute_get(function_mode_types_tree, k, &name, &value, + &is_named); + mode_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); + + submodes_tree = lttv_attribute_find_subdir(mode_tree, + LTTV_STATS_SUBMODES); + mode_events_tree = lttv_attribute_find_subdir(mode_tree, + LTTV_STATS_EVENTS); + mode_types_tree = lttv_attribute_find_subdir(mode_tree, + LTTV_STATS_MODE_TYPES); + + nb_submode = lttv_attribute_get_number(submodes_tree); + + for(l = 0 ; l < nb_submode ; l++) { + type = lttv_attribute_get(submodes_tree, l, &name, &value, + &is_named); + submode_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); + + event_types_tree = lttv_attribute_find_subdir(submode_tree, + LTTV_STATS_EVENT_TYPES); + nb_event_type = lttv_attribute_get_number(event_types_tree); + + sum = 0; + for(m = 0 ; m < nb_event_type ; m++) { + type = lttv_attribute_get(event_types_tree, m, &name, &value, + &is_named); + sum += *(value.v_uint); + } + lttv_attribute_find(submode_tree, LTTV_STATS_EVENTS_COUNT, + LTTV_UINT, &value); + *(value.v_uint) = sum; + + type = lttv_attribute_get(submodes_tree, l, &name, &value, + &is_named); + submode_tree = LTTV_ATTRIBUTE(*(value.v_gobject)); + if(!trace_is_summed) { + lttv_attribute_recursive_add(mode_events_tree, event_types_tree); + lttv_attribute_recursive_add(mode_types_tree, submode_tree); + } + } + if(!trace_is_summed) { + lttv_attribute_recursive_add(function_tree, mode_types_tree); + } + } + if(!trace_is_summed) { + lttv_attribute_recursive_add(cpu_tree, function_tree); + lttv_attribute_recursive_add(process_tree, function_tree); + lttv_attribute_recursive_add(trace_cpu_tree, function_tree); + lttv_attribute_recursive_add(main_tree, function_tree); + } + lttv_attribute_recursive_add(ts_stats, function_tree); + } } } } @@ -925,12 +999,14 @@ lttv_stats_sum_trace(LttvTraceStats *self, LttvAttribute *ts_stats) gboolean lttv_stats_sum_traceset_hook(void *hook_data, void *call_data) { - lttv_stats_sum_traceset((LttvTracesetStats *)call_data); + struct sum_traceset_closure *closure = + (struct sum_traceset_closure *)call_data; + lttv_stats_sum_traceset(closure->tss, closure->current_time); return 0; } void -lttv_stats_sum_traceset(LttvTracesetStats *self) +lttv_stats_sum_traceset(LttvTracesetStats *self, LttTime current_time) { LttvTraceset *traceset = self->parent.parent.ts; LttvAttribute *sum_container = self->stats; @@ -939,8 +1015,6 @@ lttv_stats_sum_traceset(LttvTracesetStats *self) int i, nb_trace; - LttvAttribute *main_tree; - LttvAttributeValue value; lttv_attribute_find(sum_container, LTTV_STATS_SUMMED, @@ -952,8 +1026,8 @@ lttv_stats_sum_traceset(LttvTracesetStats *self) for(i = 0 ; i < nb_trace ; i++) { tcs = (LttvTraceStats *)(self->parent.parent.traces[i]); - lttv_stats_sum_trace(tcs, self->stats); - // lttv_attribute_recursive_add(sum_container, tcs->stats); + lttv_stats_sum_trace(tcs, self->stats, current_time); + // lttv_attribute_recursive_add(sum_container, tcs->stats); } } @@ -972,7 +1046,7 @@ void lttv_stats_add_event_hooks(LttvTracesetStats *self) { LttvTraceset *traceset = self->parent.parent.ts; - guint i, j, k, l, nb_trace, nb_tracefile; + guint i, j, k, nb_trace, nb_tracefile; LttvTraceStats *ts; @@ -980,15 +1054,10 @@ void lttv_stats_add_event_hooks(LttvTracesetStats *self) GArray *hooks, *before_hooks, *after_hooks; - LttvTraceHook *hook; - - LttvTraceHookByFacility *thf; + LttvTraceHook *th; LttvAttributeValue val; - gint ret; - gint hn; - nb_trace = lttv_traceset_number(traceset); for(i = 0 ; i < nb_trace ; i++) { ts = (LttvTraceStats *)self->parent.parent.traces[i]; @@ -996,194 +1065,209 @@ void lttv_stats_add_event_hooks(LttvTracesetStats *self) /* Find the eventtype id for the following events and register the associated by id hooks. */ - hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 11); - g_array_set_size(hooks, 11); - hn=0; + hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 12); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, - LTT_FIELD_SYSCALL_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_SYSCALL_ENTRY, + FIELD_ARRAY(LTT_FIELD_SYSCALL_ID), before_syscall_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_SYSCALL_EXIT, + NULL, before_syscall_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY, - LTT_FIELD_TRAP_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_TRAP_ENTRY, + FIELD_ARRAY(LTT_FIELD_TRAP_ID), before_trap_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_TRAP_EXIT, + NULL, before_trap_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY, - LTT_FIELD_IRQ_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_IRQ_ENTRY, + FIELD_ARRAY(LTT_FIELD_IRQ_ID), before_irq_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_IRQ_EXIT, + NULL, before_irq_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY, - LTT_FIELD_SOFT_IRQ_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SOFT_IRQ_ENTRY, + FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID), before_soft_irq_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SOFT_IRQ_EXIT, + NULL, before_soft_irq_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE, - LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SCHED_SCHEDULE, + FIELD_ARRAY(LTT_FIELD_PREV_PID, LTT_FIELD_NEXT_PID, LTT_FIELD_PREV_STATE), before_schedchange, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY, - LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_USER_GENERIC, + LTT_EVENT_FUNCTION_ENTRY, + FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), before_function_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT, - LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_USER_GENERIC, + LTT_EVENT_FUNCTION_EXIT, + FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), before_function_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; - - g_array_set_size(hooks, hn); + &hooks); + + /* statedump-related hooks */ + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_LIST, + LTT_EVENT_PROCESS_STATE, + FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME), + before_enum_process_state, NULL, + &hooks); before_hooks = hooks; - hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 14); - g_array_set_size(hooks, 14); - hn=0; + hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 16); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY, - LTT_FIELD_SYSCALL_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_SYSCALL_ENTRY, + FIELD_ARRAY(LTT_FIELD_SYSCALL_ID), after_syscall_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_SYSCALL_EXIT, + NULL, after_syscall_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY, - LTT_FIELD_TRAP_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_TRAP_ENTRY, + FIELD_ARRAY(LTT_FIELD_TRAP_ID), after_trap_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL_ARCH, + LTT_EVENT_TRAP_EXIT, + NULL, after_trap_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY, - LTT_FIELD_IRQ_ID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_IRQ_ENTRY, + FIELD_ARRAY(LTT_FIELD_IRQ_ID), after_irq_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT, - 0, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_IRQ_EXIT, + NULL, after_irq_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; - - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY, - LTT_FIELD_SOFT_IRQ_ID, 0, 0, - after_irq_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; - - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT, - 0, 0, 0, + &hooks); + + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SOFT_IRQ_ENTRY, + FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID), + after_soft_irq_entry, NULL, + &hooks); + + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SOFT_IRQ_EXIT, + NULL, after_soft_irq_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE, - LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_SCHED_SCHEDULE, + FIELD_ARRAY(LTT_FIELD_PREV_PID, LTT_FIELD_NEXT_PID, LTT_FIELD_PREV_STATE), after_schedchange, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_PROCESS, LTT_EVENT_FORK, - LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_PROCESS_FORK, + FIELD_ARRAY(LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID), process_fork, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_PROCESS, LTT_EVENT_EXIT, - LTT_FIELD_PID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_PROCESS_EXIT, + FIELD_ARRAY(LTT_FIELD_PID), process_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_PROCESS, LTT_EVENT_FREE, - LTT_FIELD_PID, 0, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_KERNEL, + LTT_EVENT_PROCESS_FREE, + FIELD_ARRAY(LTT_FIELD_PID), process_free, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY, - LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_USER_GENERIC, + LTT_EVENT_FUNCTION_ENTRY, + FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), after_function_entry, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; + &hooks); - ret = lttv_trace_find_hook(ts->parent.parent.t, - LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT, - LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0, + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_USER_GENERIC, + LTT_EVENT_FUNCTION_EXIT, + FIELD_ARRAY(LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE), after_function_exit, NULL, - &g_array_index(hooks, LttvTraceHook, hn++)); - if(ret) hn--; - - g_array_set_size(hooks, hn); + &hooks); + + /* statedump-related hooks */ + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_LIST, + LTT_EVENT_PROCESS_STATE, + FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME), + after_enum_process_state, NULL, + &hooks); + + lttv_trace_find_hook(ts->parent.parent.t, + LTT_FACILITY_LIST, + LTT_EVENT_STATEDUMP_END, + NULL, + after_statedump_end, NULL, + &hooks); after_hooks = hooks; @@ -1198,26 +1282,20 @@ void lttv_stats_add_event_hooks(LttvTracesetStats *self) LTTV_PRIO_DEFAULT); for(k = 0 ; k < before_hooks->len ; k++) { - hook = &g_array_index(before_hooks, LttvTraceHook, k); - for(l = 0; lfac_list->len;l++) { - thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); - lttv_hooks_add( - lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, thf->id), - thf->h, - thf, - LTTV_PRIO_STATS_BEFORE_STATE); - } + th = &g_array_index(before_hooks, LttvTraceHook, k); + lttv_hooks_add( + lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id), + th->h, + th, + LTTV_PRIO_STATS_BEFORE_STATE); } for(k = 0 ; k < after_hooks->len ; k++) { - hook = &g_array_index(after_hooks, LttvTraceHook, k); - for(l = 0; lfac_list->len;l++) { - thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); - lttv_hooks_add( - lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, thf->id), - thf->h, - thf, - LTTV_PRIO_STATS_AFTER_STATE); - } + th = &g_array_index(after_hooks, LttvTraceHook, k); + lttv_hooks_add( + lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id), + th->h, + th, + LTTV_PRIO_STATS_AFTER_STATE); } } lttv_attribute_find(self->parent.parent.a, LTTV_STATS_BEFORE_HOOKS, @@ -1243,19 +1321,15 @@ void lttv_stats_remove_event_hooks(LttvTracesetStats *self) { LttvTraceset *traceset = self->parent.parent.ts; - guint i, j, k, l, nb_trace, nb_tracefile; + guint i, j, k, nb_trace, nb_tracefile; LttvTraceStats *ts; LttvTracefileStats *tfs; - void *hook_data; - GArray *before_hooks, *after_hooks; - LttvTraceHook *hook; - - LttvTraceHookByFacility *thf; + LttvTraceHook *th; LttvAttributeValue val; @@ -1280,27 +1354,24 @@ void lttv_stats_remove_event_hooks(LttvTracesetStats *self) NULL); for(k = 0 ; k < before_hooks->len ; k++) { - hook = &g_array_index(before_hooks, LttvTraceHook, k); - for(l = 0 ; l < hook->fac_list->len ; l++) { - thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); - lttv_hooks_remove_data( - lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, thf->id), - thf->h, - thf); - } + th = &g_array_index(before_hooks, LttvTraceHook, k); + lttv_hooks_remove_data( + lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id), + th->h, + th); } for(k = 0 ; k < after_hooks->len ; k++) { - hook = &g_array_index(after_hooks, LttvTraceHook, k); - for(l = 0 ; l < hook->fac_list->len ; l++) { - thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l); - lttv_hooks_remove_data( - lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, thf->id), - thf->h, - thf); - } + th = &g_array_index(after_hooks, LttvTraceHook, k); + lttv_hooks_remove_data( + lttv_hooks_by_id_find(tfs->parent.parent.event_by_id, th->id), + th->h, + th); + } } g_debug("lttv_stats_remove_event_hooks()"); + lttv_trace_hook_remove_all(&before_hooks); + lttv_trace_hook_remove_all(&after_hooks); g_array_free(before_hooks, TRUE); g_array_free(after_hooks, TRUE); }