projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix position set to put the old_position boolean to FALSE, because quick position...
[lttv.git] / ltt / branches / poly / lttv / modules / gui / detailedevents / events.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Mathieu Desnoyers and XangXiu Yang
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 //*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
21 /*\@{*/
22
23 /*! \file GuiEvents.c
24 * \brief Graphical plugin for showing events.
25 *
26 * This plugin lists all the events contained in the current time interval
27 * in a list.
28 *
29 * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
30 * GUI when this plugin is loaded. The init and destroy functions add the
31 * viewer's insertion menu item and toolbar icon by calling viewer.h's
32 * API functions. Then, when a viewer's object is created, the constructor
33 * creates ans register through API functions what is needed to interact
34 * with the TraceSet window.
35 *
36 * Authors : Mathieu Desnoyers and XangXiu Yang, June to December 2003
37 * Inspired from original LTT, made by Karim Yaghmour
38 */
39
40 #include <math.h>
41
42 #include <glib.h>
43 #include <gtk/gtk.h>
44 #include <gdk/gdk.h>
45
46 #include <ltt/ltt.h>
47 #include <ltt/event.h>
48 #include <ltt/type.h>
49 #include <ltt/trace.h>
50 #include <ltt/facility.h>
51 #include <lttv/module.h>
52 #include <lttv/hook.h>
53 #include <lttv/tracecontext.h>
54 #include <lttv/state.h>
55 #include <lttvwindow/lttvwindow.h>
56
57 #include "hGuiEventsInsert.xpm"
58
59 #define MAX_NUMBER_EVENT "max_number_event"
60
61
62 /** Array containing instanced objects. Used when module is unloaded */
63 static GSList *g_event_viewer_data_list = NULL ;
64
65 typedef struct _RawTraceData{
66 unsigned cpu_id;
67 char * event_name;
68 LttTime time;
69 int pid;
70 unsigned entry_length;
71 char * event_description;
72 LttEventPosition *ep;
73 } RawTraceData;
74
75 #define RESERVE_BIG_SIZE 1000
76 #define RESERVE_SMALL_SIZE 100
77 #define RESERVE_SMALL_SIZE_SQUARE RESERVE_SMALL_SIZE*RESERVE_SMALL_SIZE
78 #define RESERVE_SMALL_SIZE_CUBE RESERVE_SMALL_SIZE*RESERVE_SMALL_SIZE_SQUARE
79
80 typedef enum _ScrollDirection{
81 SCROLL_STEP_UP,
82 SCROLL_STEP_DOWN,
83 SCROLL_PAGE_UP,
84 SCROLL_PAGE_DOWN,
85 SCROLL_JUMP,
86 SCROLL_NONE
87 } ScrollDirection;
88
89 typedef struct _EventViewerData {
90
91 Tab * tab;
92 //TimeWindow time_window;
93 // LttTime current_time;
94 LttvHooks * event_hooks;
95
96 gboolean append; //prepend or append item
97 GQueue * raw_trace_data_queue; //buf to contain raw trace data
98 GQueue * raw_trace_data_queue_tmp; //tmp buf to contain raw data
99 unsigned current_event_index;
100 double previous_value; //value of the slide
101 // TimeInterval time_span;
102 unsigned start_event_index; //the first event shown in the window
103 unsigned end_event_index; //the last event shown in the window
104 unsigned size; //maxi number of events loaded when instance the viewer
105 gboolean shown; //indicate if event detail is shown or not
106 gboolean current_time_updated;
107 char * filter_key;
108
109 //scroll window containing Tree View
110 GtkWidget * scroll_win;
111
112 /* Model containing list data */
113 GtkListStore *store_m;
114
115 GtkWidget *hbox_v;
116 /* Widget to display the data in a columned list */
117 GtkWidget *tree_v;
118 GtkAdjustment *vtree_adjust_c ;
119 GtkWidget *button; /* a button of the header */
120 gint header_height;
121
122 /* Vertical scrollbar and it's adjustment */
123 GtkWidget *vscroll_vc;
124 GtkAdjustment *vadjust_c ;
125
126 /* Selection handler */
127 GtkTreeSelection *select_c;
128
129 guint num_visible_events;
130 guint first_event, last_event;
131
132 /* TEST DATA, TO BE READ FROM THE TRACE */
133 gint number_of_events ;
134 guint currently_selected_event ;
135 gboolean selected_event ;
136
137 } EventViewerData ;
138
139 /** hook functions for update time interval, current time ... */
140 gboolean update_time_window(void * hook_data, void * call_data);
141 gboolean update_current_time(void * hook_data, void * call_data);
142 //gboolean show_event_detail(void * hook_data, void * call_data);
143 gboolean traceset_changed(void * hook_data, void * call_data);
144 void remove_item_from_queue(GQueue * q, gboolean fromHead);
145 void remove_all_items_from_queue(GQueue * q);
146 void add_context_hooks(EventViewerData * event_viewer_data,
147 LttvTracesetContext * tsc);
148 void remove_context_hooks(EventViewerData * event_viewer_data,
149 LttvTracesetContext * tsc);
150
151 //! Event Viewer's constructor hook
152 GtkWidget *h_gui_events(Tab *tab, LttvTracesetSelector * s, char* key);
153 //! Event Viewer's constructor
154 EventViewerData *gui_events(Tab *tab, LttvTracesetSelector *s, char *key);
155 //! Event Viewer's destructor
156 void gui_events_destructor(EventViewerData *event_viewer_data);
157 void gui_events_free(EventViewerData *event_viewer_data);
158
159 static int event_selected_hook(void *hook_data, void *call_data);
160
161 static gboolean
162 header_size_allocate(GtkWidget *widget,
163 GtkAllocation *allocation,
164 gpointer user_data);
165
166 void tree_v_set_cursor(EventViewerData *event_viewer_data);
167 void tree_v_get_cursor(EventViewerData *event_viewer_data);
168
169 /* Prototype for selection handler callback */
170 static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
171 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
172 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
173 static void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
174 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
175 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
176 static void tree_v_grab_focus(GtkWidget *widget, gpointer data);
177
178
179 static void get_test_data(double time, guint list_height,
180 EventViewerData *event_viewer_data);
181
182 void add_test_data(EventViewerData *event_viewer_data);
183
184 static void update_raw_data_array(EventViewerData* event_viewer_data, unsigned size);
185
186 static void get_events(EventViewerData* event_viewer_data, LttTime start,
187 LttTime end, unsigned max_num_events, unsigned * real_num_events);
188 int after_get_events(void *hook_data, void *call_data);
189 static gboolean parse_event(void *hook_data, void *call_data);
190
191 static LttvModule *main_win_module;
192
193 /* Enumeration of the columns */
194 enum
195 {
196 CPUID_COLUMN,
197 EVENT_COLUMN,
198 TIME_COLUMN,
199 PID_COLUMN,
200 ENTRY_LEN_COLUMN,
201 EVENT_DESCR_COLUMN,
202 N_COLUMNS
203 };
204
205
206 /**
207 * Event Viewer's constructor hook
208 *
209 * This constructor is given as a parameter to the menuitem and toolbar button
210 * registration. It creates the list.
211 * @param parent_window A pointer to the parent window.
212 * @return The widget created.
213 */
214 GtkWidget *
215 h_gui_events(Tab * tab, LttvTracesetSelector * s, char* key)
216 {
217 EventViewerData* event_viewer_data = gui_events(tab, s, key) ;
218
219 if(event_viewer_data)
220 return event_viewer_data->hbox_v;
221 else return NULL;
222
223 }
224
225 /**
226 * Event Viewer's constructor
227 *
228 * This constructor is used to create EventViewerData data structure.
229 * @return The Event viewer data created.
230 */
231 EventViewerData *
232 gui_events(Tab *tab, LttvTracesetSelector * s,char* key )
233 {
234 LttTime start;
235 GtkTreeViewColumn *column;
236 GtkCellRenderer *renderer;
237 EventViewerData* event_viewer_data = g_new(EventViewerData,1) ;
238 RawTraceData * data;
239
240 event_viewer_data->tab = tab;
241
242 event_viewer_data->event_hooks = lttv_hooks_new();
243 lttv_hooks_add(event_viewer_data->event_hooks, parse_event, event_viewer_data, LTTV_PRIO_DEFAULT);
244
245 event_viewer_data->raw_trace_data_queue = g_queue_new();
246 event_viewer_data->raw_trace_data_queue_tmp = g_queue_new();
247
248 lttvwindow_register_time_window_notify(tab,
249 update_time_window, event_viewer_data);
250 lttvwindow_register_current_time_notify(tab,
251 update_current_time,event_viewer_data);
252 //lttvwindow_register_show_notify(tab,
253 // show_event_detail,event_viewer_data);
254 lttvwindow_register_traceset_notify(tab,
255 traceset_changed,event_viewer_data);
256
257 event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
258 gtk_widget_show (event_viewer_data->scroll_win);
259 gtk_scrolled_window_set_policy(
260 GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
261 GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
262
263 /* TEST DATA, TO BE READ FROM THE TRACE */
264 event_viewer_data->currently_selected_event = FALSE ;
265 event_viewer_data->selected_event = 0;
266
267 /* Create a model for storing the data list */
268 event_viewer_data->store_m = gtk_list_store_new (
269 N_COLUMNS, /* Total number of columns */
270 G_TYPE_INT, /* CPUID */
271 G_TYPE_STRING, /* Event */
272 G_TYPE_UINT64, /* Time */
273 G_TYPE_INT, /* PID */
274 G_TYPE_INT, /* Entry length */
275 G_TYPE_STRING); /* Event's description */
276
277 /* Create the viewer widget for the columned list */
278 event_viewer_data->tree_v =
279 gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
280
281 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
282 G_CALLBACK (tree_v_size_allocate_cb),
283 event_viewer_data);
284 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
285 G_CALLBACK (tree_v_size_request_cb),
286 event_viewer_data);
287
288 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
289 G_CALLBACK (tree_v_cursor_changed_cb),
290 event_viewer_data);
291
292 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
293 G_CALLBACK (tree_v_move_cursor_cb),
294 event_viewer_data);
295
296 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "grab-focus",
297 G_CALLBACK (tree_v_grab_focus),
298 event_viewer_data);
299
300 // Use on each column!
301 //gtk_tree_view_column_set_sizing(event_viewer_data->tree_v, GTK_TREE_VIEW_COLUMN_FIXED);
302
303 /* The view now holds a reference. We can get rid of our own
304 * reference */
305 g_object_unref (G_OBJECT (event_viewer_data->store_m));
306
307
308 /* Create a column, associating the "text" attribute of the
309 * cell_renderer to the first column of the model */
310 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
311 renderer = gtk_cell_renderer_text_new ();
312 column = gtk_tree_view_column_new_with_attributes ("CPUID",
313 renderer,
314 "text", CPUID_COLUMN,
315 NULL);
316 gtk_tree_view_column_set_alignment (column, 0.0);
317 gtk_tree_view_column_set_fixed_width (column, 45);
318 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
319
320 event_viewer_data->button = column->button;
321
322 g_signal_connect (G_OBJECT(event_viewer_data->button),
323 "size-allocate",
324 G_CALLBACK(header_size_allocate),
325 (gpointer)event_viewer_data);
326
327 renderer = gtk_cell_renderer_text_new ();
328 column = gtk_tree_view_column_new_with_attributes ("Event",
329 renderer,
330 "text", EVENT_COLUMN,
331 NULL);
332 gtk_tree_view_column_set_alignment (column, 0.0);
333 gtk_tree_view_column_set_fixed_width (column, 120);
334 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
335
336 renderer = gtk_cell_renderer_text_new ();
337 column = gtk_tree_view_column_new_with_attributes ("Time",
338 renderer,
339 "text", TIME_COLUMN,
340 NULL);
341 gtk_tree_view_column_set_alignment (column, 1.0);
342 gtk_tree_view_column_set_fixed_width (column, 120);
343 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
344
345 renderer = gtk_cell_renderer_text_new ();
346 column = gtk_tree_view_column_new_with_attributes ("PID",
347 renderer,
348 "text", PID_COLUMN,
349 NULL);
350 gtk_tree_view_column_set_alignment (column, 1.0);
351 gtk_tree_view_column_set_fixed_width (column, 45);
352 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
353
354 renderer = gtk_cell_renderer_text_new ();
355 column = gtk_tree_view_column_new_with_attributes ("Entry Length",
356 renderer,
357 "text", ENTRY_LEN_COLUMN,
358 NULL);
359 gtk_tree_view_column_set_alignment (column, 1.0);
360 gtk_tree_view_column_set_fixed_width (column, 60);
361 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
362
363 renderer = gtk_cell_renderer_text_new ();
364 column = gtk_tree_view_column_new_with_attributes ("Event Description",
365 renderer,
366 "text", EVENT_DESCR_COLUMN,
367 NULL);
368 gtk_tree_view_column_set_alignment (column, 0.0);
369 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
370
371
372 /* Setup the selection handler */
373 event_viewer_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
374 gtk_tree_selection_set_mode (event_viewer_data->select_c, GTK_SELECTION_SINGLE);
375 g_signal_connect (G_OBJECT (event_viewer_data->select_c), "changed",
376 G_CALLBACK (tree_selection_changed_cb),
377 event_viewer_data);
378
379 gtk_container_add (GTK_CONTAINER (event_viewer_data->scroll_win), event_viewer_data->tree_v);
380
381 event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
382 gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v), event_viewer_data->scroll_win, TRUE, TRUE, 0);
383
384 /* Create vertical scrollbar and pack it */
385 event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
386 gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
387 GTK_UPDATE_CONTINUOUS);
388 // Changed by MD : more user friendly :)
389 //GTK_UPDATE_DISCONTINUOUS);
390 gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v), event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
391
392 /* Get the vertical scrollbar's adjustment */
393 event_viewer_data->vadjust_c = gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
394 event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
395 GTK_TREE_VIEW (event_viewer_data->tree_v));
396
397 g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
398 G_CALLBACK (v_scroll_cb),
399 event_viewer_data);
400 /* Set the upper bound to the last event number */
401 event_viewer_data->previous_value = 0;
402 event_viewer_data->vadjust_c->lower = 0.0;
403 //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
404 event_viewer_data->vadjust_c->value = 0.0;
405 event_viewer_data->vadjust_c->step_increment = 1.0;
406 event_viewer_data->vadjust_c->page_increment = 2.0;
407 // event_viewer_data->vtree_adjust_c->upper;
408 event_viewer_data->vadjust_c->page_size = 2.0;
409 // event_viewer_data->vtree_adjust_c->upper;
410 /* Raw event trace */
411 gtk_widget_show(event_viewer_data->hbox_v);
412 gtk_widget_show(event_viewer_data->tree_v);
413 gtk_widget_show(event_viewer_data->vscroll_vc);
414
415 /* Add the object's information to the module's array */
416 g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list, event_viewer_data);
417
418 event_viewer_data->first_event = -1 ;
419 event_viewer_data->last_event = 0 ;
420
421 event_viewer_data->num_visible_events = 1;
422
423 //get the life span of the traceset and set the upper of the scroll bar
424
425 LttvTracesetContext * tsc =
426 lttvwindow_get_traceset_context(event_viewer_data->tab);
427 TimeInterval time_span = tsc->time_span;
428 start = ltt_time_sub(time_span.end_time, time_span.start_time);
429
430 event_viewer_data->vadjust_c->upper =
431 ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
432
433 event_viewer_data->append = TRUE;
434
435 event_viewer_data->start_event_index = 0;
436 event_viewer_data->end_event_index = event_viewer_data->num_visible_events - 1;
437
438 /* Set the Selected Event */
439 // tree_v_set_cursor(event_viewer_data);
440
441 event_viewer_data->shown = FALSE;
442 event_viewer_data->current_time_updated = FALSE;
443 event_viewer_data->size = RESERVE_SMALL_SIZE;
444 g_object_set_data(
445 G_OBJECT(event_viewer_data->hbox_v),
446 MAX_NUMBER_EVENT,
447 &event_viewer_data->size);
448 /*
449 g_object_set_data(
450 G_OBJECT(event_viewer_data->hbox_v),
451 TRACESET_TIME_SPAN,
452 time_span);
453 */
454 event_viewer_data->filter_key = g_strdup(key);
455 g_object_set_data(
456 G_OBJECT(event_viewer_data->hbox_v),
457 event_viewer_data->filter_key,
458 s);
459
460 g_object_set_data_full(
461 G_OBJECT(event_viewer_data->hbox_v),
462 "event_viewer_data",
463 event_viewer_data,
464 (GDestroyNotify)gui_events_free);
465
466
467 return event_viewer_data;
468 }
469
470
471
472 static gboolean
473 header_size_allocate(GtkWidget *widget,
474 GtkAllocation *allocation,
475 gpointer user_data)
476 {
477 EventViewerData *event_viewer_data = (EventViewerData*)user_data;
478
479 event_viewer_data->header_height = allocation->height;
480
481 return 0;
482 }
483
484
485 void tree_v_set_cursor(EventViewerData *event_viewer_data)
486 {
487 GtkTreePath *path;
488
489 if(event_viewer_data->selected_event && event_viewer_data->first_event != -1)
490 {
491 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
492 // event_viewer_data->currently_selected_event);
493
494 path = gtk_tree_path_new_from_indices(
495 event_viewer_data->currently_selected_event-
496 event_viewer_data->first_event,
497 -1);
498
499 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
500 gtk_tree_path_free(path);
501 }
502 }
503
504 void tree_v_get_cursor(EventViewerData *event_viewer_data)
505 {
506 GtkTreePath *path;
507 gint *indices;
508
509 gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
510 indices = gtk_tree_path_get_indices(path);
511
512 if(indices != NULL)
513 {
514 event_viewer_data->selected_event = TRUE;
515 event_viewer_data->currently_selected_event =
516 event_viewer_data->first_event + indices[0];
517
518 } else {
519 event_viewer_data->selected_event = FALSE;
520 event_viewer_data->currently_selected_event = 0;
521 }
522
523 gtk_tree_path_free(path);
524
525 }
526
527
528
529 void tree_v_move_cursor_cb (GtkWidget *widget,
530 GtkMovementStep arg1,
531 gint arg2,
532 gpointer data)
533 {
534 GtkTreePath *path; // = gtk_tree_path_new();
535 gint *indices;
536 gdouble value;
537 EventViewerData *event_viewer_data = (EventViewerData*)data;
538
539 gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
540 &path, NULL);
541 if(path == NULL)
542 {
543 /* No prior cursor, put it at beginning of page
544 * and let the execution do */
545 path = gtk_tree_path_new_from_indices(0, -1);
546 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
547 path, NULL, FALSE);
548 }
549
550 indices = gtk_tree_path_get_indices(path);
551
552 value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
553
554 if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
555 {
556 /* Move one line */
557 if(arg2 == 1)
558 {
559 /* move one line down */
560 if(indices[0] == event_viewer_data->num_visible_events - 1)
561 {
562 if(value + event_viewer_data->num_visible_events <=
563 event_viewer_data->number_of_events -1)
564 {
565 event_viewer_data->currently_selected_event += 1;
566 // gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
567 //gtk_tree_path_free(path);
568 //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
569 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
570 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
571 }
572 }
573 } else {
574 /* Move one line up */
575 if(indices[0] == 0)
576 {
577 if(value - 1 >= 0 )
578 {
579 event_viewer_data->currently_selected_event -= 1;
580 // gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
581 //gtk_tree_path_free(path);
582 //path = gtk_tree_path_new_from_indices(0, -1);
583 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
584 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
585 }
586 }
587 }
588 }
589
590 if(arg1 == GTK_MOVEMENT_PAGES)
591 {
592 /* Move one page */
593 if(arg2 == 1)
594 {
595 if(event_viewer_data->num_visible_events == 1)
596 value += 1 ;
597 /* move one page down */
598 if(value + event_viewer_data->num_visible_events-1 <=
599 event_viewer_data->number_of_events )
600 {
601 event_viewer_data->currently_selected_event +=
602 event_viewer_data->num_visible_events-1;
603 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
604 // value+(event_viewer_data->num_visible_events-1));
605 //gtk_tree_path_free(path);
606 //path = gtk_tree_path_new_from_indices(0, -1);
607 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
608 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
609 }
610 } else {
611 /* Move one page up */
612 if(event_viewer_data->num_visible_events == 1)
613 value -= 1 ;
614
615 if(indices[0] < event_viewer_data->num_visible_events - 2 )
616 {
617 if(value - (event_viewer_data->num_visible_events-1) >= 0)
618 {
619 event_viewer_data->currently_selected_event -=
620 event_viewer_data->num_visible_events-1;
621
622 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
623 // value-(event_viewer_data->num_visible_events-1));
624 //gtk_tree_path_free(path);
625 //path = gtk_tree_path_new_from_indices(0, -1);
626 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
627 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
628
629 } else {
630 /* Go to first Event */
631 event_viewer_data->currently_selected_event == 0 ;
632 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
633 // 0);
634 //gtk_tree_path_free(path);
635 //path = gtk_tree_path_new_from_indices(0, -1);
636 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
637 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
638
639 }
640 }
641 }
642 }
643
644 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
645 {
646 /* Move to the ends of the buffer */
647 if(arg2 == 1)
648 {
649 /* move end of buffer */
650 event_viewer_data->currently_selected_event =
651 event_viewer_data->number_of_events-1 ;
652 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
653 // event_viewer_data->number_of_events -
654 // event_viewer_data->num_visible_events);
655 //gtk_tree_path_free(path);
656 //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
657 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
658 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
659 } else {
660 /* Move beginning of buffer */
661 event_viewer_data->currently_selected_event = 0 ;
662 // gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
663 //gtk_tree_path_free(path);
664 //path = gtk_tree_path_new_from_indices(0, -1);
665 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
666 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
667 }
668 }
669
670 gtk_tree_path_free(path);
671 }
672
673 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
674 {
675 EventViewerData *event_viewer_data = (EventViewerData*) data;
676 Tab *tab = event_viewer_data->tab;
677 LttTime current_time = lttvwindow_get_current_time(tab);
678 LttTime ltt_time;
679 guint64 time;
680 GtkTreeIter iter;
681 GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
682 GtkTreePath *path;
683
684 /* On cursor change, modify the currently selected event by calling
685 * the right API function */
686 tree_v_get_cursor(event_viewer_data);
687
688 gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
689 if(gtk_tree_model_get_iter(model,&iter,path)){
690 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
691 ltt_time.tv_sec = time / NANOSECONDS_PER_SECOND;
692 ltt_time.tv_nsec = time % NANOSECONDS_PER_SECOND;
693
694 if(ltt_time.tv_sec != current_time.tv_sec ||
695 ltt_time.tv_nsec != current_time.tv_nsec){
696 event_viewer_data->current_time_updated = TRUE;
697 lttvwindow_report_current_time(tab,&ltt_time);
698 }
699 }else{
700 g_warning("Can not get iter\n");
701 }
702
703 }
704
705
706 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
707 {
708 EventViewerData *event_viewer_data = (EventViewerData*)data;
709 GtkTreePath *tree_path;
710
711 get_test_data(adjustment->value, event_viewer_data->num_visible_events,
712 event_viewer_data);
713
714
715 if(event_viewer_data->currently_selected_event
716 >= event_viewer_data->first_event
717 &&
718 event_viewer_data->currently_selected_event
719 <= event_viewer_data->last_event
720 &&
721 event_viewer_data->selected_event)
722 {
723
724 tree_path = gtk_tree_path_new_from_indices(
725 event_viewer_data->currently_selected_event-
726 event_viewer_data->first_event,
727 -1);
728
729 // gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
730 // NULL, FALSE);
731 gtk_tree_path_free(tree_path);
732 }
733
734
735 }
736
737 gint get_cell_height(GtkTreeView *TreeView)
738 {
739 gint height, width;
740 GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
741 GList *Render_List = gtk_tree_view_column_get_cell_renderers(column);
742 GtkCellRenderer *renderer = g_list_first(Render_List)->data;
743
744 gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
745
746 return height;
747 }
748
749 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
750 {
751 EventViewerData *event_viewer_data = (EventViewerData*)data;
752 gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
753 gint last_num_visible_events = event_viewer_data->num_visible_events;
754 gdouble exact_num_visible;
755
756 exact_num_visible = ( alloc->height -
757 event_viewer_data->header_height )
758 / (double)cell_height ;
759
760 event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
761
762 /*
763 event_viewer_data->vadjust_c->page_increment =
764 floor(exact_num_visible);
765 event_viewer_data->vadjust_c->page_size =
766 floor(exact_num_visible);
767 */
768
769 if(event_viewer_data->num_visible_events != last_num_visible_events)
770 {
771 get_test_data(event_viewer_data->vadjust_c->value,
772 event_viewer_data->num_visible_events,
773 event_viewer_data);
774 }
775
776
777 }
778
779 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
780 {
781 gint h;
782 EventViewerData *event_viewer_data = (EventViewerData*)data;
783 gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
784
785 h = cell_height + event_viewer_data->header_height;
786 requisition->height = h;
787
788 }
789
790 #if 0
791 gboolean show_event_detail(void * hook_data, void * call_data)
792 {
793 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
794 LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
795
796 if(event_viewer_data->raw_trace_data_queue_tmp->length == 0 &&
797 event_viewer_data->raw_trace_data_queue->length == 0){
798 event_viewer_data->shown = FALSE;
799 return FALSE;
800 }
801
802 if(event_viewer_data->shown == FALSE){
803 event_viewer_data->shown = TRUE;
804 update_raw_data_array(event_viewer_data,
805 event_viewer_data->raw_trace_data_queue_tmp->length);
806
807 get_test_data(event_viewer_data->vadjust_c->value,
808 event_viewer_data->num_visible_events,
809 event_viewer_data);
810
811 remove_context_hooks(event_viewer_data,tsc);
812 }
813
814 return FALSE;
815 }
816 #endif //0
817
818
819 void insert_data_into_model(EventViewerData *event_viewer_data, int start, int end)
820 {
821 int i;
822 guint64 real_data;
823 RawTraceData * raw_data;
824 GList * first;
825 GtkTreeIter iter;
826
827 first = event_viewer_data->raw_trace_data_queue->head;
828 for(i=start; i<end; i++){
829 if(i>=event_viewer_data->number_of_events) break;
830 raw_data = (RawTraceData*)g_list_nth_data(first, i);
831
832 // Add a new row to the model
833 real_data = raw_data->time.tv_sec;
834 real_data *= NANOSECONDS_PER_SECOND;
835 real_data += raw_data->time.tv_nsec;
836 gtk_list_store_append (event_viewer_data->store_m, &iter);
837 gtk_list_store_set (event_viewer_data->store_m, &iter,
838 CPUID_COLUMN, raw_data->cpu_id,
839 EVENT_COLUMN, raw_data->event_name,
840 TIME_COLUMN, real_data,
841 PID_COLUMN, raw_data->pid,
842 ENTRY_LEN_COLUMN, raw_data->entry_length,
843 EVENT_DESCR_COLUMN, raw_data->event_description,
844 -1);
845 }
846 }
847
848 static void get_test_data_wrapped(double time_value, guint list_height,
849 EventViewerData *event_viewer_data, LttEvent *ev);
850 void get_test_data(double time_value, guint list_height,
851 EventViewerData *event_viewer_data)
852 {
853 LttEvent * ev = ltt_event_new();
854
855 get_test_data_wrapped(time_value, list_height,
856 event_viewer_data, ev);
857
858 ltt_event_destroy(ev);
859 }
860
861 static void get_test_data_wrapped(double time_value, guint list_height,
862 EventViewerData *event_viewer_data, LttEvent *ev)
863 {
864 GtkTreeIter iter;
865 int i;
866 GtkTreeModel *model = GTK_TREE_MODEL(event_viewer_data->store_m);
867 GtkTreePath *tree_path;
868 RawTraceData * raw_data;
869 ScrollDirection direction = SCROLL_NONE;
870 GList * first;
871 int event_number;
872 double value = event_viewer_data->previous_value - time_value;
873 LttTime start, end, time;
874 unsigned backward_num, minNum, maxNum;
875 LttTracefile * tf;
876 unsigned block_num, event_num;
877 unsigned size = 1, count = 0;
878 gboolean need_backward_again, backward;
879 GdkWindow * win;
880 //GdkCursor * new;
881 GtkWidget* widget = gtk_widget_get_parent(event_viewer_data->hbox_v);
882 LttvTracesetContext * tsc =
883 lttvwindow_get_traceset_context(event_viewer_data->tab);
884 TimeInterval time_span = tsc->time_span;
885
886 //if(widget){
887 // new = gdk_cursor_new(GDK_X_CURSOR);
888 // win = gtk_widget_get_parent_window(widget);
889 // gdk_window_set_cursor(win, new);
890 // gdk_cursor_unref(new);
891 // gdk_window_stick(win);
892 // gdk_window_unstick(win);
893 //}
894
895
896 // if(event_number > event_viewer_data->last_event ||
897 // event_number + list_height-1 < event_viewer_data->first_event ||
898 // event_viewer_data->first_event == -1)
899 {
900 /* no event can be reused, clear and start from nothing */
901 if(value == -1.0) direction = SCROLL_STEP_DOWN;
902 else if(value == 1.0 ) direction = SCROLL_STEP_UP;
903 else if(value == -2.0) direction = SCROLL_PAGE_DOWN;
904 else if(value == 2.0 ) direction = SCROLL_PAGE_UP;
905 else if(value == 0.0 ) direction = SCROLL_NONE;
906 else direction = SCROLL_JUMP;
907
908 switch(direction){
909 case SCROLL_STEP_UP:
910 case SCROLL_PAGE_UP:
911 if(direction == SCROLL_PAGE_UP){
912 backward = list_height>event_viewer_data->start_event_index ? TRUE : FALSE;
913 }else{
914 backward = event_viewer_data->start_event_index == 0 ? TRUE : FALSE;
915 }
916 if(backward){
917 event_viewer_data->append = FALSE;
918 do{
919 if(direction == SCROLL_PAGE_UP){
920 minNum = list_height - event_viewer_data->start_event_index ;
921 }else{
922 minNum = 1;
923 }
924
925 first = event_viewer_data->raw_trace_data_queue->head;
926 if(!first)break;
927 raw_data = (RawTraceData*)g_list_nth_data(first,0);
928 end = raw_data->time;
929 if(end.tv_nsec != 0)
930 end.tv_nsec--;
931 else
932 end.tv_sec--; // even if tv_sec == 0, wrapping should give a real big
933 // value, so will read all the trace.
934 ltt_event_position_get(raw_data->ep, &block_num, &event_num, &tf);
935 if(size !=0){
936 if(event_num > minNum){
937 backward_num = event_num > RESERVE_SMALL_SIZE
938 ? event_num - RESERVE_SMALL_SIZE : 1;
939 ltt_event_position_set(raw_data->ep, block_num, backward_num);
940 ltt_tracefile_seek_position(tf, raw_data->ep);
941 g_assert(ltt_tracefile_read(tf,ev) != NULL);
942 start = ltt_event_time(ev);
943 maxNum = RESERVE_SMALL_SIZE_CUBE;
944 }else{
945 if(block_num > 1){
946 ltt_event_position_set(raw_data->ep, block_num-1, 1);
947 ltt_tracefile_seek_position(tf, raw_data->ep);
948 g_assert(ltt_tracefile_read(tf,ev) != NULL);
949 start = ltt_event_time(ev);
950 }else{
951 start.tv_sec = 0;
952 start.tv_nsec = 0;
953 }
954 maxNum = RESERVE_SMALL_SIZE_CUBE;
955 }
956 }else{
957 if(block_num > count){
958 ltt_event_position_set(raw_data->ep, block_num-count, 1);
959 ltt_tracefile_seek_position(tf, raw_data->ep);
960 g_assert(ltt_tracefile_read(tf, ev) != NULL);
961 start = ltt_event_time(ev);
962 }else{
963 start.tv_sec = 0;
964 start.tv_nsec = 0;
965 }
966 maxNum = RESERVE_SMALL_SIZE_CUBE;
967 }
968
969 event_viewer_data->current_event_index = event_viewer_data->start_event_index;
970 get_events(event_viewer_data, start, end, maxNum, &size);
971 event_viewer_data->start_event_index = event_viewer_data->current_event_index;
972
973 if(size < minNum && (start.tv_sec !=0 || start.tv_nsec !=0))
974 need_backward_again = TRUE;
975 else need_backward_again = FALSE;
976 if(size == 0){
977 count++;
978 }else{
979 count = 0;
980 }
981 }while(need_backward_again);
982 }
983 if(direction == SCROLL_STEP_UP)
984 event_number = event_viewer_data->start_event_index - 1;
985 else
986 event_number = event_viewer_data->start_event_index - list_height;
987 break;
988 case SCROLL_STEP_DOWN:
989 if(event_viewer_data->end_event_index == event_viewer_data->number_of_events - 1){
990 event_viewer_data->append = TRUE;
991 first = event_viewer_data->raw_trace_data_queue->head;
992 if(!first)break;
993 raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
994 start = raw_data->time;
995 start.tv_nsec++;
996 end.tv_sec = G_MAXULONG;
997 end.tv_nsec = G_MAXULONG;
998 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE, &size);
999 if(size == 0){
1000 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_SQUARE,&size);
1001 if(size == 0)
1002 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_CUBE,&size);
1003 }
1004 if(size==0) event_number = event_viewer_data->start_event_index;
1005 else event_number = event_viewer_data->number_of_events - size - list_height + 1;
1006 }else event_number = event_viewer_data->start_event_index + 1;
1007 break;
1008 case SCROLL_PAGE_DOWN:
1009 i = event_viewer_data->number_of_events - 1 - list_height;
1010 if((gint)(event_viewer_data->end_event_index) >= i){
1011 int remain_events = event_viewer_data->number_of_events - 1
1012 - event_viewer_data->end_event_index;
1013 event_viewer_data->append = TRUE;
1014 first = event_viewer_data->raw_trace_data_queue->head;
1015 if(!first)break;
1016 raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
1017 start = raw_data->time;
1018 start.tv_nsec++;
1019 end.tv_sec = G_MAXULONG;
1020 end.tv_nsec = G_MAXULONG;
1021 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
1022 if(size == 0){
1023 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_SQUARE,&size);
1024 if(size == 0)
1025 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_CUBE,&size);
1026 }
1027 remain_events += size;
1028 if(list_height <= remain_events)
1029 event_number = event_viewer_data->number_of_events - remain_events - 1;
1030 else
1031 event_number = event_viewer_data->number_of_events - 1 - list_height;
1032 }else event_number = event_viewer_data->start_event_index + list_height - 1;
1033 break;
1034 case SCROLL_JUMP:
1035 event_viewer_data->append = TRUE;
1036 remove_all_items_from_queue(event_viewer_data->raw_trace_data_queue);
1037 end.tv_sec = G_MAXULONG;
1038 end.tv_nsec = G_MAXULONG;
1039 time = ltt_time_from_double(time_value / NANOSECONDS_PER_SECOND);
1040 start = ltt_time_add(time_span.start_time, time);
1041 event_viewer_data->previous_value = time_value;
1042 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
1043 if(size < list_height && size > 0){
1044 event_viewer_data->append = FALSE;
1045 first = event_viewer_data->raw_trace_data_queue->head;
1046 if(!first)break;
1047 raw_data = (RawTraceData*)g_list_nth_data(first,0);
1048 end = raw_data->time;
1049 end.tv_nsec--;
1050 ltt_event_position_get(raw_data->ep, &block_num, &event_num, &tf);
1051
1052 if(event_num > list_height - size){
1053 backward_num = event_num > RESERVE_SMALL_SIZE
1054 ? event_num - RESERVE_SMALL_SIZE : 1;
1055 ltt_event_position_set(raw_data->ep, block_num, backward_num);
1056 ltt_tracefile_seek_position(tf, raw_data->ep);
1057 g_assert(ltt_tracefile_read(tf,ev) != NULL);
1058 start = ltt_event_time(ev);
1059 maxNum = RESERVE_SMALL_SIZE_CUBE;
1060 event_viewer_data->current_event_index = 0;
1061 get_events(event_viewer_data, start, end, maxNum, &size);
1062 event_viewer_data->start_event_index = event_viewer_data->current_event_index;
1063 }
1064 event_number = event_viewer_data->raw_trace_data_queue->length - list_height;
1065 }else if(size == 0){
1066 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_SQUARE,&size);
1067 if(size == 0)
1068 get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE_CUBE,&size);
1069 event_number = 0;
1070 }else{
1071 event_number = 0;
1072 }
1073 break;
1074 case SCROLL_NONE:
1075 event_number = event_viewer_data->current_event_index;
1076 break;
1077 default:
1078 break;
1079 }
1080
1081 if(event_number < 0) event_number = 0;
1082
1083 //update the value of the scroll bar
1084 if(direction != SCROLL_NONE && direction != SCROLL_JUMP){
1085 first = event_viewer_data->raw_trace_data_queue->head;
1086 if(first){
1087 raw_data = (RawTraceData*)g_list_nth_data(first,event_number);
1088 if(!raw_data) raw_data = (RawTraceData*)g_list_nth_data(first,0);
1089 time = ltt_time_sub(raw_data->time, time_span.start_time);
1090 event_viewer_data->vadjust_c->value = ltt_time_to_double(time) * NANOSECONDS_PER_SECOND;
1091 g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
1092 event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
1093 }
1094 }
1095
1096
1097 event_viewer_data->start_event_index = event_number;
1098 event_viewer_data->end_event_index = event_number + list_height - 1;
1099 if(event_viewer_data->end_event_index > event_viewer_data->number_of_events - 1){
1100 event_viewer_data->end_event_index = event_viewer_data->number_of_events - 1;
1101 }
1102
1103 first = event_viewer_data->raw_trace_data_queue->head;
1104 gtk_list_store_clear(event_viewer_data->store_m);
1105 if(!first){
1106 // event_viewer_data->previous_value = 0;
1107 // event_viewer_data->vadjust_c->value = 0.0;
1108 // gtk_widget_hide(event_viewer_data->vscroll_vc);
1109 goto LAST;
1110 }else gtk_widget_show(event_viewer_data->vscroll_vc);
1111
1112 insert_data_into_model(event_viewer_data,event_number, event_number+list_height);
1113 }
1114 #ifdef DEBUG //do not use this, it's slower and broken
1115 // } else {
1116 /* Some events will be reused */
1117 if(event_number < event_viewer_data->first_event)
1118 {
1119 /* scrolling up, prepend events */
1120 tree_path = gtk_tree_path_new_from_indices
1121 (event_number+list_height-1 -
1122 event_viewer_data->first_event + 1,
1123 -1);
1124 for(i=0; i<event_viewer_data->last_event-(event_number+list_height-1);
1125 i++)
1126 {
1127 /* Remove the last events from the list */
1128 if(gtk_tree_model_get_iter(model, &iter, tree_path))
1129 gtk_list_store_remove(event_viewer_data->store_m, &iter);
1130 }
1131
1132 for(i=event_viewer_data->first_event-1; i>=event_number; i--)
1133 {
1134 if(i>=event_viewer_data->number_of_events) break;
1135 /* Prepend new events */
1136 gtk_list_store_prepend (event_viewer_data->store_m, &iter);
1137 gtk_list_store_set (event_viewer_data->store_m, &iter,
1138 CPUID_COLUMN, 0,
1139 EVENT_COLUMN, "event irq",
1140 TIME_COLUMN, i,
1141 PID_COLUMN, 100,
1142 ENTRY_LEN_COLUMN, 17,
1143 EVENT_DESCR_COLUMN, "Detailed information",
1144 -1);
1145 }
1146 } else {
1147 /* Scrolling down, append events */
1148 for(i=event_viewer_data->first_event; i<event_number; i++)
1149 {
1150 /* Remove these events from the list */
1151 gtk_tree_model_get_iter_first(model, &iter);
1152 gtk_list_store_remove(event_viewer_data->store_m, &iter);
1153 }
1154 for(i=event_viewer_data->last_event+1; i<event_number+list_height; i++)
1155 {
1156 if(i>=event_viewer_data->number_of_events) break;
1157 /* Append new events */
1158 gtk_list_store_append (event_viewer_data->store_m, &iter);
1159 gtk_list_store_set (event_viewer_data->store_m, &iter,
1160 CPUID_COLUMN, 0,
1161 EVENT_COLUMN, "event irq",
1162 TIME_COLUMN, i,
1163 PID_COLUMN, 100,
1164 ENTRY_LEN_COLUMN, 17,
1165 EVENT_DESCR_COLUMN, "Detailed information",
1166 -1);
1167 }
1168
1169 }
1170 //}
1171 #endif //DEBUG
1172 event_viewer_data->first_event = event_viewer_data->start_event_index ;
1173 event_viewer_data->last_event = event_viewer_data->end_event_index ;
1174
1175 LAST:
1176 return;
1177 // if(widget)
1178 // gdk_window_set_cursor(win, NULL);
1179
1180 }
1181
1182 void add_test_data(EventViewerData *event_viewer_data)
1183 {
1184 GtkTreeIter iter;
1185 int i;
1186
1187 for(i=0; i<10; i++)
1188 {
1189 /* Add a new row to the model */
1190 gtk_list_store_append (event_viewer_data->store_m, &iter);
1191 gtk_list_store_set (event_viewer_data->store_m, &iter,
1192 CPUID_COLUMN, 0,
1193 EVENT_COLUMN, "event irq",
1194 TIME_COLUMN, i,
1195 PID_COLUMN, 100,
1196 ENTRY_LEN_COLUMN, 17,
1197 EVENT_DESCR_COLUMN, "Detailed information",
1198 -1);
1199 }
1200
1201 }
1202
1203 void
1204 gui_events_free(EventViewerData *event_viewer_data)
1205 {
1206 Tab *tab = event_viewer_data->tab;
1207
1208 if(event_viewer_data){
1209 lttv_hooks_remove(event_viewer_data->event_hooks,parse_event);
1210 lttv_hooks_destroy(event_viewer_data->event_hooks);
1211
1212 remove_all_items_from_queue (event_viewer_data->raw_trace_data_queue);
1213 g_queue_free(event_viewer_data->raw_trace_data_queue);
1214 g_queue_free(event_viewer_data->raw_trace_data_queue_tmp);
1215
1216 lttvwindow_unregister_time_window_notify(tab,
1217 update_time_window, event_viewer_data);
1218 lttvwindow_unregister_current_time_notify(tab,
1219 update_current_time, event_viewer_data);
1220 //lttvwindow_unregister_show_notify(tab,
1221 // show_event_detail, event_viewer_data);
1222 lttvwindow_unregister_traceset_notify(tab,
1223 traceset_changed, event_viewer_data);
1224
1225 g_free(event_viewer_data->filter_key);
1226 g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list, event_viewer_data);
1227 g_free(event_viewer_data);
1228 }
1229 }
1230
1231 void
1232 gui_events_destructor(EventViewerData *event_viewer_data)
1233 {
1234 guint index;
1235
1236 /* May already been done by GTK window closing */
1237 if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
1238 gui_events_free(event_viewer_data);
1239 gtk_widget_destroy(event_viewer_data->hbox_v);
1240 event_viewer_data = NULL;
1241 }
1242
1243 /* Destroy the Tree View */
1244 //gtk_widget_destroy(event_viewer_data->tree_v);
1245
1246 /* Clear raw event list */
1247 //gtk_list_store_clear(event_viewer_data->store_m);
1248 //gtk_widget_destroy(GTK_WIDGET(event_viewer_data->store_m));
1249
1250 //gui_events_free(event_viewer_data);
1251 }
1252
1253 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1254
1255 static void
1256 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1257 {
1258 EventViewerData *event_viewer_data = (EventViewerData*)data;
1259 GtkTreeIter iter;
1260 GtkTreeModel *model = GTK_TREE_MODEL(event_viewer_data->store_m);
1261 gchar *event;
1262
1263 if (gtk_tree_selection_get_selected (selection, &model, &iter))
1264 {
1265 gtk_tree_model_get (model, &iter, EVENT_COLUMN, &event, -1);
1266
1267 g_free (event);
1268 }
1269 }
1270
1271
1272 int event_selected_hook(void *hook_data, void *call_data)
1273 {
1274 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1275 guint *event_number = (guint*) call_data;
1276
1277 event_viewer_data->currently_selected_event = *event_number;
1278 event_viewer_data->selected_event = TRUE ;
1279
1280 tree_v_set_cursor(event_viewer_data);
1281
1282 }
1283
1284 /* If every module uses the filter, maybe these two
1285 * (add/remove_context_hooks functions) should be put in common place
1286 */
1287 void add_context_hooks(EventViewerData * event_viewer_data,
1288 LttvTracesetContext * tsc)
1289 {
1290 gint i, j, k, m,n, nbi, id;
1291 gint nb_tracefile, nb_facility, nb_event;
1292 LttTrace *trace;
1293 LttvTraceContext *tc;
1294 LttvTracefileContext *tfc;
1295 LttvTracesetSelector * ts_s;
1296 LttvTraceSelector * t_s;
1297 LttvTracefileSelector * tf_s;
1298 gboolean selected;
1299 LttFacility * fac;
1300 LttEventType * et;
1301 LttvEventtypeSelector * eventtype;
1302
1303 ts_s = (LttvTracesetSelector*)g_object_get_data(G_OBJECT(event_viewer_data->hbox_v),
1304 event_viewer_data->filter_key);
1305
1306 //if there are hooks for traceset, add them here
1307
1308 nbi = lttv_traceset_number(tsc->ts);
1309 for(i = 0 ; i < nbi ; i++) {
1310 t_s = lttv_traceset_selector_trace_get(ts_s,i);
1311 selected = lttv_trace_selector_get_selected(t_s);
1312 if(!selected) continue;
1313 tc = tsc->traces[i];
1314 trace = tc->t;
1315 //if there are hooks for trace, add them here
1316
1317 nb_tracefile = ltt_trace_control_tracefile_number(trace) +
1318 ltt_trace_per_cpu_tracefile_number(trace);
1319
1320 for(j = 0 ; j < nb_tracefile ; j++) {
1321 tf_s = lttv_trace_selector_tracefile_get(t_s,j);
1322 selected = lttv_tracefile_selector_get_selected(tf_s);
1323 if(!selected) continue;
1324 tfc = tc->tracefiles[j];
1325
1326 //if there are hooks for tracefile, add them here
1327 // lttv_tracefile_context_add_hooks(tfc, NULL,NULL,NULL,NULL,
1328 // event_viewer_data->event_hooks,NULL);
1329
1330 nb_facility = ltt_trace_facility_number(trace);
1331 n = 0;
1332 for(k=0;k<nb_facility;k++){
1333 fac = ltt_trace_facility_get(trace,k);
1334 nb_event = (int) ltt_facility_eventtype_number(fac);
1335 for(m=0;m<nb_event;m++){
1336 et = ltt_facility_eventtype_get(fac,m);
1337 eventtype = lttv_tracefile_selector_eventtype_get(tf_s, n);
1338 selected = lttv_eventtype_selector_get_selected(eventtype);
1339 if(selected){
1340 id = (gint) ltt_eventtype_id(et);
1341 lttv_tracefile_context_add_hooks_by_id(tfc,id,
1342 event_viewer_data->event_hooks);
1343 }
1344 n++;
1345 }
1346 }
1347
1348 }
1349 }
1350
1351 //add hooks for process_traceset
1352 // lttv_traceset_context_add_hooks(tsc, NULL, NULL, NULL, NULL, NULL, NULL,
1353 // NULL, NULL, NULL,event_viewer_data->event_hooks,NULL);
1354 }
1355
1356
1357 void remove_context_hooks(EventViewerData * event_viewer_data,
1358 LttvTracesetContext * tsc)
1359 {
1360 gint i, j, k, m, nbi, n, id;
1361 gint nb_tracefile, nb_facility, nb_event;
1362 LttTrace *trace;
1363 LttvTraceContext *tc;
1364 LttvTracefileContext *tfc;
1365 LttvTracesetSelector * ts_s;
1366 LttvTraceSelector * t_s;
1367 LttvTracefileSelector * tf_s;
1368 gboolean selected;
1369 LttFacility * fac;
1370 LttEventType * et;
1371 LttvEventtypeSelector * eventtype;
1372
1373 ts_s = (LttvTracesetSelector*)g_object_get_data(G_OBJECT(event_viewer_data->hbox_v),
1374 event_viewer_data->filter_key);
1375
1376 //if there are hooks for traceset, remove them here
1377
1378 nbi = lttv_traceset_number(tsc->ts);
1379 for(i = 0 ; i < nbi ; i++) {
1380 t_s = lttv_traceset_selector_trace_get(ts_s,i);
1381 selected = lttv_trace_selector_get_selected(t_s);
1382 if(!selected) continue;
1383 tc = tsc->traces[i];
1384 trace = tc->t;
1385 //if there are hooks for trace, remove them here
1386
1387 nb_tracefile = ltt_trace_control_tracefile_number(trace) +
1388 ltt_trace_per_cpu_tracefile_number(trace);
1389
1390 for(j = 0 ; j < nb_tracefile ; j++) {
1391 tf_s = lttv_trace_selector_tracefile_get(t_s,j);
1392 selected = lttv_tracefile_selector_get_selected(tf_s);
1393 if(!selected) continue;
1394 tfc = tc->tracefiles[j];
1395
1396 //if there are hooks for tracefile, remove them here
1397 // lttv_tracefile_context_remove_hooks(tfc, NULL,NULL,NULL,NULL,
1398 // event_viewer_data->event_hooks,NULL);
1399
1400 nb_facility = ltt_trace_facility_number(trace);
1401 n = 0;
1402 for(k=0;k<nb_facility;k++){
1403 fac = ltt_trace_facility_get(trace,k);
1404 nb_event = (int) ltt_facility_eventtype_number(fac);
1405 for(m=0;m<nb_event;m++){
1406 et = ltt_facility_eventtype_get(fac,m);
1407 eventtype = lttv_tracefile_selector_eventtype_get(tf_s, n);
1408 selected = lttv_eventtype_selector_get_selected(eventtype);
1409 if(selected){
1410 id = (gint) ltt_eventtype_id(et);
1411 lttv_tracefile_context_remove_hooks_by_id(tfc,id);
1412 }
1413 n++;
1414 }
1415 }
1416 }
1417 }
1418 //remove hooks from context
1419 // lttv_traceset_context_remove_hooks(tsc, NULL, NULL, NULL, NULL, NULL, NULL,
1420 // NULL, NULL, NULL,event_viewer_data->event_hooks,NULL);
1421 }
1422
1423
1424 gboolean update_time_window(void * hook_data, void * call_data)
1425 {
1426 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1427 const TimeWindowNotifyData *time_window_notify_data;
1428 LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
1429
1430 if(event_viewer_data->shown == FALSE){
1431 //event_viewer_data->time_window = *(TimeWindow*)call_data;
1432
1433 //add_context_hooks(event_viewer_data, tsc);
1434 }
1435
1436 return FALSE;
1437 }
1438
1439 gboolean update_current_time(void * hook_data, void * call_data)
1440 {
1441 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1442 const LttTime * current_time = (LttTime*)call_data;
1443 guint64 nsec = current_time->tv_sec * NANOSECONDS_PER_SECOND
1444 + current_time->tv_nsec;
1445 GtkTreeIter iter;
1446 guint64 time;
1447 int count = -1;
1448 GtkTreeModel* model = (GtkTreeModel*)event_viewer_data->store_m;
1449 GList * list;
1450 RawTraceData * data, *data1;
1451 GtkTreePath* path;
1452 char str_path[64];
1453 int i, j;
1454 LttTime t;
1455 LttvTracesetContext * tsc =
1456 lttvwindow_get_traceset_context(event_viewer_data->tab);
1457 TimeInterval time_span = tsc->time_span;
1458
1459 if(!event_viewer_data->raw_trace_data_queue->head) return FALSE;
1460
1461 if(event_viewer_data->current_time_updated ){
1462 event_viewer_data->current_time_updated = FALSE;
1463 return FALSE;
1464 }
1465
1466 //check if the event is shown in the current viewer
1467 if(gtk_tree_model_get_iter_first(model, &iter)){
1468 while(1){
1469 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
1470 if(time < nsec){
1471 if(!gtk_tree_model_iter_next(model, &iter)){
1472 count = -1;
1473 break;
1474 }
1475 count++;
1476 }else{
1477 break;
1478 }
1479 }
1480 // event_selected_hook(event_viewer_data, &count);
1481 }
1482
1483 //the event is not shown in the current viewer
1484 if(count == -1){
1485 count = 0;
1486 //check if the event is in the buffer
1487 list = event_viewer_data->raw_trace_data_queue->head;
1488 data = (RawTraceData*)g_list_nth_data(list,0);
1489 data1 = (RawTraceData*)g_list_nth_data(list,event_viewer_data->raw_trace_data_queue->length-1);
1490
1491 //the event is in the buffer
1492 if(ltt_time_compare(data->time, *current_time)<=0 &&
1493 ltt_time_compare(data1->time, *current_time)>=0){
1494 for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
1495 data = (RawTraceData*)g_list_nth_data(list,i);
1496 if(ltt_time_compare(data->time, *current_time) < 0){
1497 count++;
1498 continue;
1499 }
1500 break;
1501 }
1502 if(event_viewer_data->raw_trace_data_queue->length-count < event_viewer_data->num_visible_events){
1503 j = event_viewer_data->raw_trace_data_queue->length - event_viewer_data->num_visible_events;
1504 count -= j;
1505 data = (RawTraceData*)g_list_nth_data(list,j);
1506 }else{
1507 j = count;
1508 count = 0;
1509 }
1510 t = ltt_time_sub(data->time, time_span.start_time);
1511 event_viewer_data->vadjust_c->value = ltt_time_to_double(t) * NANOSECONDS_PER_SECOND;
1512 g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
1513 event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
1514 insert_data_into_model(event_viewer_data,j, j+event_viewer_data->num_visible_events);
1515 }else{//the event is not in the buffer
1516 LttTime start = ltt_time_sub(*current_time, time_span.start_time);
1517 double position = ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
1518 gtk_adjustment_set_value(event_viewer_data->vadjust_c, position);
1519 }
1520 }
1521
1522 sprintf(str_path,"%d\0",count);
1523 path = gtk_tree_path_new_from_string (str_path);
1524 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
1525 g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->tree_v), "cursor-changed");
1526 gtk_tree_path_free(path);
1527
1528 return FALSE;
1529 }
1530
1531 gboolean traceset_changed(void * hook_data, void * call_data)
1532 {
1533 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1534 LttvTracesetContext * tsc =
1535 lttvwindow_get_traceset_context(event_viewer_data->tab);
1536 TimeInterval time_span = tsc->time_span;
1537
1538 LttTime start;
1539 remove_all_items_from_queue(event_viewer_data->raw_trace_data_queue);
1540 gtk_list_store_clear(event_viewer_data->store_m);
1541 event_viewer_data->shown = FALSE;
1542 event_viewer_data->append = TRUE;
1543
1544 start = ltt_time_sub(time_span.end_time, time_span.start_time);
1545 event_viewer_data->vadjust_c->upper = ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
1546 // event_viewer_data->vadjust_c->value = 0;
1547
1548 return FALSE;
1549 }
1550
1551
1552 void tree_v_grab_focus(GtkWidget *widget, gpointer data){
1553 EventViewerData *event_viewer_data = (EventViewerData *)data;
1554 Tab * tab = event_viewer_data->tab;
1555 lttvwindow_report_focus(tab, event_viewer_data->hbox_v);
1556 }
1557
1558 void update_raw_data_array(EventViewerData* event_viewer_data, unsigned size)
1559 {
1560 RawTraceData * data;
1561 if(size > 0){
1562 int pid, tmpPid, i,j,len;
1563 GList * list, *tmpList;
1564 GArray * pid_array, * tmp_pid_array;
1565
1566 pid_array = g_array_sized_new(FALSE, TRUE, sizeof(int), 10);
1567 tmp_pid_array = g_array_sized_new(FALSE, TRUE, sizeof(int), 10);
1568
1569 //if the queue is full, remove some data, keep the size of the queue constant
1570 while(event_viewer_data->raw_trace_data_queue->length + size > RESERVE_BIG_SIZE){
1571 remove_item_from_queue(event_viewer_data->raw_trace_data_queue,
1572 event_viewer_data->append);
1573 }
1574
1575 //update pid if it is not known
1576 if(event_viewer_data->raw_trace_data_queue->length > 0){
1577 list = event_viewer_data->raw_trace_data_queue->head;
1578 tmpList = event_viewer_data->raw_trace_data_queue_tmp->head;
1579 if(event_viewer_data->append){
1580 for(i= event_viewer_data->raw_trace_data_queue->length-1;i>=0;i--){
1581 data = (RawTraceData*)g_list_nth_data(list,i);
1582 len = data->pid==0 ? -2 : data->pid;
1583 if(data->cpu_id+1 > pid_array->len){
1584 pid_array = g_array_set_size(pid_array,data->cpu_id+1);
1585 pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
1586 pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
1587 }else if(data->cpu_id+1 < pid_array->len){
1588 pid = g_array_index(pid_array,int,data->cpu_id);
1589 if(pid == 0){
1590 pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
1591 pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
1592 }
1593 }
1594 }
1595
1596 for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1597 data = (RawTraceData*)g_list_nth_data(tmpList,i);
1598 len = data->pid==0 ? -2 : data->pid;
1599 if(data->cpu_id+1 > tmp_pid_array->len){
1600 tmp_pid_array = g_array_set_size(tmp_pid_array,data->cpu_id+1);
1601 tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
1602 tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
1603 }else if(data->cpu_id+1 < tmp_pid_array->len){
1604 pid = g_array_index(tmp_pid_array,int,data->cpu_id);
1605 if(pid == 0){
1606 tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
1607 tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
1608 }
1609 }
1610 }
1611 }else{
1612 for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
1613 data = (RawTraceData*)g_list_nth_data(list,i);
1614 len = data->pid==0 ? -2 : data->pid;
1615 if(data->cpu_id+1 > pid_array->len){
1616 pid_array = g_array_set_size(pid_array,data->cpu_id+1);
1617 pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
1618 pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
1619 }else if(data->cpu_id+1 < pid_array->len){
1620 pid = g_array_index(pid_array,int,data->cpu_id);
1621 if(pid == 0){
1622 pid_array = g_array_insert_val(pid_array,data->cpu_id,len);
1623 pid_array = g_array_remove_index(pid_array,data->cpu_id+1);
1624 }
1625 }
1626 }
1627
1628 for(i=event_viewer_data->raw_trace_data_queue_tmp->length-1;i>=0;i--){
1629 data = (RawTraceData*)g_list_nth_data(tmpList,i);
1630 len = data->pid==0 ? -2 : data->pid;
1631 if(data->cpu_id+1 > tmp_pid_array->len){
1632 tmp_pid_array = g_array_set_size(tmp_pid_array,data->cpu_id+1);
1633 tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
1634 tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
1635 }else if(data->cpu_id+1 < tmp_pid_array->len){
1636 pid = g_array_index(tmp_pid_array,int,data->cpu_id);
1637 if(pid == 0){
1638 tmp_pid_array = g_array_insert_val(tmp_pid_array,data->cpu_id,len);
1639 tmp_pid_array = g_array_remove_index(tmp_pid_array,data->cpu_id+1);
1640 }
1641 }
1642 }
1643 }
1644
1645 len = pid_array->len > tmp_pid_array->len ? tmp_pid_array->len : pid_array->len;
1646 for(j=0;j<len;j++){
1647 pid = g_array_index(pid_array,int, j);
1648 tmpPid = g_array_index(tmp_pid_array,int,j);
1649 if(pid == -2)pid = 0;
1650 if(tmpPid == -2) tmpPid = 0;
1651
1652 if(pid == -1 && tmpPid != -1){
1653 for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
1654 data = (RawTraceData*)g_list_nth_data(list,i);
1655 if(data->pid == -1 && data->cpu_id == j) data->pid = tmpPid;
1656 }
1657 }else if(pid != -1 && tmpPid == -1){
1658 for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1659 data = (RawTraceData*)g_list_nth_data(tmpList,i);
1660 if(data->pid == -1 && data->cpu_id == j) data->pid = pid;
1661 }
1662 }
1663 }
1664 }
1665
1666 g_array_free(pid_array,TRUE);
1667 g_array_free(tmp_pid_array, TRUE);
1668
1669 //add data from tmp queue into the queue
1670 event_viewer_data->number_of_events = event_viewer_data->raw_trace_data_queue->length
1671 + event_viewer_data->raw_trace_data_queue_tmp->length;
1672 if(event_viewer_data->append){
1673 if(event_viewer_data->raw_trace_data_queue->length > 0)
1674 event_viewer_data->current_event_index = event_viewer_data->raw_trace_data_queue->length - 1;
1675 else event_viewer_data->current_event_index = 0;
1676 while((data = g_queue_pop_head(event_viewer_data->raw_trace_data_queue_tmp)) != NULL){
1677 g_queue_push_tail(event_viewer_data->raw_trace_data_queue, data);
1678 }
1679 }else{
1680 event_viewer_data->current_event_index += event_viewer_data->raw_trace_data_queue_tmp->length;
1681 while((data = g_queue_pop_tail(event_viewer_data->raw_trace_data_queue_tmp)) != NULL){
1682 g_queue_push_head(event_viewer_data->raw_trace_data_queue, data);
1683 }
1684 }
1685 }
1686 }
1687
1688 void get_events(EventViewerData* event_viewer_data, LttTime start,
1689 LttTime end,unsigned max_num_events, unsigned * real_num_events)
1690 {
1691 LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
1692 Tab *tab = event_viewer_data->tab;
1693
1694 //add_context_hooks(event_viewer_data,tsc);
1695 //seek state because we use the main window's traceset context.
1696 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc), start);
1697 lttv_process_traceset_middle(tsc, start, G_MAXUINT, NULL);
1698 lttv_process_traceset_begin(tsc,
1699 NULL,
1700 NULL,
1701 NULL,
1702 event_viewer_data->event_hooks,
1703 NULL);
1704
1705 lttv_process_traceset_middle(tsc, ltt_time_infinite, max_num_events, NULL);
1706
1707 //remove_context_hooks(event_viewer_data,tsc);
1708 lttv_process_traceset_end(tsc,
1709 NULL,
1710 NULL,
1711 NULL,
1712 event_viewer_data->event_hooks,
1713 NULL);
1714 int size;
1715
1716 size = event_viewer_data->raw_trace_data_queue_tmp->length;
1717 *real_num_events = size;
1718
1719 update_raw_data_array(event_viewer_data,size);
1720
1721 #if 0
1722 EventsRequest *events_request = g_new(EventsRequest, 1);
1723 // Create the hooks
1724 LttvHooks *event = lttv_hooks_new();
1725 LttvHooks *after_request = lttv_hooks_new();
1726
1727 lttv_hooks_add(after_request,
1728 after_get_events,
1729 events_request,
1730 LTTV_PRIO_DEFAULT);
1731 lttv_hooks_add(event,
1732 parse_event,
1733 event_viewer_data,
1734 LTTV_PRIO_DEFAULT);
1735
1736 // Fill the events request
1737 events_request->owner = event_viewer_data;
1738 events_request->viewer_data = event_viewer_data;
1739 events_request->servicing = FALSE;
1740 events_request->start_time = start;
1741 events_request->start_position = NULL;
1742 events_request->stop_flag = FALSE;
1743 events_request->end_time = ltt_time_infinite;
1744 events_request->num_events = max_num_events;
1745 events_request->end_position = NULL;
1746 events_request->before_chunk_traceset = NULL;
1747 events_request->before_chunk_trace = NULL;
1748 events_request->before_chunk_tracefile = NULL;
1749 events_request->event = event;
1750 events_request->event_by_id = NULL;
1751 events_request->after_chunk_tracefile = NULL;
1752 events_request->after_chunk_trace = NULL;
1753 events_request->after_chunk_traceset = NULL;
1754 events_request->before_request = NULL;
1755 events_request->after_request = after_request;
1756
1757 g_debug("req : start : %u, %u", start.tv_sec,
1758 start.tv_nsec);
1759
1760 lttvwindow_events_request_remove_all(tab,
1761 event_viewer_data);
1762 lttvwindow_events_request(tab, events_request);
1763 #endif //0
1764 }
1765 #if 0
1766 int after_get_events(void *hook_data, void *call_data)
1767 {
1768 EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
1769 int size;
1770
1771 size = event_viewer_data->raw_trace_data_queue_tmp->length;
1772 *real_num_events = size;
1773
1774 update_raw_data_array(event_viewer_data,size);
1775 }
1776 #endif //0
1777
1778 static void get_event_detail(LttEvent *e, LttField *f, GString * s)
1779 {
1780 LttType *type;
1781 LttField *element;
1782 char *name;
1783 int nb, i;
1784
1785 type = ltt_field_type(f);
1786 switch(ltt_type_class(type)) {
1787 case LTT_INT:
1788 g_string_append_printf(s, " %ld", ltt_event_get_long_int(e,f));
1789 break;
1790
1791 case LTT_UINT:
1792 g_string_append_printf(s, " %lu", ltt_event_get_long_unsigned(e,f));
1793 break;
1794
1795 case LTT_FLOAT:
1796 g_string_append_printf(s, " %g", ltt_event_get_double(e,f));
1797 break;
1798
1799 case LTT_STRING:
1800 g_string_append_printf(s, " \"%s\"", ltt_event_get_string(e,f));
1801 break;
1802
1803 case LTT_ENUM:
1804 g_string_append_printf(s, " %s", ltt_enum_string_get(type,
1805 ltt_event_get_unsigned(e,f)-1));
1806 break;
1807
1808 case LTT_ARRAY:
1809 case LTT_SEQUENCE:
1810 g_string_append_printf(s, " {");
1811 nb = ltt_event_field_element_number(e,f);
1812 element = ltt_field_element(f);
1813 for(i = 0 ; i < nb ; i++) {
1814 ltt_event_field_element_select(e,f,i);
1815 get_event_detail(e, element, s);
1816 }
1817 g_string_append_printf(s, " }");
1818 break;
1819
1820 case LTT_STRUCT:
1821 g_string_append_printf(s, " {");
1822 nb = ltt_type_member_number(type);
1823 for(i = 0 ; i < nb ; i++) {
1824 element = ltt_field_member(f,i);
1825 ltt_type_member_type(type, i, &name);
1826 g_string_append_printf(s, " %s = ", name);
1827 get_event_detail(e, element, s);
1828 }
1829 g_string_append_printf(s, " }");
1830 break;
1831 }
1832
1833 }
1834
1835 static void get_pid(unsigned * in, unsigned * out, char * s)
1836 {
1837 char * str;
1838 str = strstr(s, "out =");
1839 if (str){
1840 str = str + 5;
1841 sscanf(str,"%d", out);
1842 }else{
1843 g_warning("Can not find out pid\n");
1844 }
1845
1846 str = strstr(s,"in =");
1847 if (str){
1848 str = str + 4;
1849 sscanf(str,"%d", in);
1850 }else{
1851 g_warning("Can not find in pid\n");
1852 }
1853 }
1854
1855 gboolean parse_event(void *hook_data, void *call_data)
1856 {
1857 EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
1858 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1859 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1860
1861 RawTraceData * tmp_raw_trace_data,*prev_raw_trace_data = NULL, *data=NULL;
1862 LttEvent *e;
1863 LttTime time;
1864 LttField * field;
1865 unsigned in=0, out=0;
1866 int i;
1867 GString * detail_event = g_string_new("");
1868 GList * list;
1869
1870 e = tfc->e;
1871 field = ltt_event_field(e);
1872 time = ltt_event_time(e);
1873
1874 tmp_raw_trace_data = g_new(RawTraceData,1);
1875 tmp_raw_trace_data->cpu_id = ltt_event_cpu_id(e);
1876 tmp_raw_trace_data->event_name = g_strdup(ltt_eventtype_name(ltt_event_eventtype(e)));
1877 tmp_raw_trace_data->time = time;
1878 tmp_raw_trace_data->ep = ltt_event_position_new();
1879
1880 if(event_viewer_data->raw_trace_data_queue_tmp->length){
1881 list = event_viewer_data->raw_trace_data_queue_tmp->head;
1882 for(i=event_viewer_data->raw_trace_data_queue_tmp->length-1;i>=0;i--){
1883 data = (RawTraceData *)g_list_nth_data(list,i);
1884 if(data->cpu_id == tmp_raw_trace_data->cpu_id){
1885 prev_raw_trace_data = data;
1886 break;
1887 }
1888 }
1889 }
1890
1891 if(prev_raw_trace_data) tmp_raw_trace_data->pid = prev_raw_trace_data->pid;
1892 else tmp_raw_trace_data->pid = -1;
1893
1894 tmp_raw_trace_data->entry_length = field == NULL ? 0 : ltt_field_size(field);
1895 if(field) get_event_detail(e, field, detail_event);
1896 tmp_raw_trace_data->event_description = g_strdup(detail_event->str);
1897
1898 if(strcmp(tmp_raw_trace_data->event_name, "schedchange") == 0){
1899 get_pid(&in, &out, detail_event->str);
1900 }
1901
1902
1903 if(in != 0 || out != 0){
1904 tmp_raw_trace_data->pid = in;
1905 if(prev_raw_trace_data && prev_raw_trace_data->pid == -1){
1906 list = event_viewer_data->raw_trace_data_queue_tmp->head;
1907 for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1908 data = (RawTraceData *)g_list_nth_data(list,i);
1909 if(data->cpu_id == tmp_raw_trace_data->cpu_id){
1910 data->pid = out;
1911 }
1912 }
1913 }
1914 }
1915
1916 ltt_event_position(e, tmp_raw_trace_data->ep);
1917
1918 if(event_viewer_data->raw_trace_data_queue_tmp->length >= RESERVE_SMALL_SIZE){
1919 if(event_viewer_data->append){
1920 list = g_list_last(event_viewer_data->raw_trace_data_queue_tmp->head);
1921 data = (RawTraceData *)(list->data);
1922 if(data->time.tv_sec == time.tv_sec &&
1923 data->time.tv_nsec == time.tv_nsec){
1924 g_queue_push_tail(event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1925 }else{
1926 g_free(tmp_raw_trace_data);
1927 }
1928 }else{
1929 remove_item_from_queue(event_viewer_data->raw_trace_data_queue_tmp,TRUE);
1930 g_queue_push_tail(event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1931 }
1932 }else{
1933 g_queue_push_tail (event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1934 }
1935
1936 g_string_free(detail_event, TRUE);
1937
1938 return FALSE;
1939 }
1940
1941 void remove_item_from_queue(GQueue * q, gboolean fromHead)
1942 {
1943 RawTraceData *data1, *data2 = NULL;
1944 GList * list;
1945
1946 if(fromHead){
1947 data1 = (RawTraceData *)g_queue_pop_head(q);
1948 list = g_list_first(q->head);
1949 if(list)
1950 data2 = (RawTraceData *)(list->data);
1951 }else{
1952 data1 = (RawTraceData *)g_queue_pop_tail(q);
1953 list = g_list_last(q->head);
1954 if(list)
1955 data2 = (RawTraceData *)(list->data);
1956 }
1957
1958 if(data2){
1959 if(data1->time.tv_sec == data2->time.tv_sec &&
1960 data1->time.tv_nsec == data2->time.tv_nsec){
1961 remove_item_from_queue(q, fromHead);
1962 }
1963 }
1964
1965 g_free(data1);
1966
1967 return;
1968 }
1969
1970 void remove_all_items_from_queue(GQueue *q)
1971 {
1972 RawTraceData *data;
1973 while((data = (RawTraceData *)g_queue_pop_head(q)) != NULL){
1974 g_free(data);
1975 }
1976 }
1977
1978
1979 /**
1980 * plugin's init function
1981 *
1982 * This function initializes the Event Viewer functionnality through the
1983 * gtkTraceSet API.
1984 */
1985 static void init() {
1986
1987 lttvwindow_register_constructor("/",
1988 "Insert Event Viewer",
1989 hGuiEventsInsert_xpm,
1990 "Insert Event Viewer",
1991 h_gui_events);
1992 }
1993
1994 void event_destroy_walk(gpointer data, gpointer user_data)
1995 {
1996 gui_events_destructor((EventViewerData*)data);
1997 }
1998
1999 /**
2000 * plugin's destroy function
2001 *
2002 * This function releases the memory reserved by the module and unregisters
2003 * everything that has been registered in the gtkTraceSet API.
2004 */
2005 static void destroy() {
2006 int i;
2007
2008 EventViewerData *event_viewer_data;
2009
2010 g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
2011 g_slist_free(g_event_viewer_data_list);
2012
2013 lttvwindow_unregister_constructor(h_gui_events);
2014
2015 }
2016
2017
2018 LTTV_MODULE("guievents", "Detailed events view", \
2019 "Graphical module to display a detailed event list", \
2020 init, destroy, "lttvwindow")
LTTng 2.x Viewer (LTTV)
This page took 0.073662 seconds and 5 git commands to generate.