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 #include <string.h>
  32
  33 /* Comment :
  34  * Mathieu Desnoyers
  35  * usertrace is there only to be able to update the current CPU of the
  36  * usertraces when there is a schedchange. it is a way to link the ProcessState
  37  * to the associated usertrace. Link only created upon thread creation.
  38  *
  39  * The cpu id is necessary : it gives us back the current ProcessState when we
  40  * are considering data from the usertrace.
  41  */
  42
  43 #define PREALLOCATED_EXECUTION_STACK 10
  44
  45 /* Facilities Quarks */
  46
  47 GQuark
  48     LTT_FACILITY_KERNEL,
  49     LTT_FACILITY_KERNEL_ARCH,
  50     LTT_FACILITY_PROCESS,
  51     LTT_FACILITY_FS,
  52     LTT_FACILITY_STATEDUMP,
  53     LTT_FACILITY_USER_GENERIC;
  54
  55 /* Events Quarks */
  56
  57 GQuark
  58     LTT_EVENT_SYSCALL_ENTRY,
  59     LTT_EVENT_SYSCALL_EXIT,
  60     LTT_EVENT_TRAP_ENTRY,
  61     LTT_EVENT_TRAP_EXIT,
  62     LTT_EVENT_IRQ_ENTRY,
  63     LTT_EVENT_IRQ_EXIT,
  64     LTT_EVENT_SOFT_IRQ_ENTRY,
  65     LTT_EVENT_SOFT_IRQ_EXIT,
  66     LTT_EVENT_SCHEDCHANGE,
  67     LTT_EVENT_FORK,
  68     LTT_EVENT_KERNEL_THREAD,
  69     LTT_EVENT_EXIT,
  70     LTT_EVENT_FREE,
  71     LTT_EVENT_EXEC,
  72     LTT_EVENT_ENUM_PROCESS_STATE,
  73     LTT_EVENT_STATEDUMP_END,
  74     LTT_EVENT_FUNCTION_ENTRY,
  75     LTT_EVENT_FUNCTION_EXIT,
  76     LTT_EVENT_THREAD_BRAND;
  77
  78 /* Fields Quarks */
  79
  80 GQuark
  81     LTT_FIELD_SYSCALL_ID,
  82     LTT_FIELD_TRAP_ID,
  83     LTT_FIELD_IRQ_ID,
  84     LTT_FIELD_SOFT_IRQ_ID,
  85     LTT_FIELD_OUT,
  86     LTT_FIELD_IN,
  87     LTT_FIELD_OUT_STATE,
  88     LTT_FIELD_PARENT_PID,
  89     LTT_FIELD_CHILD_PID,
  90     LTT_FIELD_PID,
  91     LTT_FIELD_TGID,
  92     LTT_FIELD_FILENAME,
  93     LTT_FIELD_NAME,
  94     LTT_FIELD_TYPE,
  95     LTT_FIELD_MODE,
  96     LTT_FIELD_SUBMODE,
  97     LTT_FIELD_STATUS,
  98     LTT_FIELD_THIS_FN,
  99     LTT_FIELD_CALL_SITE;
 100
 101 LttvExecutionMode
 102   LTTV_STATE_MODE_UNKNOWN,
 103   LTTV_STATE_USER_MODE,
 104   LTTV_STATE_SYSCALL,
 105   LTTV_STATE_TRAP,
 106   LTTV_STATE_IRQ,
 107   LTTV_STATE_SOFT_IRQ;
 108
 109 LttvExecutionSubmode
 110   LTTV_STATE_SUBMODE_UNKNOWN,
 111   LTTV_STATE_SUBMODE_NONE;
 112
 113 LttvProcessStatus
 114   LTTV_STATE_UNNAMED,
 115   LTTV_STATE_WAIT_FORK,
 116   LTTV_STATE_WAIT_CPU,
 117   LTTV_STATE_EXIT,
 118   LTTV_STATE_ZOMBIE,
 119   LTTV_STATE_WAIT,
 120   LTTV_STATE_RUN,
 121   LTTV_STATE_DEAD;
 122
 123 GQuark
 124   LTTV_STATE_UNBRANDED;
 125
 126 LttvProcessType
 127   LTTV_STATE_USER_THREAD,
 128   LTTV_STATE_KERNEL_THREAD;
 129
 130 static GQuark
 131   LTTV_STATE_TRACEFILES,
 132   LTTV_STATE_PROCESSES,
 133   LTTV_STATE_PROCESS,
 134   LTTV_STATE_RUNNING_PROCESS,
 135   LTTV_STATE_EVENT,
 136   LTTV_STATE_SAVED_STATES,
 137   LTTV_STATE_SAVED_STATES_TIME,
 138   LTTV_STATE_TIME,
 139   LTTV_STATE_HOOKS,
 140   LTTV_STATE_NAME_TABLES,
 141   LTTV_STATE_TRACE_STATE_USE_COUNT;
 142
 143 static void create_max_time(LttvTraceState *tcs);
 144
 145 static void get_max_time(LttvTraceState *tcs);
 146
 147 static void free_max_time(LttvTraceState *tcs);
 148
 149 static void create_name_tables(LttvTraceState *tcs);
 150
 151 static void get_name_tables(LttvTraceState *tcs);
 152
 153 static void free_name_tables(LttvTraceState *tcs);
 154
 155 static void free_saved_state(LttvTraceState *tcs);
 156
 157 static void lttv_state_free_process_table(GHashTable *processes);
 158
 159 static void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp,
 160                        GPtrArray *quarktable);
 161
 162 void lttv_state_save(LttvTraceState *self, LttvAttribute *container)
 163 {
 164   LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container);
 165 }
 166
 167
 168 void lttv_state_restore(LttvTraceState *self, LttvAttribute *container)
 169 {
 170   LTTV_TRACE_STATE_GET_CLASS(self)->state_restore(self, container);
 171 }
 172
 173
 174 void lttv_state_state_saved_free(LttvTraceState *self,
 175     LttvAttribute *container)
 176 {
 177   LTTV_TRACE_STATE_GET_CLASS(self)->state_saved_free(self, container);
 178 }
 179
 180
 181 guint process_hash(gconstpointer key)
 182 {
 183   guint pid = ((const LttvProcessState *)key)->pid;
 184   return (pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ;
 185 }
 186
 187
 188 /* If the hash table hash function is well distributed,
 189  * the process_equal should compare different pid */
 190 gboolean process_equal(gconstpointer a, gconstpointer b)
 191 {
 192   const LttvProcessState *process_a, *process_b;
 193   gboolean ret = TRUE;
 194
 195   process_a = (const LttvProcessState *)a;
 196   process_b = (const LttvProcessState *)b;
 197
 198   if(likely(process_a->pid != process_b->pid)) ret = FALSE;
 199   else if(likely(process_a->pid == 0 &&
 200                  process_a->cpu != process_b->cpu)) ret = FALSE;
 201
 202   return ret;
 203 }
 204
 205 static void delete_usertrace(gpointer key, gpointer value, gpointer user_data)
 206 {
 207   g_tree_destroy((GTree*)value);
 208 }
 209
 210 static void lttv_state_free_usertraces(GHashTable *usertraces)
 211 {
 212   g_hash_table_foreach(usertraces, delete_usertrace, NULL);
 213   g_hash_table_destroy(usertraces);
 214 }
 215
 216
 217
 218 static void
 219 restore_init_state(LttvTraceState *self)
 220 {
 221   guint i, nb_cpus;
 222
 223   LttvTracefileState *tfcs;
 224
 225   LttTime start_time, end_time;
 226
 227   /* Free the process tables */
 228   if(self->processes != NULL) lttv_state_free_process_table(self->processes);
 229   if(self->usertraces != NULL) lttv_state_free_usertraces(self->usertraces);
 230   self->processes = g_hash_table_new(process_hash, process_equal);
 231   self->usertraces = g_hash_table_new(g_direct_hash, g_direct_equal);
 232   self->nb_event = 0;
 233
 234   /* Seek time to beginning */
 235   // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
 236   // closest. It's the tracecontext job to seek the trace to the beginning
 237   // anyway : the init state might be used at the middle of the trace as well...
 238   //g_tree_destroy(self->parent.ts_context->pqueue);
 239   //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
 240
 241   ltt_trace_time_span_get(self->parent.t, &start_time, &end_time);
 242
 243   //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
 244
 245   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
 246
 247   /* Put the per cpu running_process to beginning state : process 0. */
 248   for(i=0; i< nb_cpus; i++) {
 249     LttvExecutionState *es;
 250     self->running_process[i] = lttv_state_create_process(self, NULL, i, 0, 0,
 251         LTTV_STATE_UNNAMED, &start_time);
 252     /* We are not sure is it's a kernel thread or normal thread, put the
 253       * bottom stack state to unknown */
 254     self->running_process[i]->execution_stack =
 255       g_array_set_size(self->running_process[i]->execution_stack, 1);
 256     es = self->running_process[i]->state =
 257       &g_array_index(self->running_process[i]->execution_stack,
 258         LttvExecutionState, 0);
 259     es->t = LTTV_STATE_MODE_UNKNOWN;
 260     es->s = LTTV_STATE_UNNAMED;
 261
 262     //self->running_process[i]->state->s = LTTV_STATE_RUN;
 263     self->running_process[i]->cpu = i;
 264   }
 265
 266 #if 0
 267   nb_tracefile = self->parent.tracefiles->len;
 268
 269   for(i = 0 ; i < nb_tracefile ; i++) {
 270     tfcs =
 271       LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 272                                           LttvTracefileContext*, i));
 273     ltt_trace_time_span_get(self->parent.t, &tfcs->parent.timestamp, NULL);
 274 //    tfcs->saved_position = 0;
 275     tfcs->process = lttv_state_create_process(tfcs, NULL,0);
 276     tfcs->process->state->s = LTTV_STATE_RUN;
 277     tfcs->process->last_cpu = tfcs->cpu_name;
 278     tfcs->process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfcs)->tf);
 279   }
 280 #endif //0
 281 }
 282
 283 //static LttTime time_zero = {0,0};
 284
 285 static gint compare_usertraces(gconstpointer a, gconstpointer b,
 286     gpointer user_data)
 287 {
 288   const LttTime *t1 = (const LttTime *)a;
 289   const LttTime *t2 = (const LttTime *)b;
 290
 291   return ltt_time_compare(*t1, *t2);
 292 }
 293
 294 static void free_usertrace_key(gpointer data)
 295 {
 296   g_free(data);
 297 }
 298
 299 #define MAX_STRING_LEN 4096
 300
 301 static void
 302 state_load_saved_states(LttvTraceState *tcs)
 303 {
 304   FILE *fp;
 305   GPtrArray *quarktable;
 306   char *trace_path;
 307   char path[PATH_MAX];
 308   guint count;
 309   guint i;
 310   tcs->has_precomputed_states = FALSE;
 311   GQuark q;
 312   gchar *string;
 313   gint hdr;
 314   gchar buf[MAX_STRING_LEN];
 315   guint len;
 316
 317   trace_path = g_quark_to_string(ltt_trace_name(tcs->parent.t));
 318   strncpy(path, trace_path, PATH_MAX-1);
 319   count = strnlen(trace_path, PATH_MAX-1);
 320   // quarktable : open, test
 321   strncat(path, "/precomputed/quarktable", PATH_MAX-count-1);
 322   fp = fopen(path, "r");
 323   if(!fp) return;
 324   quarktable = g_ptr_array_sized_new(4096);
 325
 326   /* Index 0 is null */
 327   hdr = fgetc(fp);
 328   if(hdr == EOF) return;
 329   g_assert(hdr == HDR_QUARKS);
 330   q = 1;
 331   do {
 332     hdr = fgetc(fp);
 333     if(hdr == EOF) break;
 334     g_assert(hdr == HDR_QUARK);
 335     g_ptr_array_set_size(quarktable, q+1);
 336     i=0;
 337     while(1) {
 338       fread(&buf[i], sizeof(gchar), 1, fp);
 339       if(buf[i] == '\0' || feof(fp)) break;
 340       i++;
 341     }
 342     len = strnlen(buf, MAX_STRING_LEN-1);
 343     g_ptr_array_index (quarktable, q) = g_new(gchar, len+1);
 344     strncpy(g_ptr_array_index (quarktable, q), buf, len+1);
 345     q++;
 346   } while(1);
 347
 348   fclose(fp);
 349
 350   // saved_states : open, test
 351   strncpy(path, trace_path, PATH_MAX-1);
 352   count = strnlen(trace_path, PATH_MAX-1);
 353   strncat(path, "/precomputed/states", PATH_MAX-count-1);
 354   fp = fopen(path, "r");
 355   if(!fp) return;
 356
 357   hdr = fgetc(fp);
 358   if(hdr != HDR_TRACE) goto end;
 359
 360   lttv_trace_states_read_raw(tcs, fp, quarktable);
 361
 362   tcs->has_precomputed_states = TRUE;
 363
 364 end:
 365   fclose(fp);
 366
 367   /* Free the quarktable */
 368   for(i=0; i<quarktable->len; i++) {
 369     string = g_ptr_array_index (quarktable, i);
 370     g_free(string);
 371   }
 372   g_ptr_array_free(quarktable, TRUE);
 373   return;
 374 }
 375
 376 static void
 377 init(LttvTracesetState *self, LttvTraceset *ts)
 378 {
 379   guint i, j, nb_trace, nb_tracefile;
 380
 381   LttvTraceContext *tc;
 382
 383   LttvTraceState *tcs;
 384
 385   LttvTracefileState *tfcs;
 386
 387   LttvAttributeValue v;
 388
 389   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
 390       init((LttvTracesetContext *)self, ts);
 391
 392   nb_trace = lttv_traceset_number(ts);
 393   for(i = 0 ; i < nb_trace ; i++) {
 394     tc = self->parent.traces[i];
 395     tcs = LTTV_TRACE_STATE(tc);
 396     tcs->save_interval = LTTV_STATE_SAVE_INTERVAL;
 397     lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
 398         LTTV_UINT, &v);
 399     (*v.v_uint)++;
 400
 401     if(*(v.v_uint) == 1) {
 402       create_name_tables(tcs);
 403       create_max_time(tcs);
 404     }
 405     get_name_tables(tcs);
 406     get_max_time(tcs);
 407
 408     nb_tracefile = tc->tracefiles->len;
 409     tcs->processes = NULL;
 410     tcs->usertraces = NULL;
 411     tcs->running_process = g_new(LttvProcessState*,
 412                                  ltt_trace_get_num_cpu(tc->t));
 413     restore_init_state(tcs);
 414     for(j = 0 ; j < nb_tracefile ; j++) {
 415       tfcs =
 416           LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles,
 417                                           LttvTracefileContext*, j));
 418       tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf);
 419       tfcs->cpu = ltt_tracefile_cpu(tfcs->parent.tf);
 420       if(ltt_tracefile_tid(tfcs->parent.tf) != 0) {
 421         /* It's a Usertrace */
 422         guint tid = ltt_tracefile_tid(tfcs->parent.tf);
 423         GTree *usertrace_tree = (GTree*)g_hash_table_lookup(tcs->usertraces,
 424             (gconstpointer)tid);
 425         if(!usertrace_tree) {
 426           usertrace_tree = g_tree_new_full(compare_usertraces,
 427               NULL, free_usertrace_key, NULL);
 428           g_hash_table_insert(tcs->usertraces,
 429               (gpointer)tid, usertrace_tree);
 430         }
 431         LttTime *timestamp = g_new(LttTime, 1);
 432         *timestamp = ltt_interpolate_time_from_tsc(tfcs->parent.tf,
 433               ltt_tracefile_creation(tfcs->parent.tf));
 434         g_tree_insert(usertrace_tree, timestamp, tfcs);
 435       }
 436     }
 437
 438     /* See if the trace has saved states */
 439     state_load_saved_states(tcs);
 440   }
 441 }
 442
 443 static void
 444 fini(LttvTracesetState *self)
 445 {
 446   guint i, nb_trace;
 447
 448   LttvTraceState *tcs;
 449
 450   LttvTracefileState *tfcs;
 451
 452   LttvAttributeValue v;
 453
 454   nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
 455   for(i = 0 ; i < nb_trace ; i++) {
 456     tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
 457     lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
 458         LTTV_UINT, &v);
 459
 460     g_assert(*(v.v_uint) != 0);
 461     (*v.v_uint)--;
 462
 463     if(*(v.v_uint) == 0) {
 464       free_name_tables(tcs);
 465       free_max_time(tcs);
 466       free_saved_state(tcs);
 467     }
 468     g_free(tcs->running_process);
 469     tcs->running_process = NULL;
 470     lttv_state_free_process_table(tcs->processes);
 471     lttv_state_free_usertraces(tcs->usertraces);
 472     tcs->processes = NULL;
 473     tcs->usertraces = NULL;
 474   }
 475   LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
 476       fini((LttvTracesetContext *)self);
 477 }
 478
 479
 480 static LttvTracesetContext *
 481 new_traceset_context(LttvTracesetContext *self)
 482 {
 483   return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
 484 }
 485
 486
 487 static LttvTraceContext *
 488 new_trace_context(LttvTracesetContext *self)
 489 {
 490   return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
 491 }
 492
 493
 494 static LttvTracefileContext *
 495 new_tracefile_context(LttvTracesetContext *self)
 496 {
 497   return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
 498 }
 499
 500
 501 /* Write the process state of the trace */
 502
 503 static void write_process_state(gpointer key, gpointer value,
 504     gpointer user_data)
 505 {
 506   LttvProcessState *process;
 507
 508   LttvExecutionState *es;
 509
 510   FILE *fp = (FILE *)user_data;
 511
 512   guint i;
 513   guint64 address;
 514
 515   process = (LttvProcessState *)value;
 516   fprintf(fp,
 517 "  <PROCESS CORE=%p PID=%u TGID=%u PPID=%u TYPE=\"%s\" CTIME_S=%lu CTIME_NS=%lu ITIME_S=%lu ITIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\">\n",
 518       process, process->pid, process->tgid, process->ppid,
 519       g_quark_to_string(process->type),
 520       process->creation_time.tv_sec,
 521       process->creation_time.tv_nsec,
 522       process->insertion_time.tv_sec,
 523       process->insertion_time.tv_nsec,
 524       g_quark_to_string(process->name),
 525       g_quark_to_string(process->brand),
 526       process->cpu);
 527
 528   for(i = 0 ; i < process->execution_stack->len; i++) {
 529     es = &g_array_index(process->execution_stack, LttvExecutionState, i);
 530     fprintf(fp, "    <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
 531       g_quark_to_string(es->t), g_quark_to_string(es->n),
 532             es->entry.tv_sec, es->entry.tv_nsec);
 533     fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
 534             es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
 535   }
 536
 537   for(i = 0 ; i < process->user_stack->len; i++) {
 538     address = &g_array_index(process->user_stack, guint64, i);
 539     fprintf(fp, "    <USER_STACK ADDRESS=\"%llu\"/>\n",
 540             address);
 541   }
 542
 543   if(process->usertrace) {
 544     fprintf(fp, "    <USERTRACE NAME=\"%s\" CPU=%u\n/>",
 545             g_quark_to_string(process->usertrace->tracefile_name),
 546             process->usertrace->cpu);
 547   }
 548
 549
 550   fprintf(fp, "  </PROCESS>\n");
 551 }
 552
 553
 554 void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp)
 555 {
 556   guint i, nb_tracefile, nb_block, offset;
 557   guint64 tsc;
 558
 559   LttvTracefileState *tfcs;
 560
 561   LttTracefile *tf;
 562
 563   LttEventPosition *ep;
 564
 565   guint nb_cpus;
 566
 567   ep = ltt_event_position_new();
 568
 569   fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
 570
 571   g_hash_table_foreach(self->processes, write_process_state, fp);
 572
 573   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
 574   for(i=0;i<nb_cpus;i++) {
 575     fprintf(fp,"  <CPU NUM=%u RUNNING_PROCESS=%u>\n",
 576         i, self->running_process[i]->pid);
 577   }
 578
 579   nb_tracefile = self->parent.tracefiles->len;
 580
 581   for(i = 0 ; i < nb_tracefile ; i++) {
 582     tfcs =
 583           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 584                                           LttvTracefileContext*, i));
 585     fprintf(fp, "  <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
 586         tfcs->parent.timestamp.tv_sec,
 587         tfcs->parent.timestamp.tv_nsec);
 588     LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
 589     if(e == NULL) fprintf(fp,"/>\n");
 590     else {
 591       ltt_event_position(e, ep);
 592       ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
 593       fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
 594           tsc);
 595     }
 596   }
 597   g_free(ep);
 598   fprintf(fp,"</PROCESS_STATE>\n");
 599 }
 600
 601
 602 static void write_process_state_raw(gpointer key, gpointer value,
 603     gpointer user_data)
 604 {
 605   LttvProcessState *process;
 606
 607   LttvExecutionState *es;
 608
 609   FILE *fp = (FILE *)user_data;
 610
 611   guint i;
 612   guint64 address;
 613
 614   process = (LttvProcessState *)value;
 615   fputc(HDR_PROCESS, fp);
 616   //fwrite(&header, sizeof(header), 1, fp);
 617   //fprintf(fp, "%s", g_quark_to_string(process->type));
 618   //fputc('\0', fp);
 619   fwrite(&process->type, sizeof(process->type), 1, fp);
 620   //fprintf(fp, "%s", g_quark_to_string(process->name));
 621   //fputc('\0', fp);
 622   fwrite(&process->name, sizeof(process->name), 1, fp);
 623   //fprintf(fp, "%s", g_quark_to_string(process->brand));
 624   //fputc('\0', fp);
 625   fwrite(&process->brand, sizeof(process->brand), 1, fp);
 626   fwrite(&process->pid, sizeof(process->pid), 1, fp);
 627   fwrite(&process->tgid, sizeof(process->tgid), 1, fp);
 628   fwrite(&process->ppid, sizeof(process->ppid), 1, fp);
 629   fwrite(&process->cpu, sizeof(process->cpu), 1, fp);
 630   fwrite(&process->creation_time, sizeof(process->creation_time), 1, fp);
 631   fwrite(&process->insertion_time, sizeof(process->insertion_time), 1, fp);
 632
 633 #if 0
 634   fprintf(fp,
 635 "  <PROCESS CORE=%p PID=%u TGID=%u PPID=%u TYPE=\"%s\" CTIME_S=%lu CTIME_NS=%lu ITIME_S=%lu ITIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\" PROCESS_TYPE=%u>\n",
 636       process, process->pid, process->tgid, process->ppid,
 637       g_quark_to_string(process->type),
 638       process->creation_time.tv_sec,
 639       process->creation_time.tv_nsec,
 640       process->insertion_time.tv_sec,
 641       process->insertion_time.tv_nsec,
 642       g_quark_to_string(process->name),
 643       g_quark_to_string(process->brand),
 644       process->cpu);
 645 #endif //0
 646
 647   for(i = 0 ; i < process->execution_stack->len; i++) {
 648     es = &g_array_index(process->execution_stack, LttvExecutionState, i);
 649
 650     fputc(HDR_ES, fp);
 651     //fprintf(fp, "%s", g_quark_to_string(es->t));
 652     //fputc('\0', fp);
 653     fwrite(&es->t, sizeof(es->t), 1, fp);
 654     //fprintf(fp, "%s", g_quark_to_string(es->n));
 655     //fputc('\0', fp);
 656     fwrite(&es->n, sizeof(es->n), 1, fp);
 657     //fprintf(fp, "%s", g_quark_to_string(es->s));
 658     //fputc('\0', fp);
 659     fwrite(&es->s, sizeof(es->s), 1, fp);
 660     fwrite(&es->entry, sizeof(es->entry), 1, fp);
 661     fwrite(&es->change, sizeof(es->change), 1, fp);
 662     fwrite(&es->cum_cpu_time, sizeof(es->cum_cpu_time), 1, fp);
 663 #if 0
 664     fprintf(fp, "    <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
 665       g_quark_to_string(es->t), g_quark_to_string(es->n),
 666             es->entry.tv_sec, es->entry.tv_nsec);
 667     fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
 668             es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
 669 #endif //0
 670   }
 671
 672   for(i = 0 ; i < process->user_stack->len; i++) {
 673     address = &g_array_index(process->user_stack, guint64, i);
 674     fputc(HDR_USER_STACK, fp);
 675     fwrite(&address, sizeof(address), 1, fp);
 676 #if 0
 677     fprintf(fp, "    <USER_STACK ADDRESS=\"%llu\"/>\n",
 678             address);
 679 #endif //0
 680   }
 681
 682   if(process->usertrace) {
 683     fputc(HDR_USERTRACE, fp);
 684     //fprintf(fp, "%s", g_quark_to_string(process->usertrace->tracefile_name));
 685     //fputc('\0', fp);
 686     fwrite(&process->usertrace->tracefile_name,
 687                     sizeof(process->usertrace->tracefile_name), 1, fp);
 688     fwrite(&process->usertrace->cpu, sizeof(process->usertrace->cpu), 1, fp);
 689 #if 0
 690     fprintf(fp, "    <USERTRACE NAME=\"%s\" CPU=%u\n/>",
 691             g_quark_to_string(process->usertrace->tracefile_name),
 692             process->usertrace->cpu);
 693 #endif //0
 694   }
 695
 696 }
 697
 698
 699 void lttv_state_write_raw(LttvTraceState *self, LttTime t, FILE *fp)
 700 {
 701   guint i, nb_tracefile, nb_block, offset;
 702   guint64 tsc;
 703
 704   LttvTracefileState *tfcs;
 705
 706   LttTracefile *tf;
 707
 708   LttEventPosition *ep;
 709
 710   guint nb_cpus;
 711
 712   ep = ltt_event_position_new();
 713
 714   //fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
 715   fputc(HDR_PROCESS_STATE, fp);
 716   fwrite(&t, sizeof(t), 1, fp);
 717
 718   g_hash_table_foreach(self->processes, write_process_state_raw, fp);
 719
 720   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
 721   for(i=0;i<nb_cpus;i++) {
 722     fputc(HDR_CPU, fp);
 723     fwrite(&i, sizeof(i), 1, fp); /* cpu number */
 724     fwrite(&self->running_process[i]->pid,
 725         sizeof(self->running_process[i]->pid), 1, fp);
 726     //fprintf(fp,"  <CPU NUM=%u RUNNING_PROCESS=%u>\n",
 727     //    i, self->running_process[i]->pid);
 728   }
 729
 730   nb_tracefile = self->parent.tracefiles->len;
 731
 732   for(i = 0 ; i < nb_tracefile ; i++) {
 733     tfcs =
 734           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 735                                           LttvTracefileContext*, i));
 736   //  fprintf(fp, "  <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
 737   //      tfcs->parent.timestamp.tv_sec,
 738   //      tfcs->parent.timestamp.tv_nsec);
 739     fputc(HDR_TRACEFILE, fp);
 740     fwrite(&tfcs->parent.timestamp, sizeof(tfcs->parent.timestamp), 1, fp);
 741     /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
 742      * position following : end of trace */
 743     LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
 744     if(e != NULL) {
 745       ltt_event_position(e, ep);
 746       ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
 747       //fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
 748       //    tsc);
 749       fwrite(&nb_block, sizeof(nb_block), 1, fp);
 750       fwrite(&offset, sizeof(offset), 1, fp);
 751       fwrite(&tsc, sizeof(tsc), 1, fp);
 752     }
 753   }
 754   g_free(ep);
 755 }
 756
 757
 758 /* Read process state from a file */
 759
 760 /* Called because a HDR_PROCESS was found */
 761 static void read_process_state_raw(LttvTraceState *self, FILE *fp,
 762                        GPtrArray *quarktable)
 763 {
 764   LttvExecutionState *es;
 765   LttvProcessState *process, *parent_process;
 766   LttvProcessState tmp;
 767   GQuark tmpq;
 768
 769   guint i;
 770   guint64 *address;
 771   guint cpu;
 772
 773   /* TODO : check return value */
 774   fread(&tmp.type, sizeof(tmp.type), 1, fp);
 775   fread(&tmp.name, sizeof(tmp.name), 1, fp);
 776   fread(&tmp.brand, sizeof(tmp.brand), 1, fp);
 777   fread(&tmp.pid, sizeof(tmp.pid), 1, fp);
 778   fread(&tmp.tgid, sizeof(tmp.tgid), 1, fp);
 779   fread(&tmp.ppid, sizeof(tmp.ppid), 1, fp);
 780   fread(&tmp.cpu, sizeof(tmp.cpu), 1, fp);
 781   fread(&tmp.creation_time, sizeof(tmp.creation_time), 1, fp);
 782   fread(&tmp.insertion_time, sizeof(tmp.insertion_time), 1, fp);
 783
 784   if(tmp.pid == 0) {
 785     process = lttv_state_find_process(self, tmp.cpu, tmp.pid);
 786   } else {
 787     /* We must link to the parent */
 788     parent_process = lttv_state_find_process_or_create(self, ANY_CPU, tmp.ppid,
 789         &ltt_time_zero);
 790     process = lttv_state_find_process(self, ANY_CPU, tmp.pid);
 791     if(process == NULL) {
 792       process = lttv_state_create_process(self, parent_process, tmp.cpu,
 793       tmp.pid, tmp.tgid,
 794       g_quark_from_string((gchar*)g_ptr_array_index(quarktable, tmp.name)),
 795           &tmp.creation_time);
 796     }
 797   }
 798   process->insertion_time = tmp.insertion_time;
 799   process->creation_time = tmp.creation_time;
 800   process->type = g_quark_from_string(
 801     (gchar*)g_ptr_array_index(quarktable, tmp.type));
 802   process->tgid = tmp.tgid;
 803   process->ppid = tmp.ppid;
 804   process->brand = g_quark_from_string(
 805     (gchar*)g_ptr_array_index(quarktable, tmp.brand));
 806   process->name =
 807     g_quark_from_string((gchar*)g_ptr_array_index(quarktable, tmp.name));
 808
 809
 810   do {
 811     if(feof(fp) || ferror(fp)) goto end_loop;
 812
 813     gint hdr = fgetc(fp);
 814     if(hdr == EOF) goto end_loop;
 815
 816     switch(hdr) {
 817       case HDR_ES:
 818         process->execution_stack =
 819           g_array_set_size(process->execution_stack,
 820                            process->execution_stack->len + 1);
 821         es = &g_array_index(process->execution_stack, LttvExecutionState,
 822                 process->execution_stack->len-1);
 823         process->state = es;
 824
 825         fread(&es->t, sizeof(es->t), 1, fp);
 826         es->t = g_quark_from_string(
 827            (gchar*)g_ptr_array_index(quarktable, es->t));
 828         fread(&es->n, sizeof(es->n), 1, fp);
 829         es->n = g_quark_from_string(
 830            (gchar*)g_ptr_array_index(quarktable, es->n));
 831         fread(&es->s, sizeof(es->s), 1, fp);
 832         es->s = g_quark_from_string(
 833            (gchar*)g_ptr_array_index(quarktable, es->s));
 834         fread(&es->entry, sizeof(es->entry), 1, fp);
 835         fread(&es->change, sizeof(es->change), 1, fp);
 836         fread(&es->cum_cpu_time, sizeof(es->cum_cpu_time), 1, fp);
 837         break;
 838       case HDR_USER_STACK:
 839         process->user_stack = g_array_set_size(process->user_stack,
 840                               process->user_stack->len + 1);
 841         address = &g_array_index(process->user_stack, guint64,
 842                                  process->user_stack->len-1);
 843         fread(address, sizeof(address), 1, fp);
 844         process->current_function = *address;
 845         break;
 846       case HDR_USERTRACE:
 847         fread(&tmpq, sizeof(tmpq), 1, fp);
 848         fread(&process->usertrace->cpu, sizeof(process->usertrace->cpu), 1, fp);
 849         break;
 850       default:
 851         ungetc(hdr, fp);
 852         goto end_loop;
 853     };
 854   } while(1);
 855 end_loop:
 856   return;
 857 }
 858
 859
 860 /* Called because a HDR_PROCESS_STATE was found */
 861 /* Append a saved state to the trace states */
 862 void lttv_state_read_raw(LttvTraceState *self, FILE *fp, GPtrArray *quarktable)
 863 {
 864   guint i, nb_tracefile, nb_block, offset;
 865   guint64 tsc;
 866   LttvTracefileState *tfcs;
 867
 868   LttEventPosition *ep;
 869
 870   guint nb_cpus;
 871
 872   int hdr;
 873
 874   LttTime t;
 875
 876   LttvAttribute *saved_states_tree, *saved_state_tree;
 877
 878   LttvAttributeValue value;
 879   GTree *pqueue = self->parent.ts_context->pqueue;
 880   ep = ltt_event_position_new();
 881
 882   restore_init_state(self);
 883
 884   fread(&t, sizeof(t), 1, fp);
 885
 886   do {
 887     if(feof(fp) || ferror(fp)) goto end_loop;
 888     hdr = fgetc(fp);
 889     if(hdr == EOF) goto end_loop;
 890
 891     switch(hdr) {
 892       case HDR_PROCESS:
 893         /* Call read_process_state_raw */
 894         read_process_state_raw(self, fp, quarktable);
 895         break;
 896       case HDR_TRACEFILE:
 897       case HDR_TRACESET:
 898       case HDR_TRACE:
 899       case HDR_QUARKS:
 900       case HDR_QUARK:
 901       case HDR_ES:
 902       case HDR_USER_STACK:
 903       case HDR_USERTRACE:
 904       case HDR_PROCESS_STATE:
 905       case HDR_CPU:
 906         ungetc(hdr, fp);
 907         goto end_loop;
 908         break;
 909       default:
 910         g_error("Error while parsing saved state file : unknown data header %d",
 911             hdr);
 912     };
 913   } while(1);
 914 end_loop:
 915
 916   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
 917   for(i=0;i<nb_cpus;i++) {
 918     int cpu_num;
 919     hdr = fgetc(fp);
 920     g_assert(hdr == HDR_CPU);
 921     fread(&cpu_num, sizeof(cpu_num), 1, fp); /* cpu number */
 922     g_assert(i == cpu_num);
 923     fread(&self->running_process[i]->pid,
 924         sizeof(self->running_process[i]->pid), 1, fp);
 925   }
 926
 927   nb_tracefile = self->parent.tracefiles->len;
 928
 929   for(i = 0 ; i < nb_tracefile ; i++) {
 930     tfcs =
 931           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
 932                                           LttvTracefileContext*, i));
 933   //  fprintf(fp, "  <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
 934   //      tfcs->parent.timestamp.tv_sec,
 935   //      tfcs->parent.timestamp.tv_nsec);
 936     g_tree_remove(pqueue, &tfcs->parent);
 937     hdr = fgetc(fp);
 938     g_assert(hdr == HDR_TRACEFILE);
 939     fread(&tfcs->parent.timestamp, sizeof(tfcs->parent.timestamp), 1, fp);
 940     /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
 941      * position following : end of trace */
 942     if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) != 0) {
 943       fread(&nb_block, sizeof(nb_block), 1, fp);
 944       fread(&offset, sizeof(offset), 1, fp);
 945       fread(&tsc, sizeof(tsc), 1, fp);
 946       ltt_event_position_set(ep, tfcs->parent.tf, nb_block, offset, tsc);
 947       gint ret = ltt_tracefile_seek_position(tfcs->parent.tf, ep);
 948       g_assert(ret == 0);
 949       g_tree_insert(pqueue, &tfcs->parent, &tfcs->parent);
 950     }
 951   }
 952   g_free(ep);
 953
 954   saved_states_tree = lttv_attribute_find_subdir(self->parent.t_a,
 955       LTTV_STATE_SAVED_STATES);
 956   saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
 957   value = lttv_attribute_add(saved_states_tree,
 958       lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
 959   *(value.v_gobject) = (GObject *)saved_state_tree;
 960   value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
 961   *(value.v_time) = t;
 962   lttv_state_save(self, saved_state_tree);
 963   g_debug("Saving state at time %lu.%lu", t.tv_sec,
 964     t.tv_nsec);
 965
 966   *(self->max_time_state_recomputed_in_seek) = t;
 967
 968 }
 969
 970 /* Called when a HDR_TRACE is found */
 971 void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp,
 972                        GPtrArray *quarktable)
 973 {
 974   int hdr;
 975
 976   do {
 977     if(feof(fp) || ferror(fp)) goto end_loop;
 978     hdr = fgetc(fp);
 979     if(hdr == EOF) goto end_loop;
 980
 981     switch(hdr) {
 982       case HDR_PROCESS_STATE:
 983         /* Call read_process_state_raw */
 984         lttv_state_read_raw(tcs, fp, quarktable);
 985         break;
 986       case HDR_TRACEFILE:
 987       case HDR_TRACESET:
 988       case HDR_TRACE:
 989       case HDR_QUARKS:
 990       case HDR_QUARK:
 991       case HDR_ES:
 992       case HDR_USER_STACK:
 993       case HDR_USERTRACE:
 994       case HDR_PROCESS:
 995       case HDR_CPU:
 996         g_error("Error while parsing saved state file :"
 997             " unexpected data header %d",
 998             hdr);
 999         break;
1000       default:
1001         g_error("Error while parsing saved state file : unknown data header %d",
1002             hdr);
1003     };
1004   } while(1);
1005 end_loop:
1006   *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time;
1007   restore_init_state(tcs);
1008   lttv_process_trace_seek_time(tcs, ltt_time_zero);
1009   return;
1010 }
1011
1012
1013
1014 /* Copy each process from an existing hash table to a new one */
1015
1016 static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
1017 {
1018   LttvProcessState *process, *new_process;
1019
1020   GHashTable *new_processes = (GHashTable *)user_data;
1021
1022   guint i;
1023
1024   process = (LttvProcessState *)value;
1025   new_process = g_new(LttvProcessState, 1);
1026   *new_process = *process;
1027   new_process->execution_stack = g_array_sized_new(FALSE, FALSE,
1028       sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
1029   new_process->execution_stack =
1030               g_array_set_size(new_process->execution_stack,
1031                   process->execution_stack->len);
1032   for(i = 0 ; i < process->execution_stack->len; i++) {
1033     g_array_index(new_process->execution_stack, LttvExecutionState, i) =
1034         g_array_index(process->execution_stack, LttvExecutionState, i);
1035   }
1036   new_process->state = &g_array_index(new_process->execution_stack,
1037       LttvExecutionState, new_process->execution_stack->len - 1);
1038   new_process->user_stack = g_array_sized_new(FALSE, FALSE,
1039       sizeof(guint64), 0);
1040   new_process->user_stack =
1041               g_array_set_size(new_process->user_stack,
1042                   process->user_stack->len);
1043   for(i = 0 ; i < process->user_stack->len; i++) {
1044     g_array_index(new_process->user_stack, guint64, i) =
1045         g_array_index(process->user_stack, guint64, i);
1046   }
1047   new_process->current_function = process->current_function;
1048   g_hash_table_insert(new_processes, new_process, new_process);
1049 }
1050
1051
1052 static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
1053 {
1054   GHashTable *new_processes = g_hash_table_new(process_hash, process_equal);
1055
1056   g_hash_table_foreach(processes, copy_process_state, new_processes);
1057   return new_processes;
1058 }
1059
1060
1061 /* The saved state for each trace contains a member "processes", which
1062    stores a copy of the process table, and a member "tracefiles" with
1063    one entry per tracefile. Each tracefile has a "process" member pointing
1064    to the current process and a "position" member storing the tracefile
1065    position (needed to seek to the current "next" event. */
1066
1067 static void state_save(LttvTraceState *self, LttvAttribute *container)
1068 {
1069   guint i, nb_tracefile, nb_cpus;
1070
1071   LttvTracefileState *tfcs;
1072
1073   LttvAttribute *tracefiles_tree, *tracefile_tree;
1074
1075   guint *running_process;
1076
1077   LttvAttributeType type;
1078
1079   LttvAttributeValue value;
1080
1081   LttvAttributeName name;
1082
1083   LttEventPosition *ep;
1084
1085   tracefiles_tree = lttv_attribute_find_subdir(container,
1086       LTTV_STATE_TRACEFILES);
1087
1088   value = lttv_attribute_add(container, LTTV_STATE_PROCESSES,
1089       LTTV_POINTER);
1090   *(value.v_pointer) = lttv_state_copy_process_table(self->processes);
1091
1092   /* Add the currently running processes array */
1093   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
1094   running_process = g_new(guint, nb_cpus);
1095   for(i=0;i<nb_cpus;i++) {
1096     running_process[i] = self->running_process[i]->pid;
1097   }
1098   value = lttv_attribute_add(container, LTTV_STATE_RUNNING_PROCESS,
1099                              LTTV_POINTER);
1100   *(value.v_pointer) = running_process;
1101
1102   g_info("State save");
1103
1104   nb_tracefile = self->parent.tracefiles->len;
1105
1106   for(i = 0 ; i < nb_tracefile ; i++) {
1107     tfcs =
1108           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
1109                                           LttvTracefileContext*, i));
1110     tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1111     value = lttv_attribute_add(tracefiles_tree, i,
1112         LTTV_GOBJECT);
1113     *(value.v_gobject) = (GObject *)tracefile_tree;
1114 #if 0
1115     value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
1116         LTTV_UINT);
1117     *(value.v_uint) = tfcs->process->pid;
1118 #endif //0
1119     value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
1120         LTTV_POINTER);
1121     /* Only save the position if the tfs has not infinite time. */
1122     //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
1123     //    && current_tfcs != tfcs) {
1124     if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) == 0) {
1125       *(value.v_pointer) = NULL;
1126     } else {
1127       LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
1128       ep = ltt_event_position_new();
1129       ltt_event_position(e, ep);
1130       *(value.v_pointer) = ep;
1131
1132       guint nb_block, offset;
1133       guint64 tsc;
1134       LttTracefile *tf;
1135       ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
1136       g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block, offset,
1137           tsc,
1138           tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
1139     }
1140   }
1141 }
1142
1143
1144 static void state_restore(LttvTraceState *self, LttvAttribute *container)
1145 {
1146   guint i, nb_tracefile, pid, nb_cpus;
1147
1148   LttvTracefileState *tfcs;
1149
1150   LttvAttribute *tracefiles_tree, *tracefile_tree;
1151
1152   guint *running_process;
1153
1154   LttvAttributeType type;
1155
1156   LttvAttributeValue value;
1157
1158   LttvAttributeName name;
1159
1160   gboolean is_named;
1161
1162   LttEventPosition *ep;
1163
1164   LttvTracesetContext *tsc = self->parent.ts_context;
1165
1166   tracefiles_tree = lttv_attribute_find_subdir(container,
1167       LTTV_STATE_TRACEFILES);
1168
1169   type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
1170       &value);
1171   g_assert(type == LTTV_POINTER);
1172   lttv_state_free_process_table(self->processes);
1173   self->processes = lttv_state_copy_process_table(*(value.v_pointer));
1174
1175   /* Add the currently running processes array */
1176   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
1177   type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
1178         &value);
1179   g_assert(type == LTTV_POINTER);
1180   running_process = *(value.v_pointer);
1181   for(i=0;i<nb_cpus;i++) {
1182     pid = running_process[i];
1183     self->running_process[i] = lttv_state_find_process(self, i, pid);
1184     g_assert(self->running_process[i] != NULL);
1185   }
1186
1187
1188   nb_tracefile = self->parent.tracefiles->len;
1189
1190   //g_tree_destroy(tsc->pqueue);
1191   //tsc->pqueue = g_tree_new(compare_tracefile);
1192
1193   for(i = 0 ; i < nb_tracefile ; i++) {
1194     tfcs =
1195           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
1196                                           LttvTracefileContext*, i));
1197     type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named);
1198     g_assert(type == LTTV_GOBJECT);
1199     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
1200 #if 0
1201     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_PROCESS,
1202         &value);
1203     g_assert(type == LTTV_UINT);
1204     pid = *(value.v_uint);
1205     tfcs->process = lttv_state_find_process_or_create(tfcs, pid);
1206 #endif //0
1207     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
1208         &value);
1209     g_assert(type == LTTV_POINTER);
1210     //g_assert(*(value.v_pointer) != NULL);
1211     ep = *(value.v_pointer);
1212     g_assert(tfcs->parent.t_context != NULL);
1213
1214     LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs);
1215     g_tree_remove(tsc->pqueue, tfc);
1216
1217     if(ep != NULL) {
1218       g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
1219       tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
1220       g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
1221       g_tree_insert(tsc->pqueue, tfc, tfc);
1222       g_info("Restoring state for a tf at time %lu.%lu", tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
1223     } else {
1224       tfc->timestamp = ltt_time_infinite;
1225     }
1226   }
1227 }
1228
1229
1230 static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
1231 {
1232   guint i, nb_tracefile, nb_cpus;
1233
1234   LttvTracefileState *tfcs;
1235
1236   LttvAttribute *tracefiles_tree, *tracefile_tree;
1237
1238   guint *running_process;
1239
1240   LttvAttributeType type;
1241
1242   LttvAttributeValue value;
1243
1244   LttvAttributeName name;
1245
1246   gboolean is_named;
1247
1248   LttEventPosition *ep;
1249
1250   tracefiles_tree = lttv_attribute_find_subdir(container,
1251       LTTV_STATE_TRACEFILES);
1252   g_object_ref(G_OBJECT(tracefiles_tree));
1253   lttv_attribute_remove_by_name(container, LTTV_STATE_TRACEFILES);
1254
1255   type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
1256       &value);
1257   g_assert(type == LTTV_POINTER);
1258   lttv_state_free_process_table(*(value.v_pointer));
1259   *(value.v_pointer) = NULL;
1260   lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES);
1261
1262   /* Free running processes array */
1263   nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
1264   type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
1265         &value);
1266   g_assert(type == LTTV_POINTER);
1267   running_process = *(value.v_pointer);
1268   g_free(running_process);
1269
1270   nb_tracefile = self->parent.tracefiles->len;
1271
1272   for(i = 0 ; i < nb_tracefile ; i++) {
1273     tfcs =
1274           LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
1275                                           LttvTracefileContext*, i));
1276     type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named);
1277     g_assert(type == LTTV_GOBJECT);
1278     tracefile_tree = *((LttvAttribute **)(value.v_gobject));
1279
1280     type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
1281         &value);
1282     g_assert(type == LTTV_POINTER);
1283     if(*(value.v_pointer) != NULL) g_free(*(value.v_pointer));
1284   }
1285   g_object_unref(G_OBJECT(tracefiles_tree));
1286 }
1287
1288
1289 static void free_saved_state(LttvTraceState *self)
1290 {
1291   guint i, nb;
1292
1293   LttvAttributeType type;
1294
1295   LttvAttributeValue value;
1296
1297   LttvAttributeName name;
1298
1299   gboolean is_named;
1300
1301   LttvAttribute *saved_states;
1302
1303   saved_states = lttv_attribute_find_subdir(self->parent.t_a,
1304       LTTV_STATE_SAVED_STATES);
1305
1306   nb = lttv_attribute_get_number(saved_states);
1307   for(i = 0 ; i < nb ; i++) {
1308     type = lttv_attribute_get(saved_states, i, &name, &value, &is_named);
1309     g_assert(type == LTTV_GOBJECT);
1310     state_saved_free(self, *((LttvAttribute **)value.v_gobject));
1311   }
1312
1313   lttv_attribute_remove_by_name(self->parent.t_a, LTTV_STATE_SAVED_STATES);
1314 }
1315
1316
1317 static void
1318 create_max_time(LttvTraceState *tcs)
1319 {
1320   LttvAttributeValue v;
1321
1322   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
1323         LTTV_POINTER, &v);
1324   g_assert(*(v.v_pointer) == NULL);
1325   *(v.v_pointer) = g_new(LttTime,1);
1326   *((LttTime *)*(v.v_pointer)) = ltt_time_zero;
1327 }
1328
1329
1330 static void
1331 get_max_time(LttvTraceState *tcs)
1332 {
1333   LttvAttributeValue v;
1334
1335   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
1336         LTTV_POINTER, &v);
1337   g_assert(*(v.v_pointer) != NULL);
1338   tcs->max_time_state_recomputed_in_seek = (LttTime *)*(v.v_pointer);
1339 }
1340
1341
1342 static void
1343 free_max_time(LttvTraceState *tcs)
1344 {
1345   LttvAttributeValue v;
1346
1347   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
1348         LTTV_POINTER, &v);
1349   g_free(*(v.v_pointer));
1350   *(v.v_pointer) = NULL;
1351 }
1352
1353
1354 typedef struct _LttvNameTables {
1355  // FIXME  GQuark *eventtype_names;
1356   GQuark *syscall_names;
1357   guint nb_syscalls;
1358   GQuark *trap_names;
1359   guint nb_traps;
1360   GQuark *irq_names;
1361   guint nb_irqs;
1362   GQuark *soft_irq_names;
1363   guint nb_softirqs;
1364 } LttvNameTables;
1365
1366
1367 static void
1368 create_name_tables(LttvTraceState *tcs)
1369 {
1370   int i, nb;
1371
1372   GQuark f_name, e_name;
1373
1374   LttvTraceHook h;
1375
1376   LttvTraceHookByFacility *thf;
1377
1378   LttEventType *et;
1379
1380   LttType *t;
1381
1382   GString *fe_name = g_string_new("");
1383
1384   LttvNameTables *name_tables = g_new(LttvNameTables, 1);
1385
1386   LttvAttributeValue v;
1387
1388   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
1389       LTTV_POINTER, &v);
1390   g_assert(*(v.v_pointer) == NULL);
1391   *(v.v_pointer) = name_tables;
1392 #if 0 // Use iteration over the facilities_by_name and then list all event
1393       // types of each facility
1394   nb = ltt_trace_eventtype_number(tcs->parent.t);
1395   name_tables->eventtype_names = g_new(GQuark, nb);
1396   for(i = 0 ; i < nb ; i++) {
1397     et = ltt_trace_eventtype_get(tcs->parent.t, i);
1398     e_name = ltt_eventtype_name(et);
1399     f_name = ltt_facility_name(ltt_eventtype_facility(et));
1400     g_string_printf(fe_name, "%s.%s", f_name, e_name);
1401     name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
1402   }
1403 #endif //0
1404   if(!lttv_trace_find_hook(tcs->parent.t,
1405       LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
1406       LTT_FIELD_SYSCALL_ID, 0, 0,
1407       NULL, NULL, &h)) {
1408
1409     thf = lttv_trace_hook_get_first(&h);
1410
1411     t = ltt_field_type(thf->f1);
1412     nb = ltt_type_element_number(t);
1413
1414     lttv_trace_hook_destroy(&h);
1415
1416     name_tables->syscall_names = g_new(GQuark, nb);
1417     name_tables->nb_syscalls = nb;
1418
1419     for(i = 0 ; i < nb ; i++) {
1420       name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
1421       if(!name_tables->syscall_names[i]) {
1422         GString *string = g_string_new("");
1423         g_string_printf(string, "syscall %u", i);
1424         name_tables->syscall_names[i] = g_quark_from_string(string->str);
1425         g_string_free(string, TRUE);
1426       }
1427     }
1428
1429     //name_tables->syscall_names = g_new(GQuark, 256);
1430     //for(i = 0 ; i < 256 ; i++) {
1431     //  g_string_printf(fe_name, "syscall %d", i);
1432     //  name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
1433     //}
1434   } else {
1435     name_tables->syscall_names = NULL;
1436     name_tables->nb_syscalls = 0;
1437   }
1438
1439   if(!lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
1440         LTT_EVENT_TRAP_ENTRY,
1441         LTT_FIELD_TRAP_ID, 0, 0,
1442         NULL, NULL, &h)) {
1443
1444     thf = lttv_trace_hook_get_first(&h);
1445
1446     t = ltt_field_type(thf->f1);
1447     //nb = ltt_type_element_number(t);
1448
1449     lttv_trace_hook_destroy(&h);
1450
1451     /*
1452     name_tables->trap_names = g_new(GQuark, nb);
1453     for(i = 0 ; i < nb ; i++) {
1454       name_tables->trap_names[i] = g_quark_from_string(
1455           ltt_enum_string_get(t, i));
1456     }
1457     */
1458     name_tables->nb_traps = 256;
1459     name_tables->trap_names = g_new(GQuark, 256);
1460     for(i = 0 ; i < 256 ; i++) {
1461       g_string_printf(fe_name, "trap %d", i);
1462       name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
1463     }
1464   } else {
1465     name_tables->trap_names = NULL;
1466     name_tables->nb_traps = 0;
1467   }
1468
1469   if(!lttv_trace_find_hook(tcs->parent.t,
1470         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
1471         LTT_FIELD_IRQ_ID, 0, 0,
1472         NULL, NULL, &h)) {
1473
1474     thf = lttv_trace_hook_get_first(&h);
1475
1476     t = ltt_field_type(thf->f1);
1477     //nb = ltt_type_element_number(t);
1478
1479     lttv_trace_hook_destroy(&h);
1480
1481     /*
1482     name_tables->irq_names = g_new(GQuark, nb);
1483     for(i = 0 ; i < nb ; i++) {
1484       name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1485     }
1486     */
1487
1488     name_tables->nb_irqs = 256;
1489     name_tables->irq_names = g_new(GQuark, 256);
1490     for(i = 0 ; i < 256 ; i++) {
1491       g_string_printf(fe_name, "irq %d", i);
1492       name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
1493     }
1494   } else {
1495     name_tables->nb_irqs = 0;
1496     name_tables->irq_names = NULL;
1497   }
1498   /*
1499   name_tables->soft_irq_names = g_new(GQuark, nb);
1500   for(i = 0 ; i < nb ; i++) {
1501     name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1502   }
1503   */
1504
1505   name_tables->nb_softirqs = 256;
1506   name_tables->soft_irq_names = g_new(GQuark, 256);
1507   for(i = 0 ; i < 256 ; i++) {
1508     g_string_printf(fe_name, "softirq %d", i);
1509     name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str);
1510   }
1511
1512
1513   g_string_free(fe_name, TRUE);
1514 }
1515
1516
1517 static void
1518 get_name_tables(LttvTraceState *tcs)
1519 {
1520   LttvNameTables *name_tables;
1521
1522   LttvAttributeValue v;
1523
1524   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
1525         LTTV_POINTER, &v);
1526   g_assert(*(v.v_pointer) != NULL);
1527   name_tables = (LttvNameTables *)*(v.v_pointer);
1528   //tcs->eventtype_names = name_tables->eventtype_names;
1529   tcs->syscall_names = name_tables->syscall_names;
1530   tcs->nb_syscalls = name_tables->nb_syscalls;
1531   tcs->trap_names = name_tables->trap_names;
1532   tcs->nb_traps = name_tables->nb_traps;
1533   tcs->irq_names = name_tables->irq_names;
1534   tcs->soft_irq_names = name_tables->soft_irq_names;
1535   tcs->nb_irqs = name_tables->nb_irqs;
1536   tcs->nb_softirqs = name_tables->nb_softirqs;
1537 }
1538
1539
1540 static void
1541 free_name_tables(LttvTraceState *tcs)
1542 {
1543   LttvNameTables *name_tables;
1544
1545   LttvAttributeValue v;
1546
1547   lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
1548         LTTV_POINTER, &v);
1549   name_tables = (LttvNameTables *)*(v.v_pointer);
1550   *(v.v_pointer) = NULL;
1551
1552  // g_free(name_tables->eventtype_names);
1553   if(name_tables->syscall_names) g_free(name_tables->syscall_names);
1554   if(name_tables->trap_names) g_free(name_tables->trap_names);
1555   if(name_tables->irq_names) g_free(name_tables->irq_names);
1556   if(name_tables->soft_irq_names) g_free(name_tables->soft_irq_names);
1557   if(name_tables) g_free(name_tables);
1558 }
1559
1560 #ifdef HASH_TABLE_DEBUG
1561
1562 static void test_process(gpointer key, gpointer value, gpointer user_data)
1563 {
1564   LttvProcessState *process = (LttvProcessState *)value;
1565
1566   /* Test for process corruption */
1567   guint stack_len = process->execution_stack->len;
1568 }
1569
1570 static void hash_table_check(GHashTable *table)
1571 {
1572   g_hash_table_foreach(table, test_process, NULL);
1573 }
1574
1575
1576 #endif
1577
1578
1579 static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
1580     guint state_id)
1581 {
1582   LttvExecutionState *es;
1583
1584   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
1585   guint cpu = tfs->cpu;
1586
1587 #ifdef HASH_TABLE_DEBUG
1588   hash_table_check(ts->processes);
1589 #endif
1590   LttvProcessState *process = ts->running_process[cpu];
1591
1592   guint depth = process->execution_stack->len;
1593
1594   process->execution_stack =
1595     g_array_set_size(process->execution_stack, depth + 1);
1596   /* Keep in sync */
1597   process->state =
1598     &g_array_index(process->execution_stack, LttvExecutionState, depth - 1);
1599
1600   es = &g_array_index(process->execution_stack, LttvExecutionState, depth);
1601   es->t = t;
1602   es->n = state_id;
1603   es->entry = es->change = tfs->parent.timestamp;
1604   es->cum_cpu_time = ltt_time_zero;
1605   es->s = process->state->s;
1606   process->state = es;
1607 }
1608
1609 /* pop state
1610  * return 1 when empty, else 0 */
1611 int lttv_state_pop_state_cleanup(LttvProcessState *process,
1612     LttvTracefileState *tfs)
1613 {
1614   guint cpu = tfs->cpu;
1615   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
1616
1617   guint depth = process->execution_stack->len;
1618
1619   if(depth == 1){
1620     return 1;
1621   }
1622
1623   process->execution_stack =
1624     g_array_set_size(process->execution_stack, depth - 1);
1625   process->state = &g_array_index(process->execution_stack, LttvExecutionState,
1626       depth - 2);
1627   process->state->change = tfs->parent.timestamp;
1628
1629   return 0;
1630 }
1631
1632 static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
1633 {
1634   guint cpu = tfs->cpu;
1635   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
1636   LttvProcessState *process = ts->running_process[cpu];
1637
1638   guint depth = process->execution_stack->len;
1639
1640   if(process->state->t != t){
1641     g_info("Different execution mode type (%lu.%09lu): ignore it\n",
1642         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
1643     g_info("process state has %s when pop_int is %s\n",
1644         g_quark_to_string(process->state->t),
1645         g_quark_to_string(t));
1646     g_info("{ %u, %u, %s, %s, %s }\n",
1647         process->pid,
1648         process->ppid,
1649         g_quark_to_string(process->name),
1650         g_quark_to_string(process->brand),
1651         g_quark_to_string(process->state->s));
1652     return;
1653   }
1654
1655   if(depth == 1){
1656     g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
1657         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
1658     return;
1659   }
1660
1661   process->execution_stack =
1662     g_array_set_size(process->execution_stack, depth - 1);
1663   process->state = &g_array_index(process->execution_stack, LttvExecutionState,
1664       depth - 2);
1665   process->state->change = tfs->parent.timestamp;
1666 }
1667
1668 struct search_result {
1669   const LttTime *time;  /* Requested time */
1670   LttTime *best;  /* Best result */
1671 };
1672
1673 static gint search_usertrace(gconstpointer a, gconstpointer b)
1674 {
1675   const LttTime *elem_time = (const LttTime*)a;
1676   /* Explicit non const cast */
1677   struct search_result *res = (struct search_result *)b;
1678
1679   if(ltt_time_compare(*elem_time, *(res->time)) < 0) {
1680     /* The usertrace was created before the schedchange */
1681     /* Get larger keys */
1682     return 1;
1683   } else if(ltt_time_compare(*elem_time, *(res->time)) >= 0) {
1684     /* The usertrace was created after the schedchange time */
1685     /* Get smaller keys */
1686     if(res->best) {
1687       if(ltt_time_compare(*elem_time, *res->best) < 0) {
1688         res->best = elem_time;
1689       }
1690     } else {
1691       res->best = elem_time;
1692     }
1693     return -1;
1694   }
1695   return 0;
1696 }
1697
1698 static LttvTracefileState *ltt_state_usertrace_find(LttvTraceState *tcs,
1699     guint pid, const LttTime *timestamp)
1700 {
1701   LttvTracefileState *tfs = NULL;
1702   struct search_result res;
1703   /* Find the usertrace associated with a pid and time interval.
1704    * Search in the usertraces by PID (within a hash) and then, for each
1705    * corresponding element of the array, find the first one with creation
1706    * timestamp the lowest, but higher or equal to "timestamp". */
1707   res.time = timestamp;
1708   res.best = NULL;
1709   GTree *usertrace_tree = g_hash_table_lookup(tcs->usertraces, (gpointer)pid);
1710   if(usertrace_tree) {
1711     g_tree_search(usertrace_tree, search_usertrace, &res);
1712     if(res.best)
1713       tfs = g_tree_lookup(usertrace_tree, res.best);
1714   }
1715
1716   return tfs;
1717 }
1718
1719
1720 LttvProcessState *
1721 lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
1722     guint cpu, guint pid, guint tgid, GQuark name, const LttTime *timestamp)
1723 {
1724   LttvProcessState *process = g_new(LttvProcessState, 1);
1725
1726   LttvExecutionState *es;
1727
1728   LttvTraceContext *tc = (LttvTraceContext*)tcs;
1729
1730   char buffer[128];
1731
1732   process->pid = pid;
1733   process->tgid = tgid;
1734   process->cpu = cpu;
1735   process->name = name;
1736   process->brand = LTTV_STATE_UNBRANDED;
1737   //process->last_cpu = tfs->cpu_name;
1738   //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1739   process->type = LTTV_STATE_USER_THREAD;
1740   process->usertrace = ltt_state_usertrace_find(tcs, pid, timestamp);
1741   process->current_function = 0; //function 0x0 by default.
1742
1743   g_info("Process %u, core %p", process->pid, process);
1744   g_hash_table_insert(tcs->processes, process, process);
1745
1746   if(parent) {
1747     process->ppid = parent->pid;
1748     process->creation_time = *timestamp;
1749   }
1750
1751   /* No parent. This process exists but we are missing all information about
1752      its creation. The birth time is set to zero but we remember the time of
1753      insertion */
1754
1755   else {
1756     process->ppid = 0;
1757     process->creation_time = ltt_time_zero;
1758   }
1759
1760   process->insertion_time = *timestamp;
1761   sprintf(buffer,"%d-%lu.%lu",pid, process->creation_time.tv_sec,
1762     process->creation_time.tv_nsec);
1763   process->pid_time = g_quark_from_string(buffer);
1764   process->cpu = cpu;
1765   //process->last_cpu = tfs->cpu_name;
1766   //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1767   process->execution_stack = g_array_sized_new(FALSE, FALSE,
1768       sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
1769   process->execution_stack = g_array_set_size(process->execution_stack, 2);
1770   es = process->state = &g_array_index(process->execution_stack,
1771       LttvExecutionState, 0);
1772   es->t = LTTV_STATE_USER_MODE;
1773   es->n = LTTV_STATE_SUBMODE_NONE;
1774   es->entry = *timestamp;
1775   //g_assert(timestamp->tv_sec != 0);
1776   es->change = *timestamp;
1777   es->cum_cpu_time = ltt_time_zero;
1778   es->s = LTTV_STATE_RUN;
1779
1780   es = process->state = &g_array_index(process->execution_stack,
1781       LttvExecutionState, 1);
1782   es->t = LTTV_STATE_SYSCALL;
1783   es->n = LTTV_STATE_SUBMODE_NONE;
1784   es->entry = *timestamp;
1785   //g_assert(timestamp->tv_sec != 0);
1786   es->change = *timestamp;
1787   es->cum_cpu_time = ltt_time_zero;
1788   es->s = LTTV_STATE_WAIT_FORK;
1789
1790   /* Allocate an empty function call stack. If it's empty, use 0x0. */
1791   process->user_stack = g_array_sized_new(FALSE, FALSE,
1792       sizeof(guint64), 0);
1793
1794   return process;
1795 }
1796
1797 LttvProcessState *lttv_state_find_process(LttvTraceState *ts, guint cpu,
1798     guint pid)
1799 {
1800   LttvProcessState key;
1801   LttvProcessState *process;
1802
1803   key.pid = pid;
1804   key.cpu = cpu;
1805   process = g_hash_table_lookup(ts->processes, &key);
1806   return process;
1807 }
1808
1809 LttvProcessState *
1810 lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid,
1811     const LttTime *timestamp)
1812 {
1813   LttvProcessState *process = lttv_state_find_process(ts, cpu, pid);
1814   LttvExecutionState *es;
1815
1816   /* Put ltt_time_zero creation time for unexisting processes */
1817   if(unlikely(process == NULL)) {
1818     process = lttv_state_create_process(ts,
1819                 NULL, cpu, pid, 0, LTTV_STATE_UNNAMED, timestamp);
1820     /* We are not sure is it's a kernel thread or normal thread, put the
1821       * bottom stack state to unknown */
1822     process->execution_stack =
1823       g_array_set_size(process->execution_stack, 1);
1824     process->state = es =
1825       &g_array_index(process->execution_stack, LttvExecutionState, 0);
1826     es->t = LTTV_STATE_MODE_UNKNOWN;
1827     es->s = LTTV_STATE_UNNAMED;
1828   }
1829   return process;
1830 }
1831
1832 /* FIXME : this function should be called when we receive an event telling that
1833  * release_task has been called in the kernel. In happens generally when
1834  * the parent waits for its child terminaison, but may also happen in special
1835  * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1836  * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1837  * of a killed thread ground, but isn't the leader.
1838  */
1839 static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
1840 {
1841   LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
1842   LttvProcessState key;
1843
1844   key.pid = process->pid;
1845   key.cpu = process->cpu;
1846   g_hash_table_remove(ts->processes, &key);
1847   g_array_free(process->execution_stack, TRUE);
1848   g_array_free(process->user_stack, TRUE);
1849   g_free(process);
1850 }
1851
1852
1853 static void free_process_state(gpointer key, gpointer value,gpointer user_data)
1854 {
1855   g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
1856   g_array_free(((LttvProcessState *)value)->user_stack, TRUE);
1857   g_free(value);
1858 }
1859
1860
1861 static void lttv_state_free_process_table(GHashTable *processes)
1862 {
1863   g_hash_table_foreach(processes, free_process_state, NULL);
1864   g_hash_table_destroy(processes);
1865 }
1866
1867
1868 static gboolean syscall_entry(void *hook_data, void *call_data)
1869 {
1870   LttvTracefileState *s = (LttvTracefileState *)call_data;
1871   guint cpu = s->cpu;
1872   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1873   LttvProcessState *process = ts->running_process[cpu];
1874   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1875   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1876   LttField *f = thf->f1;
1877
1878   LttvExecutionSubmode submode;
1879
1880   guint nb_syscalls = ((LttvTraceState *)(s->parent.t_context))->nb_syscalls;
1881   guint syscall = ltt_event_get_unsigned(e, f);
1882
1883   if(syscall < nb_syscalls) {
1884     submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
1885         syscall];
1886   } else {
1887     /* Fixup an incomplete syscall table */
1888     GString *string = g_string_new("");
1889     g_string_printf(string, "syscall %u", syscall);
1890     submode = g_quark_from_string(string->str);
1891     g_string_free(string, TRUE);
1892   }
1893   /* There can be no system call from PID 0 : unknown state */
1894   if(process->pid != 0)
1895     push_state(s, LTTV_STATE_SYSCALL, submode);
1896   return FALSE;
1897 }
1898
1899
1900 static gboolean syscall_exit(void *hook_data, void *call_data)
1901 {
1902   LttvTracefileState *s = (LttvTracefileState *)call_data;
1903   guint cpu = s->cpu;
1904   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1905   LttvProcessState *process = ts->running_process[cpu];
1906
1907   /* There can be no system call from PID 0 : unknown state */
1908   if(process->pid != 0)
1909     pop_state(s, LTTV_STATE_SYSCALL);
1910   return FALSE;
1911 }
1912
1913
1914 static gboolean trap_entry(void *hook_data, void *call_data)
1915 {
1916   LttvTracefileState *s = (LttvTracefileState *)call_data;
1917   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1918   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1919   LttField *f = thf->f1;
1920
1921   LttvExecutionSubmode submode;
1922
1923   guint64 nb_traps = ((LttvTraceState *)(s->parent.t_context))->nb_traps;
1924   guint64 trap = ltt_event_get_long_unsigned(e, f);
1925
1926   if(trap < nb_traps) {
1927     submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[trap];
1928   } else {
1929     /* Fixup an incomplete trap table */
1930     GString *string = g_string_new("");
1931     g_string_printf(string, "trap %llu", trap);
1932     submode = g_quark_from_string(string->str);
1933     g_string_free(string, TRUE);
1934   }
1935
1936   push_state(s, LTTV_STATE_TRAP, submode);
1937   return FALSE;
1938 }
1939
1940
1941 static gboolean trap_exit(void *hook_data, void *call_data)
1942 {
1943   LttvTracefileState *s = (LttvTracefileState *)call_data;
1944
1945   pop_state(s, LTTV_STATE_TRAP);
1946   return FALSE;
1947 }
1948
1949
1950 static gboolean irq_entry(void *hook_data, void *call_data)
1951 {
1952   LttvTracefileState *s = (LttvTracefileState *)call_data;
1953   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1954   guint8 fac_id = ltt_event_facility_id(e);
1955   guint8 ev_id = ltt_event_eventtype_id(e);
1956   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1957  // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1958   g_assert(thf->f1 != NULL);
1959  // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1960   LttField *f = thf->f1;
1961
1962   LttvExecutionSubmode submode;
1963   guint64 irq = ltt_event_get_long_unsigned(e, f);
1964   guint64 nb_irqs = ((LttvTraceState *)(s->parent.t_context))->nb_irqs;
1965   GString *string;
1966
1967   if(irq < nb_irqs) {
1968     submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[irq];
1969   } else {
1970     /* Fixup an incomplete irq table */
1971     GString *string = g_string_new("");
1972     g_string_printf(string, "irq %llu", irq);
1973     submode = g_quark_from_string(string->str);
1974     g_string_free(string, TRUE);
1975   }
1976
1977   /* Do something with the info about being in user or system mode when int? */
1978   push_state(s, LTTV_STATE_IRQ, submode);
1979   return FALSE;
1980 }
1981
1982 static gboolean soft_irq_exit(void *hook_data, void *call_data)
1983 {
1984   LttvTracefileState *s = (LttvTracefileState *)call_data;
1985
1986   pop_state(s, LTTV_STATE_SOFT_IRQ);
1987   return FALSE;
1988 }
1989
1990
1991
1992 static gboolean irq_exit(void *hook_data, void *call_data)
1993 {
1994   LttvTracefileState *s = (LttvTracefileState *)call_data;
1995
1996   pop_state(s, LTTV_STATE_IRQ);
1997   return FALSE;
1998 }
1999
2000 static gboolean soft_irq_entry(void *hook_data, void *call_data)
2001 {
2002   LttvTracefileState *s = (LttvTracefileState *)call_data;
2003   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2004   guint8 fac_id = ltt_event_facility_id(e);
2005   guint8 ev_id = ltt_event_eventtype_id(e);
2006   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2007  // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
2008   g_assert(thf->f1 != NULL);
2009  // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
2010   LttField *f = thf->f1;
2011
2012   LttvExecutionSubmode submode;
2013   guint64 softirq = ltt_event_get_long_unsigned(e, f);
2014   guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_softirqs;
2015   GString *string;
2016
2017   if(softirq < nb_softirqs) {
2018     submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq];
2019   } else {
2020     /* Fixup an incomplete irq table */
2021     GString *string = g_string_new("");
2022     g_string_printf(string, "softirq %llu", softirq);
2023     submode = g_quark_from_string(string->str);
2024     g_string_free(string, TRUE);
2025   }
2026
2027   /* Do something with the info about being in user or system mode when int? */
2028   push_state(s, LTTV_STATE_SOFT_IRQ, submode);
2029   return FALSE;
2030 }
2031
2032 static void push_function(LttvTracefileState *tfs, guint64 funcptr)
2033 {
2034   guint64 *new_func;
2035
2036   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
2037   guint cpu = tfs->cpu;
2038   LttvProcessState *process = ts->running_process[cpu];
2039
2040   guint depth = process->user_stack->len;
2041
2042   process->user_stack =
2043     g_array_set_size(process->user_stack, depth + 1);
2044
2045   new_func = &g_array_index(process->user_stack, guint64, depth);
2046   *new_func = funcptr;
2047   process->current_function = funcptr;
2048 }
2049
2050 static void pop_function(LttvTracefileState *tfs, guint64 funcptr)
2051 {
2052   guint cpu = tfs->cpu;
2053   LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
2054   LttvProcessState *process = ts->running_process[cpu];
2055
2056   if(process->current_function != funcptr){
2057     g_info("Different functions (%lu.%09lu): ignore it\n",
2058         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
2059     g_info("process state has %llu when pop_function is %llu\n",
2060         process->current_function, funcptr);
2061     g_info("{ %u, %u, %s, %s, %s }\n",
2062         process->pid,
2063         process->ppid,
2064         g_quark_to_string(process->name),
2065         g_quark_to_string(process->brand),
2066         g_quark_to_string(process->state->s));
2067     return;
2068   }
2069   guint depth = process->user_stack->len;
2070
2071   if(depth == 0){
2072     g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
2073         tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
2074     return;
2075   }
2076
2077   process->user_stack =
2078     g_array_set_size(process->user_stack, depth - 1);
2079   process->current_function =
2080     g_array_index(process->user_stack, guint64, depth - 2);
2081 }
2082
2083
2084 static gboolean function_entry(void *hook_data, void *call_data)
2085 {
2086   LttvTracefileState *s = (LttvTracefileState *)call_data;
2087   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2088   guint8 fac_id = ltt_event_facility_id(e);
2089   guint8 ev_id = ltt_event_eventtype_id(e);
2090   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2091   g_assert(thf->f1 != NULL);
2092   LttField *f = thf->f1;
2093   guint64 funcptr = ltt_event_get_long_unsigned(e, f);
2094
2095   push_function(s, funcptr);
2096   return FALSE;
2097 }
2098
2099 static gboolean function_exit(void *hook_data, void *call_data)
2100 {
2101   LttvTracefileState *s = (LttvTracefileState *)call_data;
2102   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2103   guint8 fac_id = ltt_event_facility_id(e);
2104   guint8 ev_id = ltt_event_eventtype_id(e);
2105   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2106   g_assert(thf->f1 != NULL);
2107   LttField *f = thf->f1;
2108   guint64 funcptr = ltt_event_get_long_unsigned(e, f);
2109
2110   LttvExecutionSubmode submode;
2111
2112   pop_function(s, funcptr);
2113   return FALSE;
2114 }
2115
2116 static gboolean schedchange(void *hook_data, void *call_data)
2117 {
2118   LttvTracefileState *s = (LttvTracefileState *)call_data;
2119   guint cpu = s->cpu;
2120   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2121   LttvProcessState *process = ts->running_process[cpu];
2122   LttvProcessState *old_process = ts->running_process[cpu];
2123
2124   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2125   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2126   guint pid_in, pid_out;
2127   gint state_out;
2128
2129   pid_out = ltt_event_get_unsigned(e, thf->f1);
2130   pid_in = ltt_event_get_unsigned(e, thf->f2);
2131   state_out = ltt_event_get_int(e, thf->f3);
2132
2133   if(likely(process != NULL)) {
2134
2135     /* We could not know but it was not the idle process executing.
2136        This should only happen at the beginning, before the first schedule
2137        event, and when the initial information (current process for each CPU)
2138        is missing. It is not obvious how we could, after the fact, compensate
2139        the wrongly attributed statistics. */
2140
2141     //This test only makes sense once the state is known and if there is no
2142     //missing events. We need to silently ignore schedchange coming after a
2143     //process_free, or it causes glitches. (FIXME)
2144     //if(unlikely(process->pid != pid_out)) {
2145     //  g_assert(process->pid == 0);
2146     //}
2147     if(process->pid == 0
2148       && process->state->t == LTTV_STATE_MODE_UNKNOWN) {
2149       if(pid_out == 0) {
2150         /* Scheduling out of pid 0 at beginning of the trace :
2151          * we know for sure it is in syscall mode at this point. */
2152         g_assert(process->execution_stack->len == 1);
2153         process->state->t = LTTV_STATE_SYSCALL;
2154         process->state->s = LTTV_STATE_WAIT;
2155         process->state->change = s->parent.timestamp;
2156         process->state->entry = s->parent.timestamp;
2157       }
2158     } else {
2159       if(unlikely(process->state->s == LTTV_STATE_EXIT)) {
2160         process->state->s = LTTV_STATE_ZOMBIE;
2161         process->state->change = s->parent.timestamp;
2162       } else {
2163         if(unlikely(state_out == 0)) process->state->s = LTTV_STATE_WAIT_CPU;
2164         else process->state->s = LTTV_STATE_WAIT;
2165         process->state->change = s->parent.timestamp;
2166       }
2167
2168       if(state_out == 32)
2169          exit_process(s, process); /* EXIT_DEAD */
2170             /* see sched.h for states */
2171     }
2172   }
2173   process = ts->running_process[cpu] =
2174               lttv_state_find_process_or_create(
2175                   (LttvTraceState*)s->parent.t_context,
2176                   cpu, pid_in,
2177                   &s->parent.timestamp);
2178   process->state->s = LTTV_STATE_RUN;
2179   process->cpu = cpu;
2180   if(process->usertrace)
2181     process->usertrace->cpu = cpu;
2182  // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
2183   process->state->change = s->parent.timestamp;
2184   return FALSE;
2185 }
2186
2187 static gboolean process_fork(void *hook_data, void *call_data)
2188 {
2189   LttvTracefileState *s = (LttvTracefileState *)call_data;
2190   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2191   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2192   guint parent_pid;
2193   guint child_pid;  /* In the Linux Kernel, there is one PID per thread. */
2194   guint child_tgid;  /* tgid in the Linux kernel is the "real" POSIX PID. */
2195   LttvProcessState *zombie_process;
2196   guint cpu = s->cpu;
2197   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2198   LttvProcessState *process = ts->running_process[cpu];
2199   LttvProcessState *child_process;
2200
2201   /* Parent PID */
2202   parent_pid = ltt_event_get_unsigned(e, thf->f1);
2203
2204   /* Child PID */
2205   child_pid = ltt_event_get_unsigned(e, thf->f2);
2206   s->parent.target_pid = child_pid;
2207
2208   /* Child TGID */
2209   if(thf->f3) child_tgid = ltt_event_get_unsigned(e, thf->f3);
2210   else child_tgid = 0;
2211
2212   /* Mathieu : it seems like the process might have been scheduled in before the
2213    * fork, and, in a rare case, might be the current process. This might happen
2214    * in a SMP case where we don't have enough precision on the clocks.
2215    *
2216    * Test reenabled after precision fixes on time. (Mathieu) */
2217 #if 0
2218   zombie_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
2219
2220   if(unlikely(zombie_process != NULL)) {
2221     /* Reutilisation of PID. Only now we are sure that the old PID
2222      * has been released. FIXME : should know when release_task happens instead.
2223      */
2224     guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
2225     guint i;
2226     for(i=0; i< num_cpus; i++) {
2227       g_assert(zombie_process != ts->running_process[i]);
2228     }
2229
2230     exit_process(s, zombie_process);
2231   }
2232 #endif //0
2233   g_assert(process->pid != child_pid);
2234   // FIXME : Add this test in the "known state" section
2235   // g_assert(process->pid == parent_pid);
2236   child_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
2237   if(child_process == NULL) {
2238     child_process = lttv_state_create_process(ts, process, cpu,
2239                               child_pid, child_tgid,
2240                               LTTV_STATE_UNNAMED, &s->parent.timestamp);
2241   } else {
2242     /* The process has already been created :  due to time imprecision between
2243      * multiple CPUs : it has been scheduled in before creation. Note that we
2244      * shouldn't have this kind of imprecision.
2245      *
2246      * Simply put a correct parent.
2247      */
2248     g_assert(0); /* This is a problematic case : the process has been created
2249                     before the fork event */
2250     child_process->ppid = process->pid;
2251     child_process->tgid = child_tgid;
2252   }
2253   g_assert(child_process->name == LTTV_STATE_UNNAMED);
2254   child_process->name = process->name;
2255   child_process->brand = process->brand;
2256
2257   return FALSE;
2258 }
2259
2260 /* We stamp a newly created process as kernel_thread */
2261 static gboolean process_kernel_thread(void *hook_data, void *call_data)
2262 {
2263   LttvTracefileState *s = (LttvTracefileState *)call_data;
2264   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2265   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2266   guint pid;
2267   guint cpu = s->cpu;
2268   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2269   LttvProcessState *process;
2270   LttvExecutionState *es;
2271
2272   /* PID */
2273   pid = ltt_event_get_unsigned(e, thf->f1);
2274   s->parent.target_pid = pid;
2275
2276   process = lttv_state_find_process(ts, ANY_CPU, pid);
2277   es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
2278   es->t = LTTV_STATE_SYSCALL;
2279   process->type = LTTV_STATE_KERNEL_THREAD;
2280
2281   return FALSE;
2282 }
2283
2284 static gboolean process_exit(void *hook_data, void *call_data)
2285 {
2286   LttvTracefileState *s = (LttvTracefileState *)call_data;
2287   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2288   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2289   LttField *f;
2290   guint pid;
2291   guint cpu = s->cpu;
2292   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2293   LttvProcessState *process; // = ts->running_process[cpu];
2294
2295   pid = ltt_event_get_unsigned(e, thf->f1);
2296   s->parent.target_pid = pid;
2297
2298   // FIXME : Add this test in the "known state" section
2299   // g_assert(process->pid == pid);
2300
2301   process = lttv_state_find_process(ts, ANY_CPU, pid);
2302   if(likely(process != NULL)) {
2303     process->state->s = LTTV_STATE_EXIT;
2304   }
2305   return FALSE;
2306 }
2307
2308 static gboolean process_free(void *hook_data, void *call_data)
2309 {
2310   LttvTracefileState *s = (LttvTracefileState *)call_data;
2311   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2312   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2313   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2314   guint release_pid;
2315   LttvProcessState *process;
2316
2317   /* PID of the process to release */
2318   release_pid = ltt_event_get_unsigned(e, thf->f1);
2319   s->parent.target_pid = release_pid;
2320
2321   g_assert(release_pid != 0);
2322
2323   process = lttv_state_find_process(ts, ANY_CPU, release_pid);
2324
2325   if(likely(process != NULL)) {
2326     /* release_task is happening at kernel level : we can now safely release
2327      * the data structure of the process */
2328     //This test is fun, though, as it may happen that
2329     //at time t : CPU 0 : process_free
2330     //at time t+150ns : CPU 1 : schedule out
2331     //Clearly due to time imprecision, we disable it. (Mathieu)
2332     //If this weird case happen, we have no choice but to put the
2333     //Currently running process on the cpu to 0.
2334     //I re-enable it following time precision fixes. (Mathieu)
2335     //Well, in the case where an process is freed by a process on another CPU
2336     //and still scheduled, it happens that this is the schedchange that will
2337     //drop the last reference count. Do not free it here!
2338     guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
2339     guint i;
2340     for(i=0; i< num_cpus; i++) {
2341       //g_assert(process != ts->running_process[i]);
2342       if(process == ts->running_process[i]) {
2343         //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
2344         break;
2345       }
2346     }
2347     if(i == num_cpus) /* process is not scheduled */
2348       exit_process(s, process);
2349   }
2350
2351   return FALSE;
2352 }
2353
2354
2355 static gboolean process_exec(void *hook_data, void *call_data)
2356 {
2357   LttvTracefileState *s = (LttvTracefileState *)call_data;
2358   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2359   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2360   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2361   //gchar *name;
2362   guint cpu = s->cpu;
2363   LttvProcessState *process = ts->running_process[cpu];
2364
2365   /* PID of the process to release */
2366   guint64 name_len = ltt_event_field_element_number(e, thf->f1);
2367   //name = ltt_event_get_string(e, thf->f1);
2368   LttField *child = ltt_event_field_element_select(e, thf->f1, 0);
2369   gchar *name_begin =
2370     (gchar*)(ltt_event_data(e)+ltt_event_field_offset(e, child));
2371   gchar *null_term_name = g_new(gchar, name_len+1);
2372   memcpy(null_term_name, name_begin, name_len);
2373   null_term_name[name_len] = '\0';
2374
2375   process->name = g_quark_from_string(null_term_name);
2376   process->brand = LTTV_STATE_UNBRANDED;
2377   g_free(null_term_name);
2378   return FALSE;
2379 }
2380
2381 static gboolean thread_brand(void *hook_data, void *call_data)
2382 {
2383   LttvTracefileState *s = (LttvTracefileState *)call_data;
2384   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2385   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2386   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2387   gchar *name;
2388   guint cpu = s->cpu;
2389   LttvProcessState *process = ts->running_process[cpu];
2390
2391   name = ltt_event_get_string(e, thf->f1);
2392   process->brand = g_quark_from_string(name);
2393
2394   return FALSE;
2395 }
2396
2397 static void fix_process(gpointer key, gpointer value,
2398    gpointer user_data)
2399 {
2400   LttvProcessState *process;
2401   LttvExecutionState *es;
2402   process = (LttvProcessState *)value;
2403   LttvTracefileContext *tfc = (LttvTracefileContext *)user_data;
2404   LttTime *timestamp = (LttTime*)user_data;
2405
2406   if(process->type == LTTV_STATE_KERNEL_THREAD) {
2407     es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
2408     if(es->t == LTTV_STATE_MODE_UNKNOWN) {
2409       es->t = LTTV_STATE_SYSCALL;
2410       es->n = LTTV_STATE_SUBMODE_NONE;
2411       es->entry = *timestamp;
2412       es->change = *timestamp;
2413       es->cum_cpu_time = ltt_time_zero;
2414       if(es->s == LTTV_STATE_UNNAMED)
2415         es->s = LTTV_STATE_WAIT;
2416     }
2417   } else {
2418     es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
2419     if(es->t == LTTV_STATE_MODE_UNKNOWN) {
2420       es->t = LTTV_STATE_USER_MODE;
2421       es->n = LTTV_STATE_SUBMODE_NONE;
2422       es->entry = *timestamp;
2423       //g_assert(timestamp->tv_sec != 0);
2424       es->change = *timestamp;
2425       es->cum_cpu_time = ltt_time_zero;
2426       if(es->s == LTTV_STATE_UNNAMED)
2427         es->s = LTTV_STATE_RUN;
2428
2429       if(process->execution_stack->len == 1) {
2430         /* Still in user mode, means never scheduled */
2431         process->execution_stack =
2432           g_array_set_size(process->execution_stack, 2);
2433         es = process->state = &g_array_index(process->execution_stack,
2434           LttvExecutionState, 1);
2435         es->t = LTTV_STATE_SYSCALL;
2436         es->n = LTTV_STATE_SUBMODE_NONE;
2437         es->entry = *timestamp;
2438         //g_assert(timestamp->tv_sec != 0);
2439         es->change = *timestamp;
2440         es->cum_cpu_time = ltt_time_zero;
2441         es->s = LTTV_STATE_WAIT;
2442       }
2443     }
2444   }
2445 }
2446
2447 static gboolean statedump_end(void *hook_data, void *call_data)
2448 {
2449   LttvTracefileState *s = (LttvTracefileState *)call_data;
2450   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2451   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2452   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2453   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2454
2455   /* For all processes */
2456     /* if kernel thread, if stack[0] is unknown, set to syscall mode, wait */
2457     /* else, if stack[0] is unknown, set to user mode, running */
2458
2459   g_hash_table_foreach(ts->processes, fix_process, &tfc->timestamp);
2460 }
2461
2462 static gboolean enum_process_state(void *hook_data, void *call_data)
2463 {
2464   LttvTracefileState *s = (LttvTracefileState *)call_data;
2465   LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2466   //It's slow : optimise later by doing this before reading trace.
2467   LttEventType *et = ltt_event_eventtype(e);
2468   //
2469   LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2470   guint parent_pid;
2471   guint pid;
2472   guint tgid;
2473   gchar * command;
2474   guint cpu = s->cpu;
2475   LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2476   LttvProcessState *process = ts->running_process[cpu];
2477   LttvProcessState *parent_process;
2478   LttField *f4, *f5, *f6, *f7, *f8;
2479   GQuark type, mode, submode, status;
2480   LttvExecutionState *es;
2481   guint i, nb_cpus;
2482
2483   /* PID */
2484   pid = ltt_event_get_unsigned(e, thf->f1);
2485   s->parent.target_pid = pid;
2486
2487   /* Parent PID */
2488   parent_pid = ltt_event_get_unsigned(e, thf->f2);
2489
2490   /* Command name */
2491   command = ltt_event_get_string(e, thf->f3);
2492
2493   /* type */
2494   f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_TYPE);
2495   type = ltt_enum_string_get(ltt_field_type(f4),
2496       ltt_event_get_unsigned(e, f4));
2497
2498   /* mode */
2499   f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE);
2500   mode = ltt_enum_string_get(ltt_field_type(f5),
2501       ltt_event_get_unsigned(e, f5));
2502
2503   /* submode */
2504   f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE);
2505   submode = ltt_enum_string_get(ltt_field_type(f6),
2506       ltt_event_get_unsigned(e, f6));
2507
2508   /* status */
2509   f7 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS);
2510   status = ltt_enum_string_get(ltt_field_type(f7),
2511       ltt_event_get_unsigned(e, f7));
2512
2513   /* TGID */
2514   f8 = ltt_eventtype_field_by_name(et, LTT_FIELD_TGID);
2515   if(f8) tgid = ltt_event_get_unsigned(e, f8);
2516   else tgid = 0;
2517
2518
2519   if(pid == 0) {
2520     nb_cpus = ltt_trace_get_num_cpu(ts->parent.t);
2521     for(i=0; i<nb_cpus; i++) {
2522       process = lttv_state_find_process(ts, i, pid);
2523       g_assert(process != NULL);
2524
2525       process->ppid = parent_pid;
2526       process->tgid = tgid;
2527       process->name = g_quark_from_string(command);
2528       es =
2529         &g_array_index(process->execution_stack, LttvExecutionState, 0);
2530       process->type = LTTV_STATE_KERNEL_THREAD;
2531     }
2532
2533   } else {
2534     /* The process might exist if a process was forked while performing the
2535      * state dump. */
2536     process = lttv_state_find_process(ts, ANY_CPU, pid);
2537     if(process == NULL) {
2538       parent_process = lttv_state_find_process(ts, ANY_CPU, parent_pid);
2539       process = lttv_state_create_process(ts, parent_process, cpu,
2540                                 pid, tgid, g_quark_from_string(command),
2541                                 &s->parent.timestamp);
2542
2543       /* Keep the stack bottom : a running user mode */
2544       /* Disabled because of inconsistencies in the current statedump states. */
2545       if(type == LTTV_STATE_KERNEL_THREAD) {
2546         /* Only keep the bottom
2547          * FIXME Kernel thread : can be in syscall or interrupt or trap. */
2548         /* Will cause expected trap when in fact being syscall (even after end of
2549          * statedump event)
2550          * Will cause expected interrupt when being syscall. (only before end of
2551          * statedump event) */
2552         // This will cause a "popping last state on stack, ignoring it."
2553         process->execution_stack = g_array_set_size(process->execution_stack, 1);
2554         es = process->state = &g_array_index(process->execution_stack,
2555             LttvExecutionState, 0);
2556         process->type = LTTV_STATE_KERNEL_THREAD;
2557         es->t = LTTV_STATE_MODE_UNKNOWN;
2558         es->s = LTTV_STATE_UNNAMED;
2559         es->n = LTTV_STATE_SUBMODE_UNKNOWN;
2560   #if 0
2561         es->t = LTTV_STATE_SYSCALL;
2562         es->s = status;
2563         es->n = submode;
2564   #endif //0
2565       } else {
2566         /* User space process :
2567          * bottom : user mode
2568          * either currently running or scheduled out.
2569          * can be scheduled out because interrupted in (user mode or in syscall)
2570          * or because of an explicit call to the scheduler in syscall. Note that
2571          * the scheduler call comes after the irq_exit, so never in interrupt
2572          * context. */
2573         // temp workaround : set size to 1 : only have user mode bottom of stack.
2574         // will cause g_info message of expected syscall mode when in fact being
2575         // in user mode. Can also cause expected trap when in fact being user
2576         // mode in the event of a page fault reenabling interrupts in the handler.
2577         // Expected syscall and trap can also happen after the end of statedump
2578         // This will cause a "popping last state on stack, ignoring it."
2579         process->execution_stack = g_array_set_size(process->execution_stack, 1);
2580         es = process->state = &g_array_index(process->execution_stack,
2581             LttvExecutionState, 0);
2582         es->t = LTTV_STATE_MODE_UNKNOWN;
2583         es->s = LTTV_STATE_UNNAMED;
2584         es->n = LTTV_STATE_SUBMODE_UNKNOWN;
2585   #if 0
2586         es->t = LTTV_STATE_USER_MODE;
2587         es->s = status;
2588         es->n = submode;
2589   #endif //0
2590       }
2591   #if 0
2592       /* UNKNOWN STATE */
2593       {
2594         es = process->state = &g_array_index(process->execution_stack,
2595             LttvExecutionState, 1);
2596         es->t = LTTV_STATE_MODE_UNKNOWN;
2597         es->s = LTTV_STATE_UNNAMED;
2598         es->n = LTTV_STATE_SUBMODE_UNKNOWN;
2599       }
2600   #endif //0
2601     } else {
2602       /* The process has already been created :
2603        * Probably was forked while dumping the process state or
2604        * was simply scheduled in prior to get the state dump event.
2605        */
2606       process->ppid = parent_pid;
2607       process->tgid = tgid;
2608       process->name = g_quark_from_string(command);
2609       process->type = type;
2610       es =
2611         &g_array_index(process->execution_stack, LttvExecutionState, 0);
2612 #if 0
2613       if(es->t == LTTV_STATE_MODE_UNKNOWN) {
2614         if(type == LTTV_STATE_KERNEL_THREAD)
2615           es->t = LTTV_STATE_SYSCALL;
2616         else
2617           es->t = LTTV_STATE_USER_MODE;
2618       }
2619 #endif //0
2620       /* Don't mess around with the stack, it will eventually become
2621        * ok after the end of state dump. */
2622     }
2623   }
2624
2625   return FALSE;
2626 }
2627
2628 gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
2629 {
2630   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
2631
2632   lttv_state_add_event_hooks(tss);
2633
2634   return 0;
2635 }
2636
2637 void lttv_state_add_event_hooks(LttvTracesetState *self)
2638 {
2639   LttvTraceset *traceset = self->parent.ts;
2640
2641   guint i, j, k, l, nb_trace, nb_tracefile;
2642
2643   LttvTraceState *ts;
2644
2645   LttvTracefileState *tfs;
2646
2647   GArray *hooks;
2648
2649   LttvTraceHookByFacility *thf;
2650
2651   LttvTraceHook *hook;
2652
2653   LttvAttributeValue val;
2654
2655   gint ret;
2656   gint hn;
2657
2658   nb_trace = lttv_traceset_number(traceset);
2659   for(i = 0 ; i < nb_trace ; i++) {
2660     ts = (LttvTraceState *)self->parent.traces[i];
2661
2662     /* Find the eventtype id for the following events and register the
2663        associated by id hooks. */
2664
2665     hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 19);
2666     hooks = g_array_set_size(hooks, 19); // Max possible number of hooks.
2667     hn = 0;
2668
2669     ret = lttv_trace_find_hook(ts->parent.t,
2670         LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
2671         LTT_FIELD_SYSCALL_ID, 0, 0,
2672         syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2673     if(ret) hn--;
2674
2675     ret = lttv_trace_find_hook(ts->parent.t,
2676         LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT,
2677         0, 0, 0,
2678         syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2679     if(ret) hn--;
2680
2681     ret = lttv_trace_find_hook(ts->parent.t,
2682         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
2683         LTT_FIELD_TRAP_ID, 0, 0,
2684         trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2685     if(ret) hn--;
2686
2687     ret = lttv_trace_find_hook(ts->parent.t,
2688         LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
2689         0, 0, 0,
2690         trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2691     if(ret) hn--;
2692
2693     ret = lttv_trace_find_hook(ts->parent.t,
2694         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
2695         LTT_FIELD_IRQ_ID, 0, 0,
2696         irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2697     if(ret) hn--;
2698
2699     ret = lttv_trace_find_hook(ts->parent.t,
2700         LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
2701         0, 0, 0,
2702         irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2703     if(ret) hn--;
2704
2705     ret = lttv_trace_find_hook(ts->parent.t,
2706         LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY,
2707         LTT_FIELD_SOFT_IRQ_ID, 0, 0,
2708         soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2709     if(ret) hn--;
2710
2711     ret = lttv_trace_find_hook(ts->parent.t,
2712         LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT,
2713         0, 0, 0,
2714         soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2715     if(ret) hn--;
2716
2717     ret = lttv_trace_find_hook(ts->parent.t,
2718         LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
2719         LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
2720         schedchange, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2721     if(ret) hn--;
2722
2723     ret = lttv_trace_find_hook(ts->parent.t,
2724         LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
2725         LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, LTT_FIELD_TGID,
2726         process_fork, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2727     if(ret) hn--;
2728
2729     ret = lttv_trace_find_hook(ts->parent.t,
2730         LTT_FACILITY_PROCESS, LTT_EVENT_KERNEL_THREAD,
2731         LTT_FIELD_PID, 0, 0,
2732         process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook,
2733           hn++));
2734     if(ret) hn--;
2735
2736     ret = lttv_trace_find_hook(ts->parent.t,
2737         LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
2738         LTT_FIELD_PID, 0, 0,
2739         process_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2740     if(ret) hn--;
2741
2742     ret = lttv_trace_find_hook(ts->parent.t,
2743         LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
2744         LTT_FIELD_PID, 0, 0,
2745         process_free, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2746     if(ret) hn--;
2747
2748     ret = lttv_trace_find_hook(ts->parent.t,
2749         LTT_FACILITY_FS, LTT_EVENT_EXEC,
2750         LTT_FIELD_FILENAME, 0, 0,
2751         process_exec, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2752     if(ret) hn--;
2753
2754     ret = lttv_trace_find_hook(ts->parent.t,
2755         LTT_FACILITY_USER_GENERIC, LTT_EVENT_THREAD_BRAND,
2756         LTT_FIELD_NAME, 0, 0,
2757         thread_brand, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2758     if(ret) hn--;
2759
2760      /* statedump-related hooks */
2761     ret = lttv_trace_find_hook(ts->parent.t,
2762         LTT_FACILITY_STATEDUMP, LTT_EVENT_ENUM_PROCESS_STATE,
2763         LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME,
2764         enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2765     if(ret) hn--;
2766
2767     ret = lttv_trace_find_hook(ts->parent.t,
2768         LTT_FACILITY_STATEDUMP, LTT_EVENT_STATEDUMP_END,
2769         0, 0, 0,
2770         statedump_end, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2771     if(ret) hn--;
2772
2773     ret = lttv_trace_find_hook(ts->parent.t,
2774         LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY,
2775         LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
2776         function_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2777     if(ret) hn--;
2778
2779     ret = lttv_trace_find_hook(ts->parent.t,
2780         LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT,
2781         LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
2782         function_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2783     if(ret) hn--;
2784
2785     hooks = g_array_set_size(hooks, hn);
2786
2787     /* Add these hooks to each event_by_id hooks list */
2788
2789     nb_tracefile = ts->parent.tracefiles->len;
2790
2791     for(j = 0 ; j < nb_tracefile ; j++) {
2792       tfs =
2793           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
2794                                           LttvTracefileContext*, j));
2795
2796       for(k = 0 ; k < hooks->len ; k++) {
2797         hook = &g_array_index(hooks, LttvTraceHook, k);
2798         for(l=0;l<hook->fac_list->len;l++) {
2799           thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
2800           lttv_hooks_add(
2801             lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
2802             thf->h,
2803             thf,
2804             LTTV_PRIO_STATE);
2805         }
2806       }
2807     }
2808     lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
2809     *(val.v_pointer) = hooks;
2810   }
2811 }
2812
2813 gint lttv_state_hook_remove_event_hooks(void *hook_data, void *call_data)
2814 {
2815   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
2816
2817   lttv_state_remove_event_hooks(tss);
2818
2819   return 0;
2820 }
2821
2822 void lttv_state_remove_event_hooks(LttvTracesetState *self)
2823 {
2824   LttvTraceset *traceset = self->parent.ts;
2825
2826   guint i, j, k, l, nb_trace, nb_tracefile;
2827
2828   LttvTraceState *ts;
2829
2830   LttvTracefileState *tfs;
2831
2832   GArray *hooks;
2833
2834   LttvTraceHook *hook;
2835
2836   LttvTraceHookByFacility *thf;
2837
2838   LttvAttributeValue val;
2839
2840   nb_trace = lttv_traceset_number(traceset);
2841   for(i = 0 ; i < nb_trace ; i++) {
2842     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
2843
2844     lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
2845     hooks = *(val.v_pointer);
2846
2847     /* Remove these hooks from each event_by_id hooks list */
2848
2849     nb_tracefile = ts->parent.tracefiles->len;
2850
2851     for(j = 0 ; j < nb_tracefile ; j++) {
2852       tfs =
2853           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
2854                                           LttvTracefileContext*, j));
2855
2856       for(k = 0 ; k < hooks->len ; k++) {
2857         hook = &g_array_index(hooks, LttvTraceHook, k);
2858         for(l=0;l<hook->fac_list->len;l++) {
2859           thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
2860
2861           lttv_hooks_remove_data(
2862             lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
2863                     thf->h,
2864                     thf);
2865         }
2866       }
2867     }
2868     for(k = 0 ; k < hooks->len ; k++)
2869       lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k));
2870     g_array_free(hooks, TRUE);
2871   }
2872 }
2873
2874 static gboolean state_save_event_hook(void *hook_data, void *call_data)
2875 {
2876   guint *event_count = (guint*)hook_data;
2877
2878   /* Only save at LTTV_STATE_SAVE_INTERVAL */
2879   if(likely((*event_count)++ < LTTV_STATE_SAVE_INTERVAL))
2880     return FALSE;
2881   else
2882     *event_count = 0;
2883
2884   LttvTracefileState *self = (LttvTracefileState *)call_data;
2885
2886   LttvTracefileState *tfcs;
2887
2888   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
2889
2890   LttEventPosition *ep;
2891
2892   guint i;
2893
2894   LttTracefile *tf;
2895
2896   LttvAttribute *saved_states_tree, *saved_state_tree;
2897
2898   LttvAttributeValue value;
2899
2900   saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
2901       LTTV_STATE_SAVED_STATES);
2902   saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
2903   value = lttv_attribute_add(saved_states_tree,
2904       lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
2905   *(value.v_gobject) = (GObject *)saved_state_tree;
2906   value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
2907   *(value.v_time) = self->parent.timestamp;
2908   lttv_state_save(tcs, saved_state_tree);
2909   g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
2910     self->parent.timestamp.tv_nsec);
2911
2912   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
2913
2914   return FALSE;
2915 }
2916
2917 static gboolean state_save_after_trace_hook(void *hook_data, void *call_data)
2918 {
2919   LttvTraceState *tcs = (LttvTraceState *)(call_data);
2920
2921   *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time;
2922
2923   return FALSE;
2924 }
2925
2926 guint lttv_state_current_cpu(LttvTracefileState *tfs)
2927 {
2928   return tfs->cpu;
2929 }
2930
2931
2932
2933 #if 0
2934 static gboolean block_start(void *hook_data, void *call_data)
2935 {
2936   LttvTracefileState *self = (LttvTracefileState *)call_data;
2937
2938   LttvTracefileState *tfcs;
2939
2940   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
2941
2942   LttEventPosition *ep;
2943
2944   guint i, nb_block, nb_event, nb_tracefile;
2945
2946   LttTracefile *tf;
2947
2948   LttvAttribute *saved_states_tree, *saved_state_tree;
2949
2950   LttvAttributeValue value;
2951
2952   ep = ltt_event_position_new();
2953
2954   nb_tracefile = tcs->parent.tracefiles->len;
2955
2956   /* Count the number of events added since the last block end in any
2957      tracefile. */
2958
2959   for(i = 0 ; i < nb_tracefile ; i++) {
2960     tfcs =
2961           LTTV_TRACEFILE_STATE(&g_array_index(tcs->parent.tracefiles,
2962                                           LttvTracefileContext, i));
2963     ltt_event_position(tfcs->parent.e, ep);
2964     ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
2965     tcs->nb_event += nb_event - tfcs->saved_position;
2966     tfcs->saved_position = nb_event;
2967   }
2968   g_free(ep);
2969
2970   if(tcs->nb_event >= tcs->save_interval) {
2971     saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
2972         LTTV_STATE_SAVED_STATES);
2973     saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
2974     value = lttv_attribute_add(saved_states_tree,
2975         lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
2976     *(value.v_gobject) = (GObject *)saved_state_tree;
2977     value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
2978     *(value.v_time) = self->parent.timestamp;
2979     lttv_state_save(tcs, saved_state_tree);
2980     tcs->nb_event = 0;
2981     g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
2982       self->parent.timestamp.tv_nsec);
2983   }
2984   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
2985   return FALSE;
2986 }
2987 #endif //0
2988
2989 #if 0
2990 static gboolean block_end(void *hook_data, void *call_data)
2991 {
2992   LttvTracefileState *self = (LttvTracefileState *)call_data;
2993
2994   LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
2995
2996   LttTracefile *tf;
2997
2998   LttEventPosition *ep;
2999
3000   guint nb_block, nb_event;
3001
3002   ep = ltt_event_position_new();
3003   ltt_event_position(self->parent.e, ep);
3004   ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
3005   tcs->nb_event += nb_event - self->saved_position + 1;
3006   self->saved_position = 0;
3007   *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
3008   g_free(ep);
3009
3010   return FALSE;
3011 }
3012 #endif //0
3013 #if 0
3014 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
3015 {
3016   LttvTraceset *traceset = self->parent.ts;
3017
3018   guint i, j, nb_trace, nb_tracefile;
3019
3020   LttvTraceState *ts;
3021
3022   LttvTracefileState *tfs;
3023
3024   LttvTraceHook hook_start, hook_end;
3025
3026   nb_trace = lttv_traceset_number(traceset);
3027   for(i = 0 ; i < nb_trace ; i++) {
3028     ts = (LttvTraceState *)self->parent.traces[i];
3029
3030     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
3031   NULL, NULL, block_start, &hook_start);
3032     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
3033   NULL, NULL, block_end, &hook_end);
3034
3035     nb_tracefile = ts->parent.tracefiles->len;
3036
3037     for(j = 0 ; j < nb_tracefile ; j++) {
3038       tfs =
3039           LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
3040                                           LttvTracefileContext, j));
3041       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
3042                 hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
3043       lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
3044                 hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
3045     }
3046   }
3047 }
3048 #endif //0
3049
3050 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
3051 {
3052   LttvTraceset *traceset = self->parent.ts;
3053
3054   guint i, j, nb_trace, nb_tracefile;
3055
3056   LttvTraceState *ts;
3057
3058   LttvTracefileState *tfs;
3059
3060
3061   nb_trace = lttv_traceset_number(traceset);
3062   for(i = 0 ; i < nb_trace ; i++) {
3063
3064     ts = (LttvTraceState *)self->parent.traces[i];
3065     nb_tracefile = ts->parent.tracefiles->len;
3066
3067     if(ts->has_precomputed_states) continue;
3068
3069     guint *event_count = g_new(guint, 1);
3070     *event_count = 0;
3071
3072     for(j = 0 ; j < nb_tracefile ; j++) {
3073       tfs =
3074           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
3075                                           LttvTracefileContext*, j));
3076       lttv_hooks_add(tfs->parent.event,
3077                      state_save_event_hook,
3078                      event_count,
3079                      LTTV_PRIO_STATE);
3080
3081     }
3082   }
3083
3084   lttv_process_traceset_begin(&self->parent,
3085                 NULL, NULL, NULL, NULL, NULL);
3086
3087 }
3088
3089 gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data)
3090 {
3091   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
3092
3093   lttv_state_save_add_event_hooks(tss);
3094
3095   return 0;
3096 }
3097
3098
3099 #if 0
3100 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
3101 {
3102   LttvTraceset *traceset = self->parent.ts;
3103
3104   guint i, j, nb_trace, nb_tracefile;
3105
3106   LttvTraceState *ts;
3107
3108   LttvTracefileState *tfs;
3109
3110   LttvTraceHook hook_start, hook_end;
3111
3112   nb_trace = lttv_traceset_number(traceset);
3113   for(i = 0 ; i < nb_trace ; i++) {
3114     ts = LTTV_TRACE_STATE(self->parent.traces[i]);
3115
3116     lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
3117   NULL, NULL, block_start, &hook_start);
3118
3119     lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
3120   NULL, NULL, block_end, &hook_end);
3121
3122     nb_tracefile = ts->parent.tracefiles->len;
3123
3124     for(j = 0 ; j < nb_tracefile ; j++) {
3125       tfs =
3126           LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
3127                                           LttvTracefileContext, j));
3128       lttv_hooks_remove_data(lttv_hooks_by_id_find(
3129           tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
3130       lttv_hooks_remove_data(lttv_hooks_by_id_find(
3131           tfs->parent.event_by_id, hook_end.id), hook_end.h, NULL);
3132     }
3133   }
3134 }
3135 #endif //0
3136
3137 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
3138 {
3139   LttvTraceset *traceset = self->parent.ts;
3140
3141   guint i, j, nb_trace, nb_tracefile;
3142
3143   LttvTraceState *ts;
3144
3145   LttvTracefileState *tfs;
3146
3147   LttvHooks *after_trace = lttv_hooks_new();
3148
3149   lttv_hooks_add(after_trace,
3150                  state_save_after_trace_hook,
3151                  NULL,
3152                  LTTV_PRIO_STATE);
3153
3154
3155   lttv_process_traceset_end(&self->parent,
3156                 NULL, after_trace, NULL, NULL, NULL);
3157
3158   lttv_hooks_destroy(after_trace);
3159
3160   nb_trace = lttv_traceset_number(traceset);
3161   for(i = 0 ; i < nb_trace ; i++) {
3162
3163     ts = (LttvTraceState *)self->parent.traces[i];
3164     nb_tracefile = ts->parent.tracefiles->len;
3165
3166     if(ts->has_precomputed_states) continue;
3167
3168     guint *event_count = NULL;
3169
3170     for(j = 0 ; j < nb_tracefile ; j++) {
3171       tfs =
3172           LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
3173                                           LttvTracefileContext*, j));
3174       event_count = lttv_hooks_remove(tfs->parent.event,
3175                         state_save_event_hook);
3176     }
3177     if(event_count) g_free(event_count);
3178   }
3179 }
3180
3181 gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data)
3182 {
3183   LttvTracesetState *tss = (LttvTracesetState*)(call_data);
3184
3185   lttv_state_save_remove_event_hooks(tss);
3186
3187   return 0;
3188 }
3189
3190 void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
3191 {
3192   LttvTraceset *traceset = self->parent.ts;
3193
3194   guint i, nb_trace;
3195
3196   int min_pos, mid_pos, max_pos;
3197
3198   guint call_rest = 0;
3199
3200   LttvTraceState *tcs;
3201
3202   LttvAttributeValue value;
3203
3204   LttvAttributeType type;
3205
3206   LttvAttributeName name;
3207
3208   gboolean is_named;
3209
3210   LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
3211
3212   //g_tree_destroy(self->parent.pqueue);
3213   //self->parent.pqueue = g_tree_new(compare_tracefile);
3214
3215   g_info("Entering seek_time_closest for time %lu.%lu", t.tv_sec, t.tv_nsec);
3216
3217   nb_trace = lttv_traceset_number(traceset);
3218   for(i = 0 ; i < nb_trace ; i++) {
3219     tcs = (LttvTraceState *)self->parent.traces[i];
3220
3221     if(ltt_time_compare(t, *(tcs->max_time_state_recomputed_in_seek)) < 0) {
3222       saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
3223           LTTV_STATE_SAVED_STATES);
3224       min_pos = -1;
3225
3226       if(saved_states_tree) {
3227         max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
3228         mid_pos = max_pos / 2;
3229         while(min_pos < max_pos) {
3230           type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value,
3231               &is_named);
3232           g_assert(type == LTTV_GOBJECT);
3233           saved_state_tree = *((LttvAttribute **)(value.v_gobject));
3234           type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME,
3235               &value);
3236           g_assert(type == LTTV_TIME);
3237           if(ltt_time_compare(*(value.v_time), t) < 0) {
3238             min_pos = mid_pos;
3239             closest_tree = saved_state_tree;
3240           }
3241           else max_pos = mid_pos - 1;
3242
3243           mid_pos = (min_pos + max_pos + 1) / 2;
3244         }
3245       }
3246
3247       /* restore the closest earlier saved state */
3248       if(min_pos != -1) {
3249         lttv_state_restore(tcs, closest_tree);
3250         call_rest = 1;
3251       }
3252
3253       /* There is no saved state, yet we want to have it. Restart at T0 */
3254       else {
3255         restore_init_state(tcs);
3256         lttv_process_trace_seek_time(&(tcs->parent), ltt_time_zero);
3257       }
3258     }
3259     /* We want to seek quickly without restoring/updating the state */
3260     else {
3261       restore_init_state(tcs);
3262       lttv_process_trace_seek_time(&(tcs->parent), t);
3263     }
3264   }
3265   if(!call_rest) g_info("NOT Calling restore");
3266 }
3267
3268
3269 static void
3270 traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
3271 {
3272 }
3273
3274
3275 static void
3276 traceset_state_finalize (LttvTracesetState *self)
3277 {
3278   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
3279       finalize(G_OBJECT(self));
3280 }
3281
3282
3283 static void
3284 traceset_state_class_init (LttvTracesetContextClass *klass)
3285 {
3286   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
3287
3288   gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
3289   klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
3290   klass->fini = (void (*)(LttvTracesetContext *self))fini;
3291   klass->new_traceset_context = new_traceset_context;
3292   klass->new_trace_context = new_trace_context;
3293   klass->new_tracefile_context = new_tracefile_context;
3294 }
3295
3296
3297 GType
3298 lttv_traceset_state_get_type(void)
3299 {
3300   static GType type = 0;
3301   if (type == 0) {
3302     static const GTypeInfo info = {
3303       sizeof (LttvTracesetStateClass),
3304       NULL,   /* base_init */
3305       NULL,   /* base_finalize */
3306       (GClassInitFunc) traceset_state_class_init,   /* class_init */
3307       NULL,   /* class_finalize */
3308       NULL,   /* class_data */
3309       sizeof (LttvTracesetState),
3310       0,      /* n_preallocs */
3311       (GInstanceInitFunc) traceset_state_instance_init,    /* instance_init */
3312       NULL    /* value handling */
3313     };
3314
3315     type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
3316         &info, 0);
3317   }
3318   return type;
3319 }
3320
3321
3322 static void
3323 trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
3324 {
3325 }
3326
3327
3328 static void
3329 trace_state_finalize (LttvTraceState *self)
3330 {
3331   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE))->
3332       finalize(G_OBJECT(self));
3333 }
3334
3335
3336 static void
3337 trace_state_class_init (LttvTraceStateClass *klass)
3338 {
3339   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
3340
3341   gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
3342   klass->state_save = state_save;
3343   klass->state_restore = state_restore;
3344   klass->state_saved_free = state_saved_free;
3345 }
3346
3347
3348 GType
3349 lttv_trace_state_get_type(void)
3350 {
3351   static GType type = 0;
3352   if (type == 0) {
3353     static const GTypeInfo info = {
3354       sizeof (LttvTraceStateClass),
3355       NULL,   /* base_init */
3356       NULL,   /* base_finalize */
3357       (GClassInitFunc) trace_state_class_init,   /* class_init */
3358       NULL,   /* class_finalize */
3359       NULL,   /* class_data */
3360       sizeof (LttvTraceState),
3361       0,      /* n_preallocs */
3362       (GInstanceInitFunc) trace_state_instance_init,    /* instance_init */
3363       NULL    /* value handling */
3364     };
3365
3366     type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
3367         "LttvTraceStateType", &info, 0);
3368   }
3369   return type;
3370 }
3371
3372
3373 static void
3374 tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
3375 {
3376 }
3377
3378
3379 static void
3380 tracefile_state_finalize (LttvTracefileState *self)
3381 {
3382   G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE))->
3383       finalize(G_OBJECT(self));
3384 }
3385
3386
3387 static void
3388 tracefile_state_class_init (LttvTracefileStateClass *klass)
3389 {
3390   GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
3391
3392   gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
3393 }
3394
3395
3396 GType
3397 lttv_tracefile_state_get_type(void)
3398 {
3399   static GType type = 0;
3400   if (type == 0) {
3401     static const GTypeInfo info = {
3402       sizeof (LttvTracefileStateClass),
3403       NULL,   /* base_init */
3404       NULL,   /* base_finalize */
3405       (GClassInitFunc) tracefile_state_class_init,   /* class_init */
3406       NULL,   /* class_finalize */
3407       NULL,   /* class_data */
3408       sizeof (LttvTracefileState),
3409       0,      /* n_preallocs */
3410       (GInstanceInitFunc) tracefile_state_instance_init,    /* instance_init */
3411       NULL    /* value handling */
3412     };
3413
3414     type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
3415         "LttvTracefileStateType", &info, 0);
3416   }
3417   return type;
3418 }
3419
3420
3421 static void module_init()
3422 {
3423   LTTV_STATE_UNNAMED = g_quark_from_string("UNNAMED");
3424   LTTV_STATE_UNBRANDED = g_quark_from_string("UNBRANDED");
3425   LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("MODE_UNKNOWN");
3426   LTTV_STATE_USER_MODE = g_quark_from_string("USER_MODE");
3427   LTTV_STATE_SYSCALL = g_quark_from_string("SYSCALL");
3428   LTTV_STATE_TRAP = g_quark_from_string("TRAP");
3429   LTTV_STATE_IRQ = g_quark_from_string("IRQ");
3430   LTTV_STATE_SOFT_IRQ = g_quark_from_string("SOFTIRQ");
3431   LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("UNKNOWN");
3432   LTTV_STATE_SUBMODE_NONE = g_quark_from_string("NONE");
3433   LTTV_STATE_WAIT_FORK = g_quark_from_string("WAIT_FORK");
3434   LTTV_STATE_WAIT_CPU = g_quark_from_string("WAIT_CPU");
3435   LTTV_STATE_EXIT = g_quark_from_string("EXIT");
3436   LTTV_STATE_ZOMBIE = g_quark_from_string("ZOMBIE");
3437   LTTV_STATE_WAIT = g_quark_from_string("WAIT");
3438   LTTV_STATE_RUN = g_quark_from_string("RUN");
3439   LTTV_STATE_DEAD = g_quark_from_string("DEAD");
3440   LTTV_STATE_USER_THREAD = g_quark_from_string("USER_THREAD");
3441   LTTV_STATE_KERNEL_THREAD = g_quark_from_string("KERNEL_THREAD");
3442   LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
3443   LTTV_STATE_PROCESSES = g_quark_from_string("processes");
3444   LTTV_STATE_PROCESS = g_quark_from_string("process");
3445   LTTV_STATE_RUNNING_PROCESS = g_quark_from_string("running_process");
3446   LTTV_STATE_EVENT = g_quark_from_string("event");
3447   LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
3448   LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
3449   LTTV_STATE_TIME = g_quark_from_string("time");
3450   LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
3451   LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
3452   LTTV_STATE_TRACE_STATE_USE_COUNT =
3453       g_quark_from_string("trace_state_use_count");
3454
3455
3456   LTT_FACILITY_KERNEL     = g_quark_from_string("kernel");
3457   LTT_FACILITY_KERNEL_ARCH = g_quark_from_string("kernel_arch");
3458   LTT_FACILITY_PROCESS    = g_quark_from_string("process");
3459   LTT_FACILITY_FS    = g_quark_from_string("fs");
3460   LTT_FACILITY_STATEDUMP    = g_quark_from_string("statedump");
3461   LTT_FACILITY_USER_GENERIC    = g_quark_from_string("user_generic");
3462
3463
3464   LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
3465   LTT_EVENT_SYSCALL_EXIT  = g_quark_from_string("syscall_exit");
3466   LTT_EVENT_TRAP_ENTRY    = g_quark_from_string("trap_entry");
3467   LTT_EVENT_TRAP_EXIT     = g_quark_from_string("trap_exit");
3468   LTT_EVENT_IRQ_ENTRY     = g_quark_from_string("irq_entry");
3469   LTT_EVENT_IRQ_EXIT      = g_quark_from_string("irq_exit");
3470   LTT_EVENT_SOFT_IRQ_ENTRY     = g_quark_from_string("soft_irq_entry");
3471   LTT_EVENT_SOFT_IRQ_EXIT      = g_quark_from_string("soft_irq_exit");
3472   LTT_EVENT_SCHEDCHANGE   = g_quark_from_string("schedchange");
3473   LTT_EVENT_FORK          = g_quark_from_string("fork");
3474   LTT_EVENT_KERNEL_THREAD = g_quark_from_string("kernel_thread");
3475   LTT_EVENT_EXIT          = g_quark_from_string("exit");
3476   LTT_EVENT_FREE          = g_quark_from_string("free");
3477   LTT_EVENT_EXEC          = g_quark_from_string("exec");
3478   LTT_EVENT_ENUM_PROCESS_STATE  = g_quark_from_string("enumerate_process_state");
3479   LTT_EVENT_STATEDUMP_END  = g_quark_from_string("statedump_end");
3480   LTT_EVENT_FUNCTION_ENTRY  = g_quark_from_string("function_entry");
3481   LTT_EVENT_FUNCTION_EXIT  = g_quark_from_string("function_exit");
3482   LTT_EVENT_THREAD_BRAND  = g_quark_from_string("thread_brand");
3483
3484
3485   LTT_FIELD_SYSCALL_ID    = g_quark_from_string("syscall_id");
3486   LTT_FIELD_TRAP_ID       = g_quark_from_string("trap_id");
3487   LTT_FIELD_IRQ_ID        = g_quark_from_string("irq_id");
3488   LTT_FIELD_SOFT_IRQ_ID        = g_quark_from_string("softirq_id");
3489   LTT_FIELD_OUT           = g_quark_from_string("out");
3490   LTT_FIELD_IN            = g_quark_from_string("in");
3491   LTT_FIELD_OUT_STATE     = g_quark_from_string("out_state");
3492   LTT_FIELD_PARENT_PID    = g_quark_from_string("parent_pid");
3493   LTT_FIELD_CHILD_PID     = g_quark_from_string("child_pid");
3494   LTT_FIELD_PID           = g_quark_from_string("pid");
3495   LTT_FIELD_TGID          = g_quark_from_string("tgid");
3496   LTT_FIELD_FILENAME      = g_quark_from_string("filename");
3497   LTT_FIELD_NAME          = g_quark_from_string("name");
3498   LTT_FIELD_TYPE          = g_quark_from_string("type");
3499   LTT_FIELD_MODE          = g_quark_from_string("mode");
3500   LTT_FIELD_SUBMODE       = g_quark_from_string("submode");
3501   LTT_FIELD_STATUS        = g_quark_from_string("status");
3502   LTT_FIELD_THIS_FN       = g_quark_from_string("this_fn");
3503   LTT_FIELD_CALL_SITE     = g_quark_from_string("call_site");
3504
3505 }
3506
3507 static void module_destroy()
3508 {
3509 }
3510
3511
3512 LTTV_MODULE("state", "State computation", \
3513     "Update the system state, possibly saving it at intervals", \
3514     module_init, module_destroy)
3515
3516
3517