X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fmodules%2Fgui%2Fcontrolflow%2Feventhooks.c;h=d6c80459d857a9f14e99d0c17687f653ad5a4dff;hb=f4b88a7dd49bfb6b88ea579410d7e4b59faaf73c;hp=abb2fd262e8cda30cc175e86a1f9830e61fdbb6f;hpb=7c0125e0d749f61688a140b2dbb76cc37ad57beb;p=lttv.git diff --git a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c index abb2fd26..d6c80459 100644 --- a/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c +++ b/ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c @@ -45,6 +45,9 @@ * line/background. */ +#ifdef HAVE_CONFIG_H +#include +#endif //#define PANGO_ENABLE_BACKEND #include @@ -59,6 +62,7 @@ #include #include #include +#include #include #include @@ -75,7 +79,6 @@ #define MAX_PATH_LEN 256 - #if 0 typedef struct _ProcessAddClosure { ControlFlowData *cfd; @@ -149,6 +152,9 @@ gint background_ready(void *hook_data, void *call_data) drawing_clear(control_flow_data->drawing); processlist_clear(control_flow_data->process_list); + gtk_widget_set_size_request( + control_flow_data->drawing->drawing_area, + -1, processlist_get_height(control_flow_data->process_list)); redraw_notify(control_flow_data, NULL); } @@ -372,15 +378,17 @@ static inline PropertiesLine prepare_status_line(LttvProcessState *process) int before_schedchange_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; ControlFlowData *control_flow_data = events_request->viewer_data; LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; LttvTracefileState *tfs = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)tfc->t_context; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -392,12 +400,8 @@ int before_schedchange_hook(void *hook_data, void *call_data) guint pid_out; guint pid_in; { - LttField *f = ltt_event_field(e); - LttField *element; - element = ltt_field_member(f,0); - pid_out = ltt_event_get_long_unsigned(e,element); - element = ltt_field_member(f,1); - pid_in = ltt_event_get_long_unsigned(e,element); + pid_out = ltt_event_get_long_unsigned(e, thf->f1); + pid_in = ltt_event_get_long_unsigned(e, thf->f2); } { @@ -407,12 +411,11 @@ int before_schedchange_hook(void *hook_data, void *call_data) * draw items from the beginning of the read for it. If it is not * present, it's a new process and it was not present : it will * be added after the state update. */ - LttvProcessState *process; + guint cpu = ltt_tracefile_num(tfc->tf); + LttvProcessState *process = ts->running_process[cpu]; /* unknown state, bad current pid */ - if(tfs->process->pid != pid_out) - process = lttv_state_find_process(tfs, pid_out); - else - process = tfs->process; + if(process->pid != pid_out) + process = lttv_state_find_process(ts, ANY_CPU, pid_out); if(process != NULL) { /* Well, the process_out existed : we must get it in the process hash @@ -426,24 +429,23 @@ int before_schedchange_hook(void *hook_data, void *call_data) hashed_process_data = processlist_get_process_data(process_list, pid_out, - process->last_cpu_index, + process->cpu, &birth, tfc->t_context->index); if(hashed_process_data == NULL) { g_assert(pid_out == 0 || pid_out != process->ppid); - const gchar *name = g_quark_to_string(process->name); /* Process not present */ ProcessInfo *process_info; Drawing_t *drawing = control_flow_data->drawing; processlist_add(process_list, drawing, pid_out, - process->last_cpu_index, + process->cpu, process->ppid, &birth, tfc->t_context->index, - name, + process->name, &pl_height, &process_info, &hashed_process_data); @@ -568,7 +570,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) * present, it's a new process and it was not present : it will * be added after the state update. */ LttvProcessState *process; - process = lttv_state_find_process(tfs, pid_in); + process = lttv_state_find_process(ts, ANY_CPU, pid_in); if(process != NULL) { /* Well, the process_out existed : we must get it in the process hash @@ -582,24 +584,23 @@ int before_schedchange_hook(void *hook_data, void *call_data) hashed_process_data = processlist_get_process_data(process_list, pid_in, - process->last_cpu_index, + process->cpu, &birth, tfc->t_context->index); if(hashed_process_data == NULL) { g_assert(pid_in == 0 || pid_in != process->ppid); - const gchar *name = g_quark_to_string(process->name); /* Process not present */ ProcessInfo *process_info; Drawing_t *drawing = control_flow_data->drawing; processlist_add(process_list, drawing, pid_in, - process->last_cpu_index, + process->cpu, process->ppid, &birth, tfc->t_context->index, - name, + process->name, &pl_height, &process_info, &hashed_process_data); @@ -912,7 +913,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) PropertiesBG prop_bg; prop_bg.color = g_new(GdkColor,1); - switch(tfc->index) { + switch(ltt_tracefile_num(tfc->tf)) { case 0: prop_bg.color->red = 0x1515; prop_bg.color->green = 0x1515; @@ -1135,7 +1136,7 @@ int before_schedchange_hook(void *hook_data, void *call_data) PropertiesBG prop_bg; prop_bg.color = g_new(GdkColor,1); - switch(tfc->index) { + switcht(ltt_tracefile_num(tfc->tf)) { case 0: prop_bg.color->red = 0x1515; prop_bg.color->green = 0x1515; @@ -1342,15 +1343,18 @@ int before_schedchange_hook(void *hook_data, void *call_data) */ int after_schedchange_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; ControlFlowData *control_flow_data = events_request->viewer_data; LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; LttvTracefileState *tfs = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)tfc->t_context; + LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -1365,18 +1369,16 @@ int after_schedchange_hook(void *hook_data, void *call_data) guint pid_in; { guint pid_out; - LttField *f = ltt_event_field(e); - LttField *element; - element = ltt_field_member(f,0); - pid_out = ltt_event_get_long_unsigned(e,element); - element = ltt_field_member(f,1); - pid_in = ltt_event_get_long_unsigned(e,element); + pid_out = ltt_event_get_long_unsigned(e, thf->f1); + pid_in = ltt_event_get_long_unsigned(e, thf->f2); } /* Find process pid_in in the list... */ - //process_in = lttv_state_find_process(tfs, pid_in); - process_in = tfs->process; + //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in); + //process_in = tfs->process; + guint cpu = ltt_tracefile_num(tfc->tf); + process_in = ts->running_process[cpu]; /* It should exist, because we are after the state update. */ #ifdef EXTRA_CHECK g_assert(process_in != NULL); @@ -1385,24 +1387,23 @@ int after_schedchange_hook(void *hook_data, void *call_data) hashed_process_data_in = processlist_get_process_data(process_list, pid_in, - process_in->last_cpu_index, + process_in->cpu, &birth, tfc->t_context->index); if(hashed_process_data_in == NULL) { g_assert(pid_in == 0 || pid_in != process_in->ppid); - const gchar *name = g_quark_to_string(process_in->name); ProcessInfo *process_info; Drawing_t *drawing = control_flow_data->drawing; /* Process not present */ processlist_add(process_list, drawing, pid_in, - process_in->last_cpu_index, + process_in->cpu, process_in->ppid, &birth, tfc->t_context->index, - name, + process_in->name, &pl_height, &process_info, &hashed_process_data_in); @@ -1412,7 +1413,7 @@ int after_schedchange_hook(void *hook_data, void *call_data) gtk_widget_queue_draw(drawing->drawing_area); } /* Set the current process */ - process_list->current_hash_data[process_in->last_cpu_index] = + process_list->current_hash_data[process_in->cpu] = hashed_process_data_in; if(ltt_time_compare(hashed_process_data_in->next_good_time, @@ -1847,7 +1848,7 @@ int after_schedchange_hook(void *hook_data, void *call_data) prop_text_in.text = g_new(gchar, 260); strcpy(prop_text_in.text, "CPU "); - snprintf(tmp, 255, "%u", tfc->index); + snprintf(tmp, 255, "%u", ltt_tracefile_num(tfc->tf)); strcat(prop_text_in.text, tmp); draw_text((void*)&prop_text_in, (void*)draw_context_in); @@ -1952,15 +1953,18 @@ static inline PropertiesLine prepare_execmode_line(LttvProcessState *process) int before_execmode_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; ControlFlowData *control_flow_data = events_request->viewer_data; LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; LttvTracefileState *tfs = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)tfc->t_context; + LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -1969,7 +1973,9 @@ int before_execmode_hook(void *hook_data, void *call_data) * time to do it. */ /* For the pid */ - LttvProcessState *process = tfs->process; + //LttvProcessState *process = tfs->process; + guint cpu = ltt_tracefile_num(tfc->tf); + LttvProcessState *process = ts->running_process[cpu]; g_assert(process != NULL); guint pid = process->pid; @@ -1983,12 +1989,12 @@ int before_execmode_hook(void *hook_data, void *call_data) ProcessList *process_list = control_flow_data->process_list; LttTime birth = process->creation_time; - if(likely(process_list->current_hash_data[tfc->index] != NULL)) { - hashed_process_data = process_list->current_hash_data[tfc->index]; + if(likely(process_list->current_hash_data[cpu] != NULL)) { + hashed_process_data = process_list->current_hash_data[cpu]; } else { hashed_process_data = processlist_get_process_data(process_list, pid, - process->last_cpu_index, + process->cpu, &birth, tfc->t_context->index); if(unlikely(hashed_process_data == NULL)) @@ -1997,15 +2003,14 @@ int before_execmode_hook(void *hook_data, void *call_data) ProcessInfo *process_info; /* Process not present */ Drawing_t *drawing = control_flow_data->drawing; - const gchar *name = g_quark_to_string(process->name); processlist_add(process_list, drawing, pid, - process->last_cpu_index, + process->cpu, process->ppid, &birth, tfc->t_context->index, - name, + process->name, &pl_height, &process_info, &hashed_process_data); @@ -2015,7 +2020,7 @@ int before_execmode_hook(void *hook_data, void *call_data) gtk_widget_queue_draw(drawing->drawing_area); } /* Set the current process */ - process_list->current_hash_data[process->last_cpu_index] = + process_list->current_hash_data[process->cpu] = hashed_process_data; } @@ -2138,6 +2143,7 @@ int before_execmode_hook(void *hook_data, void *call_data) * This function adds items to be drawn in a queue for each process. * */ +#if 0 int after_execmode_hook(void *hook_data, void *call_data) { /**************** DOES NOTHING!! *************/ @@ -2145,8 +2151,8 @@ int after_execmode_hook(void *hook_data, void *call_data) return 0; - - EventsRequest *events_request = (EventsRequest*)hook_data; + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; ControlFlowData *control_flow_data = events_request->viewer_data; LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; @@ -2154,7 +2160,7 @@ int after_execmode_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -2175,8 +2181,8 @@ int after_execmode_hook(void *hook_data, void *call_data) birth = process->creation_time; - if(likely(process_list->current_hash_data[tfc->index] != NULL)) { - hashed_process_data = process_list->current_hash_data[tfc->index]; + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) { + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; } else { hashed_process_data = processlist_get_process_data(process_list, pid, @@ -2240,10 +2246,11 @@ int after_execmode_hook(void *hook_data, void *call_data) } return 0; } +#endif //0 -/* before_process_hook +/* before_process_exit_hook * * Draw lines for process event. * @@ -2253,110 +2260,81 @@ int after_execmode_hook(void *hook_data, void *call_data) * This function adds items to be drawn in a queue for each process. * */ -int before_process_hook(void *hook_data, void *call_data) + + +int before_process_exit_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; + ControlFlowData *control_flow_data = events_request->viewer_data; LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; LttvTracefileState *tfs = (LttvTracefileState *)call_data; + LttvTraceState *ts = (LttvTraceState *)tfc->t_context; + LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); - guint sub_id; - { - LttField *f = ltt_event_field(e); - LttField *element; - element = ltt_field_member(f,0); - sub_id = ltt_event_get_long_unsigned(e,element); - } - - if(sub_id == 3) { /* exit */ - - /* Add process to process list (if not present) */ - LttvProcessState *process = tfs->process; - guint pid = process->pid; - LttTime birth; - guint pl_height = 0; - HashedProcessData *hashed_process_data = NULL; - - ProcessList *process_list = control_flow_data->process_list; - - g_assert(process != NULL); + /* Add process to process list (if not present) */ + //LttvProcessState *process = tfs->process; + guint cpu = ltt_tracefile_num(tfc->tf); + LttvProcessState *process = ts->running_process[cpu]; + guint pid = process->pid; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; - birth = process->creation_time; + ProcessList *process_list = control_flow_data->process_list; + + g_assert(process != NULL); - if(likely(process_list->current_hash_data[tfc->index] != NULL)) { - hashed_process_data = process_list->current_hash_data[tfc->index]; - } else { - hashed_process_data = processlist_get_process_data(process_list, - pid, - process->last_cpu_index, - &birth, - tfc->t_context->index); - if(unlikely(hashed_process_data == NULL)) - { - g_assert(pid == 0 || pid != process->ppid); - /* Process not present */ - Drawing_t *drawing = control_flow_data->drawing; - const gchar *name = g_quark_to_string(process->name); - ProcessInfo *process_info; - processlist_add(process_list, - drawing, - pid, - process->last_cpu_index, - process->ppid, - &birth, - tfc->t_context->index, - name, - &pl_height, - &process_info, - &hashed_process_data); - gtk_widget_set_size_request(drawing->drawing_area, - -1, - pl_height); - gtk_widget_queue_draw(drawing->drawing_area); - } - } + birth = process->creation_time; - /* Now, the process is in the state hash and our own process hash. - * We definitely can draw the items related to the ending state. - */ - - if(likely(ltt_time_compare(hashed_process_data->next_good_time, - evtime) > 0)) + if(likely(process_list->current_hash_data[cpu] != NULL)) { + hashed_process_data = process_list->current_hash_data[cpu]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->cpu, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) { - if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { - TimeWindow time_window = - lttvwindow_get_time_window(control_flow_data->tab); - -#ifdef EXTRA_CHECK - if(ltt_time_compare(evtime, time_window.start_time) == -1 - || ltt_time_compare(evtime, time_window.end_time) == 1) - return; -#endif //EXTRA_CHECK - Drawing_t *drawing = control_flow_data->drawing; - guint width = drawing->width; - guint x; - convert_time_to_pixels( - time_window, - evtime, - width, - &x); + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->cpu, + process->ppid, + &birth, + tfc->t_context->index, + process->name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + } - /* Draw collision indicator */ - gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); - gdk_draw_point(hashed_process_data->pixmap, - drawing->gc, - x, - (hashed_process_data->height/2)-3); - hashed_process_data->x.middle_marked = TRUE; - } - } else { + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { TimeWindow time_window = lttvwindow_get_time_window(control_flow_data->tab); @@ -2368,64 +2346,644 @@ int before_process_hook(void *hook_data, void *call_data) Drawing_t *drawing = control_flow_data->drawing; guint width = drawing->width; guint x; - convert_time_to_pixels( - time_window, - evtime, - width, - &x); + time_window, + evtime, + width, + &x); + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + } else { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); - /* Jump over draw if we are at the same x position */ - if(unlikely(x == hashed_process_data->x.middle && - hashed_process_data->x.middle_used)) - { - if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { - /* Draw collision indicator */ - gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); - gdk_draw_point(hashed_process_data->pixmap, - drawing->gc, - x, - (hashed_process_data->height/2)-3); - hashed_process_data->x.middle_marked = TRUE; - } - /* jump */ - } else { - DrawContext draw_context; +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; - /* Now create the drawing context that will be used to draw - * items related to the last state. */ - draw_context.drawable = hashed_process_data->pixmap; - draw_context.gc = drawing->gc; - draw_context.pango_layout = drawing->pango_layout; - draw_context.drawinfo.start.x = hashed_process_data->x.middle; - draw_context.drawinfo.end.x = x; + convert_time_to_pixels( + time_window, + evtime, + width, + &x); - draw_context.drawinfo.y.over = 1; - draw_context.drawinfo.y.middle = (hashed_process_data->height/2); - draw_context.drawinfo.y.under = hashed_process_data->height; - draw_context.drawinfo.start.offset.over = 0; - draw_context.drawinfo.start.offset.middle = 0; - draw_context.drawinfo.start.offset.under = 0; - draw_context.drawinfo.end.offset.over = 0; - draw_context.drawinfo.end.offset.middle = 0; - draw_context.drawinfo.end.offset.under = 0; + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* jump */ + } else { + DrawContext draw_context; - { - /* Draw the line */ + /* Now create the drawing context that will be used to draw + * items related to the last state. */ + draw_context.drawable = hashed_process_data->pixmap; + draw_context.gc = drawing->gc; + draw_context.pango_layout = drawing->pango_layout; + draw_context.drawinfo.start.x = hashed_process_data->x.middle; + draw_context.drawinfo.end.x = x; + + draw_context.drawinfo.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; + + draw_context.drawinfo.start.offset.over = 0; + draw_context.drawinfo.start.offset.middle = 0; + draw_context.drawinfo.start.offset.under = 0; + draw_context.drawinfo.end.offset.over = 0; + draw_context.drawinfo.end.offset.middle = 0; + draw_context.drawinfo.end.offset.under = 0; + + { + /* Draw the line */ + PropertiesLine prop_line = prepare_s_e_line(process); + draw_line((void*)&prop_line, (void*)&draw_context); + + } + /* become the last x position */ + hashed_process_data->x.middle = x; + hashed_process_data->x.middle_used = TRUE; + hashed_process_data->x.middle_marked = FALSE; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + + return 0; + +} + + + +/* before_process_release_hook + * + * Draw lines for process event. + * + * @param hook_data ControlFlowData structure of the viewer. + * @param call_data Event context. + * + * This function adds items to be drawn in a queue for each process. + * + */ + + +int before_process_release_hook(void *hook_data, void *call_data) +{ + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; + + ControlFlowData *control_flow_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); + + + guint pid; + { + pid = ltt_event_get_long_unsigned(e, thf->f1); + } + + /* Add process to process list (if not present) */ + /* Don't care about the process if it's not in the state hash already : + * that means a process that has never done anything in the trace and + * unknown suddently gets destroyed : no state meaningful to show. */ + LttvProcessState *process = lttv_state_find_process(ts, ANY_CPU, pid); + + if(process != NULL) { + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + birth = process->creation_time; + + /* Cannot use current process : this event happens on another process, + * action done by the parent. */ + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->cpu, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->cpu, + process->ppid, + &birth, + tfc->t_context->index, + process->name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + } else { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* jump */ + } else { + DrawContext draw_context; + + /* Now create the drawing context that will be used to draw + * items related to the last state. */ + draw_context.drawable = hashed_process_data->pixmap; + draw_context.gc = drawing->gc; + draw_context.pango_layout = drawing->pango_layout; + draw_context.drawinfo.start.x = hashed_process_data->x.middle; + draw_context.drawinfo.end.x = x; + + draw_context.drawinfo.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; + + draw_context.drawinfo.start.offset.over = 0; + draw_context.drawinfo.start.offset.middle = 0; + draw_context.drawinfo.start.offset.under = 0; + draw_context.drawinfo.end.offset.over = 0; + draw_context.drawinfo.end.offset.middle = 0; + draw_context.drawinfo.end.offset.under = 0; + + { + /* Draw the line */ + PropertiesLine prop_line = prepare_s_e_line(process); + draw_line((void*)&prop_line, (void*)&draw_context); + + } + /* become the last x position */ + hashed_process_data->x.middle = x; + hashed_process_data->x.middle_used = TRUE; + hashed_process_data->x.middle_marked = FALSE; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + } + + return 0; +} + + + + + + + + +#if 0 +/* before_process_hook + * + * Draw lines for process event. + * + * @param hook_data ControlFlowData structure of the viewer. + * @param call_data Event context. + * + * This function adds items to be drawn in a queue for each process. + * + */ +int before_process_hook(void *hook_data, void *call_data) +{ + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; + ControlFlowData *control_flow_data = events_request->viewer_data; + + LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + + LttvTracefileState *tfs = (LttvTracefileState *)call_data; + + LttEvent *e; + e = ltt_tracefile_get_event(tfc->tf); + + LttTime evtime = ltt_event_time(e); + + guint sub_id; + { + LttField *f = ltt_event_field(e); + LttField *element; + element = ltt_field_member(f,0); + sub_id = ltt_event_get_long_unsigned(e,element); + } + + if(sub_id == 3) { /* exit */ + + /* Add process to process list (if not present) */ + LttvProcessState *process = tfs->process; + guint pid = process->pid; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + g_assert(process != NULL); + + birth = process->creation_time; + + if(likely(process_list->current_hash_data[tfc->index] != NULL)) { + hashed_process_data = process_list->current_hash_data[tfc->index]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + const gchar *name = g_quark_to_string(process->name); + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + } else { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* jump */ + } else { + DrawContext draw_context; + + /* Now create the drawing context that will be used to draw + * items related to the last state. */ + draw_context.drawable = hashed_process_data->pixmap; + draw_context.gc = drawing->gc; + draw_context.pango_layout = drawing->pango_layout; + draw_context.drawinfo.start.x = hashed_process_data->x.middle; + draw_context.drawinfo.end.x = x; + + draw_context.drawinfo.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; + + draw_context.drawinfo.start.offset.over = 0; + draw_context.drawinfo.start.offset.middle = 0; + draw_context.drawinfo.start.offset.under = 0; + draw_context.drawinfo.end.offset.over = 0; + draw_context.drawinfo.end.offset.middle = 0; + draw_context.drawinfo.end.offset.under = 0; + + { + /* Draw the line */ PropertiesLine prop_line = prepare_s_e_line(process); draw_line((void*)&prop_line, (void*)&draw_context); } - /* become the last x position */ - hashed_process_data->x.middle = x; - hashed_process_data->x.middle_used = TRUE; - hashed_process_data->x.middle_marked = FALSE; - - /* Calculate the next good time */ - convert_pixels_to_time(width, x+1, time_window, - &hashed_process_data->next_good_time); + /* become the last x position */ + hashed_process_data->x.middle = x; + hashed_process_data->x.middle_used = TRUE; + hashed_process_data->x.middle_marked = FALSE; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } + } + + } else if(sub_id == 7) /* release */ { + + guint pid; + { + LttField *f = ltt_event_field(e); + LttField *element; + element = ltt_field_member(f,1); + pid = ltt_event_get_long_unsigned(e,element); + } + + /* Add process to process list (if not present) */ + /* Don't care about the process if it's not in the state hash already : + * that means a process that has never done anything in the trace and + * unknown suddently gets destroyed : no state meaningful to show. */ + LttvProcessState *process = lttv_state_find_process(tfs, pid); + + if(process != NULL) { + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + birth = process->creation_time; + + /* Cannot use current process : this event happens on another process, + * action done by the parent. */ + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->last_cpu_index, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->last_cpu_index, + process->ppid, + &birth, + tfc->t_context->index, + process->name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + /* Now, the process is in the state hash and our own process hash. + * We definitely can draw the items related to the ending state. + */ + + if(likely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) > 0)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + } else { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint x; + + convert_time_to_pixels( + time_window, + evtime, + width, + &x); + + + /* Jump over draw if we are at the same x position */ + if(unlikely(x == hashed_process_data->x.middle && + hashed_process_data->x.middle_used)) + { + if(unlikely(hashed_process_data->x.middle_marked == FALSE)) { + /* Draw collision indicator */ + gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]); + gdk_draw_point(hashed_process_data->pixmap, + drawing->gc, + x, + (hashed_process_data->height/2)-3); + hashed_process_data->x.middle_marked = TRUE; + } + /* jump */ + } else { + DrawContext draw_context; + + /* Now create the drawing context that will be used to draw + * items related to the last state. */ + draw_context.drawable = hashed_process_data->pixmap; + draw_context.gc = drawing->gc; + draw_context.pango_layout = drawing->pango_layout; + draw_context.drawinfo.start.x = hashed_process_data->x.middle; + draw_context.drawinfo.end.x = x; + + draw_context.drawinfo.y.over = 1; + draw_context.drawinfo.y.middle = (hashed_process_data->height/2); + draw_context.drawinfo.y.under = hashed_process_data->height; + + draw_context.drawinfo.start.offset.over = 0; + draw_context.drawinfo.start.offset.middle = 0; + draw_context.drawinfo.start.offset.under = 0; + draw_context.drawinfo.end.offset.over = 0; + draw_context.drawinfo.end.offset.middle = 0; + draw_context.drawinfo.end.offset.under = 0; + + { + /* Draw the line */ + PropertiesLine prop_line = prepare_s_e_line(process); + draw_line((void*)&prop_line, (void*)&draw_context); + + } + /* become the last x position */ + hashed_process_data->x.middle = x; + hashed_process_data->x.middle_used = TRUE; + hashed_process_data->x.middle_marked = FALSE; + + /* Calculate the next good time */ + convert_pixels_to_time(width, x+1, time_window, + &hashed_process_data->next_good_time); + } } } @@ -2434,10 +2992,242 @@ int before_process_hook(void *hook_data, void *call_data) } +#endif //0 + + + +/* after_process_fork_hook + * + * Create the processlist entry for the child process. Put the last + * position in x at the current time value. + * + * @param hook_data ControlFlowData structure of the viewer. + * @param call_data Event context. + * + * This function adds items to be drawn in a queue for each process. + * + */ +int after_process_fork_hook(void *hook_data, void *call_data) +{ + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; + ControlFlowData *control_flow_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); + + guint child_pid; + { + child_pid = ltt_event_get_long_unsigned(e, thf->f2); + } + + /* Add process to process list (if not present) */ + LttvProcessState *process_child; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data_child = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + /* Find child in the list... */ + process_child = lttv_state_find_process(ts, ANY_CPU, child_pid); + /* It should exist, because we are after the state update. */ + g_assert(process_child != NULL); + + birth = process_child->creation_time; + + /* Cannot use current process, because this action is done by the parent + * on its child. */ + hashed_process_data_child = processlist_get_process_data(process_list, + child_pid, + process_child->cpu, + &birth, + tfc->t_context->index); + if(likely(hashed_process_data_child == NULL)) + { + g_assert(child_pid == 0 || child_pid != process_child->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + child_pid, + process_child->cpu, + process_child->ppid, + &birth, + tfc->t_context->index, + process_child->name, + &pl_height, + &process_info, + &hashed_process_data_child); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + + if(likely(ltt_time_compare(hashed_process_data_child->next_good_time, + evtime) <= 0)) + { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); + +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint new_x; + convert_time_to_pixels( + time_window, + evtime, + width, + &new_x); + + if(likely(hashed_process_data_child->x.over != new_x)) { + hashed_process_data_child->x.over = new_x; + hashed_process_data_child->x.over_used = FALSE; + hashed_process_data_child->x.over_marked = FALSE; + } + if(likely(hashed_process_data_child->x.middle != new_x)) { + hashed_process_data_child->x.middle = new_x; + hashed_process_data_child->x.middle_used = FALSE; + hashed_process_data_child->x.middle_marked = FALSE; + } + if(likely(hashed_process_data_child->x.under != new_x)) { + hashed_process_data_child->x.under = new_x; + hashed_process_data_child->x.under_used = FALSE; + hashed_process_data_child->x.under_marked = FALSE; + } + } + return 0; +} + + + +/* after_process_exit_hook + * + * Create the processlist entry for the child process. Put the last + * position in x at the current time value. + * + * @param hook_data ControlFlowData structure of the viewer. + * @param call_data Event context. + * + * This function adds items to be drawn in a queue for each process. + * + */ +int after_process_exit_hook(void *hook_data, void *call_data) +{ + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; + ControlFlowData *control_flow_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); + + /* Add process to process list (if not present) */ + //LttvProcessState *process = tfs->process; + guint cpu = ltt_tracefile_num(tfc->tf); + LttvProcessState *process = ts->running_process[cpu]; + + /* It should exist, because we are after the state update. */ + g_assert(process != NULL); + + guint pid = process->pid; + LttTime birth; + guint pl_height = 0; + HashedProcessData *hashed_process_data = NULL; + + ProcessList *process_list = control_flow_data->process_list; + + birth = process->creation_time; + + if(likely(process_list->current_hash_data[cpu] != NULL) ){ + hashed_process_data = process_list->current_hash_data[cpu]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->cpu, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + ProcessInfo *process_info; + processlist_add(process_list, + drawing, + pid, + process->cpu, + process->ppid, + &birth, + tfc->t_context->index, + process->name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + + /* Set the current process */ + process_list->current_hash_data[process->cpu] = + hashed_process_data; + } + + if(unlikely(ltt_time_compare(hashed_process_data->next_good_time, + evtime) <= 0)) + { + TimeWindow time_window = + lttvwindow_get_time_window(control_flow_data->tab); +#ifdef EXTRA_CHECK + if(ltt_time_compare(evtime, time_window.start_time) == -1 + || ltt_time_compare(evtime, time_window.end_time) == 1) + return; +#endif //EXTRA_CHECK + Drawing_t *drawing = control_flow_data->drawing; + guint width = drawing->width; + guint new_x; + convert_time_to_pixels( + time_window, + evtime, + width, + &new_x); + if(unlikely(hashed_process_data->x.middle != new_x)) { + hashed_process_data->x.middle = new_x; + hashed_process_data->x.middle_used = FALSE; + hashed_process_data->x.middle_marked = FALSE; + } + } + return 0; +} +#if 0 /* after_process_hook * @@ -2452,7 +3242,8 @@ int before_process_hook(void *hook_data, void *call_data) */ int after_process_hook(void *hook_data, void *call_data) { - EventsRequest *events_request = (EventsRequest*)hook_data; + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; ControlFlowData *control_flow_data = events_request->viewer_data; LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; @@ -2460,7 +3251,7 @@ int after_process_hook(void *hook_data, void *call_data) LttvTracefileState *tfs = (LttvTracefileState *)call_data; LttEvent *e; - e = tfc->e; + e = ltt_tracefile_get_event(tfc->tf); LttTime evtime = ltt_event_time(e); @@ -2493,6 +3284,8 @@ int after_process_hook(void *hook_data, void *call_data) birth = process_child->creation_time; + /* Cannot use current process, because this action is done by the parent + * on its child. */ hashed_process_data_child = processlist_get_process_data(process_list, child_pid, process_child->last_cpu_index, @@ -2576,8 +3369,8 @@ int after_process_hook(void *hook_data, void *call_data) birth = process->creation_time; - if(likely(process_list->current_hash_data[tfc->index] != NULL) ){ - hashed_process_data = process_list->current_hash_data[tfc->index]; + if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL) ){ + hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)]; } else { hashed_process_data = processlist_get_process_data(process_list, pid, @@ -2643,6 +3436,78 @@ int after_process_hook(void *hook_data, void *call_data) return 0; } +#endif //0 + +/* Get the filename of the process to print */ +int after_fs_exec_hook(void *hook_data, void *call_data) +{ + LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data; + EventsRequest *events_request = (EventsRequest*)thf->hook_data; + ControlFlowData *control_flow_data = events_request->viewer_data; + + LttvTracefileContext *tfc = (LttvTracefileContext *)call_data; + + LttvTracefileState *tfs = (LttvTracefileState *)call_data; + + LttvTraceState *ts = (LttvTraceState *)tfc->t_context; + + guint cpu = ltt_tracefile_num(tfc->tf); + LttvProcessState *process = ts->running_process[cpu]; + g_assert(process != NULL); + + guint pid = process->pid; + + /* 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; + HashedProcessData *hashed_process_data = NULL; + ProcessList *process_list = control_flow_data->process_list; + LttTime birth = process->creation_time; + + if(likely(process_list->current_hash_data[cpu] != NULL)) { + hashed_process_data = process_list->current_hash_data[cpu]; + } else { + hashed_process_data = processlist_get_process_data(process_list, + pid, + process->cpu, + &birth, + tfc->t_context->index); + if(unlikely(hashed_process_data == NULL)) + { + g_assert(pid == 0 || pid != process->ppid); + ProcessInfo *process_info; + /* Process not present */ + Drawing_t *drawing = control_flow_data->drawing; + processlist_add(process_list, + drawing, + pid, + process->cpu, + process->ppid, + &birth, + tfc->t_context->index, + process->name, + &pl_height, + &process_info, + &hashed_process_data); + gtk_widget_set_size_request(drawing->drawing_area, + -1, + pl_height); + gtk_widget_queue_draw(drawing->drawing_area); + } + /* Set the current process */ + process_list->current_hash_data[process->cpu] = + hashed_process_data; + } + + processlist_set_name(process_list, process->name, hashed_process_data); + + return 0; + +} + + gint update_time_window_hook(void *hook_data, void *call_data) @@ -2870,6 +3735,9 @@ gint traceset_notify(void *hook_data, void *call_data) drawing_clear(control_flow_data->drawing); processlist_clear(control_flow_data->process_list); + gtk_widget_set_size_request( + control_flow_data->drawing->drawing_area, + -1, processlist_get_height(control_flow_data->process_list)); redraw_notify(control_flow_data, NULL); request_background_data(control_flow_data); @@ -2889,7 +3757,9 @@ gint redraw_notify(void *hook_data, void *call_data) /* fun feature, to be separated someday... */ drawing_clear(control_flow_data->drawing); processlist_clear(control_flow_data->process_list); - + gtk_widget_set_size_request( + control_flow_data->drawing->drawing_area, + -1, processlist_get_height(control_flow_data->process_list)); // Clear the images rectangle_pixmap (control_flow_data->process_list, widget->style->black_gc, @@ -2979,12 +3849,12 @@ gint update_current_time_hook(void *hook_data, void *call_data) * at one end of the trace. */ - if(ltt_time_compare(current_time, time_begin) == -1) + if(ltt_time_compare(current_time, time_begin) < 0) { TimeWindow new_time_window; if(ltt_time_compare(current_time, - ltt_time_add(trace_start,half_width)) == -1) + ltt_time_add(trace_start,half_width)) < 0) time_begin = trace_start; else time_begin = ltt_time_sub(current_time,half_width); @@ -2996,11 +3866,11 @@ gint update_current_time_hook(void *hook_data, void *call_data) lttvwindow_report_time_window(control_flow_data->tab, new_time_window); } - else if(ltt_time_compare(current_time, time_end) == 1) + else if(ltt_time_compare(current_time, time_end) > 0) { TimeWindow new_time_window; - if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) == 1) + if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0) time_begin = ltt_time_sub(trace_end,width); else time_begin = ltt_time_sub(current_time,half_width); @@ -3051,13 +3921,30 @@ void draw_closure(gpointer key, gpointer value, gpointer user_data) #ifdef EXTRA_CHECK g_assert(lttv_traceset_number(tsc->ts) > 0); #endif //EXTRA_CHECK - /* tracefiles[0] is ok here, because we draw for every PID, and - * assume CPU 0 for PID 0 //FIXME */ - LttvTracefileState *tfs = - (LttvTracefileState*)tsc->traces[process_info->trace_num]->tracefiles[0]; + LttvTraceContext *tc = tsc->traces[process_info->trace_num]; + LttvTraceState *ts = (LttvTraceState*)tc; + +#if 0 + //FIXME : optimize data structures. + LttvTracefileState *tfs; + LttvTracefileContext *tfc; + guint i; + for(i=0;itracefiles->len;i++) { + tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i); + if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU + && ltt_tracefile_num(tfc->tf) == process_info->cpu) + break; + } + g_assert(itracefiles->len); + tfs = LTTV_TRACEFILE_STATE(tfc); +#endif //0 + // LttvTracefileState *tfs = + // (LttvTracefileState*)tsc->traces[process_info->trace_num]-> + // tracefiles[process_info->cpu]; + LttvProcessState *process; - process = lttv_state_find_process(tfs, + process = lttv_state_find_process(ts, process_info->cpu, process_info->pid); if(unlikely(process != NULL)) { @@ -3168,13 +4055,13 @@ 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; - +#if 0 /* Desactivate sort */ gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(cfd->process_list->list_store), TRACE_COLUMN, GTK_SORT_ASCENDING); - +#endif //0 drawing_chunk_begin(events_request, tss); return 0; @@ -3275,7 +4162,7 @@ int after_chunk(void *hook_data, void *call_data) /* Draw last items */ g_hash_table_foreach(process_list->process_hash, draw_closure, (void*)&closure_data); - +#if 0 /* Reactivate sort */ gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(control_flow_data->process_list->list_store), @@ -3283,8 +4170,10 @@ int after_chunk(void *hook_data, void *call_data) GTK_SORT_ASCENDING); update_index_to_pixmap(control_flow_data->process_list); - - /* Request expose */ + /* Request a full expose : drawing scrambled */ + gtk_widget_queue_draw(control_flow_data->drawing->drawing_area); +#endif //0 + /* Request expose (updates damages zone also) */ drawing_request_expose(events_request, tss, end_time); return 0;