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;
1055   gint state_out;
1056
1057   pid_out = ltt_event_get_unsigned(e, thf->f1);
1058   pid_in = ltt_event_get_unsigned(e, thf->f2);
1059   state_out = ltt_event_get_int(e, thf->f3);
1060
1061   if(likely(s->process != NULL)) {
1062
1063     /* We could not know but it was not the idle process executing.
1064        This should only happen at the beginning, before the first schedule
1065        event, and when the initial information (current process for each CPU)
1066        is missing. It is not obvious how we could, after the fact, compensate
1067        the wrongly attributed statistics. */
1068
1069     if(unlikely(s->process->pid != pid_out)) {
1070       g_assert(s->process->pid == 0);
1071     }
1072
1073     if(unlikely(s->process->state->s == LTTV_STATE_EXIT)) {
1074       s->process->state->s = LTTV_STATE_ZOMBIE;
1075     } else {
1076       if(unlikely(state_out == 0)) s->process->state->s = LTTV_STATE_WAIT_CPU;
1077       else s->process->state->s = LTTV_STATE_WAIT;
1078     } /* FIXME : we do not remove process here, because the kernel
1079        * still has them : they may be zombies. We need to know
1080        * exactly when release_task is executed on the PID to
1081        * know when the zombie is destroyed.
1082        */
1083     //else
1084     //  exit_process(s, s->process);
1085
1086     s->process->state->change = s->parent.timestamp;
1087   }
1088   s->process = lttv_state_find_process_or_create(s, pid_in);
1089   s->process->state->s = LTTV_STATE_RUN;
1090   s->process->last_cpu = s->cpu_name;
1091   s->process->last_cpu_index = ((LttvTracefileContext*)s)->index;
1092   s->process->state->change = s->parent.timestamp;
1093   return FALSE;
1094 }
1095
1096 static gboolean process_fork(void *hook_data, void *call_data)
1097 {
1098   LttvTracefileState *s = (LttvTracefileState *)call_data;
1099   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1100   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1101   LttField *f;
1102   guint parent_pid;
1103   guint child_pid;
1104   LttvProcessState *zombie_process;
1105
1106   /* Parent PID */
1107   f = thf->f1;
1108   parent_pid = ltt_event_get_unsigned(e, f);
1109
1110   /* Child PID */
1111   f = thf->f2;
1112   child_pid = ltt_event_get_unsigned(e, f);
1113
1114   zombie_process = lttv_state_find_process(s, child_pid);
1115
1116   if(unlikely(zombie_process != NULL)) {
1117     /* Reutilisation of PID. Only now we are sure that the old PID
1118      * has been released. FIXME : should know when release_task happens instead.
1119      */
1120     exit_process(s, zombie_process);
1121   }
1122   g_assert(s->process->pid != child_pid);
1123   // FIXME : Add this test in the "known state" section
1124   // g_assert(s->process->pid == parent_pid);
1125   lttv_state_create_process(s, s->process, child_pid);
1126
1127   return FALSE;
1128 }
1129
1130
1131 static gboolean process_exit(void *hook_data, void *call_data)
1132 {
1133   LttvTracefileState *s = (LttvTracefileState *)call_data;
1134   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1135   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1136   LttField *f;
1137   guint pid;
1138
1139   pid = ltt_event_get_unsigned(e, thf->f1);
1140
1141   // FIXME : Add this test in the "known state" section
1142   // g_assert(s->process->pid == pid);
1143
1144   if(likely(s->process != NULL)) {
1145     s->process->state->s = LTTV_STATE_EXIT;
1146   }
1147   return FALSE;
1148 }
1149
1150 static gboolean process_free(void *hook_data, void *call_data)
1151 {
1152   LttvTracefileState *s = (LttvTracefileState *)call_data;
1153   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1154   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1155   guint release_pid;
1156   LttvProcessState *process;
1157
1158   /* PID of the process to release */
1159   release_pid = ltt_event_get_unsigned(e, thf->f1);
1160
1161   process = lttv_state_find_process(s, release_pid);
1162
1163   if(likely(process != NULL)) {
1164     /* release_task is happening at kernel level : we can now safely release
1165      * the data structure of the process */
1166     exit_process(s, process);
1167   }
1168
1169   return FALSE;
1170 }
1171
1172 gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
1173 {
1174   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1175
1176   lttv_state_add_event_hooks(tss);
1177
1178   return 0;
1179 }
1180
1181 void lttv_state_add_event_hooks(LttvTracesetState *self)
1182 {
1183   LttvTraceset *traceset = self->parent.ts;
1184
1185   guint i, j, k, l, nb_trace, nb_tracefile;
1186
1187   LttvTraceState *ts;
1188
1189   LttvTracefileState *tfs;
1190
1191   GArray *hooks;
1192
1193   LttvTraceHookByFacility *thf;
1194
1195   LttvTraceHook *hook;
1196
1197   LttvAttributeValue val;
1198
1199   gint ret;
1200
1201   nb_trace = lttv_traceset_number(traceset);
1202   for(i = 0 ; i < nb_trace ; i++) {
1203     ts = (LttvTraceState *)self->parent.traces[i];
1204
1205     /* Find the eventtype id for the following events and register the
1206        associated by id hooks. */
1207
1208     hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 10);
1209     g_array_set_size(hooks, 10);
1210
1211     ret = lttv_trace_find_hook(ts->parent.t,
1212         LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
1213         LTT_FIELD_SYSCALL_ID, 0, 0,
1214         syscall_entry, &g_array_index(hooks, LttvTraceHook, 0));
1215     g_assert(!ret);
1216
1217     ret = lttv_trace_find_hook(ts->parent.t,
1218         LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_EXIT,
1219         0, 0, 0,
1220         syscall_exit, &g_array_index(hooks, LttvTraceHook, 1));
1221     g_assert(!ret);
1222
1223     ret = lttv_trace_find_hook(ts->parent.t,
1224         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
1225         LTT_FIELD_TRAP_ID, 0, 0,
1226         trap_entry, &g_array_index(hooks, LttvTraceHook, 2));
1227     g_assert(!ret);
1228
1229     ret = lttv_trace_find_hook(ts->parent.t,
1230         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
1231         0, 0, 0,
1232         trap_exit, &g_array_index(hooks, LttvTraceHook, 3));
1233     g_assert(!ret);
1234
1235     ret = lttv_trace_find_hook(ts->parent.t,
1236         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
1237         LTT_FIELD_IRQ_ID, 0, 0,
1238         irq_entry, &g_array_index(hooks, LttvTraceHook, 4));
1239     g_assert(!ret);
1240
1241     ret = lttv_trace_find_hook(ts->parent.t,
1242         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
1243         0, 0, 0,
1244         irq_exit, &g_array_index(hooks, LttvTraceHook, 5));
1245     g_assert(!ret);
1246
1247     ret = lttv_trace_find_hook(ts->parent.t,
1248         LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
1249         LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
1250         schedchange, &g_array_index(hooks, LttvTraceHook, 6));
1251     g_assert(!ret);
1252
1253     ret = lttv_trace_find_hook(ts->parent.t,
1254         LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
1255         LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0,
1256         process_fork, &g_array_index(hooks, LttvTraceHook, 7));
1257     g_assert(!ret);
1258
1259     ret = lttv_trace_find_hook(ts->parent.t,
1260         LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
1261         LTT_FIELD_PID, 0, 0,
1262         process_exit, &g_array_index(hooks, LttvTraceHook, 8));
1263     g_assert(!ret);
1264
1265     ret = lttv_trace_find_hook(ts->parent.t,
1266         LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
1267         LTT_FIELD_PID, 0, 0,
1268         process_free, &g_array_index(hooks, LttvTraceHook, 9));
1269     g_assert(!ret);
1270
1271
1272     /* Add these hooks to each event_by_id hooks list */
1273
1274     nb_tracefile = ts->parent.tracefiles->len;
1275
1276     for(j = 0 ; j < nb_tracefile ; j++) {
1277       tfs =
1278           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1279                                           LttvTracefileContext*, j));
1280
1281       for(k = 0 ; k < hooks->len ; k++) {
1282         hook = &g_array_index(hooks, LttvTraceHook, k);
1283         for(l=0;l<hook->fac_list->len;l++) {
1284           thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
1285           lttv_hooks_add(
1286             lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
1287             thf->h,
1288             thf,
1289             LTTV_PRIO_STATE);
1290         }
1291       }
1292     }
1293     lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1294     *(val.v_pointer) = hooks;
1295   }
1296 }
1297
1298 gint lttv_state_hook_remove_event_hooks(void *hook_data, void *call_data)
1299 {
1300   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1301
1302   lttv_state_remove_event_hooks(tss);
1303
1304   return 0;
1305 }
1306
1307 void lttv_state_remove_event_hooks(LttvTracesetState *self)
1308 {
1309   LttvTraceset *traceset = self->parent.ts;
1310
1311   guint i, j, k, l, nb_trace, nb_tracefile;
1312
1313   LttvTraceState *ts;
1314
1315   LttvTracefileState *tfs;
1316
1317   GArray *hooks;
1318
1319   LttvTraceHook *hook;
1320
1321   LttvTraceHookByFacility *thf;
1322
1323   LttvAttributeValue val;
1324
1325   nb_trace = lttv_traceset_number(traceset);
1326   for(i = 0 ; i < nb_trace ; i++) {
1327     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1328     lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1329     hooks = *(val.v_pointer);
1330
1331     /* Remove these hooks from each event_by_id hooks list */
1332
1333     nb_tracefile = ts->parent.tracefiles->len;
1334
1335     for(j = 0 ; j < nb_tracefile ; j++) {
1336       tfs =
1337           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1338                                           LttvTracefileContext*, j));
1339
1340       for(k = 0 ; k < hooks->len ; k++) {
1341         hook = &g_array_index(hooks, LttvTraceHook, k);
1342         for(l=0;l<hook->fac_list->len;l++) {
1343           thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
1344
1345           lttv_hooks_remove_data(
1346             lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
1347                     thf->h,
1348                     thf);
1349         }
1350         lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k));
1351       }
1352     }
1353     g_array_free(hooks, TRUE);
1354   }
1355 }
1356
1357
1358 static gboolean state_save_event_hook(void *hook_data, void *call_data)
1359 {
1360   guint *event_count = (guint*)hook_data;
1361
1362   /* Only save at LTTV_STATE_SAVE_INTERVAL */
1363   if(likely((*event_count)++ < LTTV_STATE_SAVE_INTERVAL))
1364     return FALSE;
1365   else
1366     event_count = 0;
1367
1368   LttvTracefileState *self = (LttvTracefileState *)call_data;
1369
1370   LttvTracefileState *tfcs;
1371
1372   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1373
1374   LttEventPosition *ep;
1375
1376   guint i;
1377
1378   LttTracefile *tf;
1379
1380   LttvAttribute *saved_states_tree, *saved_state_tree;
1381
1382   LttvAttributeValue value;
1383
1384   saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1385       LTTV_STATE_SAVED_STATES);
1386   saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1387   value = lttv_attribute_add(saved_states_tree,
1388       lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1389   *(value.v_gobject) = (GObject *)saved_state_tree;
1390   value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1391   *(value.v_time) = self->parent.timestamp;
1392   lttv_state_save(tcs, saved_state_tree);
1393   g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1394     self->parent.timestamp.tv_nsec);
1395
1396   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1397
1398   return FALSE;
1399 }
1400
1401 #if 0
1402 static gboolean block_start(void *hook_data, void *call_data)
1403 {
1404   LttvTracefileState *self = (LttvTracefileState *)call_data;
1405
1406   LttvTracefileState *tfcs;
1407
1408   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1409
1410   LttEventPosition *ep;
1411
1412   guint i, nb_block, nb_event, nb_tracefile;
1413
1414   LttTracefile *tf;
1415
1416   LttvAttribute *saved_states_tree, *saved_state_tree;
1417
1418   LttvAttributeValue value;
1419
1420   ep = ltt_event_position_new();
1421
1422   nb_tracefile = tcs->parent.tracefiles->len;
1423
1424   /* Count the number of events added since the last block end in any
1425      tracefile. */
1426
1427   for(i = 0 ; i < nb_tracefile ; i++) {
1428     tfcs =
1429           LTTV_TRACEFILE_STATE(&g_array_index(tcs->parent.tracefiles,
1430                                           LttvTracefileContext, i));
1431     ltt_event_position(tfcs->parent.e, ep);
1432     ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1433     tcs->nb_event += nb_event - tfcs->saved_position;
1434     tfcs->saved_position = nb_event;
1435   }
1436   g_free(ep);
1437
1438   if(tcs->nb_event >= tcs->save_interval) {
1439     saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1440         LTTV_STATE_SAVED_STATES);
1441     saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1442     value = lttv_attribute_add(saved_states_tree,
1443         lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1444     *(value.v_gobject) = (GObject *)saved_state_tree;
1445     value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1446     *(value.v_time) = self->parent.timestamp;
1447     lttv_state_save(tcs, saved_state_tree);
1448     tcs->nb_event = 0;
1449     g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1450             self->parent.timestamp.tv_nsec);
1451   }
1452   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1453   return FALSE;
1454 }
1455 #endif //0
1456
1457 #if 0
1458 static gboolean block_end(void *hook_data, void *call_data)
1459 {
1460   LttvTracefileState *self = (LttvTracefileState *)call_data;
1461
1462   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1463
1464   LttTracefile *tf;
1465
1466   LttEventPosition *ep;
1467
1468   guint nb_block, nb_event;
1469
1470   ep = ltt_event_position_new();
1471   ltt_event_position(self->parent.e, ep);
1472   ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1473   tcs->nb_event += nb_event - self->saved_position + 1;
1474   self->saved_position = 0;
1475   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1476   g_free(ep);
1477
1478   return FALSE;
1479 }
1480 #endif //0
1481 #if 0
1482 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1483 {
1484   LttvTraceset *traceset = self->parent.ts;
1485
1486   guint i, j, nb_trace, nb_tracefile;
1487
1488   LttvTraceState *ts;
1489
1490   LttvTracefileState *tfs;
1491
1492   LttvTraceHook hook_start, hook_end;
1493
1494   nb_trace = lttv_traceset_number(traceset);
1495   for(i = 0 ; i < nb_trace ; i++) {
1496     ts = (LttvTraceState *)self->parent.traces[i];
1497
1498     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1499         NULL, NULL, block_start, &hook_start);
1500     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1501         NULL, NULL, block_end, &hook_end);
1502
1503     nb_tracefile = ts->parent.tracefiles->len;
1504
1505     for(j = 0 ; j < nb_tracefile ; j++) {
1506       tfs =
1507           LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
1508                                           LttvTracefileContext, j));
1509       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1510                 hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
1511       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1512                       hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
1513     }
1514   }
1515 }
1516 #endif //0
1517
1518 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1519 {
1520   LttvTraceset *traceset = self->parent.ts;
1521
1522   guint i, j, nb_trace, nb_tracefile;
1523
1524   LttvTraceState *ts;
1525
1526   LttvTracefileState *tfs;
1527
1528
1529   nb_trace = lttv_traceset_number(traceset);
1530   for(i = 0 ; i < nb_trace ; i++) {
1531
1532     ts = (LttvTraceState *)self->parent.traces[i];
1533     nb_tracefile = ts->parent.tracefiles->len;
1534
1535     guint *event_count = g_new(guint, 1);
1536     *event_count = 0;
1537
1538     for(j = 0 ; j < nb_tracefile ; j++) {
1539       tfs =
1540           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1541                                           LttvTracefileContext*, j));
1542       lttv_hooks_add(tfs->parent.event,
1543                      state_save_event_hook,
1544                      event_count,
1545                      LTTV_PRIO_STATE);
1546
1547     }
1548   }
1549 }
1550
1551 gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data)
1552 {
1553   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1554
1555   lttv_state_save_add_event_hooks(tss);
1556
1557   return 0;
1558 }
1559
1560
1561 #if 0
1562 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
1563 {
1564   LttvTraceset *traceset = self->parent.ts;
1565
1566   guint i, j, nb_trace, nb_tracefile;
1567
1568   LttvTraceState *ts;
1569
1570   LttvTracefileState *tfs;
1571
1572   LttvTraceHook hook_start, hook_end;
1573
1574   nb_trace = lttv_traceset_number(traceset);
1575   for(i = 0 ; i < nb_trace ; i++) {
1576     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1577
1578     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1579         NULL, NULL, block_start, &hook_start);
1580
1581     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1582         NULL, NULL, block_end, &hook_end);
1583
1584     nb_tracefile = ts->parent.tracefiles->len;
1585
1586     for(j = 0 ; j < nb_tracefile ; j++) {
1587       tfs =
1588           LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
1589                                           LttvTracefileContext, j));
1590       lttv_hooks_remove_data(lttv_hooks_by_id_find(
1591           tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
1592       lttv_hooks_remove_data(lttv_hooks_by_id_find(
1593           tfs->parent.event_by_id, hook_end.id), hook_end.h, NULL);
1594     }
1595   }
1596 }
1597 #endif //0
1598
1599 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
1600 {
1601   LttvTraceset *traceset = self->parent.ts;
1602
1603   guint i, j, nb_trace, nb_tracefile;
1604
1605   LttvTraceState *ts;
1606
1607   LttvTracefileState *tfs;
1608
1609
1610   nb_trace = lttv_traceset_number(traceset);
1611   for(i = 0 ; i < nb_trace ; i++) {
1612
1613     ts = (LttvTraceState *)self->parent.traces[i];
1614     nb_tracefile = ts->parent.tracefiles->len;
1615
1616     guint *event_count;
1617
1618     for(j = 0 ; j < nb_tracefile ; j++) {
1619       tfs =
1620           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1621                                           LttvTracefileContext*, j));
1622       event_count = lttv_hooks_remove(tfs->parent.event,
1623                         state_save_event_hook);
1624       g_free(event_count);
1625
1626     }
1627   }
1628 }
1629
1630 gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data)
1631 {
1632   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1633
1634   lttv_state_save_remove_event_hooks(tss);
1635
1636   return 0;
1637 }
1638
1639 void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
1640 {
1641   LttvTraceset *traceset = self->parent.ts;
1642
1643   guint i, nb_trace;
1644
1645   int min_pos, mid_pos, max_pos;
1646
1647   LttvTraceState *tcs;
1648
1649   LttvAttributeValue value;
1650
1651   LttvAttributeType type;
1652
1653   LttvAttributeName name;
1654
1655   LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
1656
1657   nb_trace = lttv_traceset_number(traceset);
1658   for(i = 0 ; i < nb_trace ; i++) {
1659     tcs = (LttvTraceState *)self->parent.traces[i];
1660
1661     if(ltt_time_compare(t, *(tcs->max_time_state_recomputed_in_seek)) < 0) {
1662       saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1663           LTTV_STATE_SAVED_STATES);
1664       min_pos = -1;
1665
1666       if(saved_states_tree) {
1667         max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
1668         mid_pos = max_pos / 2;
1669         while(min_pos < max_pos) {
1670           type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value);
1671           g_assert(type == LTTV_GOBJECT);
1672           saved_state_tree = *((LttvAttribute **)(value.v_gobject));
1673           type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME,
1674               &value);
1675           g_assert(type == LTTV_TIME);
1676           if(ltt_time_compare(*(value.v_time), t) < 0) {
1677             min_pos = mid_pos;
1678             closest_tree = saved_state_tree;
1679           }
1680           else max_pos = mid_pos - 1;
1681
1682           mid_pos = (min_pos + max_pos + 1) / 2;
1683         }
1684       }
1685
1686       /* restore the closest earlier saved state */
1687       if(min_pos != -1) {
1688         lttv_state_restore(tcs, closest_tree);
1689       }
1690
1691       /* There is no saved state, yet we want to have it. Restart at T0 */
1692       else {
1693         restore_init_state(tcs);
1694         lttv_process_trace_seek_time(&(tcs->parent), ltt_time_zero);
1695       }
1696     }
1697     /* We want to seek quickly without restoring/updating the state */
1698     else {
1699       restore_init_state(tcs);
1700       lttv_process_trace_seek_time(&(tcs->parent), t);
1701     }
1702   }
1703 }
1704
1705
1706 static void
1707 traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
1708 {
1709 }
1710
1711
1712 static void
1713 traceset_state_finalize (LttvTracesetState *self)
1714 {
1715   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
1716       finalize(G_OBJECT(self));
1717 }
1718
1719
1720 static void
1721 traceset_state_class_init (LttvTracesetContextClass *klass)
1722 {
1723   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1724
1725   gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
1726   klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
1727   klass->fini = (void (*)(LttvTracesetContext *self))fini;
1728   klass->new_traceset_context = new_traceset_context;
1729   klass->new_trace_context = new_trace_context;
1730   klass->new_tracefile_context = new_tracefile_context;
1731 }
1732
1733
1734 GType
1735 lttv_traceset_state_get_type(void)
1736 {
1737   static GType type = 0;
1738   if (type == 0) {
1739     static const GTypeInfo info = {
1740       sizeof (LttvTracesetStateClass),
1741       NULL,   /* base_init */
1742       NULL,   /* base_finalize */
1743       (GClassInitFunc) traceset_state_class_init,   /* class_init */
1744       NULL,   /* class_finalize */
1745       NULL,   /* class_data */
1746       sizeof (LttvTracesetState),
1747       0,      /* n_preallocs */
1748       (GInstanceInitFunc) traceset_state_instance_init,    /* instance_init */
1749       NULL    /* value handling */
1750     };
1751
1752     type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
1753         &info, 0);
1754   }
1755   return type;
1756 }
1757
1758
1759 static void
1760 trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
1761 {
1762 }
1763
1764
1765 static void
1766 trace_state_finalize (LttvTraceState *self)
1767 {
1768   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE))->
1769       finalize(G_OBJECT(self));
1770 }
1771
1772
1773 static void
1774 trace_state_class_init (LttvTraceStateClass *klass)
1775 {
1776   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1777
1778   gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
1779   klass->state_save = state_save;
1780   klass->state_restore = state_restore;
1781   klass->state_saved_free = state_saved_free;
1782 }
1783
1784
1785 GType
1786 lttv_trace_state_get_type(void)
1787 {
1788   static GType type = 0;
1789   if (type == 0) {
1790     static const GTypeInfo info = {
1791       sizeof (LttvTraceStateClass),
1792       NULL,   /* base_init */
1793       NULL,   /* base_finalize */
1794       (GClassInitFunc) trace_state_class_init,   /* class_init */
1795       NULL,   /* class_finalize */
1796       NULL,   /* class_data */
1797       sizeof (LttvTraceState),
1798       0,      /* n_preallocs */
1799       (GInstanceInitFunc) trace_state_instance_init,    /* instance_init */
1800       NULL    /* value handling */
1801     };
1802
1803     type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
1804         "LttvTraceStateType", &info, 0);
1805   }
1806   return type;
1807 }
1808
1809
1810 static void
1811 tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
1812 {
1813 }
1814
1815
1816 static void
1817 tracefile_state_finalize (LttvTracefileState *self)
1818 {
1819   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE))->
1820       finalize(G_OBJECT(self));
1821 }
1822
1823
1824 static void
1825 tracefile_state_class_init (LttvTracefileStateClass *klass)
1826 {
1827   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
1828
1829   gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
1830 }
1831
1832
1833 GType
1834 lttv_tracefile_state_get_type(void)
1835 {
1836   static GType type = 0;
1837   if (type == 0) {
1838     static const GTypeInfo info = {
1839       sizeof (LttvTracefileStateClass),
1840       NULL,   /* base_init */
1841       NULL,   /* base_finalize */
1842       (GClassInitFunc) tracefile_state_class_init,   /* class_init */
1843       NULL,   /* class_finalize */
1844       NULL,   /* class_data */
1845       sizeof (LttvTracefileState),
1846       0,      /* n_preallocs */
1847       (GInstanceInitFunc) tracefile_state_instance_init,    /* instance_init */
1848       NULL    /* value handling */
1849     };
1850
1851     type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
1852         "LttvTracefileStateType", &info, 0);
1853   }
1854   return type;
1855 }
1856
1857
1858 static void module_init()
1859 {
1860   LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
1861   LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("unknown execution mode");
1862   LTTV_STATE_USER_MODE = g_quark_from_string("user mode");
1863   LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork");
1864   LTTV_STATE_SYSCALL = g_quark_from_string("system call");
1865   LTTV_STATE_TRAP = g_quark_from_string("trap");
1866   LTTV_STATE_IRQ = g_quark_from_string("irq");
1867   LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("unknown submode");
1868   LTTV_STATE_SUBMODE_NONE = g_quark_from_string("(no submode)");
1869   LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
1870   LTTV_STATE_EXIT = g_quark_from_string("exiting");
1871   LTTV_STATE_ZOMBIE = g_quark_from_string("zombie");
1872   LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
1873   LTTV_STATE_RUN = g_quark_from_string("running");
1874   LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
1875   LTTV_STATE_PROCESSES = g_quark_from_string("processes");
1876   LTTV_STATE_PROCESS = g_quark_from_string("process");
1877   LTTV_STATE_EVENT = g_quark_from_string("event");
1878   LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
1879   LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
1880   LTTV_STATE_TIME = g_quark_from_string("time");
1881   LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
1882   LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
1883   LTTV_STATE_TRACE_STATE_USE_COUNT =
1884       g_quark_from_string("trace_state_use_count");
1885
1886
1887   LTT_FACILITY_KERNEL     = g_quark_from_string("kernel");
1888   LTT_FACILITY_PROCESS    = g_quark_from_string("process");
1889
1890
1891   LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
1892   LTT_EVENT_SYSCALL_EXIT  = g_quark_from_string("syscall_exit");
1893   LTT_EVENT_TRAP_ENTRY    = g_quark_from_string("trap_entry");
1894   LTT_EVENT_TRAP_EXIT     = g_quark_from_string("trap_exit");
1895   LTT_EVENT_IRQ_ENTRY     = g_quark_from_string("irq_entry");
1896   LTT_EVENT_IRQ_EXIT      = g_quark_from_string("irq_exit");
1897   LTT_EVENT_SCHEDCHANGE   = g_quark_from_string("schedchange");
1898   LTT_EVENT_FORK          = g_quark_from_string("fork");
1899   LTT_EVENT_EXIT          = g_quark_from_string("exit");
1900   LTT_EVENT_FREE          = g_quark_from_string("free");
1901
1902
1903   LTT_FIELD_SYSCALL_ID    = g_quark_from_string("syscall_id");
1904   LTT_FIELD_TRAP_ID       = g_quark_from_string("trap_id");
1905   LTT_FIELD_IRQ_ID        = g_quark_from_string("irq_id");
1906   LTT_FIELD_OUT           = g_quark_from_string("out");
1907   LTT_FIELD_IN            = g_quark_from_string("in");
1908   LTT_FIELD_OUT_STATE     = g_quark_from_string("out_state");
1909   LTT_FIELD_PARENT_PID    = g_quark_from_string("parent_pid");
1910   LTT_FIELD_CHILD_PID     = g_quark_from_string("child_pid");
1911   LTT_FIELD_PID           = g_quark_from_string("pid");
1912
1913 }
1914
1915 static void module_destroy()
1916 {
1917 }
1918
1919
1920 LTTV_MODULE("state", "State computation", \
1921     "Update the system state, possibly saving it at intervals", \
1922     module_init, module_destroy)
1923
1924
1925