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 */
43 LTT_EVENT_SYSCALL_ENTRY
,
44 LTT_EVENT_SYSCALL_EXIT
,
49 LTT_EVENT_SCHEDCHANGE
,
68 LTTV_STATE_MODE_UNKNOWN
,
75 LTTV_STATE_SUBMODE_UNKNOWN
,
76 LTTV_STATE_SUBMODE_NONE
;
88 LTTV_STATE_TRACEFILES
,
92 LTTV_STATE_SAVED_STATES
,
93 LTTV_STATE_SAVED_STATES_TIME
,
96 LTTV_STATE_NAME_TABLES
,
97 LTTV_STATE_TRACE_STATE_USE_COUNT
;
99 static void create_max_time(LttvTraceState
*tcs
);
101 static void get_max_time(LttvTraceState
*tcs
);
103 static void free_max_time(LttvTraceState
*tcs
);
105 static void create_name_tables(LttvTraceState
*tcs
);
107 static void get_name_tables(LttvTraceState
*tcs
);
109 static void free_name_tables(LttvTraceState
*tcs
);
111 static void free_saved_state(LttvTraceState
*tcs
);
113 static void lttv_state_free_process_table(GHashTable
*processes
);
116 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
118 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
122 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
124 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
128 void lttv_state_state_saved_free(LttvTraceState
*self
,
129 LttvAttribute
*container
)
131 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
135 guint
process_hash(gconstpointer key
)
137 guint pid
= ((const LttvProcessState
*)key
)->pid
;
138 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
142 /* If the hash table hash function is well distributed,
143 * the process_equal should compare different pid */
144 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
146 const LttvProcessState
*process_a
, *process_b
;
149 process_a
= (const LttvProcessState
*)a
;
150 process_b
= (const LttvProcessState
*)b
;
152 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
153 else if(likely(process_a
->pid
== 0 &&
154 process_a
->last_cpu
!= process_b
->last_cpu
)) ret
= FALSE
;
161 restore_init_state(LttvTraceState
*self
)
163 guint i
, nb_tracefile
;
165 LttvTracefileState
*tfcs
;
167 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
168 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
171 nb_tracefile
= self
->parent
.tracefiles
->len
;
173 for(i
= 0 ; i
< nb_tracefile
; i
++) {
175 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
176 LttvTracefileContext
*, i
));
177 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
178 // tfcs->saved_position = 0;
179 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
180 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
181 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
182 tfcs
->process
->last_cpu_index
= ((LttvTracefileContext
*)tfcs
)->index
;
186 static LttTime time_zero
= {0,0};
189 init(LttvTracesetState
*self
, LttvTraceset
*ts
)
191 guint i
, j
, nb_trace
, nb_tracefile
;
193 LttvTraceContext
*tc
;
197 LttvTracefileState
*tfcs
;
199 LttvAttributeValue v
;
201 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
202 init((LttvTracesetContext
*)self
, ts
);
204 nb_trace
= lttv_traceset_number(ts
);
205 for(i
= 0 ; i
< nb_trace
; i
++) {
206 tc
= self
->parent
.traces
[i
];
207 tcs
= (LttvTraceState
*)tc
;
208 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
209 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
213 if(*(v
.v_uint
) == 1) {
214 create_name_tables(tcs
);
215 create_max_time(tcs
);
217 get_name_tables(tcs
);
220 nb_tracefile
= tc
->tracefiles
->len
;
222 for(j
= 0 ; j
< nb_tracefile
; j
++) {
224 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
225 LttvTracefileContext
*, j
));
226 tfcs
->cpu_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
228 tcs
->processes
= NULL
;
229 restore_init_state(tcs
);
235 fini(LttvTracesetState
*self
)
241 LttvTracefileState
*tfcs
;
243 LttvAttributeValue v
;
245 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
246 for(i
= 0 ; i
< nb_trace
; i
++) {
247 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
248 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
251 g_assert(*(v
.v_uint
) != 0);
254 if(*(v
.v_uint
) == 0) {
255 free_name_tables(tcs
);
257 free_saved_state(tcs
);
259 lttv_state_free_process_table(tcs
->processes
);
260 tcs
->processes
= NULL
;
262 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
263 fini((LttvTracesetContext
*)self
);
267 static LttvTracesetContext
*
268 new_traceset_context(LttvTracesetContext
*self
)
270 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
274 static LttvTraceContext
*
275 new_trace_context(LttvTracesetContext
*self
)
277 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
281 static LttvTracefileContext
*
282 new_tracefile_context(LttvTracesetContext
*self
)
284 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
288 /* Write the process state of the trace */
290 static void write_process_state(gpointer key
, gpointer value
,
293 LttvProcessState
*process
;
295 LttvExecutionState
*es
;
297 FILE *fp
= (FILE *)user_data
;
301 process
= (LttvProcessState
*)value
;
303 " <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%s\">\n",
304 process
, process
->pid
, process
->ppid
, process
->creation_time
.tv_sec
,
305 process
->creation_time
.tv_nsec
, g_quark_to_string(process
->name
),
306 g_quark_to_string(process
->last_cpu
));
308 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
309 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
310 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
311 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
312 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
313 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
314 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
316 fprintf(fp
, " </PROCESS>\n");
320 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
322 guint i
, nb_tracefile
, nb_block
, offset
;
325 LttvTracefileState
*tfcs
;
329 LttEventPosition
*ep
;
331 ep
= ltt_event_position_new();
333 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
335 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
337 nb_tracefile
= self
->parent
.tracefiles
->len
;
339 for(i
= 0 ; i
< nb_tracefile
; i
++) {
341 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
342 LttvTracefileContext
*, i
));
343 fprintf(fp
, " <TRACEFILE PID=%u TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
344 tfcs
->process
->pid
, tfcs
->parent
.timestamp
.tv_sec
,
345 tfcs
->parent
.timestamp
.tv_nsec
);
346 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
347 if(e
== NULL
) fprintf(fp
,"/>\n");
349 ltt_event_position(e
, ep
);
350 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
351 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block
, offset
,
356 fprintf(fp
,"</PROCESS_STATE>");
360 /* Copy each process from an existing hash table to a new one */
362 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
364 LttvProcessState
*process
, *new_process
;
366 GHashTable
*new_processes
= (GHashTable
*)user_data
;
370 process
= (LttvProcessState
*)value
;
371 new_process
= g_new(LttvProcessState
, 1);
372 *new_process
= *process
;
373 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
374 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
375 g_array_set_size(new_process
->execution_stack
,process
->execution_stack
->len
);
376 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
377 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
378 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
380 new_process
->state
= &g_array_index(new_process
->execution_stack
,
381 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
382 g_hash_table_insert(new_processes
, new_process
, new_process
);
386 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
388 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
390 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
391 return new_processes
;
395 /* The saved state for each trace contains a member "processes", which
396 stores a copy of the process table, and a member "tracefiles" with
397 one entry per tracefile. Each tracefile has a "process" member pointing
398 to the current process and a "position" member storing the tracefile
399 position (needed to seek to the current "next" event. */
401 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
403 guint i
, nb_tracefile
;
405 LttvTracefileState
*tfcs
;
407 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
409 LttvAttributeType type
;
411 LttvAttributeValue value
;
413 LttvAttributeName name
;
415 LttEventPosition
*ep
;
417 tracefiles_tree
= lttv_attribute_find_subdir(container
,
418 LTTV_STATE_TRACEFILES
);
420 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
422 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
424 nb_tracefile
= self
->parent
.tracefiles
->len
;
426 for(i
= 0 ; i
< nb_tracefile
; i
++) {
428 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
429 LttvTracefileContext
*, i
));
430 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
431 value
= lttv_attribute_add(tracefiles_tree
, i
,
433 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
434 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
436 *(value
.v_uint
) = tfcs
->process
->pid
;
437 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
439 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
440 if(e
== NULL
) *(value
.v_pointer
) = NULL
;
442 ep
= ltt_event_position_new();
443 ltt_event_position(e
, ep
);
444 *(value
.v_pointer
) = ep
;
446 guint nb_block
, offset
;
449 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
450 g_debug("Block %u offset %u tsc %llu time %lu.%lu", nb_block
, offset
,
452 tfcs
->parent
.timestamp
.tv_sec
, tfcs
->parent
.timestamp
.tv_nsec
);
458 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
460 guint i
, nb_tracefile
, pid
;
462 LttvTracefileState
*tfcs
;
464 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
466 LttvAttributeType type
;
468 LttvAttributeValue value
;
470 LttvAttributeName name
;
472 LttEventPosition
*ep
;
474 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
476 tracefiles_tree
= lttv_attribute_find_subdir(container
,
477 LTTV_STATE_TRACEFILES
);
479 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
481 g_assert(type
== LTTV_POINTER
);
482 lttv_state_free_process_table(self
->processes
);
483 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
485 nb_tracefile
= self
->parent
.tracefiles
->len
;
487 for(i
= 0 ; i
< nb_tracefile
; i
++) {
489 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
490 LttvTracefileContext
*, i
));
491 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
);
492 g_assert(type
== LTTV_GOBJECT
);
493 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
495 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
497 g_assert(type
== LTTV_UINT
);
498 pid
= *(value
.v_uint
);
499 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
501 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
503 g_assert(type
== LTTV_POINTER
);
504 g_assert(*(value
.v_pointer
) != NULL
);
505 ep
= *(value
.v_pointer
);
506 g_assert(tfcs
->parent
.t_context
!= NULL
);
508 g_tree_destroy(tsc
->pqueue
);
509 tsc
->pqueue
= g_tree_new(compare_tracefile
);
511 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
513 g_assert(ltt_tracefile_seek_position(tfc
->tf
, ep
) == 0);
514 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
515 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
520 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
522 guint i
, nb_tracefile
;
524 LttvTracefileState
*tfcs
;
526 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
528 LttvAttributeType type
;
530 LttvAttributeValue value
;
532 LttvAttributeName name
;
534 LttEventPosition
*ep
;
536 tracefiles_tree
= lttv_attribute_find_subdir(container
,
537 LTTV_STATE_TRACEFILES
);
538 g_object_ref(G_OBJECT(tracefiles_tree
));
539 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
541 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
543 g_assert(type
== LTTV_POINTER
);
544 lttv_state_free_process_table(*(value
.v_pointer
));
545 *(value
.v_pointer
) = NULL
;
546 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
548 nb_tracefile
= self
->parent
.tracefiles
->len
;
550 for(i
= 0 ; i
< nb_tracefile
; i
++) {
552 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
553 LttvTracefileContext
*, i
));
554 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
);
555 g_assert(type
== LTTV_GOBJECT
);
556 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
558 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
560 g_assert(type
== LTTV_POINTER
);
561 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
563 g_object_unref(G_OBJECT(tracefiles_tree
));
567 static void free_saved_state(LttvTraceState
*self
)
571 LttvAttributeType type
;
573 LttvAttributeValue value
;
575 LttvAttributeName name
;
577 LttvAttribute
*saved_states
;
579 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
580 LTTV_STATE_SAVED_STATES
);
582 nb
= lttv_attribute_get_number(saved_states
);
583 for(i
= 0 ; i
< nb
; i
++) {
584 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
);
585 g_assert(type
== LTTV_GOBJECT
);
586 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
589 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
594 create_max_time(LttvTraceState
*tcs
)
596 LttvAttributeValue v
;
598 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
600 g_assert(*(v
.v_pointer
) == NULL
);
601 *(v
.v_pointer
) = g_new(LttTime
,1);
602 *((LttTime
*)*(v
.v_pointer
)) = time_zero
;
607 get_max_time(LttvTraceState
*tcs
)
609 LttvAttributeValue v
;
611 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
613 g_assert(*(v
.v_pointer
) != NULL
);
614 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
619 free_max_time(LttvTraceState
*tcs
)
621 LttvAttributeValue v
;
623 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
625 g_free(*(v
.v_pointer
));
626 *(v
.v_pointer
) = NULL
;
630 typedef struct _LttvNameTables
{
631 // FIXME GQuark *eventtype_names;
632 GQuark
*syscall_names
;
639 create_name_tables(LttvTraceState
*tcs
)
643 GQuark f_name
, e_name
;
647 LttvTraceHookByFacility
*thf
;
653 GString
*fe_name
= g_string_new("");
655 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
657 LttvAttributeValue v
;
659 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
661 g_assert(*(v
.v_pointer
) == NULL
);
662 *(v
.v_pointer
) = name_tables
;
663 #if 0 // Use iteration over the facilities_by_name and then list all event
664 // types of each facility
665 nb
= ltt_trace_eventtype_number(tcs
->parent
.t
);
666 name_tables
->eventtype_names
= g_new(GQuark
, nb
);
667 for(i
= 0 ; i
< nb
; i
++) {
668 et
= ltt_trace_eventtype_get(tcs
->parent
.t
, i
);
669 e_name
= ltt_eventtype_name(et
);
670 f_name
= ltt_facility_name(ltt_eventtype_facility(et
));
671 g_string_printf(fe_name
, "%s.%s", f_name
, e_name
);
672 name_tables
->eventtype_names
[i
] = g_quark_from_string(fe_name
->str
);
675 if(lttv_trace_find_hook(tcs
->parent
.t
,
676 LTT_FACILITY_KERNEL
, LTT_EVENT_SYSCALL_ENTRY
,
677 LTT_FIELD_SYSCALL_ID
, 0, 0,
681 thf
= lttv_trace_hook_get_first(h
);
683 t
= ltt_field_type(thf
->f1
);
684 nb
= ltt_type_element_number(t
);
686 lttv_trace_hook_destroy(h
);
688 /* CHECK syscalls should be an enum but currently are not!
689 name_tables->syscall_names = g_new(GQuark, nb);
691 for(i = 0 ; i < nb ; i++) {
692 name_tables->syscall_names[i] = g_quark_from_string(
693 ltt_enum_string_get(t, i));
697 name_tables
->syscall_names
= g_new(GQuark
, 256);
698 for(i
= 0 ; i
< 256 ; i
++) {
699 g_string_printf(fe_name
, "syscall %d", i
);
700 name_tables
->syscall_names
[i
] = g_quark_from_string(fe_name
->str
);
703 if(lttv_trace_find_hook(tcs
->parent
.t
, LTT_FACILITY_KERNEL
,
704 LTT_EVENT_TRAP_ENTRY
,
705 LTT_FIELD_TRAP_ID
, 0, 0,
709 thf
= lttv_trace_hook_get_first(h
);
711 t
= ltt_field_type(thf
->f1
);
712 nb
= ltt_type_element_number(t
);
714 lttv_trace_hook_destroy(h
);
717 name_tables->trap_names = g_new(GQuark, nb);
718 for(i = 0 ; i < nb ; i++) {
719 name_tables->trap_names[i] = g_quark_from_string(
720 ltt_enum_string_get(t, i));
724 name_tables
->trap_names
= g_new(GQuark
, 256);
725 for(i
= 0 ; i
< 256 ; i
++) {
726 g_string_printf(fe_name
, "trap %d", i
);
727 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
730 if(lttv_trace_find_hook(tcs
->parent
.t
,
731 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
732 LTT_FIELD_IRQ_ID
, 0, 0,
736 thf
= lttv_trace_hook_get_first(h
);
738 t
= ltt_field_type(thf
->f1
);
739 nb
= ltt_type_element_number(t
);
741 lttv_trace_hook_destroy(h
);
744 name_tables->irq_names = g_new(GQuark, nb);
745 for(i = 0 ; i < nb ; i++) {
746 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
750 name_tables
->irq_names
= g_new(GQuark
, 256);
751 for(i
= 0 ; i
< 256 ; i
++) {
752 g_string_printf(fe_name
, "irq %d", i
);
753 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
756 g_string_free(fe_name
, TRUE
);
761 get_name_tables(LttvTraceState
*tcs
)
763 LttvNameTables
*name_tables
;
765 LttvAttributeValue v
;
767 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
769 g_assert(*(v
.v_pointer
) != NULL
);
770 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
771 //tcs->eventtype_names = name_tables->eventtype_names;
772 tcs
->syscall_names
= name_tables
->syscall_names
;
773 tcs
->trap_names
= name_tables
->trap_names
;
774 tcs
->irq_names
= name_tables
->irq_names
;
779 free_name_tables(LttvTraceState
*tcs
)
781 LttvNameTables
*name_tables
;
783 LttvAttributeValue v
;
785 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
787 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
788 *(v
.v_pointer
) = NULL
;
790 // g_free(name_tables->eventtype_names);
791 g_free(name_tables
->syscall_names
);
792 g_free(name_tables
->trap_names
);
793 g_free(name_tables
->irq_names
);
798 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
801 LttvExecutionState
*es
;
803 LttvProcessState
*process
= tfs
->process
;
805 guint depth
= process
->execution_stack
->len
;
807 g_array_set_size(process
->execution_stack
, depth
+ 1);
808 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
811 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
812 es
->s
= process
->state
->s
;
817 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
819 LttvProcessState
*process
= tfs
->process
;
821 guint depth
= process
->execution_stack
->len
;
823 if(process
->state
->t
!= t
){
824 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
825 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
826 g_info("process state has %s when pop_int is %s\n",
827 g_quark_to_string(process
->state
->t
),
828 g_quark_to_string(t
));
829 g_info("{ %u, %u, %s, %s }\n",
832 g_quark_to_string(process
->name
),
833 g_quark_to_string(process
->state
->s
));
838 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
839 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
843 g_array_set_size(process
->execution_stack
, depth
- 1);
844 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
846 process
->state
->change
= tfs
->parent
.timestamp
;
851 lttv_state_create_process(LttvTracefileState
*tfs
, LttvProcessState
*parent
,
854 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
856 LttvExecutionState
*es
;
858 LttvTraceContext
*tc
;
864 tc
= tfs
->parent
.t_context
;
865 tcs
= (LttvTraceState
*)tc
;
868 process
->last_cpu
= tfs
->cpu_name
;
869 process
->last_cpu_index
= ((LttvTracefileContext
*)tfs
)->index
;
870 g_info("Process %u, core %p", process
->pid
, process
);
871 g_hash_table_insert(tcs
->processes
, process
, process
);
874 process
->ppid
= parent
->pid
;
875 process
->name
= parent
->name
;
876 process
->creation_time
= tfs
->parent
.timestamp
;
879 /* No parent. This process exists but we are missing all information about
880 its creation. The birth time is set to zero but we remember the time of
885 process
->name
= LTTV_STATE_UNNAMED
;
886 process
->creation_time
= ltt_time_zero
;
889 process
->insertion_time
= tfs
->parent
.timestamp
;
890 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
891 process
->creation_time
.tv_nsec
);
892 process
->pid_time
= g_quark_from_string(buffer
);
893 process
->last_cpu
= tfs
->cpu_name
;
894 process
->last_cpu_index
= ((LttvTracefileContext
*)tfs
)->index
;
895 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
896 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
897 g_array_set_size(process
->execution_stack
, 1);
898 es
= process
->state
= &g_array_index(process
->execution_stack
,
899 LttvExecutionState
, 0);
900 es
->t
= LTTV_STATE_USER_MODE
;
901 es
->n
= LTTV_STATE_SUBMODE_NONE
;
902 es
->entry
= tfs
->parent
.timestamp
;
903 g_assert(tfs
->parent
.timestamp
.tv_sec
!= 0);
904 es
->change
= tfs
->parent
.timestamp
;
905 es
->s
= LTTV_STATE_WAIT_FORK
;
910 LttvProcessState
*lttv_state_find_process(LttvTracefileState
*tfs
,
913 LttvProcessState key
;
914 LttvProcessState
*process
;
916 LttvTraceState
* ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
919 key
.last_cpu
= tfs
->cpu_name
;
920 process
= g_hash_table_lookup(ts
->processes
, &key
);
925 lttv_state_find_process_or_create(LttvTracefileState
*tfs
, guint pid
)
927 LttvProcessState
*process
= lttv_state_find_process(tfs
, pid
);
929 if(unlikely(process
== NULL
)) process
= lttv_state_create_process(tfs
, NULL
, pid
);
933 /* FIXME : this function should be called when we receive an event telling that
934 * release_task has been called in the kernel. In happens generally when
935 * the parent waits for its child terminaison, but may also happen in special
936 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
937 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
938 * of a killed thread ground, but isn't the leader.
940 static void exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
942 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
943 LttvProcessState key
;
945 key
.pid
= process
->pid
;
946 key
.last_cpu
= process
->last_cpu
;
947 g_hash_table_remove(ts
->processes
, &key
);
948 g_array_free(process
->execution_stack
, TRUE
);
953 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
955 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
960 static void lttv_state_free_process_table(GHashTable
*processes
)
962 g_hash_table_foreach(processes
, free_process_state
, NULL
);
963 g_hash_table_destroy(processes
);
967 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
969 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
970 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
971 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
972 LttField
*f
= thf
->f1
;
974 LttvExecutionSubmode submode
;
976 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->syscall_names
[
977 ltt_event_get_unsigned(e
, f
)];
978 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
983 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
985 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
987 pop_state(s
, LTTV_STATE_SYSCALL
);
992 static gboolean
trap_entry(void *hook_data
, void *call_data
)
994 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
995 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
996 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
997 LttField
*f
= thf
->f1
;
999 LttvExecutionSubmode submode
;
1001 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->trap_names
[
1002 ltt_event_get_unsigned(e
, f
)];
1003 push_state(s
, LTTV_STATE_TRAP
, submode
);
1008 static gboolean
trap_exit(void *hook_data
, void *call_data
)
1010 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1012 pop_state(s
, LTTV_STATE_TRAP
);
1017 static gboolean
irq_entry(void *hook_data
, void *call_data
)
1019 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1020 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1021 guint8 fac_id
= ltt_event_facility_id(e
);
1022 guint8 ev_id
= ltt_event_eventtype_id(e
);
1023 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1024 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1025 g_assert(thf
->f1
!= NULL
);
1026 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1027 LttField
*f
= thf
->f1
;
1029 LttvExecutionSubmode submode
;
1031 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->irq_names
[
1032 ltt_event_get_unsigned(e
, f
)];
1034 /* Do something with the info about being in user or system mode when int? */
1035 push_state(s
, LTTV_STATE_IRQ
, submode
);
1040 static gboolean
irq_exit(void *hook_data
, void *call_data
)
1042 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1044 pop_state(s
, LTTV_STATE_IRQ
);
1049 static gboolean
schedchange(void *hook_data
, void *call_data
)
1051 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1052 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1053 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1054 guint pid_in
, pid_out
, state_out
;
1056 pid_out
= ltt_event_get_unsigned(e
, thf
->f1
);
1057 pid_in
= ltt_event_get_unsigned(e
, thf
->f2
);
1058 state_out
= ltt_event_get_unsigned(e
, thf
->f3
);
1060 if(likely(s
->process
!= NULL
)) {
1062 /* We could not know but it was not the idle process executing.
1063 This should only happen at the beginning, before the first schedule
1064 event, and when the initial information (current process for each CPU)
1065 is missing. It is not obvious how we could, after the fact, compensate
1066 the wrongly attributed statistics. */
1068 if(unlikely(s
->process
->pid
!= pid_out
)) {
1069 g_assert(s
->process
->pid
== 0);
1072 if(unlikely(s
->process
->state
->s
== LTTV_STATE_EXIT
)) {
1073 s
->process
->state
->s
= LTTV_STATE_ZOMBIE
;
1075 if(unlikely(state_out
== 0)) s
->process
->state
->s
= LTTV_STATE_WAIT_CPU
;
1076 else s
->process
->state
->s
= LTTV_STATE_WAIT
;
1077 } /* FIXME : we do not remove process here, because the kernel
1078 * still has them : they may be zombies. We need to know
1079 * exactly when release_task is executed on the PID to
1080 * know when the zombie is destroyed.
1083 // exit_process(s, s->process);
1085 s
->process
->state
->change
= s
->parent
.timestamp
;
1087 s
->process
= lttv_state_find_process_or_create(s
, pid_in
);
1088 s
->process
->state
->s
= LTTV_STATE_RUN
;
1089 s
->process
->last_cpu
= s
->cpu_name
;
1090 s
->process
->last_cpu_index
= ((LttvTracefileContext
*)s
)->index
;
1091 s
->process
->state
->change
= s
->parent
.timestamp
;
1095 static gboolean
process_fork(void *hook_data
, void *call_data
)
1097 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1098 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1099 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1103 LttvProcessState
*zombie_process
;
1107 parent_pid
= ltt_event_get_unsigned(e
, f
);
1111 child_pid
= ltt_event_get_unsigned(e
, f
);
1113 zombie_process
= lttv_state_find_process(s
, child_pid
);
1115 if(unlikely(zombie_process
!= NULL
)) {
1116 /* Reutilisation of PID. Only now we are sure that the old PID
1117 * has been released. FIXME : should know when release_task happens instead.
1119 exit_process(s
, zombie_process
);
1121 g_assert(s
->process
->pid
!= child_pid
);
1122 // FIXME : Add this test in the "known state" section
1123 // g_assert(s->process->pid == parent_pid);
1124 lttv_state_create_process(s
, s
->process
, child_pid
);
1130 static gboolean
process_exit(void *hook_data
, void *call_data
)
1132 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1133 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1134 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1138 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1140 // FIXME : Add this test in the "known state" section
1141 // g_assert(s->process->pid == pid);
1143 if(likely(s
->process
!= NULL
)) {
1144 s
->process
->state
->s
= LTTV_STATE_EXIT
;
1149 static gboolean
process_free(void *hook_data
, void *call_data
)
1151 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1152 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1153 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1155 LttvProcessState
*process
;
1157 /* PID of the process to release */
1158 release_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1160 process
= lttv_state_find_process(s
, release_pid
);
1162 if(likely(process
!= NULL
)) {
1163 /* release_task is happening at kernel level : we can now safely release
1164 * the data structure of the process */
1165 exit_process(s
, process
);
1171 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
1173 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1175 lttv_state_add_event_hooks(tss
);
1180 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
1182 LttvTraceset
*traceset
= self
->parent
.ts
;
1184 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1188 LttvTracefileState
*tfs
;
1192 LttvTraceHookByFacility
*thf
;
1194 LttvTraceHook
*hook
;
1196 LttvAttributeValue val
;
1200 nb_trace
= lttv_traceset_number(traceset
);
1201 for(i
= 0 ; i
< nb_trace
; i
++) {
1202 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1204 /* Find the eventtype id for the following events and register the
1205 associated by id hooks. */
1207 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 10);
1208 g_array_set_size(hooks
, 10);
1210 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1211 LTT_FACILITY_KERNEL
, LTT_EVENT_SYSCALL_ENTRY
,
1212 LTT_FIELD_SYSCALL_ID
, 0, 0,
1213 syscall_entry
, &g_array_index(hooks
, LttvTraceHook
, 0));
1216 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1217 LTT_FACILITY_KERNEL
, LTT_EVENT_SYSCALL_EXIT
,
1219 syscall_exit
, &g_array_index(hooks
, LttvTraceHook
, 1));
1222 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1223 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_ENTRY
,
1224 LTT_FIELD_TRAP_ID
, 0, 0,
1225 trap_entry
, &g_array_index(hooks
, LttvTraceHook
, 2));
1228 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1229 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_EXIT
,
1231 trap_exit
, &g_array_index(hooks
, LttvTraceHook
, 3));
1234 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1235 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
1236 LTT_FIELD_IRQ_ID
, 0, 0,
1237 irq_entry
, &g_array_index(hooks
, LttvTraceHook
, 4));
1240 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1241 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_EXIT
,
1243 irq_exit
, &g_array_index(hooks
, LttvTraceHook
, 5));
1246 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1247 LTT_FACILITY_PROCESS
, LTT_EVENT_SCHEDCHANGE
,
1248 LTT_FIELD_OUT
, LTT_FIELD_IN
, LTT_FIELD_OUT_STATE
,
1249 schedchange
, &g_array_index(hooks
, LttvTraceHook
, 6));
1252 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1253 LTT_FACILITY_PROCESS
, LTT_EVENT_FORK
,
1254 LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
, 0,
1255 process_fork
, &g_array_index(hooks
, LttvTraceHook
, 7));
1258 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1259 LTT_FACILITY_PROCESS
, LTT_EVENT_EXIT
,
1260 LTT_FIELD_PID
, 0, 0,
1261 process_exit
, &g_array_index(hooks
, LttvTraceHook
, 8));
1264 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1265 LTT_FACILITY_PROCESS
, LTT_EVENT_FREE
,
1266 LTT_FIELD_PID
, 0, 0,
1267 process_free
, &g_array_index(hooks
, LttvTraceHook
, 9));
1271 /* Add these hooks to each event_by_id hooks list */
1273 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1275 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1277 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1278 LttvTracefileContext
*, j
));
1280 for(k
= 0 ; k
< hooks
->len
; k
++) {
1281 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
1282 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
1283 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
1285 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
1292 lttv_attribute_find(self
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
1293 *(val
.v_pointer
) = hooks
;
1297 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1299 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1301 lttv_state_remove_event_hooks(tss
);
1306 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
1308 LttvTraceset
*traceset
= self
->parent
.ts
;
1310 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1314 LttvTracefileState
*tfs
;
1318 LttvTraceHook
*hook
;
1320 LttvTraceHookByFacility
*thf
;
1322 LttvAttributeValue val
;
1324 nb_trace
= lttv_traceset_number(traceset
);
1325 for(i
= 0 ; i
< nb_trace
; i
++) {
1326 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
1327 lttv_attribute_find(self
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
1328 hooks
= *(val
.v_pointer
);
1330 /* Remove these hooks from each event_by_id hooks list */
1332 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1334 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1336 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1337 LttvTracefileContext
*, j
));
1339 for(k
= 0 ; k
< hooks
->len
; k
++) {
1340 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
1341 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
1342 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
1344 lttv_hooks_remove_data(
1345 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
1349 lttv_trace_hook_destroy(&g_array_index(hooks
, LttvTraceHook
, k
));
1352 g_array_free(hooks
, TRUE
);
1357 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
1359 guint
*event_count
= (guint
*)hook_data
;
1361 /* Only save at LTTV_STATE_SAVE_INTERVAL */
1362 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
1367 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1369 LttvTracefileState
*tfcs
;
1371 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1373 LttEventPosition
*ep
;
1379 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1381 LttvAttributeValue value
;
1383 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1384 LTTV_STATE_SAVED_STATES
);
1385 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1386 value
= lttv_attribute_add(saved_states_tree
,
1387 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1388 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1389 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1390 *(value
.v_time
) = self
->parent
.timestamp
;
1391 lttv_state_save(tcs
, saved_state_tree
);
1392 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
1393 self
->parent
.timestamp
.tv_nsec
);
1395 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1401 static gboolean
block_start(void *hook_data
, void *call_data
)
1403 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1405 LttvTracefileState
*tfcs
;
1407 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1409 LttEventPosition
*ep
;
1411 guint i
, nb_block
, nb_event
, nb_tracefile
;
1415 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1417 LttvAttributeValue value
;
1419 ep
= ltt_event_position_new();
1421 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
1423 /* Count the number of events added since the last block end in any
1426 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1428 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
1429 LttvTracefileContext
, i
));
1430 ltt_event_position(tfcs
->parent
.e
, ep
);
1431 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
1432 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
1433 tfcs
->saved_position
= nb_event
;
1437 if(tcs
->nb_event
>= tcs
->save_interval
) {
1438 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1439 LTTV_STATE_SAVED_STATES
);
1440 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1441 value
= lttv_attribute_add(saved_states_tree
,
1442 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1443 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1444 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1445 *(value
.v_time
) = self
->parent
.timestamp
;
1446 lttv_state_save(tcs
, saved_state_tree
);
1448 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
1449 self
->parent
.timestamp
.tv_nsec
);
1451 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1457 static gboolean
block_end(void *hook_data
, void *call_data
)
1459 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1461 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1465 LttEventPosition
*ep
;
1467 guint nb_block
, nb_event
;
1469 ep
= ltt_event_position_new();
1470 ltt_event_position(self
->parent
.e
, ep
);
1471 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
1472 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
1473 self
->saved_position
= 0;
1474 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1481 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
1483 LttvTraceset
*traceset
= self
->parent
.ts
;
1485 guint i
, j
, nb_trace
, nb_tracefile
;
1489 LttvTracefileState
*tfs
;
1491 LttvTraceHook hook_start
, hook_end
;
1493 nb_trace
= lttv_traceset_number(traceset
);
1494 for(i
= 0 ; i
< nb_trace
; i
++) {
1495 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1497 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
1498 NULL
, NULL
, block_start
, &hook_start
);
1499 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
1500 NULL
, NULL
, block_end
, &hook_end
);
1502 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1504 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1506 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
1507 LttvTracefileContext
, j
));
1508 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
1509 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
1510 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
1511 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
1517 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
1519 LttvTraceset
*traceset
= self
->parent
.ts
;
1521 guint i
, j
, nb_trace
, nb_tracefile
;
1525 LttvTracefileState
*tfs
;
1528 nb_trace
= lttv_traceset_number(traceset
);
1529 for(i
= 0 ; i
< nb_trace
; i
++) {
1531 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1532 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1534 guint
*event_count
= g_new(guint
, 1);
1537 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1539 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1540 LttvTracefileContext
*, j
));
1541 lttv_hooks_add(tfs
->parent
.event
,
1542 state_save_event_hook
,
1550 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
1552 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1554 lttv_state_save_add_event_hooks(tss
);
1561 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
1563 LttvTraceset
*traceset
= self
->parent
.ts
;
1565 guint i
, j
, nb_trace
, nb_tracefile
;
1569 LttvTracefileState
*tfs
;
1571 LttvTraceHook hook_start
, hook_end
;
1573 nb_trace
= lttv_traceset_number(traceset
);
1574 for(i
= 0 ; i
< nb_trace
; i
++) {
1575 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
1577 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
1578 NULL
, NULL
, block_start
, &hook_start
);
1580 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
1581 NULL
, NULL
, block_end
, &hook_end
);
1583 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1585 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1587 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
1588 LttvTracefileContext
, j
));
1589 lttv_hooks_remove_data(lttv_hooks_by_id_find(
1590 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
1591 lttv_hooks_remove_data(lttv_hooks_by_id_find(
1592 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
1598 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
1600 LttvTraceset
*traceset
= self
->parent
.ts
;
1602 guint i
, j
, nb_trace
, nb_tracefile
;
1606 LttvTracefileState
*tfs
;
1609 nb_trace
= lttv_traceset_number(traceset
);
1610 for(i
= 0 ; i
< nb_trace
; i
++) {
1612 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1613 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1617 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1619 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1620 LttvTracefileContext
*, j
));
1621 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
1622 state_save_event_hook
);
1623 g_free(event_count
);
1629 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1631 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1633 lttv_state_save_remove_event_hooks(tss
);
1638 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
1640 LttvTraceset
*traceset
= self
->parent
.ts
;
1644 int min_pos
, mid_pos
, max_pos
;
1646 LttvTraceState
*tcs
;
1648 LttvAttributeValue value
;
1650 LttvAttributeType type
;
1652 LttvAttributeName name
;
1654 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
;
1656 nb_trace
= lttv_traceset_number(traceset
);
1657 for(i
= 0 ; i
< nb_trace
; i
++) {
1658 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
1660 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
1661 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1662 LTTV_STATE_SAVED_STATES
);
1665 if(saved_states_tree
) {
1666 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
1667 mid_pos
= max_pos
/ 2;
1668 while(min_pos
< max_pos
) {
1669 type
= lttv_attribute_get(saved_states_tree
, mid_pos
, &name
, &value
);
1670 g_assert(type
== LTTV_GOBJECT
);
1671 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1672 type
= lttv_attribute_get_by_name(saved_state_tree
, LTTV_STATE_TIME
,
1674 g_assert(type
== LTTV_TIME
);
1675 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
1677 closest_tree
= saved_state_tree
;
1679 else max_pos
= mid_pos
- 1;
1681 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
1685 /* restore the closest earlier saved state */
1687 lttv_state_restore(tcs
, closest_tree
);
1690 /* There is no saved state, yet we want to have it. Restart at T0 */
1692 restore_init_state(tcs
);
1693 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
1696 /* We want to seek quickly without restoring/updating the state */
1698 restore_init_state(tcs
);
1699 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
1706 traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
1712 traceset_state_finalize (LttvTracesetState
*self
)
1714 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
1715 finalize(G_OBJECT(self
));
1720 traceset_state_class_init (LttvTracesetContextClass
*klass
)
1722 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
1724 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
1725 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
1726 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
1727 klass
->new_traceset_context
= new_traceset_context
;
1728 klass
->new_trace_context
= new_trace_context
;
1729 klass
->new_tracefile_context
= new_tracefile_context
;
1734 lttv_traceset_state_get_type(void)
1736 static GType type
= 0;
1738 static const GTypeInfo info
= {
1739 sizeof (LttvTracesetStateClass
),
1740 NULL
, /* base_init */
1741 NULL
, /* base_finalize */
1742 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
1743 NULL
, /* class_finalize */
1744 NULL
, /* class_data */
1745 sizeof (LttvTracesetState
),
1746 0, /* n_preallocs */
1747 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
1748 NULL
/* value handling */
1751 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
1759 trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
1765 trace_state_finalize (LttvTraceState
*self
)
1767 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
1768 finalize(G_OBJECT(self
));
1773 trace_state_class_init (LttvTraceStateClass
*klass
)
1775 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
1777 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
1778 klass
->state_save
= state_save
;
1779 klass
->state_restore
= state_restore
;
1780 klass
->state_saved_free
= state_saved_free
;
1785 lttv_trace_state_get_type(void)
1787 static GType type
= 0;
1789 static const GTypeInfo info
= {
1790 sizeof (LttvTraceStateClass
),
1791 NULL
, /* base_init */
1792 NULL
, /* base_finalize */
1793 (GClassInitFunc
) trace_state_class_init
, /* class_init */
1794 NULL
, /* class_finalize */
1795 NULL
, /* class_data */
1796 sizeof (LttvTraceState
),
1797 0, /* n_preallocs */
1798 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
1799 NULL
/* value handling */
1802 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
1803 "LttvTraceStateType", &info
, 0);
1810 tracefile_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
1816 tracefile_state_finalize (LttvTracefileState
*self
)
1818 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
1819 finalize(G_OBJECT(self
));
1824 tracefile_state_class_init (LttvTracefileStateClass
*klass
)
1826 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
1828 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
1833 lttv_tracefile_state_get_type(void)
1835 static GType type
= 0;
1837 static const GTypeInfo info
= {
1838 sizeof (LttvTracefileStateClass
),
1839 NULL
, /* base_init */
1840 NULL
, /* base_finalize */
1841 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
1842 NULL
, /* class_finalize */
1843 NULL
, /* class_data */
1844 sizeof (LttvTracefileState
),
1845 0, /* n_preallocs */
1846 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
1847 NULL
/* value handling */
1850 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
1851 "LttvTracefileStateType", &info
, 0);
1857 static void module_init()
1859 LTTV_STATE_UNNAMED
= g_quark_from_string("unnamed");
1860 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("unknown execution mode");
1861 LTTV_STATE_USER_MODE
= g_quark_from_string("user mode");
1862 LTTV_STATE_WAIT_FORK
= g_quark_from_string("wait fork");
1863 LTTV_STATE_SYSCALL
= g_quark_from_string("system call");
1864 LTTV_STATE_TRAP
= g_quark_from_string("trap");
1865 LTTV_STATE_IRQ
= g_quark_from_string("irq");
1866 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("unknown submode");
1867 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("(no submode)");
1868 LTTV_STATE_WAIT_CPU
= g_quark_from_string("wait for cpu");
1869 LTTV_STATE_EXIT
= g_quark_from_string("exiting");
1870 LTTV_STATE_ZOMBIE
= g_quark_from_string("zombie");
1871 LTTV_STATE_WAIT
= g_quark_from_string("wait for I/O");
1872 LTTV_STATE_RUN
= g_quark_from_string("running");
1873 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
1874 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
1875 LTTV_STATE_PROCESS
= g_quark_from_string("process");
1876 LTTV_STATE_EVENT
= g_quark_from_string("event");
1877 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
1878 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
1879 LTTV_STATE_TIME
= g_quark_from_string("time");
1880 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
1881 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
1882 LTTV_STATE_TRACE_STATE_USE_COUNT
=
1883 g_quark_from_string("trace_state_use_count");
1886 LTT_FACILITY_KERNEL
= g_quark_from_string("kernel");
1887 LTT_FACILITY_PROCESS
= g_quark_from_string("process");
1890 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
1891 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
1892 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
1893 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
1894 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
1895 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
1896 LTT_EVENT_SCHEDCHANGE
= g_quark_from_string("schedchange");
1897 LTT_EVENT_FORK
= g_quark_from_string("fork");
1898 LTT_EVENT_EXIT
= g_quark_from_string("exit");
1899 LTT_EVENT_FREE
= g_quark_from_string("free");
1902 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
1903 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
1904 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
1905 LTT_FIELD_OUT
= g_quark_from_string("out");
1906 LTT_FIELD_IN
= g_quark_from_string("in");
1907 LTT_FIELD_OUT_STATE
= g_quark_from_string("out_state");
1908 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
1909 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
1910 LTT_FIELD_PID
= g_quark_from_string("pid");
1914 static void module_destroy()
1919 LTTV_MODULE("state", "State computation", \
1920 "Update the system state, possibly saving it at intervals", \
1921 module_init
, module_destroy
)