ltt/branches/poly/lttv/lttv/tracecontext.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Michel Dagenais
   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 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <string.h>
  24 #include <lttv/tracecontext.h>
  25 #include <ltt/event.h>
  26 #include <ltt/facility.h>
  27 #include <ltt/trace.h>
  28 #include <ltt/type.h>
  29 #include <errno.h>
  30
  31
  32
  33
  34 gint compare_tracefile(gconstpointer a, gconstpointer b)
  35 {
  36   gint comparison = 0;
  37
  38   const LttvTracefileContext *trace_a = (const LttvTracefileContext *)a;
  39   const LttvTracefileContext *trace_b = (const LttvTracefileContext *)b;
  40
  41   if(likely(trace_a != trace_b)) {
  42     comparison = ltt_time_compare(trace_b->timestamp, trace_a->timestamp);
  43     if(unlikely(comparison == 0)) {
  44       if(trace_a->index < trace_b->index) comparison = -1;
  45       else if(trace_a->index > trace_b->index) comparison = 1;
  46       else if(trace_a->t_context->index < trace_b->t_context->index)
  47         comparison = -1;
  48       else if(trace_a->t_context->index > trace_b->t_context->index)
  49         comparison = 1;
  50     }
  51   }
  52   return comparison;
  53 }
  54
  55 struct _LttvTracesetContextPosition {
  56   GArray *ep;                        /* Array of LttEventPosition */
  57   GArray *tfc;                       /* Array of corresponding
  58                                         TracefileContext* */
  59   LttTime timestamp;                 /* Current time at the saved position */
  60 };
  61
  62 void lttv_context_init(LttvTracesetContext *self, LttvTraceset *ts)
  63 {
  64   LTTV_TRACESET_CONTEXT_GET_CLASS(self)->init(self, ts);
  65 }
  66
  67
  68 void lttv_context_fini(LttvTracesetContext *self)
  69 {
  70   LTTV_TRACESET_CONTEXT_GET_CLASS(self)->fini(self);
  71 }
  72
  73
  74 LttvTracesetContext *
  75 lttv_context_new_traceset_context(LttvTracesetContext *self)
  76 {
  77   return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_traceset_context(self);
  78 }
  79
  80
  81
  82
  83 LttvTraceContext *
  84 lttv_context_new_trace_context(LttvTracesetContext *self)
  85 {
  86   return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
  87 }
  88
  89
  90 LttvTracefileContext *
  91 lttv_context_new_tracefile_context(LttvTracesetContext *self)
  92 {
  93   return LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
  94 }
  95
  96 /****************************************************************************
  97  * lttv_traceset_context_compute_time_span
  98  *
  99  * Keep the time span is sync with on the fly addition and removal of traces
 100  * in a trace set. It must be called each time a trace is added/removed from
 101  * the traceset. It could be more efficient to call it only once a bunch
 102  * of traces are loaded, but the calculation is not long, so it's not
 103  * critical.
 104  *
 105  * Author : Xang Xiu Yang
 106  ***************************************************************************/
 107 static void lttv_traceset_context_compute_time_span(
 108                                           LttvTracesetContext *self,
 109                                                                   TimeInterval *time_span)
 110 {
 111   LttvTraceset * traceset = self->ts;
 112   int numTraces = lttv_traceset_number(traceset);
 113   int i;
 114   LttTime s, e;
 115   LttvTraceContext *tc;
 116   LttTrace * trace;
 117
 118   time_span->start_time.tv_sec = 0;
 119   time_span->start_time.tv_nsec = 0;
 120   time_span->end_time.tv_sec = 0;
 121   time_span->end_time.tv_nsec = 0;
 122
 123   for(i=0; i<numTraces;i++){
 124     tc = self->traces[i];
 125     trace = tc->t;
 126
 127     ltt_trace_time_span_get(trace, &s, &e);
 128
 129     if(i==0){
 130       time_span->start_time = s;
 131       time_span->end_time   = e;
 132     }else{
 133       if(s.tv_sec < time_span->start_time.tv_sec
 134           || (s.tv_sec == time_span->start_time.tv_sec
 135                && s.tv_nsec < time_span->start_time.tv_nsec))
 136               time_span->start_time = s;
 137       if(e.tv_sec > time_span->end_time.tv_sec
 138           || (e.tv_sec == time_span->end_time.tv_sec
 139                && e.tv_nsec > time_span->end_time.tv_nsec))
 140         time_span->end_time = e;
 141     }
 142   }
 143 }
 144
 145 static void init_tracefile_context(LttTracefile *tracefile,
 146                                     LttvTraceContext *tc)
 147 {
 148   LttvTracefileContext *tfc;
 149   LttvTracesetContext *tsc = tc->ts_context;
 150
 151   tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(tsc)->new_tracefile_context(tsc);
 152
 153   tfc->index = tc->tracefiles->len;
 154   tc->tracefiles = g_array_append_val(tc->tracefiles, tfc);
 155
 156   tfc->tf = tracefile;
 157
 158   tfc->t_context = tc;
 159   tfc->event = lttv_hooks_new();
 160   tfc->event_by_id = lttv_hooks_by_id_new();
 161   tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 162 }
 163
 164
 165 static void
 166 init(LttvTracesetContext *self, LttvTraceset *ts)
 167 {
 168   guint i, j, nb_trace;
 169
 170   LttvTraceContext *tc;
 171
 172   GData **tracefiles_groups;
 173
 174   struct compute_tracefile_group_args args;
 175
 176   nb_trace = lttv_traceset_number(ts);
 177   self->ts = ts;
 178   self->traces = g_new(LttvTraceContext *, nb_trace);
 179   self->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 180   self->ts_a = lttv_traceset_attribute(ts);
 181   for(i = 0 ; i < nb_trace ; i++) {
 182     tc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_trace_context(self);
 183     self->traces[i] = tc;
 184
 185     tc->ts_context = self;
 186     tc->index = i;
 187     tc->vt = lttv_traceset_get(ts, i);
 188     tc->t = lttv_trace(tc->vt);
 189     tc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 190     tc->t_a = lttv_trace_attribute(tc->vt);
 191     tc->tracefiles = g_array_sized_new(FALSE, TRUE,
 192                         sizeof(LttvTracefileContext*), 10);
 193
 194     tracefiles_groups = ltt_trace_get_tracefiles_groups(tc->t);
 195     if(tracefiles_groups != NULL) {
 196       args.func = (ForEachTraceFileFunc)init_tracefile_context;
 197       args.func_args = tc;
 198
 199       g_datalist_foreach(tracefiles_groups,
 200                             (GDataForeachFunc)compute_tracefile_group,
 201                             &args);
 202     }
 203
 204 #if 0
 205     nb_control = ltt_trace_control_tracefile_number(tc->t);
 206     nb_per_cpu = ltt_trace_per_cpu_tracefile_number(tc->t);
 207     nb_tracefile = nb_control + nb_per_cpu;
 208     tc->tracefiles = g_new(LttvTracefileContext *, nb_tracefile);
 209
 210     for(j = 0 ; j < nb_tracefile ; j++) {
 211       tfc = LTTV_TRACESET_CONTEXT_GET_CLASS(self)->new_tracefile_context(self);
 212       tc->tracefiles[j] = tfc;
 213       tfc->index = j;
 214
 215       if(j < nb_control) {
 216         tfc->control = TRUE;
 217         tfc->tf = ltt_trace_control_tracefile_get(tc->t, j);
 218       }
 219       else {
 220         tfc->control = FALSE;
 221         tfc->tf = ltt_trace_per_cpu_tracefile_get(tc->t, j - nb_control);
 222       }
 223
 224       tfc->t_context = tc;
 225       tfc->e = ltt_event_new();
 226       tfc->event = lttv_hooks_new();
 227       tfc->event_by_id = lttv_hooks_by_id_new();
 228       tfc->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 229     }
 230 #endif //0
 231
 232   }
 233   self->pqueue = g_tree_new(compare_tracefile);
 234   lttv_process_traceset_seek_time(self, ltt_time_zero);
 235   lttv_traceset_context_compute_time_span(self, &self->time_span);
 236
 237 }
 238
 239
 240 void fini(LttvTracesetContext *self)
 241 {
 242   guint i, j, nb_trace, nb_tracefile;
 243
 244   LttvTraceContext *tc;
 245
 246   LttvTracefileContext **tfc;
 247
 248   LttvTraceset *ts = self->ts;
 249
 250   g_tree_destroy(self->pqueue);
 251   g_object_unref(self->a);
 252
 253   nb_trace = lttv_traceset_number(ts);
 254
 255   for(i = 0 ; i < nb_trace ; i++) {
 256     tc = self->traces[i];
 257
 258     g_object_unref(tc->a);
 259
 260     nb_tracefile = tc->tracefiles->len;
 261
 262     for(j = 0 ; j < nb_tracefile ; j++) {
 263       tfc = &g_array_index(tc->tracefiles, LttvTracefileContext*, j);
 264       lttv_hooks_destroy((*tfc)->event);
 265       lttv_hooks_by_id_destroy((*tfc)->event_by_id);
 266       g_object_unref((*tfc)->a);
 267       g_object_unref(*tfc);
 268     }
 269     g_array_free(tc->tracefiles, TRUE);
 270     g_object_unref(tc);
 271   }
 272   g_free(self->traces);
 273 }
 274
 275
 276 void lttv_traceset_context_add_hooks(LttvTracesetContext *self,
 277     LttvHooks *before_traceset,
 278     LttvHooks *before_trace,
 279     LttvHooks *before_tracefile,
 280     LttvHooks *event,
 281     LttvHooksById *event_by_id)
 282 {
 283   LttvTraceset *ts = self->ts;
 284
 285   guint i, nb_trace;
 286
 287   LttvTraceContext *tc;
 288
 289   lttv_hooks_call(before_traceset, self);
 290
 291   nb_trace = lttv_traceset_number(ts);
 292
 293   for(i = 0 ; i < nb_trace ; i++) {
 294     tc = self->traces[i];
 295     lttv_trace_context_add_hooks(tc,
 296                                  before_trace,
 297                                  before_tracefile,
 298                                  event,
 299                                  event_by_id);
 300   }
 301 }
 302
 303
 304 void lttv_traceset_context_remove_hooks(LttvTracesetContext *self,
 305     LttvHooks *after_traceset,
 306     LttvHooks *after_trace,
 307     LttvHooks *after_tracefile,
 308     LttvHooks *event,
 309     LttvHooksById *event_by_id)
 310 {
 311
 312   LttvTraceset *ts = self->ts;
 313
 314   guint i, nb_trace;
 315
 316   LttvTraceContext *tc;
 317
 318   nb_trace = lttv_traceset_number(ts);
 319
 320   for(i = 0 ; i < nb_trace ; i++) {
 321     tc = self->traces[i];
 322     lttv_trace_context_remove_hooks(tc,
 323                                     after_trace,
 324                                     after_tracefile,
 325                                     event,
 326                                     event_by_id);
 327   }
 328
 329   lttv_hooks_call(after_traceset, self);
 330
 331
 332 }
 333
 334 void lttv_trace_context_add_hooks(LttvTraceContext *self,
 335     LttvHooks *before_trace,
 336     LttvHooks *before_tracefile,
 337     LttvHooks *event,
 338     LttvHooksById *event_by_id)
 339 {
 340   guint i, nb_tracefile;
 341
 342   LttvTracefileContext **tfc;
 343
 344   lttv_hooks_call(before_trace, self);
 345
 346   nb_tracefile = self->tracefiles->len;
 347
 348   for(i = 0 ; i < nb_tracefile ; i++) {
 349     tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
 350     lttv_tracefile_context_add_hooks(*tfc,
 351                                      before_tracefile,
 352                                      event,
 353                                      event_by_id);
 354   }
 355 }
 356
 357
 358
 359 void lttv_trace_context_remove_hooks(LttvTraceContext *self,
 360     LttvHooks *after_trace,
 361     LttvHooks *after_tracefile,
 362     LttvHooks *event,
 363     LttvHooksById *event_by_id)
 364 {
 365   guint i, nb_tracefile;
 366
 367   LttvTracefileContext **tfc;
 368
 369   nb_tracefile = self->tracefiles->len;
 370
 371   for(i = 0 ; i < nb_tracefile ; i++) {
 372     tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
 373     lttv_tracefile_context_remove_hooks(*tfc,
 374                                         after_tracefile,
 375                                         event,
 376                                         event_by_id);
 377   }
 378
 379   lttv_hooks_call(after_trace, self);
 380 }
 381
 382 void lttv_tracefile_context_add_hooks(LttvTracefileContext *self,
 383           LttvHooks *before_tracefile,
 384           LttvHooks *event,
 385           LttvHooksById *event_by_id)
 386 {
 387   guint i, index;
 388
 389   LttvHooks *hook;
 390
 391   lttv_hooks_call(before_tracefile, self);
 392   lttv_hooks_add_list(self->event, event);
 393   if(event_by_id != NULL) {
 394     for(i = 0; i < event_by_id->array->len; i++) {
 395       index = g_array_index(event_by_id->array, guint, i);
 396       hook = lttv_hooks_by_id_find(self->event_by_id, index);
 397       lttv_hooks_add_list(hook, lttv_hooks_by_id_get(event_by_id, index));
 398     }
 399   }
 400 }
 401
 402 void lttv_tracefile_context_remove_hooks(LttvTracefileContext *self,
 403            LttvHooks *after_tracefile,
 404            LttvHooks *event,
 405            LttvHooksById *event_by_id)
 406 {
 407   guint i, index;
 408
 409   LttvHooks *hook;
 410
 411   lttv_hooks_remove_list(self->event, event);
 412   if(event_by_id != NULL) {
 413     for(i = 0; i < event_by_id->array->len; i++) {
 414       index = g_array_index(event_by_id->array, guint, i);
 415       hook = lttv_hooks_by_id_get(self->event_by_id, index);
 416       if(hook != NULL)
 417         lttv_hooks_remove_list(hook, lttv_hooks_by_id_get(event_by_id, index));
 418     }
 419   }
 420
 421   lttv_hooks_call(after_tracefile, self);
 422 }
 423
 424
 425
 426 void lttv_tracefile_context_add_hooks_by_id(LttvTracefileContext *tfc,
 427                                             unsigned i,
 428                                             LttvHooks *event_by_id)
 429 {
 430   LttvHooks * h;
 431   h = lttv_hooks_by_id_find(tfc->event_by_id, i);
 432   lttv_hooks_add_list(h, event_by_id);
 433 }
 434
 435 void lttv_tracefile_context_remove_hooks_by_id(LttvTracefileContext *tfc,
 436                                                unsigned i)
 437 {
 438   lttv_hooks_by_id_remove(tfc->event_by_id, i);
 439 }
 440
 441 static LttvTracesetContext *
 442 new_traceset_context(LttvTracesetContext *self)
 443 {
 444   return g_object_new(LTTV_TRACESET_CONTEXT_TYPE, NULL);
 445 }
 446
 447
 448 static LttvTraceContext *
 449 new_trace_context(LttvTracesetContext *self)
 450 {
 451   return g_object_new(LTTV_TRACE_CONTEXT_TYPE, NULL);
 452 }
 453
 454
 455 static LttvTracefileContext *
 456 new_tracefile_context(LttvTracesetContext *self)
 457 {
 458   return g_object_new(LTTV_TRACEFILE_CONTEXT_TYPE, NULL);
 459 }
 460
 461
 462 static void
 463 traceset_context_instance_init (GTypeInstance *instance, gpointer g_class)
 464 {
 465   /* Be careful of anything which would not work well with shallow copies */
 466 }
 467
 468
 469 static void
 470 traceset_context_finalize (LttvTracesetContext *self)
 471 {
 472   G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACESET_CONTEXT_TYPE)))
 473       ->finalize(G_OBJECT(self));
 474 }
 475
 476
 477 static void
 478 traceset_context_class_init (LttvTracesetContextClass *klass)
 479 {
 480   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 481
 482   gobject_class->finalize = (void (*)(GObject *self))traceset_context_finalize;
 483   klass->init = init;
 484   klass->fini = fini;
 485   klass->new_traceset_context = new_traceset_context;
 486   klass->new_trace_context = new_trace_context;
 487   klass->new_tracefile_context = new_tracefile_context;
 488 }
 489
 490
 491 GType
 492 lttv_traceset_context_get_type(void)
 493 {
 494   static GType type = 0;
 495   if (type == 0) {
 496     static const GTypeInfo info = {
 497       sizeof (LttvTracesetContextClass),
 498       NULL,   /* base_init */
 499       NULL,   /* base_finalize */
 500       (GClassInitFunc) traceset_context_class_init,   /* class_init */
 501       NULL,   /* class_finalize */
 502       NULL,   /* class_data */
 503       sizeof (LttvTracesetContext),
 504       0,      /* n_preallocs */
 505       (GInstanceInitFunc) traceset_context_instance_init, /* instance_init */
 506       NULL    /* Value handling */
 507     };
 508
 509     type = g_type_register_static (G_TYPE_OBJECT, "LttvTracesetContextType",
 510         &info, 0);
 511   }
 512   return type;
 513 }
 514
 515
 516 static void
 517 trace_context_instance_init (GTypeInstance *instance, gpointer g_class)
 518 {
 519   /* Be careful of anything which would not work well with shallow copies */
 520 }
 521
 522
 523 static void
 524 trace_context_finalize (LttvTraceContext *self)
 525 {
 526   G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACE_CONTEXT_TYPE)))->
 527       finalize(G_OBJECT(self));
 528 }
 529
 530
 531 static void
 532 trace_context_class_init (LttvTraceContextClass *klass)
 533 {
 534   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 535
 536   gobject_class->finalize = (void (*)(GObject *self)) trace_context_finalize;
 537 }
 538
 539
 540 GType
 541 lttv_trace_context_get_type(void)
 542 {
 543   static GType type = 0;
 544   if (type == 0) {
 545     static const GTypeInfo info = {
 546       sizeof (LttvTraceContextClass),
 547       NULL,   /* base_init */
 548       NULL,   /* base_finalize */
 549       (GClassInitFunc) trace_context_class_init,   /* class_init */
 550       NULL,   /* class_finalize */
 551       NULL,   /* class_data */
 552       sizeof (LttvTraceContext),
 553       0,      /* n_preallocs */
 554       (GInstanceInitFunc) trace_context_instance_init,    /* instance_init */
 555       NULL    /* Value handling */
 556     };
 557
 558     type = g_type_register_static (G_TYPE_OBJECT, "LttvTraceContextType",
 559         &info, 0);
 560   }
 561   return type;
 562 }
 563
 564
 565 static void
 566 tracefile_context_instance_init (GTypeInstance *instance, gpointer g_class)
 567 {
 568   /* Be careful of anything which would not work well with shallow copies */
 569 }
 570
 571
 572 static void
 573 tracefile_context_finalize (LttvTracefileContext *self)
 574 {
 575   G_OBJECT_CLASS(g_type_class_peek(g_type_parent(LTTV_TRACEFILE_CONTEXT_TYPE)))
 576       ->finalize(G_OBJECT(self));
 577 }
 578
 579
 580 static void
 581 tracefile_context_class_init (LttvTracefileContextClass *klass)
 582 {
 583   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 584
 585   gobject_class->finalize = (void (*)(GObject *self))tracefile_context_finalize;
 586 }
 587
 588
 589 GType
 590 lttv_tracefile_context_get_type(void)
 591 {
 592   static GType type = 0;
 593   if (type == 0) {
 594     static const GTypeInfo info = {
 595       sizeof (LttvTracefileContextClass),
 596       NULL,   /* base_init */
 597       NULL,   /* base_finalize */
 598       (GClassInitFunc) tracefile_context_class_init,   /* class_init */
 599       NULL,   /* class_finalize */
 600       NULL,   /* class_data */
 601       sizeof (LttvTracefileContext),
 602       0,      /* n_preallocs */
 603       (GInstanceInitFunc) tracefile_context_instance_init,    /* instance_init */
 604       NULL    /* Value handling */
 605     };
 606
 607     type = g_type_register_static (G_TYPE_OBJECT, "LttvTracefileContextType",
 608         &info, 0);
 609   }
 610   return type;
 611 }
 612
 613
 614
 615 static gboolean get_first(gpointer key, gpointer value, gpointer user_data) {
 616   g_assert(key == value);
 617   *((LttvTracefileContext **)user_data) = (LttvTracefileContext *)value;
 618   return TRUE;
 619 }
 620
 621 static gboolean test_tree(gpointer key, gpointer value, gpointer user_data) {
 622
 623   LttvTracefileContext *tfc = (LttvTracefileContext *)key;
 624
 625   g_debug("Tracefile name %s, time %lu.%lu, tfi %u, ti %u",
 626       g_quark_to_string(ltt_tracefile_name(tfc->tf)),
 627       tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec,
 628       tfc->index, tfc->t_context->index);
 629
 630   if(((LttvTracefileContext *)user_data) == (LttvTracefileContext *)value) {
 631     g_assert(compare_tracefile(user_data, value) == 0);
 632   } else
 633     g_assert(compare_tracefile(user_data, value) != 0);
 634
 635   //g_assert(((LttvTracefileContext *)user_data) != (LttvTracefileContext *)value);
 636   return FALSE;
 637 }
 638
 639
 640
 641 void lttv_process_traceset_begin(LttvTracesetContext *self,
 642                                  LttvHooks       *before_traceset,
 643                                  LttvHooks       *before_trace,
 644                                  LttvHooks       *before_tracefile,
 645                                  LttvHooks       *event,
 646                                  LttvHooksById   *event_by_id)
 647 {
 648
 649   /* simply add hooks in context. _before hooks are called by add_hooks. */
 650   /* It calls all before_traceset, before_trace, and before_tracefile hooks. */
 651   lttv_traceset_context_add_hooks(self,
 652                                   before_traceset,
 653                                   before_trace,
 654                                   before_tracefile,
 655                                   event,
 656                                   event_by_id);
 657
 658 }
 659
 660 /* Note : a _middle must be preceded from a _seek or another middle */
 661 guint lttv_process_traceset_middle(LttvTracesetContext *self,
 662                               LttTime end,
 663                               guint nb_events,
 664                               const LttvTracesetContextPosition *end_position)
 665 {
 666   GTree *pqueue = self->pqueue;
 667
 668   guint fac_id, ev_id, id;
 669
 670   LttvTracefileContext *tfc;
 671
 672   LttEvent *e;
 673
 674   unsigned count = 0;
 675
 676   guint read_ret = FALSE;
 677
 678   gboolean last_ret = FALSE; /* return value of the last hook list called */
 679
 680   /* Get the next event from the pqueue, call its hooks,
 681      reinsert in the pqueue the following event from the same tracefile
 682      unless the tracefile is finished or the event is later than the
 683      end time. */
 684
 685   while(TRUE) {
 686     tfc = NULL;
 687     g_tree_foreach(pqueue, get_first, &tfc);
 688     /* End of traceset : tfc is NULL */
 689     if(unlikely(tfc == NULL))
 690     {
 691       return count;
 692     }
 693
 694     /* Have we reached :
 695      * - the maximum number of events specified?
 696      * - the end position ?
 697      * - the end time ?
 698      * then the read is finished. We leave the queue in the same state and
 699      * break the loop.
 700      */
 701
 702     if(unlikely(last_ret == TRUE ||
 703                 ((count >= nb_events) && (nb_events != G_MAXULONG)) ||
 704      (end_position!=NULL&&lttv_traceset_context_ctx_pos_compare(self,
 705                                                           end_position) == 0)||
 706        ltt_time_compare(end, tfc->timestamp) <= 0))
 707     {
 708       return count;
 709     }
 710
 711     /* Get the tracefile with an event for the smallest time found. If two
 712        or more tracefiles have events for the same time, hope that lookup
 713        and remove are consistent. */
 714
 715 #ifdef DEBUG
 716     g_debug("test tree before remove");
 717     g_tree_foreach(pqueue, test_tree, tfc);
 718 #endif //DEBUG
 719     g_tree_remove(pqueue, tfc);
 720
 721 #ifdef DEBUG
 722     g_debug("test tree after remove");
 723     g_tree_foreach(pqueue, test_tree, tfc);
 724 #endif //DEBUG
 725
 726     count++;
 727
 728     e = ltt_tracefile_get_event(tfc->tf);
 729     fac_id = ltt_event_facility_id(e);
 730     ev_id = ltt_event_eventtype_id(e);
 731     id = GET_HOOK_ID(fac_id, ev_id);
 732     last_ret = lttv_hooks_call_merge(tfc->event, tfc,
 733                         lttv_hooks_by_id_get(tfc->event_by_id, id), tfc);
 734
 735     read_ret = ltt_tracefile_read(tfc->tf);
 736
 737     if(likely(!read_ret)) {
 738       g_debug("An event is ready");
 739       tfc->timestamp = ltt_event_time(e);
 740
 741             g_tree_insert(pqueue, tfc, tfc);
 742     } else {
 743       tfc->timestamp = ltt_time_infinite;
 744
 745       if(read_ret == ERANGE)
 746         g_debug("End of trace");
 747       else
 748         g_error("Error happened in lttv_process_traceset_middle");
 749     }
 750   }
 751 }
 752
 753
 754 void lttv_process_traceset_end(LttvTracesetContext *self,
 755                                LttvHooks           *after_traceset,
 756                                LttvHooks           *after_trace,
 757                                LttvHooks           *after_tracefile,
 758                                LttvHooks           *event,
 759                                LttvHooksById       *event_by_id)
 760 {
 761   /* Remove hooks from context. _after hooks are called by remove_hooks. */
 762   /* It calls all after_traceset, after_trace, and after_tracefile hooks. */
 763   lttv_traceset_context_remove_hooks(self,
 764                                      after_traceset,
 765                                      after_trace,
 766                                      after_tracefile,
 767                                      event,
 768                                      event_by_id);
 769 }
 770
 771 /* Subtile modification :
 772  * if tracefile has no event at or after the time requested, it is not put in
 773  * the queue, as the next read would fail. */
 774 void lttv_process_trace_seek_time(LttvTraceContext *self, LttTime start)
 775 {
 776   guint i, nb_tracefile;
 777
 778   gint ret;
 779
 780   LttvTracefileContext **tfc;
 781
 782   GTree *pqueue = self->ts_context->pqueue;
 783
 784   nb_tracefile = self->tracefiles->len;
 785
 786   for(i = 0 ; i < nb_tracefile ; i++) {
 787     tfc = &g_array_index(self->tracefiles, LttvTracefileContext*, i);
 788
 789     g_tree_remove(pqueue, *tfc);
 790
 791     ret = ltt_tracefile_seek_time((*tfc)->tf, start);
 792     if(ret == EPERM) g_error("error in lttv_process_trace_seek_time seek");
 793
 794     if(ret == 0) { /* not ERANGE especially */
 795       (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
 796       g_tree_insert(pqueue, (*tfc), (*tfc));
 797     } else {
 798       (*tfc)->timestamp = ltt_time_infinite;
 799     }
 800   }
 801 }
 802
 803
 804 void lttv_process_traceset_seek_time(LttvTracesetContext *self, LttTime start)
 805 {
 806   guint i, nb_trace;
 807
 808   LttvTraceContext *tc;
 809
 810   nb_trace = lttv_traceset_number(self->ts);
 811   for(i = 0 ; i < nb_trace ; i++) {
 812     tc = self->traces[i];
 813     lttv_process_trace_seek_time(tc, start);
 814   }
 815 }
 816
 817
 818 gboolean lttv_process_traceset_seek_position(LttvTracesetContext *self,
 819                                         const LttvTracesetContextPosition *pos)
 820 {
 821   guint i;
 822   LttvTraceContext *tc;
 823   LttvTracefileContext *tfc;
 824
 825   g_tree_destroy(self->pqueue);
 826   self->pqueue = g_tree_new(compare_tracefile);
 827
 828   for(i=0;i<pos->ep->len; i++) {
 829     LttEventPosition **ep = &g_array_index(pos->ep, LttEventPosition*, i);
 830     LttvTracefileContext **tfc =
 831       &g_array_index(pos->tfc, LttvTracefileContext*, i);
 832     if(*ep != NULL) {
 833       g_assert(ltt_tracefile_seek_position((*tfc)->tf, *ep) == 0);
 834       (*tfc)->timestamp = ltt_event_time(ltt_tracefile_get_event((*tfc)->tf));
 835       g_tree_insert(self->pqueue, (*tfc), (*tfc));
 836     } else {
 837       (*tfc)->timestamp = ltt_time_infinite;
 838     }
 839   }
 840   return TRUE;
 841 }
 842
 843
 844
 845 static LttField *
 846 find_field(LttEventType *et, const GQuark field)
 847 {
 848   LttType *t;
 849
 850   LttField *f;
 851
 852   guint i, nb;
 853
 854   GQuark name;
 855
 856   /* Field is unset */
 857   if(field == 0) return NULL;
 858
 859   f = ltt_eventtype_field(et);
 860   t = ltt_eventtype_type(et);
 861   g_assert(ltt_type_class(t) == LTT_STRUCT);
 862   nb = ltt_type_member_number(t);
 863   for(i = 0 ; i < nb ; i++) {
 864     ltt_type_member_type(t, i, &name);
 865     if(name == field) break;
 866   }
 867   g_assert(i < nb);
 868   return ltt_field_member(f, i);
 869 }
 870
 871 LttvTraceHookByFacility *lttv_trace_hook_get_fac(LttvTraceHook *th,
 872                                                  guint facility_id)
 873 {
 874   return &g_array_index(th->fac_index, LttvTraceHookByFacility, facility_id);
 875 }
 876
 877 /* Get the first facility corresponding to the name. As the types must be
 878  * compatible, it is relevant to use the field name and sizes of the first
 879  * facility to create data structures and assume the data will be compatible
 880  * thorough the trace */
 881 LttvTraceHookByFacility *lttv_trace_hook_get_first(LttvTraceHook *th)
 882 {
 883   g_assert(th->fac_list->len > 0);
 884   return g_array_index(th->fac_list, LttvTraceHookByFacility*, 0);
 885 }
 886
 887
 888 /* Returns 0 on success, -1 if fails. */
 889 gint
 890 lttv_trace_find_hook(LttTrace *t, GQuark facility, GQuark event,
 891     GQuark field1, GQuark field2, GQuark field3, LttvHook h, LttvTraceHook *th)
 892 {
 893   LttFacility *f;
 894
 895   LttEventType *et, *first_et;
 896
 897   GArray *facilities;
 898
 899   guint i, fac_id, ev_id;
 900
 901   LttvTraceHookByFacility *thf, *first_thf;
 902
 903   facilities = ltt_trace_facility_get_by_name(t, facility);
 904
 905   if(unlikely(facilities == NULL)) goto facility_error;
 906
 907   th->fac_index = g_array_sized_new(FALSE, TRUE,
 908              sizeof(LttvTraceHookByFacility),
 909              NUM_FACILITIES);
 910   th->fac_index = g_array_set_size(th->fac_index, NUM_FACILITIES);
 911
 912   th->fac_list = g_array_sized_new(FALSE, TRUE,
 913              sizeof(LttvTraceHookByFacility*),
 914              facilities->len);
 915   th->fac_list = g_array_set_size(th->fac_list, facilities->len);
 916
 917   fac_id = g_array_index(facilities, guint, 0);
 918   f = ltt_trace_get_facility_by_num(t, fac_id);
 919
 920   et = ltt_facility_eventtype_get_by_name(f, event);
 921   if(unlikely(et == NULL)) goto event_error;
 922
 923   thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
 924   g_array_index(th->fac_list, LttvTraceHookByFacility*, 0) = thf;
 925
 926   ev_id = ltt_eventtype_id(et);
 927
 928   thf->h = h;
 929   thf->id = GET_HOOK_ID(fac_id, ev_id);
 930   thf->f1 = find_field(et, field1);
 931   thf->f2 = find_field(et, field2);
 932   thf->f3 = find_field(et, field3);
 933
 934   first_thf = thf;
 935
 936   /* Check for type compatibility too */
 937   for(i=1;i<facilities->len;i++) {
 938     fac_id = g_array_index(facilities, guint, i);
 939     f = ltt_trace_get_facility_by_num(t, fac_id);
 940
 941     et = ltt_facility_eventtype_get_by_name(f, ltt_eventtype_name(et));
 942     if(unlikely(et == NULL)) goto event_error;
 943
 944     thf = &g_array_index(th->fac_index, LttvTraceHookByFacility, fac_id);
 945     g_array_index(th->fac_list, LttvTraceHookByFacility*, i) = thf;
 946     ev_id = ltt_eventtype_id(et);
 947     thf->h = h;
 948     thf->id = GET_HOOK_ID(fac_id, ev_id);
 949     thf->f1 = find_field(et, field1);
 950     if(check_fields_compatibility(first_et, et,
 951         first_thf->f1, thf->f1))
 952       goto type_error;
 953
 954     thf->f2 = find_field(et, field2);
 955     if(check_fields_compatibility(first_et, et,
 956         first_thf->f2, thf->f2))
 957       goto type_error;
 958
 959     thf->f3 = find_field(et, field3);
 960     if(check_fields_compatibility(first_et, et,
 961         first_thf->f3, thf->f3))
 962       goto type_error;
 963   }
 964
 965   return 0;
 966
 967 type_error:
 968   goto free;
 969 event_error:
 970   g_error("Event type %s does not exist",
 971       g_quark_to_string(ltt_eventtype_name(et)));
 972   goto free;
 973 facility_error:
 974   g_error("No %s facility", g_quark_to_string(facility));
 975   goto free;
 976 free:
 977   g_array_free(th->fac_index, TRUE);
 978   g_array_free(th->fac_list, TRUE);
 979   th->fac_index = NULL;
 980   th->fac_list = NULL;
 981   return -1;
 982 }
 983
 984 void lttv_trace_hook_destroy(LttvTraceHook *th)
 985 {
 986   g_array_free(th->fac_index, TRUE);
 987   g_array_free(th->fac_list, TRUE);
 988 }
 989
 990
 991 LttvTracesetContextPosition *lttv_traceset_context_position_new()
 992 {
 993   LttvTracesetContextPosition *pos = g_new(LttvTracesetContextPosition,1);
 994   pos->ep = g_array_sized_new(FALSE, TRUE, sizeof(LttEventPosition*),
 995                               10);
 996   pos->tfc = g_array_sized_new(FALSE, TRUE, sizeof(LttvTracefileContext*),
 997                               10);
 998   pos->timestamp = ltt_time_infinite;
 999   return pos;
1000 }
1001
1002 /* Save all positions, the ones not in the pqueue will have NULL
1003  * ep. */
1004 void lttv_traceset_context_position_save(const LttvTracesetContext *self,
1005                                     LttvTracesetContextPosition *pos)
1006 {
1007   guint i;
1008   guint num_traces = lttv_traceset_number(self->ts);
1009
1010   for(i=0; i<num_traces;i++) {
1011     GArray * tracefiles = self->traces[i]->tracefiles;
1012     guint j;
1013     guint num_tracefiles = tracefiles->len;
1014
1015     for(j=0;j<num_tracefiles;j++) {
1016       LttvTracefileContext **tfc = &g_array_index(tracefiles,
1017           LttvTracefileContext*, j);
1018
1019       LttEvent *event = ltt_tracefile_get_event((*tfc)->tf);
1020       LttEventPosition *ep;
1021
1022       if(ltt_time_compare((*tfc)->timestamp, ltt_time_infinite) != 0) {
1023         ep = ltt_event_position_new();
1024         ltt_event_position(event, ep);
1025         if(ltt_time_compare((*tfc)->timestamp, pos->timestamp) < 0)
1026           pos->timestamp = (*tfc)->timestamp;
1027       } else {
1028         ep = NULL;
1029       }
1030       g_array_append_val(pos->tfc, *tfc);
1031       g_array_append_val(pos->ep, ep);
1032     }
1033
1034   }
1035 }
1036
1037 void lttv_traceset_context_position_destroy(LttvTracesetContextPosition *pos)
1038 {
1039   int i;
1040   LttEventPosition **ep;
1041
1042   for(i=0;i<pos->ep->len;i++) {
1043     ep = &g_array_index(pos->ep, LttEventPosition*, i);
1044     if(*ep != NULL)
1045       g_free(*ep);
1046   }
1047   g_array_free(pos->ep, TRUE);
1048   g_array_free(pos->tfc, TRUE);
1049   g_free(pos);
1050 }
1051
1052 void lttv_traceset_context_position_copy(LttvTracesetContextPosition *dest,
1053                                    const LttvTracesetContextPosition *src)
1054 {
1055   int i;
1056   LttEventPosition **src_ep, **dest_ep;
1057
1058   g_array_set_size(dest->ep, src->ep->len);
1059   g_array_set_size(dest->tfc, src->tfc->len);
1060
1061   for(i=0;i<src->ep->len;i++) {
1062     src_ep = &g_array_index(src->ep, LttEventPosition*, i);
1063     dest_ep = &g_array_index(dest->ep, LttEventPosition*, i);
1064     if(*src_ep != NULL) {
1065       *dest_ep = ltt_event_position_new();
1066       ltt_event_position_copy(
1067           *dest_ep,
1068           *src_ep);
1069     } else
1070       *dest_ep = NULL;
1071   }
1072   for(i=0;i<src->tfc->len;i++) {
1073     g_array_index(dest->tfc, LttvTracefileContext*, i) =
1074                     g_array_index(src->tfc, LttvTracefileContext*, i);
1075   }
1076   dest->timestamp = src->timestamp;
1077 }
1078
1079 gint lttv_traceset_context_ctx_pos_compare(const LttvTracesetContext *self,
1080                                         const LttvTracesetContextPosition *pos)
1081 {
1082   int i;
1083   int ret;
1084
1085   for(i=0;i<pos->ep->len;i++) {
1086     LttEventPosition *ep = g_array_index(pos->ep, LttEventPosition*, i);
1087     LttvTracefileContext *tfc =
1088       g_array_index(pos->tfc, LttvTracefileContext*, i);
1089
1090     if(ep == NULL) {
1091       if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0) {
1092         ret = -1;
1093       }
1094     } else {
1095       if(ltt_time_compare(tfc->timestamp, ltt_time_infinite) == 0) {
1096         ret = 1;
1097       } else {
1098         LttEvent *event = ltt_tracefile_get_event(tfc->tf);
1099
1100         ret = ltt_event_position_compare((LttEventPosition*)event,
1101                                           ep);
1102       }
1103     }
1104     if(ret != 0) return ret;
1105
1106   }
1107   return 0;
1108 }
1109
1110
1111 gint lttv_traceset_context_pos_pos_compare(
1112                                   const LttvTracesetContextPosition *pos1,
1113                                   const LttvTracesetContextPosition *pos2)
1114 {
1115   int i, j;
1116   int ret;
1117
1118   for(i=0;i<pos1->ep->len;i++) {
1119     LttEventPosition *ep1 = g_array_index(pos1->ep, LttEventPosition*, i);
1120     LttvTracefileContext *tfc1 = g_array_index(pos1->tfc,
1121                                       LttvTracefileContext*, i);
1122
1123     if(ep1 != NULL) {
1124       for(j=0;j<pos2->ep->len;j++) {
1125         LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
1126         LttvTracefileContext *tfc2 = g_array_index(pos2->tfc,
1127                                            LttvTracefileContext*, j);
1128         if(tfc1 == tfc2) {
1129           if(ep2 != NULL)
1130             ret = ltt_event_position_compare(ep1, ep2);
1131           else
1132             ret = -1;
1133
1134           if(ret != 0) return ret;
1135         }
1136       }
1137     } else {
1138       for(j=0;j<pos2->ep->len;j++) {
1139         LttEventPosition *ep2 = g_array_index(pos2->ep, LttEventPosition*, j);
1140         LttvTracefileContext *tfc2 = g_array_index(pos2->tfc,
1141                                            LttvTracefileContext*, j);
1142         if(tfc1 == tfc2) {
1143           if(ep2 != NULL) ret = 1;
1144         }
1145       }
1146     }
1147   }
1148   return 0;
1149 }
1150
1151
1152 LttTime lttv_traceset_context_position_get_time(
1153                                   const LttvTracesetContextPosition *pos)
1154 {
1155   return pos->timestamp;
1156 }
1157
1158
1159 LttvTracefileContext *lttv_traceset_context_get_current_tfc(LttvTracesetContext *self)
1160 {
1161   GTree *pqueue = self->pqueue;
1162   LttvTracefileContext *tfc = NULL;
1163
1164   g_tree_foreach(pqueue, get_first, &tfc);
1165
1166   return tfc;
1167 }