tags/LinuxTraceToolkitViewer-0.10.0-pre-115102007/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.c

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