ltt/branches/poly/lttv/lttv/state.c

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