1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
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;
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.
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,
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>
32 #define PREALLOCATED_EXECUTION_STACK 10
34 /* Facilities Quarks */
44 LTT_EVENT_SYSCALL_ENTRY
,
45 LTT_EVENT_SYSCALL_EXIT
,
50 LTT_EVENT_SCHEDCHANGE
,
71 LTTV_STATE_MODE_UNKNOWN
,
78 LTTV_STATE_SUBMODE_UNKNOWN
,
79 LTTV_STATE_SUBMODE_NONE
;
91 LTTV_STATE_TRACEFILES
,
94 LTTV_STATE_RUNNING_PROCESS
,
96 LTTV_STATE_SAVED_STATES
,
97 LTTV_STATE_SAVED_STATES_TIME
,
100 LTTV_STATE_NAME_TABLES
,
101 LTTV_STATE_TRACE_STATE_USE_COUNT
;
103 static void create_max_time(LttvTraceState
*tcs
);
105 static void get_max_time(LttvTraceState
*tcs
);
107 static void free_max_time(LttvTraceState
*tcs
);
109 static void create_name_tables(LttvTraceState
*tcs
);
111 static void get_name_tables(LttvTraceState
*tcs
);
113 static void free_name_tables(LttvTraceState
*tcs
);
115 static void free_saved_state(LttvTraceState
*tcs
);
117 static void lttv_state_free_process_table(GHashTable
*processes
);
120 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
122 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
126 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
128 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
132 void lttv_state_state_saved_free(LttvTraceState
*self
,
133 LttvAttribute
*container
)
135 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
139 guint
process_hash(gconstpointer key
)
141 guint pid
= ((const LttvProcessState
*)key
)->pid
;
142 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
146 /* If the hash table hash function is well distributed,
147 * the process_equal should compare different pid */
148 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
150 const LttvProcessState
*process_a
, *process_b
;
153 process_a
= (const LttvProcessState
*)a
;
154 process_b
= (const LttvProcessState
*)b
;
156 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
157 else if(likely(process_a
->pid
== 0 &&
158 process_a
->cpu
!= process_b
->cpu
)) ret
= FALSE
;
165 restore_init_state(LttvTraceState
*self
)
169 LttvTracefileState
*tfcs
;
171 /* Free the process tables */
172 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
173 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
176 /* Seek time to beginning */
177 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
178 // closest. It's the tracecontext job to seek the trace to the beginning
179 // anyway : the init state might be used at the middle of the trace as well...
180 //g_tree_destroy(self->parent.ts_context->pqueue);
181 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
184 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
186 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
188 /* Put the per cpu running_process to beginning state : process 0. */
189 for(i
=0; i
< nb_cpus
; i
++) {
190 self
->running_process
[i
] = lttv_state_create_process(self
, NULL
, i
, 0,
192 self
->running_process
[i
]->state
->s
= LTTV_STATE_RUN
;
193 self
->running_process
[i
]->cpu
= i
;
197 nb_tracefile
= self
->parent
.tracefiles
->len
;
199 for(i
= 0 ; i
< nb_tracefile
; i
++) {
201 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
202 LttvTracefileContext
*, i
));
203 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
204 // tfcs->saved_position = 0;
205 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
206 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
207 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
208 tfcs
->process
->last_cpu_index
= ltt_tracefile_num(((LttvTracefileContext
*)tfcs
)->tf
);
213 //static LttTime time_zero = {0,0};
216 init(LttvTracesetState
*self
, LttvTraceset
*ts
)
218 guint i
, j
, nb_trace
, nb_tracefile
;
220 LttvTraceContext
*tc
;
224 LttvTracefileState
*tfcs
;
226 LttvAttributeValue v
;
228 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
229 init((LttvTracesetContext
*)self
, ts
);
231 nb_trace
= lttv_traceset_number(ts
);
232 for(i
= 0 ; i
< nb_trace
; i
++) {
233 tc
= self
->parent
.traces
[i
];
234 tcs
= LTTV_TRACE_STATE(tc
);
235 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
236 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
240 if(*(v
.v_uint
) == 1) {
241 create_name_tables(tcs
);
242 create_max_time(tcs
);
244 get_name_tables(tcs
);
247 nb_tracefile
= tc
->tracefiles
->len
;
249 for(j
= 0 ; j
< nb_tracefile
; j
++) {
251 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
252 LttvTracefileContext
*, j
));
253 tfcs
->tracefile_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
256 tcs
->processes
= NULL
;
257 tcs
->running_process
= g_new(LttvProcessState
*,
258 ltt_trace_get_num_cpu(tc
->t
));
259 restore_init_state(tcs
);
265 fini(LttvTracesetState
*self
)
271 LttvTracefileState
*tfcs
;
273 LttvAttributeValue v
;
275 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
276 for(i
= 0 ; i
< nb_trace
; i
++) {
277 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
278 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
281 g_assert(*(v
.v_uint
) != 0);
284 if(*(v
.v_uint
) == 0) {
285 free_name_tables(tcs
);
287 free_saved_state(tcs
);
289 g_free(tcs
->running_process
);
290 tcs
->running_process
= NULL
;
291 lttv_state_free_process_table(tcs
->processes
);
292 tcs
->processes
= NULL
;
294 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
295 fini((LttvTracesetContext
*)self
);
299 static LttvTracesetContext
*
300 new_traceset_context(LttvTracesetContext
*self
)
302 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
306 static LttvTraceContext
*
307 new_trace_context(LttvTracesetContext
*self
)
309 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
313 static LttvTracefileContext
*
314 new_tracefile_context(LttvTracesetContext
*self
)
316 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
320 /* Write the process state of the trace */
322 static void write_process_state(gpointer key
, gpointer value
,
325 LttvProcessState
*process
;
327 LttvExecutionState
*es
;
329 FILE *fp
= (FILE *)user_data
;
333 process
= (LttvProcessState
*)value
;
335 " <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%u\">\n",
336 process
, process
->pid
, process
->ppid
, process
->creation_time
.tv_sec
,
337 process
->creation_time
.tv_nsec
, g_quark_to_string(process
->name
),
340 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
341 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
342 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
343 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
344 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
345 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
346 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
348 fprintf(fp
, " </PROCESS>\n");
352 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
354 guint i
, nb_tracefile
, nb_block
, offset
;
357 LttvTracefileState
*tfcs
;
361 LttEventPosition
*ep
;
365 ep
= ltt_event_position_new();
367 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
369 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
371 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
372 for(i
=0;i
<nb_cpus
;i
++) {
373 fprintf(fp
,"<CPU NUM=%u RUNNING_PROCESS=%u>\n",
374 i
, self
->running_process
[i
]->pid
);
377 nb_tracefile
= self
->parent
.tracefiles
->len
;
379 for(i
= 0 ; i
< nb_tracefile
; i
++) {
381 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
382 LttvTracefileContext
*, i
));
383 fprintf(fp
, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
384 tfcs
->parent
.timestamp
.tv_sec
,
385 tfcs
->parent
.timestamp
.tv_nsec
);
386 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
387 if(e
== NULL
) fprintf(fp
,"/>\n");
389 ltt_event_position(e
, ep
);
390 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
391 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block
, offset
,
396 fprintf(fp
,"</PROCESS_STATE>");
400 /* Copy each process from an existing hash table to a new one */
402 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
404 LttvProcessState
*process
, *new_process
;
406 GHashTable
*new_processes
= (GHashTable
*)user_data
;
410 process
= (LttvProcessState
*)value
;
411 new_process
= g_new(LttvProcessState
, 1);
412 *new_process
= *process
;
413 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
414 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
415 new_process
->execution_stack
=
416 g_array_set_size(new_process
->execution_stack
,
417 process
->execution_stack
->len
);
418 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
419 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
420 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
422 new_process
->state
= &g_array_index(new_process
->execution_stack
,
423 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
424 g_hash_table_insert(new_processes
, new_process
, new_process
);
428 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
430 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
432 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
433 return new_processes
;
437 /* The saved state for each trace contains a member "processes", which
438 stores a copy of the process table, and a member "tracefiles" with
439 one entry per tracefile. Each tracefile has a "process" member pointing
440 to the current process and a "position" member storing the tracefile
441 position (needed to seek to the current "next" event. */
443 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
445 guint i
, nb_tracefile
, nb_cpus
;
447 LttvTracefileState
*tfcs
;
449 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
451 guint
*running_process
;
453 LttvAttributeType type
;
455 LttvAttributeValue value
;
457 LttvAttributeName name
;
459 LttEventPosition
*ep
;
461 tracefiles_tree
= lttv_attribute_find_subdir(container
,
462 LTTV_STATE_TRACEFILES
);
464 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
466 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
468 /* Add the currently running processes array */
469 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
470 running_process
= g_new(guint
, nb_cpus
);
471 for(i
=0;i
<nb_cpus
;i
++) {
472 running_process
[i
] = self
->running_process
[i
]->pid
;
474 value
= lttv_attribute_add(container
, LTTV_STATE_RUNNING_PROCESS
,
476 *(value
.v_pointer
) = running_process
;
478 g_info("State save");
480 nb_tracefile
= self
->parent
.tracefiles
->len
;
482 for(i
= 0 ; i
< nb_tracefile
; i
++) {
484 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
485 LttvTracefileContext
*, i
));
486 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
487 value
= lttv_attribute_add(tracefiles_tree
, i
,
489 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
491 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
493 *(value
.v_uint
) = tfcs
->process
->pid
;
495 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
497 /* Only save the position if the tfs has not infinite time. */
498 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
499 // && current_tfcs != tfcs) {
500 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) == 0) {
501 *(value
.v_pointer
) = NULL
;
503 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
504 ep
= ltt_event_position_new();
505 ltt_event_position(e
, ep
);
506 *(value
.v_pointer
) = ep
;
508 guint nb_block
, offset
;
511 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
512 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block
, offset
,
514 tfcs
->parent
.timestamp
.tv_sec
, tfcs
->parent
.timestamp
.tv_nsec
);
520 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
522 guint i
, nb_tracefile
, pid
, nb_cpus
;
524 LttvTracefileState
*tfcs
;
526 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
528 guint
*running_process
;
530 LttvAttributeType type
;
532 LttvAttributeValue value
;
534 LttvAttributeName name
;
536 LttEventPosition
*ep
;
538 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
540 tracefiles_tree
= lttv_attribute_find_subdir(container
,
541 LTTV_STATE_TRACEFILES
);
543 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
545 g_assert(type
== LTTV_POINTER
);
546 lttv_state_free_process_table(self
->processes
);
547 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
549 /* Add the currently running processes array */
550 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
551 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
553 g_assert(type
== LTTV_POINTER
);
554 running_process
= *(value
.v_pointer
);
555 for(i
=0;i
<nb_cpus
;i
++) {
556 pid
= running_process
[i
];
557 self
->running_process
[i
] = lttv_state_find_process(self
, i
, pid
);
558 g_assert(self
->running_process
[i
] != NULL
);
562 nb_tracefile
= self
->parent
.tracefiles
->len
;
564 //g_tree_destroy(tsc->pqueue);
565 //tsc->pqueue = g_tree_new(compare_tracefile);
567 for(i
= 0 ; i
< nb_tracefile
; i
++) {
569 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
570 LttvTracefileContext
*, i
));
571 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
);
572 g_assert(type
== LTTV_GOBJECT
);
573 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
575 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
577 g_assert(type
== LTTV_UINT
);
578 pid
= *(value
.v_uint
);
579 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
581 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
583 g_assert(type
== LTTV_POINTER
);
584 //g_assert(*(value.v_pointer) != NULL);
585 ep
= *(value
.v_pointer
);
586 g_assert(tfcs
->parent
.t_context
!= NULL
);
588 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
589 g_tree_remove(tsc
->pqueue
, tfc
);
592 g_assert(ltt_tracefile_seek_position(tfc
->tf
, ep
) == 0);
593 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
594 g_assert(ltt_time_compare(tfc
->timestamp
, ltt_time_infinite
) != 0);
595 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
596 g_info("Restoring state for a tf at time %lu.%lu", tfc
->timestamp
.tv_sec
, tfc
->timestamp
.tv_nsec
);
598 tfc
->timestamp
= ltt_time_infinite
;
604 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
606 guint i
, nb_tracefile
, nb_cpus
;
608 LttvTracefileState
*tfcs
;
610 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
612 guint
*running_process
;
614 LttvAttributeType type
;
616 LttvAttributeValue value
;
618 LttvAttributeName name
;
620 LttEventPosition
*ep
;
622 tracefiles_tree
= lttv_attribute_find_subdir(container
,
623 LTTV_STATE_TRACEFILES
);
624 g_object_ref(G_OBJECT(tracefiles_tree
));
625 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
627 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
629 g_assert(type
== LTTV_POINTER
);
630 lttv_state_free_process_table(*(value
.v_pointer
));
631 *(value
.v_pointer
) = NULL
;
632 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
634 /* Free running processes array */
635 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
636 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
638 g_assert(type
== LTTV_POINTER
);
639 running_process
= *(value
.v_pointer
);
640 g_free(running_process
);
642 nb_tracefile
= self
->parent
.tracefiles
->len
;
644 for(i
= 0 ; i
< nb_tracefile
; i
++) {
646 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
647 LttvTracefileContext
*, i
));
648 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
);
649 g_assert(type
== LTTV_GOBJECT
);
650 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
652 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
654 g_assert(type
== LTTV_POINTER
);
655 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
657 g_object_unref(G_OBJECT(tracefiles_tree
));
661 static void free_saved_state(LttvTraceState
*self
)
665 LttvAttributeType type
;
667 LttvAttributeValue value
;
669 LttvAttributeName name
;
671 LttvAttribute
*saved_states
;
673 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
674 LTTV_STATE_SAVED_STATES
);
676 nb
= lttv_attribute_get_number(saved_states
);
677 for(i
= 0 ; i
< nb
; i
++) {
678 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
);
679 g_assert(type
== LTTV_GOBJECT
);
680 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
683 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
688 create_max_time(LttvTraceState
*tcs
)
690 LttvAttributeValue v
;
692 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
694 g_assert(*(v
.v_pointer
) == NULL
);
695 *(v
.v_pointer
) = g_new(LttTime
,1);
696 *((LttTime
*)*(v
.v_pointer
)) = ltt_time_zero
;
701 get_max_time(LttvTraceState
*tcs
)
703 LttvAttributeValue v
;
705 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
707 g_assert(*(v
.v_pointer
) != NULL
);
708 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
713 free_max_time(LttvTraceState
*tcs
)
715 LttvAttributeValue v
;
717 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
719 g_free(*(v
.v_pointer
));
720 *(v
.v_pointer
) = NULL
;
724 typedef struct _LttvNameTables
{
725 // FIXME GQuark *eventtype_names;
726 GQuark
*syscall_names
;
733 create_name_tables(LttvTraceState
*tcs
)
737 GQuark f_name
, e_name
;
741 LttvTraceHookByFacility
*thf
;
747 GString
*fe_name
= g_string_new("");
749 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
751 LttvAttributeValue v
;
753 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
755 g_assert(*(v
.v_pointer
) == NULL
);
756 *(v
.v_pointer
) = name_tables
;
757 #if 0 // Use iteration over the facilities_by_name and then list all event
758 // types of each facility
759 nb
= ltt_trace_eventtype_number(tcs
->parent
.t
);
760 name_tables
->eventtype_names
= g_new(GQuark
, nb
);
761 for(i
= 0 ; i
< nb
; i
++) {
762 et
= ltt_trace_eventtype_get(tcs
->parent
.t
, i
);
763 e_name
= ltt_eventtype_name(et
);
764 f_name
= ltt_facility_name(ltt_eventtype_facility(et
));
765 g_string_printf(fe_name
, "%s.%s", f_name
, e_name
);
766 name_tables
->eventtype_names
[i
] = g_quark_from_string(fe_name
->str
);
769 if(lttv_trace_find_hook(tcs
->parent
.t
,
770 LTT_FACILITY_KERNEL
, LTT_EVENT_SYSCALL_ENTRY
,
771 LTT_FIELD_SYSCALL_ID
, 0, 0,
775 thf
= lttv_trace_hook_get_first(&h
);
777 t
= ltt_field_type(thf
->f1
);
778 nb
= ltt_type_element_number(t
);
780 lttv_trace_hook_destroy(&h
);
782 /* CHECK syscalls should be an enum but currently are not!
783 name_tables->syscall_names = g_new(GQuark, nb);
785 for(i = 0 ; i < nb ; i++) {
786 name_tables->syscall_names[i] = g_quark_from_string(
787 ltt_enum_string_get(t, i));
791 name_tables
->syscall_names
= g_new(GQuark
, 256);
792 for(i
= 0 ; i
< 256 ; i
++) {
793 g_string_printf(fe_name
, "syscall %d", i
);
794 name_tables
->syscall_names
[i
] = g_quark_from_string(fe_name
->str
);
797 if(lttv_trace_find_hook(tcs
->parent
.t
, LTT_FACILITY_KERNEL
,
798 LTT_EVENT_TRAP_ENTRY
,
799 LTT_FIELD_TRAP_ID
, 0, 0,
803 thf
= lttv_trace_hook_get_first(&h
);
805 t
= ltt_field_type(thf
->f1
);
806 nb
= ltt_type_element_number(t
);
808 lttv_trace_hook_destroy(&h
);
811 name_tables->trap_names = g_new(GQuark, nb);
812 for(i = 0 ; i < nb ; i++) {
813 name_tables->trap_names[i] = g_quark_from_string(
814 ltt_enum_string_get(t, i));
818 name_tables
->trap_names
= g_new(GQuark
, 256);
819 for(i
= 0 ; i
< 256 ; i
++) {
820 g_string_printf(fe_name
, "trap %d", i
);
821 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
824 if(lttv_trace_find_hook(tcs
->parent
.t
,
825 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
826 LTT_FIELD_IRQ_ID
, 0, 0,
830 thf
= lttv_trace_hook_get_first(&h
);
832 t
= ltt_field_type(thf
->f1
);
833 nb
= ltt_type_element_number(t
);
835 lttv_trace_hook_destroy(&h
);
838 name_tables->irq_names = g_new(GQuark, nb);
839 for(i = 0 ; i < nb ; i++) {
840 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
844 name_tables
->irq_names
= g_new(GQuark
, 256);
845 for(i
= 0 ; i
< 256 ; i
++) {
846 g_string_printf(fe_name
, "irq %d", i
);
847 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
850 g_string_free(fe_name
, TRUE
);
855 get_name_tables(LttvTraceState
*tcs
)
857 LttvNameTables
*name_tables
;
859 LttvAttributeValue v
;
861 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
863 g_assert(*(v
.v_pointer
) != NULL
);
864 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
865 //tcs->eventtype_names = name_tables->eventtype_names;
866 tcs
->syscall_names
= name_tables
->syscall_names
;
867 tcs
->trap_names
= name_tables
->trap_names
;
868 tcs
->irq_names
= name_tables
->irq_names
;
873 free_name_tables(LttvTraceState
*tcs
)
875 LttvNameTables
*name_tables
;
877 LttvAttributeValue v
;
879 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
881 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
882 *(v
.v_pointer
) = NULL
;
884 // g_free(name_tables->eventtype_names);
885 g_free(name_tables
->syscall_names
);
886 g_free(name_tables
->trap_names
);
887 g_free(name_tables
->irq_names
);
891 #ifdef HASH_TABLE_DEBUG
893 static void test_process(gpointer key
, gpointer value
, gpointer user_data
)
895 LttvProcessState
*process
= (LttvProcessState
*)value
;
897 /* Test for process corruption */
898 guint stack_len
= process
->execution_stack
->len
;
901 static void hash_table_check(GHashTable
*table
)
903 g_hash_table_foreach(table
, test_process
, NULL
);
910 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
913 LttvExecutionState
*es
;
915 guint cpu
= ltt_tracefile_num(tfs
->parent
.tf
);
916 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
918 #ifdef HASH_TABLE_DEBUG
919 hash_table_check(ts
->processes
);
921 LttvProcessState
*process
= ts
->running_process
[cpu
];
923 guint depth
= process
->execution_stack
->len
;
925 process
->execution_stack
=
926 g_array_set_size(process
->execution_stack
, depth
+ 1);
929 &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
- 1);
931 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
934 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
935 es
->s
= process
->state
->s
;
940 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
942 guint cpu
= ltt_tracefile_num(tfs
->parent
.tf
);
943 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
944 LttvProcessState
*process
= ts
->running_process
[cpu
];
946 guint depth
= process
->execution_stack
->len
;
948 if(process
->state
->t
!= t
){
949 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
950 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
951 g_info("process state has %s when pop_int is %s\n",
952 g_quark_to_string(process
->state
->t
),
953 g_quark_to_string(t
));
954 g_info("{ %u, %u, %s, %s }\n",
957 g_quark_to_string(process
->name
),
958 g_quark_to_string(process
->state
->s
));
963 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
964 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
968 process
->execution_stack
=
969 g_array_set_size(process
->execution_stack
, depth
- 1);
970 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
972 process
->state
->change
= tfs
->parent
.timestamp
;
977 lttv_state_create_process(LttvTraceState
*tcs
, LttvProcessState
*parent
,
978 guint cpu
, guint pid
, const LttTime
*timestamp
)
980 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
982 LttvExecutionState
*es
;
984 LttvTraceContext
*tc
= (LttvTraceContext
*)tcs
;
990 //process->last_cpu = tfs->cpu_name;
991 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
992 g_info("Process %u, core %p", process
->pid
, process
);
993 g_hash_table_insert(tcs
->processes
, process
, process
);
996 process
->ppid
= parent
->pid
;
997 process
->name
= parent
->name
;
998 process
->creation_time
= *timestamp
;
1001 /* No parent. This process exists but we are missing all information about
1002 its creation. The birth time is set to zero but we remember the time of
1007 process
->name
= LTTV_STATE_UNNAMED
;
1008 process
->creation_time
= ltt_time_zero
;
1011 process
->insertion_time
= *timestamp
;
1012 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
1013 process
->creation_time
.tv_nsec
);
1014 process
->pid_time
= g_quark_from_string(buffer
);
1016 //process->last_cpu = tfs->cpu_name;
1017 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1018 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1019 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1020 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
1021 es
= process
->state
= &g_array_index(process
->execution_stack
,
1022 LttvExecutionState
, 0);
1023 es
->t
= LTTV_STATE_USER_MODE
;
1024 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1025 es
->entry
= *timestamp
;
1026 //g_assert(timestamp->tv_sec != 0);
1027 es
->change
= *timestamp
;
1028 es
->s
= LTTV_STATE_WAIT_FORK
;
1033 LttvProcessState
*lttv_state_find_process(LttvTraceState
*ts
, guint cpu
,
1036 LttvProcessState key
;
1037 LttvProcessState
*process
;
1041 process
= g_hash_table_lookup(ts
->processes
, &key
);
1046 lttv_state_find_process_or_create(LttvTraceState
*ts
, guint cpu
, guint pid
,
1049 LttvProcessState
*process
= lttv_state_find_process(ts
, cpu
, pid
);
1051 /* Put ltt_time_zero creation time for unexisting processes */
1052 if(unlikely(process
== NULL
)) process
= lttv_state_create_process(ts
,
1053 NULL
, cpu
, pid
, timestamp
);
1057 /* FIXME : this function should be called when we receive an event telling that
1058 * release_task has been called in the kernel. In happens generally when
1059 * the parent waits for its child terminaison, but may also happen in special
1060 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1061 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1062 * of a killed thread ground, but isn't the leader.
1064 static void exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
1066 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
1067 LttvProcessState key
;
1069 key
.pid
= process
->pid
;
1070 key
.cpu
= process
->cpu
;
1071 g_hash_table_remove(ts
->processes
, &key
);
1072 g_array_free(process
->execution_stack
, TRUE
);
1077 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1079 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
1084 static void lttv_state_free_process_table(GHashTable
*processes
)
1086 g_hash_table_foreach(processes
, free_process_state
, NULL
);
1087 g_hash_table_destroy(processes
);
1091 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
1093 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1094 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1095 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1096 LttField
*f
= thf
->f1
;
1098 LttvExecutionSubmode submode
;
1100 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->syscall_names
[
1101 ltt_event_get_unsigned(e
, f
)];
1102 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
1107 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
1109 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1111 pop_state(s
, LTTV_STATE_SYSCALL
);
1116 static gboolean
trap_entry(void *hook_data
, void *call_data
)
1118 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1119 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1120 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1121 LttField
*f
= thf
->f1
;
1123 LttvExecutionSubmode submode
;
1125 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->trap_names
[
1126 ltt_event_get_unsigned(e
, f
)];
1127 push_state(s
, LTTV_STATE_TRAP
, submode
);
1132 static gboolean
trap_exit(void *hook_data
, void *call_data
)
1134 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1136 pop_state(s
, LTTV_STATE_TRAP
);
1141 static gboolean
irq_entry(void *hook_data
, void *call_data
)
1143 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1144 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1145 guint8 fac_id
= ltt_event_facility_id(e
);
1146 guint8 ev_id
= ltt_event_eventtype_id(e
);
1147 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1148 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1149 g_assert(thf
->f1
!= NULL
);
1150 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1151 LttField
*f
= thf
->f1
;
1153 LttvExecutionSubmode submode
;
1155 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->irq_names
[
1156 ltt_event_get_unsigned(e
, f
)];
1158 /* Do something with the info about being in user or system mode when int? */
1159 push_state(s
, LTTV_STATE_IRQ
, submode
);
1164 static gboolean
irq_exit(void *hook_data
, void *call_data
)
1166 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1168 pop_state(s
, LTTV_STATE_IRQ
);
1173 static gboolean
schedchange(void *hook_data
, void *call_data
)
1175 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1176 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1177 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1178 LttvProcessState
*process
= ts
->running_process
[cpu
];
1180 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1181 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1182 guint pid_in
, pid_out
;
1185 pid_out
= ltt_event_get_unsigned(e
, thf
->f1
);
1186 pid_in
= ltt_event_get_unsigned(e
, thf
->f2
);
1187 state_out
= ltt_event_get_int(e
, thf
->f3
);
1189 if(likely(process
!= NULL
)) {
1191 /* We could not know but it was not the idle process executing.
1192 This should only happen at the beginning, before the first schedule
1193 event, and when the initial information (current process for each CPU)
1194 is missing. It is not obvious how we could, after the fact, compensate
1195 the wrongly attributed statistics. */
1197 //This test only makes sense once the state is known and if there is no
1199 //if(unlikely(process->pid != pid_out)) {
1200 // g_assert(process->pid == 0);
1203 if(unlikely(process
->state
->s
== LTTV_STATE_EXIT
)) {
1204 process
->state
->s
= LTTV_STATE_ZOMBIE
;
1206 if(unlikely(state_out
== 0)) process
->state
->s
= LTTV_STATE_WAIT_CPU
;
1207 else process
->state
->s
= LTTV_STATE_WAIT
;
1208 } /* FIXME : we do not remove process here, because the kernel
1209 * still has them : they may be zombies. We need to know
1210 * exactly when release_task is executed on the PID to
1211 * know when the zombie is destroyed.
1214 // exit_process(s, process);
1216 process
->state
->change
= s
->parent
.timestamp
;
1218 process
= ts
->running_process
[cpu
] =
1219 lttv_state_find_process_or_create(
1220 (LttvTraceState
*)s
->parent
.t_context
,
1222 &s
->parent
.timestamp
);
1223 process
->state
->s
= LTTV_STATE_RUN
;
1225 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
1226 process
->state
->change
= s
->parent
.timestamp
;
1230 static gboolean
process_fork(void *hook_data
, void *call_data
)
1232 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1233 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1234 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1238 LttvProcessState
*zombie_process
;
1239 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1240 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1241 LttvProcessState
*process
= ts
->running_process
[cpu
];
1242 LttvProcessState
*child_process
;
1246 parent_pid
= ltt_event_get_unsigned(e
, f
);
1250 child_pid
= ltt_event_get_unsigned(e
, f
);
1252 /* Mathieu : it seems like the process might have been scheduled in before the
1253 * fork, and, in a rare case, might be the current process. This might happen
1254 * in a SMP case where we don't have enough precision on the clocks */
1256 zombie_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1258 if(unlikely(zombie_process
!= NULL
)) {
1259 /* Reutilisation of PID. Only now we are sure that the old PID
1260 * has been released. FIXME : should know when release_task happens instead.
1262 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
1264 for(i
=0; i
< num_cpus
; i
++) {
1265 g_assert(process
!= ts
->running_process
[i
]);
1268 exit_process(s
, zombie_process
);
1271 g_assert(process
->pid
!= child_pid
);
1272 // FIXME : Add this test in the "known state" section
1273 // g_assert(process->pid == parent_pid);
1274 child_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1275 if(child_process
== NULL
) {
1276 lttv_state_create_process(ts
, process
, cpu
,
1277 child_pid
, &s
->parent
.timestamp
);
1279 /* The process has already been created : due to time imprecision between
1280 * multiple CPUs : it has been scheduled in before creation.
1282 * Simply put a correct parent.
1284 child_process
->ppid
= process
->pid
;
1291 static gboolean
process_exit(void *hook_data
, void *call_data
)
1293 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1294 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1295 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1298 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1299 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1300 LttvProcessState
*process
= ts
->running_process
[cpu
];
1302 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1304 // FIXME : Add this test in the "known state" section
1305 // g_assert(process->pid == pid);
1307 if(likely(process
!= NULL
)) {
1308 process
->state
->s
= LTTV_STATE_EXIT
;
1313 static gboolean
process_free(void *hook_data
, void *call_data
)
1315 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1316 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1317 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1318 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1320 LttvProcessState
*process
;
1322 /* PID of the process to release */
1323 release_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1325 g_assert(release_pid
!= 0);
1327 process
= lttv_state_find_process(ts
, ANY_CPU
, release_pid
);
1329 if(likely(process
!= NULL
)) {
1330 /* release_task is happening at kernel level : we can now safely release
1331 * the data structure of the process */
1332 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
1334 for(i
=0; i
< num_cpus
; i
++) {
1335 g_assert(process
!= ts
->running_process
[i
]);
1337 exit_process(s
, process
);
1344 static gboolean
process_exec(void *hook_data
, void *call_data
)
1346 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1347 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1348 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1349 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1351 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1352 LttvProcessState
*process
= ts
->running_process
[cpu
];
1354 /* PID of the process to release */
1355 name
= ltt_event_get_string(e
, thf
->f1
);
1357 process
->name
= g_quark_from_string(name
);
1365 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
1367 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1369 lttv_state_add_event_hooks(tss
);
1374 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
1376 LttvTraceset
*traceset
= self
->parent
.ts
;
1378 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1382 LttvTracefileState
*tfs
;
1386 LttvTraceHookByFacility
*thf
;
1388 LttvTraceHook
*hook
;
1390 LttvAttributeValue val
;
1394 nb_trace
= lttv_traceset_number(traceset
);
1395 for(i
= 0 ; i
< nb_trace
; i
++) {
1396 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1398 /* Find the eventtype id for the following events and register the
1399 associated by id hooks. */
1401 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 11);
1402 hooks
= g_array_set_size(hooks
, 11);
1404 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1405 LTT_FACILITY_KERNEL
, LTT_EVENT_SYSCALL_ENTRY
,
1406 LTT_FIELD_SYSCALL_ID
, 0, 0,
1407 syscall_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 0));
1410 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1411 LTT_FACILITY_KERNEL
, LTT_EVENT_SYSCALL_EXIT
,
1413 syscall_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 1));
1416 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1417 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_ENTRY
,
1418 LTT_FIELD_TRAP_ID
, 0, 0,
1419 trap_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 2));
1422 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1423 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_EXIT
,
1425 trap_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 3));
1428 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1429 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
1430 LTT_FIELD_IRQ_ID
, 0, 0,
1431 irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 4));
1434 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1435 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_EXIT
,
1437 irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 5));
1440 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1441 LTT_FACILITY_PROCESS
, LTT_EVENT_SCHEDCHANGE
,
1442 LTT_FIELD_OUT
, LTT_FIELD_IN
, LTT_FIELD_OUT_STATE
,
1443 schedchange
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 6));
1446 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1447 LTT_FACILITY_PROCESS
, LTT_EVENT_FORK
,
1448 LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
, 0,
1449 process_fork
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 7));
1452 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1453 LTT_FACILITY_PROCESS
, LTT_EVENT_EXIT
,
1454 LTT_FIELD_PID
, 0, 0,
1455 process_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 8));
1458 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1459 LTT_FACILITY_PROCESS
, LTT_EVENT_FREE
,
1460 LTT_FIELD_PID
, 0, 0,
1461 process_free
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 9));
1464 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1465 LTT_FACILITY_FS
, LTT_EVENT_EXEC
,
1466 LTT_FIELD_FILENAME
, 0, 0,
1467 process_exec
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 10));
1472 /* Add these hooks to each event_by_id hooks list */
1474 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1476 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1478 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1479 LttvTracefileContext
*, j
));
1481 for(k
= 0 ; k
< hooks
->len
; k
++) {
1482 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
1483 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
1484 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
1486 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
1493 lttv_attribute_find(self
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
1494 *(val
.v_pointer
) = hooks
;
1498 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1500 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1502 lttv_state_remove_event_hooks(tss
);
1507 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
1509 LttvTraceset
*traceset
= self
->parent
.ts
;
1511 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1515 LttvTracefileState
*tfs
;
1519 LttvTraceHook
*hook
;
1521 LttvTraceHookByFacility
*thf
;
1523 LttvAttributeValue val
;
1525 nb_trace
= lttv_traceset_number(traceset
);
1526 for(i
= 0 ; i
< nb_trace
; i
++) {
1527 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
1528 lttv_attribute_find(self
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
1529 hooks
= *(val
.v_pointer
);
1531 /* Remove these hooks from each event_by_id hooks list */
1533 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1535 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1537 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1538 LttvTracefileContext
*, j
));
1540 for(k
= 0 ; k
< hooks
->len
; k
++) {
1541 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
1542 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
1543 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
1545 lttv_hooks_remove_data(
1546 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
1552 for(k
= 0 ; k
< hooks
->len
; k
++)
1553 lttv_trace_hook_destroy(&g_array_index(hooks
, LttvTraceHook
, k
));
1554 g_array_free(hooks
, TRUE
);
1558 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
1560 guint
*event_count
= (guint
*)hook_data
;
1562 /* Only save at LTTV_STATE_SAVE_INTERVAL */
1563 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
1568 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1570 LttvTracefileState
*tfcs
;
1572 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1574 LttEventPosition
*ep
;
1580 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1582 LttvAttributeValue value
;
1584 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1585 LTTV_STATE_SAVED_STATES
);
1586 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1587 value
= lttv_attribute_add(saved_states_tree
,
1588 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1589 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1590 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1591 *(value
.v_time
) = self
->parent
.timestamp
;
1592 lttv_state_save(tcs
, saved_state_tree
);
1593 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
1594 self
->parent
.timestamp
.tv_nsec
);
1596 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1601 static gboolean
state_save_after_trace_hook(void *hook_data
, void *call_data
)
1603 LttvTraceState
*tcs
= (LttvTraceState
*)(call_data
);
1605 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
1611 static gboolean
block_start(void *hook_data
, void *call_data
)
1613 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1615 LttvTracefileState
*tfcs
;
1617 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1619 LttEventPosition
*ep
;
1621 guint i
, nb_block
, nb_event
, nb_tracefile
;
1625 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1627 LttvAttributeValue value
;
1629 ep
= ltt_event_position_new();
1631 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
1633 /* Count the number of events added since the last block end in any
1636 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1638 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
1639 LttvTracefileContext
, i
));
1640 ltt_event_position(tfcs
->parent
.e
, ep
);
1641 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
1642 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
1643 tfcs
->saved_position
= nb_event
;
1647 if(tcs
->nb_event
>= tcs
->save_interval
) {
1648 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1649 LTTV_STATE_SAVED_STATES
);
1650 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1651 value
= lttv_attribute_add(saved_states_tree
,
1652 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1653 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1654 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1655 *(value
.v_time
) = self
->parent
.timestamp
;
1656 lttv_state_save(tcs
, saved_state_tree
);
1658 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
1659 self
->parent
.timestamp
.tv_nsec
);
1661 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1667 static gboolean
block_end(void *hook_data
, void *call_data
)
1669 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1671 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1675 LttEventPosition
*ep
;
1677 guint nb_block
, nb_event
;
1679 ep
= ltt_event_position_new();
1680 ltt_event_position(self
->parent
.e
, ep
);
1681 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
1682 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
1683 self
->saved_position
= 0;
1684 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1691 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
1693 LttvTraceset
*traceset
= self
->parent
.ts
;
1695 guint i
, j
, nb_trace
, nb_tracefile
;
1699 LttvTracefileState
*tfs
;
1701 LttvTraceHook hook_start
, hook_end
;
1703 nb_trace
= lttv_traceset_number(traceset
);
1704 for(i
= 0 ; i
< nb_trace
; i
++) {
1705 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1707 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
1708 NULL
, NULL
, block_start
, &hook_start
);
1709 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
1710 NULL
, NULL
, block_end
, &hook_end
);
1712 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1714 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1716 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
1717 LttvTracefileContext
, j
));
1718 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
1719 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
1720 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
1721 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
1727 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
1729 LttvTraceset
*traceset
= self
->parent
.ts
;
1731 guint i
, j
, nb_trace
, nb_tracefile
;
1735 LttvTracefileState
*tfs
;
1738 nb_trace
= lttv_traceset_number(traceset
);
1739 for(i
= 0 ; i
< nb_trace
; i
++) {
1741 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1742 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1744 guint
*event_count
= g_new(guint
, 1);
1747 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1749 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1750 LttvTracefileContext
*, j
));
1751 lttv_hooks_add(tfs
->parent
.event
,
1752 state_save_event_hook
,
1759 lttv_process_traceset_begin(&self
->parent
,
1760 NULL
, NULL
, NULL
, NULL
, NULL
);
1764 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
1766 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1768 lttv_state_save_add_event_hooks(tss
);
1775 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
1777 LttvTraceset
*traceset
= self
->parent
.ts
;
1779 guint i
, j
, nb_trace
, nb_tracefile
;
1783 LttvTracefileState
*tfs
;
1785 LttvTraceHook hook_start
, hook_end
;
1787 nb_trace
= lttv_traceset_number(traceset
);
1788 for(i
= 0 ; i
< nb_trace
; i
++) {
1789 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
1791 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
1792 NULL
, NULL
, block_start
, &hook_start
);
1794 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
1795 NULL
, NULL
, block_end
, &hook_end
);
1797 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1799 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1801 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
1802 LttvTracefileContext
, j
));
1803 lttv_hooks_remove_data(lttv_hooks_by_id_find(
1804 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
1805 lttv_hooks_remove_data(lttv_hooks_by_id_find(
1806 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
1812 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
1814 LttvTraceset
*traceset
= self
->parent
.ts
;
1816 guint i
, j
, nb_trace
, nb_tracefile
;
1820 LttvTracefileState
*tfs
;
1822 LttvHooks
*after_trace
= lttv_hooks_new();
1824 lttv_hooks_add(after_trace
,
1825 state_save_after_trace_hook
,
1830 lttv_process_traceset_end(&self
->parent
,
1831 NULL
, after_trace
, NULL
, NULL
, NULL
);
1833 lttv_hooks_destroy(after_trace
);
1835 nb_trace
= lttv_traceset_number(traceset
);
1836 for(i
= 0 ; i
< nb_trace
; i
++) {
1838 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1839 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1843 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1845 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1846 LttvTracefileContext
*, j
));
1847 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
1848 state_save_event_hook
);
1850 g_free(event_count
);
1854 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1856 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1858 lttv_state_save_remove_event_hooks(tss
);
1863 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
1865 LttvTraceset
*traceset
= self
->parent
.ts
;
1869 int min_pos
, mid_pos
, max_pos
;
1871 guint call_rest
= 0;
1873 LttvTraceState
*tcs
;
1875 LttvAttributeValue value
;
1877 LttvAttributeType type
;
1879 LttvAttributeName name
;
1881 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
;
1883 //g_tree_destroy(self->parent.pqueue);
1884 //self->parent.pqueue = g_tree_new(compare_tracefile);
1886 g_info("Entering seek_time_closest for time %lu.%lu", t
.tv_sec
, t
.tv_nsec
);
1888 nb_trace
= lttv_traceset_number(traceset
);
1889 for(i
= 0 ; i
< nb_trace
; i
++) {
1890 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
1892 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
1893 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1894 LTTV_STATE_SAVED_STATES
);
1897 if(saved_states_tree
) {
1898 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
1899 mid_pos
= max_pos
/ 2;
1900 while(min_pos
< max_pos
) {
1901 type
= lttv_attribute_get(saved_states_tree
, mid_pos
, &name
, &value
);
1902 g_assert(type
== LTTV_GOBJECT
);
1903 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1904 type
= lttv_attribute_get_by_name(saved_state_tree
, LTTV_STATE_TIME
,
1906 g_assert(type
== LTTV_TIME
);
1907 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
1909 closest_tree
= saved_state_tree
;
1911 else max_pos
= mid_pos
- 1;
1913 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
1917 /* restore the closest earlier saved state */
1919 lttv_state_restore(tcs
, closest_tree
);
1923 /* There is no saved state, yet we want to have it. Restart at T0 */
1925 restore_init_state(tcs
);
1926 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
1929 /* We want to seek quickly without restoring/updating the state */
1931 restore_init_state(tcs
);
1932 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
1935 if(!call_rest
) g_info("NOT Calling restore");
1940 traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
1946 traceset_state_finalize (LttvTracesetState
*self
)
1948 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
1949 finalize(G_OBJECT(self
));
1954 traceset_state_class_init (LttvTracesetContextClass
*klass
)
1956 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
1958 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
1959 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
1960 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
1961 klass
->new_traceset_context
= new_traceset_context
;
1962 klass
->new_trace_context
= new_trace_context
;
1963 klass
->new_tracefile_context
= new_tracefile_context
;
1968 lttv_traceset_state_get_type(void)
1970 static GType type
= 0;
1972 static const GTypeInfo info
= {
1973 sizeof (LttvTracesetStateClass
),
1974 NULL
, /* base_init */
1975 NULL
, /* base_finalize */
1976 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
1977 NULL
, /* class_finalize */
1978 NULL
, /* class_data */
1979 sizeof (LttvTracesetState
),
1980 0, /* n_preallocs */
1981 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
1982 NULL
/* value handling */
1985 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
1993 trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
1999 trace_state_finalize (LttvTraceState
*self
)
2001 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
2002 finalize(G_OBJECT(self
));
2007 trace_state_class_init (LttvTraceStateClass
*klass
)
2009 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2011 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
2012 klass
->state_save
= state_save
;
2013 klass
->state_restore
= state_restore
;
2014 klass
->state_saved_free
= state_saved_free
;
2019 lttv_trace_state_get_type(void)
2021 static GType type
= 0;
2023 static const GTypeInfo info
= {
2024 sizeof (LttvTraceStateClass
),
2025 NULL
, /* base_init */
2026 NULL
, /* base_finalize */
2027 (GClassInitFunc
) trace_state_class_init
, /* class_init */
2028 NULL
, /* class_finalize */
2029 NULL
, /* class_data */
2030 sizeof (LttvTraceState
),
2031 0, /* n_preallocs */
2032 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
2033 NULL
/* value handling */
2036 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
2037 "LttvTraceStateType", &info
, 0);
2044 tracefile_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
2050 tracefile_state_finalize (LttvTracefileState
*self
)
2052 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
2053 finalize(G_OBJECT(self
));
2058 tracefile_state_class_init (LttvTracefileStateClass
*klass
)
2060 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2062 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
2067 lttv_tracefile_state_get_type(void)
2069 static GType type
= 0;
2071 static const GTypeInfo info
= {
2072 sizeof (LttvTracefileStateClass
),
2073 NULL
, /* base_init */
2074 NULL
, /* base_finalize */
2075 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
2076 NULL
, /* class_finalize */
2077 NULL
, /* class_data */
2078 sizeof (LttvTracefileState
),
2079 0, /* n_preallocs */
2080 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
2081 NULL
/* value handling */
2084 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
2085 "LttvTracefileStateType", &info
, 0);
2091 static void module_init()
2093 LTTV_STATE_UNNAMED
= g_quark_from_string("unnamed");
2094 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("unknown execution mode");
2095 LTTV_STATE_USER_MODE
= g_quark_from_string("user mode");
2096 LTTV_STATE_WAIT_FORK
= g_quark_from_string("wait fork");
2097 LTTV_STATE_SYSCALL
= g_quark_from_string("system call");
2098 LTTV_STATE_TRAP
= g_quark_from_string("trap");
2099 LTTV_STATE_IRQ
= g_quark_from_string("irq");
2100 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("unknown submode");
2101 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("(no submode)");
2102 LTTV_STATE_WAIT_CPU
= g_quark_from_string("wait for cpu");
2103 LTTV_STATE_EXIT
= g_quark_from_string("exiting");
2104 LTTV_STATE_ZOMBIE
= g_quark_from_string("zombie");
2105 LTTV_STATE_WAIT
= g_quark_from_string("wait for I/O");
2106 LTTV_STATE_RUN
= g_quark_from_string("running");
2107 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
2108 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
2109 LTTV_STATE_PROCESS
= g_quark_from_string("process");
2110 LTTV_STATE_RUNNING_PROCESS
= g_quark_from_string("running_process");
2111 LTTV_STATE_EVENT
= g_quark_from_string("event");
2112 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
2113 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
2114 LTTV_STATE_TIME
= g_quark_from_string("time");
2115 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
2116 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
2117 LTTV_STATE_TRACE_STATE_USE_COUNT
=
2118 g_quark_from_string("trace_state_use_count");
2121 LTT_FACILITY_KERNEL
= g_quark_from_string("kernel");
2122 LTT_FACILITY_PROCESS
= g_quark_from_string("process");
2123 LTT_FACILITY_FS
= g_quark_from_string("fs");
2126 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
2127 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
2128 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
2129 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
2130 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
2131 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
2132 LTT_EVENT_SCHEDCHANGE
= g_quark_from_string("schedchange");
2133 LTT_EVENT_FORK
= g_quark_from_string("fork");
2134 LTT_EVENT_EXIT
= g_quark_from_string("exit");
2135 LTT_EVENT_FREE
= g_quark_from_string("free");
2136 LTT_EVENT_EXEC
= g_quark_from_string("exec");
2139 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
2140 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
2141 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
2142 LTT_FIELD_OUT
= g_quark_from_string("out");
2143 LTT_FIELD_IN
= g_quark_from_string("in");
2144 LTT_FIELD_OUT_STATE
= g_quark_from_string("out_state");
2145 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
2146 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
2147 LTT_FIELD_PID
= g_quark_from_string("pid");
2148 LTT_FIELD_FILENAME
= g_quark_from_string("filename");
2152 static void module_destroy()
2157 LTTV_MODULE("state", "State computation", \
2158 "Update the system state, possibly saving it at intervals", \
2159 module_init
, module_destroy
)