projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
remove files unneeded for lttv
[lttv.git] / lttv / lttv / modules / gui / lttvwindow / lttvwindow / lttvwindowtraces.c
CommitLineData
a1a2b649 1/* This file is part of the Linux Trace Toolkit Graphic User Interface
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/* This file is the API used to launch any background computation on a trace */
20
21/* Here is the implementation of the API */
22
4e4d11b3 23#ifdef HAVE_CONFIG_H
24#include <config.h>
25#endif
26
0fdb8bb0 27#include <sys/types.h>
28#include <sys/stat.h>
29#include <unistd.h>
2eef04b5 30#include <string.h>
43ed82b5 31#include <inttypes.h>
0fdb8bb0 32
a1a2b649 33#include <ltt/time.h>
34#include <ltt/trace.h>
35#include <glib.h>
36#include <lttv/lttv.h>
37#include <lttv/traceset.h>
38#include <lttv/attribute.h>
39#include <lttv/tracecontext.h>
40#include <lttvwindow/lttvwindowtraces.h>
8bc02ec8 41#include <lttvwindow/lttvwindow.h> // for CHUNK_NUM_EVENTS
b5e17af5 42#include <lttvwindow/mainwindow-private.h> /* for main window structure */
a1a2b649 43
b5e17af5 44extern GSList * g_main_window_list;
a1a2b649 45
46typedef struct _BackgroundRequest {
47 LttvAttributeName module_name; /* Hook path in global attributes,
48 where all standard hooks under computation/.
49 i.e. modulename */
50 LttvTrace *trace; /* trace concerned */
93ac601b 51 GtkWidget *dialog; /* Dialog linked with the request, may be NULL */
b5e17af5 52 GtkWidget *parent_window; /* Parent window the dialog must be transient for */
a1a2b649 53} BackgroundRequest;
54
55typedef struct _BackgroundNotify {
56 gpointer owner;
57 LttvTrace *trace; /* trace */
58 LttTime notify_time;
59 LttvTracesetContextPosition *notify_position;
60 LttvHooks *notify; /* Hook to call when the notify is
61 passed, or at the end of trace */
62} BackgroundNotify;
63
64
65
313bd6fc 66/* Prototypes */
67gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace);
68
a1a2b649 69/* Get a trace by its path name.
70 *
71 * @param path path of the trace on the virtual file system.
72 * @return Pointer to trace if found
73 * NULL is returned if the trace is not present
74 */
75
f9240312 76__EXPORT LttvTrace *lttvwindowtraces_get_trace_by_name(gchar *path)
a1a2b649 77{
a1a2b649 78 guint i;
79
80 for(i=0;i<lttvwindowtraces_get_number();i++) {
81 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
82 LttTrace *trace;
43ed82b5 83 const gchar *name;
a1a2b649 84 g_assert(trace_v != NULL);
85
86 trace = lttv_trace(trace_v);
87 g_assert(trace != NULL);
d27948a3 88 name = g_quark_to_string(ltt_trace_name(trace));
a1a2b649 89
90 if(strcmp(name, path) == 0) {
91 /* Found */
92 return trace_v;
93 }
94 }
95
96 return NULL;
97}
98
99/* Get a trace by its number identifier */
100
f9240312 101__EXPORT LttvTrace *lttvwindowtraces_get_trace(guint num)
a1a2b649 102{
103 LttvAttribute *g_attribute = lttv_global_attributes();
104 LttvAttribute *attribute;
105 LttvAttributeType type;
106 LttvAttributeName name;
107 LttvAttributeValue value;
c0cb4d12 108 gboolean is_named;
a1a2b649 109
96c9eb79 110 attribute =
a1a2b649 111 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 112 LTTV_TRACES));
113 g_assert(attribute);
a1a2b649 114
c0cb4d12 115 type = lttv_iattribute_get(LTTV_IATTRIBUTE(attribute), num, &name, &value,
116 &is_named);
a1a2b649 117
118 if(type == LTTV_POINTER) {
119 return (LttvTrace *)*(value.v_pointer);
120 }
121
122 return NULL;
123}
124
125/* Total number of traces */
126
f9240312 127__EXPORT guint lttvwindowtraces_get_number()
a1a2b649 128{
129 LttvAttribute *g_attribute = lttv_global_attributes();
130 LttvAttribute *attribute;
a1a2b649 131
96c9eb79 132 attribute =
a1a2b649 133 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 134 LTTV_TRACES));
135 g_assert(attribute);
a1a2b649 136
137 return ( lttv_iattribute_get_number(LTTV_IATTRIBUTE(attribute)) );
138}
139
140/* Add a trace to the global attributes */
141
142void lttvwindowtraces_add_trace(LttvTrace *trace)
143{
144 LttvAttribute *g_attribute = lttv_global_attributes();
145 LttvAttribute *attribute;
146 LttvAttributeValue value;
0fdb8bb0 147 struct stat buf;
148 gchar attribute_path[PATH_MAX];
96c9eb79 149 int result;
150 gboolean result_b;
a1a2b649 151
23bb9b6b 152 if(stat(g_quark_to_string(ltt_trace_name(lttv_trace(trace))), &buf)) {
0fdb8bb0 153 g_warning("lttvwindowtraces_add_trace: Trace %s not found",
23bb9b6b 154 g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
0fdb8bb0 155 return;
156 }
43ed82b5 157 result = snprintf(attribute_path, PATH_MAX, "%" PRIu64 ":%" PRIu64,
158 buf.st_dev, buf.st_ino);
96c9eb79 159 g_assert(result >= 0);
0fdb8bb0 160
96c9eb79 161 attribute =
a1a2b649 162 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 163 LTTV_TRACES));
164 g_assert(attribute);
0fdb8bb0 165
a1a2b649 166 value = lttv_attribute_add(attribute,
0fdb8bb0 167 g_quark_from_string(attribute_path),
a1a2b649 168 LTTV_POINTER);
169
170 *(value.v_pointer) = (gpointer)trace;
8bc02ec8 171
172 /* create new traceset and tracesetcontext */
173 LttvTraceset *ts;
313bd6fc 174 LttvTracesetStats *tss;
088f6772 175 //LttvTracesetContextPosition *sync_position;
8bc02ec8 176
177 attribute = lttv_trace_attribute(trace);
96c9eb79 178 result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
8bc02ec8 179 LTTV_COMPUTATION_TRACESET,
180 LTTV_POINTER,
96c9eb79 181 &value);
182 g_assert(result_b);
183
8bc02ec8 184 ts = lttv_traceset_new();
185 *(value.v_pointer) = ts;
186
187 lttv_traceset_add(ts,trace);
188
96c9eb79 189 result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
8bc02ec8 190 LTTV_COMPUTATION_TRACESET_CONTEXT,
191 LTTV_POINTER,
96c9eb79 192 &value);
193 g_assert(result_b);
194
313bd6fc 195 tss = g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
196 *(value.v_pointer) = tss;
8bc02ec8 197
313bd6fc 198 lttv_context_init(LTTV_TRACESET_CONTEXT(tss), ts);
088f6772 199#if 0
96c9eb79 200 result_b = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
79257ba5 201 LTTV_COMPUTATION_SYNC_POSITION,
202 LTTV_POINTER,
96c9eb79 203 &value);
204 g_assert(result_b);
79257ba5 205
206 sync_position = lttv_traceset_context_position_new();
207 *(value.v_pointer) = sync_position;
088f6772 208#endif //0
8bc02ec8 209 value = lttv_attribute_add(attribute,
210 LTTV_REQUESTS_QUEUE,
211 LTTV_POINTER);
212
213 value = lttv_attribute_add(attribute,
214 LTTV_REQUESTS_CURRENT,
215 LTTV_POINTER);
216
217 value = lttv_attribute_add(attribute,
218 LTTV_NOTIFY_QUEUE,
219 LTTV_POINTER);
220
221 value = lttv_attribute_add(attribute,
222 LTTV_NOTIFY_CURRENT,
223 LTTV_POINTER);
a1a2b649 224}
225
226/* Remove a trace from the global attributes */
227
228void lttvwindowtraces_remove_trace(LttvTrace *trace)
229{
230 LttvAttribute *g_attribute = lttv_global_attributes();
231 LttvAttribute *attribute;
232 LttvAttributeValue value;
233 guint i;
96c9eb79 234 gboolean result;
a1a2b649 235
96c9eb79 236 attribute =
a1a2b649 237 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 238 LTTV_TRACES));
239 g_assert(attribute);
a1a2b649 240
241 for(i=0;i<lttvwindowtraces_get_number();i++) {
242 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
243
244 g_assert(trace_v != NULL);
245
b052368a 246 /* Remove and background computation that could be in progress */
247 g_idle_remove_by_data(trace_v);
248
a1a2b649 249 if(trace_v == trace) {
250 /* Found */
8bc02ec8 251 LttvAttribute *l_attribute;
252
23bb9b6b 253 /* destroy traceset and tracesetcontext */
8bc02ec8 254 LttvTraceset *ts;
313bd6fc 255 LttvTracesetStats *tss;
088f6772 256 //LttvTracesetContextPosition *sync_position;
8bc02ec8 257
258 l_attribute = lttv_trace_attribute(trace);
259
260
261 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
262 LTTV_REQUESTS_QUEUE);
263
264 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
265 LTTV_REQUESTS_CURRENT);
266
267 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
268 LTTV_NOTIFY_QUEUE);
269
270 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
271 LTTV_NOTIFY_CURRENT);
272
96c9eb79 273 result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
8bc02ec8 274 LTTV_COMPUTATION_TRACESET,
275 LTTV_POINTER,
96c9eb79 276 &value);
277 g_assert(result);
278
8bc02ec8 279 ts = (LttvTraceset*)*(value.v_pointer);
088f6772 280#if 0
96c9eb79 281 result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
79257ba5 282 LTTV_COMPUTATION_SYNC_POSITION,
283 LTTV_POINTER,
96c9eb79 284 &value);
285 g_assert(result);
286
79257ba5 287 sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
79257ba5 288 lttv_traceset_context_position_destroy(sync_position);
289
290 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
291 LTTV_COMPUTATION_SYNC_POSITION);
292
088f6772 293#endif //0
96c9eb79 294 result = lttv_iattribute_find(LTTV_IATTRIBUTE(l_attribute),
8bc02ec8 295 LTTV_COMPUTATION_TRACESET_CONTEXT,
296 LTTV_POINTER,
96c9eb79 297 &value);
298 g_assert(result);
299
313bd6fc 300 tss = (LttvTracesetStats*)*(value.v_pointer);
8bc02ec8 301
313bd6fc 302 lttv_context_fini(LTTV_TRACESET_CONTEXT(tss));
303 g_object_unref(tss);
8bc02ec8 304 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
305 LTTV_COMPUTATION_TRACESET_CONTEXT);
8bc02ec8 306 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(l_attribute),
307 LTTV_COMPUTATION_TRACESET);
1ba187d3 308 /* Destroy the traceset and the trace also */
309 lttv_traceset_destroy(ts);
8bc02ec8 310
311 /* finally, remove the global attribute */
a1a2b649 312 lttv_attribute_remove(attribute, i);
8bc02ec8 313
a1a2b649 314 return;
315 }
316 }
317}
318
93ac601b 319static void destroy_dialog(BackgroundRequest *bg_req)
320{
321 gtk_widget_destroy(bg_req->dialog);
322 bg_req->dialog = NULL;
323}
324
a1a2b649 325
326/**
327 * Function to request data from a specific trace
328 *
329 * The memory allocated for the request will be managed by the API.
330 *
b5e17af5 331 * @param widget the current Window
a1a2b649 332 * @param trace the trace to compute
333 * @param module_name the name of the module which registered global computation
334 * hooks.
335 */
336
f9240312 337__EXPORT void lttvwindowtraces_background_request_queue
b5e17af5 338 (GtkWidget *widget, LttvTrace *trace, gchar *module_name)
a1a2b649 339{
340 BackgroundRequest *bg_req;
341 LttvAttribute *attribute = lttv_trace_attribute(trace);
91fd6881 342 LttvAttribute *g_attribute = lttv_global_attributes();
343 LttvAttribute *module_attribute;
a1a2b649 344 LttvAttributeValue value;
91fd6881 345 LttvAttributeType type;
a1a2b649 346 GSList **slist;
96c9eb79 347 gboolean result;
a1a2b649 348
eaac6798 349 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
a1a2b649 350 LTTV_REQUESTS_QUEUE,
351 LTTV_POINTER,
96c9eb79 352 &value);
353 g_assert(result);
354
a1a2b649 355 slist = (GSList**)(value.v_pointer);
91fd6881 356
357 /* Verify that the calculator is loaded */
96c9eb79 358 module_attribute =
91fd6881 359 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 360 LTTV_COMPUTATION));
361 g_assert(module_attribute);
91fd6881 362
363 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
364 g_quark_from_string(module_name),
365 &value);
366 if(type == LTTV_NONE) {
367 g_critical("Missing background calculator %s", module_name);
368 return;
369 }
370
a1a2b649 371 bg_req = g_new(BackgroundRequest,1);
372 bg_req->module_name = g_quark_from_string(module_name);
373 bg_req->trace = trace;
374
375 *slist = g_slist_append(*slist, bg_req);
313bd6fc 376
377 /* Priority lower than live servicing */
378 g_idle_remove_by_data(trace);
379 g_idle_add_full((G_PRIORITY_HIGH_IDLE + 23),
380 (GSourceFunc)lttvwindowtraces_process_pending_requests,
381 trace,
382 NULL);
b052368a 383 /* FIXME : show message in status bar, need context and message id */
93ac601b 384 g_info("Background computation for %s started for trace %p", module_name,
385 trace);
386 GtkWidget *dialog =
b5e17af5 387 gtk_message_dialog_new(
388 GTK_WINDOW(widget),
389 GTK_DIALOG_DESTROY_WITH_PARENT,
390 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
93ac601b 391 "Background computation for %s started for trace %s",
392 module_name,
393 g_quark_to_string(ltt_trace_name(lttv_trace(trace))));
b5e17af5 394 gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(widget));
93ac601b 395 g_signal_connect_swapped (dialog, "response",
396 G_CALLBACK (destroy_dialog),
397 bg_req);
398 bg_req->dialog = dialog;
b5e17af5 399 /* the parent window might vanish : only use this pointer for a
400 * comparison with existing windows */
401 bg_req->parent_window = gtk_widget_get_toplevel(widget);
93ac601b 402 gtk_widget_show(dialog);
a1a2b649 403}
404
405/**
406 * Remove a background request from a trace.
407 *
408 * This should ONLY be used by the modules which registered the global hooks
409 * (module_name). If this is called by the viewers, it may lead to incomplete
410 * and incoherent background processing information.
411 *
412 * Even if the module which deals with the hooks removes the background
413 * requests, it may cause a problem if the module gets loaded again in the
414 * session : the data will be partially calculated. The calculation function
415 * must deal with this case correctly.
416 *
417 * @param trace the trace to compute
418 * @param module_name the name of the module which registered global computation
419 * hooks.
420 */
421
422void lttvwindowtraces_background_request_remove
423 (LttvTrace *trace, gchar *module_name)
424{
425 LttvAttribute *attribute = lttv_trace_attribute(trace);
426 LttvAttributeValue value;
427 GSList *iter = NULL;
428 GSList **slist;
96c9eb79 429 gboolean result;
a1a2b649 430
eaac6798 431 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
a1a2b649 432 LTTV_REQUESTS_QUEUE,
433 LTTV_POINTER,
96c9eb79 434 &value);
435 g_assert(result);
436
a1a2b649 437 slist = (GSList**)(value.v_pointer);
438
439 for(iter=*slist;iter!=NULL;) {
440 BackgroundRequest *bg_req =
441 (BackgroundRequest *)iter->data;
442
443 if(bg_req->module_name == g_quark_from_string(module_name)) {
444 GSList *rem_iter = iter;
445 iter=g_slist_next(iter);
446 g_free(bg_req);
447 *slist = g_slist_delete_link(*slist, rem_iter);
448 } else {
449 iter=g_slist_next(iter);
450 }
451 }
452}
453
93ac601b 454/**
455 * Find a background request in a trace
456 *
457 */
458
f9240312 459__EXPORT gboolean lttvwindowtraces_background_request_find
93ac601b 460 (LttvTrace *trace, gchar *module_name)
461{
462 LttvAttribute *attribute = lttv_trace_attribute(trace);
463 LttvAttributeValue value;
464 GSList *iter = NULL;
465 GSList **slist;
96c9eb79 466 gboolean result;
93ac601b 467
96c9eb79 468 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
93ac601b 469 LTTV_REQUESTS_QUEUE,
470 LTTV_POINTER,
96c9eb79 471 &value);
472 g_assert(result);
473
93ac601b 474 slist = (GSList**)(value.v_pointer);
475
476 for(iter=*slist;iter!=NULL;) {
477 BackgroundRequest *bg_req =
478 (BackgroundRequest *)iter->data;
479
480 if(bg_req->module_name == g_quark_from_string(module_name)) {
481 return TRUE;
482 } else {
483 iter=g_slist_next(iter);
484 }
485 }
486 return FALSE;
487}
a1a2b649 488
489/**
490 * Register a callback to be called when requested data is passed in the next
491 * queued background processing.
492 *
493 * @param owner owner of the background notification
494 * @param trace the trace computed
495 * @param notify_time time when notification hooks must be called
496 * @param notify_position position when notification hooks must be called
497 * @param notify Hook to call when the notify position is passed
498 */
499
f9240312 500__EXPORT void lttvwindowtraces_background_notify_queue
a1a2b649 501 (gpointer owner,
502 LttvTrace *trace,
503 LttTime notify_time,
504 const LttvTracesetContextPosition *notify_position,
505 const LttvHooks *notify)
506{
507 BackgroundNotify *bg_notify;
508 LttvAttribute *attribute = lttv_trace_attribute(trace);
509 LttvAttributeValue value;
510 GSList **slist;
96c9eb79 511 gboolean result;
a1a2b649 512
96c9eb79 513 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
a1a2b649 514 LTTV_NOTIFY_QUEUE,
515 LTTV_POINTER,
96c9eb79 516 &value);
517 g_assert(result);
518
a1a2b649 519 slist = (GSList**)(value.v_pointer);
520
96c9eb79 521 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
8e680509 522 LTTV_COMPUTATION_TRACESET_CONTEXT,
523 LTTV_POINTER,
96c9eb79 524 &value);
525 g_assert(result);
526
8e680509 527 LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
a1a2b649 528
529 bg_notify = g_new(BackgroundNotify,1);
530
531 bg_notify->owner = owner;
532 bg_notify->trace = trace;
533 bg_notify->notify_time = notify_time;
313bd6fc 534 if(notify_position != NULL) {
8e680509 535 bg_notify->notify_position = lttv_traceset_context_position_new(tsc);
313bd6fc 536 lttv_traceset_context_position_copy(bg_notify->notify_position,
537 notify_position);
538 } else {
539 bg_notify->notify_position = NULL;
540 }
541
a1a2b649 542 bg_notify->notify = lttv_hooks_new();
543 lttv_hooks_add_list(bg_notify->notify, notify);
544
545 *slist = g_slist_append(*slist, bg_notify);
546}
547
548/**
549 * Register a callback to be called when requested data is passed in the current
550 * background processing.
551 *
552 * @param owner owner of the background notification
553 * @param trace the trace computed
554 * @param notify_time time when notification hooks must be called
555 * @param notify_position position when notification hooks must be called
556 * @param notify Hook to call when the notify position is passed
557 */
558
f9240312 559__EXPORT void lttvwindowtraces_background_notify_current
a1a2b649 560 (gpointer owner,
561 LttvTrace *trace,
562 LttTime notify_time,
563 const LttvTracesetContextPosition *notify_position,
564 const LttvHooks *notify)
565{
566 BackgroundNotify *bg_notify;
567 LttvAttribute *attribute = lttv_trace_attribute(trace);
568 LttvAttributeValue value;
569 GSList **slist;
96c9eb79 570 gboolean result;
a1a2b649 571
96c9eb79 572 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
a1a2b649 573 LTTV_NOTIFY_CURRENT,
574 LTTV_POINTER,
96c9eb79 575 &value);
576 g_assert(result);
577
a1a2b649 578 slist = (GSList**)(value.v_pointer);
579
96c9eb79 580 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
8e680509 581 LTTV_COMPUTATION_TRACESET_CONTEXT,
582 LTTV_POINTER,
96c9eb79 583 &value);
584 g_assert(result);
585
8e680509 586 LttvTracesetContext *tsc = (LttvTracesetContext*)(value.v_pointer);
587
588
a1a2b649 589 bg_notify = g_new(BackgroundNotify,1);
590
591 bg_notify->owner = owner;
592 bg_notify->trace = trace;
593 bg_notify->notify_time = notify_time;
313bd6fc 594 if(notify_position!= NULL) {
8e680509 595 bg_notify->notify_position = lttv_traceset_context_position_new(tsc);
313bd6fc 596 lttv_traceset_context_position_copy(bg_notify->notify_position,
597 notify_position);
598 } else {
599 bg_notify->notify_position = NULL;
600 }
a1a2b649 601 bg_notify->notify = lttv_hooks_new();
602 lttv_hooks_add_list(bg_notify->notify, notify);
603
604 *slist = g_slist_append(*slist, bg_notify);
605}
606
b052368a 607
608static void notify_request_free(BackgroundNotify *notify_req)
609{
610 if(notify_req == NULL) return;
611
612 if(notify_req->notify_position != NULL)
613 lttv_traceset_context_position_destroy(notify_req->notify_position);
614 if(notify_req->notify != NULL)
615 lttv_hooks_destroy(notify_req->notify);
616 g_free(notify_req);
617}
618
a1a2b649 619/**
620 * Removes all the notifications requests from a specific viewer.
621 *
622 * @param owner owner of the background notification
623 */
624
f9240312 625__EXPORT void lttvwindowtraces_background_notify_remove(gpointer owner)
a1a2b649 626{
627 guint i;
628
629 for(i=0;i<lttvwindowtraces_get_number();i++) {
630 LttvAttribute *attribute;
631 LttvAttributeValue value;
632 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
633 GSList **slist;
634 GSList *iter = NULL;
96c9eb79 635 gboolean result;
a1a2b649 636
637 g_assert(trace_v != NULL);
638
b052368a 639 attribute = lttv_trace_attribute(trace_v);
a1a2b649 640
96c9eb79 641 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
a1a2b649 642 LTTV_NOTIFY_QUEUE,
643 LTTV_POINTER,
96c9eb79 644 &value);
645 g_assert(result);
646
a1a2b649 647 slist = (GSList**)(value.v_pointer);
648
649 for(iter=*slist;iter!=NULL;) {
650
651 BackgroundNotify *bg_notify = (BackgroundNotify*)iter->data;
652
653 if(bg_notify->owner == owner) {
654 GSList *rem_iter = iter;
655 iter=g_slist_next(iter);
b052368a 656 notify_request_free(bg_notify);
657 *slist = g_slist_remove_link(*slist, rem_iter);
a1a2b649 658 } else {
659 iter=g_slist_next(iter);
660 }
661 }
662
96c9eb79 663 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
a1a2b649 664 LTTV_NOTIFY_CURRENT,
665 LTTV_POINTER,
96c9eb79 666 &value);
667 g_assert(result);
668
a1a2b649 669 slist = (GSList**)(value.v_pointer);
670
671 for(iter=*slist;iter!=NULL;) {
672
673 BackgroundNotify *bg_notify = (BackgroundNotify*)iter->data;
674
675 if(bg_notify->owner == owner) {
676 GSList *rem_iter = iter;
677 iter=g_slist_next(iter);
b052368a 678 notify_request_free(bg_notify);
679 *slist = g_slist_remove_link(*slist, rem_iter);
a1a2b649 680 } else {
681 iter=g_slist_next(iter);
682 }
683 }
684 }
685}
686
8bc02ec8 687
688/* Background processing helper functions */
689
690void lttvwindowtraces_add_computation_hooks(LttvAttributeName module_name,
1ce324c6 691 LttvTracesetContext *tsc,
692 LttvHooks *hook_adder)
8bc02ec8 693{
694 LttvAttribute *g_attribute = lttv_global_attributes();
695 LttvAttribute *module_attribute;
696 LttvAttributeType type;
697 LttvAttributeValue value;
088f6772 698
699
96c9eb79 700 module_attribute =
088f6772 701 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 702 LTTV_COMPUTATION));
703 g_assert(module_attribute);
088f6772 704
96c9eb79 705 module_attribute =
088f6772 706 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
707 LTTV_IATTRIBUTE(module_attribute),
96c9eb79 708 module_name));
709 g_assert(module_attribute);
088f6772 710
711 /* Call the module's hook adder */
712 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
713 LTTV_HOOK_ADDER,
714 &value);
715 if(type == LTTV_POINTER) {
716 //lttv_hooks_call((LttvHooks*)*(value.v_pointer), (gpointer)tss);
717 if(hook_adder != NULL)
718 lttv_hooks_add_list(hook_adder, (LttvHooks*)*(value.v_pointer));
719 }
720}
721
722void lttvwindowtraces_remove_computation_hooks(LttvAttributeName module_name,
723 LttvTracesetContext *tsc,
724 LttvHooks *hook_remover)
725{
726 LttvAttribute *g_attribute = lttv_global_attributes();
727 LttvAttribute *module_attribute;
728 LttvAttributeType type;
729 LttvAttributeValue value;
730
96c9eb79 731 module_attribute =
088f6772 732 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 733 LTTV_COMPUTATION));
734 g_assert(module_attribute);
088f6772 735
96c9eb79 736 module_attribute =
088f6772 737 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
738 LTTV_IATTRIBUTE(module_attribute),
96c9eb79 739 module_name));
740 g_assert(module_attribute);
088f6772 741
742 /* Call the module's hook remover */
743 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
744 LTTV_HOOK_REMOVER,
745 &value);
746 if(type == LTTV_POINTER) {
747 //lttv_hooks_call((LttvHooks*)*(value.v_pointer), (gpointer)tss);
748 if(hook_remover != NULL)
749 lttv_hooks_add_list(hook_remover, (LttvHooks*)*(value.v_pointer));
750 }
751}
752
753void lttvwindowtraces_call_before_chunk(LttvAttributeName module_name,
754 LttvTracesetContext *tsc)
755{
756 LttvAttribute *g_attribute = lttv_global_attributes();
757 LttvAttribute *module_attribute;
758 LttvAttributeType type;
759 LttvAttributeValue value;
8bc02ec8 760 LttvHooks *before_chunk_traceset=NULL;
761 LttvHooks *before_chunk_trace=NULL;
762 LttvHooks *before_chunk_tracefile=NULL;
763 LttvHooks *event_hook=NULL;
750eb11a 764 LttvHooksByIdChannelArray *event_hook_by_id_channel=NULL;
8bc02ec8 765
766
96c9eb79 767 module_attribute =
8bc02ec8 768 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 769 LTTV_COMPUTATION));
770 g_assert(module_attribute);
8bc02ec8 771
96c9eb79 772 module_attribute =
8bc02ec8 773 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
774 LTTV_IATTRIBUTE(module_attribute),
96c9eb79 775 module_name));
776 g_assert(module_attribute);
8bc02ec8 777
778 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
779 LTTV_BEFORE_CHUNK_TRACESET,
780 &value);
781 if(type == LTTV_POINTER) {
782 before_chunk_traceset = (LttvHooks*)*(value.v_pointer);
783 }
784
785 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
786 LTTV_BEFORE_CHUNK_TRACE,
787 &value);
788 if(type == LTTV_POINTER) {
789 before_chunk_trace = (LttvHooks*)*(value.v_pointer);
790 }
791
792 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
793 LTTV_BEFORE_CHUNK_TRACEFILE,
794 &value);
795 if(type == LTTV_POINTER) {
796 before_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
797 }
798
799 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
800 LTTV_EVENT_HOOK,
801 &value);
802 if(type == LTTV_POINTER) {
803 event_hook = (LttvHooks*)*(value.v_pointer);
804 }
805
806 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
750eb11a 807 LTTV_EVENT_HOOK_BY_ID_CHANNEL,
8bc02ec8 808 &value);
809 if(type == LTTV_POINTER) {
43ed82b5 810 event_hook_by_id_channel = (LttvHooksByIdChannelArray*)*(value.v_pointer);
8bc02ec8 811 }
812
8bc02ec8 813 lttv_process_traceset_begin(tsc,
814 before_chunk_traceset,
815 before_chunk_trace,
816 before_chunk_tracefile,
817 event_hook,
750eb11a 818 event_hook_by_id_channel);
8bc02ec8 819}
088f6772 820
821
822
823void lttvwindowtraces_call_after_chunk(LttvAttributeName module_name,
824 LttvTracesetContext *tsc)
8bc02ec8 825{
826 LttvAttribute *g_attribute = lttv_global_attributes();
827 LttvAttribute *module_attribute;
828 LttvAttributeType type;
829 LttvAttributeValue value;
830 LttvHooks *after_chunk_traceset=NULL;
831 LttvHooks *after_chunk_trace=NULL;
832 LttvHooks *after_chunk_tracefile=NULL;
833 LttvHooks *event_hook=NULL;
43ed82b5 834 LttvHooksByIdChannelArray *event_hook_by_id_channel=NULL;
8bc02ec8 835
96c9eb79 836 module_attribute =
8bc02ec8 837 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 838 LTTV_COMPUTATION));
839 g_assert(module_attribute);
8bc02ec8 840
96c9eb79 841 module_attribute =
8bc02ec8 842 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
843 LTTV_IATTRIBUTE(module_attribute),
96c9eb79 844 module_name));
845 g_assert(module_attribute);
8bc02ec8 846
847 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
848 LTTV_AFTER_CHUNK_TRACESET,
849 &value);
850 if(type == LTTV_POINTER) {
851 after_chunk_traceset = (LttvHooks*)*(value.v_pointer);
852 }
853
854 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
855 LTTV_AFTER_CHUNK_TRACE,
856 &value);
857 if(type == LTTV_POINTER) {
858 after_chunk_trace = (LttvHooks*)*(value.v_pointer);
859 }
860
861 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
862 LTTV_AFTER_CHUNK_TRACEFILE,
863 &value);
864 if(type == LTTV_POINTER) {
865 after_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
866 }
867
868 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
869 LTTV_EVENT_HOOK,
870 &value);
871 if(type == LTTV_POINTER) {
872 event_hook = (LttvHooks*)*(value.v_pointer);
873 }
874
875 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
750eb11a 876 LTTV_EVENT_HOOK_BY_ID_CHANNEL,
8bc02ec8 877 &value);
878 if(type == LTTV_POINTER) {
43ed82b5 879 event_hook_by_id_channel = (LttvHooksByIdChannelArray*)*(value.v_pointer);
8bc02ec8 880 }
313bd6fc 881
8bc02ec8 882 lttv_process_traceset_end(tsc,
883 after_chunk_traceset,
884 after_chunk_trace,
885 after_chunk_tracefile,
886 event_hook,
750eb11a 887 event_hook_by_id_channel);
313bd6fc 888
8bc02ec8 889}
890
891
892void lttvwindowtraces_set_in_progress(LttvAttributeName module_name,
893 LttvTrace *trace)
894{
895 LttvAttribute *attribute = lttv_trace_attribute(trace);
896 LttvAttributeValue value;
897
96c9eb79 898 attribute =
8bc02ec8 899 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 900 module_name));
901 g_assert(attribute);
8bc02ec8 902
903 value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
904 LTTV_IN_PROGRESS,
905 LTTV_INT);
906 /* the value is left unset. The only presence of the attribute is necessary.
907 */
908}
909
910void lttvwindowtraces_unset_in_progress(LttvAttributeName module_name,
911 LttvTrace *trace)
912{
913 LttvAttribute *attribute = lttv_trace_attribute(trace);
914
96c9eb79 915 attribute =
8bc02ec8 916 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 917 module_name));
918 g_assert(attribute);
8bc02ec8 919
313bd6fc 920 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
8bc02ec8 921 LTTV_IN_PROGRESS);
922}
923
f9240312 924__EXPORT gboolean lttvwindowtraces_get_in_progress(LttvAttributeName module_name,
8bc02ec8 925 LttvTrace *trace)
926{
927 LttvAttribute *attribute = lttv_trace_attribute(trace);
928 LttvAttributeType type;
929 LttvAttributeValue value;
930
96c9eb79 931 attribute =
8bc02ec8 932 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 933 module_name));
934 g_assert(attribute);
8bc02ec8 935
936 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
937 LTTV_IN_PROGRESS,
938 &value);
939 /* The only presence of the attribute is necessary. */
940 if(type == LTTV_NONE)
941 return FALSE;
942 else
943 return TRUE;
944}
945
946void lttvwindowtraces_set_ready(LttvAttributeName module_name,
947 LttvTrace *trace)
948{
949 LttvAttribute *attribute = lttv_trace_attribute(trace);
950 LttvAttributeValue value;
951
96c9eb79 952 attribute =
8bc02ec8 953 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 954 module_name));
955 g_assert(attribute);
8bc02ec8 956
957 value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
958 LTTV_READY,
959 LTTV_INT);
960 /* the value is left unset. The only presence of the attribute is necessary.
961 */
962}
963
964void lttvwindowtraces_unset_ready(LttvAttributeName module_name,
965 LttvTrace *trace)
966{
967 LttvAttribute *attribute = lttv_trace_attribute(trace);
968
96c9eb79 969 attribute =
8bc02ec8 970 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 971 module_name));
972 g_assert(attribute);
8bc02ec8 973
313bd6fc 974 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
8bc02ec8 975 LTTV_READY);
976}
977
f9240312 978__EXPORT gboolean lttvwindowtraces_get_ready(LttvAttributeName module_name,
8bc02ec8 979 LttvTrace *trace)
980{
981 LttvAttribute *attribute = lttv_trace_attribute(trace);
982 LttvAttributeType type;
983 LttvAttributeValue value;
984
96c9eb79 985 attribute =
8bc02ec8 986 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 987 module_name));
988 g_assert(attribute);
8bc02ec8 989
990 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
991 LTTV_READY,
992 &value);
993 /* The only presence of the attribute is necessary. */
994 if(type == LTTV_NONE)
995 return FALSE;
996 else
997 return TRUE;
998}
999
b5e17af5 1000static gint find_window_widget(MainWindow *a, GtkWidget *b)
1001{
1002 if(a->mwindow == b) return 0;
1003 else return -1;
1004}
1005
8bc02ec8 1006
8bc02ec8 1007/* lttvwindowtraces_process_pending_requests
d389bc8d 1008 *
1009 * Process the pending background computation requests
8bc02ec8 1010 *
1011 * This internal function gets called by g_idle, taking care of the pending
1012 * requests.
1013 *
1014 */
1015
1016
1017gboolean lttvwindowtraces_process_pending_requests(LttvTrace *trace)
1018{
1019 LttvTracesetContext *tsc;
313bd6fc 1020 LttvTracesetStats *tss;
8bc02ec8 1021 LttvTraceset *ts;
088f6772 1022 //LttvTracesetContextPosition *sync_position;
8bc02ec8 1023 LttvAttribute *attribute;
91fd6881 1024 LttvAttribute *g_attribute = lttv_global_attributes();
313bd6fc 1025 GSList **list_out, **list_in, **notify_in, **notify_out;
8bc02ec8 1026 LttvAttributeValue value;
1027 LttvAttributeType type;
b052368a 1028 gboolean ret_val;
8bc02ec8 1029
313bd6fc 1030 if(trace == NULL)
8bc02ec8 1031 return FALSE;
3c456a8a 1032
1033 if(lttvwindow_preempt_count > 0) return TRUE;
8bc02ec8 1034
1035 attribute = lttv_trace_attribute(trace);
1036
1037 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1038 LTTV_REQUESTS_QUEUE,
1039 &value);
1040 g_assert(type == LTTV_POINTER);
313bd6fc 1041 list_out = (GSList**)(value.v_pointer);
8bc02ec8 1042
1043 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1044 LTTV_REQUESTS_CURRENT,
1045 &value);
1046 g_assert(type == LTTV_POINTER);
313bd6fc 1047 list_in = (GSList**)(value.v_pointer);
8bc02ec8 1048
1049 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1050 LTTV_NOTIFY_QUEUE,
1051 &value);
1052 g_assert(type == LTTV_POINTER);
313bd6fc 1053 notify_out = (GSList**)(value.v_pointer);
8bc02ec8 1054
1055 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1056 LTTV_NOTIFY_CURRENT,
1057 &value);
1058 g_assert(type == LTTV_POINTER);
313bd6fc 1059 notify_in = (GSList**)(value.v_pointer);
8bc02ec8 1060
1061 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1062 LTTV_COMPUTATION_TRACESET,
1063 &value);
1064 g_assert(type == LTTV_POINTER);
1065 ts = (LttvTraceset*)*(value.v_pointer);
1066
1067 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1068 LTTV_COMPUTATION_TRACESET_CONTEXT,
1069 &value);
1070 g_assert(type == LTTV_POINTER);
1071 tsc = (LttvTracesetContext*)*(value.v_pointer);
313bd6fc 1072 tss = (LttvTracesetStats*)*(value.v_pointer);
8bc02ec8 1073 g_assert(LTTV_IS_TRACESET_CONTEXT(tsc));
313bd6fc 1074 g_assert(LTTV_IS_TRACESET_STATS(tss));
088f6772 1075#if 0
79257ba5 1076 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1077 LTTV_COMPUTATION_SYNC_POSITION,
1078 &value);
1079 g_assert(type == LTTV_POINTER);
1080 sync_position = (LttvTracesetContextPosition*)*(value.v_pointer);
088f6772 1081#endif //0
8bc02ec8 1082 /* There is no events requests pending : we should never have been called! */
313bd6fc 1083 g_assert(g_slist_length(*list_out) != 0 || g_slist_length(*list_in) != 0);
b052368a 1084 /* 0.1 Lock traces */
1085 {
1086 guint iter_trace=0;
1087
1088 for(iter_trace=0;
1089 iter_trace<lttv_traceset_number(tsc->ts);
1090 iter_trace++) {
1091 LttvTrace *trace_v = lttv_traceset_get(tsc->ts,iter_trace);
1092
1093 if(lttvwindowtraces_lock(trace_v) != 0)
1094 return TRUE; /* Cannot get trace lock, try later */
8bc02ec8 1095
b052368a 1096 }
1097 }
1098 /* 0.2 Sync tracefiles */
088f6772 1099 //g_assert(lttv_process_traceset_seek_position(tsc, sync_position) == 0);
1100 lttv_process_traceset_synchronize_tracefiles(tsc);
8bc02ec8 1101 /* 1. Before processing */
1102 {
1103 /* if list_in is empty */
313bd6fc 1104 if(g_slist_length(*list_in) == 0) {
8bc02ec8 1105
1106 {
1107 /* - Add all requests in list_out to list_in, empty list_out */
313bd6fc 1108 GSList *iter = *list_out;
8bc02ec8 1109
1110 while(iter != NULL) {
1111 gboolean remove = FALSE;
1112 gboolean free_data = FALSE;
1113
1114 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1115
1116 remove = TRUE;
1117 free_data = FALSE;
313bd6fc 1118 *list_in = g_slist_append(*list_in, bg_req);
8bc02ec8 1119
1120 /* Go to next */
1121 if(remove)
1122 {
1123 GSList *remove_iter = iter;
1124
1125 iter = g_slist_next(iter);
1126 if(free_data) g_free(remove_iter->data);
313bd6fc 1127 *list_out = g_slist_remove_link(*list_out, remove_iter);
8bc02ec8 1128 } else { // not remove
1129 iter = g_slist_next(iter);
1130 }
1131 }
1132 }
1133
1134 {
313bd6fc 1135 GSList *iter = *list_in;
8bc02ec8 1136 /* - for each request in list_in */
1137 while(iter != NULL) {
1138
1139 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
91fd6881 1140 /* - set hooks'in_progress flag to TRUE */
8bc02ec8 1141 lttvwindowtraces_set_in_progress(bg_req->module_name,
1142 bg_req->trace);
91fd6881 1143
1144 /* - call before request hook */
1145 /* Get before request hook */
1146 LttvAttribute *module_attribute;
1147
96c9eb79 1148 module_attribute =
91fd6881 1149 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1150 LTTV_IATTRIBUTE(g_attribute),
96c9eb79 1151 LTTV_COMPUTATION));
1152 g_assert(module_attribute);
91fd6881 1153
96c9eb79 1154 module_attribute =
91fd6881 1155 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1156 LTTV_IATTRIBUTE(module_attribute),
96c9eb79 1157 bg_req->module_name));
1158 g_assert(module_attribute);
91fd6881 1159
1160 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
1161 LTTV_BEFORE_REQUEST,
1162 &value);
1163 g_assert(type == LTTV_POINTER);
1164 LttvHooks *before_request = (LttvHooks*)*(value.v_pointer);
91fd6881 1165
1166 if(before_request != NULL) lttv_hooks_call(before_request, tsc);
8bc02ec8 1167
1168 iter = g_slist_next(iter);
1169 }
1170 }
1171
1172 /* - seek trace to start */
1173 {
1174 LttTime start = { 0, 0};
1175 lttv_process_traceset_seek_time(tsc, start);
1176 }
1177
1178 /* - Move all notifications from notify_out to notify_in. */
1179 {
313bd6fc 1180 GSList *iter = *notify_out;
1181 g_assert(g_slist_length(*notify_in) == 0);
8bc02ec8 1182
1183 while(iter != NULL) {
1184 gboolean remove = FALSE;
1185 gboolean free_data = FALSE;
1186
1187 BackgroundNotify *notify_req = (BackgroundNotify*)iter->data;
1188
1189 remove = TRUE;
1190 free_data = FALSE;
313bd6fc 1191 *notify_in = g_slist_append(*notify_in, notify_req);
8bc02ec8 1192
1193 /* Go to next */
1194 if(remove)
1195 {
1196 GSList *remove_iter = iter;
1197
1198 iter = g_slist_next(iter);
b052368a 1199 if(free_data)
1200 notify_request_free((BackgroundNotify*)remove_iter->data);
313bd6fc 1201 *notify_out = g_slist_remove_link(*notify_out, remove_iter);
8bc02ec8 1202 } else { // not remove
1203 iter = g_slist_next(iter);
1204 }
1205 }
1206 }
088f6772 1207 {
1208 GSList *iter = *list_in;
1209 LttvHooks *hook_adder = lttv_hooks_new();
1210 /* - for each request in list_in */
1211 while(iter != NULL) {
1212
1213 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1214 /*- add hooks to context*/
1215 lttvwindowtraces_add_computation_hooks(bg_req->module_name,
1216 tsc,
1217 hook_adder);
1218 iter = g_slist_next(iter);
1219 }
1220 lttv_hooks_call(hook_adder,tsc);
1221 lttv_hooks_destroy(hook_adder);
1222 }
1223
1224
8bc02ec8 1225 }
1226
1227 {
313bd6fc 1228 GSList *iter = *list_in;
8bc02ec8 1229 /* - for each request in list_in */
1230 while(iter != NULL) {
1231
1232 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1233 /*- Call before chunk hooks for list_in*/
088f6772 1234 lttvwindowtraces_call_before_chunk(bg_req->module_name,
1235 tsc);
8bc02ec8 1236 iter = g_slist_next(iter);
1237 }
1238 }
8bc02ec8 1239
088f6772 1240 }
8bc02ec8 1241 /* 2. call process traceset middle for a chunk */
1242 {
1243 /*(assert list_in is not empty! : should not even be called in that case)*/
0aa6c3a1 1244 LttTime end = ltt_time_infinite;
313bd6fc 1245 g_assert(g_slist_length(*list_in) != 0);
8bc02ec8 1246
1247 lttv_process_traceset_middle(tsc, end, CHUNK_NUM_EVENTS, NULL);
1248 }
1249
1250 /* 3. After the chunk */
1251 {
1252 /* 3.1 call after_chunk hooks for list_in */
1253 {
313bd6fc 1254 GSList *iter = *list_in;
8bc02ec8 1255 /* - for each request in list_in */
1256 while(iter != NULL) {
1257
1258 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1259 /* - Call after chunk hooks for list_in */
088f6772 1260 lttvwindowtraces_call_after_chunk(bg_req->module_name,
1261 tsc);
8bc02ec8 1262 iter = g_slist_next(iter);
1263 }
1264 }
1265
1266 /* 3.2 for each notify_in */
1267 {
313bd6fc 1268 GSList *iter = *notify_in;
8bc02ec8 1269 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
1270
1271 while(iter != NULL) {
1272 gboolean remove = FALSE;
1273 gboolean free_data = FALSE;
1274
1275 BackgroundNotify *notify_req = (BackgroundNotify*)iter->data;
1276
1277 /* - if current time >= notify time, call notify and remove from
1278 * notify_in.
1279 * - if current position >= notify position, call notify and remove
1280 * from notify_in.
1281 */
1282 if( (tfc != NULL &&
313bd6fc 1283 ltt_time_compare(notify_req->notify_time, tfc->timestamp) <= 0)
8bc02ec8 1284 ||
313bd6fc 1285 (notify_req->notify_position != NULL &&
1286 lttv_traceset_context_ctx_pos_compare(tsc,
1287 notify_req->notify_position) >= 0)
8bc02ec8 1288 ) {
1289
1290 lttv_hooks_call(notify_req->notify, notify_req);
1291
1292 remove = TRUE;
1293 free_data = TRUE;
1294 }
1295
1296 /* Go to next */
1297 if(remove)
1298 {
1299 GSList *remove_iter = iter;
1300
1301 iter = g_slist_next(iter);
b052368a 1302 if(free_data)
1303 notify_request_free((BackgroundNotify*)remove_iter->data);
313bd6fc 1304 *notify_in = g_slist_remove_link(*notify_in, remove_iter);
8bc02ec8 1305 } else { // not remove
1306 iter = g_slist_next(iter);
1307 }
1308 }
1309 }
1310
1311 {
1312 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
1313 /* 3.3 if end of trace reached */
313bd6fc 1314 if(tfc != NULL)
1315 g_debug("Current time : %lu sec, %lu nsec",
1316 tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
8bc02ec8 1317 if(tfc == NULL || ltt_time_compare(tfc->timestamp,
1318 tsc->time_span.end_time) > 0) {
088f6772 1319
1320 {
1321 GSList *iter = *list_in;
1322 LttvHooks *hook_remover = lttv_hooks_new();
1323 /* - for each request in list_in */
1324 while(iter != NULL) {
1325
1326 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1327 /* - remove hooks from context */
1328 lttvwindowtraces_remove_computation_hooks(bg_req->module_name,
1329 tsc,
1330 hook_remover);
1331 iter = g_slist_next(iter);
1332 }
1333 lttv_hooks_call(hook_remover,tsc);
1334 lttv_hooks_destroy(hook_remover);
1335 }
1336
8bc02ec8 1337 /* - for each request in list_in */
1338 {
313bd6fc 1339 GSList *iter = *list_in;
8bc02ec8 1340
1341 while(iter != NULL) {
1342 gboolean remove = FALSE;
1343 gboolean free_data = FALSE;
1344
1345 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1346
1347 /* - set hooks'in_progress flag to FALSE */
1348 lttvwindowtraces_unset_in_progress(bg_req->module_name,
1349 bg_req->trace);
1350 /* - set hooks'ready flag to TRUE */
1351 lttvwindowtraces_set_ready(bg_req->module_name,
1352 bg_req->trace);
91fd6881 1353 /* - call after request hook */
1354 /* Get after request hook */
1355 LttvAttribute *module_attribute;
1356
96c9eb79 1357 module_attribute =
91fd6881 1358 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1359 LTTV_IATTRIBUTE(g_attribute),
96c9eb79 1360 LTTV_COMPUTATION));
1361 g_assert(module_attribute);
91fd6881 1362
96c9eb79 1363 module_attribute =
91fd6881 1364 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
1365 LTTV_IATTRIBUTE(module_attribute),
96c9eb79 1366 bg_req->module_name));
1367 g_assert(module_attribute);
91fd6881 1368
1369 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(module_attribute),
1370 LTTV_AFTER_REQUEST,
1371 &value);
1372 g_assert(type == LTTV_POINTER);
1373 LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
b91e751b 1374 {
1375 struct sum_traceset_closure t_closure;
1376 t_closure.tss = (LttvTracesetStats*)tsc;
1377 t_closure.current_time = ltt_time_infinite;
1378 if(after_request != NULL) lttv_hooks_call(after_request,
1379 &t_closure);
1380 }
93ac601b 1381
1382 if(bg_req->dialog != NULL)
1383 gtk_widget_destroy(bg_req->dialog);
b5e17af5 1384 GtkWidget *parent_window;
1385 if(g_slist_find_custom(g_main_window_list,
1386 bg_req->parent_window,
1387 (GCompareFunc)find_window_widget))
1388 parent_window = GTK_WIDGET(bg_req->parent_window);
1389 else
1390 parent_window = NULL;
1391
93ac601b 1392 GtkWidget *dialog =
b5e17af5 1393 gtk_message_dialog_new(GTK_WINDOW(parent_window),
1394 GTK_DIALOG_DESTROY_WITH_PARENT,
1395 GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
93ac601b 1396 "Background computation %s finished for trace %s",
1397 g_quark_to_string(bg_req->module_name),
1398 g_quark_to_string(ltt_trace_name(lttv_trace(bg_req->trace))));
b5e17af5 1399 if(parent_window != NULL)
1400 gtk_window_set_transient_for(GTK_WINDOW(dialog),
1401 GTK_WINDOW(parent_window));
93ac601b 1402 g_signal_connect_swapped (dialog, "response",
1403 G_CALLBACK (gtk_widget_destroy),
1404 dialog);
1405 gtk_widget_show(dialog);
1406
8bc02ec8 1407 /* - remove request */
1408 remove = TRUE;
1409 free_data = TRUE;
1410
1411 /* Go to next */
1412 if(remove)
1413 {
1414 GSList *remove_iter = iter;
1415
1416 iter = g_slist_next(iter);
1417 if(free_data) g_free(remove_iter->data);
313bd6fc 1418 *list_in = g_slist_remove_link(*list_in, remove_iter);
8bc02ec8 1419 } else { // not remove
1420 iter = g_slist_next(iter);
1421 }
1422 }
1423 }
1424
1425 /* - for each notifications in notify_in */
1426 {
313bd6fc 1427 GSList *iter = *notify_in;
8bc02ec8 1428
1429 while(iter != NULL) {
1430 gboolean remove = FALSE;
1431 gboolean free_data = FALSE;
1432
1433 BackgroundNotify *notify_req = (BackgroundNotify*)iter->data;
1434
1435 /* - call notify and remove from notify_in */
1436 lttv_hooks_call(notify_req->notify, notify_req);
1437 remove = TRUE;
1438 free_data = TRUE;
1439
1440 /* Go to next */
1441 if(remove)
1442 {
1443 GSList *remove_iter = iter;
1444
1445 iter = g_slist_next(iter);
b052368a 1446 if(free_data)
1447 notify_request_free((BackgroundNotify*)remove_iter->data);
313bd6fc 1448 *notify_in = g_slist_remove_link(*notify_in, remove_iter);
8bc02ec8 1449 } else { // not remove
1450 iter = g_slist_next(iter);
1451 }
1452 }
1453 }
1ce324c6 1454 {
1455 /* - reset the context */
1456 LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->fini(tsc);
1457 LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->init(tsc,ts);
1458 }
3710295e 1459 /* - if list_out is empty */
1460 if(g_slist_length(*list_out) == 0) {
1461 /* - return FALSE (scheduler stopped) */
1462 g_debug("Background computation scheduler stopped");
1463 g_info("Background computation finished for trace %p", trace);
1464 /* FIXME : remove status bar info, need context id and message id */
93ac601b 1465
3710295e 1466 ret_val = FALSE;
1467 } else {
1468 ret_val = TRUE;
1469 }
8bc02ec8 1470 } else {
1471 /* 3.4 else, end of trace not reached */
1472 /* - return TRUE (scheduler still registered) */
313bd6fc 1473 g_debug("Background computation left");
b052368a 1474 ret_val = TRUE;
8bc02ec8 1475 }
1476 }
1477 }
b052368a 1478 /* 4. Unlock traces */
1479 {
088f6772 1480 lttv_process_traceset_get_sync_data(tsc);
1481 //lttv_traceset_context_position_save(tsc, sync_position);
b052368a 1482 guint iter_trace;
1483
1484 for(iter_trace=0;
1485 iter_trace<lttv_traceset_number(tsc->ts);
1486 iter_trace++) {
1487 LttvTrace *trace_v = lttv_traceset_get(tsc->ts, iter_trace);
1488
1489 lttvwindowtraces_unlock(trace_v);
1490 }
1491 }
1492 return ret_val;
8bc02ec8 1493}
e62a7964 1494
1495
1496
1497/**
1498 * Register the background computation hooks for a specific module. It adds the
313bd6fc 1499 * computation hooks to the global attrubutes, under "computation/module name".
e62a7964 1500 *
1501 * @param module_name A GQuark : the name of the module which computes the
1502 * information.
1503 */
1504void lttvwindowtraces_register_computation_hooks(LttvAttributeName module_name,
750eb11a 1505 LttvHooks *before_chunk_traceset,
1506 LttvHooks *before_chunk_trace,
1507 LttvHooks *before_chunk_tracefile,
1508 LttvHooks *after_chunk_traceset,
1509 LttvHooks *after_chunk_trace,
1510 LttvHooks *after_chunk_tracefile,
1511 LttvHooks *before_request,
1512 LttvHooks *after_request,
1513 LttvHooks *event_hook,
1514 LttvHooksById *event_hook_by_id_channel,
1515 LttvHooks *hook_adder,
1516 LttvHooks *hook_remover)
e62a7964 1517{
1518 LttvAttribute *g_attribute = lttv_global_attributes();
1519 LttvAttribute *attribute;
1520 LttvAttributeValue value;
96c9eb79 1521 gboolean result;
e62a7964 1522
96c9eb79 1523 attribute =
e62a7964 1524 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 1525 LTTV_COMPUTATION));
1526 g_assert(attribute);
e62a7964 1527
96c9eb79 1528 attribute =
e62a7964 1529 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
96c9eb79 1530 module_name));
1531 g_assert(attribute);
e62a7964 1532
96c9eb79 1533 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1534 LTTV_BEFORE_CHUNK_TRACESET,
1535 LTTV_POINTER,
96c9eb79 1536 &value);
1537 g_assert(result);
1538
e62a7964 1539 *(value.v_pointer) = before_chunk_traceset;
1540
96c9eb79 1541 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1542 LTTV_BEFORE_CHUNK_TRACE,
1543 LTTV_POINTER,
96c9eb79 1544 &value);
1545 g_assert(result);
e62a7964 1546 *(value.v_pointer) = before_chunk_trace;
1547
96c9eb79 1548 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1549 LTTV_BEFORE_CHUNK_TRACEFILE,
1550 LTTV_POINTER,
96c9eb79 1551 &value);
1552 g_assert(result);
e62a7964 1553 *(value.v_pointer) = before_chunk_tracefile;
1554
96c9eb79 1555 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1556 LTTV_AFTER_CHUNK_TRACESET,
1557 LTTV_POINTER,
96c9eb79 1558 &value);
1559 g_assert(result);
e62a7964 1560 *(value.v_pointer) = after_chunk_traceset;
1561
96c9eb79 1562 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1563 LTTV_AFTER_CHUNK_TRACE,
1564 LTTV_POINTER,
96c9eb79 1565 &value);
1566 g_assert(result);
e62a7964 1567 *(value.v_pointer) = after_chunk_trace;
1568
96c9eb79 1569 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1570 LTTV_AFTER_CHUNK_TRACEFILE,
1571 LTTV_POINTER,
96c9eb79 1572 &value);
1573 g_assert(result);
e62a7964 1574 *(value.v_pointer) = after_chunk_tracefile;
1575
96c9eb79 1576 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1577 LTTV_BEFORE_REQUEST,
1578 LTTV_POINTER,
96c9eb79 1579 &value);
1580 g_assert(result);
e62a7964 1581 *(value.v_pointer) = before_request;
1582
96c9eb79 1583 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1584 LTTV_AFTER_REQUEST,
1585 LTTV_POINTER,
96c9eb79 1586 &value);
1587 g_assert(result);
e62a7964 1588 *(value.v_pointer) = after_request;
1589
96c9eb79 1590 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1591 LTTV_EVENT_HOOK,
1592 LTTV_POINTER,
96c9eb79 1593 &value);
1594 g_assert(result);
e62a7964 1595 *(value.v_pointer) = event_hook;
1596
96c9eb79 1597 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
750eb11a 1598 LTTV_EVENT_HOOK_BY_ID_CHANNEL,
e62a7964 1599 LTTV_POINTER,
96c9eb79 1600 &value);
1601 g_assert(result);
750eb11a 1602 *(value.v_pointer) = event_hook_by_id_channel;
e62a7964 1603
96c9eb79 1604 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
313bd6fc 1605 LTTV_HOOK_ADDER,
1606 LTTV_POINTER,
96c9eb79 1607 &value);
1608 g_assert(result);
313bd6fc 1609 *(value.v_pointer) = hook_adder;
1610
96c9eb79 1611 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
313bd6fc 1612 LTTV_HOOK_REMOVER,
1613 LTTV_POINTER,
96c9eb79 1614 &value);
1615 g_assert(result);
313bd6fc 1616 *(value.v_pointer) = hook_remover;
1617
e62a7964 1618}
1619
1620
1621/**
d389bc8d 1622 * It removes all the requests that can be currently processed by the
e62a7964 1623 * background computation algorithm for all the traces (list_in and list_out).
1624 *
1625 * Leaves the flag to in_progress or none.. depending if current or queue
1626 *
1627 * @param module_name A GQuark : the name of the module which computes the
1628 * information.
1629 */
1630void lttvwindowtraces_unregister_requests(LttvAttributeName module_name)
1631{
1632 guint i;
96c9eb79 1633 gboolean result;
e62a7964 1634
1635 for(i=0;i<lttvwindowtraces_get_number();i++) {
1636 LttvTrace *trace_v = lttvwindowtraces_get_trace(i);
1637 g_assert(trace_v != NULL);
e62a7964 1638 LttvAttribute *attribute = lttv_trace_attribute(trace_v);
1639 LttvAttributeValue value;
313bd6fc 1640 GSList **queue, **current;
e62a7964 1641 GSList *iter;
1642
96c9eb79 1643 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1644 LTTV_REQUESTS_QUEUE,
1645 LTTV_POINTER,
96c9eb79 1646 &value);
1647 g_assert(result);
1648
313bd6fc 1649 queue = (GSList**)(value.v_pointer);
e62a7964 1650
313bd6fc 1651 iter = *queue;
e62a7964 1652 while(iter != NULL) {
1653 gboolean remove = FALSE;
1654 gboolean free_data = FALSE;
1655
1656 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1657
1658 if(bg_req->module_name == module_name) {
1659 remove = TRUE;
1660 free_data = TRUE;
1661 }
1662
1663 /* Go to next */
1664 if(remove)
1665 {
1666 GSList *remove_iter = iter;
1667
1668 iter = g_slist_next(iter);
1669 if(free_data) g_free(remove_iter->data);
313bd6fc 1670 *queue = g_slist_remove_link(*queue, remove_iter);
e62a7964 1671 } else { // not remove
1672 iter = g_slist_next(iter);
1673 }
1674 }
1675
1676
96c9eb79 1677 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
e62a7964 1678 LTTV_REQUESTS_CURRENT,
1679 LTTV_POINTER,
96c9eb79 1680 &value);
1681 g_assert(result);
1682
313bd6fc 1683 current = (GSList**)(value.v_pointer);
e62a7964 1684
313bd6fc 1685 iter = *current;
e62a7964 1686 while(iter != NULL) {
1687 gboolean remove = FALSE;
1688 gboolean free_data = FALSE;
1689
1690 BackgroundRequest *bg_req = (BackgroundRequest*)iter->data;
1691
1692 if(bg_req->module_name == module_name) {
1693 remove = TRUE;
1694 free_data = TRUE;
1695 }
1696
1697 /* Go to next */
1698 if(remove)
1699 {
1700 GSList *remove_iter = iter;
1701
1702 iter = g_slist_next(iter);
1703 if(free_data) g_free(remove_iter->data);
313bd6fc 1704 *current = g_slist_remove_link(*current, remove_iter);
e62a7964 1705 } else { // not remove
1706 iter = g_slist_next(iter);
1707 }
1708 }
1709 }
1710}
1711
1712
1713/**
1714 * Unregister the background computation hooks for a specific module.
1715 *
d389bc8d 1716 * It also removes all the requests that can be currently processed by the
e62a7964 1717 * background computation algorithm for all the traces (list_in and list_out).
1718 *
1719 * @param module_name A GQuark : the name of the module which computes the
1720 * information.
1721 */
1722
1723void lttvwindowtraces_unregister_computation_hooks
1724 (LttvAttributeName module_name)
1725{
1726 LttvAttribute *g_attribute = lttv_global_attributes();
1727 LttvAttribute *attribute;
91fd6881 1728 LttvAttributeValue value;
96c9eb79 1729 gboolean result;
e62a7964 1730
96c9eb79 1731 attribute =
e62a7964 1732 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 1733 LTTV_COMPUTATION));
1734 g_assert(attribute);
e62a7964 1735
96c9eb79 1736 attribute =
1737 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(attribute),
1738 module_name));
1739 g_assert(attribute);
e62a7964 1740
96c9eb79 1741 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1742 LTTV_BEFORE_CHUNK_TRACESET,
1743 LTTV_POINTER,
96c9eb79 1744 &value);
1745 g_assert(result);
1746
91fd6881 1747 LttvHooks *before_chunk_traceset = (LttvHooks*)*(value.v_pointer);
1748 if(before_chunk_traceset != NULL)
1749 lttv_hooks_destroy(before_chunk_traceset);
1750
96c9eb79 1751 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1752 LTTV_BEFORE_CHUNK_TRACE,
1753 LTTV_POINTER,
96c9eb79 1754 &value);
1755 g_assert(result);
1756
91fd6881 1757 LttvHooks *before_chunk_trace = (LttvHooks*)*(value.v_pointer);
1758 if(before_chunk_trace != NULL)
1759 lttv_hooks_destroy(before_chunk_trace);
1760
96c9eb79 1761 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1762 LTTV_BEFORE_CHUNK_TRACEFILE,
1763 LTTV_POINTER,
96c9eb79 1764 &value);
1765 g_assert(result);
1766
91fd6881 1767 LttvHooks *before_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
1768 if(before_chunk_tracefile != NULL)
1769 lttv_hooks_destroy(before_chunk_tracefile);
1770
96c9eb79 1771 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1772 LTTV_AFTER_CHUNK_TRACESET,
1773 LTTV_POINTER,
96c9eb79 1774 &value);
1775 g_assert(result);
1776
91fd6881 1777 LttvHooks *after_chunk_traceset = (LttvHooks*)*(value.v_pointer);
1778 if(after_chunk_traceset != NULL)
1779 lttv_hooks_destroy(after_chunk_traceset);
1780
96c9eb79 1781 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1782 LTTV_AFTER_CHUNK_TRACE,
1783 LTTV_POINTER,
96c9eb79 1784 &value);
1785 g_assert(result);
1786
91fd6881 1787 LttvHooks *after_chunk_trace = (LttvHooks*)*(value.v_pointer);
1788 if(after_chunk_trace != NULL)
1789 lttv_hooks_destroy(after_chunk_trace);
1790
96c9eb79 1791 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1792 LTTV_AFTER_CHUNK_TRACEFILE,
1793 LTTV_POINTER,
96c9eb79 1794 &value);
1795 g_assert(result);
1796
91fd6881 1797 LttvHooks *after_chunk_tracefile = (LttvHooks*)*(value.v_pointer);
1798 if(after_chunk_tracefile != NULL)
1799 lttv_hooks_destroy(after_chunk_tracefile);
1800
96c9eb79 1801 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1802 LTTV_BEFORE_REQUEST,
1803 LTTV_POINTER,
96c9eb79 1804 &value);
1805 g_assert(result);
1806
91fd6881 1807 LttvHooks *before_request = (LttvHooks*)*(value.v_pointer);
1808 if(before_request != NULL)
1809 lttv_hooks_destroy(before_request);
1810
96c9eb79 1811 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1812 LTTV_AFTER_REQUEST,
1813 LTTV_POINTER,
96c9eb79 1814 &value);
1815 g_assert(result);
1816
91fd6881 1817 LttvHooks *after_request = (LttvHooks*)*(value.v_pointer);
1818 if(after_request != NULL)
1819 lttv_hooks_destroy(after_request);
1820
96c9eb79 1821 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1822 LTTV_EVENT_HOOK,
1823 LTTV_POINTER,
96c9eb79 1824 &value);
1825 g_assert(result);
1826
91fd6881 1827 LttvHooks *event_hook = (LttvHooks*)*(value.v_pointer);
1828 if(event_hook != NULL)
1829 lttv_hooks_destroy(event_hook);
1830
96c9eb79 1831 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
750eb11a 1832 LTTV_EVENT_HOOK_BY_ID_CHANNEL,
91fd6881 1833 LTTV_POINTER,
96c9eb79 1834 &value);
1835 g_assert(result);
1836
43ed82b5 1837 LttvHooksByIdChannelArray *event_hook_by_id_channel = (LttvHooksByIdChannelArray*)*(value.v_pointer);
750eb11a 1838 if(event_hook_by_id_channel != NULL)
1839 lttv_hooks_by_id_channel_destroy(event_hook_by_id_channel);
91fd6881 1840
96c9eb79 1841 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1842 LTTV_HOOK_ADDER,
1843 LTTV_POINTER,
96c9eb79 1844 &value);
1845 g_assert(result);
1846
91fd6881 1847 LttvHooks *hook_adder = (LttvHooks*)*(value.v_pointer);
1848 if(hook_adder != NULL)
1849 lttv_hooks_destroy(hook_adder);
1850
96c9eb79 1851 result = lttv_iattribute_find(LTTV_IATTRIBUTE(attribute),
91fd6881 1852 LTTV_HOOK_REMOVER,
1853 LTTV_POINTER,
96c9eb79 1854 &value);
1855 g_assert(result);
1856
91fd6881 1857 LttvHooks *hook_remover = (LttvHooks*)*(value.v_pointer);
1858 if(hook_remover != NULL)
1859 lttv_hooks_destroy(hook_remover);
1860
1861
e62a7964 1862 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
750eb11a 1863 LTTV_EVENT_HOOK_BY_ID_CHANNEL);
e62a7964 1864 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1865 LTTV_EVENT_HOOK);
1866
1867 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1868 LTTV_AFTER_REQUEST);
1869 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1870 LTTV_BEFORE_REQUEST);
1871
1872 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1873 LTTV_AFTER_CHUNK_TRACEFILE);
1874 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1875 LTTV_AFTER_CHUNK_TRACE);
1876 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1877 LTTV_AFTER_CHUNK_TRACESET);
1878
1879 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1880 LTTV_BEFORE_CHUNK_TRACEFILE);
1881 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1882 LTTV_BEFORE_CHUNK_TRACE);
1883 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1884 LTTV_BEFORE_CHUNK_TRACESET);
313bd6fc 1885 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1886 LTTV_HOOK_ADDER);
1887 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1888 LTTV_HOOK_REMOVER);
1889
e62a7964 1890 /* finally, remove module name */
96c9eb79 1891 attribute =
e62a7964 1892 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(LTTV_IATTRIBUTE(g_attribute),
96c9eb79 1893 LTTV_COMPUTATION));
1894 g_assert(attribute);
e62a7964 1895 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1896 module_name);
1897
1898}
1899
b052368a 1900/**
1901 * Lock a trace so no other instance can use it.
1902 *
1903 * @param trace The trace to lock.
1904 * @return 0 on success, -1 if cannot get lock.
1905 */
1906gint lttvwindowtraces_lock(LttvTrace *trace)
1907{
1908 LttvAttribute *attribute = lttv_trace_attribute(trace);
1909 LttvAttributeValue value;
1910 LttvAttributeType type;
1911
1912 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1913 LTTV_LOCK,
1914 &value);
1915 /* Verify the absence of the lock. */
1916 if(type != LTTV_NONE) {
1917 g_critical("Cannot take trace lock");
1918 return -1;
1919 }
1920
1921 value = lttv_iattribute_add(LTTV_IATTRIBUTE(attribute),
1922 LTTV_LOCK,
1923 LTTV_INT);
1924 /* the value is left unset. The only presence of the attribute is necessary.
1925 */
1926
1927 return 0;
1928}
1929
1930/**
1931 * Unlock a trace.
1932 *
1933 * @param trace The trace to unlock.
1934 * @return 0 on success, -1 if cannot unlock (not locked ?).
1935 */
1936gint lttvwindowtraces_unlock(LttvTrace *trace)
1937{
1938 LttvAttribute *attribute = lttv_trace_attribute(trace);
1939 LttvAttributeType type;
1940 LttvAttributeValue value;
1941
1942 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1943 LTTV_LOCK,
1944 &value);
1945 /* Verify the presence of the lock. */
1946 if(type == LTTV_NONE) {
1947 g_critical("Cannot release trace lock");
1948 return -1;
1949 }
1950
1951 lttv_iattribute_remove_by_name(LTTV_IATTRIBUTE(attribute),
1952 LTTV_LOCK);
1953
1954 return 0;
1955}
1956
1957/**
1958 * Verify if a trace is locked.
1959 *
1960 * @param trace The trace to verify.
1961 * @return TRUE if locked, FALSE is unlocked.
1962 */
1963gint lttvwindowtraces_get_lock_state(LttvTrace *trace)
1964{
1965 LttvAttribute *attribute = lttv_trace_attribute(trace);
1966 LttvAttributeType type;
1967 LttvAttributeValue value;
1968
1969 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
1970 LTTV_LOCK,
1971 &value);
1972 /* The only presence of the attribute is necessary. */
1973 if(type == LTTV_NONE)
1974 return FALSE;
1975 else
1976 return TRUE;
1977}
e62a7964 1978
LTTng 2.x Viewer (LTTV)
This page took 0.153316 seconds and 4 git commands to generate.