X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttv%2Fmodules%2Fgui%2Fresourceview%2Feventhooks.c;h=86bb8cdb8550a56c3904c273adcebc5599b98c02;hb=190724cdfc53eeebfd895b594f875b53a72adf37;hp=271e8d27df3e4f1b6069ed3da87c1d546d741ac4;hpb=1cd9058f63bc277629d796bac29c4530d151bea4;p=lttv.git diff --git a/lttv/modules/gui/resourceview/eventhooks.c b/lttv/modules/gui/resourceview/eventhooks.c index 271e8d27..86bb8cdb 100644 --- a/lttv/modules/gui/resourceview/eventhooks.c +++ b/lttv/modules/gui/resourceview/eventhooks.c @@ -60,10 +60,6 @@ //#include -#include -#include -#include - #include #include #include @@ -116,9 +112,9 @@ static gint background_ready(void *hook_data, void *call_data) */ static void request_background_data(ControlFlowData *resourceview_data) { - LttvTracesetContext * tsc = - lttvwindow_get_traceset_context(resourceview_data->tab); - gint num_traces = lttv_traceset_number(tsc->ts); + LttvTraceset* ts = + lttvwindow_get_traceset(resourceview_data->tab); + gint num_traces = lttv_traceset_number(ts); gint i; LttvTrace *trace; LttvTraceState *tstate; @@ -130,11 +126,10 @@ static void request_background_data(ControlFlowData *resourceview_data) resourceview_data->background_info_waiting = 0; for(i=0;its, i); - tstate = LTTV_TRACE_STATE(tsc->traces[i]); - + trace = lttv_traceset_get(ts, i); + if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE - && !tstate->has_precomputed_states) { + && !ts->has_precomputed_states) { if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"), trace) == FALSE) { @@ -255,7 +250,6 @@ h_legend(LttvPlugin *plugin) int event_selected_hook(void *hook_data, void *call_data) { - ControlFlowData *resourceview_data = (ControlFlowData*) hook_data; guint *event_number = (guint*) call_data; g_debug("DEBUG : event selected by main window : %u", *event_number); @@ -312,7 +306,6 @@ static void irq_set_line_color(PropertiesLine *prop_line, LttvIRQState *s) static void soft_irq_set_line_color(PropertiesLine *prop_line, LttvSoftIRQState *s) { - GQuark present_state; if(s->running) prop_line->color = drawing_colors_soft_irq[COL_SOFT_IRQ_BUSY]; else if(s->pending) @@ -323,7 +316,6 @@ static void soft_irq_set_line_color(PropertiesLine *prop_line, LttvSoftIRQState static void trap_set_line_color(PropertiesLine *prop_line, LttvTrapState *s) { - GQuark present_state; if(s->running == 0) prop_line->color = drawing_colors_trap[COL_TRAP_IDLE]; else @@ -372,21 +364,17 @@ static void bdev_set_line_color(PropertiesLine *prop_line, LttvBdevState *s) int before_schedchange_hook(void *hook_data, void *call_data) { - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + LttvEvent *event; + LttvTraceState *ts; - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; + event = (LttvEvent *) call_data; + if (strcmp(lttv_traceset_get_name_from_event(event),"sched_switch") != 0) + return FALSE; - LttEvent *e; - e = ltt_tracefile_get_event(tfc->tf); - gint target_pid_saved = tfc->target_pid; + ControlFlowData *resourceview_data = (ControlFlowData*)hook_data; - LttTime evtime = ltt_event_time(e); - LttvFilter *filter = resourceview_data->filter; + LttTime evtime = lttv_event_get_timestamp(event); /* we are in a schedchange, before the state update. We must draw the * items corresponding to the state before it changes : now is the right @@ -394,24 +382,21 @@ int before_schedchange_hook(void *hook_data, void *call_data) */ guint pid_out; - guint pid_in; - pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0)); - pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1)); + pid_out = lttv_event_get_long(event, "prev_tid"); // TODO: can't we reenable this? pmf // if(pid_in != 0 && pid_out != 0) { // /* not a transition to/from idle */ // return 0; // } - tfc->target_pid = pid_out; - guint cpu = tfs->cpu; + guint cpu = lttv_traceset_get_cpuid_from_event(event); + ts = event->state; - guint trace_num = ts->parent.index; - /* Add process to process list (if not present) */ - guint pl_height = 0; + guint trace_num = lttv_traceset_get_trace_index_from_event(event); + + /* Add process to process list (if not present) */ HashedResourceData *hashed_process_data = NULL; - ProcessList *process_list = resourceview_data->process_list; hashed_process_data = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu); @@ -508,7 +493,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) prop_line.line_width = STATE_LINE_WIDTH; prop_line.style = GDK_LINE_SOLID; prop_line.y = MIDDLE; - cpu_set_line_color(&prop_line, tfs->cpu_state); + cpu_set_line_color(&prop_line, &(ts->cpu_states[cpu])); draw_line((void*)&prop_line, (void*)&draw_context); } @@ -538,51 +523,42 @@ int before_schedchange_hook(void *hook_data, void *call_data) */ int after_schedchange_hook(void *hook_data, void *call_data) { - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; - LttEvent *e; + LttvEvent *event; - e = ltt_tracefile_get_event(tfc->tf); + event = (LttvEvent *) call_data; + + if (strcmp(lttv_traceset_get_name_from_event(event),"sched_switch") != 0) + return FALSE; + + ControlFlowData *resourceview_data = (ControlFlowData*) hook_data; + LttvTraceState *ts = event->state; +#ifdef BABEL_CLEANUP LttvFilter *filter = resourceview_data->filter; if(filter != NULL && filter->head != NULL) if(!lttv_filter_tree_parse(filter->head,e,tfc->tf, tfc->t_context->t,tfc,NULL,NULL)) return FALSE; +#endif - LttTime evtime = ltt_event_time(e); + LttTime evtime = lttv_event_get_timestamp(event); /* Add process to process list (if not present) */ LttvProcessState *process_in; - LttTime birth; - guint pl_height = 0; HashedResourceData *hashed_process_data_in = NULL; ProcessList *process_list = resourceview_data->process_list; - guint pid_in; - { - guint pid_out; - pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0)); - pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1)); - } - - /* Find process pid_in in the list... */ //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in); //process_in = tfs->process; - guint cpu = tfs->cpu; - guint trace_num = ts->parent.index; + guint cpu = lttv_traceset_get_cpuid_from_event(event); + guint trace_num = lttv_traceset_get_trace_index_from_event(event); process_in = ts->running_process[cpu]; /* It should exist, because we are after the state update. */ #ifdef EXTRA_CHECK g_assert(process_in != NULL); #endif //EXTRA_CHECK - birth = process_in->creation_time; //hashed_process_data_in = processlist_get_process_data(process_list, cpuq, trace_num); hashed_process_data_in = resourcelist_obtain_cpu(resourceview_data, trace_num, cpu); @@ -644,44 +620,47 @@ int before_execmode_hook_trap(void *hook_data, void *call_data); int before_execmode_hook(void *hook_data, void *call_data) { - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; - - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; - - LttEvent *e; - e = ltt_tracefile_get_event(tfc->tf); - - LttTime evtime = ltt_event_time(e); + LttvEvent *event; + guint cpu; + guint pid = 0; + LttvTraceState *ts; + LttvProcessState *process; before_execmode_hook_irq(hook_data, call_data); before_execmode_hook_soft_irq(hook_data, call_data); +#ifdef TRAP_NO_EXIST before_execmode_hook_trap(hook_data, call_data); - +#endif /* we are in a execmode, before the state update. We must draw the * items corresponding to the state before it changes : now is the right * time to do it. */ + event = (LttvEvent *) call_data; + if ((strncmp(lttv_traceset_get_name_from_event(event),"sys_", sizeof("sys_") - 1) == 0) + ||(strcmp(lttv_traceset_get_name_from_event(event),"exit_syscall") == 0) + ||(strncmp(lttv_traceset_get_name_from_event(event),"irq_handler_",sizeof("irq_handler_") -1) == 0) + ||(strncmp(lttv_traceset_get_name_from_event(event),"softirq_", sizeof("softirq_") - 1) == 0)) { + + LttTime evtime = lttv_event_get_timestamp(event); + ControlFlowData *resourceview_data = (ControlFlowData*)hook_data; + /* For the pid */ - guint cpu = tfs->cpu; + LttvTraceset *traceSet = lttvwindow_get_traceset(resourceview_data->tab); + + cpu = lttv_traceset_get_cpuid_from_event(event); + ts = event->state; + + guint trace_num = lttv_traceset_get_trace_index_from_event(event); - guint trace_num = ts->parent.index; - LttvProcessState *process = ts->running_process[cpu]; + process = ts->running_process[cpu]; g_assert(process != NULL); /* Well, the process_out existed : we must get it in the process hash * or add it, and draw its items. */ - /* Add process to process list (if not present) */ - guint pl_height = 0; + /* Add process to process list (if not present) */ HashedResourceData *hashed_process_data = NULL; ProcessList *process_list = resourceview_data->process_list; - - LttTime birth = process->creation_time; if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) { hashed_process_data = process_list->current_hash_data[trace_num][cpu]; @@ -790,7 +769,7 @@ int before_execmode_hook(void *hook_data, void *call_data) prop_line.line_width = STATE_LINE_WIDTH; prop_line.style = GDK_LINE_SOLID; prop_line.y = MIDDLE; - cpu_set_line_color(&prop_line, tfs->cpu_state); + cpu_set_line_color(&prop_line, &ts->cpu_states[cpu]); draw_line((void*)&prop_line, (void*)&draw_context); } /* become the last x position */ @@ -802,29 +781,19 @@ int before_execmode_hook(void *hook_data, void *call_data) convert_pixels_to_time(width, x+1, time_window, &hashed_process_data->next_good_time); } + } } - return 0; } int before_execmode_hook_irq(void *hook_data, void *call_data) { - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; - - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; - struct marker_info *minfo; - - LttEvent *e; - e = ltt_tracefile_get_event(tfc->tf); - - LttTime evtime = ltt_event_time(e); + LttvEvent *event; - LttTrace *trace = tfc->t_context->t; + event = (LttvEvent *) call_data; + + LttTime evtime = lttv_event_get_timestamp(event); + ControlFlowData *resourceview_data = (ControlFlowData*)hook_data; /* we are in a execmode, before the state update. We must draw the * items corresponding to the state before it changes : now is the right @@ -833,19 +802,17 @@ int before_execmode_hook_irq(void *hook_data, void *call_data) /* For the pid */ guint64 irq; - guint cpu = tfs->cpu; + guint cpu = lttv_traceset_get_cpuid_from_event(event); + LttvTraceset *traceSet = lttvwindow_get_traceset(resourceview_data->tab); + LttvTraceState *ts = event->state;; /* * Check for LTT_CHANNEL_KERNEL channel name and event ID * corresponding to LTT_EVENT_IRQ_ENTRY or LTT_EVENT_IRQ_EXIT. */ - if (tfc->tf->name != LTT_CHANNEL_KERNEL) - return 0; - minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id); - g_assert(minfo != NULL); - if (minfo->name == LTT_EVENT_IRQ_ENTRY) { - irq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0)); - } else if (minfo->name == LTT_EVENT_IRQ_EXIT) { + if (strncmp(lttv_traceset_get_name_from_event(event),"irq_handler_entry",sizeof("irq_handler_entry")) == 0) { + irq = lttv_event_get_long(event, "irq"); + } else if (strncmp(lttv_traceset_get_name_from_event(event),"irq_handler_exit",sizeof("irq_handler_exit")) == 0) { gint len = ts->cpu_states[cpu].irq_stack->len; if(len) { irq = g_array_index(ts->cpu_states[cpu].irq_stack, gint, len-1); @@ -856,15 +823,13 @@ int before_execmode_hook_irq(void *hook_data, void *call_data) } else return 0; - guint trace_num = ts->parent.index; + guint trace_num = lttv_traceset_get_trace_index_from_event(event); /* Well, the process_out existed : we must get it in the process hash * or add it, and draw its items. */ - /* Add process to process list (if not present) */ - guint pl_height = 0; + /* Add process to process list (if not present) */ HashedResourceData *hashed_process_data = NULL; - ProcessList *process_list = resourceview_data->process_list; hashed_process_data = resourcelist_obtain_irq(resourceview_data, trace_num, irq); // TODO: fix this, it's ugly and slow: @@ -994,22 +959,14 @@ int before_execmode_hook_irq(void *hook_data, void *call_data) int before_execmode_hook_soft_irq(void *hook_data, void *call_data) { - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + LttvEvent *event; + LttvTraceState *ts; - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; - struct marker_info *minfo; - - LttEvent *e; - e = ltt_tracefile_get_event(tfc->tf); - - LttTime evtime = ltt_event_time(e); - - LttTrace *trace = tfc->t_context->t; + event = (LttvEvent *) call_data; + + + /* we are in a execmode, before the state update. We must draw the * items corresponding to the state before it changes : now is the right @@ -1018,40 +975,36 @@ int before_execmode_hook_soft_irq(void *hook_data, void *call_data) /* For the pid */ guint64 softirq; - guint cpu = tfs->cpu; + /* * Check for LTT_CHANNEL_KERNEL channel name and event ID * corresponding to LTT_EVENT_SOFT_IRQ_RAISE, LTT_EVENT_SOFT_IRQ_ENTRY * or LTT_EVENT_SOFT_IRQ_EXIT. */ - if (tfc->tf->name != LTT_CHANNEL_KERNEL) - return 0; - minfo = marker_get_info_from_id(tfc->tf->mdata, e->event_id); - g_assert(minfo != NULL); - if (minfo->name == LTT_EVENT_SOFT_IRQ_RAISE - || minfo->name == LTT_EVENT_SOFT_IRQ_ENTRY) { - softirq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0)); - } else if (minfo->name == LTT_EVENT_SOFT_IRQ_EXIT) { - gint len = ts->cpu_states[cpu].softirq_stack->len; - if(len) { - softirq = g_array_index(ts->cpu_states[cpu].softirq_stack, gint, len-1); - } - else { - return 0; - } - } else + + if (strncmp(lttv_traceset_get_name_from_event(event),"softirq_entry",sizeof("softirq_entry")) == 0 + || strncmp(lttv_traceset_get_name_from_event(event),"softirq_raise",sizeof("softirq_raise")) == 0 + || strncmp(lttv_traceset_get_name_from_event(event),"softirq_exit",sizeof("softirq_exit")) == 0 ) { + + softirq = lttv_event_get_long_unsigned(event, "vec"); + + } else { return 0; + } - guint trace_num = ts->parent.index; + LttTime evtime = lttv_event_get_timestamp(event); + ControlFlowData *resourceview_data = (ControlFlowData*)hook_data; + LttvTraceset *traceSet = lttvwindow_get_traceset(resourceview_data->tab); + guint cpu = lttv_traceset_get_cpuid_from_event(event); + ts = event->state; + guint trace_num = lttv_traceset_get_trace_index_from_event(event); /* Well, the process_out existed : we must get it in the process hash * or add it, and draw its items. */ - /* Add process to process list (if not present) */ - guint pl_height = 0; + /* Add process to process list (if not present) */ HashedResourceData *hashed_process_data = NULL; - ProcessList *process_list = resourceview_data->process_list; hashed_process_data = resourcelist_obtain_soft_irq(resourceview_data, trace_num, softirq); @@ -1165,10 +1118,10 @@ int before_execmode_hook_soft_irq(void *hook_data, void *call_data) &hashed_process_data->next_good_time); } } - + return 0; } - +#ifdef TRAP_NO_EXIST int before_execmode_hook_trap(void *hook_data, void *call_data) { LttvTraceHook *th = (LttvTraceHook*)hook_data; @@ -1186,8 +1139,6 @@ int before_execmode_hook_trap(void *hook_data, void *call_data) LttTime evtime = ltt_event_time(e); - LttTrace *trace = tfc->t_context->t; - /* we are in a execmode, before the state update. We must draw the * items corresponding to the state before it changes : now is the right * time to do it. @@ -1228,10 +1179,8 @@ int before_execmode_hook_trap(void *hook_data, void *call_data) /* Well, the process_out existed : we must get it in the process hash * or add it, and draw its items. */ - /* Add process to process list (if not present) */ - guint pl_height = 0; + /* Add process to process list (if not present) */ HashedResourceData *hashed_process_data = NULL; - ProcessList *process_list = resourceview_data->process_list; hashed_process_data = resourcelist_obtain_trap(resourceview_data, trace_num, trap); @@ -1348,37 +1297,38 @@ int before_execmode_hook_trap(void *hook_data, void *call_data) return 0; } - - +#endif +#ifdef BABEL_CLEANUP +//TODO investigate the use of block dev resource int before_bdev_event_hook(void *hook_data, void *call_data) { - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; - - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; - - LttEvent *e; - e = ltt_tracefile_get_event(tfc->tf); +LttvEvent *event; + guint cpu; + guint pid = 0; + LttvTraceState *ts; + LttvProcessState *process; - LttTime evtime = ltt_event_time(e); /* we are in a execmode, before the state update. We must draw the * items corresponding to the state before it changes : now is the right * time to do it. */ + + event = (LttvEvent *) call_data; + if (strcmp(lttv_traceset_get_name_from_event(event),"block_rq_issue") != 0 && strcmp(lttv_traceset_get_name_from_event(event),"block_rq_complete") != 0) + return FALSE; + + + ControlFlowData *resourceview_data = (ControlFlowData*) hook_data; + + LttvTraceState *ts = event->state; /* For the pid */ - guint cpu = tfs->cpu; guint8 major = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0)); guint8 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)); gint devcode_gint = MKDEV(major,minor); - guint trace_num = ts->parent.index; + guint trace_num = lttv_traceset_get_trace_index_from_event(event); LttvBdevState *bdev = g_hash_table_lookup(ts->bdev_states, &devcode_gint); /* the result of the lookup might be NULL. that's ok, the rest of the function @@ -1387,10 +1337,8 @@ int before_bdev_event_hook(void *hook_data, void *call_data) /* Well, the process_out existed : we must get it in the process hash * or add it, and draw its items. */ - /* Add process to process list (if not present) */ - guint pl_height = 0; + /* Add process to process list (if not present) */ HashedResourceData *hashed_process_data = NULL; - ProcessList *process_list = resourceview_data->process_list; // LttTime birth = process->creation_time; // if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) { @@ -1522,7 +1470,7 @@ int before_bdev_event_hook(void *hook_data, void *call_data) return 0; } - +#endif gint update_time_window_hook(void *hook_data, void *call_data) { ControlFlowData *resourceview_data = (ControlFlowData*) hook_data; @@ -1567,9 +1515,7 @@ gint update_time_window_hook(void *hook_data, void *call_data) /* Same scale (scrolling) */ g_info("scrolling"); LttTime *ns = &new_time_window->start_time; - LttTime *nw = &new_time_window->time_width; LttTime *os = &old_time_window->start_time; - LttTime *ow = &old_time_window->time_width; LttTime old_end = old_time_window->end_time; LttTime new_end = new_time_window->end_time; //if(nsdrawing; LttTime current_time = *((LttTime*)call_data); @@ -1823,11 +1768,11 @@ gint update_current_time_hook(void *hook_data, void *call_data) } LttTime time_end = ltt_time_add(time_begin, width); - LttvTracesetContext * tsc = - lttvwindow_get_traceset_context(resourceview_data->tab); - - LttTime trace_start = tsc->time_span.start_time; - LttTime trace_end = tsc->time_span.end_time; + LttvTraceset * ts = lttvwindow_get_traceset(resourceview_data->tab); + + TimeInterval time_span = lttv_traceset_get_time_span_real(ts); + LttTime trace_start = time_span.start_time; + LttTime trace_end = time_span.end_time; g_info("New current time HOOK : %lu, %lu", current_time.tv_sec, current_time.tv_nsec); @@ -1887,7 +1832,6 @@ gint update_current_time_hook(void *hook_data, void *call_data) typedef struct _ClosureData { EventsRequest *events_request; - LttvTracesetState *tss; LttTime end_time; guint x_end; } ClosureData; @@ -1902,9 +1846,7 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) EventsRequest *events_request = closure_data->events_request; ControlFlowData *resourceview_data = events_request->viewer_data; - - LttvTracesetState *tss = closure_data->tss; - LttvTracesetContext *tsc = (LttvTracesetContext*)tss; + LttvTraceset *ts = lttvwindow_get_traceset(resourceview_data->tab); LttTime evtime = closure_data->end_time; @@ -1923,12 +1865,12 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) #ifdef EXTRA_CHECK g_assert(lttv_traceset_number(tsc->ts) > 0); #endif //EXTRA_CHECK - LttvTraceContext *tc = tsc->traces[process_info->trace_num]; - LttvTraceState *ts = (LttvTraceState*)tc; + + LttvTrace *trace = lttv_traceset_get(ts,process_info->trace_num); + LttvTraceState *ts = trace->state; /* Only draw for processes that are currently in the trace states */ - ProcessList *process_list = resourceview_data->process_list; #ifdef EXTRA_CHECK /* Should be alike when background info is ready */ if(resourceview_data->background_info_waiting==0) @@ -2048,8 +1990,8 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) int before_chunk(void *hook_data, void *call_data) { EventsRequest *events_request = (EventsRequest*)hook_data; - LttvTracesetState *tss = (LttvTracesetState*)call_data; - ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data; + LttvTraceset *ts = (LttvTraceset*)call_data; + #if 0 /* Deactivate sort */ gtk_tree_sortable_set_sort_column_id( @@ -2057,7 +1999,7 @@ int before_chunk(void *hook_data, void *call_data) TRACE_COLUMN, GTK_SORT_ASCENDING); #endif //0 - drawing_chunk_begin(events_request, tss); + drawing_chunk_begin(events_request, ts); return 0; } @@ -2070,38 +2012,21 @@ int before_chunk(void *hook_data, void *call_data) int before_request(void *hook_data, void *call_data) { EventsRequest *events_request = (EventsRequest*)hook_data; - LttvTracesetState *tss = (LttvTracesetState*)call_data; - drawing_data_request_begin(events_request, tss); + drawing_data_request_begin(events_request); return 0; } - -/* - * after request is necessary in addition of after chunk in order to draw - * lines until the end of the screen. after chunk just draws lines until - * the last event. - * - * for each process - * draw closing line - * expose - */ -int after_request(void *hook_data, void *call_data) +void draw_closing_lines(ControlFlowData *resourceview_data, + EventsRequest* events_request) { - guint i; - EventsRequest *events_request = (EventsRequest*)hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; - LttvTracesetState *tss = (LttvTracesetState*)call_data; - - ProcessList *process_list = resourceview_data->process_list; - LttTime end_time = events_request->end_time; - + LttTime end_time = events_request->end_time; ClosureData closure_data; - closure_data.events_request = (EventsRequest*)hook_data; - closure_data.tss = tss; + closure_data.events_request = events_request; closure_data.end_time = end_time; + TimeWindow time_window = lttvwindow_get_time_window(resourceview_data->tab); guint width = resourceview_data->drawing->width; @@ -2111,7 +2036,7 @@ int after_request(void *hook_data, void *call_data) width, &closure_data.x_end); - + guint i; /* Draw last items */ for(i=0; iviewer_data; + + draw_closing_lines(resourceview_data, events_request); + return 0; } @@ -2132,15 +2076,13 @@ int after_chunk(void *hook_data, void *call_data) { EventsRequest *events_request = (EventsRequest*)hook_data; ControlFlowData *resourceview_data = events_request->viewer_data; - LttvTracesetState *tss = (LttvTracesetState*)call_data; - LttvTracesetContext *tsc = (LttvTracesetContext*)call_data; - LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc); + LttvTraceset *ts = (LttvTraceset*)call_data; + LttTime end_time; ProcessList *process_list = resourceview_data->process_list; guint i; - LttvTraceset *traceset = tsc->ts; - guint nb_trace = lttv_traceset_number(traceset); + guint nb_trace = lttv_traceset_number(ts); /* Only execute when called for the first trace's events request */ if(!process_list->current_hash_data) @@ -2151,44 +2093,13 @@ int after_chunk(void *hook_data, void *call_data) } g_free(process_list->current_hash_data); process_list->current_hash_data = NULL; - +#ifdef BABEL_CLEANUP if(tfc != NULL) end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time); else /* end of traceset, or position now out of request : end */ end_time = events_request->end_time; - - ClosureData closure_data; - closure_data.events_request = (EventsRequest*)hook_data; - closure_data.tss = tss; - closure_data.end_time = end_time; - - TimeWindow time_window = - lttvwindow_get_time_window(resourceview_data->tab); - guint width = resourceview_data->drawing->width; - convert_time_to_pixels( - time_window, - end_time, - width, - &closure_data.x_end); - - /* Draw last items */ - for(i=0; iprocess_list->list_store), - GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, - GTK_SORT_ASCENDING); - - update_index_to_pixmap(resourceview_data->process_list); - /* Request a full expose : drawing scrambled */ - gtk_widget_queue_draw(resourceview_data->drawing->drawing_area); -#endif //0 - /* Request expose (updates damages zone also) */ - drawing_request_expose(events_request, tss, end_time); +#endif + draw_closing_lines(resourceview_data, events_request); return 0; } @@ -2203,35 +2114,39 @@ int after_chunk(void *hook_data, void *call_data) */ int before_statedump_end(void *hook_data, void *call_data) { - gint i; + LttvEvent *event; - LttvTraceHook *th = (LttvTraceHook*)hook_data; - EventsRequest *events_request = (EventsRequest*)th->hook_data; - ControlFlowData *resourceview_data = events_request->viewer_data; + event = (LttvEvent *) call_data; + + if (strcmp(lttv_traceset_get_name_from_event(event),"lttng_statedump_end") != 0) + return FALSE; - LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + ControlFlowData *resourceview_data = (ControlFlowData*) hook_data; - LttvTracefileState *tfs = (LttvTracefileState *)call_data; - LttvTraceState *ts = (LttvTraceState *)tfc->t_context; + LttvTraceState *ts = event->state; - LttvTracesetState *tss = (LttvTracesetState*)tfc->t_context->ts_context; - ProcessList *process_list = resourceview_data->process_list; - LttEvent *e; - e = ltt_tracefile_get_event(tfc->tf); + gint i; + +#ifdef BABEL_CLEANUP LttvFilter *filter = resourceview_data->filter; if(filter != NULL && filter->head != NULL) if(!lttv_filter_tree_parse(filter->head,e,tfc->tf, tfc->t_context->t,tfc,NULL,NULL)) return FALSE; +#endif - LttTime evtime = ltt_event_time(e); + LttTime evtime = lttv_event_get_timestamp(event); ClosureData closure_data; - closure_data.events_request = events_request; - closure_data.tss = tss; + //TODO ybrosseau 2013-03-27: Fake and event_request. + // We need to change the API of drawing_request_expose to ask + // For and control flow data only. + EventsRequest events_request; + events_request.viewer_data = resourceview_data; + closure_data.events_request = &events_request; closure_data.end_time = evtime; TimeWindow time_window = @@ -2261,7 +2176,8 @@ int before_statedump_end(void *hook_data, void *call_data) gtk_widget_queue_draw(resourceview_data->drawing->drawing_area); #endif //0 /* Request expose (updates damages zone also) */ - drawing_request_expose(events_request, tss, evtime); + drawing_request_expose(&events_request, evtime); return 0; + }