ltt/branches/poly/lttv/lttv/state.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
  20 #include <lttv/lttv.h>
  21 #include <lttv/module.h>
  22 #include <lttv/state.h>
  23 #include <ltt/facility.h>
  24 #include <ltt/trace.h>
  25 #include <ltt/event.h>
  26 #include <ltt/type.h>
  27 #include <stdio.h>
  28
  29 LttvExecutionMode
  30   LTTV_STATE_MODE_UNKNOWN,
  31   LTTV_STATE_USER_MODE,
  32   LTTV_STATE_SYSCALL,
  33   LTTV_STATE_TRAP,
  34   LTTV_STATE_IRQ;
  35
  36 LttvExecutionSubmode
  37   LTTV_STATE_SUBMODE_UNKNOWN,
  38   LTTV_STATE_SUBMODE_NONE;
  39
  40 LttvProcessStatus
  41   LTTV_STATE_UNNAMED,
  42   LTTV_STATE_WAIT_FORK,
  43   LTTV_STATE_WAIT_CPU,
  44   LTTV_STATE_EXIT,
  45   LTTV_STATE_WAIT,
  46   LTTV_STATE_RUN;
  47
  48 static GQuark
  49   LTTV_STATE_TRACEFILES,
  50   LTTV_STATE_PROCESSES,
  51   LTTV_STATE_PROCESS,
  52   LTTV_STATE_EVENT,
  53   LTTV_STATE_SAVED_STATES,
  54   LTTV_STATE_SAVED_STATES_TIME,
  55   LTTV_STATE_TIME,
  56   LTTV_STATE_HOOKS,
  57   LTTV_STATE_NAME_TABLES,
  58   LTTV_STATE_TRACE_STATE_USE_COUNT;
  59
  60
  61 static void create_max_time(LttvTraceState *tcs);
  62
  63 static void get_max_time(LttvTraceState *tcs);
  64
  65 static void free_max_time(LttvTraceState *tcs);
  66
  67 static void create_name_tables(LttvTraceState *tcs);
  68
  69 static void get_name_tables(LttvTraceState *tcs);
  70
  71 static void free_name_tables(LttvTraceState *tcs);
  72
  73 static void free_saved_state(LttvTraceState *tcs);
  74
  75 static void lttv_state_free_process_table(GHashTable *processes);
  76
  77
  78 void lttv_state_save(LttvTraceState *self, LttvAttribute *container)
  79 {
  80   LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container);
  81 }
  82
  83
  84 void lttv_state_restore(LttvTraceState *self, LttvAttribute *container)
  85 {
  86   LTTV_TRACE_STATE_GET_CLASS(self)->state_restore(self, container);
  87 }
  88
  89
  90 void lttv_state_state_saved_free(LttvTraceState *self,
  91     LttvAttribute *container)
  92 {
  93   LTTV_TRACE_STATE_GET_CLASS(self)->state_saved_free(self, container);
  94 }
  95
  96
  97 guint process_hash(gconstpointer key)
  98 {
  99   return ((LttvProcessState *)key)->pid;
 100 }
 101
 102
 103 gboolean process_equal(gconstpointer a, gconstpointer b)
 104 {
 105   LttvProcessState *process_a, *process_b;
 106
 107   process_a = (LttvProcessState *)a;
 108   process_b = (LttvProcessState *)b;
 109
 110   if(process_a->pid != process_b->pid) return FALSE;
 111   if(process_a->pid == 0 &&
 112       process_a->last_cpu != process_b->last_cpu) return FALSE;
 113   return TRUE;
 114 }
 115
 116
 117 static void
 118 restore_init_state(LttvTraceState *self)
 119 {
 120   guint i, nb_tracefile;
 121
 122   LttvTracefileState *tfcs;
 123
 124   LttTime null_time = {0,0};
 125
 126   if(self->processes != NULL) lttv_state_free_process_table(self->processes);
 127   self->processes = g_hash_table_new(process_hash, process_equal);
 128   self->nb_event = 0;
 129
 130   nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
 131       ltt_trace_per_cpu_tracefile_number(self->parent.t);
 132
 133   for(i = 0 ; i < nb_tracefile ; i++) {
 134     tfcs = LTTV_TRACEFILE_STATE(self->parent.tracefiles[i]);
 135     tfcs->parent.timestamp = null_time;
 136     tfcs->saved_position = 0;
 137     tfcs->process = lttv_state_create_process(tfcs, NULL,0);
 138     tfcs->process->state->s = LTTV_STATE_RUN;
 139     tfcs->process->last_cpu = tfcs->cpu_name;
 140   }
 141 }
 142
 143 static LttTime time_zero = {0,0};
 144
 145 static void
 146 init(LttvTracesetState *self, LttvTraceset *ts)
 147 {
 148   guint i, j, nb_trace, nb_tracefile;
 149
 150   LttvTraceContext *tc;
 151
 152   LttvTraceState *tcs;
 153
 154   LttvTracefileState *tfcs;
 155
 156   LttvAttributeValue v;
 157
 158   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
 159       init((LttvTracesetContext *)self, ts);
 160
 161   nb_trace = lttv_traceset_number(ts);
 162   for(i = 0 ; i < nb_trace ; i++) {
 163     tc = self->parent.traces[i];
 164     tcs = (LttvTraceState *)tc;
 165     tcs->save_interval = 50000;
 166     lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
 167         LTTV_UINT, &v);
 168     (*v.v_uint)++;
 169
 170     if(*(v.v_uint) == 1) {
 171       create_name_tables(tcs);
 172       create_max_time(tcs);
 173     }
 174     get_name_tables(tcs);
 175     get_max_time(tcs);
 176
 177     nb_tracefile = ltt_trace_control_tracefile_number(tc->t) +
 178         ltt_trace_per_cpu_tracefile_number(tc->t);
 179
 180     for(j = 0 ; j < nb_tracefile ; j++) {
 181       tfcs = LTTV_TRACEFILE_STATE(tc->tracefiles[j]);
 182       tfcs->cpu_name= g_quark_from_string(ltt_tracefile_name(tfcs->parent.tf));
 183     }
 184     tcs->processes = NULL;
 185     restore_init_state(tcs);
 186   }
 187 }
 188
 189
 190 static void
 191 fini(LttvTracesetState *self)
 192 {
 193   guint i, j, nb_trace;
 194
 195   LttvTraceState *tcs;
 196
 197   LttvTracefileState *tfcs;
 198
 199   LttvAttributeValue v;
 200
 201   nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
 202   for(i = 0 ; i < nb_trace ; i++) {
 203     tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
 204     lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
 205         LTTV_UINT, &v);
 206     (*v.v_uint)--;
 207
 208     g_assert(*(v.v_uint) >= 0);
 209     if(*(v.v_uint) == 0) {
 210       free_name_tables(tcs);
 211       free_max_time(tcs);
 212       free_saved_state(tcs);
 213     }
 214     lttv_state_free_process_table(tcs->processes);
 215     tcs->processes = NULL;
 216   }
 217   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
 218       fini((LttvTracesetContext *)self);
 219 }
 220
 221
 222 static LttvTracesetContext *
 223 new_traceset_context(LttvTracesetContext *self)
 224 {
 225   return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
 226 }
 227
 228
 229 static LttvTraceContext *
 230 new_trace_context(LttvTracesetContext *self)
 231 {
 232   return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
 233 }
 234
 235
 236 static LttvTracefileContext *
 237 new_tracefile_context(LttvTracesetContext *self)
 238 {
 239   return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
 240 }
 241
 242
 243 /* Write the process state of the trace */
 244
 245 static void write_process_state(gpointer key, gpointer value,
 246     gpointer user_data)
 247 {
 248   LttvProcessState *process;
 249
 250   LttvExecutionState *es;
 251
 252   FILE *fp = (FILE *)user_data;
 253
 254   guint i;
 255
 256   process = (LttvProcessState *)value;
 257   fprintf(fp,
 258 "  <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%s\">\n",
 259       process, process->pid, process->ppid, process->creation_time.tv_sec,
 260       process->creation_time.tv_nsec, g_quark_to_string(process->name),
 261       g_quark_to_string(process->last_cpu));
 262
 263   for(i = 0 ; i < process->execution_stack->len; i++) {
 264     es = &g_array_index(process->execution_stack, LttvExecutionState, i);
 265     fprintf(fp, "    <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
 266             g_quark_to_string(es->t), g_quark_to_string(es->n),
 267             es->entry.tv_sec, es->entry.tv_nsec);
 268     fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
 269             es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
 270   }
 271   fprintf(fp, "  </PROCESS>\n");
 272 }
 273
 274
 275 void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp)
 276 {
 277   guint i, nb_tracefile, nb_block, nb_event;
 278
 279   LttvTracefileState *tfcs;
 280
 281   LttTracefile *tf;
 282
 283   LttEventPosition *ep;
 284
 285   ep = ltt_event_position_new();
 286
 287   fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
 288
 289   g_hash_table_foreach(self->processes, write_process_state, fp);
 290
 291   nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
 292       ltt_trace_per_cpu_tracefile_number(self->parent.t);
 293
 294   for(i = 0 ; i < nb_tracefile ; i++) {
 295     tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
 296     fprintf(fp, "  <TRACEFILE PID=%u TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
 297         tfcs->process->pid, tfcs->parent.timestamp.tv_sec,
 298         tfcs->parent.timestamp.tv_nsec);
 299     if(tfcs->parent.e == NULL) fprintf(fp,"/>\n");
 300     else {
 301       ltt_event_position(tfcs->parent.e, ep);
 302       ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
 303       fprintf(fp, " BLOCK=%u EVENT=%u/>\n", nb_block, nb_event);
 304     }
 305   }
 306   g_free(ep);
 307   fprintf(fp,"</PROCESS_STATE>");
 308 }
 309
 310
 311 /* Copy each process from an existing hash table to a new one */
 312
 313 static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
 314 {
 315   LttvProcessState *process, *new_process;
 316
 317   GHashTable *new_processes = (GHashTable *)user_data;
 318
 319   guint i;
 320
 321   process = (LttvProcessState *)value;
 322   new_process = g_new(LttvProcessState, 1);
 323   *new_process = *process;
 324   new_process->execution_stack = g_array_new(FALSE, FALSE,
 325       sizeof(LttvExecutionState));
 326   g_array_set_size(new_process->execution_stack,process->execution_stack->len);
 327   for(i = 0 ; i < process->execution_stack->len; i++) {
 328     g_array_index(new_process->execution_stack, LttvExecutionState, i) =
 329         g_array_index(process->execution_stack, LttvExecutionState, i);
 330   }
 331   new_process->state = &g_array_index(new_process->execution_stack,
 332       LttvExecutionState, new_process->execution_stack->len - 1);
 333   g_hash_table_insert(new_processes, new_process, new_process);
 334 }
 335
 336
 337 static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
 338 {
 339   GHashTable *new_processes = g_hash_table_new(process_hash, process_equal);
 340
 341   g_hash_table_foreach(processes, copy_process_state, new_processes);
 342   return new_processes;
 343 }
 344
 345
 346 /* The saved state for each trace contains a member "processes", which
 347    stores a copy of the process table, and a member "tracefiles" with
 348    one entry per tracefile. Each tracefile has a "process" member pointing
 349    to the current process and a "position" member storing the tracefile
 350    position (needed to seek to the current "next" event. */
 351
 352 static void state_save(LttvTraceState *self, LttvAttribute *container)
 353 {
 354   guint i, nb_tracefile;
 355
 356   LttvTracefileState *tfcs;
 357
 358   LttvAttribute *tracefiles_tree, *tracefile_tree;
 359
 360   LttvAttributeType type;
 361
 362   LttvAttributeValue value;
 363
 364   LttvAttributeName name;
 365
 366   LttEventPosition *ep;
 367
 368   tracefiles_tree = lttv_attribute_find_subdir(container,
 369       LTTV_STATE_TRACEFILES);
 370
 371   value = lttv_attribute_add(container, LTTV_STATE_PROCESSES,
 372       LTTV_POINTER);
 373   *(value.v_pointer) = lttv_state_copy_process_table(self->processes);
 374
 375   nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
 376       ltt_trace_per_cpu_tracefile_number(self->parent.t);
 377
 378   for(i = 0 ; i < nb_tracefile ; i++) {
 379     tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
 380     tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 381     value = lttv_attribute_add(tracefiles_tree, i,
 382         LTTV_GOBJECT);
 383     *(value.v_gobject) = (GObject *)tracefile_tree;
 384     value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
 385         LTTV_UINT);
 386     *(value.v_uint) = tfcs->process->pid;
 387     value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
 388         LTTV_POINTER);
 389     if(tfcs->parent.e == NULL) *(value.v_pointer) = NULL;
 390     else {
 391       ep = ltt_event_position_new();
 392       ltt_event_position(tfcs->parent.e, ep);
 393       *(value.v_pointer) = ep;
 394
 395       guint nb_block, nb_event;
 396       LttTracefile *tf;
 397       ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
 398       g_debug("Block %u event %u time %lu.%lu", nb_block, nb_event,
 399           tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
 400     }
 401   }
 402 }
 403
 404
 405 static void state_restore(LttvTraceState *self, LttvAttribute *container)
 406 {
 407   guint i, nb_tracefile, pid;
 408
 409   LttvTracefileState *tfcs;
 410
 411   LttvAttribute *tracefiles_tree, *tracefile_tree;
 412
 413   LttvAttributeType type;
 414
 415   LttvAttributeValue value;
 416
 417   LttvAttributeName name;
 418
 419   LttEventPosition *ep;
 420
 421   tracefiles_tree = lttv_attribute_find_subdir(container,
 422       LTTV_STATE_TRACEFILES);
 423
 424   type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
 425       &value);
 426   g_assert(type == LTTV_POINTER);
 427   lttv_state_free_process_table(self->processes);
 428   self->processes = lttv_state_copy_process_table(*(value.v_pointer));
 429
 430   nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
 431       ltt_trace_per_cpu_tracefile_number(self->parent.t);
 432
 433   for(i = 0 ; i < nb_tracefile ; i++) {
 434     tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
 435     type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
 436     g_assert(type == LTTV_GOBJECT);
 437     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
 438
 439     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_PROCESS,
 440         &value);
 441     g_assert(type == LTTV_UINT);
 442     pid = *(value.v_uint);
 443     tfcs->process = lttv_state_find_process_or_create(tfcs, pid);
 444
 445     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
 446         &value);
 447     g_assert(type == LTTV_POINTER);
 448     if(*(value.v_pointer) == NULL) tfcs->parent.e = NULL;
 449     else {
 450       ep = *(value.v_pointer);
 451       lttv_process_tracefile_seek_position(tfcs->parent, ep);
 452     }
 453   }
 454 }
 455
 456
 457 static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
 458 {
 459   guint i, nb_tracefile;
 460
 461   LttvTracefileState *tfcs;
 462
 463   LttvAttribute *tracefiles_tree, *tracefile_tree;
 464
 465   LttvAttributeType type;
 466
 467   LttvAttributeValue value;
 468
 469   LttvAttributeName name;
 470
 471   LttEventPosition *ep;
 472
 473   tracefiles_tree = lttv_attribute_find_subdir(container,
 474       LTTV_STATE_TRACEFILES);
 475   g_object_ref(G_OBJECT(tracefiles_tree));
 476   lttv_attribute_remove_by_name(container, LTTV_STATE_TRACEFILES);
 477
 478   type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
 479       &value);
 480   g_assert(type == LTTV_POINTER);
 481   lttv_state_free_process_table(*(value.v_pointer));
 482   *(value.v_pointer) = NULL;
 483   lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES);
 484
 485   nb_tracefile = ltt_trace_control_tracefile_number(self->parent.t) +
 486       ltt_trace_per_cpu_tracefile_number(self->parent.t);
 487
 488   for(i = 0 ; i < nb_tracefile ; i++) {
 489     tfcs = (LttvTracefileState *)self->parent.tracefiles[i];
 490     type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
 491     g_assert(type == LTTV_GOBJECT);
 492     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
 493
 494     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
 495         &value);
 496     g_assert(type == LTTV_POINTER);
 497     if(*(value.v_pointer) != NULL) g_free(*(value.v_pointer));
 498   }
 499   g_object_unref(G_OBJECT(tracefiles_tree));
 500 }
 501
 502
 503 static void free_saved_state(LttvTraceState *self)
 504 {
 505   guint i, nb;
 506
 507   LttvAttributeType type;
 508
 509   LttvAttributeValue value;
 510
 511   LttvAttributeName name;
 512
 513   LttvAttribute *saved_states;
 514
 515   saved_states = lttv_attribute_find_subdir(self->parent.t_a,
 516       LTTV_STATE_SAVED_STATES);
 517
 518   nb = lttv_attribute_get_number(saved_states);
 519   for(i = 0 ; i < nb ; i++) {
 520     type = lttv_attribute_get(saved_states, i, &name, &value);
 521     g_assert(type == LTTV_GOBJECT);
 522     state_saved_free(self, *((LttvAttribute **)value.v_gobject));
 523   }
 524
 525   lttv_attribute_remove_by_name(self->parent.t_a, LTTV_STATE_SAVED_STATES);
 526 }
 527
 528
 529 static void
 530 create_max_time(LttvTraceState *tcs)
 531 {
 532   LttvAttributeValue v;
 533
 534   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
 535         LTTV_POINTER, &v);
 536   g_assert(*(v.v_pointer) == NULL);
 537   *(v.v_pointer) = g_new(LttTime,1);
 538   *((LttTime *)*(v.v_pointer)) = time_zero;
 539 }
 540
 541
 542 static void
 543 get_max_time(LttvTraceState *tcs)
 544 {
 545   LttvAttributeValue v;
 546
 547   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
 548         LTTV_POINTER, &v);
 549   g_assert(*(v.v_pointer) != NULL);
 550   tcs->max_time_state_recomputed_in_seek = (LttTime *)*(v.v_pointer);
 551 }
 552
 553
 554 static void
 555 free_max_time(LttvTraceState *tcs)
 556 {
 557   LttvAttributeValue v;
 558
 559   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
 560         LTTV_POINTER, &v);
 561   g_free(*(v.v_pointer));
 562   *(v.v_pointer) = NULL;
 563 }
 564
 565
 566 typedef struct _LttvNameTables {
 567   GQuark *eventtype_names;
 568   GQuark *syscall_names;
 569   GQuark *trap_names;
 570   GQuark *irq_names;
 571 } LttvNameTables;
 572
 573
 574 static void
 575 create_name_tables(LttvTraceState *tcs)
 576 {
 577   int i, nb;
 578
 579   char *f_name, *e_name;
 580
 581   LttvTraceHook h;
 582
 583   LttEventType *et;
 584
 585   LttType *t;
 586
 587   GString *fe_name = g_string_new("");
 588
 589   LttvNameTables *name_tables = g_new(LttvNameTables, 1);
 590
 591   LttvAttributeValue v;
 592
 593   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
 594       LTTV_POINTER, &v);
 595   g_assert(*(v.v_pointer) == NULL);
 596   *(v.v_pointer) = name_tables;
 597
 598   nb = ltt_trace_eventtype_number(tcs->parent.t);
 599   name_tables->eventtype_names = g_new(GQuark, nb);
 600   for(i = 0 ; i < nb ; i++) {
 601     et = ltt_trace_eventtype_get(tcs->parent.t, i);
 602     e_name = ltt_eventtype_name(et);
 603     f_name = ltt_facility_name(ltt_eventtype_facility(et));
 604     g_string_printf(fe_name, "%s.%s", f_name, e_name);
 605     name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
 606   }
 607
 608   lttv_trace_find_hook(tcs->parent.t, "core", "syscall_entry",
 609       "syscall_id", NULL, NULL, NULL, &h);
 610   t = ltt_field_type(h.f1);
 611   nb = ltt_type_element_number(t);
 612
 613   /* CHECK syscalls should be an emun but currently are not!
 614   name_tables->syscall_names = g_new(GQuark, nb);
 615
 616   for(i = 0 ; i < nb ; i++) {
 617     name_tables->syscall_names[i] = g_quark_from_string(
 618         ltt_enum_string_get(t, i));
 619   }
 620   */
 621
 622   name_tables->syscall_names = g_new(GQuark, 256);
 623   for(i = 0 ; i < 256 ; i++) {
 624     g_string_printf(fe_name, "syscall %d", i);
 625     name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
 626   }
 627
 628   lttv_trace_find_hook(tcs->parent.t, "core", "trap_entry",
 629       "trap_id", NULL, NULL, NULL, &h);
 630   t = ltt_field_type(h.f1);
 631   nb = ltt_type_element_number(t);
 632
 633   /*
 634   name_tables->trap_names = g_new(GQuark, nb);
 635   for(i = 0 ; i < nb ; i++) {
 636     name_tables->trap_names[i] = g_quark_from_string(
 637         ltt_enum_string_get(t, i));
 638   }
 639   */
 640
 641   name_tables->trap_names = g_new(GQuark, 256);
 642   for(i = 0 ; i < 256 ; i++) {
 643     g_string_printf(fe_name, "trap %d", i);
 644     name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
 645   }
 646
 647   lttv_trace_find_hook(tcs->parent.t, "core", "irq_entry",
 648       "irq_id", NULL, NULL, NULL, &h);
 649   t = ltt_field_type(h.f1);
 650   nb = ltt_type_element_number(t);
 651
 652   /*
 653   name_tables->irq_names = g_new(GQuark, nb);
 654   for(i = 0 ; i < nb ; i++) {
 655     name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
 656   }
 657   */
 658
 659   name_tables->irq_names = g_new(GQuark, 256);
 660   for(i = 0 ; i < 256 ; i++) {
 661     g_string_printf(fe_name, "irq %d", i);
 662     name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
 663   }
 664
 665   g_string_free(fe_name, TRUE);
 666 }
 667
 668
 669 static void
 670 get_name_tables(LttvTraceState *tcs)
 671 {
 672   LttvNameTables *name_tables;
 673
 674   LttvAttributeValue v;
 675
 676   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
 677         LTTV_POINTER, &v);
 678   g_assert(*(v.v_pointer) != NULL);
 679   name_tables = (LttvNameTables *)*(v.v_pointer);
 680   tcs->eventtype_names = name_tables->eventtype_names;
 681   tcs->syscall_names = name_tables->syscall_names;
 682   tcs->trap_names = name_tables->trap_names;
 683   tcs->irq_names = name_tables->irq_names;
 684 }
 685
 686
 687 static void
 688 free_name_tables(LttvTraceState *tcs)
 689 {
 690   LttvNameTables *name_tables;
 691
 692   LttvAttributeValue v;
 693
 694   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
 695         LTTV_POINTER, &v);
 696   name_tables = (LttvNameTables *)*(v.v_pointer);
 697   *(v.v_pointer) = NULL;
 698
 699   g_free(name_tables->eventtype_names);
 700   g_free(name_tables->syscall_names);
 701   g_free(name_tables->trap_names);
 702   g_free(name_tables->irq_names);
 703   g_free(name_tables);
 704 }
 705
 706
 707 static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
 708     guint state_id)
 709 {
 710   LttvExecutionState *es;
 711
 712   LttvProcessState *process = tfs->process;
 713
 714   guint depth = process->execution_stack->len;
 715
 716   g_array_set_size(process->execution_stack, depth + 1);
 717   es = &g_array_index(process->execution_stack, LttvExecutionState, depth);
 718   es->t = t;
 719   es->n = state_id;
 720   es->entry = es->change = tfs->parent.timestamp;
 721   es->s = process->state->s;
 722   process->state = es;
 723 }
 724
 725
 726 static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
 727 {
 728   LttvProcessState *process = tfs->process;
 729
 730   guint depth = process->execution_stack->len;
 731
 732   if(process->state->t != t){
 733     g_info("Different execution mode type (%d.%09d): ignore it\n",
 734         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
 735     g_info("process state has %s when pop_int is %s\n",
 736                     g_quark_to_string(process->state->t),
 737                     g_quark_to_string(t));
 738     g_info("{ %u, %u, %s, %s }\n",
 739                     process->pid,
 740                     process->ppid,
 741                     g_quark_to_string(process->name),
 742                     g_quark_to_string(process->state->s));
 743     return;
 744   }
 745
 746   if(depth == 1){
 747     g_info("Trying to pop last state on stack (%d.%09d): ignore it\n",
 748         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
 749     return;
 750   }
 751
 752   g_array_set_size(process->execution_stack, depth - 1);
 753   process->state = &g_array_index(process->execution_stack, LttvExecutionState,
 754       depth - 2);
 755   process->state->change = tfs->parent.timestamp;
 756 }
 757
 758
 759 LttvProcessState *
 760 lttv_state_create_process(LttvTracefileState *tfs, LttvProcessState *parent,
 761     guint pid)
 762 {
 763   LttvProcessState *process = g_new(LttvProcessState, 1);
 764
 765   LttvExecutionState *es;
 766
 767   LttvTraceContext *tc;
 768
 769   LttvTraceState *tcs;
 770
 771   char buffer[128];
 772
 773   tc = tfs->parent.t_context;
 774   tcs = (LttvTraceState *)tc;
 775
 776   process->pid = pid;
 777   process->last_cpu = tfs->cpu_name;
 778   g_warning("Process %u, core %p", process->pid, process);
 779   g_hash_table_insert(tcs->processes, process, process);
 780
 781   if(parent) {
 782     process->ppid = parent->pid;
 783     process->name = parent->name;
 784     process->creation_time = tfs->parent.timestamp;
 785   }
 786
 787   /* No parent. This process exists but we are missing all information about
 788      its creation. The birth time is set to zero but we remember the time of
 789      insertion */
 790
 791   else {
 792     process->ppid = 0;
 793     process->name = LTTV_STATE_UNNAMED;
 794     process->creation_time = ltt_time_zero;
 795   }
 796
 797   process->insertion_time = tfs->parent.timestamp;
 798   sprintf(buffer,"%d-%lu.%lu",pid, process->creation_time.tv_sec,
 799           process->creation_time.tv_nsec);
 800   process->pid_time = g_quark_from_string(buffer);
 801   process->last_cpu = tfs->cpu_name;
 802   process->execution_stack = g_array_new(FALSE, FALSE,
 803       sizeof(LttvExecutionState));
 804   g_array_set_size(process->execution_stack, 1);
 805   es = process->state = &g_array_index(process->execution_stack,
 806       LttvExecutionState, 0);
 807   es->t = LTTV_STATE_USER_MODE;
 808   es->n = LTTV_STATE_SUBMODE_NONE;
 809   es->entry = tfs->parent.timestamp;
 810   es->change = tfs->parent.timestamp;
 811   es->s = LTTV_STATE_WAIT_FORK;
 812
 813   return process;
 814 }
 815
 816
 817 LttvProcessState *
 818 lttv_state_find_process_from_trace(LttvTraceState *ts, GQuark cpu, guint pid)
 819 {
 820   LttvProcessState key;
 821   LttvProcessState *process;
 822
 823   key.pid = pid;
 824   key.last_cpu = cpu;
 825   process = g_hash_table_lookup(ts->processes, &key);
 826   return process;
 827 }
 828
 829
 830 LttvProcessState *lttv_state_find_process(LttvTracefileState *tfs,
 831     guint pid)
 832 {
 833   LttvTraceState *ts =(LttvTraceState *)tfs->parent.t_context;
 834   return lttv_state_find_process_from_trace(ts, tfs->cpu_name, pid);
 835 }
 836
 837
 838 LttvProcessState *
 839 lttv_state_find_process_or_create(LttvTracefileState *tfs, guint pid)
 840 {
 841   LttvProcessState *process = lttv_state_find_process(tfs, pid);
 842
 843   if(process == NULL) process = lttv_state_create_process(tfs, NULL, pid);
 844   return process;
 845 }
 846
 847
 848 static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
 849 {
 850   LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
 851   LttvProcessState key;
 852
 853   key.pid = process->pid;
 854   key.last_cpu = process->last_cpu;
 855   g_hash_table_remove(ts->processes, &key);
 856   g_array_free(process->execution_stack, TRUE);
 857   g_free(process);
 858 }
 859
 860
 861 static void free_process_state(gpointer key, gpointer value,gpointer user_data)
 862 {
 863   g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
 864   g_free(value);
 865 }
 866
 867
 868 static void lttv_state_free_process_table(GHashTable *processes)
 869 {
 870   g_hash_table_foreach(processes, free_process_state, NULL);
 871   g_hash_table_destroy(processes);
 872 }
 873
 874
 875 static gboolean syscall_entry(void *hook_data, void *call_data)
 876 {
 877   LttField *f = ((LttvTraceHook *)hook_data)->f1;
 878
 879   LttvTracefileState *s = (LttvTracefileState *)call_data;
 880
 881   LttvExecutionSubmode submode;
 882
 883   submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
 884       ltt_event_get_unsigned(s->parent.e, f)];
 885   push_state(s, LTTV_STATE_SYSCALL, submode);
 886   return FALSE;
 887 }
 888
 889
 890 static gboolean syscall_exit(void *hook_data, void *call_data)
 891 {
 892   LttvTracefileState *s = (LttvTracefileState *)call_data;
 893
 894   pop_state(s, LTTV_STATE_SYSCALL);
 895   return FALSE;
 896 }
 897
 898
 899 static gboolean trap_entry(void *hook_data, void *call_data)
 900 {
 901   LttField *f = ((LttvTraceHook *)hook_data)->f1;
 902
 903   LttvTracefileState *s = (LttvTracefileState *)call_data;
 904
 905   LttvExecutionSubmode submode;
 906
 907   submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[
 908       ltt_event_get_unsigned(s->parent.e, f)];
 909   push_state(s, LTTV_STATE_TRAP, submode);
 910   return FALSE;
 911 }
 912
 913
 914 static gboolean trap_exit(void *hook_data, void *call_data)
 915 {
 916   LttvTracefileState *s = (LttvTracefileState *)call_data;
 917
 918   pop_state(s, LTTV_STATE_TRAP);
 919   return FALSE;
 920 }
 921
 922
 923 static gboolean irq_entry(void *hook_data, void *call_data)
 924 {
 925   LttField *f = ((LttvTraceHook *)hook_data)->f1;
 926
 927   LttvTracefileState *s = (LttvTracefileState *)call_data;
 928
 929   LttvExecutionSubmode submode;
 930
 931   submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[
 932       ltt_event_get_unsigned(s->parent.e, f)];
 933
 934   /* Do something with the info about being in user or system mode when int? */
 935   push_state(s, LTTV_STATE_IRQ, submode);
 936   return FALSE;
 937 }
 938
 939
 940 static gboolean irq_exit(void *hook_data, void *call_data)
 941 {
 942   LttvTracefileState *s = (LttvTracefileState *)call_data;
 943
 944   pop_state(s, LTTV_STATE_IRQ);
 945   return FALSE;
 946 }
 947
 948
 949 static gboolean schedchange(void *hook_data, void *call_data)
 950 {
 951   LttvTraceHook *h = (LttvTraceHook *)hook_data;
 952
 953   LttvTracefileState *s = (LttvTracefileState *)call_data;
 954
 955   guint pid_in, pid_out, state_out;
 956
 957   pid_in = ltt_event_get_unsigned(s->parent.e, h->f1);
 958   pid_out = ltt_event_get_unsigned(s->parent.e, h->f2);
 959   state_out = ltt_event_get_unsigned(s->parent.e, h->f3);
 960
 961   if(s->process != NULL) {
 962
 963     /* We could not know but it was not the idle process executing.
 964        This should only happen at the beginning, before the first schedule
 965        event, and when the initial information (current process for each CPU)
 966        is missing. It is not obvious how we could, after the fact, compensate
 967        the wrongly attributed statistics. */
 968
 969     if(s->process->pid != pid_out) {
 970       g_assert(s->process->pid == 0);
 971     }
 972
 973     if(state_out == 0) s->process->state->s = LTTV_STATE_WAIT_CPU;
 974     else if(s->process->state->s == LTTV_STATE_EXIT)
 975         exit_process(s, s->process);
 976     else s->process->state->s = LTTV_STATE_WAIT;
 977
 978     s->process->state->change = s->parent.timestamp;
 979   }
 980   s->process = lttv_state_find_process_or_create(s, pid_in);
 981   s->process->state->s = LTTV_STATE_RUN;
 982   s->process->last_cpu = s->cpu_name;
 983   s->process->state->change = s->parent.timestamp;
 984   return FALSE;
 985 }
 986
 987
 988 static gboolean process_fork(void *hook_data, void *call_data)
 989 {
 990   LttField *f = ((LttvTraceHook *)hook_data)->f1;
 991
 992   LttvTracefileState *s = (LttvTracefileState *)call_data;
 993
 994   guint child_pid;
 995
 996   child_pid = ltt_event_get_unsigned(s->parent.e, f);
 997   lttv_state_create_process(s, s->process, child_pid);
 998   return FALSE;
 999 }
1000
1001
1002 static gboolean process_exit(void *hook_data, void *call_data)
1003 {
1004   LttvTracefileState *s = (LttvTracefileState *)call_data;
1005
1006   if(s->process != NULL) {
1007     s->process->state->s = LTTV_STATE_EXIT;
1008   }
1009   return FALSE;
1010 }
1011
1012
1013 void lttv_state_add_event_hooks(LttvTracesetState *self)
1014 {
1015   LttvTraceset *traceset = self->parent.ts;
1016
1017   guint i, j, k, nb_trace, nb_tracefile;
1018
1019   LttvTraceState *ts;
1020
1021   LttvTracefileState *tfs;
1022
1023   GArray *hooks;
1024
1025   LttvTraceHook hook;
1026
1027   LttvAttributeValue val;
1028
1029   nb_trace = lttv_traceset_number(traceset);
1030   for(i = 0 ; i < nb_trace ; i++) {
1031     ts = (LttvTraceState *)self->parent.traces[i];
1032
1033     /* Find the eventtype id for the following events and register the
1034        associated by id hooks. */
1035
1036     hooks = g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
1037     g_array_set_size(hooks, 9);
1038
1039     lttv_trace_find_hook(ts->parent.t, "core","syscall_entry","syscall_id",
1040         NULL, NULL, syscall_entry, &g_array_index(hooks, LttvTraceHook, 0));
1041
1042     lttv_trace_find_hook(ts->parent.t, "core", "syscall_exit", NULL, NULL,
1043         NULL, syscall_exit, &g_array_index(hooks, LttvTraceHook, 1));
1044
1045     lttv_trace_find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
1046         NULL, NULL, trap_entry, &g_array_index(hooks, LttvTraceHook, 2));
1047
1048     lttv_trace_find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL, NULL,
1049         trap_exit, &g_array_index(hooks, LttvTraceHook, 3));
1050
1051     lttv_trace_find_hook(ts->parent.t, "core", "irq_entry", "irq_id", NULL,
1052         NULL, irq_entry, &g_array_index(hooks, LttvTraceHook, 4));
1053
1054     lttv_trace_find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL, NULL,
1055         irq_exit, &g_array_index(hooks, LttvTraceHook, 5));
1056
1057     lttv_trace_find_hook(ts->parent.t, "core", "schedchange", "in", "out",
1058         "out_state", schedchange, &g_array_index(hooks, LttvTraceHook, 6));
1059
1060     lttv_trace_find_hook(ts->parent.t, "core", "process_fork", "child_pid",
1061         NULL, NULL, process_fork, &g_array_index(hooks, LttvTraceHook, 7));
1062
1063     lttv_trace_find_hook(ts->parent.t, "core", "process_exit", NULL, NULL,
1064         NULL, process_exit, &g_array_index(hooks, LttvTraceHook, 8));
1065
1066     /* Add these hooks to each event_by_id hooks list */
1067
1068     nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
1069         ltt_trace_per_cpu_tracefile_number(ts->parent.t);
1070
1071     for(j = 0 ; j < nb_tracefile ; j++) {
1072       tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
1073
1074       for(k = 0 ; k < hooks->len ; k++) {
1075         hook = g_array_index(hooks, LttvTraceHook, k);
1076         lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1077           hook.id), hook.h, &g_array_index(hooks, LttvTraceHook, k), LTTV_PRIO_STATE);
1078       }
1079     }
1080     lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1081     *(val.v_pointer) = hooks;
1082   }
1083 }
1084
1085
1086 void lttv_state_remove_event_hooks(LttvTracesetState *self)
1087 {
1088   LttvTraceset *traceset = self->parent.ts;
1089
1090   guint i, j, k, nb_trace, nb_tracefile;
1091
1092   LttvTraceState *ts;
1093
1094   LttvTracefileState *tfs;
1095
1096   GArray *hooks;
1097
1098   LttvTraceHook hook;
1099
1100   LttvAttributeValue val;
1101
1102   nb_trace = lttv_traceset_number(traceset);
1103   for(i = 0 ; i < nb_trace ; i++) {
1104     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1105     lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1106     hooks = *(val.v_pointer);
1107
1108     /* Remove these hooks from each event_by_id hooks list */
1109
1110     nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
1111         ltt_trace_per_cpu_tracefile_number(ts->parent.t);
1112
1113     for(j = 0 ; j < nb_tracefile ; j++) {
1114       tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
1115
1116       for(k = 0 ; k < hooks->len ; k++) {
1117         hook = g_array_index(hooks, LttvTraceHook, k);
1118         lttv_hooks_remove_data(
1119             lttv_hooks_by_id_find(tfs->parent.event_by_id,
1120             hook.id), hook.h, &g_array_index(hooks, LttvTraceHook, k));
1121       }
1122     }
1123     g_array_free(hooks, TRUE);
1124   }
1125 }
1126
1127
1128 static gboolean block_start(void *hook_data, void *call_data)
1129 {
1130   LttvTracefileState *self = (LttvTracefileState *)call_data;
1131
1132   LttvTracefileState *tfcs;
1133
1134   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1135
1136   LttEventPosition *ep;
1137
1138   guint i, nb_block, nb_event, nb_tracefile;
1139
1140   LttTracefile *tf;
1141
1142   LttvAttribute *saved_states_tree, *saved_state_tree;
1143
1144   LttvAttributeValue value;
1145
1146   ep = ltt_event_position_new();
1147   nb_tracefile = ltt_trace_control_tracefile_number(tcs->parent.t) +
1148       ltt_trace_per_cpu_tracefile_number(tcs->parent.t);
1149
1150   /* Count the number of events added since the last block end in any
1151      tracefile. */
1152
1153   for(i = 0 ; i < nb_tracefile ; i++) {
1154     tfcs = (LttvTracefileState *)tcs->parent.tracefiles[i];
1155     ltt_event_position(tfcs->parent.e, ep);
1156     ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1157     tcs->nb_event += nb_event - tfcs->saved_position;
1158     tfcs->saved_position = nb_event;
1159   }
1160   g_free(ep);
1161
1162   if(tcs->nb_event >= tcs->save_interval) {
1163     saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1164         LTTV_STATE_SAVED_STATES);
1165     saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1166     value = lttv_attribute_add(saved_states_tree,
1167         lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1168     *(value.v_gobject) = (GObject *)saved_state_tree;
1169     value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1170     *(value.v_time) = self->parent.timestamp;
1171     lttv_state_save(tcs, saved_state_tree);
1172     tcs->nb_event = 0;
1173     g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1174             self->parent.timestamp.tv_nsec);
1175   }
1176   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1177   return FALSE;
1178 }
1179
1180
1181 static gboolean block_end(void *hook_data, void *call_data)
1182 {
1183   LttvTracefileState *self = (LttvTracefileState *)call_data;
1184
1185   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1186
1187   LttTracefile *tf;
1188
1189   LttEventPosition *ep;
1190
1191   guint nb_block, nb_event;
1192
1193   ep = ltt_event_position_new();
1194   ltt_event_position(self->parent.e, ep);
1195   ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1196   tcs->nb_event += nb_event - self->saved_position + 1;
1197   self->saved_position = 0;
1198   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1199   g_free(ep);
1200 }
1201
1202
1203 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1204 {
1205   LttvTraceset *traceset = self->parent.ts;
1206
1207   guint i, j, k, nb_trace, nb_tracefile;
1208
1209   LttvTraceState *ts;
1210
1211   LttvTracefileState *tfs;
1212
1213   LttvTraceHook hook_start, hook_end;
1214
1215   nb_trace = lttv_traceset_number(traceset);
1216   for(i = 0 ; i < nb_trace ; i++) {
1217     ts = (LttvTraceState *)self->parent.traces[i];
1218     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1219         NULL, NULL, block_start, &hook_start);
1220     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1221         NULL, NULL, block_end, &hook_end);
1222
1223     nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
1224         ltt_trace_per_cpu_tracefile_number(ts->parent.t);
1225
1226     for(j = 0 ; j < nb_tracefile ; j++) {
1227       tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
1228       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1229           hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
1230       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1231           hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
1232     }
1233   }
1234 }
1235
1236
1237 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
1238 {
1239   LttvTraceset *traceset = self->parent.ts;
1240
1241   guint i, j, k, nb_trace, nb_tracefile;
1242
1243   LttvTraceState *ts;
1244
1245   LttvTracefileState *tfs;
1246
1247   LttvTraceHook hook_start, hook_end;
1248
1249   nb_trace = lttv_traceset_number(traceset);
1250   for(i = 0 ; i < nb_trace ; i++) {
1251     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1252     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1253         NULL, NULL, block_start, &hook_start);
1254
1255     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1256         NULL, NULL, block_end, &hook_end);
1257
1258     nb_tracefile = ltt_trace_control_tracefile_number(ts->parent.t) +
1259         ltt_trace_per_cpu_tracefile_number(ts->parent.t);
1260
1261     for(j = 0 ; j < nb_tracefile ; j++) {
1262       tfs = LTTV_TRACEFILE_STATE(ts->parent.tracefiles[j]);
1263       lttv_hooks_remove_data(lttv_hooks_by_id_find(
1264           tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
1265       lttv_hooks_remove_data(lttv_hooks_by_id_find(
1266           tfs->parent.event_by_id, hook_end.id), hook_end.h, NULL);
1267     }
1268   }
1269 }
1270
1271
1272 void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
1273 {
1274   LttvTraceset *traceset = self->parent.ts;
1275
1276   guint i, j, nb_trace, nb_saved_state;
1277
1278   int min_pos, mid_pos, max_pos;
1279
1280   LttvTraceState *tcs;
1281
1282   LttvAttributeValue value;
1283
1284   LttvAttributeType type;
1285
1286   LttvAttributeName name;
1287
1288   LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
1289
1290   nb_trace = lttv_traceset_number(traceset);
1291   for(i = 0 ; i < nb_trace ; i++) {
1292     tcs = (LttvTraceState *)self->parent.traces[i];
1293
1294     if(ltt_time_compare(t, *(tcs->max_time_state_recomputed_in_seek)) < 0) {
1295       saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1296           LTTV_STATE_SAVED_STATES);
1297       min_pos = -1;
1298
1299       if(saved_states_tree) {
1300         max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
1301         mid_pos = max_pos / 2;
1302         while(min_pos < max_pos) {
1303           type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value);
1304           g_assert(type == LTTV_GOBJECT);
1305           saved_state_tree = *((LttvAttribute **)(value.v_gobject));
1306           type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME,
1307               &value);
1308           g_assert(type == LTTV_TIME);
1309           if(ltt_time_compare(*(value.v_time), t) < 0) {
1310             min_pos = mid_pos;
1311             closest_tree = saved_state_tree;
1312           }
1313           else max_pos = mid_pos - 1;
1314
1315           mid_pos = (min_pos + max_pos + 1) / 2;
1316         }
1317       }
1318
1319       /* restore the closest earlier saved state */
1320       if(min_pos != -1) {
1321         lttv_state_restore(tcs, closest_tree);
1322       }
1323
1324       /* There is no saved state, yet we want to have it. Restart at T0 */
1325       else {
1326         restore_init_state(tcs);
1327         lttv_process_trace_seek_time(&(tcs->parent), ltt_time_zero);
1328       }
1329     }
1330     /* We want to seek quickly without restoring/updating the state */
1331     else {
1332       restore_init_state(tcs);
1333       lttv_process_trace_seek_time(&(tcs->parent), t);
1334     }
1335   }
1336 }
1337
1338
1339 static void
1340 traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
1341 {
1342 }
1343
1344
1345 static void
1346 traceset_state_finalize (LttvTracesetState *self)
1347 {
1348   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
1349       finalize(G_OBJECT(self));
1350 }
1351
1352
1353 static void
1354 traceset_state_class_init (LttvTracesetContextClass *klass)
1355 {
1356   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1357
1358   gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
1359   klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
1360   klass->fini = (void (*)(LttvTracesetContext *self))fini;
1361   klass->new_traceset_context = new_traceset_context;
1362   klass->new_trace_context = new_trace_context;
1363   klass->new_tracefile_context = new_tracefile_context;
1364 }
1365
1366
1367 GType
1368 lttv_traceset_state_get_type(void)
1369 {
1370   static GType type = 0;
1371   if (type == 0) {
1372     static const GTypeInfo info = {
1373       sizeof (LttvTracesetStateClass),
1374       NULL,   /* base_init */
1375       NULL,   /* base_finalize */
1376       (GClassInitFunc) traceset_state_class_init,   /* class_init */
1377       NULL,   /* class_finalize */
1378       NULL,   /* class_data */
1379       sizeof (LttvTracesetState),
1380       0,      /* n_preallocs */
1381       (GInstanceInitFunc) traceset_state_instance_init    /* instance_init */
1382     };
1383
1384     type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
1385         &info, 0);
1386   }
1387   return type;
1388 }
1389
1390
1391 static void
1392 trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
1393 {
1394 }
1395
1396
1397 static void
1398 trace_state_finalize (LttvTraceState *self)
1399 {
1400   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE))->
1401       finalize(G_OBJECT(self));
1402 }
1403
1404
1405 static void
1406 trace_state_class_init (LttvTraceStateClass *klass)
1407 {
1408   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1409
1410   gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
1411   klass->state_save = state_save;
1412   klass->state_restore = state_restore;
1413   klass->state_saved_free = state_saved_free;
1414 }
1415
1416
1417 GType
1418 lttv_trace_state_get_type(void)
1419 {
1420   static GType type = 0;
1421   if (type == 0) {
1422     static const GTypeInfo info = {
1423       sizeof (LttvTraceStateClass),
1424       NULL,   /* base_init */
1425       NULL,   /* base_finalize */
1426       (GClassInitFunc) trace_state_class_init,   /* class_init */
1427       NULL,   /* class_finalize */
1428       NULL,   /* class_data */
1429       sizeof (LttvTraceState),
1430       0,      /* n_preallocs */
1431       (GInstanceInitFunc) trace_state_instance_init    /* instance_init */
1432     };
1433
1434     type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
1435         "LttvTraceStateType", &info, 0);
1436   }
1437   return type;
1438 }
1439
1440
1441 static void
1442 tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
1443 {
1444 }
1445
1446
1447 static void
1448 tracefile_state_finalize (LttvTracefileState *self)
1449 {
1450   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE))->
1451       finalize(G_OBJECT(self));
1452 }
1453
1454
1455 static void
1456 tracefile_state_class_init (LttvTracefileStateClass *klass)
1457 {
1458   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1459
1460   gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
1461 }
1462
1463
1464 GType
1465 lttv_tracefile_state_get_type(void)
1466 {
1467   static GType type = 0;
1468   if (type == 0) {
1469     static const GTypeInfo info = {
1470       sizeof (LttvTracefileStateClass),
1471       NULL,   /* base_init */
1472       NULL,   /* base_finalize */
1473       (GClassInitFunc) tracefile_state_class_init,   /* class_init */
1474       NULL,   /* class_finalize */
1475       NULL,   /* class_data */
1476       sizeof (LttvTracefileState),
1477       0,      /* n_preallocs */
1478       (GInstanceInitFunc) tracefile_state_instance_init    /* instance_init */
1479     };
1480
1481     type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
1482         "LttvTracefileStateType", &info, 0);
1483   }
1484   return type;
1485 }
1486
1487
1488 static void module_init()
1489 {
1490   LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
1491   LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("unknown execution mode");
1492   LTTV_STATE_USER_MODE = g_quark_from_string("user mode");
1493   LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork");
1494   LTTV_STATE_SYSCALL = g_quark_from_string("system call");
1495   LTTV_STATE_TRAP = g_quark_from_string("trap");
1496   LTTV_STATE_IRQ = g_quark_from_string("irq");
1497   LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("unknown submode");
1498   LTTV_STATE_SUBMODE_NONE = g_quark_from_string("(no submode)");
1499   LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
1500   LTTV_STATE_EXIT = g_quark_from_string("exiting");
1501   LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
1502   LTTV_STATE_RUN = g_quark_from_string("running");
1503   LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
1504   LTTV_STATE_PROCESSES = g_quark_from_string("processes");
1505   LTTV_STATE_PROCESS = g_quark_from_string("process");
1506   LTTV_STATE_EVENT = g_quark_from_string("event");
1507   LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
1508   LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
1509   LTTV_STATE_TIME = g_quark_from_string("time");
1510   LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
1511   LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
1512   LTTV_STATE_TRACE_STATE_USE_COUNT =
1513       g_quark_from_string("trace_state_use_count");
1514 }
1515
1516 static void module_destroy()
1517 {
1518 }
1519
1520
1521 LTTV_MODULE("state", "State computation", \
1522     "Update the system state, possibly saving it at intervals", \
1523     module_init, module_destroy)
1524
1525
1526