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 */
38 LTT_FACILITY_KERNEL_ARCH
,
45 LTT_EVENT_SYSCALL_ENTRY
,
46 LTT_EVENT_SYSCALL_EXIT
,
51 LTT_EVENT_SCHEDCHANGE
,
72 LTTV_STATE_MODE_UNKNOWN
,
79 LTTV_STATE_SUBMODE_UNKNOWN
,
80 LTTV_STATE_SUBMODE_NONE
;
93 LTTV_STATE_TRACEFILES
,
96 LTTV_STATE_RUNNING_PROCESS
,
98 LTTV_STATE_SAVED_STATES
,
99 LTTV_STATE_SAVED_STATES_TIME
,
102 LTTV_STATE_NAME_TABLES
,
103 LTTV_STATE_TRACE_STATE_USE_COUNT
;
105 static void create_max_time(LttvTraceState
*tcs
);
107 static void get_max_time(LttvTraceState
*tcs
);
109 static void free_max_time(LttvTraceState
*tcs
);
111 static void create_name_tables(LttvTraceState
*tcs
);
113 static void get_name_tables(LttvTraceState
*tcs
);
115 static void free_name_tables(LttvTraceState
*tcs
);
117 static void free_saved_state(LttvTraceState
*tcs
);
119 static void lttv_state_free_process_table(GHashTable
*processes
);
122 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
124 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
128 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
130 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
134 void lttv_state_state_saved_free(LttvTraceState
*self
,
135 LttvAttribute
*container
)
137 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
141 guint
process_hash(gconstpointer key
)
143 guint pid
= ((const LttvProcessState
*)key
)->pid
;
144 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
148 /* If the hash table hash function is well distributed,
149 * the process_equal should compare different pid */
150 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
152 const LttvProcessState
*process_a
, *process_b
;
155 process_a
= (const LttvProcessState
*)a
;
156 process_b
= (const LttvProcessState
*)b
;
158 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
159 else if(likely(process_a
->pid
== 0 &&
160 process_a
->cpu
!= process_b
->cpu
)) ret
= FALSE
;
167 restore_init_state(LttvTraceState
*self
)
171 LttvTracefileState
*tfcs
;
173 /* Free the process tables */
174 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
175 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
178 /* Seek time to beginning */
179 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
180 // closest. It's the tracecontext job to seek the trace to the beginning
181 // anyway : the init state might be used at the middle of the trace as well...
182 //g_tree_destroy(self->parent.ts_context->pqueue);
183 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
186 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
188 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
190 /* Put the per cpu running_process to beginning state : process 0. */
191 for(i
=0; i
< nb_cpus
; i
++) {
192 self
->running_process
[i
] = lttv_state_create_process(self
, NULL
, i
, 0,
194 self
->running_process
[i
]->state
->s
= LTTV_STATE_RUN
;
195 self
->running_process
[i
]->cpu
= i
;
199 nb_tracefile
= self
->parent
.tracefiles
->len
;
201 for(i
= 0 ; i
< nb_tracefile
; i
++) {
203 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
204 LttvTracefileContext
*, i
));
205 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
206 // tfcs->saved_position = 0;
207 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
208 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
209 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
210 tfcs
->process
->last_cpu_index
= ltt_tracefile_num(((LttvTracefileContext
*)tfcs
)->tf
);
215 //static LttTime time_zero = {0,0};
218 init(LttvTracesetState
*self
, LttvTraceset
*ts
)
220 guint i
, j
, nb_trace
, nb_tracefile
;
222 LttvTraceContext
*tc
;
226 LttvTracefileState
*tfcs
;
228 LttvAttributeValue v
;
230 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
231 init((LttvTracesetContext
*)self
, ts
);
233 nb_trace
= lttv_traceset_number(ts
);
234 for(i
= 0 ; i
< nb_trace
; i
++) {
235 tc
= self
->parent
.traces
[i
];
236 tcs
= LTTV_TRACE_STATE(tc
);
237 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
238 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
242 if(*(v
.v_uint
) == 1) {
243 create_name_tables(tcs
);
244 create_max_time(tcs
);
246 get_name_tables(tcs
);
249 nb_tracefile
= tc
->tracefiles
->len
;
251 for(j
= 0 ; j
< nb_tracefile
; j
++) {
253 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
254 LttvTracefileContext
*, j
));
255 tfcs
->tracefile_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
258 tcs
->processes
= NULL
;
259 tcs
->running_process
= g_new(LttvProcessState
*,
260 ltt_trace_get_num_cpu(tc
->t
));
261 restore_init_state(tcs
);
267 fini(LttvTracesetState
*self
)
273 LttvTracefileState
*tfcs
;
275 LttvAttributeValue v
;
277 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
278 for(i
= 0 ; i
< nb_trace
; i
++) {
279 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
280 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
283 g_assert(*(v
.v_uint
) != 0);
286 if(*(v
.v_uint
) == 0) {
287 free_name_tables(tcs
);
289 free_saved_state(tcs
);
291 g_free(tcs
->running_process
);
292 tcs
->running_process
= NULL
;
293 lttv_state_free_process_table(tcs
->processes
);
294 tcs
->processes
= NULL
;
296 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
297 fini((LttvTracesetContext
*)self
);
301 static LttvTracesetContext
*
302 new_traceset_context(LttvTracesetContext
*self
)
304 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
308 static LttvTraceContext
*
309 new_trace_context(LttvTracesetContext
*self
)
311 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
315 static LttvTracefileContext
*
316 new_tracefile_context(LttvTracesetContext
*self
)
318 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
322 /* Write the process state of the trace */
324 static void write_process_state(gpointer key
, gpointer value
,
327 LttvProcessState
*process
;
329 LttvExecutionState
*es
;
331 FILE *fp
= (FILE *)user_data
;
335 process
= (LttvProcessState
*)value
;
337 " <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%u\">\n",
338 process
, process
->pid
, process
->ppid
, process
->creation_time
.tv_sec
,
339 process
->creation_time
.tv_nsec
, g_quark_to_string(process
->name
),
342 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
343 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
344 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
345 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
346 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
347 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
348 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
350 fprintf(fp
, " </PROCESS>\n");
354 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
356 guint i
, nb_tracefile
, nb_block
, offset
;
359 LttvTracefileState
*tfcs
;
363 LttEventPosition
*ep
;
367 ep
= ltt_event_position_new();
369 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
371 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
373 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
374 for(i
=0;i
<nb_cpus
;i
++) {
375 fprintf(fp
,"<CPU NUM=%u RUNNING_PROCESS=%u>\n",
376 i
, self
->running_process
[i
]->pid
);
379 nb_tracefile
= self
->parent
.tracefiles
->len
;
381 for(i
= 0 ; i
< nb_tracefile
; i
++) {
383 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
384 LttvTracefileContext
*, i
));
385 fprintf(fp
, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
386 tfcs
->parent
.timestamp
.tv_sec
,
387 tfcs
->parent
.timestamp
.tv_nsec
);
388 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
389 if(e
== NULL
) fprintf(fp
,"/>\n");
391 ltt_event_position(e
, ep
);
392 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
393 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block
, offset
,
398 fprintf(fp
,"</PROCESS_STATE>");
402 /* Copy each process from an existing hash table to a new one */
404 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
406 LttvProcessState
*process
, *new_process
;
408 GHashTable
*new_processes
= (GHashTable
*)user_data
;
412 process
= (LttvProcessState
*)value
;
413 new_process
= g_new(LttvProcessState
, 1);
414 *new_process
= *process
;
415 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
416 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
417 new_process
->execution_stack
=
418 g_array_set_size(new_process
->execution_stack
,
419 process
->execution_stack
->len
);
420 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
421 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
422 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
424 new_process
->state
= &g_array_index(new_process
->execution_stack
,
425 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
426 g_hash_table_insert(new_processes
, new_process
, new_process
);
430 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
432 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
434 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
435 return new_processes
;
439 /* The saved state for each trace contains a member "processes", which
440 stores a copy of the process table, and a member "tracefiles" with
441 one entry per tracefile. Each tracefile has a "process" member pointing
442 to the current process and a "position" member storing the tracefile
443 position (needed to seek to the current "next" event. */
445 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
447 guint i
, nb_tracefile
, nb_cpus
;
449 LttvTracefileState
*tfcs
;
451 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
453 guint
*running_process
;
455 LttvAttributeType type
;
457 LttvAttributeValue value
;
459 LttvAttributeName name
;
461 LttEventPosition
*ep
;
463 tracefiles_tree
= lttv_attribute_find_subdir(container
,
464 LTTV_STATE_TRACEFILES
);
466 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
468 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
470 /* Add the currently running processes array */
471 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
472 running_process
= g_new(guint
, nb_cpus
);
473 for(i
=0;i
<nb_cpus
;i
++) {
474 running_process
[i
] = self
->running_process
[i
]->pid
;
476 value
= lttv_attribute_add(container
, LTTV_STATE_RUNNING_PROCESS
,
478 *(value
.v_pointer
) = running_process
;
480 g_info("State save");
482 nb_tracefile
= self
->parent
.tracefiles
->len
;
484 for(i
= 0 ; i
< nb_tracefile
; i
++) {
486 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
487 LttvTracefileContext
*, i
));
488 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
489 value
= lttv_attribute_add(tracefiles_tree
, i
,
491 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
493 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
495 *(value
.v_uint
) = tfcs
->process
->pid
;
497 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
499 /* Only save the position if the tfs has not infinite time. */
500 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
501 // && current_tfcs != tfcs) {
502 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) == 0) {
503 *(value
.v_pointer
) = NULL
;
505 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
506 ep
= ltt_event_position_new();
507 ltt_event_position(e
, ep
);
508 *(value
.v_pointer
) = ep
;
510 guint nb_block
, offset
;
513 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
514 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block
, offset
,
516 tfcs
->parent
.timestamp
.tv_sec
, tfcs
->parent
.timestamp
.tv_nsec
);
522 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
524 guint i
, nb_tracefile
, pid
, nb_cpus
;
526 LttvTracefileState
*tfcs
;
528 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
530 guint
*running_process
;
532 LttvAttributeType type
;
534 LttvAttributeValue value
;
536 LttvAttributeName name
;
538 LttEventPosition
*ep
;
540 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
542 tracefiles_tree
= lttv_attribute_find_subdir(container
,
543 LTTV_STATE_TRACEFILES
);
545 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
547 g_assert(type
== LTTV_POINTER
);
548 lttv_state_free_process_table(self
->processes
);
549 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
551 /* Add the currently running processes array */
552 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
553 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
555 g_assert(type
== LTTV_POINTER
);
556 running_process
= *(value
.v_pointer
);
557 for(i
=0;i
<nb_cpus
;i
++) {
558 pid
= running_process
[i
];
559 self
->running_process
[i
] = lttv_state_find_process(self
, i
, pid
);
560 g_assert(self
->running_process
[i
] != NULL
);
564 nb_tracefile
= self
->parent
.tracefiles
->len
;
566 //g_tree_destroy(tsc->pqueue);
567 //tsc->pqueue = g_tree_new(compare_tracefile);
569 for(i
= 0 ; i
< nb_tracefile
; i
++) {
571 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
572 LttvTracefileContext
*, i
));
573 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
);
574 g_assert(type
== LTTV_GOBJECT
);
575 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
577 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
579 g_assert(type
== LTTV_UINT
);
580 pid
= *(value
.v_uint
);
581 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
583 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
585 g_assert(type
== LTTV_POINTER
);
586 //g_assert(*(value.v_pointer) != NULL);
587 ep
= *(value
.v_pointer
);
588 g_assert(tfcs
->parent
.t_context
!= NULL
);
590 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
591 g_tree_remove(tsc
->pqueue
, tfc
);
594 g_assert(ltt_tracefile_seek_position(tfc
->tf
, ep
) == 0);
595 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
596 g_assert(ltt_time_compare(tfc
->timestamp
, ltt_time_infinite
) != 0);
597 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
598 g_info("Restoring state for a tf at time %lu.%lu", tfc
->timestamp
.tv_sec
, tfc
->timestamp
.tv_nsec
);
600 tfc
->timestamp
= ltt_time_infinite
;
606 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
608 guint i
, nb_tracefile
, nb_cpus
;
610 LttvTracefileState
*tfcs
;
612 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
614 guint
*running_process
;
616 LttvAttributeType type
;
618 LttvAttributeValue value
;
620 LttvAttributeName name
;
622 LttEventPosition
*ep
;
624 tracefiles_tree
= lttv_attribute_find_subdir(container
,
625 LTTV_STATE_TRACEFILES
);
626 g_object_ref(G_OBJECT(tracefiles_tree
));
627 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
629 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
631 g_assert(type
== LTTV_POINTER
);
632 lttv_state_free_process_table(*(value
.v_pointer
));
633 *(value
.v_pointer
) = NULL
;
634 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
636 /* Free running processes array */
637 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
638 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
640 g_assert(type
== LTTV_POINTER
);
641 running_process
= *(value
.v_pointer
);
642 g_free(running_process
);
644 nb_tracefile
= self
->parent
.tracefiles
->len
;
646 for(i
= 0 ; i
< nb_tracefile
; i
++) {
648 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
649 LttvTracefileContext
*, i
));
650 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
);
651 g_assert(type
== LTTV_GOBJECT
);
652 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
654 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
656 g_assert(type
== LTTV_POINTER
);
657 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
659 g_object_unref(G_OBJECT(tracefiles_tree
));
663 static void free_saved_state(LttvTraceState
*self
)
667 LttvAttributeType type
;
669 LttvAttributeValue value
;
671 LttvAttributeName name
;
673 LttvAttribute
*saved_states
;
675 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
676 LTTV_STATE_SAVED_STATES
);
678 nb
= lttv_attribute_get_number(saved_states
);
679 for(i
= 0 ; i
< nb
; i
++) {
680 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
);
681 g_assert(type
== LTTV_GOBJECT
);
682 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
685 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
690 create_max_time(LttvTraceState
*tcs
)
692 LttvAttributeValue v
;
694 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
696 g_assert(*(v
.v_pointer
) == NULL
);
697 *(v
.v_pointer
) = g_new(LttTime
,1);
698 *((LttTime
*)*(v
.v_pointer
)) = ltt_time_zero
;
703 get_max_time(LttvTraceState
*tcs
)
705 LttvAttributeValue v
;
707 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
709 g_assert(*(v
.v_pointer
) != NULL
);
710 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
715 free_max_time(LttvTraceState
*tcs
)
717 LttvAttributeValue v
;
719 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
721 g_free(*(v
.v_pointer
));
722 *(v
.v_pointer
) = NULL
;
726 typedef struct _LttvNameTables
{
727 // FIXME GQuark *eventtype_names;
728 GQuark
*syscall_names
;
735 create_name_tables(LttvTraceState
*tcs
)
739 GQuark f_name
, e_name
;
743 LttvTraceHookByFacility
*thf
;
749 GString
*fe_name
= g_string_new("");
751 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
753 LttvAttributeValue v
;
755 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
757 g_assert(*(v
.v_pointer
) == NULL
);
758 *(v
.v_pointer
) = name_tables
;
759 #if 0 // Use iteration over the facilities_by_name and then list all event
760 // types of each facility
761 nb
= ltt_trace_eventtype_number(tcs
->parent
.t
);
762 name_tables
->eventtype_names
= g_new(GQuark
, nb
);
763 for(i
= 0 ; i
< nb
; i
++) {
764 et
= ltt_trace_eventtype_get(tcs
->parent
.t
, i
);
765 e_name
= ltt_eventtype_name(et
);
766 f_name
= ltt_facility_name(ltt_eventtype_facility(et
));
767 g_string_printf(fe_name
, "%s.%s", f_name
, e_name
);
768 name_tables
->eventtype_names
[i
] = g_quark_from_string(fe_name
->str
);
771 if(lttv_trace_find_hook(tcs
->parent
.t
,
772 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
773 LTT_FIELD_SYSCALL_ID
, 0, 0,
777 thf
= lttv_trace_hook_get_first(&h
);
779 t
= ltt_field_type(thf
->f1
);
780 nb
= ltt_type_element_number(t
);
782 lttv_trace_hook_destroy(&h
);
784 name_tables
->syscall_names
= g_new(GQuark
, nb
);
786 for(i
= 0 ; i
< nb
; i
++) {
787 name_tables
->syscall_names
[i
] = ltt_enum_string_get(t
, i
);
790 //name_tables->syscall_names = g_new(GQuark, 256);
791 //for(i = 0 ; i < 256 ; i++) {
792 // g_string_printf(fe_name, "syscall %d", i);
793 // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
796 if(lttv_trace_find_hook(tcs
->parent
.t
, LTT_FACILITY_KERNEL
,
797 LTT_EVENT_TRAP_ENTRY
,
798 LTT_FIELD_TRAP_ID
, 0, 0,
802 thf
= lttv_trace_hook_get_first(&h
);
804 t
= ltt_field_type(thf
->f1
);
805 //nb = ltt_type_element_number(t);
807 lttv_trace_hook_destroy(&h
);
810 name_tables->trap_names = g_new(GQuark, nb);
811 for(i = 0 ; i < nb ; i++) {
812 name_tables->trap_names[i] = g_quark_from_string(
813 ltt_enum_string_get(t, i));
817 name_tables
->trap_names
= g_new(GQuark
, 256);
818 for(i
= 0 ; i
< 256 ; i
++) {
819 g_string_printf(fe_name
, "trap %d", i
);
820 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
823 if(lttv_trace_find_hook(tcs
->parent
.t
,
824 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
825 LTT_FIELD_IRQ_ID
, 0, 0,
829 thf
= lttv_trace_hook_get_first(&h
);
831 t
= ltt_field_type(thf
->f1
);
832 //nb = ltt_type_element_number(t);
834 lttv_trace_hook_destroy(&h
);
837 name_tables->irq_names = g_new(GQuark, nb);
838 for(i = 0 ; i < nb ; i++) {
839 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
843 name_tables
->irq_names
= g_new(GQuark
, 256);
844 for(i
= 0 ; i
< 256 ; i
++) {
845 g_string_printf(fe_name
, "irq %d", i
);
846 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
849 g_string_free(fe_name
, TRUE
);
854 get_name_tables(LttvTraceState
*tcs
)
856 LttvNameTables
*name_tables
;
858 LttvAttributeValue v
;
860 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
862 g_assert(*(v
.v_pointer
) != NULL
);
863 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
864 //tcs->eventtype_names = name_tables->eventtype_names;
865 tcs
->syscall_names
= name_tables
->syscall_names
;
866 tcs
->trap_names
= name_tables
->trap_names
;
867 tcs
->irq_names
= name_tables
->irq_names
;
872 free_name_tables(LttvTraceState
*tcs
)
874 LttvNameTables
*name_tables
;
876 LttvAttributeValue v
;
878 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
880 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
881 *(v
.v_pointer
) = NULL
;
883 // g_free(name_tables->eventtype_names);
884 g_free(name_tables
->syscall_names
);
885 g_free(name_tables
->trap_names
);
886 g_free(name_tables
->irq_names
);
890 #ifdef HASH_TABLE_DEBUG
892 static void test_process(gpointer key
, gpointer value
, gpointer user_data
)
894 LttvProcessState
*process
= (LttvProcessState
*)value
;
896 /* Test for process corruption */
897 guint stack_len
= process
->execution_stack
->len
;
900 static void hash_table_check(GHashTable
*table
)
902 g_hash_table_foreach(table
, test_process
, NULL
);
909 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
912 LttvExecutionState
*es
;
914 guint cpu
= ltt_tracefile_num(tfs
->parent
.tf
);
915 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
917 #ifdef HASH_TABLE_DEBUG
918 hash_table_check(ts
->processes
);
920 LttvProcessState
*process
= ts
->running_process
[cpu
];
922 guint depth
= process
->execution_stack
->len
;
924 process
->execution_stack
=
925 g_array_set_size(process
->execution_stack
, depth
+ 1);
928 &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
- 1);
930 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
933 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
934 es
->s
= process
->state
->s
;
939 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
941 guint cpu
= ltt_tracefile_num(tfs
->parent
.tf
);
942 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
943 LttvProcessState
*process
= ts
->running_process
[cpu
];
945 guint depth
= process
->execution_stack
->len
;
947 if(process
->state
->t
!= t
){
948 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
949 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
950 g_info("process state has %s when pop_int is %s\n",
951 g_quark_to_string(process
->state
->t
),
952 g_quark_to_string(t
));
953 g_info("{ %u, %u, %s, %s }\n",
956 g_quark_to_string(process
->name
),
957 g_quark_to_string(process
->state
->s
));
962 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
963 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
967 process
->execution_stack
=
968 g_array_set_size(process
->execution_stack
, depth
- 1);
969 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
971 process
->state
->change
= tfs
->parent
.timestamp
;
976 lttv_state_create_process(LttvTraceState
*tcs
, LttvProcessState
*parent
,
977 guint cpu
, guint pid
, const LttTime
*timestamp
)
979 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
981 LttvExecutionState
*es
;
983 LttvTraceContext
*tc
= (LttvTraceContext
*)tcs
;
989 //process->last_cpu = tfs->cpu_name;
990 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
991 g_info("Process %u, core %p", process
->pid
, process
);
992 g_hash_table_insert(tcs
->processes
, process
, process
);
995 process
->ppid
= parent
->pid
;
996 process
->name
= parent
->name
;
997 process
->creation_time
= *timestamp
;
1000 /* No parent. This process exists but we are missing all information about
1001 its creation. The birth time is set to zero but we remember the time of
1006 process
->name
= LTTV_STATE_UNNAMED
;
1007 process
->creation_time
= ltt_time_zero
;
1010 process
->insertion_time
= *timestamp
;
1011 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
1012 process
->creation_time
.tv_nsec
);
1013 process
->pid_time
= g_quark_from_string(buffer
);
1015 //process->last_cpu = tfs->cpu_name;
1016 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1017 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1018 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1019 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 2);
1020 es
= process
->state
= &g_array_index(process
->execution_stack
,
1021 LttvExecutionState
, 0);
1022 es
->t
= LTTV_STATE_USER_MODE
;
1023 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1024 es
->entry
= *timestamp
;
1025 //g_assert(timestamp->tv_sec != 0);
1026 es
->change
= *timestamp
;
1027 es
->s
= LTTV_STATE_RUN
;
1029 es
= process
->state
= &g_array_index(process
->execution_stack
,
1030 LttvExecutionState
, 1);
1031 es
->t
= LTTV_STATE_SYSCALL
;
1032 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1033 es
->entry
= *timestamp
;
1034 //g_assert(timestamp->tv_sec != 0);
1035 es
->change
= *timestamp
;
1036 es
->s
= LTTV_STATE_WAIT_FORK
;
1041 LttvProcessState
*lttv_state_find_process(LttvTraceState
*ts
, guint cpu
,
1044 LttvProcessState key
;
1045 LttvProcessState
*process
;
1049 process
= g_hash_table_lookup(ts
->processes
, &key
);
1054 lttv_state_find_process_or_create(LttvTraceState
*ts
, guint cpu
, guint pid
,
1057 LttvProcessState
*process
= lttv_state_find_process(ts
, cpu
, pid
);
1059 /* Put ltt_time_zero creation time for unexisting processes */
1060 if(unlikely(process
== NULL
)) process
= lttv_state_create_process(ts
,
1061 NULL
, cpu
, pid
, timestamp
);
1065 /* FIXME : this function should be called when we receive an event telling that
1066 * release_task has been called in the kernel. In happens generally when
1067 * the parent waits for its child terminaison, but may also happen in special
1068 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1069 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1070 * of a killed thread ground, but isn't the leader.
1072 static void exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
1074 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
1075 LttvProcessState key
;
1077 key
.pid
= process
->pid
;
1078 key
.cpu
= process
->cpu
;
1079 g_hash_table_remove(ts
->processes
, &key
);
1080 g_array_free(process
->execution_stack
, TRUE
);
1085 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1087 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
1092 static void lttv_state_free_process_table(GHashTable
*processes
)
1094 g_hash_table_foreach(processes
, free_process_state
, NULL
);
1095 g_hash_table_destroy(processes
);
1099 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
1101 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1102 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1103 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1104 LttField
*f
= thf
->f1
;
1106 LttvExecutionSubmode submode
;
1108 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->syscall_names
[
1109 ltt_event_get_unsigned(e
, f
)];
1110 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
1115 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
1117 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1119 pop_state(s
, LTTV_STATE_SYSCALL
);
1124 static gboolean
trap_entry(void *hook_data
, void *call_data
)
1126 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1127 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1128 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1129 LttField
*f
= thf
->f1
;
1131 LttvExecutionSubmode submode
;
1133 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->trap_names
[
1134 ltt_event_get_unsigned(e
, f
)];
1135 push_state(s
, LTTV_STATE_TRAP
, submode
);
1140 static gboolean
trap_exit(void *hook_data
, void *call_data
)
1142 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1144 pop_state(s
, LTTV_STATE_TRAP
);
1149 static gboolean
irq_entry(void *hook_data
, void *call_data
)
1151 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1152 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1153 guint8 fac_id
= ltt_event_facility_id(e
);
1154 guint8 ev_id
= ltt_event_eventtype_id(e
);
1155 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1156 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1157 g_assert(thf
->f1
!= NULL
);
1158 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1159 LttField
*f
= thf
->f1
;
1161 LttvExecutionSubmode submode
;
1163 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->irq_names
[
1164 ltt_event_get_unsigned(e
, f
)];
1166 /* Do something with the info about being in user or system mode when int? */
1167 push_state(s
, LTTV_STATE_IRQ
, submode
);
1172 static gboolean
irq_exit(void *hook_data
, void *call_data
)
1174 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1176 pop_state(s
, LTTV_STATE_IRQ
);
1181 static gboolean
schedchange(void *hook_data
, void *call_data
)
1183 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1184 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1185 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1186 LttvProcessState
*process
= ts
->running_process
[cpu
];
1188 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1189 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1190 guint pid_in
, pid_out
;
1193 pid_out
= ltt_event_get_unsigned(e
, thf
->f1
);
1194 pid_in
= ltt_event_get_unsigned(e
, thf
->f2
);
1195 state_out
= ltt_event_get_int(e
, thf
->f3
);
1197 if(likely(process
!= NULL
)) {
1199 /* We could not know but it was not the idle process executing.
1200 This should only happen at the beginning, before the first schedule
1201 event, and when the initial information (current process for each CPU)
1202 is missing. It is not obvious how we could, after the fact, compensate
1203 the wrongly attributed statistics. */
1205 //This test only makes sense once the state is known and if there is no
1207 //if(unlikely(process->pid != pid_out)) {
1208 // g_assert(process->pid == 0);
1211 if(unlikely(process
->state
->s
== LTTV_STATE_EXIT
)) {
1212 process
->state
->s
= LTTV_STATE_ZOMBIE
;
1213 process
->state
->change
= s
->parent
.timestamp
;
1215 if(unlikely(state_out
== 0)) process
->state
->s
= LTTV_STATE_WAIT_CPU
;
1216 else process
->state
->s
= LTTV_STATE_WAIT
;
1217 process
->state
->change
= s
->parent
.timestamp
;
1221 exit_process(s
, process
); /* EXIT_DEAD */
1222 /* see sched.h for states */
1224 process
= ts
->running_process
[cpu
] =
1225 lttv_state_find_process_or_create(
1226 (LttvTraceState
*)s
->parent
.t_context
,
1228 &s
->parent
.timestamp
);
1229 process
->state
->s
= LTTV_STATE_RUN
;
1231 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
1232 process
->state
->change
= s
->parent
.timestamp
;
1236 static gboolean
process_fork(void *hook_data
, void *call_data
)
1238 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1239 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1240 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1244 LttvProcessState
*zombie_process
;
1245 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1246 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1247 LttvProcessState
*process
= ts
->running_process
[cpu
];
1248 LttvProcessState
*child_process
;
1252 parent_pid
= ltt_event_get_unsigned(e
, f
);
1256 child_pid
= ltt_event_get_unsigned(e
, f
);
1258 /* Mathieu : it seems like the process might have been scheduled in before the
1259 * fork, and, in a rare case, might be the current process. This might happen
1260 * in a SMP case where we don't have enough precision on the clocks.
1262 * Test reenabled after precision fixes on time. (Mathieu) */
1264 zombie_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1266 if(unlikely(zombie_process
!= NULL
)) {
1267 /* Reutilisation of PID. Only now we are sure that the old PID
1268 * has been released. FIXME : should know when release_task happens instead.
1270 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
1272 for(i
=0; i
< num_cpus
; i
++) {
1273 g_assert(zombie_process
!= ts
->running_process
[i
]);
1276 exit_process(s
, zombie_process
);
1279 g_assert(process
->pid
!= child_pid
);
1280 // FIXME : Add this test in the "known state" section
1281 // g_assert(process->pid == parent_pid);
1282 child_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1283 if(child_process
== NULL
) {
1284 lttv_state_create_process(ts
, process
, cpu
,
1285 child_pid
, &s
->parent
.timestamp
);
1287 /* The process has already been created : due to time imprecision between
1288 * multiple CPUs : it has been scheduled in before creation. Note that we
1289 * shouldn't have this kind of imprecision.
1291 * Simply put a correct parent.
1293 g_assert(0); /* This is a problematic case : the process has been created
1294 before the fork event */
1295 child_process
->ppid
= process
->pid
;
1302 static gboolean
process_exit(void *hook_data
, void *call_data
)
1304 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1305 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1306 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1309 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1310 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1311 LttvProcessState
*process
= ts
->running_process
[cpu
];
1313 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1315 // FIXME : Add this test in the "known state" section
1316 // g_assert(process->pid == pid);
1318 if(likely(process
!= NULL
)) {
1319 process
->state
->s
= LTTV_STATE_EXIT
;
1324 static gboolean
process_free(void *hook_data
, void *call_data
)
1326 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1327 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1328 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1329 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1331 LttvProcessState
*process
;
1333 /* PID of the process to release */
1334 release_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1336 g_assert(release_pid
!= 0);
1338 process
= lttv_state_find_process(ts
, ANY_CPU
, release_pid
);
1340 if(likely(process
!= NULL
)) {
1341 /* release_task is happening at kernel level : we can now safely release
1342 * the data structure of the process */
1343 //This test is fun, though, as it may happen that
1344 //at time t : CPU 0 : process_free
1345 //at time t+150ns : CPU 1 : schedule out
1346 //Clearly due to time imprecision, we disable it. (Mathieu)
1347 //If this weird case happen, we have no choice but to put the
1348 //Currently running process on the cpu to 0.
1349 //I re-enable it following time precision fixes. (Mathieu)
1350 //Well, in the case where an process is freed by a process on another CPU
1351 //and still scheduled, it happens that this is the schedchange that will
1352 //drop the last reference count. Do not free it here!
1353 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
1355 for(i
=0; i
< num_cpus
; i
++) {
1356 //g_assert(process != ts->running_process[i]);
1357 if(process
== ts
->running_process
[i
]) {
1358 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
1362 if(i
== num_cpus
) /* process is not scheduled */
1363 exit_process(s
, process
);
1370 static gboolean
process_exec(void *hook_data
, void *call_data
)
1372 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1373 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1374 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1375 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1377 guint cpu
= ltt_tracefile_num(s
->parent
.tf
);
1378 LttvProcessState
*process
= ts
->running_process
[cpu
];
1380 /* PID of the process to release */
1381 guint64 name_len
= ltt_event_field_element_number(e
, thf
->f1
);
1382 //name = ltt_event_get_string(e, thf->f1);
1383 LttField
*child
= ltt_event_field_element_select(e
, thf
->f1
, 0);
1385 (gchar
*)(ltt_event_data(e
)+ltt_event_field_offset(e
, child
));
1386 gchar
*null_term_name
= g_new(gchar
, name_len
+1);
1387 memcpy(null_term_name
, name_begin
, name_len
);
1388 null_term_name
[name_len
] = '\0';
1390 process
->name
= g_quark_from_string(null_term_name
);
1391 g_free(null_term_name
);
1398 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
1400 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1402 lttv_state_add_event_hooks(tss
);
1407 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
1409 LttvTraceset
*traceset
= self
->parent
.ts
;
1411 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1415 LttvTracefileState
*tfs
;
1419 LttvTraceHookByFacility
*thf
;
1421 LttvTraceHook
*hook
;
1423 LttvAttributeValue val
;
1427 nb_trace
= lttv_traceset_number(traceset
);
1428 for(i
= 0 ; i
< nb_trace
; i
++) {
1429 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1431 /* Find the eventtype id for the following events and register the
1432 associated by id hooks. */
1434 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 11);
1435 hooks
= g_array_set_size(hooks
, 11);
1437 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1438 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
1439 LTT_FIELD_SYSCALL_ID
, 0, 0,
1440 syscall_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 0));
1443 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1444 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_EXIT
,
1446 syscall_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 1));
1449 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1450 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_ENTRY
,
1451 LTT_FIELD_TRAP_ID
, 0, 0,
1452 trap_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 2));
1455 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1456 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_EXIT
,
1458 trap_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 3));
1461 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1462 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
1463 LTT_FIELD_IRQ_ID
, 0, 0,
1464 irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 4));
1467 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1468 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_EXIT
,
1470 irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 5));
1473 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1474 LTT_FACILITY_PROCESS
, LTT_EVENT_SCHEDCHANGE
,
1475 LTT_FIELD_OUT
, LTT_FIELD_IN
, LTT_FIELD_OUT_STATE
,
1476 schedchange
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 6));
1479 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1480 LTT_FACILITY_PROCESS
, LTT_EVENT_FORK
,
1481 LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
, 0,
1482 process_fork
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 7));
1485 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1486 LTT_FACILITY_PROCESS
, LTT_EVENT_EXIT
,
1487 LTT_FIELD_PID
, 0, 0,
1488 process_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 8));
1491 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1492 LTT_FACILITY_PROCESS
, LTT_EVENT_FREE
,
1493 LTT_FIELD_PID
, 0, 0,
1494 process_free
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 9));
1497 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1498 LTT_FACILITY_FS
, LTT_EVENT_EXEC
,
1499 LTT_FIELD_FILENAME
, 0, 0,
1500 process_exec
, NULL
, &g_array_index(hooks
, LttvTraceHook
, 10));
1505 /* Add these hooks to each event_by_id hooks list */
1507 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1509 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1511 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1512 LttvTracefileContext
*, j
));
1514 for(k
= 0 ; k
< hooks
->len
; k
++) {
1515 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
1516 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
1517 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
1519 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
1526 lttv_attribute_find(self
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
1527 *(val
.v_pointer
) = hooks
;
1531 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1533 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1535 lttv_state_remove_event_hooks(tss
);
1540 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
1542 LttvTraceset
*traceset
= self
->parent
.ts
;
1544 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1548 LttvTracefileState
*tfs
;
1552 LttvTraceHook
*hook
;
1554 LttvTraceHookByFacility
*thf
;
1556 LttvAttributeValue val
;
1558 nb_trace
= lttv_traceset_number(traceset
);
1559 for(i
= 0 ; i
< nb_trace
; i
++) {
1560 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
1561 lttv_attribute_find(self
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
1562 hooks
= *(val
.v_pointer
);
1564 /* Remove these hooks from each event_by_id hooks list */
1566 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1568 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1570 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1571 LttvTracefileContext
*, j
));
1573 for(k
= 0 ; k
< hooks
->len
; k
++) {
1574 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
1575 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
1576 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
1578 lttv_hooks_remove_data(
1579 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
1585 for(k
= 0 ; k
< hooks
->len
; k
++)
1586 lttv_trace_hook_destroy(&g_array_index(hooks
, LttvTraceHook
, k
));
1587 g_array_free(hooks
, TRUE
);
1591 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
1593 guint
*event_count
= (guint
*)hook_data
;
1595 /* Only save at LTTV_STATE_SAVE_INTERVAL */
1596 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
1601 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1603 LttvTracefileState
*tfcs
;
1605 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1607 LttEventPosition
*ep
;
1613 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1615 LttvAttributeValue value
;
1617 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1618 LTTV_STATE_SAVED_STATES
);
1619 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1620 value
= lttv_attribute_add(saved_states_tree
,
1621 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1622 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1623 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1624 *(value
.v_time
) = self
->parent
.timestamp
;
1625 lttv_state_save(tcs
, saved_state_tree
);
1626 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
1627 self
->parent
.timestamp
.tv_nsec
);
1629 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1634 static gboolean
state_save_after_trace_hook(void *hook_data
, void *call_data
)
1636 LttvTraceState
*tcs
= (LttvTraceState
*)(call_data
);
1638 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
1644 static gboolean
block_start(void *hook_data
, void *call_data
)
1646 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1648 LttvTracefileState
*tfcs
;
1650 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1652 LttEventPosition
*ep
;
1654 guint i
, nb_block
, nb_event
, nb_tracefile
;
1658 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1660 LttvAttributeValue value
;
1662 ep
= ltt_event_position_new();
1664 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
1666 /* Count the number of events added since the last block end in any
1669 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1671 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
1672 LttvTracefileContext
, i
));
1673 ltt_event_position(tfcs
->parent
.e
, ep
);
1674 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
1675 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
1676 tfcs
->saved_position
= nb_event
;
1680 if(tcs
->nb_event
>= tcs
->save_interval
) {
1681 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1682 LTTV_STATE_SAVED_STATES
);
1683 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1684 value
= lttv_attribute_add(saved_states_tree
,
1685 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1686 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1687 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1688 *(value
.v_time
) = self
->parent
.timestamp
;
1689 lttv_state_save(tcs
, saved_state_tree
);
1691 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
1692 self
->parent
.timestamp
.tv_nsec
);
1694 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1700 static gboolean
block_end(void *hook_data
, void *call_data
)
1702 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
1704 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
1708 LttEventPosition
*ep
;
1710 guint nb_block
, nb_event
;
1712 ep
= ltt_event_position_new();
1713 ltt_event_position(self
->parent
.e
, ep
);
1714 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
1715 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
1716 self
->saved_position
= 0;
1717 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
1724 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
1726 LttvTraceset
*traceset
= self
->parent
.ts
;
1728 guint i
, j
, nb_trace
, nb_tracefile
;
1732 LttvTracefileState
*tfs
;
1734 LttvTraceHook hook_start
, hook_end
;
1736 nb_trace
= lttv_traceset_number(traceset
);
1737 for(i
= 0 ; i
< nb_trace
; i
++) {
1738 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1740 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
1741 NULL
, NULL
, block_start
, &hook_start
);
1742 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
1743 NULL
, NULL
, block_end
, &hook_end
);
1745 nb_tracefile
= ts
->parent
.tracefiles
->len
;
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(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
1752 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
1753 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
1754 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
1760 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
1762 LttvTraceset
*traceset
= self
->parent
.ts
;
1764 guint i
, j
, nb_trace
, nb_tracefile
;
1768 LttvTracefileState
*tfs
;
1771 nb_trace
= lttv_traceset_number(traceset
);
1772 for(i
= 0 ; i
< nb_trace
; i
++) {
1774 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1775 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1777 guint
*event_count
= g_new(guint
, 1);
1780 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1782 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1783 LttvTracefileContext
*, j
));
1784 lttv_hooks_add(tfs
->parent
.event
,
1785 state_save_event_hook
,
1792 lttv_process_traceset_begin(&self
->parent
,
1793 NULL
, NULL
, NULL
, NULL
, NULL
);
1797 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
1799 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1801 lttv_state_save_add_event_hooks(tss
);
1808 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
1810 LttvTraceset
*traceset
= self
->parent
.ts
;
1812 guint i
, j
, nb_trace
, nb_tracefile
;
1816 LttvTracefileState
*tfs
;
1818 LttvTraceHook hook_start
, hook_end
;
1820 nb_trace
= lttv_traceset_number(traceset
);
1821 for(i
= 0 ; i
< nb_trace
; i
++) {
1822 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
1824 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
1825 NULL
, NULL
, block_start
, &hook_start
);
1827 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
1828 NULL
, NULL
, block_end
, &hook_end
);
1830 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1832 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1834 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
1835 LttvTracefileContext
, j
));
1836 lttv_hooks_remove_data(lttv_hooks_by_id_find(
1837 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
1838 lttv_hooks_remove_data(lttv_hooks_by_id_find(
1839 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
1845 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
1847 LttvTraceset
*traceset
= self
->parent
.ts
;
1849 guint i
, j
, nb_trace
, nb_tracefile
;
1853 LttvTracefileState
*tfs
;
1855 LttvHooks
*after_trace
= lttv_hooks_new();
1857 lttv_hooks_add(after_trace
,
1858 state_save_after_trace_hook
,
1863 lttv_process_traceset_end(&self
->parent
,
1864 NULL
, after_trace
, NULL
, NULL
, NULL
);
1866 lttv_hooks_destroy(after_trace
);
1868 nb_trace
= lttv_traceset_number(traceset
);
1869 for(i
= 0 ; i
< nb_trace
; i
++) {
1871 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1872 nb_tracefile
= ts
->parent
.tracefiles
->len
;
1874 guint
*event_count
= NULL
;
1876 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1878 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
1879 LttvTracefileContext
*, j
));
1880 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
1881 state_save_event_hook
);
1883 if(event_count
) g_free(event_count
);
1887 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
1889 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1891 lttv_state_save_remove_event_hooks(tss
);
1896 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
1898 LttvTraceset
*traceset
= self
->parent
.ts
;
1902 int min_pos
, mid_pos
, max_pos
;
1904 guint call_rest
= 0;
1906 LttvTraceState
*tcs
;
1908 LttvAttributeValue value
;
1910 LttvAttributeType type
;
1912 LttvAttributeName name
;
1914 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
;
1916 //g_tree_destroy(self->parent.pqueue);
1917 //self->parent.pqueue = g_tree_new(compare_tracefile);
1919 g_info("Entering seek_time_closest for time %lu.%lu", t
.tv_sec
, t
.tv_nsec
);
1921 nb_trace
= lttv_traceset_number(traceset
);
1922 for(i
= 0 ; i
< nb_trace
; i
++) {
1923 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
1925 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
1926 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
1927 LTTV_STATE_SAVED_STATES
);
1930 if(saved_states_tree
) {
1931 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
1932 mid_pos
= max_pos
/ 2;
1933 while(min_pos
< max_pos
) {
1934 type
= lttv_attribute_get(saved_states_tree
, mid_pos
, &name
, &value
);
1935 g_assert(type
== LTTV_GOBJECT
);
1936 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1937 type
= lttv_attribute_get_by_name(saved_state_tree
, LTTV_STATE_TIME
,
1939 g_assert(type
== LTTV_TIME
);
1940 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
1942 closest_tree
= saved_state_tree
;
1944 else max_pos
= mid_pos
- 1;
1946 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
1950 /* restore the closest earlier saved state */
1952 lttv_state_restore(tcs
, closest_tree
);
1956 /* There is no saved state, yet we want to have it. Restart at T0 */
1958 restore_init_state(tcs
);
1959 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
1962 /* We want to seek quickly without restoring/updating the state */
1964 restore_init_state(tcs
);
1965 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
1968 if(!call_rest
) g_info("NOT Calling restore");
1973 traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
1979 traceset_state_finalize (LttvTracesetState
*self
)
1981 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
1982 finalize(G_OBJECT(self
));
1987 traceset_state_class_init (LttvTracesetContextClass
*klass
)
1989 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
1991 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
1992 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
1993 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
1994 klass
->new_traceset_context
= new_traceset_context
;
1995 klass
->new_trace_context
= new_trace_context
;
1996 klass
->new_tracefile_context
= new_tracefile_context
;
2001 lttv_traceset_state_get_type(void)
2003 static GType type
= 0;
2005 static const GTypeInfo info
= {
2006 sizeof (LttvTracesetStateClass
),
2007 NULL
, /* base_init */
2008 NULL
, /* base_finalize */
2009 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
2010 NULL
, /* class_finalize */
2011 NULL
, /* class_data */
2012 sizeof (LttvTracesetState
),
2013 0, /* n_preallocs */
2014 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
2015 NULL
/* value handling */
2018 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
2026 trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
2032 trace_state_finalize (LttvTraceState
*self
)
2034 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
2035 finalize(G_OBJECT(self
));
2040 trace_state_class_init (LttvTraceStateClass
*klass
)
2042 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2044 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
2045 klass
->state_save
= state_save
;
2046 klass
->state_restore
= state_restore
;
2047 klass
->state_saved_free
= state_saved_free
;
2052 lttv_trace_state_get_type(void)
2054 static GType type
= 0;
2056 static const GTypeInfo info
= {
2057 sizeof (LttvTraceStateClass
),
2058 NULL
, /* base_init */
2059 NULL
, /* base_finalize */
2060 (GClassInitFunc
) trace_state_class_init
, /* class_init */
2061 NULL
, /* class_finalize */
2062 NULL
, /* class_data */
2063 sizeof (LttvTraceState
),
2064 0, /* n_preallocs */
2065 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
2066 NULL
/* value handling */
2069 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
2070 "LttvTraceStateType", &info
, 0);
2077 tracefile_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
2083 tracefile_state_finalize (LttvTracefileState
*self
)
2085 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
2086 finalize(G_OBJECT(self
));
2091 tracefile_state_class_init (LttvTracefileStateClass
*klass
)
2093 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2095 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
2100 lttv_tracefile_state_get_type(void)
2102 static GType type
= 0;
2104 static const GTypeInfo info
= {
2105 sizeof (LttvTracefileStateClass
),
2106 NULL
, /* base_init */
2107 NULL
, /* base_finalize */
2108 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
2109 NULL
, /* class_finalize */
2110 NULL
, /* class_data */
2111 sizeof (LttvTracefileState
),
2112 0, /* n_preallocs */
2113 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
2114 NULL
/* value handling */
2117 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
2118 "LttvTracefileStateType", &info
, 0);
2124 static void module_init()
2126 LTTV_STATE_UNNAMED
= g_quark_from_string("unnamed");
2127 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("unknown execution mode");
2128 LTTV_STATE_USER_MODE
= g_quark_from_string("user mode");
2129 LTTV_STATE_WAIT_FORK
= g_quark_from_string("wait fork");
2130 LTTV_STATE_SYSCALL
= g_quark_from_string("system call");
2131 LTTV_STATE_TRAP
= g_quark_from_string("trap");
2132 LTTV_STATE_IRQ
= g_quark_from_string("irq");
2133 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("unknown submode");
2134 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("(no submode)");
2135 LTTV_STATE_WAIT_CPU
= g_quark_from_string("wait for cpu");
2136 LTTV_STATE_EXIT
= g_quark_from_string("exiting");
2137 LTTV_STATE_ZOMBIE
= g_quark_from_string("zombie");
2138 LTTV_STATE_WAIT
= g_quark_from_string("wait for I/O");
2139 LTTV_STATE_RUN
= g_quark_from_string("running");
2140 LTTV_STATE_DEAD
= g_quark_from_string("dead");
2141 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
2142 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
2143 LTTV_STATE_PROCESS
= g_quark_from_string("process");
2144 LTTV_STATE_RUNNING_PROCESS
= g_quark_from_string("running_process");
2145 LTTV_STATE_EVENT
= g_quark_from_string("event");
2146 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
2147 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
2148 LTTV_STATE_TIME
= g_quark_from_string("time");
2149 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
2150 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
2151 LTTV_STATE_TRACE_STATE_USE_COUNT
=
2152 g_quark_from_string("trace_state_use_count");
2155 LTT_FACILITY_KERNEL
= g_quark_from_string("kernel");
2156 LTT_FACILITY_KERNEL_ARCH
= g_quark_from_string("kernel_arch");
2157 LTT_FACILITY_PROCESS
= g_quark_from_string("process");
2158 LTT_FACILITY_FS
= g_quark_from_string("fs");
2161 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
2162 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
2163 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
2164 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
2165 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
2166 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
2167 LTT_EVENT_SCHEDCHANGE
= g_quark_from_string("schedchange");
2168 LTT_EVENT_FORK
= g_quark_from_string("fork");
2169 LTT_EVENT_EXIT
= g_quark_from_string("exit");
2170 LTT_EVENT_FREE
= g_quark_from_string("free");
2171 LTT_EVENT_EXEC
= g_quark_from_string("exec");
2174 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
2175 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
2176 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
2177 LTT_FIELD_OUT
= g_quark_from_string("out");
2178 LTT_FIELD_IN
= g_quark_from_string("in");
2179 LTT_FIELD_OUT_STATE
= g_quark_from_string("out_state");
2180 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
2181 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
2182 LTT_FIELD_PID
= g_quark_from_string("pid");
2183 LTT_FIELD_FILENAME
= g_quark_from_string("filename");
2187 static void module_destroy()
2192 LTTV_MODULE("state", "State computation", \
2193 "Update the system state, possibly saving it at intervals", \
2194 module_init
, module_destroy
)