projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update compat
[lttv.git] / ltt / branches / poly / lttv / modules / gui / controlflow / eventhooks.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Mathieu Desnoyers
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
16 * MA 02111-1307, USA.
17 */
18
19
20 /*****************************************************************************
21 * Hooks to be called by the main window *
22 *****************************************************************************/
23
24
25 /* Event hooks are the drawing hooks called during traceset read. They draw the
26 * icons, text, lines and background color corresponding to the events read.
27 *
28 * Two hooks are used for drawing : before_schedchange and after_schedchange hooks. The
29 * before_schedchange is called before the state update that occurs with an event and
30 * the after_schedchange hook is called after this state update.
31 *
32 * The before_schedchange hooks fulfill the task of drawing the visible objects that
33 * corresponds to the data accumulated by the after_schedchange hook.
34 *
35 * The after_schedchange hook accumulates the data that need to be shown on the screen
36 * (items) into a queue. Then, the next before_schedchange hook will draw what that
37 * queue contains. That's the Right Way (TM) of drawing items on the screen,
38 * because we need to draw the background first (and then add icons, text, ...
39 * over it), but we only know the length of a background region once the state
40 * corresponding to it is over, which happens to be at the next before_schedchange
41 * hook.
42 *
43 * We also have a hook called at the end of a chunk to draw the information left
44 * undrawn in each process queue. We use the current time as end of
45 * line/background.
46 */
47
48 #ifdef HAVE_CONFIG_H
49 #include <config.h>
50 #endif
51
52 //#define PANGO_ENABLE_BACKEND
53 #include <gtk/gtk.h>
54 #include <gdk/gdk.h>
55 #include <glib.h>
56 #include <assert.h>
57 #include <string.h>
58 #include <stdio.h>
59
60 //#include <pango/pango.h>
61
62 #include <ltt/event.h>
63 #include <ltt/time.h>
64 #include <ltt/type.h>
65 #include <ltt/trace.h>
66
67 #include <lttv/lttv.h>
68 #include <lttv/hook.h>
69 #include <lttv/state.h>
70 #include <lttvwindow/lttvwindow.h>
71 #include <lttvwindow/lttvwindowtraces.h>
72 #include <lttvwindow/support.h>
73
74
75 #include "eventhooks.h"
76 #include "cfv.h"
77 #include "processlist.h"
78 #include "drawing.h"
79
80
81 #define MAX_PATH_LEN 256
82 #define STATE_LINE_WIDTH 4
83 #define COLLISION_POSITION(height) (((height - STATE_LINE_WIDTH)/2) -3)
84
85 extern GSList *g_legend_list;
86
87
88 /* Action to do when background computation completed.
89 *
90 * Wait for all the awaited computations to be over.
91 */
92
93 static gint background_ready(void *hook_data, void *call_data)
94 {
95 ControlFlowData *control_flow_data = (ControlFlowData *)hook_data;
96 LttvTrace *trace = (LttvTrace*)call_data;
97
98 control_flow_data->background_info_waiting--;
99
100 if(control_flow_data->background_info_waiting == 0) {
101 g_message("control flow viewer : background computation data ready.");
102
103 drawing_clear(control_flow_data->drawing);
104 processlist_clear(control_flow_data->process_list);
105 gtk_widget_set_size_request(
106 control_flow_data->drawing->drawing_area,
107 -1, processlist_get_height(control_flow_data->process_list));
108 redraw_notify(control_flow_data, NULL);
109 }
110
111 return 0;
112 }
113
114
115 /* Request background computation. Verify if it is in progress or ready first.
116 * Only for each trace in the tab's traceset.
117 */
118 static void request_background_data(ControlFlowData *control_flow_data)
119 {
120 LttvTracesetContext * tsc =
121 lttvwindow_get_traceset_context(control_flow_data->tab);
122 gint num_traces = lttv_traceset_number(tsc->ts);
123 gint i;
124 LttvTrace *trace;
125 LttvTraceState *tstate;
126
127 LttvHooks *background_ready_hook =
128 lttv_hooks_new();
129 lttv_hooks_add(background_ready_hook, background_ready, control_flow_data,
130 LTTV_PRIO_DEFAULT);
131 control_flow_data->background_info_waiting = 0;
132
133 for(i=0;i<num_traces;i++) {
134 trace = lttv_traceset_get(tsc->ts, i);
135 tstate = LTTV_TRACE_STATE(tsc->traces[i]);
136
137 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
138 && !tstate->has_precomputed_states) {
139
140 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
141 trace) == FALSE) {
142 /* We first remove requests that could have been done for the same
143 * information. Happens when two viewers ask for it before servicing
144 * starts.
145 */
146 if(!lttvwindowtraces_background_request_find(trace, "state"))
147 lttvwindowtraces_background_request_queue(
148 main_window_get_widget(control_flow_data->tab), trace, "state");
149 lttvwindowtraces_background_notify_queue(control_flow_data,
150 trace,
151 ltt_time_infinite,
152 NULL,
153 background_ready_hook);
154 control_flow_data->background_info_waiting++;
155 } else { /* in progress */
156
157 lttvwindowtraces_background_notify_current(control_flow_data,
158 trace,
159 ltt_time_infinite,
160 NULL,
161 background_ready_hook);
162 control_flow_data->background_info_waiting++;
163 }
164 } else {
165 /* Data ready. By its nature, this viewer doesn't need to have
166 * its data ready hook called there, because a background
167 * request is always linked with a redraw.
168 */
169 }
170
171 }
172
173 lttv_hooks_destroy(background_ready_hook);
174 }
175
176
177
178
179 /**
180 * Event Viewer's constructor hook
181 *
182 * This constructor is given as a parameter to the menuitem and toolbar button
183 * registration. It creates the list.
184 * @param tab A pointer to the parent tab.
185 * @return The widget created.
186 */
187 GtkWidget *
188 h_guicontrolflow(LttvPlugin *plugin)
189 {
190 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
191 Tab *tab = ptab->tab;
192 g_info("h_guicontrolflow, %p", tab);
193 ControlFlowData *control_flow_data = guicontrolflow(ptab);
194
195 control_flow_data->tab = tab;
196
197 // Unreg done in the GuiControlFlow_Destructor
198 lttvwindow_register_traceset_notify(tab,
199 traceset_notify,
200 control_flow_data);
201
202 lttvwindow_register_time_window_notify(tab,
203 update_time_window_hook,
204 control_flow_data);
205 lttvwindow_register_current_time_notify(tab,
206 update_current_time_hook,
207 control_flow_data);
208 lttvwindow_register_redraw_notify(tab,
209 redraw_notify,
210 control_flow_data);
211 lttvwindow_register_continue_notify(tab,
212 continue_notify,
213 control_flow_data);
214 request_background_data(control_flow_data);
215
216
217 return guicontrolflow_get_widget(control_flow_data) ;
218
219 }
220
221 void legend_destructor(GtkWindow *legend)
222 {
223 g_legend_list = g_slist_remove(g_legend_list, legend);
224 }
225
226 /* Create a popup legend */
227 GtkWidget *
228 h_legend(LttvPlugin *plugin)
229 {
230 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
231 Tab *tab = ptab->tab;
232 g_info("h_legend, %p", tab);
233
234 GtkWindow *legend = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
235
236 g_legend_list = g_slist_append(
237 g_legend_list,
238 legend);
239
240 g_object_set_data_full(
241 G_OBJECT(legend),
242 "legend",
243 legend,
244 (GDestroyNotify)legend_destructor);
245
246 gtk_window_set_title(legend, "Control Flow View Legend");
247
248 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(legend), "lttv-color-list.png");
249
250 // GtkImage *image = GTK_IMAGE(gtk_image_new_from_pixmap(
251 // GDK_PIXMAP(pixmap), NULL));
252
253 gtk_container_add(GTK_CONTAINER(legend), GTK_WIDGET(pixmap));
254
255 gtk_widget_show(GTK_WIDGET(pixmap));
256 gtk_widget_show(GTK_WIDGET(legend));
257
258
259 return NULL; /* This is a popup window */
260 }
261
262
263 int event_selected_hook(void *hook_data, void *call_data)
264 {
265 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
266 guint *event_number = (guint*) call_data;
267
268 g_debug("DEBUG : event selected by main window : %u", *event_number);
269
270 return 0;
271 }
272
273 /* Function that selects the color of status&exemode line */
274 static inline PropertiesLine prepare_s_e_line(LttvProcessState *process)
275 {
276 PropertiesLine prop_line;
277 prop_line.line_width = STATE_LINE_WIDTH;
278 prop_line.style = GDK_LINE_SOLID;
279 prop_line.y = MIDDLE;
280 //GdkColormap *colormap = gdk_colormap_get_system();
281
282 if(process->state->s == LTTV_STATE_RUN) {
283 if(process->state->t == LTTV_STATE_USER_MODE)
284 prop_line.color = drawing_colors[COL_RUN_USER_MODE];
285 else if(process->state->t == LTTV_STATE_SYSCALL)
286 prop_line.color = drawing_colors[COL_RUN_SYSCALL];
287 else if(process->state->t == LTTV_STATE_TRAP)
288 prop_line.color = drawing_colors[COL_RUN_TRAP];
289 else if(process->state->t == LTTV_STATE_IRQ)
290 prop_line.color = drawing_colors[COL_RUN_IRQ];
291 else if(process->state->t == LTTV_STATE_SOFT_IRQ)
292 prop_line.color = drawing_colors[COL_RUN_SOFT_IRQ];
293 else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
294 prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
295 else
296 g_assert(FALSE); /* RUNNING MODE UNKNOWN */
297 } else if(process->state->s == LTTV_STATE_WAIT) {
298 /* We don't show if we wait while in user mode, trap, irq or syscall */
299 prop_line.color = drawing_colors[COL_WAIT];
300 } else if(process->state->s == LTTV_STATE_WAIT_CPU) {
301 /* We don't show if we wait for CPU while in user mode, trap, irq
302 * or syscall */
303 prop_line.color = drawing_colors[COL_WAIT_CPU];
304 } else if(process->state->s == LTTV_STATE_ZOMBIE) {
305 prop_line.color = drawing_colors[COL_ZOMBIE];
306 } else if(process->state->s == LTTV_STATE_WAIT_FORK) {
307 prop_line.color = drawing_colors[COL_WAIT_FORK];
308 } else if(process->state->s == LTTV_STATE_EXIT) {
309 prop_line.color = drawing_colors[COL_EXIT];
310 } else if(process->state->s == LTTV_STATE_UNNAMED) {
311 prop_line.color = drawing_colors[COL_UNNAMED];
312 } else {
313 g_critical("unknown state : %s", g_quark_to_string(process->state->s));
314 g_assert(FALSE); /* UNKNOWN STATE */
315 }
316
317 return prop_line;
318
319 }
320
321
322 /* before_schedchange_hook
323 *
324 * This function basically draw lines and icons. Two types of lines are drawn :
325 * one small (3 pixels?) representing the state of the process and the second
326 * type is thicker (10 pixels?) representing on which CPU a process is running
327 * (and this only in running state).
328 *
329 * Extremums of the lines :
330 * x_min : time of the last event context for this process kept in memory.
331 * x_max : time of the current event.
332 * y : middle of the process in the process list. The process is found in the
333 * list, therefore is it's position in pixels.
334 *
335 * The choice of lines'color is defined by the context of the last event for this
336 * process.
337 */
338
339
340 int before_schedchange_hook(void *hook_data, void *call_data)
341 {
342 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
343 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
344 ControlFlowData *control_flow_data = events_request->viewer_data;
345
346 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
347
348 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
349 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
350
351 LttEvent *e;
352 e = ltt_tracefile_get_event(tfc->tf);
353 gint target_pid_saved = tfc->target_pid;
354
355 LttTime evtime = ltt_event_time(e);
356 LttvFilter *filter = control_flow_data->filter;
357
358 /* we are in a schedchange, before the state update. We must draw the
359 * items corresponding to the state before it changes : now is the right
360 * time to do it.
361 */
362
363 guint pid_out;
364 guint pid_in;
365 {
366 pid_out = ltt_event_get_long_unsigned(e, thf->f1);
367 pid_in = ltt_event_get_long_unsigned(e, thf->f2);
368 }
369
370 tfc->target_pid = pid_out;
371 if(!filter || !filter->head ||
372 lttv_filter_tree_parse(filter->head,e,tfc->tf,
373 tfc->t_context->t,tfc,NULL,NULL)) {
374 /* For the pid_out */
375 /* First, check if the current process is in the state computation
376 * process list. If it is there, that means we must add it right now and
377 * draw items from the beginning of the read for it. If it is not
378 * present, it's a new process and it was not present : it will
379 * be added after the state update. */
380 guint cpu = tfs->cpu;
381 guint trace_num = ts->parent.index;
382 LttvProcessState *process = ts->running_process[cpu];
383 /* unknown state, bad current pid */
384 if(process->pid != pid_out)
385 process = lttv_state_find_process(ts,
386 tfs->cpu, pid_out);
387
388 if(process != NULL) {
389 /* Well, the process_out existed : we must get it in the process hash
390 * or add it, and draw its items.
391 */
392 /* Add process to process list (if not present) */
393 guint pl_height = 0;
394 HashedProcessData *hashed_process_data = NULL;
395 ProcessList *process_list = control_flow_data->process_list;
396 LttTime birth = process->creation_time;
397
398 hashed_process_data = processlist_get_process_data(process_list,
399 pid_out,
400 process->cpu,
401 &birth,
402 trace_num);
403 if(hashed_process_data == NULL)
404 {
405 g_assert(pid_out == 0 || pid_out != process->ppid);
406 /* Process not present */
407 ProcessInfo *process_info;
408 Drawing_t *drawing = control_flow_data->drawing;
409 processlist_add(process_list,
410 drawing,
411 pid_out,
412 process->tgid,
413 process->cpu,
414 process->ppid,
415 &birth,
416 trace_num,
417 process->name,
418 process->brand,
419 &pl_height,
420 &process_info,
421 &hashed_process_data);
422 gtk_widget_set_size_request(drawing->drawing_area,
423 -1,
424 pl_height);
425 gtk_widget_queue_draw(drawing->drawing_area);
426
427 }
428
429 /* Now, the process is in the state hash and our own process hash.
430 * We definitely can draw the items related to the ending state.
431 */
432
433 if(ltt_time_compare(hashed_process_data->next_good_time,
434 evtime) > 0)
435 {
436 if(hashed_process_data->x.middle_marked == FALSE) {
437
438 TimeWindow time_window =
439 lttvwindow_get_time_window(control_flow_data->tab);
440 #ifdef EXTRA_CHECK
441 if(ltt_time_compare(evtime, time_window.start_time) == -1
442 || ltt_time_compare(evtime, time_window.end_time) == 1)
443 return;
444 #endif //EXTRA_CHECK
445 Drawing_t *drawing = control_flow_data->drawing;
446 guint width = drawing->width;
447 guint x;
448 convert_time_to_pixels(
449 time_window,
450 evtime,
451 width,
452 &x);
453
454 /* Draw collision indicator */
455 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
456 gdk_draw_point(hashed_process_data->pixmap,
457 drawing->gc,
458 x,
459 COLLISION_POSITION(hashed_process_data->height));
460 hashed_process_data->x.middle_marked = TRUE;
461 }
462 } else {
463 TimeWindow time_window =
464 lttvwindow_get_time_window(control_flow_data->tab);
465 #ifdef EXTRA_CHECK
466 if(ltt_time_compare(evtime, time_window.start_time) == -1
467 || ltt_time_compare(evtime, time_window.end_time) == 1)
468 return;
469 #endif //EXTRA_CHECK
470 Drawing_t *drawing = control_flow_data->drawing;
471 guint width = drawing->width;
472 guint x;
473 convert_time_to_pixels(
474 time_window,
475 evtime,
476 width,
477 &x);
478
479
480 /* Jump over draw if we are at the same x position */
481 if(x == hashed_process_data->x.middle &&
482 hashed_process_data->x.middle_used)
483 {
484 if(hashed_process_data->x.middle_marked == FALSE) {
485 /* Draw collision indicator */
486 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
487 gdk_draw_point(hashed_process_data->pixmap,
488 drawing->gc,
489 x,
490 COLLISION_POSITION(hashed_process_data->height));
491 hashed_process_data->x.middle_marked = TRUE;
492 }
493 /* jump */
494 } else {
495 DrawContext draw_context;
496
497 /* Now create the drawing context that will be used to draw
498 * items related to the last state. */
499 draw_context.drawable = hashed_process_data->pixmap;
500 draw_context.gc = drawing->gc;
501 draw_context.pango_layout = drawing->pango_layout;
502 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
503 draw_context.drawinfo.end.x = x;
504
505 draw_context.drawinfo.y.over = 1;
506 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
507 draw_context.drawinfo.y.under = hashed_process_data->height;
508
509 draw_context.drawinfo.start.offset.over = 0;
510 draw_context.drawinfo.start.offset.middle = 0;
511 draw_context.drawinfo.start.offset.under = 0;
512 draw_context.drawinfo.end.offset.over = 0;
513 draw_context.drawinfo.end.offset.middle = 0;
514 draw_context.drawinfo.end.offset.under = 0;
515
516 {
517 /* Draw the line */
518 PropertiesLine prop_line = prepare_s_e_line(process);
519 draw_line((void*)&prop_line, (void*)&draw_context);
520
521 }
522 /* become the last x position */
523 hashed_process_data->x.middle = x;
524 hashed_process_data->x.middle_used = TRUE;
525 hashed_process_data->x.middle_marked = FALSE;
526
527 /* Calculate the next good time */
528 convert_pixels_to_time(width, x+1, time_window,
529 &hashed_process_data->next_good_time);
530 }
531 }
532 }
533 }
534
535 tfc->target_pid = pid_in;
536 if(!filter || !filter->head ||
537 lttv_filter_tree_parse(filter->head,e,tfc->tf,
538 tfc->t_context->t,tfc,NULL,NULL)) {
539 /* For the pid_in */
540 /* First, check if the current process is in the state computation
541 * process list. If it is there, that means we must add it right now and
542 * draw items from the beginning of the read for it. If it is not
543 * present, it's a new process and it was not present : it will
544 * be added after the state update. */
545 LttvProcessState *process;
546 process = lttv_state_find_process(ts,
547 tfs->cpu, pid_in);
548 guint trace_num = ts->parent.index;
549
550 if(process != NULL) {
551 /* Well, the process existed : we must get it in the process hash
552 * or add it, and draw its items.
553 */
554 /* Add process to process list (if not present) */
555 guint pl_height = 0;
556 HashedProcessData *hashed_process_data = NULL;
557 ProcessList *process_list = control_flow_data->process_list;
558 LttTime birth = process->creation_time;
559
560 hashed_process_data = processlist_get_process_data(process_list,
561 pid_in,
562 tfs->cpu,
563 &birth,
564 trace_num);
565 if(hashed_process_data == NULL)
566 {
567 g_assert(pid_in == 0 || pid_in != process->ppid);
568 /* Process not present */
569 ProcessInfo *process_info;
570 Drawing_t *drawing = control_flow_data->drawing;
571 processlist_add(process_list,
572 drawing,
573 pid_in,
574 process->tgid,
575 tfs->cpu,
576 process->ppid,
577 &birth,
578 trace_num,
579 process->name,
580 process->brand,
581 &pl_height,
582 &process_info,
583 &hashed_process_data);
584 gtk_widget_set_size_request(drawing->drawing_area,
585 -1,
586 pl_height);
587 gtk_widget_queue_draw(drawing->drawing_area);
588
589 }
590 //We could set the current process and hash here, but will be done
591 //by after schedchange hook
592
593 /* Now, the process is in the state hash and our own process hash.
594 * We definitely can draw the items related to the ending state.
595 */
596
597 if(ltt_time_compare(hashed_process_data->next_good_time,
598 evtime) > 0)
599 {
600 if(hashed_process_data->x.middle_marked == FALSE) {
601
602 TimeWindow time_window =
603 lttvwindow_get_time_window(control_flow_data->tab);
604 #ifdef EXTRA_CHECK
605 if(ltt_time_compare(evtime, time_window.start_time) == -1
606 || ltt_time_compare(evtime, time_window.end_time) == 1)
607 return;
608 #endif //EXTRA_CHECK
609 Drawing_t *drawing = control_flow_data->drawing;
610 guint width = drawing->width;
611 guint x;
612 convert_time_to_pixels(
613 time_window,
614 evtime,
615 width,
616 &x);
617
618 /* Draw collision indicator */
619 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
620 gdk_draw_point(hashed_process_data->pixmap,
621 drawing->gc,
622 x,
623 COLLISION_POSITION(hashed_process_data->height));
624 hashed_process_data->x.middle_marked = TRUE;
625 }
626 } else {
627 TimeWindow time_window =
628 lttvwindow_get_time_window(control_flow_data->tab);
629 #ifdef EXTRA_CHECK
630 if(ltt_time_compare(evtime, time_window.start_time) == -1
631 || ltt_time_compare(evtime, time_window.end_time) == 1)
632 return;
633 #endif //EXTRA_CHECK
634 Drawing_t *drawing = control_flow_data->drawing;
635 guint width = drawing->width;
636 guint x;
637
638 convert_time_to_pixels(
639 time_window,
640 evtime,
641 width,
642 &x);
643
644
645 /* Jump over draw if we are at the same x position */
646 if(x == hashed_process_data->x.middle &&
647 hashed_process_data->x.middle_used)
648 {
649 if(hashed_process_data->x.middle_marked == FALSE) {
650 /* Draw collision indicator */
651 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
652 gdk_draw_point(hashed_process_data->pixmap,
653 drawing->gc,
654 x,
655 COLLISION_POSITION(hashed_process_data->height));
656 hashed_process_data->x.middle_marked = TRUE;
657 }
658 /* jump */
659 } else {
660 DrawContext draw_context;
661
662 /* Now create the drawing context that will be used to draw
663 * items related to the last state. */
664 draw_context.drawable = hashed_process_data->pixmap;
665 draw_context.gc = drawing->gc;
666 draw_context.pango_layout = drawing->pango_layout;
667 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
668 draw_context.drawinfo.end.x = x;
669
670 draw_context.drawinfo.y.over = 1;
671 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
672 draw_context.drawinfo.y.under = hashed_process_data->height;
673
674 draw_context.drawinfo.start.offset.over = 0;
675 draw_context.drawinfo.start.offset.middle = 0;
676 draw_context.drawinfo.start.offset.under = 0;
677 draw_context.drawinfo.end.offset.over = 0;
678 draw_context.drawinfo.end.offset.middle = 0;
679 draw_context.drawinfo.end.offset.under = 0;
680
681 {
682 /* Draw the line */
683 PropertiesLine prop_line = prepare_s_e_line(process);
684 draw_line((void*)&prop_line, (void*)&draw_context);
685 }
686
687
688 /* become the last x position */
689 hashed_process_data->x.middle = x;
690 hashed_process_data->x.middle_used = TRUE;
691 hashed_process_data->x.middle_marked = FALSE;
692
693 /* Calculate the next good time */
694 convert_pixels_to_time(width, x+1, time_window,
695 &hashed_process_data->next_good_time);
696 }
697 }
698 } else
699 g_warning("Cannot find pin_in in schedchange %u", pid_in);
700 }
701 tfc->target_pid = target_pid_saved;
702 return 0;
703
704
705
706
707 /* Text dump */
708 #ifdef DONTSHOW
709 GString *string = g_string_new("");;
710 gboolean field_names = TRUE, state = TRUE;
711
712 lttv_event_to_string(e, tfc->tf, string, TRUE, field_names, tfs);
713 g_string_append_printf(string,"\n");
714
715 if(state) {
716 g_string_append_printf(string, " %s",
717 g_quark_to_string(tfs->process->state->s));
718 }
719
720 g_info("%s",string->str);
721
722 g_string_free(string, TRUE);
723
724 /* End of text dump */
725 #endif //DONTSHOW
726
727 }
728
729 /* after_schedchange_hook
730 *
731 * The draw after hook is called by the reading API to have a
732 * particular event drawn on the screen.
733 * @param hook_data ControlFlowData structure of the viewer.
734 * @param call_data Event context.
735 *
736 * This function adds items to be drawn in a queue for each process.
737 *
738 */
739 int after_schedchange_hook(void *hook_data, void *call_data)
740 {
741 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
742 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
743 ControlFlowData *control_flow_data = events_request->viewer_data;
744
745 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
746
747 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
748
749 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
750
751 LttEvent *e;
752 e = ltt_tracefile_get_event(tfc->tf);
753
754 LttvFilter *filter = control_flow_data->filter;
755 if(filter != NULL && filter->head != NULL)
756 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
757 tfc->t_context->t,tfc,NULL,NULL))
758 return FALSE;
759
760 LttTime evtime = ltt_event_time(e);
761
762 /* Add process to process list (if not present) */
763 LttvProcessState *process_in;
764 LttTime birth;
765 guint pl_height = 0;
766 HashedProcessData *hashed_process_data_in = NULL;
767
768 ProcessList *process_list = control_flow_data->process_list;
769
770 guint pid_in;
771 {
772 guint pid_out;
773 pid_out = ltt_event_get_long_unsigned(e, thf->f1);
774 pid_in = ltt_event_get_long_unsigned(e, thf->f2);
775 }
776
777
778 /* Find process pid_in in the list... */
779 //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
780 //process_in = tfs->process;
781 guint cpu = tfs->cpu;
782 guint trace_num = ts->parent.index;
783 process_in = ts->running_process[cpu];
784 /* It should exist, because we are after the state update. */
785 #ifdef EXTRA_CHECK
786 g_assert(process_in != NULL);
787 #endif //EXTRA_CHECK
788 birth = process_in->creation_time;
789
790 hashed_process_data_in = processlist_get_process_data(process_list,
791 pid_in,
792 process_in->cpu,
793 &birth,
794 trace_num);
795 if(hashed_process_data_in == NULL)
796 {
797 g_assert(pid_in == 0 || pid_in != process_in->ppid);
798 ProcessInfo *process_info;
799 Drawing_t *drawing = control_flow_data->drawing;
800 /* Process not present */
801 processlist_add(process_list,
802 drawing,
803 pid_in,
804 process_in->tgid,
805 process_in->cpu,
806 process_in->ppid,
807 &birth,
808 trace_num,
809 process_in->name,
810 process_in->brand,
811 &pl_height,
812 &process_info,
813 &hashed_process_data_in);
814 gtk_widget_set_size_request(drawing->drawing_area,
815 -1,
816 pl_height);
817 gtk_widget_queue_draw(drawing->drawing_area);
818 }
819 /* Set the current process */
820 process_list->current_hash_data[trace_num][process_in->cpu] =
821 hashed_process_data_in;
822
823 if(ltt_time_compare(hashed_process_data_in->next_good_time,
824 evtime) <= 0)
825 {
826 TimeWindow time_window =
827 lttvwindow_get_time_window(control_flow_data->tab);
828
829 #ifdef EXTRA_CHECK
830 if(ltt_time_compare(evtime, time_window.start_time) == -1
831 || ltt_time_compare(evtime, time_window.end_time) == 1)
832 return;
833 #endif //EXTRA_CHECK
834 Drawing_t *drawing = control_flow_data->drawing;
835 guint width = drawing->width;
836 guint new_x;
837
838 convert_time_to_pixels(
839 time_window,
840 evtime,
841 width,
842 &new_x);
843
844 if(hashed_process_data_in->x.middle != new_x) {
845 hashed_process_data_in->x.middle = new_x;
846 hashed_process_data_in->x.middle_used = FALSE;
847 hashed_process_data_in->x.middle_marked = FALSE;
848 }
849 }
850 return 0;
851 }
852
853
854
855
856 /* before_execmode_hook
857 *
858 * This function basically draw lines and icons. Two types of lines are drawn :
859 * one small (3 pixels?) representing the state of the process and the second
860 * type is thicker (10 pixels?) representing on which CPU a process is running
861 * (and this only in running state).
862 *
863 * Extremums of the lines :
864 * x_min : time of the last event context for this process kept in memory.
865 * x_max : time of the current event.
866 * y : middle of the process in the process list. The process is found in the
867 * list, therefore is it's position in pixels.
868 *
869 * The choice of lines'color is defined by the context of the last event for this
870 * process.
871 */
872
873
874 int before_execmode_hook(void *hook_data, void *call_data)
875 {
876 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
877 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
878 ControlFlowData *control_flow_data = events_request->viewer_data;
879
880 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
881
882 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
883
884 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
885
886 LttEvent *e;
887 e = ltt_tracefile_get_event(tfc->tf);
888
889 LttvFilter *filter = control_flow_data->filter;
890 if(filter != NULL && filter->head != NULL)
891 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
892 tfc->t_context->t,tfc,NULL,NULL))
893 return FALSE;
894
895 LttTime evtime = ltt_event_time(e);
896
897 /* we are in a execmode, before the state update. We must draw the
898 * items corresponding to the state before it changes : now is the right
899 * time to do it.
900 */
901 /* For the pid */
902 //LttvProcessState *process = tfs->process;
903 guint cpu = tfs->cpu;
904 guint trace_num = ts->parent.index;
905 LttvProcessState *process = ts->running_process[cpu];
906 g_assert(process != NULL);
907
908 guint pid = process->pid;
909
910 /* Well, the process_out existed : we must get it in the process hash
911 * or add it, and draw its items.
912 */
913 /* Add process to process list (if not present) */
914 guint pl_height = 0;
915 HashedProcessData *hashed_process_data = NULL;
916 ProcessList *process_list = control_flow_data->process_list;
917 LttTime birth = process->creation_time;
918
919 if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
920 hashed_process_data = process_list->current_hash_data[trace_num][cpu];
921 } else {
922 hashed_process_data = processlist_get_process_data(process_list,
923 pid,
924 process->cpu,
925 &birth,
926 trace_num);
927 if(unlikely(hashed_process_data == NULL))
928 {
929 g_assert(pid == 0 || pid != process->ppid);
930 ProcessInfo *process_info;
931 /* Process not present */
932 Drawing_t *drawing = control_flow_data->drawing;
933 processlist_add(process_list,
934 drawing,
935 pid,
936 process->tgid,
937 process->cpu,
938 process->ppid,
939 &birth,
940 trace_num,
941 process->name,
942 process->brand,
943 &pl_height,
944 &process_info,
945 &hashed_process_data);
946 gtk_widget_set_size_request(drawing->drawing_area,
947 -1,
948 pl_height);
949 gtk_widget_queue_draw(drawing->drawing_area);
950 }
951 /* Set the current process */
952 process_list->current_hash_data[trace_num][process->cpu] =
953 hashed_process_data;
954 }
955
956 /* Now, the process is in the state hash and our own process hash.
957 * We definitely can draw the items related to the ending state.
958 */
959
960 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
961 evtime) > 0))
962 {
963 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
964 TimeWindow time_window =
965 lttvwindow_get_time_window(control_flow_data->tab);
966
967 #ifdef EXTRA_CHECK
968 if(ltt_time_compare(evtime, time_window.start_time) == -1
969 || ltt_time_compare(evtime, time_window.end_time) == 1)
970 return;
971 #endif //EXTRA_CHECK
972 Drawing_t *drawing = control_flow_data->drawing;
973 guint width = drawing->width;
974 guint x;
975 convert_time_to_pixels(
976 time_window,
977 evtime,
978 width,
979 &x);
980
981 /* Draw collision indicator */
982 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
983 gdk_draw_point(hashed_process_data->pixmap,
984 drawing->gc,
985 x,
986 COLLISION_POSITION(hashed_process_data->height));
987 hashed_process_data->x.middle_marked = TRUE;
988 }
989 } else {
990 TimeWindow time_window =
991 lttvwindow_get_time_window(control_flow_data->tab);
992
993 #ifdef EXTRA_CHECK
994 if(ltt_time_compare(evtime, time_window.start_time) == -1
995 || ltt_time_compare(evtime, time_window.end_time) == 1)
996 return;
997 #endif //EXTRA_CHECK
998 Drawing_t *drawing = control_flow_data->drawing;
999 guint width = drawing->width;
1000 guint x;
1001
1002 convert_time_to_pixels(
1003 time_window,
1004 evtime,
1005 width,
1006 &x);
1007
1008
1009 /* Jump over draw if we are at the same x position */
1010 if(unlikely(x == hashed_process_data->x.middle &&
1011 hashed_process_data->x.middle_used))
1012 {
1013 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1014 /* Draw collision indicator */
1015 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1016 gdk_draw_point(hashed_process_data->pixmap,
1017 drawing->gc,
1018 x,
1019 COLLISION_POSITION(hashed_process_data->height));
1020 hashed_process_data->x.middle_marked = TRUE;
1021 }
1022 /* jump */
1023 } else {
1024
1025 DrawContext draw_context;
1026 /* Now create the drawing context that will be used to draw
1027 * items related to the last state. */
1028 draw_context.drawable = hashed_process_data->pixmap;
1029 draw_context.gc = drawing->gc;
1030 draw_context.pango_layout = drawing->pango_layout;
1031 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1032 draw_context.drawinfo.end.x = x;
1033
1034 draw_context.drawinfo.y.over = 1;
1035 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1036 draw_context.drawinfo.y.under = hashed_process_data->height;
1037
1038 draw_context.drawinfo.start.offset.over = 0;
1039 draw_context.drawinfo.start.offset.middle = 0;
1040 draw_context.drawinfo.start.offset.under = 0;
1041 draw_context.drawinfo.end.offset.over = 0;
1042 draw_context.drawinfo.end.offset.middle = 0;
1043 draw_context.drawinfo.end.offset.under = 0;
1044
1045 {
1046 /* Draw the line */
1047 PropertiesLine prop_line = prepare_s_e_line(process);
1048 draw_line((void*)&prop_line, (void*)&draw_context);
1049
1050 }
1051 /* become the last x position */
1052 hashed_process_data->x.middle = x;
1053 hashed_process_data->x.middle_used = TRUE;
1054 hashed_process_data->x.middle_marked = FALSE;
1055
1056 /* Calculate the next good time */
1057 convert_pixels_to_time(width, x+1, time_window,
1058 &hashed_process_data->next_good_time);
1059 }
1060 }
1061
1062 return 0;
1063 }
1064
1065 /* before_process_exit_hook
1066 *
1067 * Draw lines for process event.
1068 *
1069 * @param hook_data ControlFlowData structure of the viewer.
1070 * @param call_data Event context.
1071 *
1072 * This function adds items to be drawn in a queue for each process.
1073 *
1074 */
1075
1076
1077 int before_process_exit_hook(void *hook_data, void *call_data)
1078 {
1079 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1080 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1081
1082 ControlFlowData *control_flow_data = events_request->viewer_data;
1083
1084 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1085
1086 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1087
1088 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1089
1090 LttEvent *e;
1091 e = ltt_tracefile_get_event(tfc->tf);
1092
1093 LttvFilter *filter = control_flow_data->filter;
1094 if(filter != NULL && filter->head != NULL)
1095 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1096 tfc->t_context->t,tfc,NULL,NULL))
1097 return FALSE;
1098
1099 LttTime evtime = ltt_event_time(e);
1100
1101 /* Add process to process list (if not present) */
1102 //LttvProcessState *process = tfs->process;
1103 guint cpu = tfs->cpu;
1104 guint trace_num = ts->parent.index;
1105 LttvProcessState *process = ts->running_process[cpu];
1106 guint pid = process->pid;
1107 LttTime birth;
1108 guint pl_height = 0;
1109 HashedProcessData *hashed_process_data = NULL;
1110
1111 ProcessList *process_list = control_flow_data->process_list;
1112
1113 g_assert(process != NULL);
1114
1115 birth = process->creation_time;
1116
1117 if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1118 hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1119 } else {
1120 hashed_process_data = processlist_get_process_data(process_list,
1121 pid,
1122 process->cpu,
1123 &birth,
1124 trace_num);
1125 if(unlikely(hashed_process_data == NULL))
1126 {
1127 g_assert(pid == 0 || pid != process->ppid);
1128 /* Process not present */
1129 Drawing_t *drawing = control_flow_data->drawing;
1130 ProcessInfo *process_info;
1131 processlist_add(process_list,
1132 drawing,
1133 pid,
1134 process->tgid,
1135 process->cpu,
1136 process->ppid,
1137 &birth,
1138 trace_num,
1139 process->name,
1140 process->brand,
1141 &pl_height,
1142 &process_info,
1143 &hashed_process_data);
1144 gtk_widget_set_size_request(drawing->drawing_area,
1145 -1,
1146 pl_height);
1147 gtk_widget_queue_draw(drawing->drawing_area);
1148 }
1149 }
1150
1151 /* Now, the process is in the state hash and our own process hash.
1152 * We definitely can draw the items related to the ending state.
1153 */
1154
1155 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1156 evtime) > 0))
1157 {
1158 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1159 TimeWindow time_window =
1160 lttvwindow_get_time_window(control_flow_data->tab);
1161
1162 #ifdef EXTRA_CHECK
1163 if(ltt_time_compare(evtime, time_window.start_time) == -1
1164 || ltt_time_compare(evtime, time_window.end_time) == 1)
1165 return;
1166 #endif //EXTRA_CHECK
1167 Drawing_t *drawing = control_flow_data->drawing;
1168 guint width = drawing->width;
1169 guint x;
1170 convert_time_to_pixels(
1171 time_window,
1172 evtime,
1173 width,
1174 &x);
1175
1176 /* Draw collision indicator */
1177 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1178 gdk_draw_point(hashed_process_data->pixmap,
1179 drawing->gc,
1180 x,
1181 COLLISION_POSITION(hashed_process_data->height));
1182 hashed_process_data->x.middle_marked = TRUE;
1183 }
1184 } else {
1185 TimeWindow time_window =
1186 lttvwindow_get_time_window(control_flow_data->tab);
1187
1188 #ifdef EXTRA_CHECK
1189 if(ltt_time_compare(evtime, time_window.start_time) == -1
1190 || ltt_time_compare(evtime, time_window.end_time) == 1)
1191 return;
1192 #endif //EXTRA_CHECK
1193 Drawing_t *drawing = control_flow_data->drawing;
1194 guint width = drawing->width;
1195 guint x;
1196
1197 convert_time_to_pixels(
1198 time_window,
1199 evtime,
1200 width,
1201 &x);
1202
1203
1204 /* Jump over draw if we are at the same x position */
1205 if(unlikely(x == hashed_process_data->x.middle &&
1206 hashed_process_data->x.middle_used))
1207 {
1208 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1209 /* Draw collision indicator */
1210 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1211 gdk_draw_point(hashed_process_data->pixmap,
1212 drawing->gc,
1213 x,
1214 COLLISION_POSITION(hashed_process_data->height));
1215 hashed_process_data->x.middle_marked = TRUE;
1216 }
1217 /* jump */
1218 } else {
1219 DrawContext draw_context;
1220
1221 /* Now create the drawing context that will be used to draw
1222 * items related to the last state. */
1223 draw_context.drawable = hashed_process_data->pixmap;
1224 draw_context.gc = drawing->gc;
1225 draw_context.pango_layout = drawing->pango_layout;
1226 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1227 draw_context.drawinfo.end.x = x;
1228
1229 draw_context.drawinfo.y.over = 1;
1230 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1231 draw_context.drawinfo.y.under = hashed_process_data->height;
1232
1233 draw_context.drawinfo.start.offset.over = 0;
1234 draw_context.drawinfo.start.offset.middle = 0;
1235 draw_context.drawinfo.start.offset.under = 0;
1236 draw_context.drawinfo.end.offset.over = 0;
1237 draw_context.drawinfo.end.offset.middle = 0;
1238 draw_context.drawinfo.end.offset.under = 0;
1239
1240 {
1241 /* Draw the line */
1242 PropertiesLine prop_line = prepare_s_e_line(process);
1243 draw_line((void*)&prop_line, (void*)&draw_context);
1244
1245 }
1246 /* become the last x position */
1247 hashed_process_data->x.middle = x;
1248 hashed_process_data->x.middle_used = TRUE;
1249 hashed_process_data->x.middle_marked = FALSE;
1250
1251 /* Calculate the next good time */
1252 convert_pixels_to_time(width, x+1, time_window,
1253 &hashed_process_data->next_good_time);
1254 }
1255 }
1256
1257 return 0;
1258
1259 }
1260
1261
1262
1263 /* before_process_release_hook
1264 *
1265 * Draw lines for process event.
1266 *
1267 * @param hook_data ControlFlowData structure of the viewer.
1268 * @param call_data Event context.
1269 *
1270 * This function adds items to be drawn in a queue for each process.
1271 *
1272 */
1273
1274
1275 int before_process_release_hook(void *hook_data, void *call_data)
1276 {
1277 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1278 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1279
1280 ControlFlowData *control_flow_data = events_request->viewer_data;
1281
1282 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1283
1284 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1285
1286 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1287
1288 LttEvent *e;
1289 e = ltt_tracefile_get_event(tfc->tf);
1290
1291 LttvFilter *filter = control_flow_data->filter;
1292 if(filter != NULL && filter->head != NULL)
1293 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1294 tfc->t_context->t,tfc,NULL,NULL))
1295 return FALSE;
1296
1297 LttTime evtime = ltt_event_time(e);
1298
1299 guint trace_num = ts->parent.index;
1300
1301 guint pid;
1302 {
1303 pid = ltt_event_get_long_unsigned(e, thf->f1);
1304 }
1305
1306 /* Add process to process list (if not present) */
1307 /* Don't care about the process if it's not in the state hash already :
1308 * that means a process that has never done anything in the trace and
1309 * unknown suddently gets destroyed : no state meaningful to show. */
1310 LttvProcessState *process = lttv_state_find_process(ts, ANY_CPU, pid);
1311
1312 if(process != NULL) {
1313 LttTime birth;
1314 guint pl_height = 0;
1315 HashedProcessData *hashed_process_data = NULL;
1316
1317 ProcessList *process_list = control_flow_data->process_list;
1318
1319 birth = process->creation_time;
1320
1321 /* Cannot use current process : this event happens on another process,
1322 * action done by the parent. */
1323 hashed_process_data = processlist_get_process_data(process_list,
1324 pid,
1325 process->cpu,
1326 &birth,
1327 trace_num);
1328 if(unlikely(hashed_process_data == NULL))
1329 {
1330 g_assert(pid == 0 || pid != process->ppid);
1331 /* Process not present */
1332 Drawing_t *drawing = control_flow_data->drawing;
1333 ProcessInfo *process_info;
1334 processlist_add(process_list,
1335 drawing,
1336 pid,
1337 process->tgid,
1338 process->cpu,
1339 process->ppid,
1340 &birth,
1341 trace_num,
1342 process->name,
1343 process->brand,
1344 &pl_height,
1345 &process_info,
1346 &hashed_process_data);
1347 gtk_widget_set_size_request(drawing->drawing_area,
1348 -1,
1349 pl_height);
1350 gtk_widget_queue_draw(drawing->drawing_area);
1351 }
1352
1353 /* Now, the process is in the state hash and our own process hash.
1354 * We definitely can draw the items related to the ending state.
1355 */
1356
1357 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1358 evtime) > 0))
1359 {
1360 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1361 TimeWindow time_window =
1362 lttvwindow_get_time_window(control_flow_data->tab);
1363
1364 #ifdef EXTRA_CHECK
1365 if(ltt_time_compare(evtime, time_window.start_time) == -1
1366 || ltt_time_compare(evtime, time_window.end_time) == 1)
1367 return;
1368 #endif //EXTRA_CHECK
1369 Drawing_t *drawing = control_flow_data->drawing;
1370 guint width = drawing->width;
1371 guint x;
1372 convert_time_to_pixels(
1373 time_window,
1374 evtime,
1375 width,
1376 &x);
1377
1378 /* Draw collision indicator */
1379 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1380 gdk_draw_point(hashed_process_data->pixmap,
1381 drawing->gc,
1382 x,
1383 COLLISION_POSITION(hashed_process_data->height));
1384 hashed_process_data->x.middle_marked = TRUE;
1385 }
1386 } else {
1387 TimeWindow time_window =
1388 lttvwindow_get_time_window(control_flow_data->tab);
1389
1390 #ifdef EXTRA_CHECK
1391 if(ltt_time_compare(evtime, time_window.start_time) == -1
1392 || ltt_time_compare(evtime, time_window.end_time) == 1)
1393 return;
1394 #endif //EXTRA_CHECK
1395 Drawing_t *drawing = control_flow_data->drawing;
1396 guint width = drawing->width;
1397 guint x;
1398
1399 convert_time_to_pixels(
1400 time_window,
1401 evtime,
1402 width,
1403 &x);
1404
1405
1406 /* Jump over draw if we are at the same x position */
1407 if(unlikely(x == hashed_process_data->x.middle &&
1408 hashed_process_data->x.middle_used))
1409 {
1410 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1411 /* Draw collision indicator */
1412 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1413 gdk_draw_point(hashed_process_data->pixmap,
1414 drawing->gc,
1415 x,
1416 COLLISION_POSITION(hashed_process_data->height));
1417 hashed_process_data->x.middle_marked = TRUE;
1418 }
1419 /* jump */
1420 } else {
1421 DrawContext draw_context;
1422
1423 /* Now create the drawing context that will be used to draw
1424 * items related to the last state. */
1425 draw_context.drawable = hashed_process_data->pixmap;
1426 draw_context.gc = drawing->gc;
1427 draw_context.pango_layout = drawing->pango_layout;
1428 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1429 draw_context.drawinfo.end.x = x;
1430
1431 draw_context.drawinfo.y.over = 1;
1432 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1433 draw_context.drawinfo.y.under = hashed_process_data->height;
1434
1435 draw_context.drawinfo.start.offset.over = 0;
1436 draw_context.drawinfo.start.offset.middle = 0;
1437 draw_context.drawinfo.start.offset.under = 0;
1438 draw_context.drawinfo.end.offset.over = 0;
1439 draw_context.drawinfo.end.offset.middle = 0;
1440 draw_context.drawinfo.end.offset.under = 0;
1441
1442 {
1443 /* Draw the line */
1444 PropertiesLine prop_line = prepare_s_e_line(process);
1445 draw_line((void*)&prop_line, (void*)&draw_context);
1446
1447 }
1448 /* become the last x position */
1449 hashed_process_data->x.middle = x;
1450 hashed_process_data->x.middle_used = TRUE;
1451 hashed_process_data->x.middle_marked = FALSE;
1452
1453 /* Calculate the next good time */
1454 convert_pixels_to_time(width, x+1, time_window,
1455 &hashed_process_data->next_good_time);
1456 }
1457 }
1458 }
1459
1460 return 0;
1461 }
1462
1463
1464
1465
1466
1467 /* after_process_fork_hook
1468 *
1469 * Create the processlist entry for the child process. Put the last
1470 * position in x at the current time value.
1471 *
1472 * @param hook_data ControlFlowData structure of the viewer.
1473 * @param call_data Event context.
1474 *
1475 * This function adds items to be drawn in a queue for each process.
1476 *
1477 */
1478 int after_process_fork_hook(void *hook_data, void *call_data)
1479 {
1480 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1481 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1482 ControlFlowData *control_flow_data = events_request->viewer_data;
1483
1484 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1485
1486 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1487
1488 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1489
1490 LttEvent *e;
1491 e = ltt_tracefile_get_event(tfc->tf);
1492
1493 LttvFilter *filter = control_flow_data->filter;
1494 if(filter != NULL && filter->head != NULL)
1495 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1496 tfc->t_context->t,tfc,NULL,NULL))
1497 return FALSE;
1498
1499 LttTime evtime = ltt_event_time(e);
1500
1501 guint child_pid;
1502 {
1503 child_pid = ltt_event_get_long_unsigned(e, thf->f2);
1504 }
1505
1506 /* Add process to process list (if not present) */
1507 LttvProcessState *process_child;
1508 LttTime birth;
1509 guint pl_height = 0;
1510 HashedProcessData *hashed_process_data_child = NULL;
1511
1512 ProcessList *process_list = control_flow_data->process_list;
1513
1514 /* Find child in the list... */
1515 process_child = lttv_state_find_process(ts, ANY_CPU, child_pid);
1516 /* It should exist, because we are after the state update. */
1517 g_assert(process_child != NULL);
1518
1519 birth = process_child->creation_time;
1520 guint trace_num = ts->parent.index;
1521
1522 /* Cannot use current process, because this action is done by the parent
1523 * on its child. */
1524 hashed_process_data_child = processlist_get_process_data(process_list,
1525 child_pid,
1526 process_child->cpu,
1527 &birth,
1528 trace_num);
1529 if(likely(hashed_process_data_child == NULL))
1530 {
1531 g_assert(child_pid == 0 || child_pid != process_child->ppid);
1532 /* Process not present */
1533 Drawing_t *drawing = control_flow_data->drawing;
1534 ProcessInfo *process_info;
1535 processlist_add(process_list,
1536 drawing,
1537 child_pid,
1538 process_child->tgid,
1539 process_child->cpu,
1540 process_child->ppid,
1541 &birth,
1542 trace_num,
1543 process_child->name,
1544 process_child->brand,
1545 &pl_height,
1546 &process_info,
1547 &hashed_process_data_child);
1548 gtk_widget_set_size_request(drawing->drawing_area,
1549 -1,
1550 pl_height);
1551 gtk_widget_queue_draw(drawing->drawing_area);
1552 } else {
1553 processlist_set_ppid(process_list, process_child->ppid,
1554 hashed_process_data_child);
1555 processlist_set_tgid(process_list, process_child->tgid,
1556 hashed_process_data_child);
1557 }
1558
1559
1560 if(likely(ltt_time_compare(hashed_process_data_child->next_good_time,
1561 evtime) <= 0))
1562 {
1563 TimeWindow time_window =
1564 lttvwindow_get_time_window(control_flow_data->tab);
1565
1566 #ifdef EXTRA_CHECK
1567 if(ltt_time_compare(evtime, time_window.start_time) == -1
1568 || ltt_time_compare(evtime, time_window.end_time) == 1)
1569 return;
1570 #endif //EXTRA_CHECK
1571 Drawing_t *drawing = control_flow_data->drawing;
1572 guint width = drawing->width;
1573 guint new_x;
1574 convert_time_to_pixels(
1575 time_window,
1576 evtime,
1577 width,
1578 &new_x);
1579
1580 if(likely(hashed_process_data_child->x.over != new_x)) {
1581 hashed_process_data_child->x.over = new_x;
1582 hashed_process_data_child->x.over_used = FALSE;
1583 hashed_process_data_child->x.over_marked = FALSE;
1584 }
1585 if(likely(hashed_process_data_child->x.middle != new_x)) {
1586 hashed_process_data_child->x.middle = new_x;
1587 hashed_process_data_child->x.middle_used = FALSE;
1588 hashed_process_data_child->x.middle_marked = FALSE;
1589 }
1590 if(likely(hashed_process_data_child->x.under != new_x)) {
1591 hashed_process_data_child->x.under = new_x;
1592 hashed_process_data_child->x.under_used = FALSE;
1593 hashed_process_data_child->x.under_marked = FALSE;
1594 }
1595 }
1596 return 0;
1597 }
1598
1599
1600
1601 /* after_process_exit_hook
1602 *
1603 * Create the processlist entry for the child process. Put the last
1604 * position in x at the current time value.
1605 *
1606 * @param hook_data ControlFlowData structure of the viewer.
1607 * @param call_data Event context.
1608 *
1609 * This function adds items to be drawn in a queue for each process.
1610 *
1611 */
1612 int after_process_exit_hook(void *hook_data, void *call_data)
1613 {
1614 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1615 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1616 ControlFlowData *control_flow_data = events_request->viewer_data;
1617
1618 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1619
1620 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1621
1622 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1623
1624 LttEvent *e;
1625 e = ltt_tracefile_get_event(tfc->tf);
1626
1627 LttvFilter *filter = control_flow_data->filter;
1628 if(filter != NULL && filter->head != NULL)
1629 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1630 tfc->t_context->t,tfc,NULL,NULL))
1631 return FALSE;
1632
1633 LttTime evtime = ltt_event_time(e);
1634
1635 /* Add process to process list (if not present) */
1636 //LttvProcessState *process = tfs->process;
1637 guint cpu = tfs->cpu;
1638 guint trace_num = ts->parent.index;
1639 LttvProcessState *process = ts->running_process[cpu];
1640
1641 /* It should exist, because we are after the state update. */
1642 g_assert(process != NULL);
1643
1644 guint pid = process->pid;
1645 LttTime birth;
1646 guint pl_height = 0;
1647 HashedProcessData *hashed_process_data = NULL;
1648
1649 ProcessList *process_list = control_flow_data->process_list;
1650
1651 birth = process->creation_time;
1652
1653 if(likely(process_list->current_hash_data[trace_num][cpu] != NULL) ){
1654 hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1655 } else {
1656 hashed_process_data = processlist_get_process_data(process_list,
1657 pid,
1658 process->cpu,
1659 &birth,
1660 trace_num);
1661 if(unlikely(hashed_process_data == NULL))
1662 {
1663 g_assert(pid == 0 || pid != process->ppid);
1664 /* Process not present */
1665 Drawing_t *drawing = control_flow_data->drawing;
1666 ProcessInfo *process_info;
1667 processlist_add(process_list,
1668 drawing,
1669 pid,
1670 process->tgid,
1671 process->cpu,
1672 process->ppid,
1673 &birth,
1674 trace_num,
1675 process->name,
1676 process->brand,
1677 &pl_height,
1678 &process_info,
1679 &hashed_process_data);
1680 gtk_widget_set_size_request(drawing->drawing_area,
1681 -1,
1682 pl_height);
1683 gtk_widget_queue_draw(drawing->drawing_area);
1684 }
1685
1686 /* Set the current process */
1687 process_list->current_hash_data[trace_num][process->cpu] =
1688 hashed_process_data;
1689 }
1690
1691 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
1692 evtime) <= 0))
1693 {
1694 TimeWindow time_window =
1695 lttvwindow_get_time_window(control_flow_data->tab);
1696
1697 #ifdef EXTRA_CHECK
1698 if(ltt_time_compare(evtime, time_window.start_time) == -1
1699 || ltt_time_compare(evtime, time_window.end_time) == 1)
1700 return;
1701 #endif //EXTRA_CHECK
1702 Drawing_t *drawing = control_flow_data->drawing;
1703 guint width = drawing->width;
1704 guint new_x;
1705 convert_time_to_pixels(
1706 time_window,
1707 evtime,
1708 width,
1709 &new_x);
1710 if(unlikely(hashed_process_data->x.middle != new_x)) {
1711 hashed_process_data->x.middle = new_x;
1712 hashed_process_data->x.middle_used = FALSE;
1713 hashed_process_data->x.middle_marked = FALSE;
1714 }
1715 }
1716
1717 return 0;
1718 }
1719
1720
1721 /* Get the filename of the process to print */
1722 int after_fs_exec_hook(void *hook_data, void *call_data)
1723 {
1724 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1725 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1726 ControlFlowData *control_flow_data = events_request->viewer_data;
1727
1728 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1729
1730 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1731
1732 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1733
1734 LttEvent *e;
1735 e = ltt_tracefile_get_event(tfc->tf);
1736
1737 LttvFilter *filter = control_flow_data->filter;
1738 if(filter != NULL && filter->head != NULL)
1739 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1740 tfc->t_context->t,tfc,NULL,NULL))
1741 return FALSE;
1742
1743 guint cpu = tfs->cpu;
1744 guint trace_num = ts->parent.index;
1745 LttvProcessState *process = ts->running_process[cpu];
1746 g_assert(process != NULL);
1747
1748 guint pid = process->pid;
1749
1750 /* Well, the process_out existed : we must get it in the process hash
1751 * or add it, and draw its items.
1752 */
1753 /* Add process to process list (if not present) */
1754 guint pl_height = 0;
1755 HashedProcessData *hashed_process_data = NULL;
1756 ProcessList *process_list = control_flow_data->process_list;
1757 LttTime birth = process->creation_time;
1758
1759 if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1760 hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1761 } else {
1762 hashed_process_data = processlist_get_process_data(process_list,
1763 pid,
1764 process->cpu,
1765 &birth,
1766 trace_num);
1767 if(unlikely(hashed_process_data == NULL))
1768 {
1769 g_assert(pid == 0 || pid != process->ppid);
1770 ProcessInfo *process_info;
1771 /* Process not present */
1772 Drawing_t *drawing = control_flow_data->drawing;
1773 processlist_add(process_list,
1774 drawing,
1775 pid,
1776 process->tgid,
1777 process->cpu,
1778 process->ppid,
1779 &birth,
1780 trace_num,
1781 process->name,
1782 process->brand,
1783 &pl_height,
1784 &process_info,
1785 &hashed_process_data);
1786 gtk_widget_set_size_request(drawing->drawing_area,
1787 -1,
1788 pl_height);
1789 gtk_widget_queue_draw(drawing->drawing_area);
1790 }
1791 /* Set the current process */
1792 process_list->current_hash_data[trace_num][process->cpu] =
1793 hashed_process_data;
1794 }
1795
1796 processlist_set_name(process_list, process->name, hashed_process_data);
1797
1798 return 0;
1799
1800 }
1801
1802 /* Get the filename of the process to print */
1803 int after_user_generic_thread_brand_hook(void *hook_data, void *call_data)
1804 {
1805 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1806 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1807 ControlFlowData *control_flow_data = events_request->viewer_data;
1808
1809 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1810
1811 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1812
1813 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1814
1815 LttEvent *e;
1816 e = ltt_tracefile_get_event(tfc->tf);
1817
1818 LttvFilter *filter = control_flow_data->filter;
1819 if(filter != NULL && filter->head != NULL)
1820 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1821 tfc->t_context->t,tfc,NULL,NULL))
1822 return FALSE;
1823
1824 guint cpu = tfs->cpu;
1825 guint trace_num = ts->parent.index;
1826 LttvProcessState *process = ts->running_process[cpu];
1827 g_assert(process != NULL);
1828
1829 guint pid = process->pid;
1830
1831 /* Well, the process_out existed : we must get it in the process hash
1832 * or add it, and draw its items.
1833 */
1834 /* Add process to process list (if not present) */
1835 guint pl_height = 0;
1836 HashedProcessData *hashed_process_data = NULL;
1837 ProcessList *process_list = control_flow_data->process_list;
1838 LttTime birth = process->creation_time;
1839
1840 if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1841 hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1842 } else {
1843 hashed_process_data = processlist_get_process_data(process_list,
1844 pid,
1845 process->cpu,
1846 &birth,
1847 trace_num);
1848 if(unlikely(hashed_process_data == NULL))
1849 {
1850 g_assert(pid == 0 || pid != process->ppid);
1851 ProcessInfo *process_info;
1852 /* Process not present */
1853 Drawing_t *drawing = control_flow_data->drawing;
1854 processlist_add(process_list,
1855 drawing,
1856 pid,
1857 process->tgid,
1858 process->cpu,
1859 process->ppid,
1860 &birth,
1861 trace_num,
1862 process->name,
1863 process->brand,
1864 &pl_height,
1865 &process_info,
1866 &hashed_process_data);
1867 gtk_widget_set_size_request(drawing->drawing_area,
1868 -1,
1869 pl_height);
1870 gtk_widget_queue_draw(drawing->drawing_area);
1871 }
1872 /* Set the current process */
1873 process_list->current_hash_data[trace_num][process->cpu] =
1874 hashed_process_data;
1875 }
1876
1877 processlist_set_brand(process_list, process->brand, hashed_process_data);
1878
1879 return 0;
1880
1881 }
1882
1883
1884 /* after_event_enum_process_hook
1885 *
1886 * Create the processlist entry for the child process. Put the last
1887 * position in x at the current time value.
1888 *
1889 * @param hook_data ControlFlowData structure of the viewer.
1890 * @param call_data Event context.
1891 *
1892 * This function adds items to be drawn in a queue for each process.
1893 *
1894 */
1895 int after_event_enum_process_hook(void *hook_data, void *call_data)
1896 {
1897 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1898 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
1899 ControlFlowData *control_flow_data = events_request->viewer_data;
1900
1901 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1902
1903 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1904
1905 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1906
1907 LttEvent *e;
1908 e = ltt_tracefile_get_event(tfc->tf);
1909
1910 LttvFilter *filter = control_flow_data->filter;
1911 if(filter != NULL && filter->head != NULL)
1912 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1913 tfc->t_context->t,tfc,NULL,NULL))
1914 return FALSE;
1915
1916 LttTime evtime = ltt_event_time(e);
1917
1918 /* Add process to process list (if not present) */
1919 LttvProcessState *process_in;
1920 LttTime birth;
1921 guint pl_height = 0;
1922 HashedProcessData *hashed_process_data_in = NULL;
1923
1924 ProcessList *process_list = control_flow_data->process_list;
1925 guint trace_num = ts->parent.index;
1926
1927 guint pid_in;
1928 {
1929 pid_in = ltt_event_get_long_unsigned(e, thf->f1);
1930 }
1931
1932
1933 /* Find process pid_in in the list... */
1934 process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
1935 //process_in = tfs->process;
1936 //guint cpu = tfs->cpu;
1937 //guint trace_num = ts->parent.index;
1938 //process_in = ts->running_process[cpu];
1939 /* It should exist, because we are after the state update. */
1940 #ifdef EXTRA_CHECK
1941 //g_assert(process_in != NULL);
1942 #endif //EXTRA_CHECK
1943 birth = process_in->creation_time;
1944
1945 hashed_process_data_in = processlist_get_process_data(process_list,
1946 pid_in,
1947 process_in->cpu,
1948 &birth,
1949 trace_num);
1950 if(hashed_process_data_in == NULL)
1951 {
1952 if(pid_in != 0 && pid_in == process_in->ppid)
1953 g_critical("TEST %u , %u", pid_in, process_in->ppid);
1954 g_assert(pid_in == 0 || pid_in != process_in->ppid);
1955 ProcessInfo *process_info;
1956 Drawing_t *drawing = control_flow_data->drawing;
1957 /* Process not present */
1958 processlist_add(process_list,
1959 drawing,
1960 pid_in,
1961 process_in->tgid,
1962 process_in->cpu,
1963 process_in->ppid,
1964 &birth,
1965 trace_num,
1966 process_in->name,
1967 process_in->brand,
1968 &pl_height,
1969 &process_info,
1970 &hashed_process_data_in);
1971 gtk_widget_set_size_request(drawing->drawing_area,
1972 -1,
1973 pl_height);
1974 gtk_widget_queue_draw(drawing->drawing_area);
1975 } else {
1976 processlist_set_name(process_list, process_in->name,
1977 hashed_process_data_in);
1978 processlist_set_ppid(process_list, process_in->ppid,
1979 hashed_process_data_in);
1980 processlist_set_tgid(process_list, process_in->tgid,
1981 hashed_process_data_in);
1982 }
1983 return 0;
1984 }
1985
1986
1987 gint update_time_window_hook(void *hook_data, void *call_data)
1988 {
1989 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
1990 Drawing_t *drawing = control_flow_data->drawing;
1991 ProcessList *process_list = control_flow_data->process_list;
1992
1993 const TimeWindowNotifyData *time_window_nofify_data =
1994 ((const TimeWindowNotifyData *)call_data);
1995
1996 TimeWindow *old_time_window =
1997 time_window_nofify_data->old_time_window;
1998 TimeWindow *new_time_window =
1999 time_window_nofify_data->new_time_window;
2000
2001 /* Update the ruler */
2002 drawing_update_ruler(control_flow_data->drawing,
2003 new_time_window);
2004
2005
2006 /* Two cases : zoom in/out or scrolling */
2007
2008 /* In order to make sure we can reuse the old drawing, the scale must
2009 * be the same and the new time interval being partly located in the
2010 * currently shown time interval. (reuse is only for scrolling)
2011 */
2012
2013 g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
2014 old_time_window->start_time.tv_sec,
2015 old_time_window->start_time.tv_nsec,
2016 old_time_window->time_width.tv_sec,
2017 old_time_window->time_width.tv_nsec);
2018
2019 g_info("New time window HOOK : %lu, %lu to %lu, %lu",
2020 new_time_window->start_time.tv_sec,
2021 new_time_window->start_time.tv_nsec,
2022 new_time_window->time_width.tv_sec,
2023 new_time_window->time_width.tv_nsec);
2024
2025 if( new_time_window->time_width.tv_sec == old_time_window->time_width.tv_sec
2026 && new_time_window->time_width.tv_nsec == old_time_window->time_width.tv_nsec)
2027 {
2028 /* Same scale (scrolling) */
2029 g_info("scrolling");
2030 LttTime *ns = &new_time_window->start_time;
2031 LttTime *nw = &new_time_window->time_width;
2032 LttTime *os = &old_time_window->start_time;
2033 LttTime *ow = &old_time_window->time_width;
2034 LttTime old_end = old_time_window->end_time;
2035 LttTime new_end = new_time_window->end_time;
2036 //if(ns<os+w<ns+w)
2037 //if(ns<os+w && os+w<ns+w)
2038 //if(ns<old_end && os<ns)
2039 if(ltt_time_compare(*ns, old_end) == -1
2040 && ltt_time_compare(*os, *ns) == -1)
2041 {
2042 g_info("scrolling near right");
2043 /* Scroll right, keep right part of the screen */
2044 guint x = 0;
2045 guint width = control_flow_data->drawing->width;
2046 convert_time_to_pixels(
2047 *old_time_window,
2048 *ns,
2049 width,
2050 &x);
2051
2052 /* Copy old data to new location */
2053 copy_pixmap_region(process_list,
2054 NULL,
2055 control_flow_data->drawing->drawing_area->style->black_gc,
2056 NULL,
2057 x, 0,
2058 0, 0,
2059 control_flow_data->drawing->width-x+SAFETY, -1);
2060
2061 if(drawing->damage_begin == drawing->damage_end)
2062 drawing->damage_begin = control_flow_data->drawing->width-x;
2063 else
2064 drawing->damage_begin = 0;
2065
2066 drawing->damage_end = control_flow_data->drawing->width;
2067
2068 /* Clear the data request background, but not SAFETY */
2069 rectangle_pixmap(process_list,
2070 control_flow_data->drawing->drawing_area->style->black_gc,
2071 TRUE,
2072 drawing->damage_begin+SAFETY, 0,
2073 drawing->damage_end - drawing->damage_begin, // do not overlap
2074 -1);
2075 gtk_widget_queue_draw(drawing->drawing_area);
2076 //gtk_widget_queue_draw_area (drawing->drawing_area,
2077 // 0,0,
2078 // control_flow_data->drawing->width,
2079 // control_flow_data->drawing->height);
2080
2081 /* Get new data for the rest. */
2082 drawing_data_request(control_flow_data->drawing,
2083 drawing->damage_begin, 0,
2084 drawing->damage_end - drawing->damage_begin,
2085 control_flow_data->drawing->height);
2086 } else {
2087 //if(ns<os<ns+w)
2088 //if(ns<os && os<ns+w)
2089 //if(ns<os && os<new_end)
2090 if(ltt_time_compare(*ns,*os) == -1
2091 && ltt_time_compare(*os,new_end) == -1)
2092 {
2093 g_info("scrolling near left");
2094 /* Scroll left, keep left part of the screen */
2095 guint x = 0;
2096 guint width = control_flow_data->drawing->width;
2097 convert_time_to_pixels(
2098 *new_time_window,
2099 *os,
2100 width,
2101 &x);
2102
2103 /* Copy old data to new location */
2104 copy_pixmap_region (process_list,
2105 NULL,
2106 control_flow_data->drawing->drawing_area->style->black_gc,
2107 NULL,
2108 0, 0,
2109 x, 0,
2110 -1, -1);
2111
2112 if(drawing->damage_begin == drawing->damage_end)
2113 drawing->damage_end = x;
2114 else
2115 drawing->damage_end =
2116 control_flow_data->drawing->width;
2117
2118 drawing->damage_begin = 0;
2119
2120 rectangle_pixmap (process_list,
2121 control_flow_data->drawing->drawing_area->style->black_gc,
2122 TRUE,
2123 drawing->damage_begin, 0,
2124 drawing->damage_end - drawing->damage_begin, // do not overlap
2125 -1);
2126
2127 gtk_widget_queue_draw(drawing->drawing_area);
2128 //gtk_widget_queue_draw_area (drawing->drawing_area,
2129 // 0,0,
2130 // control_flow_data->drawing->width,
2131 // control_flow_data->drawing->height);
2132
2133
2134 /* Get new data for the rest. */
2135 drawing_data_request(control_flow_data->drawing,
2136 drawing->damage_begin, 0,
2137 drawing->damage_end - drawing->damage_begin,
2138 control_flow_data->drawing->height);
2139
2140 } else {
2141 if(ltt_time_compare(*ns,*os) == 0)
2142 {
2143 g_info("not scrolling");
2144 } else {
2145 g_info("scrolling far");
2146 /* Cannot reuse any part of the screen : far jump */
2147
2148
2149 rectangle_pixmap (process_list,
2150 control_flow_data->drawing->drawing_area->style->black_gc,
2151 TRUE,
2152 0, 0,
2153 control_flow_data->drawing->width+SAFETY, // do not overlap
2154 -1);
2155
2156 //gtk_widget_queue_draw_area (drawing->drawing_area,
2157 // 0,0,
2158 // control_flow_data->drawing->width,
2159 // control_flow_data->drawing->height);
2160 gtk_widget_queue_draw(drawing->drawing_area);
2161
2162 drawing->damage_begin = 0;
2163 drawing->damage_end = control_flow_data->drawing->width;
2164
2165 drawing_data_request(control_flow_data->drawing,
2166 0, 0,
2167 control_flow_data->drawing->width,
2168 control_flow_data->drawing->height);
2169
2170 }
2171 }
2172 }
2173 } else {
2174 /* Different scale (zoom) */
2175 g_info("zoom");
2176
2177 rectangle_pixmap (process_list,
2178 control_flow_data->drawing->drawing_area->style->black_gc,
2179 TRUE,
2180 0, 0,
2181 control_flow_data->drawing->width+SAFETY, // do not overlap
2182 -1);
2183
2184 //gtk_widget_queue_draw_area (drawing->drawing_area,
2185 // 0,0,
2186 // control_flow_data->drawing->width,
2187 // control_flow_data->drawing->height);
2188 gtk_widget_queue_draw(drawing->drawing_area);
2189
2190 drawing->damage_begin = 0;
2191 drawing->damage_end = control_flow_data->drawing->width;
2192
2193 drawing_data_request(control_flow_data->drawing,
2194 0, 0,
2195 control_flow_data->drawing->width,
2196 control_flow_data->drawing->height);
2197 }
2198
2199 /* Update directly when scrolling */
2200 gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
2201 TRUE);
2202
2203 return 0;
2204 }
2205
2206 gint traceset_notify(void *hook_data, void *call_data)
2207 {
2208 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2209 Drawing_t *drawing = control_flow_data->drawing;
2210
2211 if(unlikely(drawing->gc == NULL)) {
2212 return FALSE;
2213 }
2214 if(drawing->dotted_gc == NULL) {
2215 return FALSE;
2216 }
2217
2218 drawing_clear(control_flow_data->drawing);
2219 processlist_clear(control_flow_data->process_list);
2220 gtk_widget_set_size_request(
2221 control_flow_data->drawing->drawing_area,
2222 -1, processlist_get_height(control_flow_data->process_list));
2223 redraw_notify(control_flow_data, NULL);
2224
2225 request_background_data(control_flow_data);
2226
2227 return FALSE;
2228 }
2229
2230 gint redraw_notify(void *hook_data, void *call_data)
2231 {
2232 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2233 Drawing_t *drawing = control_flow_data->drawing;
2234 GtkWidget *widget = drawing->drawing_area;
2235
2236 drawing->damage_begin = 0;
2237 drawing->damage_end = drawing->width;
2238
2239 /* fun feature, to be separated someday... */
2240 drawing_clear(control_flow_data->drawing);
2241 processlist_clear(control_flow_data->process_list);
2242 gtk_widget_set_size_request(
2243 control_flow_data->drawing->drawing_area,
2244 -1, processlist_get_height(control_flow_data->process_list));
2245 // Clear the images
2246 rectangle_pixmap (control_flow_data->process_list,
2247 widget->style->black_gc,
2248 TRUE,
2249 0, 0,
2250 drawing->alloc_width,
2251 -1);
2252
2253 gtk_widget_queue_draw(drawing->drawing_area);
2254
2255 if(drawing->damage_begin < drawing->damage_end)
2256 {
2257 drawing_data_request(drawing,
2258 drawing->damage_begin,
2259 0,
2260 drawing->damage_end-drawing->damage_begin,
2261 drawing->height);
2262 }
2263
2264 //gtk_widget_queue_draw_area(drawing->drawing_area,
2265 // 0,0,
2266 // drawing->width,
2267 // drawing->height);
2268 return FALSE;
2269
2270 }
2271
2272
2273 gint continue_notify(void *hook_data, void *call_data)
2274 {
2275 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2276 Drawing_t *drawing = control_flow_data->drawing;
2277
2278 //g_assert(widget->allocation.width == drawing->damage_end);
2279
2280 if(drawing->damage_begin < drawing->damage_end)
2281 {
2282 drawing_data_request(drawing,
2283 drawing->damage_begin,
2284 0,
2285 drawing->damage_end-drawing->damage_begin,
2286 drawing->height);
2287 }
2288
2289 return FALSE;
2290 }
2291
2292
2293 gint update_current_time_hook(void *hook_data, void *call_data)
2294 {
2295 ControlFlowData *control_flow_data = (ControlFlowData*)hook_data;
2296 Drawing_t *drawing = control_flow_data->drawing;
2297
2298 LttTime current_time = *((LttTime*)call_data);
2299
2300 TimeWindow time_window =
2301 lttvwindow_get_time_window(control_flow_data->tab);
2302
2303 LttTime time_begin = time_window.start_time;
2304 LttTime width = time_window.time_width;
2305 LttTime half_width;
2306 {
2307 guint64 time_ll = ltt_time_to_uint64(width);
2308 time_ll = time_ll >> 1; /* divide by two */
2309 half_width = ltt_time_from_uint64(time_ll);
2310 }
2311 LttTime time_end = ltt_time_add(time_begin, width);
2312
2313 LttvTracesetContext * tsc =
2314 lttvwindow_get_traceset_context(control_flow_data->tab);
2315
2316 LttTime trace_start = tsc->time_span.start_time;
2317 LttTime trace_end = tsc->time_span.end_time;
2318
2319 g_info("New current time HOOK : %lu, %lu", current_time.tv_sec,
2320 current_time.tv_nsec);
2321
2322
2323
2324 /* If current time is inside time interval, just move the highlight
2325 * bar */
2326
2327 /* Else, we have to change the time interval. We have to tell it
2328 * to the main window. */
2329 /* The time interval change will take care of placing the current
2330 * time at the center of the visible area, or nearest possible if we are
2331 * at one end of the trace. */
2332
2333
2334 if(ltt_time_compare(current_time, time_begin) < 0)
2335 {
2336 TimeWindow new_time_window;
2337
2338 if(ltt_time_compare(current_time,
2339 ltt_time_add(trace_start,half_width)) < 0)
2340 time_begin = trace_start;
2341 else
2342 time_begin = ltt_time_sub(current_time,half_width);
2343
2344 new_time_window.start_time = time_begin;
2345 new_time_window.time_width = width;
2346 new_time_window.time_width_double = ltt_time_to_double(width);
2347 new_time_window.end_time = ltt_time_add(time_begin, width);
2348
2349 lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
2350 }
2351 else if(ltt_time_compare(current_time, time_end) > 0)
2352 {
2353 TimeWindow new_time_window;
2354
2355 if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0)
2356 time_begin = ltt_time_sub(trace_end,width);
2357 else
2358 time_begin = ltt_time_sub(current_time,half_width);
2359
2360 new_time_window.start_time = time_begin;
2361 new_time_window.time_width = width;
2362 new_time_window.time_width_double = ltt_time_to_double(width);
2363 new_time_window.end_time = ltt_time_add(time_begin, width);
2364
2365 lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
2366
2367 }
2368 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2369
2370 /* Update directly when scrolling */
2371 gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
2372 TRUE);
2373
2374 return 0;
2375 }
2376
2377 typedef struct _ClosureData {
2378 EventsRequest *events_request;
2379 LttvTracesetState *tss;
2380 LttTime end_time;
2381 guint x_end;
2382 } ClosureData;
2383
2384
2385 void draw_closure(gpointer key, gpointer value, gpointer user_data)
2386 {
2387 ProcessInfo *process_info = (ProcessInfo*)key;
2388 HashedProcessData *hashed_process_data = (HashedProcessData*)value;
2389 ClosureData *closure_data = (ClosureData*)user_data;
2390
2391 EventsRequest *events_request = closure_data->events_request;
2392 ControlFlowData *control_flow_data = events_request->viewer_data;
2393
2394 LttvTracesetState *tss = closure_data->tss;
2395 LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
2396
2397 LttTime evtime = closure_data->end_time;
2398
2399 gboolean dodraw = TRUE;
2400
2401 {
2402 /* For the process */
2403 /* First, check if the current process is in the state computation
2404 * process list. If it is there, that means we must add it right now and
2405 * draw items from the beginning of the read for it. If it is not
2406 * present, it's a new process and it was not present : it will
2407 * be added after the state update. */
2408 #ifdef EXTRA_CHECK
2409 g_assert(lttv_traceset_number(tsc->ts) > 0);
2410 #endif //EXTRA_CHECK
2411 LttvTraceContext *tc = tsc->traces[process_info->trace_num];
2412 LttvTraceState *ts = (LttvTraceState*)tc;
2413
2414 #if 0
2415 //FIXME : optimize data structures.
2416 LttvTracefileState *tfs;
2417 LttvTracefileContext *tfc;
2418 guint i;
2419 for(i=0;i<tc->tracefiles->len;i++) {
2420 tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i);
2421 if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU
2422 && tfs->cpu == process_info->cpu)
2423 break;
2424
2425 }
2426 g_assert(i<tc->tracefiles->len);
2427 tfs = LTTV_TRACEFILE_STATE(tfc);
2428 #endif //0
2429 // LttvTracefileState *tfs =
2430 // (LttvTracefileState*)tsc->traces[process_info->trace_num]->
2431 // tracefiles[process_info->cpu];
2432
2433 LttvProcessState *process;
2434 process = lttv_state_find_process(ts, process_info->cpu,
2435 process_info->pid);
2436
2437 if(unlikely(process != NULL)) {
2438
2439 LttvFilter *filter = control_flow_data->filter;
2440 if(filter != NULL && filter->head != NULL)
2441 if(!lttv_filter_tree_parse(filter->head,NULL,NULL,
2442 tc->t,NULL,process,tc))
2443 dodraw = FALSE;
2444
2445 /* Only draw for processes that are currently in the trace states */
2446
2447 ProcessList *process_list = control_flow_data->process_list;
2448 #ifdef EXTRA_CHECK
2449 /* Should be alike when background info is ready */
2450 if(control_flow_data->background_info_waiting==0)
2451 g_assert(ltt_time_compare(process->creation_time,
2452 process_info->birth) == 0);
2453 #endif //EXTRA_CHECK
2454
2455 /* Now, the process is in the state hash and our own process hash.
2456 * We definitely can draw the items related to the ending state.
2457 */
2458
2459 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
2460 evtime) <= 0))
2461 {
2462 TimeWindow time_window =
2463 lttvwindow_get_time_window(control_flow_data->tab);
2464
2465 #ifdef EXTRA_CHECK
2466 if(ltt_time_compare(evtime, time_window.start_time) == -1
2467 || ltt_time_compare(evtime, time_window.end_time) == 1)
2468 return;
2469 #endif //EXTRA_CHECK
2470 Drawing_t *drawing = control_flow_data->drawing;
2471 guint width = drawing->width;
2472
2473 guint x = closure_data->x_end;
2474
2475 DrawContext draw_context;
2476
2477 /* Now create the drawing context that will be used to draw
2478 * items related to the last state. */
2479 draw_context.drawable = hashed_process_data->pixmap;
2480 draw_context.gc = drawing->gc;
2481 draw_context.pango_layout = drawing->pango_layout;
2482 draw_context.drawinfo.end.x = x;
2483
2484 draw_context.drawinfo.y.over = 1;
2485 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2486 draw_context.drawinfo.y.under = hashed_process_data->height;
2487
2488 draw_context.drawinfo.start.offset.over = 0;
2489 draw_context.drawinfo.start.offset.middle = 0;
2490 draw_context.drawinfo.start.offset.under = 0;
2491 draw_context.drawinfo.end.offset.over = 0;
2492 draw_context.drawinfo.end.offset.middle = 0;
2493 draw_context.drawinfo.end.offset.under = 0;
2494 #if 0
2495 /* Jump over draw if we are at the same x position */
2496 if(x == hashed_process_data->x.over)
2497 {
2498 /* jump */
2499 } else {
2500 draw_context.drawinfo.start.x = hashed_process_data->x.over;
2501 /* Draw the line */
2502 PropertiesLine prop_line = prepare_execmode_line(process);
2503 draw_line((void*)&prop_line, (void*)&draw_context);
2504
2505 hashed_process_data->x.over = x;
2506 }
2507 #endif //0
2508
2509 if(unlikely(x == hashed_process_data->x.middle &&
2510 hashed_process_data->x.middle_used)) {
2511 #if 0 /* do not mark closure : not missing information */
2512 if(hashed_process_data->x.middle_marked == FALSE) {
2513 /* Draw collision indicator */
2514 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2515 gdk_draw_point(drawing->pixmap,
2516 drawing->gc,
2517 x,
2518 y+(height/2)-3);
2519 hashed_process_data->x.middle_marked = TRUE;
2520 }
2521 #endif //0
2522 /* Jump */
2523 } else {
2524 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2525 /* Draw the line */
2526 if(dodraw) {
2527 PropertiesLine prop_line = prepare_s_e_line(process);
2528 draw_line((void*)&prop_line, (void*)&draw_context);
2529 }
2530
2531 /* become the last x position */
2532 if(likely(x != hashed_process_data->x.middle)) {
2533 hashed_process_data->x.middle = x;
2534 /* but don't use the pixel */
2535 hashed_process_data->x.middle_used = FALSE;
2536
2537 /* Calculate the next good time */
2538 convert_pixels_to_time(width, x+1, time_window,
2539 &hashed_process_data->next_good_time);
2540 }
2541 }
2542 }
2543 }
2544 }
2545 return;
2546 }
2547
2548 int before_chunk(void *hook_data, void *call_data)
2549 {
2550 EventsRequest *events_request = (EventsRequest*)hook_data;
2551 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2552 ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data;
2553 #if 0
2554 /* Desactivate sort */
2555 gtk_tree_sortable_set_sort_column_id(
2556 GTK_TREE_SORTABLE(cfd->process_list->list_store),
2557 TRACE_COLUMN,
2558 GTK_SORT_ASCENDING);
2559 #endif //0
2560 drawing_chunk_begin(events_request, tss);
2561
2562 return 0;
2563 }
2564
2565 int before_request(void *hook_data, void *call_data)
2566 {
2567 EventsRequest *events_request = (EventsRequest*)hook_data;
2568 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2569
2570 drawing_data_request_begin(events_request, tss);
2571
2572 return 0;
2573 }
2574
2575
2576 /*
2577 * after request is necessary in addition of after chunk in order to draw
2578 * lines until the end of the screen. after chunk just draws lines until
2579 * the last event.
2580 *
2581 * for each process
2582 * draw closing line
2583 * expose
2584 */
2585 int after_request(void *hook_data, void *call_data)
2586 {
2587 EventsRequest *events_request = (EventsRequest*)hook_data;
2588 ControlFlowData *control_flow_data = events_request->viewer_data;
2589 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2590
2591 ProcessList *process_list = control_flow_data->process_list;
2592 LttTime end_time = events_request->end_time;
2593
2594 ClosureData closure_data;
2595 closure_data.events_request = (EventsRequest*)hook_data;
2596 closure_data.tss = tss;
2597 closure_data.end_time = end_time;
2598
2599 TimeWindow time_window =
2600 lttvwindow_get_time_window(control_flow_data->tab);
2601 guint width = control_flow_data->drawing->width;
2602 convert_time_to_pixels(
2603 time_window,
2604 end_time,
2605 width,
2606 &closure_data.x_end);
2607
2608
2609 /* Draw last items */
2610 g_hash_table_foreach(process_list->process_hash, draw_closure,
2611 (void*)&closure_data);
2612
2613
2614 /* Request expose */
2615 drawing_request_expose(events_request, tss, end_time);
2616 return 0;
2617 }
2618
2619 /*
2620 * for each process
2621 * draw closing line
2622 * expose
2623 */
2624 int after_chunk(void *hook_data, void *call_data)
2625 {
2626 EventsRequest *events_request = (EventsRequest*)hook_data;
2627 ControlFlowData *control_flow_data = events_request->viewer_data;
2628 LttvTracesetState *tss = (LttvTracesetState*)call_data;
2629 LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
2630 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
2631 LttTime end_time;
2632
2633 ProcessList *process_list = control_flow_data->process_list;
2634 guint i;
2635 LttvTraceset *traceset = tsc->ts;
2636 guint nb_trace = lttv_traceset_number(traceset);
2637
2638 /* Only execute when called for the first trace's events request */
2639 if(!process_list->current_hash_data) return;
2640
2641 for(i = 0 ; i < nb_trace ; i++) {
2642 g_free(process_list->current_hash_data[i]);
2643 }
2644 g_free(process_list->current_hash_data);
2645 process_list->current_hash_data = NULL;
2646
2647 if(tfc != NULL)
2648 end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
2649 else /* end of traceset, or position now out of request : end */
2650 end_time = events_request->end_time;
2651
2652 ClosureData closure_data;
2653 closure_data.events_request = (EventsRequest*)hook_data;
2654 closure_data.tss = tss;
2655 closure_data.end_time = end_time;
2656
2657 TimeWindow time_window =
2658 lttvwindow_get_time_window(control_flow_data->tab);
2659 guint width = control_flow_data->drawing->width;
2660 convert_time_to_pixels(
2661 time_window,
2662 end_time,
2663 width,
2664 &closure_data.x_end);
2665
2666 /* Draw last items */
2667 g_hash_table_foreach(process_list->process_hash, draw_closure,
2668 (void*)&closure_data);
2669 #if 0
2670 /* Reactivate sort */
2671 gtk_tree_sortable_set_sort_column_id(
2672 GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
2673 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2674 GTK_SORT_ASCENDING);
2675
2676 update_index_to_pixmap(control_flow_data->process_list);
2677 /* Request a full expose : drawing scrambled */
2678 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2679 #endif //0
2680 /* Request expose (updates damages zone also) */
2681 drawing_request_expose(events_request, tss, end_time);
2682
2683 return 0;
2684 }
2685
2686 /* after_statedump_end
2687 *
2688 * @param hook_data ControlFlowData structure of the viewer.
2689 * @param call_data Event context.
2690 *
2691 * This function adds items to be drawn in a queue for each process.
2692 *
2693 */
2694 int before_statedump_end(void *hook_data, void *call_data)
2695 {
2696 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
2697 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
2698 ControlFlowData *control_flow_data = events_request->viewer_data;
2699
2700 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2701
2702 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
2703
2704 LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
2705
2706 LttvTracesetState *tss = (LttvTracesetState*)tfc->t_context->ts_context;
2707 ProcessList *process_list = control_flow_data->process_list;
2708
2709 LttEvent *e;
2710 e = ltt_tracefile_get_event(tfc->tf);
2711
2712 LttvFilter *filter = control_flow_data->filter;
2713 if(filter != NULL && filter->head != NULL)
2714 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
2715 tfc->t_context->t,tfc,NULL,NULL))
2716 return FALSE;
2717
2718 LttTime evtime = ltt_event_time(e);
2719
2720 ClosureData closure_data;
2721 closure_data.events_request = events_request;
2722 closure_data.tss = tss;
2723 closure_data.end_time = evtime;
2724
2725 TimeWindow time_window =
2726 lttvwindow_get_time_window(control_flow_data->tab);
2727 guint width = control_flow_data->drawing->width;
2728 convert_time_to_pixels(
2729 time_window,
2730 evtime,
2731 width,
2732 &closure_data.x_end);
2733
2734 /* Draw last items */
2735 g_hash_table_foreach(process_list->process_hash, draw_closure,
2736 (void*)&closure_data);
2737 #if 0
2738 /* Reactivate sort */
2739 gtk_tree_sortable_set_sort_column_id(
2740 GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
2741 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2742 GTK_SORT_ASCENDING);
2743
2744 update_index_to_pixmap(control_flow_data->process_list);
2745 /* Request a full expose : drawing scrambled */
2746 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2747 #endif //0
2748 /* Request expose (updates damages zone also) */
2749 drawing_request_expose(events_request, tss, evtime);
2750
2751 return 0;
2752 }
LTTng 2.x Viewer (LTTV)
This page took 0.083874 seconds and 5 git commands to generate.