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 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <lttv/lttv.h>
  24 #include <lttv/module.h>
  25 #include <lttv/state.h>
  26 #include <ltt/facility.h>
  27 #include <ltt/trace.h>
  28 #include <ltt/event.h>
  29 #include <ltt/type.h>
  30 #include <stdio.h>
  31
  32 #define PREALLOCATED_EXECUTION_STACK 10
  33
  34 /* Facilities Quarks */
  35
  36 GQuark
  37     LTT_FACILITY_KERNEL,
  38     LTT_FACILITY_PROCESS;
  39
  40 /* Events Quarks */
  41
  42 GQuark
  43     LTT_EVENT_SYSCALL_ENTRY,
  44     LTT_EVENT_SYSCALL_EXIT,
  45     LTT_EVENT_TRAP_ENTRY,
  46     LTT_EVENT_TRAP_EXIT,
  47     LTT_EVENT_IRQ_ENTRY,
  48     LTT_EVENT_IRQ_EXIT,
  49     LTT_EVENT_SCHEDCHANGE,
  50     LTT_EVENT_FORK,
  51     LTT_EVENT_EXIT,
  52     LTT_EVENT_FREE;
  53
  54 /* Fields Quarks */
  55
  56 GQuark
  57     LTT_FIELD_SYSCALL_ID,
  58     LTT_FIELD_TRAP_ID,
  59     LTT_FIELD_IRQ_ID,
  60     LTT_FIELD_OUT,
  61     LTT_FIELD_IN,
  62     LTT_FIELD_OUT_STATE,
  63     LTT_FIELD_PARENT_PID,
  64     LTT_FIELD_CHILD_PID,
  65     LTT_FIELD_PID;
  66
  67 LttvExecutionMode
  68   LTTV_STATE_MODE_UNKNOWN,
  69   LTTV_STATE_USER_MODE,
  70   LTTV_STATE_SYSCALL,
  71   LTTV_STATE_TRAP,
  72   LTTV_STATE_IRQ;
  73
  74 LttvExecutionSubmode
  75   LTTV_STATE_SUBMODE_UNKNOWN,
  76   LTTV_STATE_SUBMODE_NONE;
  77
  78 LttvProcessStatus
  79   LTTV_STATE_UNNAMED,
  80   LTTV_STATE_WAIT_FORK,
  81   LTTV_STATE_WAIT_CPU,
  82   LTTV_STATE_EXIT,
  83   LTTV_STATE_ZOMBIE,
  84   LTTV_STATE_WAIT,
  85   LTTV_STATE_RUN;
  86
  87 static GQuark
  88   LTTV_STATE_TRACEFILES,
  89   LTTV_STATE_PROCESSES,
  90   LTTV_STATE_PROCESS,
  91   LTTV_STATE_EVENT,
  92   LTTV_STATE_SAVED_STATES,
  93   LTTV_STATE_SAVED_STATES_TIME,
  94   LTTV_STATE_TIME,
  95   LTTV_STATE_HOOKS,
  96   LTTV_STATE_NAME_TABLES,
  97   LTTV_STATE_TRACE_STATE_USE_COUNT;
  98
  99 static void create_max_time(LttvTraceState *tcs);
 100
 101 static void get_max_time(LttvTraceState *tcs);
 102
 103 static void free_max_time(LttvTraceState *tcs);
 104
 105 static void create_name_tables(LttvTraceState *tcs);
 106
 107 static void get_name_tables(LttvTraceState *tcs);
 108
 109 static void free_name_tables(LttvTraceState *tcs);
 110
 111 static void free_saved_state(LttvTraceState *tcs);
 112
 113 static void lttv_state_free_process_table(GHashTable *processes);
 114
 115
 116 void lttv_state_save(LttvTraceState *self, LttvAttribute *container)
 117 {
 118   LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container);
 119 }
 120
 121
 122 void lttv_state_restore(LttvTraceState *self, LttvAttribute *container)
 123 {
 124   LTTV_TRACE_STATE_GET_CLASS(self)->state_restore(self, container);
 125 }
 126
 127
 128 void lttv_state_state_saved_free(LttvTraceState *self,
 129     LttvAttribute *container)
 130 {
 131   LTTV_TRACE_STATE_GET_CLASS(self)->state_saved_free(self, container);
 132 }
 133
 134
 135 guint process_hash(gconstpointer key)
 136 {
 137   guint pid = ((const LttvProcessState *)key)->pid;
 138   return (pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ;
 139 }
 140
 141
 142 /* If the hash table hash function is well distributed,
 143  * the process_equal should compare different pid */
 144 gboolean process_equal(gconstpointer a, gconstpointer b)
 145 {
 146   const LttvProcessState *process_a, *process_b;
 147   gboolean ret = TRUE;
 148
 149   process_a = (const LttvProcessState *)a;
 150   process_b = (const LttvProcessState *)b;
 151
 152   if(likely(process_a->pid != process_b->pid)) ret = FALSE;
 153   else if(likely(process_a->pid == 0 &&
 154                  process_a->last_cpu != process_b->last_cpu)) ret = FALSE;
 155
 156   return ret;
 157 }
 158
 159
 160 static void
 161 restore_init_state(LttvTraceState *self)
 162 {
 163   guint i, nb_tracefile;
 164
 165   LttvTracefileState *tfcs;
 166
 167   if(self->processes != NULL) lttv_state_free_process_table(self->processes);
 168   self->processes = g_hash_table_new(process_hash, process_equal);
 169   self->nb_event = 0;
 170
 171   nb_tracefile = self->parent.tracefiles->len;
 172
 173   for(i = 0 ; i < nb_tracefile ; i++) {
 174     tfcs =
 175       LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 176                                           LttvTracefileContext*, i));
 177     ltt_trace_time_span_get(self->parent.t, &tfcs->parent.timestamp, NULL);
 178 //    tfcs->saved_position = 0;
 179     tfcs->process = lttv_state_create_process(tfcs, NULL,0);
 180     tfcs->process->state->s = LTTV_STATE_RUN;
 181     tfcs->process->last_cpu = tfcs->cpu_name;
 182     tfcs->process->last_cpu_index = ((LttvTracefileContext*)tfcs)->index;
 183   }
 184 }
 185
 186 static LttTime time_zero = {0,0};
 187
 188 static void
 189 init(LttvTracesetState *self, LttvTraceset *ts)
 190 {
 191   guint i, j, nb_trace, nb_tracefile;
 192
 193   LttvTraceContext *tc;
 194
 195   LttvTraceState *tcs;
 196
 197   LttvTracefileState *tfcs;
 198
 199   LttvAttributeValue v;
 200
 201   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
 202       init((LttvTracesetContext *)self, ts);
 203
 204   nb_trace = lttv_traceset_number(ts);
 205   for(i = 0 ; i < nb_trace ; i++) {
 206     tc = self->parent.traces[i];
 207     tcs = (LttvTraceState *)tc;
 208     tcs->save_interval = LTTV_STATE_SAVE_INTERVAL;
 209     lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
 210         LTTV_UINT, &v);
 211     (*v.v_uint)++;
 212
 213     if(*(v.v_uint) == 1) {
 214       create_name_tables(tcs);
 215       create_max_time(tcs);
 216     }
 217     get_name_tables(tcs);
 218     get_max_time(tcs);
 219
 220     nb_tracefile = tc->tracefiles->len;
 221
 222     for(j = 0 ; j < nb_tracefile ; j++) {
 223       tfcs =
 224           LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles,
 225                                           LttvTracefileContext*, j));
 226       tfcs->cpu_name = ltt_tracefile_name(tfcs->parent.tf);
 227     }
 228     tcs->processes = NULL;
 229     restore_init_state(tcs);
 230   }
 231 }
 232
 233
 234 static void
 235 fini(LttvTracesetState *self)
 236 {
 237   guint i, nb_trace;
 238
 239   LttvTraceState *tcs;
 240
 241   LttvTracefileState *tfcs;
 242
 243   LttvAttributeValue v;
 244
 245   nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
 246   for(i = 0 ; i < nb_trace ; i++) {
 247     tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
 248     lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
 249         LTTV_UINT, &v);
 250
 251     g_assert(*(v.v_uint) != 0);
 252     (*v.v_uint)--;
 253
 254     if(*(v.v_uint) == 0) {
 255       free_name_tables(tcs);
 256       free_max_time(tcs);
 257       free_saved_state(tcs);
 258     }
 259     lttv_state_free_process_table(tcs->processes);
 260     tcs->processes = NULL;
 261   }
 262   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
 263       fini((LttvTracesetContext *)self);
 264 }
 265
 266
 267 static LttvTracesetContext *
 268 new_traceset_context(LttvTracesetContext *self)
 269 {
 270   return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
 271 }
 272
 273
 274 static LttvTraceContext *
 275 new_trace_context(LttvTracesetContext *self)
 276 {
 277   return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
 278 }
 279
 280
 281 static LttvTracefileContext *
 282 new_tracefile_context(LttvTracesetContext *self)
 283 {
 284   return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
 285 }
 286
 287
 288 /* Write the process state of the trace */
 289
 290 static void write_process_state(gpointer key, gpointer value,
 291     gpointer user_data)
 292 {
 293   LttvProcessState *process;
 294
 295   LttvExecutionState *es;
 296
 297   FILE *fp = (FILE *)user_data;
 298
 299   guint i;
 300
 301   process = (LttvProcessState *)value;
 302   fprintf(fp,
 303 "  <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%s\">\n",
 304       process, process->pid, process->ppid, process->creation_time.tv_sec,
 305       process->creation_time.tv_nsec, g_quark_to_string(process->name),
 306       g_quark_to_string(process->last_cpu));
 307
 308   for(i = 0 ; i < process->execution_stack->len; i++) {
 309     es = &g_array_index(process->execution_stack, LttvExecutionState, i);
 310     fprintf(fp, "    <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
 311             g_quark_to_string(es->t), g_quark_to_string(es->n),
 312             es->entry.tv_sec, es->entry.tv_nsec);
 313     fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
 314             es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
 315   }
 316   fprintf(fp, "  </PROCESS>\n");
 317 }
 318
 319
 320 void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp)
 321 {
 322   guint i, nb_tracefile, nb_block, offset;
 323   guint64 tsc;
 324
 325   LttvTracefileState *tfcs;
 326
 327   LttTracefile *tf;
 328
 329   LttEventPosition *ep;
 330
 331   ep = ltt_event_position_new();
 332
 333   fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
 334
 335   g_hash_table_foreach(self->processes, write_process_state, fp);
 336
 337   nb_tracefile = self->parent.tracefiles->len;
 338
 339   for(i = 0 ; i < nb_tracefile ; i++) {
 340     tfcs =
 341           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 342                                           LttvTracefileContext*, i));
 343     fprintf(fp, "  <TRACEFILE PID=%u TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
 344         tfcs->process->pid, tfcs->parent.timestamp.tv_sec,
 345         tfcs->parent.timestamp.tv_nsec);
 346     LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
 347     if(e == NULL) fprintf(fp,"/>\n");
 348     else {
 349       ltt_event_position(e, ep);
 350       ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
 351       fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
 352           tsc);
 353     }
 354   }
 355   g_free(ep);
 356   fprintf(fp,"</PROCESS_STATE>");
 357 }
 358
 359
 360 /* Copy each process from an existing hash table to a new one */
 361
 362 static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
 363 {
 364   LttvProcessState *process, *new_process;
 365
 366   GHashTable *new_processes = (GHashTable *)user_data;
 367
 368   guint i;
 369
 370   process = (LttvProcessState *)value;
 371   new_process = g_new(LttvProcessState, 1);
 372   *new_process = *process;
 373   new_process->execution_stack = g_array_sized_new(FALSE, FALSE,
 374       sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
 375   g_array_set_size(new_process->execution_stack,process->execution_stack->len);
 376   for(i = 0 ; i < process->execution_stack->len; i++) {
 377     g_array_index(new_process->execution_stack, LttvExecutionState, i) =
 378         g_array_index(process->execution_stack, LttvExecutionState, i);
 379   }
 380   new_process->state = &g_array_index(new_process->execution_stack,
 381       LttvExecutionState, new_process->execution_stack->len - 1);
 382   g_hash_table_insert(new_processes, new_process, new_process);
 383 }
 384
 385
 386 static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
 387 {
 388   GHashTable *new_processes = g_hash_table_new(process_hash, process_equal);
 389
 390   g_hash_table_foreach(processes, copy_process_state, new_processes);
 391   return new_processes;
 392 }
 393
 394
 395 /* The saved state for each trace contains a member "processes", which
 396    stores a copy of the process table, and a member "tracefiles" with
 397    one entry per tracefile. Each tracefile has a "process" member pointing
 398    to the current process and a "position" member storing the tracefile
 399    position (needed to seek to the current "next" event. */
 400
 401 static void state_save(LttvTraceState *self, LttvAttribute *container)
 402 {
 403   guint i, nb_tracefile;
 404
 405   LttvTracefileState *tfcs;
 406
 407   LttvAttribute *tracefiles_tree, *tracefile_tree;
 408
 409   LttvAttributeType type;
 410
 411   LttvAttributeValue value;
 412
 413   LttvAttributeName name;
 414
 415   LttEventPosition *ep;
 416
 417   tracefiles_tree = lttv_attribute_find_subdir(container,
 418       LTTV_STATE_TRACEFILES);
 419
 420   value = lttv_attribute_add(container, LTTV_STATE_PROCESSES,
 421       LTTV_POINTER);
 422   *(value.v_pointer) = lttv_state_copy_process_table(self->processes);
 423
 424   nb_tracefile = self->parent.tracefiles->len;
 425
 426   for(i = 0 ; i < nb_tracefile ; i++) {
 427     tfcs =
 428           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 429                                           LttvTracefileContext*, i));
 430     tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 431     value = lttv_attribute_add(tracefiles_tree, i,
 432         LTTV_GOBJECT);
 433     *(value.v_gobject) = (GObject *)tracefile_tree;
 434     value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
 435         LTTV_UINT);
 436     *(value.v_uint) = tfcs->process->pid;
 437     value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
 438         LTTV_POINTER);
 439     LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
 440     if(e == NULL) *(value.v_pointer) = NULL;
 441     else {
 442       ep = ltt_event_position_new();
 443       ltt_event_position(e, ep);
 444       *(value.v_pointer) = ep;
 445
 446       guint nb_block, offset;
 447       guint64 tsc;
 448       LttTracefile *tf;
 449       ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
 450       g_debug("Block %u offset %u tsc %llu time %lu.%lu", nb_block, offset,
 451           tsc,
 452           tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
 453     }
 454   }
 455 }
 456
 457
 458 static void state_restore(LttvTraceState *self, LttvAttribute *container)
 459 {
 460   guint i, nb_tracefile, pid;
 461
 462   LttvTracefileState *tfcs;
 463
 464   LttvAttribute *tracefiles_tree, *tracefile_tree;
 465
 466   LttvAttributeType type;
 467
 468   LttvAttributeValue value;
 469
 470   LttvAttributeName name;
 471
 472   LttEventPosition *ep;
 473
 474   LttvTracesetContext *tsc = self->parent.ts_context;
 475
 476   tracefiles_tree = lttv_attribute_find_subdir(container,
 477       LTTV_STATE_TRACEFILES);
 478
 479   type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
 480       &value);
 481   g_assert(type == LTTV_POINTER);
 482   lttv_state_free_process_table(self->processes);
 483   self->processes = lttv_state_copy_process_table(*(value.v_pointer));
 484
 485   nb_tracefile = self->parent.tracefiles->len;
 486
 487   for(i = 0 ; i < nb_tracefile ; i++) {
 488     tfcs =
 489           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 490                                           LttvTracefileContext*, i));
 491     type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
 492     g_assert(type == LTTV_GOBJECT);
 493     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
 494
 495     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_PROCESS,
 496         &value);
 497     g_assert(type == LTTV_UINT);
 498     pid = *(value.v_uint);
 499     tfcs->process = lttv_state_find_process_or_create(tfcs, pid);
 500
 501     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
 502         &value);
 503     g_assert(type == LTTV_POINTER);
 504     g_assert(*(value.v_pointer) != NULL);
 505     ep = *(value.v_pointer);
 506     g_assert(tfcs->parent.t_context != NULL);
 507
 508     g_tree_destroy(tsc->pqueue);
 509     tsc->pqueue = g_tree_new(compare_tracefile);
 510
 511     LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs);
 512
 513     g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
 514     tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
 515     g_tree_insert(tsc->pqueue, tfc, tfc);
 516   }
 517 }
 518
 519
 520 static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
 521 {
 522   guint i, nb_tracefile;
 523
 524   LttvTracefileState *tfcs;
 525
 526   LttvAttribute *tracefiles_tree, *tracefile_tree;
 527
 528   LttvAttributeType type;
 529
 530   LttvAttributeValue value;
 531
 532   LttvAttributeName name;
 533
 534   LttEventPosition *ep;
 535
 536   tracefiles_tree = lttv_attribute_find_subdir(container,
 537       LTTV_STATE_TRACEFILES);
 538   g_object_ref(G_OBJECT(tracefiles_tree));
 539   lttv_attribute_remove_by_name(container, LTTV_STATE_TRACEFILES);
 540
 541   type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
 542       &value);
 543   g_assert(type == LTTV_POINTER);
 544   lttv_state_free_process_table(*(value.v_pointer));
 545   *(value.v_pointer) = NULL;
 546   lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES);
 547
 548   nb_tracefile = self->parent.tracefiles->len;
 549
 550   for(i = 0 ; i < nb_tracefile ; i++) {
 551     tfcs =
 552           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 553                                           LttvTracefileContext*, i));
 554     type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
 555     g_assert(type == LTTV_GOBJECT);
 556     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
 557
 558     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
 559         &value);
 560     g_assert(type == LTTV_POINTER);
 561     if(*(value.v_pointer) != NULL) g_free(*(value.v_pointer));
 562   }
 563   g_object_unref(G_OBJECT(tracefiles_tree));
 564 }
 565
 566
 567 static void free_saved_state(LttvTraceState *self)
 568 {
 569   guint i, nb;
 570
 571   LttvAttributeType type;
 572
 573   LttvAttributeValue value;
 574
 575   LttvAttributeName name;
 576
 577   LttvAttribute *saved_states;
 578
 579   saved_states = lttv_attribute_find_subdir(self->parent.t_a,
 580       LTTV_STATE_SAVED_STATES);
 581
 582   nb = lttv_attribute_get_number(saved_states);
 583   for(i = 0 ; i < nb ; i++) {
 584     type = lttv_attribute_get(saved_states, i, &name, &value);
 585     g_assert(type == LTTV_GOBJECT);
 586     state_saved_free(self, *((LttvAttribute **)value.v_gobject));
 587   }
 588
 589   lttv_attribute_remove_by_name(self->parent.t_a, LTTV_STATE_SAVED_STATES);
 590 }
 591
 592
 593 static void
 594 create_max_time(LttvTraceState *tcs)
 595 {
 596   LttvAttributeValue v;
 597
 598   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
 599         LTTV_POINTER, &v);
 600   g_assert(*(v.v_pointer) == NULL);
 601   *(v.v_pointer) = g_new(LttTime,1);
 602   *((LttTime *)*(v.v_pointer)) = time_zero;
 603 }
 604
 605
 606 static void
 607 get_max_time(LttvTraceState *tcs)
 608 {
 609   LttvAttributeValue v;
 610
 611   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
 612         LTTV_POINTER, &v);
 613   g_assert(*(v.v_pointer) != NULL);
 614   tcs->max_time_state_recomputed_in_seek = (LttTime *)*(v.v_pointer);
 615 }
 616
 617
 618 static void
 619 free_max_time(LttvTraceState *tcs)
 620 {
 621   LttvAttributeValue v;
 622
 623   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
 624         LTTV_POINTER, &v);
 625   g_free(*(v.v_pointer));
 626   *(v.v_pointer) = NULL;
 627 }
 628
 629
 630 typedef struct _LttvNameTables {
 631  // FIXME  GQuark *eventtype_names;
 632   GQuark *syscall_names;
 633   GQuark *trap_names;
 634   GQuark *irq_names;
 635 } LttvNameTables;
 636
 637
 638 static void
 639 create_name_tables(LttvTraceState *tcs)
 640 {
 641   int i, nb;
 642
 643   GQuark f_name, e_name;
 644
 645   LttvTraceHook *h;
 646
 647   LttvTraceHookByFacility *thf;
 648
 649   LttEventType *et;
 650
 651   LttType *t;
 652
 653   GString *fe_name = g_string_new("");
 654
 655   LttvNameTables *name_tables = g_new(LttvNameTables, 1);
 656
 657   LttvAttributeValue v;
 658
 659   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
 660       LTTV_POINTER, &v);
 661   g_assert(*(v.v_pointer) == NULL);
 662   *(v.v_pointer) = name_tables;
 663 #if 0 // Use iteration over the facilities_by_name and then list all event
 664       // types of each facility
 665   nb = ltt_trace_eventtype_number(tcs->parent.t);
 666   name_tables->eventtype_names = g_new(GQuark, nb);
 667   for(i = 0 ; i < nb ; i++) {
 668     et = ltt_trace_eventtype_get(tcs->parent.t, i);
 669     e_name = ltt_eventtype_name(et);
 670     f_name = ltt_facility_name(ltt_eventtype_facility(et));
 671     g_string_printf(fe_name, "%s.%s", f_name, e_name);
 672     name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
 673   }
 674 #endif //0
 675   if(lttv_trace_find_hook(tcs->parent.t,
 676       LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
 677       LTT_FIELD_SYSCALL_ID, 0, 0,
 678       NULL, h))
 679     return;
 680
 681   thf = lttv_trace_hook_get_first(h);
 682
 683   t = ltt_field_type(thf->f1);
 684   nb = ltt_type_element_number(t);
 685
 686   lttv_trace_hook_destroy(h);
 687
 688   /* CHECK syscalls should be an enum but currently are not!
 689   name_tables->syscall_names = g_new(GQuark, nb);
 690
 691   for(i = 0 ; i < nb ; i++) {
 692     name_tables->syscall_names[i] = g_quark_from_string(
 693         ltt_enum_string_get(t, i));
 694   }
 695   */
 696
 697   name_tables->syscall_names = g_new(GQuark, 256);
 698   for(i = 0 ; i < 256 ; i++) {
 699     g_string_printf(fe_name, "syscall %d", i);
 700     name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
 701   }
 702
 703   if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
 704         LTT_EVENT_TRAP_ENTRY,
 705         LTT_FIELD_TRAP_ID, 0, 0,
 706         NULL, h))
 707     return;
 708
 709   thf = lttv_trace_hook_get_first(h);
 710
 711   t = ltt_field_type(thf->f1);
 712   nb = ltt_type_element_number(t);
 713
 714   lttv_trace_hook_destroy(h);
 715
 716   /*
 717   name_tables->trap_names = g_new(GQuark, nb);
 718   for(i = 0 ; i < nb ; i++) {
 719     name_tables->trap_names[i] = g_quark_from_string(
 720         ltt_enum_string_get(t, i));
 721   }
 722   */
 723
 724   name_tables->trap_names = g_new(GQuark, 256);
 725   for(i = 0 ; i < 256 ; i++) {
 726     g_string_printf(fe_name, "trap %d", i);
 727     name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
 728   }
 729
 730   if(lttv_trace_find_hook(tcs->parent.t,
 731         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
 732         LTT_FIELD_IRQ_ID, 0, 0,
 733         NULL, h))
 734     return;
 735
 736   thf = lttv_trace_hook_get_first(h);
 737
 738   t = ltt_field_type(thf->f1);
 739   nb = ltt_type_element_number(t);
 740
 741   lttv_trace_hook_destroy(h);
 742
 743   /*
 744   name_tables->irq_names = g_new(GQuark, nb);
 745   for(i = 0 ; i < nb ; i++) {
 746     name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
 747   }
 748   */
 749
 750   name_tables->irq_names = g_new(GQuark, 256);
 751   for(i = 0 ; i < 256 ; i++) {
 752     g_string_printf(fe_name, "irq %d", i);
 753     name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
 754   }
 755
 756   g_string_free(fe_name, TRUE);
 757 }
 758
 759
 760 static void
 761 get_name_tables(LttvTraceState *tcs)
 762 {
 763   LttvNameTables *name_tables;
 764
 765   LttvAttributeValue v;
 766
 767   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
 768         LTTV_POINTER, &v);
 769   g_assert(*(v.v_pointer) != NULL);
 770   name_tables = (LttvNameTables *)*(v.v_pointer);
 771   //tcs->eventtype_names = name_tables->eventtype_names;
 772   tcs->syscall_names = name_tables->syscall_names;
 773   tcs->trap_names = name_tables->trap_names;
 774   tcs->irq_names = name_tables->irq_names;
 775 }
 776
 777
 778 static void
 779 free_name_tables(LttvTraceState *tcs)
 780 {
 781   LttvNameTables *name_tables;
 782
 783   LttvAttributeValue v;
 784
 785   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
 786         LTTV_POINTER, &v);
 787   name_tables = (LttvNameTables *)*(v.v_pointer);
 788   *(v.v_pointer) = NULL;
 789
 790  // g_free(name_tables->eventtype_names);
 791   g_free(name_tables->syscall_names);
 792   g_free(name_tables->trap_names);
 793   g_free(name_tables->irq_names);
 794   g_free(name_tables);
 795 }
 796
 797
 798 static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
 799     guint state_id)
 800 {
 801   LttvExecutionState *es;
 802
 803   LttvProcessState *process = tfs->process;
 804
 805   guint depth = process->execution_stack->len;
 806
 807   g_array_set_size(process->execution_stack, depth + 1);
 808   es = &g_array_index(process->execution_stack, LttvExecutionState, depth);
 809   es->t = t;
 810   es->n = state_id;
 811   es->entry = es->change = tfs->parent.timestamp;
 812   es->s = process->state->s;
 813   process->state = es;
 814 }
 815
 816
 817 static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
 818 {
 819   LttvProcessState *process = tfs->process;
 820
 821   guint depth = process->execution_stack->len;
 822
 823   if(process->state->t != t){
 824     g_info("Different execution mode type (%lu.%09lu): ignore it\n",
 825         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
 826     g_info("process state has %s when pop_int is %s\n",
 827                     g_quark_to_string(process->state->t),
 828                     g_quark_to_string(t));
 829     g_info("{ %u, %u, %s, %s }\n",
 830                     process->pid,
 831                     process->ppid,
 832                     g_quark_to_string(process->name),
 833                     g_quark_to_string(process->state->s));
 834     return;
 835   }
 836
 837   if(depth == 1){
 838     g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
 839         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
 840     return;
 841   }
 842
 843   g_array_set_size(process->execution_stack, depth - 1);
 844   process->state = &g_array_index(process->execution_stack, LttvExecutionState,
 845       depth - 2);
 846   process->state->change = tfs->parent.timestamp;
 847 }
 848
 849
 850 LttvProcessState *
 851 lttv_state_create_process(LttvTracefileState *tfs, LttvProcessState *parent,
 852     guint pid)
 853 {
 854   LttvProcessState *process = g_new(LttvProcessState, 1);
 855
 856   LttvExecutionState *es;
 857
 858   LttvTraceContext *tc;
 859
 860   LttvTraceState *tcs;
 861
 862   char buffer[128];
 863
 864   tc = tfs->parent.t_context;
 865   tcs = (LttvTraceState *)tc;
 866
 867   process->pid = pid;
 868   process->last_cpu = tfs->cpu_name;
 869   process->last_cpu_index = ((LttvTracefileContext*)tfs)->index;
 870   g_info("Process %u, core %p", process->pid, process);
 871   g_hash_table_insert(tcs->processes, process, process);
 872
 873   if(parent) {
 874     process->ppid = parent->pid;
 875     process->name = parent->name;
 876     process->creation_time = tfs->parent.timestamp;
 877   }
 878
 879   /* No parent. This process exists but we are missing all information about
 880      its creation. The birth time is set to zero but we remember the time of
 881      insertion */
 882
 883   else {
 884     process->ppid = 0;
 885     process->name = LTTV_STATE_UNNAMED;
 886     process->creation_time = ltt_time_zero;
 887   }
 888
 889   process->insertion_time = tfs->parent.timestamp;
 890   sprintf(buffer,"%d-%lu.%lu",pid, process->creation_time.tv_sec,
 891           process->creation_time.tv_nsec);
 892   process->pid_time = g_quark_from_string(buffer);
 893   process->last_cpu = tfs->cpu_name;
 894   process->last_cpu_index = ((LttvTracefileContext*)tfs)->index;
 895   process->execution_stack = g_array_sized_new(FALSE, FALSE,
 896       sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
 897   g_array_set_size(process->execution_stack, 1);
 898   es = process->state = &g_array_index(process->execution_stack,
 899       LttvExecutionState, 0);
 900   es->t = LTTV_STATE_USER_MODE;
 901   es->n = LTTV_STATE_SUBMODE_NONE;
 902   es->entry = tfs->parent.timestamp;
 903   g_assert(tfs->parent.timestamp.tv_sec != 0);
 904   es->change = tfs->parent.timestamp;
 905   es->s = LTTV_STATE_WAIT_FORK;
 906
 907   return process;
 908 }
 909
 910 LttvProcessState *lttv_state_find_process(LttvTracefileState *tfs,
 911     guint pid)
 912 {
 913   LttvProcessState key;
 914   LttvProcessState *process;
 915
 916   LttvTraceState* ts = (LttvTraceState*)tfs->parent.t_context;
 917
 918   key.pid = pid;
 919   key.last_cpu = tfs->cpu_name;
 920   process = g_hash_table_lookup(ts->processes, &key);
 921   return process;
 922 }
 923
 924 LttvProcessState *
 925 lttv_state_find_process_or_create(LttvTracefileState *tfs, guint pid)
 926 {
 927   LttvProcessState *process = lttv_state_find_process(tfs, pid);
 928
 929   if(unlikely(process == NULL)) process = lttv_state_create_process(tfs, NULL, pid);
 930   return process;
 931 }
 932
 933 /* FIXME : this function should be called when we receive an event telling that
 934  * release_task has been called in the kernel. In happens generally when
 935  * the parent waits for its child terminaison, but may also happen in special
 936  * cases in the child's exit : when the parent ignores its children SIGCCHLD or
 937  * has the flag SA_NOCLDWAIT. It can also happen when the child is part
 938  * of a killed thread ground, but isn't the leader.
 939  */
 940 static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
 941 {
 942   LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
 943   LttvProcessState key;
 944
 945   key.pid = process->pid;
 946   key.last_cpu = process->last_cpu;
 947   g_hash_table_remove(ts->processes, &key);
 948   g_array_free(process->execution_stack, TRUE);
 949   g_free(process);
 950 }
 951
 952
 953 static void free_process_state(gpointer key, gpointer value,gpointer user_data)
 954 {
 955   g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
 956   g_free(value);
 957 }
 958
 959
 960 static void lttv_state_free_process_table(GHashTable *processes)
 961 {
 962   g_hash_table_foreach(processes, free_process_state, NULL);
 963   g_hash_table_destroy(processes);
 964 }
 965
 966
 967 static gboolean syscall_entry(void *hook_data, void *call_data)
 968 {
 969   LttvTracefileState *s = (LttvTracefileState *)call_data;
 970   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
 971   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
 972   LttField *f = thf->f1;
 973
 974   LttvExecutionSubmode submode;
 975
 976   submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
 977       ltt_event_get_unsigned(e, f)];
 978   push_state(s, LTTV_STATE_SYSCALL, submode);
 979   return FALSE;
 980 }
 981
 982
 983 static gboolean syscall_exit(void *hook_data, void *call_data)
 984 {
 985   LttvTracefileState *s = (LttvTracefileState *)call_data;
 986
 987   pop_state(s, LTTV_STATE_SYSCALL);
 988   return FALSE;
 989 }
 990
 991
 992 static gboolean trap_entry(void *hook_data, void *call_data)
 993 {
 994   LttvTracefileState *s = (LttvTracefileState *)call_data;
 995   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
 996   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
 997   LttField *f = thf->f1;
 998
 999   LttvExecutionSubmode submode;
1000
1001   submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[
1002       ltt_event_get_unsigned(e, f)];
1003   push_state(s, LTTV_STATE_TRAP, submode);
1004   return FALSE;
1005 }
1006
1007
1008 static gboolean trap_exit(void *hook_data, void *call_data)
1009 {
1010   LttvTracefileState *s = (LttvTracefileState *)call_data;
1011
1012   pop_state(s, LTTV_STATE_TRAP);
1013   return FALSE;
1014 }
1015
1016
1017 static gboolean irq_entry(void *hook_data, void *call_data)
1018 {
1019   LttvTracefileState *s = (LttvTracefileState *)call_data;
1020   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1021   guint8 fac_id = ltt_event_facility_id(e);
1022   guint8 ev_id = ltt_event_eventtype_id(e);
1023   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1024  // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1025   g_assert(thf->f1 != NULL);
1026  // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1027   LttField *f = thf->f1;
1028
1029   LttvExecutionSubmode submode;
1030
1031   submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[
1032       ltt_event_get_unsigned(e, f)];
1033
1034   /* Do something with the info about being in user or system mode when int? */
1035   push_state(s, LTTV_STATE_IRQ, submode);
1036   return FALSE;
1037 }
1038
1039
1040 static gboolean irq_exit(void *hook_data, void *call_data)
1041 {
1042   LttvTracefileState *s = (LttvTracefileState *)call_data;
1043
1044   pop_state(s, LTTV_STATE_IRQ);
1045   return FALSE;
1046 }
1047
1048
1049 static gboolean schedchange(void *hook_data, void *call_data)
1050 {
1051   LttvTracefileState *s = (LttvTracefileState *)call_data;
1052   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1053   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1054   guint pid_in, pid_out, state_out;
1055
1056   pid_out = ltt_event_get_unsigned(e, thf->f1);
1057   pid_in = ltt_event_get_unsigned(e, thf->f2);
1058   state_out = ltt_event_get_unsigned(e, thf->f3);
1059
1060   if(likely(s->process != NULL)) {
1061
1062     /* We could not know but it was not the idle process executing.
1063        This should only happen at the beginning, before the first schedule
1064        event, and when the initial information (current process for each CPU)
1065        is missing. It is not obvious how we could, after the fact, compensate
1066        the wrongly attributed statistics. */
1067
1068     if(unlikely(s->process->pid != pid_out)) {
1069       g_assert(s->process->pid == 0);
1070     }
1071
1072     if(unlikely(s->process->state->s == LTTV_STATE_EXIT)) {
1073       s->process->state->s = LTTV_STATE_ZOMBIE;
1074     } else {
1075       if(unlikely(state_out == 0)) s->process->state->s = LTTV_STATE_WAIT_CPU;
1076       else s->process->state->s = LTTV_STATE_WAIT;
1077     } /* FIXME : we do not remove process here, because the kernel
1078        * still has them : they may be zombies. We need to know
1079        * exactly when release_task is executed on the PID to
1080        * know when the zombie is destroyed.
1081        */
1082     //else
1083     //  exit_process(s, s->process);
1084
1085     s->process->state->change = s->parent.timestamp;
1086   }
1087   s->process = lttv_state_find_process_or_create(s, pid_in);
1088   s->process->state->s = LTTV_STATE_RUN;
1089   s->process->last_cpu = s->cpu_name;
1090   s->process->last_cpu_index = ((LttvTracefileContext*)s)->index;
1091   s->process->state->change = s->parent.timestamp;
1092   return FALSE;
1093 }
1094
1095 static gboolean process_fork(void *hook_data, void *call_data)
1096 {
1097   LttvTracefileState *s = (LttvTracefileState *)call_data;
1098   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1099   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1100   LttField *f;
1101   guint parent_pid;
1102   guint child_pid;
1103   LttvProcessState *zombie_process;
1104
1105   /* Parent PID */
1106   f = thf->f1;
1107   parent_pid = ltt_event_get_unsigned(e, f);
1108
1109   /* Child PID */
1110   f = thf->f2;
1111   child_pid = ltt_event_get_unsigned(e, f);
1112
1113   zombie_process = lttv_state_find_process(s, child_pid);
1114
1115   if(unlikely(zombie_process != NULL)) {
1116     /* Reutilisation of PID. Only now we are sure that the old PID
1117      * has been released. FIXME : should know when release_task happens instead.
1118      */
1119     exit_process(s, zombie_process);
1120   }
1121   g_assert(s->process->pid != child_pid);
1122   // FIXME : Add this test in the "known state" section
1123   // g_assert(s->process->pid == parent_pid);
1124   lttv_state_create_process(s, s->process, child_pid);
1125
1126   return FALSE;
1127 }
1128
1129
1130 static gboolean process_exit(void *hook_data, void *call_data)
1131 {
1132   LttvTracefileState *s = (LttvTracefileState *)call_data;
1133   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1134   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1135   LttField *f;
1136   guint pid;
1137
1138   pid = ltt_event_get_unsigned(e, thf->f1);
1139
1140   // FIXME : Add this test in the "known state" section
1141   // g_assert(s->process->pid == pid);
1142
1143   if(likely(s->process != NULL)) {
1144     s->process->state->s = LTTV_STATE_EXIT;
1145   }
1146   return FALSE;
1147 }
1148
1149 static gboolean process_free(void *hook_data, void *call_data)
1150 {
1151   LttvTracefileState *s = (LttvTracefileState *)call_data;
1152   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1153   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1154   guint release_pid;
1155   LttvProcessState *process;
1156
1157   /* PID of the process to release */
1158   release_pid = ltt_event_get_unsigned(e, thf->f1);
1159
1160   process = lttv_state_find_process(s, release_pid);
1161
1162   if(likely(process != NULL)) {
1163     /* release_task is happening at kernel level : we can now safely release
1164      * the data structure of the process */
1165     exit_process(s, process);
1166   }
1167
1168   return FALSE;
1169 }
1170
1171 gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
1172 {
1173   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1174
1175   lttv_state_add_event_hooks(tss);
1176
1177   return 0;
1178 }
1179
1180 void lttv_state_add_event_hooks(LttvTracesetState *self)
1181 {
1182   LttvTraceset *traceset = self->parent.ts;
1183
1184   guint i, j, k, l, nb_trace, nb_tracefile;
1185
1186   LttvTraceState *ts;
1187
1188   LttvTracefileState *tfs;
1189
1190   GArray *hooks;
1191
1192   LttvTraceHookByFacility *thf;
1193
1194   LttvTraceHook *hook;
1195
1196   LttvAttributeValue val;
1197
1198   gint ret;
1199
1200   nb_trace = lttv_traceset_number(traceset);
1201   for(i = 0 ; i < nb_trace ; i++) {
1202     ts = (LttvTraceState *)self->parent.traces[i];
1203
1204     /* Find the eventtype id for the following events and register the
1205        associated by id hooks. */
1206
1207     hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 10);
1208     g_array_set_size(hooks, 10);
1209
1210     ret = lttv_trace_find_hook(ts->parent.t,
1211         LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
1212         LTT_FIELD_SYSCALL_ID, 0, 0,
1213         syscall_entry, &g_array_index(hooks, LttvTraceHook, 0));
1214     g_assert(!ret);
1215
1216     ret = lttv_trace_find_hook(ts->parent.t,
1217         LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_EXIT,
1218         0, 0, 0,
1219         syscall_exit, &g_array_index(hooks, LttvTraceHook, 1));
1220     g_assert(!ret);
1221
1222     ret = lttv_trace_find_hook(ts->parent.t,
1223         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
1224         LTT_FIELD_TRAP_ID, 0, 0,
1225         trap_entry, &g_array_index(hooks, LttvTraceHook, 2));
1226     g_assert(!ret);
1227
1228     ret = lttv_trace_find_hook(ts->parent.t,
1229         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
1230         0, 0, 0,
1231         trap_exit, &g_array_index(hooks, LttvTraceHook, 3));
1232     g_assert(!ret);
1233
1234     ret = lttv_trace_find_hook(ts->parent.t,
1235         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
1236         LTT_FIELD_IRQ_ID, 0, 0,
1237         irq_entry, &g_array_index(hooks, LttvTraceHook, 4));
1238     g_assert(!ret);
1239
1240     ret = lttv_trace_find_hook(ts->parent.t,
1241         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
1242         0, 0, 0,
1243         irq_exit, &g_array_index(hooks, LttvTraceHook, 5));
1244     g_assert(!ret);
1245
1246     ret = lttv_trace_find_hook(ts->parent.t,
1247         LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
1248         LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
1249         schedchange, &g_array_index(hooks, LttvTraceHook, 6));
1250     g_assert(!ret);
1251
1252     ret = lttv_trace_find_hook(ts->parent.t,
1253         LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
1254         LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0,
1255         process_fork, &g_array_index(hooks, LttvTraceHook, 7));
1256     g_assert(!ret);
1257
1258     ret = lttv_trace_find_hook(ts->parent.t,
1259         LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
1260         LTT_FIELD_PID, 0, 0,
1261         process_exit, &g_array_index(hooks, LttvTraceHook, 8));
1262     g_assert(!ret);
1263
1264     ret = lttv_trace_find_hook(ts->parent.t,
1265         LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
1266         LTT_FIELD_PID, 0, 0,
1267         process_free, &g_array_index(hooks, LttvTraceHook, 9));
1268     g_assert(!ret);
1269
1270
1271     /* Add these hooks to each event_by_id hooks list */
1272
1273     nb_tracefile = ts->parent.tracefiles->len;
1274
1275     for(j = 0 ; j < nb_tracefile ; j++) {
1276       tfs =
1277           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1278                                           LttvTracefileContext*, j));
1279
1280       for(k = 0 ; k < hooks->len ; k++) {
1281         hook = &g_array_index(hooks, LttvTraceHook, k);
1282         for(l=0;l<hook->fac_list->len;l++) {
1283           thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
1284           lttv_hooks_add(
1285             lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
1286             thf->h,
1287             thf,
1288             LTTV_PRIO_STATE);
1289         }
1290       }
1291     }
1292     lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1293     *(val.v_pointer) = hooks;
1294   }
1295 }
1296
1297 gint lttv_state_hook_remove_event_hooks(void *hook_data, void *call_data)
1298 {
1299   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1300
1301   lttv_state_remove_event_hooks(tss);
1302
1303   return 0;
1304 }
1305
1306 void lttv_state_remove_event_hooks(LttvTracesetState *self)
1307 {
1308   LttvTraceset *traceset = self->parent.ts;
1309
1310   guint i, j, k, l, nb_trace, nb_tracefile;
1311
1312   LttvTraceState *ts;
1313
1314   LttvTracefileState *tfs;
1315
1316   GArray *hooks;
1317
1318   LttvTraceHook *hook;
1319
1320   LttvTraceHookByFacility *thf;
1321
1322   LttvAttributeValue val;
1323
1324   nb_trace = lttv_traceset_number(traceset);
1325   for(i = 0 ; i < nb_trace ; i++) {
1326     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1327     lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1328     hooks = *(val.v_pointer);
1329
1330     /* Remove these hooks from each event_by_id hooks list */
1331
1332     nb_tracefile = ts->parent.tracefiles->len;
1333
1334     for(j = 0 ; j < nb_tracefile ; j++) {
1335       tfs =
1336           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1337                                           LttvTracefileContext*, j));
1338
1339       for(k = 0 ; k < hooks->len ; k++) {
1340         hook = &g_array_index(hooks, LttvTraceHook, k);
1341         for(l=0;l<hook->fac_list->len;l++) {
1342           thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
1343
1344           lttv_hooks_remove_data(
1345             lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
1346                     thf->h,
1347                     thf);
1348         }
1349         lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k));
1350       }
1351     }
1352     g_array_free(hooks, TRUE);
1353   }
1354 }
1355
1356
1357 static gboolean state_save_event_hook(void *hook_data, void *call_data)
1358 {
1359   guint *event_count = (guint*)hook_data;
1360
1361   /* Only save at LTTV_STATE_SAVE_INTERVAL */
1362   if(likely((*event_count)++ < LTTV_STATE_SAVE_INTERVAL))
1363     return FALSE;
1364   else
1365     event_count = 0;
1366
1367   LttvTracefileState *self = (LttvTracefileState *)call_data;
1368
1369   LttvTracefileState *tfcs;
1370
1371   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1372
1373   LttEventPosition *ep;
1374
1375   guint i;
1376
1377   LttTracefile *tf;
1378
1379   LttvAttribute *saved_states_tree, *saved_state_tree;
1380
1381   LttvAttributeValue value;
1382
1383   saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1384       LTTV_STATE_SAVED_STATES);
1385   saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1386   value = lttv_attribute_add(saved_states_tree,
1387       lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1388   *(value.v_gobject) = (GObject *)saved_state_tree;
1389   value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1390   *(value.v_time) = self->parent.timestamp;
1391   lttv_state_save(tcs, saved_state_tree);
1392   g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1393     self->parent.timestamp.tv_nsec);
1394
1395   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1396
1397   return FALSE;
1398 }
1399
1400 #if 0
1401 static gboolean block_start(void *hook_data, void *call_data)
1402 {
1403   LttvTracefileState *self = (LttvTracefileState *)call_data;
1404
1405   LttvTracefileState *tfcs;
1406
1407   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1408
1409   LttEventPosition *ep;
1410
1411   guint i, nb_block, nb_event, nb_tracefile;
1412
1413   LttTracefile *tf;
1414
1415   LttvAttribute *saved_states_tree, *saved_state_tree;
1416
1417   LttvAttributeValue value;
1418
1419   ep = ltt_event_position_new();
1420
1421   nb_tracefile = tcs->parent.tracefiles->len;
1422
1423   /* Count the number of events added since the last block end in any
1424      tracefile. */
1425
1426   for(i = 0 ; i < nb_tracefile ; i++) {
1427     tfcs =
1428           LTTV_TRACEFILE_STATE(&g_array_index(tcs->parent.tracefiles,
1429                                           LttvTracefileContext, i));
1430     ltt_event_position(tfcs->parent.e, ep);
1431     ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1432     tcs->nb_event += nb_event - tfcs->saved_position;
1433     tfcs->saved_position = nb_event;
1434   }
1435   g_free(ep);
1436
1437   if(tcs->nb_event >= tcs->save_interval) {
1438     saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1439         LTTV_STATE_SAVED_STATES);
1440     saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1441     value = lttv_attribute_add(saved_states_tree,
1442         lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1443     *(value.v_gobject) = (GObject *)saved_state_tree;
1444     value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1445     *(value.v_time) = self->parent.timestamp;
1446     lttv_state_save(tcs, saved_state_tree);
1447     tcs->nb_event = 0;
1448     g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1449             self->parent.timestamp.tv_nsec);
1450   }
1451   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1452   return FALSE;
1453 }
1454 #endif //0
1455
1456 #if 0
1457 static gboolean block_end(void *hook_data, void *call_data)
1458 {
1459   LttvTracefileState *self = (LttvTracefileState *)call_data;
1460
1461   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1462
1463   LttTracefile *tf;
1464
1465   LttEventPosition *ep;
1466
1467   guint nb_block, nb_event;
1468
1469   ep = ltt_event_position_new();
1470   ltt_event_position(self->parent.e, ep);
1471   ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1472   tcs->nb_event += nb_event - self->saved_position + 1;
1473   self->saved_position = 0;
1474   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1475   g_free(ep);
1476
1477   return FALSE;
1478 }
1479 #endif //0
1480 #if 0
1481 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1482 {
1483   LttvTraceset *traceset = self->parent.ts;
1484
1485   guint i, j, nb_trace, nb_tracefile;
1486
1487   LttvTraceState *ts;
1488
1489   LttvTracefileState *tfs;
1490
1491   LttvTraceHook hook_start, hook_end;
1492
1493   nb_trace = lttv_traceset_number(traceset);
1494   for(i = 0 ; i < nb_trace ; i++) {
1495     ts = (LttvTraceState *)self->parent.traces[i];
1496
1497     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1498         NULL, NULL, block_start, &hook_start);
1499     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1500         NULL, NULL, block_end, &hook_end);
1501
1502     nb_tracefile = ts->parent.tracefiles->len;
1503
1504     for(j = 0 ; j < nb_tracefile ; j++) {
1505       tfs =
1506           LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
1507                                           LttvTracefileContext, j));
1508       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1509                 hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
1510       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1511                       hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
1512     }
1513   }
1514 }
1515 #endif //0
1516
1517 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1518 {
1519   LttvTraceset *traceset = self->parent.ts;
1520
1521   guint i, j, nb_trace, nb_tracefile;
1522
1523   LttvTraceState *ts;
1524
1525   LttvTracefileState *tfs;
1526
1527
1528   nb_trace = lttv_traceset_number(traceset);
1529   for(i = 0 ; i < nb_trace ; i++) {
1530
1531     ts = (LttvTraceState *)self->parent.traces[i];
1532     nb_tracefile = ts->parent.tracefiles->len;
1533
1534     guint *event_count = g_new(guint, 1);
1535     *event_count = 0;
1536
1537     for(j = 0 ; j < nb_tracefile ; j++) {
1538       tfs =
1539           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1540                                           LttvTracefileContext*, j));
1541       lttv_hooks_add(tfs->parent.event,
1542                      state_save_event_hook,
1543                      event_count,
1544                      LTTV_PRIO_STATE);
1545
1546     }
1547   }
1548 }
1549
1550 gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data)
1551 {
1552   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1553
1554   lttv_state_save_add_event_hooks(tss);
1555
1556   return 0;
1557 }
1558
1559
1560 #if 0
1561 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
1562 {
1563   LttvTraceset *traceset = self->parent.ts;
1564
1565   guint i, j, nb_trace, nb_tracefile;
1566
1567   LttvTraceState *ts;
1568
1569   LttvTracefileState *tfs;
1570
1571   LttvTraceHook hook_start, hook_end;
1572
1573   nb_trace = lttv_traceset_number(traceset);
1574   for(i = 0 ; i < nb_trace ; i++) {
1575     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1576
1577     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1578         NULL, NULL, block_start, &hook_start);
1579
1580     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1581         NULL, NULL, block_end, &hook_end);
1582
1583     nb_tracefile = ts->parent.tracefiles->len;
1584
1585     for(j = 0 ; j < nb_tracefile ; j++) {
1586       tfs =
1587           LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
1588                                           LttvTracefileContext, j));
1589       lttv_hooks_remove_data(lttv_hooks_by_id_find(
1590           tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
1591       lttv_hooks_remove_data(lttv_hooks_by_id_find(
1592           tfs->parent.event_by_id, hook_end.id), hook_end.h, NULL);
1593     }
1594   }
1595 }
1596 #endif //0
1597
1598 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
1599 {
1600   LttvTraceset *traceset = self->parent.ts;
1601
1602   guint i, j, nb_trace, nb_tracefile;
1603
1604   LttvTraceState *ts;
1605
1606   LttvTracefileState *tfs;
1607
1608
1609   nb_trace = lttv_traceset_number(traceset);
1610   for(i = 0 ; i < nb_trace ; i++) {
1611
1612     ts = (LttvTraceState *)self->parent.traces[i];
1613     nb_tracefile = ts->parent.tracefiles->len;
1614
1615     guint *event_count;
1616
1617     for(j = 0 ; j < nb_tracefile ; j++) {
1618       tfs =
1619           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1620                                           LttvTracefileContext*, j));
1621       event_count = lttv_hooks_remove(tfs->parent.event,
1622                         state_save_event_hook);
1623       g_free(event_count);
1624
1625     }
1626   }
1627 }
1628
1629 gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data)
1630 {
1631   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1632
1633   lttv_state_save_remove_event_hooks(tss);
1634
1635   return 0;
1636 }
1637
1638 void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
1639 {
1640   LttvTraceset *traceset = self->parent.ts;
1641
1642   guint i, nb_trace;
1643
1644   int min_pos, mid_pos, max_pos;
1645
1646   LttvTraceState *tcs;
1647
1648   LttvAttributeValue value;
1649
1650   LttvAttributeType type;
1651
1652   LttvAttributeName name;
1653
1654   LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
1655
1656   nb_trace = lttv_traceset_number(traceset);
1657   for(i = 0 ; i < nb_trace ; i++) {
1658     tcs = (LttvTraceState *)self->parent.traces[i];
1659
1660     if(ltt_time_compare(t, *(tcs->max_time_state_recomputed_in_seek)) < 0) {
1661       saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1662           LTTV_STATE_SAVED_STATES);
1663       min_pos = -1;
1664
1665       if(saved_states_tree) {
1666         max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
1667         mid_pos = max_pos / 2;
1668         while(min_pos < max_pos) {
1669           type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value);
1670           g_assert(type == LTTV_GOBJECT);
1671           saved_state_tree = *((LttvAttribute **)(value.v_gobject));
1672           type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME,
1673               &value);
1674           g_assert(type == LTTV_TIME);
1675           if(ltt_time_compare(*(value.v_time), t) < 0) {
1676             min_pos = mid_pos;
1677             closest_tree = saved_state_tree;
1678           }
1679           else max_pos = mid_pos - 1;
1680
1681           mid_pos = (min_pos + max_pos + 1) / 2;
1682         }
1683       }
1684
1685       /* restore the closest earlier saved state */
1686       if(min_pos != -1) {
1687         lttv_state_restore(tcs, closest_tree);
1688       }
1689
1690       /* There is no saved state, yet we want to have it. Restart at T0 */
1691       else {
1692         restore_init_state(tcs);
1693         lttv_process_trace_seek_time(&(tcs->parent), ltt_time_zero);
1694       }
1695     }
1696     /* We want to seek quickly without restoring/updating the state */
1697     else {
1698       restore_init_state(tcs);
1699       lttv_process_trace_seek_time(&(tcs->parent), t);
1700     }
1701   }
1702 }
1703
1704
1705 static void
1706 traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
1707 {
1708 }
1709
1710
1711 static void
1712 traceset_state_finalize (LttvTracesetState *self)
1713 {
1714   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
1715       finalize(G_OBJECT(self));
1716 }
1717
1718
1719 static void
1720 traceset_state_class_init (LttvTracesetContextClass *klass)
1721 {
1722   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1723
1724   gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
1725   klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
1726   klass->fini = (void (*)(LttvTracesetContext *self))fini;
1727   klass->new_traceset_context = new_traceset_context;
1728   klass->new_trace_context = new_trace_context;
1729   klass->new_tracefile_context = new_tracefile_context;
1730 }
1731
1732
1733 GType
1734 lttv_traceset_state_get_type(void)
1735 {
1736   static GType type = 0;
1737   if (type == 0) {
1738     static const GTypeInfo info = {
1739       sizeof (LttvTracesetStateClass),
1740       NULL,   /* base_init */
1741       NULL,   /* base_finalize */
1742       (GClassInitFunc) traceset_state_class_init,   /* class_init */
1743       NULL,   /* class_finalize */
1744       NULL,   /* class_data */
1745       sizeof (LttvTracesetState),
1746       0,      /* n_preallocs */
1747       (GInstanceInitFunc) traceset_state_instance_init,    /* instance_init */
1748       NULL    /* value handling */
1749     };
1750
1751     type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
1752         &info, 0);
1753   }
1754   return type;
1755 }
1756
1757
1758 static void
1759 trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
1760 {
1761 }
1762
1763
1764 static void
1765 trace_state_finalize (LttvTraceState *self)
1766 {
1767   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE))->
1768       finalize(G_OBJECT(self));
1769 }
1770
1771
1772 static void
1773 trace_state_class_init (LttvTraceStateClass *klass)
1774 {
1775   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1776
1777   gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
1778   klass->state_save = state_save;
1779   klass->state_restore = state_restore;
1780   klass->state_saved_free = state_saved_free;
1781 }
1782
1783
1784 GType
1785 lttv_trace_state_get_type(void)
1786 {
1787   static GType type = 0;
1788   if (type == 0) {
1789     static const GTypeInfo info = {
1790       sizeof (LttvTraceStateClass),
1791       NULL,   /* base_init */
1792       NULL,   /* base_finalize */
1793       (GClassInitFunc) trace_state_class_init,   /* class_init */
1794       NULL,   /* class_finalize */
1795       NULL,   /* class_data */
1796       sizeof (LttvTraceState),
1797       0,      /* n_preallocs */
1798       (GInstanceInitFunc) trace_state_instance_init,    /* instance_init */
1799       NULL    /* value handling */
1800     };
1801
1802     type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
1803         "LttvTraceStateType", &info, 0);
1804   }
1805   return type;
1806 }
1807
1808
1809 static void
1810 tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
1811 {
1812 }
1813
1814
1815 static void
1816 tracefile_state_finalize (LttvTracefileState *self)
1817 {
1818   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE))->
1819       finalize(G_OBJECT(self));
1820 }
1821
1822
1823 static void
1824 tracefile_state_class_init (LttvTracefileStateClass *klass)
1825 {
1826   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1827
1828   gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
1829 }
1830
1831
1832 GType
1833 lttv_tracefile_state_get_type(void)
1834 {
1835   static GType type = 0;
1836   if (type == 0) {
1837     static const GTypeInfo info = {
1838       sizeof (LttvTracefileStateClass),
1839       NULL,   /* base_init */
1840       NULL,   /* base_finalize */
1841       (GClassInitFunc) tracefile_state_class_init,   /* class_init */
1842       NULL,   /* class_finalize */
1843       NULL,   /* class_data */
1844       sizeof (LttvTracefileState),
1845       0,      /* n_preallocs */
1846       (GInstanceInitFunc) tracefile_state_instance_init,    /* instance_init */
1847       NULL    /* value handling */
1848     };
1849
1850     type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
1851         "LttvTracefileStateType", &info, 0);
1852   }
1853   return type;
1854 }
1855
1856
1857 static void module_init()
1858 {
1859   LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
1860   LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("unknown execution mode");
1861   LTTV_STATE_USER_MODE = g_quark_from_string("user mode");
1862   LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork");
1863   LTTV_STATE_SYSCALL = g_quark_from_string("system call");
1864   LTTV_STATE_TRAP = g_quark_from_string("trap");
1865   LTTV_STATE_IRQ = g_quark_from_string("irq");
1866   LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("unknown submode");
1867   LTTV_STATE_SUBMODE_NONE = g_quark_from_string("(no submode)");
1868   LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
1869   LTTV_STATE_EXIT = g_quark_from_string("exiting");
1870   LTTV_STATE_ZOMBIE = g_quark_from_string("zombie");
1871   LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
1872   LTTV_STATE_RUN = g_quark_from_string("running");
1873   LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
1874   LTTV_STATE_PROCESSES = g_quark_from_string("processes");
1875   LTTV_STATE_PROCESS = g_quark_from_string("process");
1876   LTTV_STATE_EVENT = g_quark_from_string("event");
1877   LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
1878   LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
1879   LTTV_STATE_TIME = g_quark_from_string("time");
1880   LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
1881   LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
1882   LTTV_STATE_TRACE_STATE_USE_COUNT =
1883       g_quark_from_string("trace_state_use_count");
1884
1885
1886   LTT_FACILITY_KERNEL     = g_quark_from_string("kernel");
1887   LTT_FACILITY_PROCESS    = g_quark_from_string("process");
1888
1889
1890   LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
1891   LTT_EVENT_SYSCALL_EXIT  = g_quark_from_string("syscall_exit");
1892   LTT_EVENT_TRAP_ENTRY    = g_quark_from_string("trap_entry");
1893   LTT_EVENT_TRAP_EXIT     = g_quark_from_string("trap_exit");
1894   LTT_EVENT_IRQ_ENTRY     = g_quark_from_string("irq_entry");
1895   LTT_EVENT_IRQ_EXIT      = g_quark_from_string("irq_exit");
1896   LTT_EVENT_SCHEDCHANGE   = g_quark_from_string("schedchange");
1897   LTT_EVENT_FORK          = g_quark_from_string("fork");
1898   LTT_EVENT_EXIT          = g_quark_from_string("exit");
1899   LTT_EVENT_FREE          = g_quark_from_string("free");
1900
1901
1902   LTT_FIELD_SYSCALL_ID    = g_quark_from_string("syscall_id");
1903   LTT_FIELD_TRAP_ID       = g_quark_from_string("trap_id");
1904   LTT_FIELD_IRQ_ID        = g_quark_from_string("irq_id");
1905   LTT_FIELD_OUT           = g_quark_from_string("out");
1906   LTT_FIELD_IN            = g_quark_from_string("in");
1907   LTT_FIELD_OUT_STATE     = g_quark_from_string("out_state");
1908   LTT_FIELD_PARENT_PID    = g_quark_from_string("parent_pid");
1909   LTT_FIELD_CHILD_PID     = g_quark_from_string("child_pid");
1910   LTT_FIELD_PID           = g_quark_from_string("pid");
1911
1912 }
1913
1914 static void module_destroy()
1915 {
1916 }
1917
1918
1919 LTTV_MODULE("state", "State computation", \
1920     "Update the system state, possibly saving it at intervals", \
1921     module_init, module_destroy)
1922
1923
1924